Редакция 19 | К новейшей редакции | Весь файл | Учитывать пробелы | Содержимое файла | Авторство | Последнее изменение | Открыть журнал | RSS
| Редакция 19 | Редакция 109 | ||
|---|---|---|---|
| Строка 1... | Строка 1... | ||
| 1 | /*!
|
1 | /*!
|
| 2 | * jQuery JavaScript Library v1.3.2
|
2 | * jQuery JavaScript Library v1.3.3pre
|
| 3 | * http://jquery.com/
|
3 | * http://jquery.com/
|
| 4 | *
|
4 | *
|
| 5 | * Copyright (c) 2009 John Resig
|
5 | * Copyright (c) 2009 John Resig
|
| 6 | * Dual licensed under the MIT and GPL licenses.
|
6 | * Dual licensed under the MIT and GPL licenses.
|
| 7 | * http://docs.jquery.com/License
|
7 | * http://docs.jquery.com/License
|
| 8 | *
|
8 | *
|
| 9 | * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)
|
9 | * Date: 2009-03-28 00:20:57 +0600 (Сбт, 28 Мар 2009)
|
| 10 | * Revision: 6246
|
10 | * Revision: 6301
|
| 11 | */
|
11 | */
|
| 12 | (function(){ |
12 | (function(){ |
| 13 | 13 | ||
| 14 | var
|
14 | var
|
| 15 | // Will speed up references to window, and allows munging its name.
|
15 | // Will speed up references to window, and allows munging its name.
|
| Строка 21... | Строка 21... | ||
| 21 | // Map over the $ in case of overwrite
|
21 | // Map over the $ in case of overwrite
|
| 22 | _$ = window.$, |
22 | _$ = window.$, |
| 23 | 23 | ||
| 24 | jQuery = window.jQuery = window.$ = function( selector, context ) { |
24 | jQuery = window.jQuery = window.$ = function( selector, context ) { |
| 25 | // The jQuery object is actually just the init constructor 'enhanced'
|
25 | // The jQuery object is actually just the init constructor 'enhanced'
|
| - | 26 | return selector === undefined ? |
|
| - | 27 | rootjQuery :
|
|
| 26 | return new jQuery.fn.init( selector, context ); |
28 | new jQuery.fn.init( selector, context ); |
| 27 | }, |
29 | }, |
| 28 | 30 | ||
| 29 | // A simple way to check for HTML strings or ID strings
|
31 | // A simple way to check for HTML strings or ID strings
|
| 30 | // (both of which we optimize for)
|
32 | // (both of which we optimize for)
|
| 31 | quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/, |
33 | quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/, |
| 32 | // Is it a simple selector
|
34 | // Is it a simple selector
|
| 33 | isSimple = /^.[^:#\[\.,]*$/; |
35 | isSimple = /^.[^:#\[\.,]*$/; |
| 34 | 36 | ||
| 35 | jQuery.fn = jQuery.prototype = { |
37 | jQuery.fn = jQuery.prototype = { |
| 36 | init: function( selector, context ) { |
38 | init: function( selector, context ) { |
| 37 | // Make sure that a selection was provided
|
39 | // Handle $("") or $(null)
|
| 38 | selector = selector || document; |
40 | if ( !selector ) { |
| - | 41 | this.length = 0; |
|
| - | 42 | return this; |
|
| - | 43 | }
|
|
| 39 | 44 | ||
| 40 | // Handle $(DOMElement)
|
45 | // Handle $(DOMElement)
|
| 41 | if ( selector.nodeType ) { |
46 | if ( selector.nodeType ) { |
| 42 | this[0] = selector; |
47 | this[0] = selector; |
| 43 | this.length = 1; |
48 | this.length = 1; |
| 44 | this.context = selector; |
49 | this.context = selector; |
| 45 | return this; |
50 | return this; |
| 46 | }
|
51 | }
|
| - | 52 | ||
| 47 | // Handle HTML strings
|
53 | // Handle HTML strings
|
| 48 | if ( typeof selector === "string" ) { |
54 | if ( typeof selector === "string" ) { |
| 49 | // Are we dealing with HTML string or an ID?
|
55 | // Are we dealing with HTML string or an ID?
|
| 50 | var match = quickExpr.exec( selector ); |
56 | var match = quickExpr.exec( selector ); |
| 51 | 57 | ||
| 52 | // Verify a match, and that no context was specified for #id
|
58 | // Verify a match, and that no context was specified for #id
|
| 53 | if ( match && (match[1] || !context) ) { |
59 | if ( match && (match[1] || !context) ) { |
| 54 | 60 | ||
| 55 | // HANDLE: $(html) -> $(array)
|
61 | // HANDLE: $(html) -> $(array)
|
| 56 | if ( match[1] ) |
62 | if ( match[1] ) { |
| 57 | selector = jQuery.clean( [ match[1] ], context ); |
63 | selector = jQuery.clean( [ match[1] ], context ); |
| 58 | 64 | ||
| 59 | // HANDLE: $("#id")
|
65 | // HANDLE: $("#id")
|
| 60 | else { |
66 | } else { |
| 61 | var elem = document.getElementById( match[3] ); |
67 | var elem = document.getElementById( match[3] ); |
| 62 | 68 | ||
| 63 | // Handle the case where IE and Opera return items
|
69 | // Handle the case where IE and Opera return items
|
| 64 | // by name instead of ID
|
70 | // by name instead of ID
|
| 65 | if ( elem && elem.id != match[3] ) |
71 | if ( elem && elem.id != match[3] ) { |
| 66 | return jQuery().find( selector ); |
72 | return rootjQuery.find( selector ); |
| - | 73 | }
|
|
| 67 | 74 | ||
| 68 | // Otherwise, we inject the element directly into the jQuery object
|
75 | // Otherwise, we inject the element directly into the jQuery object
|
| 69 | var ret = jQuery( elem || [] ); |
76 | var ret = jQuery( elem || null ); |
| 70 | ret.context = document; |
77 | ret.context = document; |
| 71 | ret.selector = selector; |
78 | ret.selector = selector; |
| 72 | return ret; |
79 | return ret; |
| 73 | }
|
80 | }
|
| 74 | 81 | ||
| - | 82 | // HANDLE: $(expr, $(...))
|
|
| - | 83 | } else if ( !context || context.jquery ) { |
|
| - | 84 | return (context || rootjQuery).find( selector ); |
|
| - | 85 | ||
| 75 | // HANDLE: $(expr, [context])
|
86 | // HANDLE: $(expr, context)
|
| 76 | // (which is just equivalent to: $(content).find(expr)
|
87 | // (which is just equivalent to: $(context).find(expr)
|
| 77 | } else |
88 | } else { |
| 78 | return jQuery( context ).find( selector ); |
89 | return jQuery( context ).find( selector ); |
| - | 90 | }
|
|
| 79 | 91 | ||
| 80 | // HANDLE: $(function)
|
92 | // HANDLE: $(function)
|
| 81 | // Shortcut for document ready
|
93 | // Shortcut for document ready
|
| 82 | } else if ( jQuery.isFunction( selector ) ) |
94 | } else if ( jQuery.isFunction( selector ) ) { |
| 83 | return jQuery( document ).ready( selector ); |
95 | return rootjQuery.ready( selector ); |
| - | 96 | }
|
|
| 84 | 97 | ||
| 85 | // Make sure that old selector state is passed along
|
98 | // Make sure that old selector state is passed along
|
| 86 | if ( selector.selector && selector.context ) { |
99 | if ( selector.selector && selector.context ) { |
| 87 | this.selector = selector.selector; |
100 | this.selector = selector.selector; |
| 88 | this.context = selector.context; |
101 | this.context = selector.context; |
| Строка 95... | Строка 108... | ||
| 95 | 108 | ||
| 96 | // Start with an empty selector
|
109 | // Start with an empty selector
|
| 97 | selector: "", |
110 | selector: "", |
| 98 | 111 | ||
| 99 | // The current version of jQuery being used
|
112 | // The current version of jQuery being used
|
| 100 | jquery: "1.3.2", |
113 | jquery: "1.3.3pre", |
| 101 | 114 | ||
| 102 | // The number of elements contained in the matched element set
|
115 | // The number of elements contained in the matched element set
|
| 103 | size: function() { |
116 | size: function() { |
| 104 | return this.length; |
117 | return this.length; |
| 105 | }, |
118 | }, |
| Строка 118... | Строка 131... | ||
| 118 | 131 | ||
| 119 | // Take an array of elements and push it onto the stack
|
132 | // Take an array of elements and push it onto the stack
|
| 120 | // (returning the new matched element set)
|
133 | // (returning the new matched element set)
|
| 121 | pushStack: function( elems, name, selector ) { |
134 | pushStack: function( elems, name, selector ) { |
| 122 | // Build a new jQuery matched element set
|
135 | // Build a new jQuery matched element set
|
| 123 | var ret = jQuery( elems ); |
136 | var ret = jQuery( elems || null ); |
| 124 | 137 | ||
| 125 | // Add the old object onto the stack (as a reference)
|
138 | // Add the old object onto the stack (as a reference)
|
| 126 | ret.prevObject = this; |
139 | ret.prevObject = this; |
| 127 | 140 | ||
| 128 | ret.context = this.context; |
141 | ret.context = this.context; |
| Строка 163... | Строка 176... | ||
| 163 | // If it receives a jQuery object, the first element is used
|
176 | // If it receives a jQuery object, the first element is used
|
| 164 | elem && elem.jquery ? elem[0] : elem |
177 | elem && elem.jquery ? elem[0] : elem |
| 165 | , this ); |
178 | , this ); |
| 166 | }, |
179 | }, |
| 167 | 180 | ||
| 168 | attr: function( name, value, type ) { |
181 | is: function( selector ) { |
| 169 | var options = name; |
182 | return !!selector && jQuery.multiFilter( selector, this ).length > 0; |
| - | 183 | }, |
|
| 170 | 184 | ||
| - | 185 | // For internal use only.
|
|
| 171 | // Look for the case where we're accessing a style value
|
186 | // Behaves like an Array's method, not like a jQuery method.
|
| 172 | if ( typeof name === "string" ) |
187 | push: [].push, |
| 173 | if ( value === undefined ) |
188 | sort: [].sort, |
| 174 | return this[0] && jQuery[ type || "attr" ]( this[0], name ); |
189 | splice: [].splice |
| - | 190 | }; |
|
| 175 | 191 | ||
| 176 | else { |
- | |
| 177 | options = {}; |
192 | // Give the init function the jQuery prototype for later instantiation
|
| 178 | options[ name ] = value; |
193 | jQuery.fn.init.prototype = jQuery.fn; |
| 179 | }
|
- | |
| 180 | 194 | ||
| 181 | // Check to see if we're setting style values
|
- | |
| 182 | return this.each(function(i){ |
195 | function evalScript( i, elem ) { |
| 183 | // Set all the styles
|
- | |
| 184 | for ( name in options ) |
196 | if ( elem.src ) |
| 185 | jQuery.attr( |
197 | jQuery.ajax({ |
| 186 | type ?
|
198 | url: elem.src, |
| 187 | this.style : |
199 | async: false, |
| 188 | this, |
200 | dataType: "script" |
| 189 | name, jQuery.prop( this, options[ name ], type, i, name ) |
- | |
| 190 | ); |
- | |
| 191 | }); |
201 | }); |
| 192 | }, |
- | |
| 193 | 202 | ||
| 194 | css: function( key, value ) { |
- | |
| 195 | // ignore negative width and height values
|
- | |
| 196 | if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 ) |
- | |
| 197 | value = undefined; |
203 | else
|
| 198 | return this.attr( key, value, "curCSS" ); |
204 | jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); |
| 199 | }, |
- | |
| 200 | 205 | ||
| 201 | text: function( text ) { |
206 | if ( elem.parentNode ) |
| 202 | if ( typeof text !== "object" && text != null ) |
207 | elem.parentNode.removeChild( elem ); |
| 203 | return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) ); |
- | |
| - | 208 | }
|
|
| 204 | 209 | ||
| - | 210 | function now(){ |
|
| 205 | var ret = ""; |
211 | return +new Date; |
| - | 212 | }
|
|
| 206 | 213 | ||
| 207 | jQuery.each( text || this, function(){ |
214 | jQuery.extend = jQuery.fn.extend = function() { |
| 208 | jQuery.each( this.childNodes, function(){ |
- | |
| 209 | if ( this.nodeType != 8 ) |
215 | // copy reference to target object
|
| 210 | ret += this.nodeType != 1 ? |
216 | var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options; |
| 211 | this.nodeValue : |
- | |
| 212 | jQuery.fn.text( [ this ] ); |
- | |
| 213 | }); |
- | |
| 214 | }); |
- | |
| 215 | 217 | ||
| - | 218 | // Handle a deep copy situation
|
|
| - | 219 | if ( typeof target === "boolean" ) { |
|
| 216 | return ret; |
220 | deep = target; |
| - | 221 | target = arguments[1] || {}; |
|
| - | 222 | // skip the boolean and the target
|
|
| - | 223 | i = 2; |
|
| 217 | }, |
224 | }
|
| 218 | 225 | ||
| 219 | wrapAll: function( html ) { |
- | |
| 220 | if ( this[0] ) { |
- | |
| 221 | // The elements to wrap the target around
|
226 | // Handle case when target is a string or something (possible in deep copy)
|
| 222 | var wrap = jQuery( html, this[0].ownerDocument ).clone(); |
227 | if ( typeof target !== "object" && !jQuery.isFunction(target) ) |
| - | 228 | target = {}; |
|
| 223 | 229 | ||
| - | 230 | // extend jQuery itself if only one argument is passed
|
|
| 224 | if ( this[0].parentNode ) |
231 | if ( length == i ) { |
| 225 | wrap.insertBefore( this[0] ); |
232 | target = this; |
| - | 233 | --i; |
|
| - | 234 | }
|
|
| 226 | 235 | ||
| 227 | wrap.map(function(){ |
236 | for ( ; i < length; i++ ) |
| - | 237 | // Only deal with non-null/undefined values
|
|
| - | 238 | if ( (options = arguments[ i ]) != null ) |
|
| - | 239 | // Extend the base object
|
|
| 228 | var elem = this; |
240 | for ( var name in options ) { |
| - | 241 | var src = target[ name ], copy = options[ name ]; |
|
| 229 | 242 | ||
| - | 243 | // Prevent never-ending loop
|
|
| 230 | while ( elem.firstChild ) |
244 | if ( target === copy ) |
| - | 245 | continue; |
|
| - | 246 | ||
| - | 247 | // Recurse if we're merging object values
|
|
| - | 248 | if ( deep && copy && typeof copy === "object" && !copy.nodeType ) |
|
| - | 249 | target[ name ] = jQuery.extend( deep, |
|
| - | 250 | // Never move original objects, clone them
|
|
| - | 251 | src || ( copy.length != null ? [ ] : { } ) |
|
| - | 252 | , copy ); |
|
| - | 253 | ||
| - | 254 | // Don't bring in undefined values
|
|
| - | 255 | else if ( copy !== undefined ) |
|
| 231 | elem = elem.firstChild; |
256 | target[ name ] = copy; |
| 232 | 257 | ||
| 233 | return elem; |
- | |
| 234 | }).append(this); |
- | |
| 235 | }
|
258 | }
|
| 236 | 259 | ||
| - | 260 | // Return the modified object
|
|
| 237 | return this; |
261 | return target; |
| 238 | }, |
262 | }; |
| 239 | 263 | ||
| 240 | wrapInner: function( html ) { |
- | |
| 241 | return this.each(function(){ |
- | |
| 242 | jQuery( this ).contents().wrapAll( html ); |
264 | var toString = Object.prototype.toString; |
| 243 | }); |
- | |
| 244 | }, |
- | |
| 245 | 265 | ||
| 246 | wrap: function( html ) { |
266 | jQuery.extend({ |
| 247 | return this.each(function(){ |
267 | noConflict: function( deep ) { |
| 248 | jQuery( this ).wrapAll( html ); |
268 | window.$ = _$; |
| 249 | }); |
- | |
| 250 | }, |
- | |
| 251 | 269 | ||
| 252 | append: function() { |
- | |
| 253 | return this.domManip(arguments, true, function(elem){ |
- | |
| 254 | if (this.nodeType == 1) |
270 | if ( deep ) |
| 255 | this.appendChild( elem ); |
271 | window.jQuery = _jQuery; |
| 256 | }); |
- | |
| 257 | }, |
- | |
| 258 | 272 | ||
| 259 | prepend: function() { |
273 | return jQuery; |
| 260 | return this.domManip(arguments, true, function(elem){ |
- | |
| 261 | if (this.nodeType == 1) |
- | |
| 262 | this.insertBefore( elem, this.firstChild ); |
- | |
| 263 | }); |
- | |
| 264 | }, |
274 | }, |
| 265 | 275 | ||
| 266 | before: function() { |
276 | // See test/unit/core.js for details concerning isFunction.
|
| 267 | return this.domManip(arguments, false, function(elem){ |
277 | // Since version 1.3, DOM methods and functions like alert
|
| 268 | this.parentNode.insertBefore( elem, this ); |
278 | // aren't supported. They return false on IE (#2968).
|
| 269 | }); |
279 | isFunction: function( obj ) { |
| - | 280 | return toString.call(obj) === "[object Function]"; |
|
| 270 | }, |
281 | }, |
| 271 | 282 | ||
| 272 | after: function() { |
283 | isArray: function( obj ) { |
| 273 | return this.domManip(arguments, false, function(elem){ |
284 | return toString.call(obj) === "[object Array]"; |
| 274 | this.parentNode.insertBefore( elem, this.nextSibling ); |
- | |
| 275 | }); |
- | |
| 276 | }, |
285 | }, |
| 277 | 286 | ||
| - | 287 | // check if an element is in a (or is an) XML document
|
|
| 278 | end: function() { |
288 | isXMLDoc: function( elem ) { |
| 279 | return this.prevObject || jQuery( [] ); |
289 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
| - | 290 | !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML"; |
|
| 280 | }, |
291 | }, |
| 281 | 292 | ||
| 282 | // For internal use only.
|
293 | // Evalulates a script in a global context
|
| 283 | // Behaves like an Array's method, not like a jQuery method.
|
294 | globalEval: function( data ) { |
| 284 | push: [].push, |
295 | if ( data && /\S/.test(data) ) { |
| 285 | sort: [].sort, |
296 | // Inspired by code by Andrea Giammarchi
|
| - | 297 | // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
|
|
| - | 298 | var head = document.getElementsByTagName("head")[0] || document.documentElement, |
|
| 286 | splice: [].splice, |
299 | script = document.createElement("script"); |
| 287 | 300 | ||
| 288 | find: function( selector ) { |
301 | script.type = "text/javascript"; |
| 289 | if ( this.length === 1 ) { |
302 | if ( jQuery.support.scriptEval ) |
| 290 | var ret = this.pushStack( [], "find", selector ); |
303 | script.appendChild( document.createTextNode( data ) ); |
| 291 | ret.length = 0; |
304 | else
|
| 292 | jQuery.find( selector, this[0], ret ); |
- | |
| 293 | return ret; |
305 | script.text = data; |
| 294 | } else { |
306 | |
| 295 | return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){ |
307 | // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
| - | 308 | // This arises when a base node is used (#2709).
|
|
| 296 | return jQuery.find( selector, elem ); |
309 | head.insertBefore( script, head.firstChild ); |
| 297 | })), "find", selector ); |
310 | head.removeChild( script ); |
| 298 | }
|
311 | }
|
| 299 | }, |
312 | }, |
| 300 | 313 | ||
| 301 | clone: function( events ) { |
314 | nodeName: function( elem, name ) { |
| 302 | // Do the clone
|
- | |
| 303 | var ret = this.map(function(){ |
- | |
| 304 | if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) { |
- | |
| 305 | // IE copies events bound via attachEvent when
|
- | |
| 306 | // using cloneNode. Calling detachEvent on the
|
- | |
| 307 | // clone will also remove the events from the orignal
|
315 | return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase(); |
| 308 | // In order to get around this, we use innerHTML.
|
- | |
| 309 | // Unfortunately, this means some modifications to
|
- | |
| - | 316 | }, |
|
| - | 317 | ||
| 310 | // attributes in IE that are actually only stored
|
318 | // args is for internal usage only
|
| 311 | // as properties will not be copied (such as the
|
319 | each: function( object, callback, args ) { |
| 312 | // the name attribute on an input).
|
- | |
| 313 | var html = this.outerHTML; |
320 | var name, i = 0, length = object.length; |
| 314 | if ( !html ) { |
- | |
| 315 | var div = this.ownerDocument.createElement("div"); |
- | |
| 316 | div.appendChild( this.cloneNode(true) ); |
- | |
| 317 | html = div.innerHTML; |
- | |
| 318 | }
|
- | |
| 319 | 321 | ||
| - | 322 | if ( args ) { |
|
| - | 323 | if ( length === undefined ) { |
|
| - | 324 | for ( name in object ) |
|
| 320 | return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0]; |
325 | if ( callback.apply( object[ name ], args ) === false ) |
| - | 326 | break; |
|
| 321 | } else |
327 | } else |
| 322 | return this.cloneNode(true); |
328 | for ( ; i < length; ) |
| - | 329 | if ( callback.apply( object[ i++ ], args ) === false ) |
|
| 323 | }); |
330 | break; |
| 324 | 331 | ||
| 325 | // Copy the events from the original to the clone
|
332 | // A special, fast, case for the most common use of each
|
| - | 333 | } else { |
|
| 326 | if ( events === true ) { |
334 | if ( length === undefined ) { |
| - | 335 | for ( name in object ) |
|
| - | 336 | if ( callback.call( object[ name ], name, object[ name ] ) === false ) |
|
| - | 337 | break; |
|
| - | 338 | } else |
|
| 327 | var orig = this.find("*").andSelf(), i = 0; |
339 | for ( var value = object[0]; |
| - | 340 | i < length && callback.call( value, i, value ) !== false; value = object[++i] ){} |
|
| - | 341 | }
|
|
| 328 | 342 | ||
| 329 | ret.find("*").andSelf().each(function(){ |
- | |
| 330 | if ( this.nodeName !== orig[i].nodeName ) |
- | |
| 331 | return; |
343 | return object; |
| - | 344 | }, |
|
| 332 | 345 | ||
| - | 346 | trim: function( text ) { |
|
| 333 | var events = jQuery.data( orig[i], "events" ); |
347 | return (text || "").replace( /^\s+|\s+$/g, "" ); |
| - | 348 | }, |
|
| 334 | 349 | ||
| 335 | for ( var type in events ) { |
350 | makeArray: function( array ) { |
| 336 | for ( var handler in events[ type ] ) { |
- | |
| 337 | jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data ); |
- | |
| 338 | }
|
351 | var ret = []; |
| 339 | }
|
- | |
| 340 | 352 | ||
| - | 353 | if( array != null ){ |
|
| - | 354 | var i = array.length; |
|
| - | 355 | // The window, strings (and functions) also have 'length'
|
|
| - | 356 | if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval ) |
|
| 341 | i++;
|
357 | ret[0] = array; |
| 342 | }); |
358 | else
|
| - | 359 | while( i ) |
|
| - | 360 | ret[--i] = array[i]; |
|
| 343 | }
|
361 | }
|
| 344 | 362 | ||
| 345 | // Return the cloned set
|
- | |
| 346 | return ret; |
363 | return ret; |
| 347 | }, |
364 | }, |
| 348 | 365 | ||
| 349 | filter: function( selector ) { |
366 | inArray: function( elem, array ) { |
| 350 | return this.pushStack( |
- | |
| 351 | jQuery.isFunction( selector ) && |
367 | for ( var i = 0, length = array.length; i < length; i++ ) |
| 352 | jQuery.grep(this, function(elem, i){ |
368 | // Use === because on IE, window == document
|
| 353 | return selector.call( elem, i ); |
369 | if ( array[ i ] === elem ) |
| 354 | }) || |
370 | return i; |
| 355 | 371 | ||
| 356 | jQuery.multiFilter( selector, jQuery.grep(this, function(elem){ |
- | |
| 357 | return elem.nodeType === 1; |
372 | return -1; |
| 358 | }) ), "filter", selector ); |
- | |
| 359 | }, |
373 | }, |
| 360 | 374 | ||
| 361 | closest: function( selector ) { |
375 | merge: function( first, second ) { |
| 362 | var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null, |
376 | // We have to loop this way because IE & Opera overwrite the length
|
| 363 | closer = 0; |
- | |
| 364 | - | ||
| 365 | return this.map(function(){ |
377 | // expando of getElementsByTagName
|
| 366 | var cur = this; |
378 | var i = 0, elem, pos = first.length; |
| 367 | while ( cur && cur.ownerDocument ) { |
379 | // Also, we need to make sure that the correct elements are being returned
|
| 368 | if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) { |
380 | // (IE returns comment nodes in a '*' query)
|
| 369 | jQuery.data(cur, "closest", closer); |
381 | if ( !jQuery.support.getAll ) { |
| 370 | return cur; |
382 | while ( (elem = second[ i++ ]) != null ) |
| 371 | }
|
- | |
| 372 | cur = cur.parentNode; |
383 | if ( elem.nodeType != 8 ) |
| 373 | closer++;
|
384 | first[ pos++ ] = elem; |
| 374 | }
|
- | |
| 375 | }); |
- | |
| 376 | }, |
- | |
| 377 | 385 | ||
| 378 | not: function( selector ) { |
- | |
| 379 | if ( typeof selector === "string" ) |
- | |
| 380 | // test special case where just one selector is passed in
|
- | |
| 381 | if ( isSimple.test( selector ) ) |
- | |
| 382 | return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector ); |
- | |
| 383 | else
|
386 | } else |
| 384 | selector = jQuery.multiFilter( selector, this ); |
387 | while ( (elem = second[ i++ ]) != null ) |
| - | 388 | first[ pos++ ] = elem; |
|
| 385 | 389 | ||
| 386 | var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType; |
- | |
| 387 | return this.filter(function() { |
390 | return first; |
| 388 | return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector; |
- | |
| 389 | }); |
- | |
| 390 | }, |
391 | }, |
| 391 | 392 | ||
| 392 | add: function( selector ) { |
393 | unique: function( array ) { |
| 393 | return this.pushStack( jQuery.unique( jQuery.merge( |
- | |
| 394 | this.get(), |
- | |
| 395 | typeof selector === "string" ? |
- | |
| 396 | jQuery( selector ) : |
394 | var ret = [], done = {}; |
| 397 | jQuery.makeArray( selector ) |
- | |
| 398 | ))); |
- | |
| 399 | }, |
- | |
| 400 | 395 | ||
| 401 | is: function( selector ) { |
- | |
| 402 | return !!selector && jQuery.multiFilter( selector, this ).length > 0; |
- | |
| 403 | }, |
396 | try { |
| 404 | 397 | ||
| 405 | hasClass: function( selector ) { |
398 | for ( var i = 0, length = array.length; i < length; i++ ) { |
| 406 | return !!selector && this.is( "." + selector ); |
399 | var id = jQuery.data( array[ i ] ); |
| 407 | }, |
- | |
| 408 | 400 | ||
| 409 | val: function( value ) { |
401 | if ( !done[ id ] ) { |
| 410 | if ( value === undefined ) { |
402 | done[ id ] = true; |
| 411 | var elem = this[0]; |
403 | ret.push( array[ i ] ); |
| - | 404 | }
|
|
| - | 405 | }
|
|
| 412 | 406 | ||
| 413 | if ( elem ) { |
407 | } catch( e ) { |
| 414 | if( jQuery.nodeName( elem, 'option' ) ) |
408 | ret = array; |
| 415 | return (elem.attributes.value || {}).specified ? elem.value : elem.text; |
- | |
| - | 409 | }
|
|
| 416 | 410 | ||
| 417 | // We need to handle select boxes special
|
- | |
| 418 | if ( jQuery.nodeName( elem, "select" ) ) { |
- | |
| 419 | var index = elem.selectedIndex, |
- | |
| 420 | values = [], |
411 | return ret; |
| 421 | options = elem.options, |
412 | }, |
| 422 | one = elem.type == "select-one"; |
- | |
| 423 | 413 | ||
| 424 | // Nothing was selected
|
414 | grep: function( elems, callback, inv ) { |
| 425 | if ( index < 0 ) |
- | |
| 426 | return null; |
415 | var ret = []; |
| 427 | 416 | ||
| - | 417 | // Go through the array, only saving the items
|
|
| 428 | // Loop through all the selected options
|
418 | // that pass the validator function
|
| 429 | for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { |
419 | for ( var i = 0, length = elems.length; i < length; i++ ) |
| - | 420 | if ( !inv != !callback( elems[ i ], i ) ) |
|
| 430 | var option = options[ i ]; |
421 | ret.push( elems[ i ] ); |
| 431 | 422 | ||
| 432 | if ( option.selected ) { |
423 | return ret; |
| 433 | // Get the specifc value for the option
|
- | |
| 434 | value = jQuery(option).val(); |
- | |
| - | 424 | }, |
|
| 435 | 425 | ||
| 436 | // We don't need an array for one selects
|
426 | map: function( elems, callback ) { |
| 437 | if ( one ) |
- | |
| 438 | return value; |
427 | var ret = []; |
| 439 | 428 | ||
| 440 | // Multi-Selects return an array
|
429 | // Go through the array, translating each of the items to their
|
| 441 | values.push( value ); |
430 | // new value (or values).
|
| - | 431 | for ( var i = 0, length = elems.length; i < length; i++ ) { |
|
| 442 | }
|
432 | var value = callback( elems[ i ], i ); |
| 443 | }
|
- | |
| 444 | 433 | ||
| - | 434 | if ( value != null ) |
|
| 445 | return values; |
435 | ret[ ret.length ] = value; |
| 446 | }
|
436 | }
|
| 447 | 437 | ||
| 448 | // Everything else, we just grab the value
|
- | |
| 449 | return (elem.value || "").replace(/\r/g, ""); |
438 | return ret.concat.apply( [], ret ); |
| 450 | - | ||
| 451 | }
|
439 | }
|
| - | 440 | }); |
|
| 452 | 441 | ||
| - | 442 | // All jQuery objects should point back to these
|
|
| 453 | return undefined; |
443 | var rootjQuery = jQuery(document); |
| 454 | }
|
- | |
| 455 | 444 | ||
| 456 | if ( typeof value === "number" ) |
445 | // Use of jQuery.browser is deprecated.
|
| - | 446 | // It's included for backwards compatibility and plugins,
|
|
| 457 | value += ''; |
447 | // although they should work to migrate away.
|
| 458 | 448 | ||
| 459 | return this.each(function(){ |
449 | var userAgent = navigator.userAgent.toLowerCase(); |
| 460 | if ( this.nodeType != 1 ) |
- | |
| 461 | return; |
- | |
| 462 | 450 | ||
| - | 451 | // Figure out what browser is being used
|
|
| - | 452 | jQuery.browser = { |
|
| - | 453 | version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1], |
|
| - | 454 | safari: /webkit/.test( userAgent ), |
|
| - | 455 | opera: /opera/.test( userAgent ), |
|
| 463 | if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) ) |
456 | msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ), |
| 464 | this.checked = (jQuery.inArray(this.value, value) >= 0 || |
457 | mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent ) |
| 465 | jQuery.inArray(this.name, value) >= 0); |
458 | };var expando = "jQuery" + now(), uuid = 0, windowData = {}; |
| 466 | 459 | ||
| 467 | else if ( jQuery.nodeName( this, "select" ) ) { |
460 | jQuery.extend({ |
| 468 | var values = jQuery.makeArray(value); |
461 | cache: {}, |
| 469 | 462 | ||
| 470 | jQuery( "option", this ).each(function(){ |
463 | data: function( elem, name, data ) { |
| 471 | this.selected = (jQuery.inArray( this.value, values ) >= 0 || |
464 | elem = elem == window ? |
| 472 | jQuery.inArray( this.text, values ) >= 0); |
465 | windowData :
|
| 473 | }); |
466 | elem;
|
| 474 | 467 | ||
| 475 | if ( !values.length ) |
- | |
| 476 | this.selectedIndex = -1; |
468 | var id = elem[ expando ]; |
| 477 | 469 | ||
| - | 470 | // Compute a unique ID for the element
|
|
| 478 | } else |
471 | if ( !id ) |
| 479 | this.value = value; |
472 | id = elem[ expando ] = ++uuid; |
| 480 | }); |
- | |
| 481 | }, |
- | |
| 482 | 473 | ||
| 483 | html: function( value ) { |
474 | // Only generate the data cache if we're
|
| 484 | return value === undefined ? |
475 | // trying to access or manipulate it
|
| 485 | (this[0] ? |
- | |
| 486 | this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") : |
476 | if ( name && !jQuery.cache[ id ] ) |
| 487 | null) : |
- | |
| 488 | this.empty().append( value ); |
477 | jQuery.cache[ id ] = {}; |
| 489 | }, |
- | |
| 490 | 478 | ||
| - | 479 | // Prevent overriding the named cache with undefined values
|
|
| 491 | replaceWith: function( value ) { |
480 | if ( data !== undefined ) |
| 492 | return this.after( value ).remove(); |
481 | jQuery.cache[ id ][ name ] = data; |
| 493 | }, |
- | |
| 494 | 482 | ||
| - | 483 | // Return the named cache data, or the ID for the element
|
|
| 495 | eq: function( i ) { |
484 | return name ? |
| 496 | return this.slice( i, +i + 1 ); |
485 | jQuery.cache[ id ][ name ] : |
| - | 486 | id;
|
|
| 497 | }, |
487 | }, |
| 498 | 488 | ||
| 499 | slice: function() { |
489 | removeData: function( elem, name ) { |
| 500 | return this.pushStack( Array.prototype.slice.apply( this, arguments ), |
490 | elem = elem == window ? |
| 501 | "slice", Array.prototype.slice.call(arguments).join(",") ); |
491 | windowData :
|
| 502 | }, |
492 | elem;
|
| 503 | 493 | ||
| 504 | map: function( callback ) { |
- | |
| 505 | return this.pushStack( jQuery.map(this, function(elem, i){ |
- | |
| 506 | return callback.call( elem, i, elem ); |
494 | var id = elem[ expando ]; |
| 507 | })); |
- | |
| 508 | }, |
- | |
| 509 | 495 | ||
| - | 496 | // If we want to remove a specific section of the element's data
|
|
| 510 | andSelf: function() { |
497 | if ( name ) { |
| - | 498 | if ( jQuery.cache[ id ] ) { |
|
| - | 499 | // Remove the section of cache data
|
|
| 511 | return this.add( this.prevObject ); |
500 | delete jQuery.cache[ id ][ name ]; |
| 512 | }, |
- | |
| 513 | 501 | ||
| 514 | domManip: function( args, table, callback ) { |
502 | // If we've removed all the data, remove the element's cache
|
| 515 | if ( this[0] ) { |
503 | name = ""; |
| 516 | var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(), |
- | |
| 517 | scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ), |
- | |
| 518 | first = fragment.firstChild; |
- | |
| 519 | 504 | ||
| 520 | if ( first ) |
- | |
| 521 | for ( var i = 0, l = this.length; i < l; i++ ) |
505 | for ( name in jQuery.cache[ id ] ) |
| 522 | callback.call( root(this[i], first), this.length > 1 || i > 0 ? |
- | |
| 523 | fragment.cloneNode(true) : fragment ); |
506 | break; |
| 524 | 507 | ||
| 525 | if ( scripts ) |
508 | if ( !name ) |
| 526 | jQuery.each( scripts, evalScript ); |
509 | jQuery.removeData( elem ); |
| 527 | }
|
510 | }
|
| 528 | 511 | ||
| - | 512 | // Otherwise, we want to remove all of the element's data
|
|
| - | 513 | } else { |
|
| - | 514 | // Clean up the element expando
|
|
| 529 | return this; |
515 | try { |
| - | 516 | delete elem[ expando ]; |
|
| - | 517 | } catch(e){ |
|
| - | 518 | // IE has trouble directly removing the expando
|
|
| - | 519 | // but it's ok with using removeAttribute
|
|
| - | 520 | if ( elem.removeAttribute ) |
|
| - | 521 | elem.removeAttribute( expando ); |
|
| - | 522 | }
|
|
| 530 | 523 | ||
| 531 | function root( elem, cur ) { |
524 | // Completely remove the data cache
|
| 532 | return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ? |
- | |
| 533 | (elem.getElementsByTagName("tbody")[0] || |
525 | delete jQuery.cache[ id ]; |
| 534 | elem.appendChild(elem.ownerDocument.createElement("tbody"))) : |
- | |
| 535 | elem;
|
- | |
| 536 | }
|
- | |
| 537 | }
|
526 | }
|
| 538 | }; |
527 | }, |
| - | 528 | queue: function( elem, type, data ) { |
|
| - | 529 | if ( elem ){ |
|
| 539 | 530 | ||
| 540 | // Give the init function the jQuery prototype for later instantiation
|
- | |
| 541 | jQuery.fn.init.prototype = jQuery.fn; |
531 | type = (type || "fx") + "queue"; |
| 542 | 532 | ||
| 543 | function evalScript( i, elem ) { |
533 | var q = jQuery.data( elem, type ); |
| 544 | if ( elem.src ) |
- | |
| 545 | jQuery.ajax({ |
- | |
| 546 | url: elem.src, |
- | |
| 547 | async: false, |
- | |
| 548 | dataType: "script" |
- | |
| 549 | }); |
- | |
| 550 | 534 | ||
| 551 | else
|
535 | if ( !q || jQuery.isArray(data) ) |
| 552 | jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); |
536 | q = jQuery.data( elem, type, jQuery.makeArray(data) ); |
| - | 537 | else if( data ) |
|
| - | 538 | q.push( data ); |
|
| 553 | 539 | ||
| 554 | if ( elem.parentNode ) |
- | |
| 555 | elem.parentNode.removeChild( elem ); |
- | |
| 556 | }
|
540 | }
|
| - | 541 | return q; |
|
| - | 542 | }, |
|
| 557 | 543 | ||
| 558 | function now(){ |
544 | dequeue: function( elem, type ){ |
| - | 545 | var queue = jQuery.queue( elem, type ), |
|
| 559 | return +new Date; |
546 | fn = queue.shift(); |
| 560 | }
|
- | |
| 561 | 547 | ||
| 562 | jQuery.extend = jQuery.fn.extend = function() { |
548 | if( !type || type === "fx" ) |
| 563 | // copy reference to target object
|
549 | fn = queue[0]; |
| 564 | var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options; |
- | |
| 565 | 550 | ||
| 566 | // Handle a deep copy situation
|
- | |
| 567 | if ( typeof target === "boolean" ) { |
551 | if( fn !== undefined ) |
| 568 | deep = target; |
552 | fn.call(elem); |
| 569 | target = arguments[1] || {}; |
- | |
| 570 | // skip the boolean and the target
|
- | |
| 571 | i = 2; |
- | |
| 572 | }
|
553 | }
|
| - | 554 | }); |
|
| 573 | 555 | ||
| - | 556 | jQuery.fn.extend({ |
|
| 574 | // Handle case when target is a string or something (possible in deep copy)
|
557 | data: function( key, value ){ |
| 575 | if ( typeof target !== "object" && !jQuery.isFunction(target) ) |
558 | var parts = key.split("."); |
| 576 | target = {}; |
559 | parts[1] = parts[1] ? "." + parts[1] : ""; |
| 577 | 560 | ||
| 578 | // extend jQuery itself if only one argument is passed
|
- | |
| 579 | if ( length == i ) { |
561 | if ( value === undefined ) { |
| 580 | target = this; |
562 | var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); |
| 581 | --i; |
- | |
| 582 | }
|
- | |
| 583 | 563 | ||
| 584 | for ( ; i < length; i++ ) |
- | |
| 585 | // Only deal with non-null/undefined values
|
- | |
| 586 | if ( (options = arguments[ i ]) != null ) |
564 | if ( data === undefined && this.length ) |
| 587 | // Extend the base object
|
- | |
| 588 | for ( var name in options ) { |
565 | data = jQuery.data( this[0], key ); |
| 589 | var src = target[ name ], copy = options[ name ]; |
- | |
| 590 | 566 | ||
| 591 | // Prevent never-ending loop
|
567 | return data === undefined && parts[1] ? |
| 592 | if ( target === copy ) |
568 | this.data( parts[0] ) : |
| 593 | continue; |
569 | data;
|
| - | 570 | } else |
|
| - | 571 | return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){ |
|
| - | 572 | jQuery.data( this, key, value ); |
|
| - | 573 | }); |
|
| - | 574 | }, |
|
| 594 | 575 | ||
| 595 | // Recurse if we're merging object values
|
576 | removeData: function( key ){ |
| 596 | if ( deep && copy && typeof copy === "object" && !copy.nodeType ) |
577 | return this.each(function(){ |
| 597 | target[ name ] = jQuery.extend( deep, |
578 | jQuery.removeData( this, key ); |
| - | 579 | }); |
|
| - | 580 | }, |
|
| 598 | // Never move original objects, clone them
|
581 | queue: function(type, data){ |
| 599 | src || ( copy.length != null ? [ ] : { } ) |
582 | if ( typeof type !== "string" ) { |
| 600 | , copy ); |
583 | data = type; |
| - | 584 | type = "fx"; |
|
| - | 585 | }
|
|
| 601 | 586 | ||
| 602 | // Don't bring in undefined values
|
- | |
| 603 | else if ( copy !== undefined ) |
587 | if ( data === undefined ) |
| 604 | target[ name ] = copy; |
588 | return jQuery.queue( this[0], type ); |
| 605 | 589 | ||
| 606 | }
|
590 | return this.each(function(){ |
| - | 591 | var queue = jQuery.queue( this, type, data ); |
|
| 607 | 592 | ||
| - | 593 | if( type == "fx" && queue.length == 1 ) |
|
| - | 594 | queue[0].call(this); |
|
| - | 595 | }); |
|
| - | 596 | }, |
|
| 608 | // Return the modified object
|
597 | dequeue: function(type){ |
| 609 | return target; |
598 | return this.each(function(){ |
| - | 599 | jQuery.dequeue( this, type ); |
|
| - | 600 | }); |
|
| 610 | }; |
601 | }
|
| - | 602 | });/*! |
|
| - | 603 | * Sizzle CSS Selector Engine - v1.0
|
|
| - | 604 | * Copyright 2009, The Dojo Foundation
|
|
| - | 605 | * Released under the MIT, BSD, and GPL Licenses.
|
|
| - | 606 | * More information: http://sizzlejs.com/
|
|
| - | 607 | */
|
|
| - | 608 | (function(){ |
|
| 611 | 609 | ||
| 612 | // exclude the following css properties to add px
|
- | |
| 613 | var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i, |
610 | var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g, |
| 614 | // cache defaultView
|
611 | done = 0, |
| 615 | defaultView = document.defaultView || {}, |
- | |
| 616 | toString = Object.prototype.toString; |
612 | toString = Object.prototype.toString; |
| 617 | 613 | ||
| 618 | jQuery.extend({ |
614 | var Sizzle = function(selector, context, results, seed) { |
| 619 | noConflict: function( deep ) { |
615 | results = results || []; |
| 620 | window.$ = _$; |
616 | var origContext = context = context || document; |
| 621 | 617 | ||
| 622 | if ( deep ) |
618 | if ( context.nodeType !== 1 && context.nodeType !== 9 ) { |
| 623 | window.jQuery = _jQuery; |
619 | return []; |
| - | 620 | }
|
|
| 624 | 621 | ||
| - | 622 | if ( !selector || typeof selector !== "string" ) { |
|
| 625 | return jQuery; |
623 | return results; |
| 626 | }, |
624 | }
|
| 627 | 625 | ||
| 628 | // See test/unit/core.js for details concerning isFunction.
|
626 | var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context); |
| 629 | // Since version 1.3, DOM methods and functions like alert
|
- | |
| 630 | // aren't supported. They return false on IE (#2968).
|
- | |
| 631 | isFunction: function( obj ) { |
- | |
| 632 | return toString.call(obj) === "[object Function]"; |
- | |
| 633 | }, |
- | |
| 634 | 627 | ||
| 635 | isArray: function( obj ) { |
628 | // Reset the position of the chunker regexp (start from head)
|
| 636 | return toString.call(obj) === "[object Array]"; |
629 | chunker.lastIndex = 0; |
| 637 | }, |
- | |
| 638 | 630 | ||
| 639 | // check if an element is in a (or is an) XML document
|
631 | while ( (m = chunker.exec(selector)) !== null ) { |
| 640 | isXMLDoc: function( elem ) { |
632 | parts.push( m[1] ); |
| 641 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
- | |
| 642 | !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument ); |
- | |
| 643 | }, |
- | |
| 644 | 633 | ||
| 645 | // Evalulates a script in a global context
|
- | |
| 646 | globalEval: function( data ) { |
634 | if ( m[2] ) { |
| 647 | if ( data && /\S/.test(data) ) { |
635 | extra = RegExp.rightContext; |
| 648 | // Inspired by code by Andrea Giammarchi
|
636 | break; |
| 649 | // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
|
- | |
| 650 | var head = document.getElementsByTagName("head")[0] || document.documentElement, |
- | |
| 651 | script = document.createElement("script"); |
- | |
| - | 637 | }
|
|
| - | 638 | }
|
|
| 652 | 639 | ||
| 653 | script.type = "text/javascript"; |
640 | if ( parts.length > 1 && origPOS.exec( selector ) ) { |
| 654 | if ( jQuery.support.scriptEval ) |
641 | if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { |
| 655 | script.appendChild( document.createTextNode( data ) ); |
642 | set = posProcess( parts[0] + parts[1], context ); |
| 656 | else
|
643 | } else { |
| - | 644 | set = Expr.relative[ parts[0] ] ? |
|
| 657 | script.text = data; |
645 | [ context ] : |
| - | 646 | Sizzle( parts.shift(), context ); |
|
| 658 | 647 | ||
| 659 | // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
- | |
| 660 | // This arises when a base node is used (#2709).
|
- | |
| 661 | head.insertBefore( script, head.firstChild ); |
648 | while ( parts.length ) { |
| 662 | head.removeChild( script ); |
649 | selector = parts.shift(); |
| 663 | }
|
- | |
| 664 | }, |
- | |
| 665 | 650 | ||
| 666 | nodeName: function( elem, name ) { |
651 | if ( Expr.relative[ selector ] ) |
| 667 | return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase(); |
652 | selector += parts.shift(); |
| 668 | }, |
- | |
| 669 | 653 | ||
| 670 | // args is for internal usage only
|
654 | set = posProcess( selector, set ); |
| - | 655 | }
|
|
| - | 656 | }
|
|
| - | 657 | } else { |
|
| 671 | each: function( object, callback, args ) { |
658 | // Take a shortcut and set the context if the root selector is an ID
|
| - | 659 | // (but not if it'll be faster if the inner selector is an ID)
|
|
| - | 660 | if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML && |
|
| - | 661 | Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) { |
|
| 672 | var name, i = 0, length = object.length; |
662 | var ret = Sizzle.find( parts.shift(), context, contextXML ); |
| - | 663 | context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0]; |
|
| - | 664 | }
|
|
| 673 | 665 | ||
| 674 | if ( args ) { |
666 | if ( context ) { |
| 675 | if ( length === undefined ) { |
667 | var ret = seed ? |
| 676 | for ( name in object ) |
668 | { expr: parts.pop(), set: makeArray(seed) } : |
| 677 | if ( callback.apply( object[ name ], args ) === false ) |
669 | Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); |
| 678 | break; |
- | |
| 679 | } else |
- | |
| 680 | for ( ; i < length; ) |
- | |
| 681 | if ( callback.apply( object[ i++ ], args ) === false ) |
670 | set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set; |
| 682 | break; |
- | |
| 683 | 671 | ||
| 684 | // A special, fast, case for the most common use of each
|
672 | if ( parts.length > 0 ) { |
| - | 673 | checkSet = makeArray(set); |
|
| 685 | } else { |
674 | } else { |
| 686 | if ( length === undefined ) { |
- | |
| 687 | for ( name in object ) |
- | |
| 688 | if ( callback.call( object[ name ], name, object[ name ] ) === false ) |
- | |
| 689 | break; |
675 | prune = false; |
| 690 | } else |
- | |
| 691 | for ( var value = object[0]; |
- | |
| 692 | i < length && callback.call( value, i, value ) !== false; value = object[++i] ){} |
- | |
| 693 | }
|
676 | }
|
| 694 | 677 | ||
| 695 | return object; |
678 | while ( parts.length ) { |
| 696 | }, |
679 | var cur = parts.pop(), pop = cur; |
| 697 | 680 | ||
| 698 | prop: function( elem, value, type, i, name ) { |
681 | if ( !Expr.relative[ cur ] ) { |
| 699 | // Handle executable functions
|
682 | cur = ""; |
| 700 | if ( jQuery.isFunction( value ) ) |
683 | } else { |
| 701 | value = value.call( elem, i ); |
684 | pop = parts.pop(); |
| - | 685 | }
|
|
| 702 | 686 | ||
| 703 | // Handle passing in a number to a CSS property
|
- | |
| 704 | return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ? |
- | |
| 705 | value + "px" : |
687 | if ( pop == null ) { |
| 706 | value;
|
688 | pop = context; |
| 707 | }, |
689 | }
|
| 708 | 690 | ||
| 709 | className: { |
- | |
| 710 | // internal only, use addClass("class")
|
691 | Expr.relative[ cur ]( checkSet, pop, contextXML ); |
| - | 692 | }
|
|
| 711 | add: function( elem, classNames ) { |
693 | } else { |
| 712 | jQuery.each((classNames || "").split(/\s+/), function(i, className){ |
- | |
| 713 | if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) ) |
- | |
| 714 | elem.className += (elem.className ? " " : "") + className; |
694 | checkSet = parts = []; |
| 715 | }); |
695 | }
|
| 716 | }, |
696 | }
|
| 717 | 697 | ||
| 718 | // internal only, use removeClass("class")
|
- | |
| 719 | remove: function( elem, classNames ) { |
- | |
| 720 | if (elem.nodeType == 1) |
698 | if ( !checkSet ) { |
| 721 | elem.className = classNames !== undefined ? |
- | |
| 722 | jQuery.grep(elem.className.split(/\s+/), function(className){ |
- | |
| 723 | return !jQuery.className.has( classNames, className ); |
- | |
| 724 | }).join(" ") : |
699 | checkSet = set; |
| 725 | ""; |
- | |
| 726 | }, |
- | |
| 727 | - | ||
| 728 | // internal only, use hasClass("class")
|
- | |
| 729 | has: function( elem, className ) { |
- | |
| 730 | return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1; |
- | |
| 731 | }
|
700 | }
|
| 732 | }, |
- | |
| 733 | 701 | ||
| 734 | // A method for quickly swapping in/out CSS properties to get correct calculations
|
- | |
| 735 | swap: function( elem, options, callback ) { |
- | |
| 736 | var old = {}; |
702 | if ( !checkSet ) { |
| 737 | // Remember the old values, and insert the new ones
|
703 | throw "Syntax error, unrecognized expression: " + (cur || selector); |
| 738 | for ( var name in options ) { |
- | |
| 739 | old[ name ] = elem.style[ name ]; |
- | |
| 740 | elem.style[ name ] = options[ name ]; |
- | |
| 741 | }
|
704 | }
|
| 742 | 705 | ||
| - | 706 | if ( toString.call(checkSet) === "[object Array]" ) { |
|
| - | 707 | if ( !prune ) { |
|
| - | 708 | results.push.apply( results, checkSet ); |
|
| - | 709 | } else if ( context && context.nodeType === 1 ) { |
|
| - | 710 | for ( var i = 0; checkSet[i] != null; i++ ) { |
|
| - | 711 | if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { |
|
| 743 | callback.call( elem ); |
712 | results.push( set[i] ); |
| - | 713 | }
|
|
| 744 | 714 | }
|
|
| - | 715 | } else { |
|
| 745 | // Revert the old values
|
716 | for ( var i = 0; checkSet[i] != null; i++ ) { |
| - | 717 | if ( checkSet[i] && checkSet[i].nodeType === 1 ) { |
|
| 746 | for ( var name in options ) |
718 | results.push( set[i] ); |
| - | 719 | }
|
|
| - | 720 | }
|
|
| - | 721 | }
|
|
| - | 722 | } else { |
|
| 747 | elem.style[ name ] = old[ name ]; |
723 | makeArray( checkSet, results ); |
| 748 | }, |
724 | }
|
| 749 | 725 | ||
| 750 | css: function( elem, name, force, extra ) { |
726 | if ( extra ) { |
| 751 | if ( name == "width" || name == "height" ) { |
727 | Sizzle( extra, origContext, results, seed ); |
| 752 | var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ]; |
728 | Sizzle.uniqueSort( results ); |
| - | 729 | }
|
|
| 753 | 730 | ||
| 754 | function getWH() { |
731 | return results; |
| 755 | val = name == "width" ? elem.offsetWidth : elem.offsetHeight; |
- | |
| - | 732 | }; |
|
| 756 | 733 | ||
| - | 734 | Sizzle.uniqueSort = function(results){ |
|
| 757 | if ( extra === "border" ) |
735 | if ( sortOrder ) { |
| - | 736 | hasDuplicate = false; |
|
| 758 | return; |
737 | results.sort(sortOrder); |
| 759 | 738 | ||
| 760 | jQuery.each( which, function() { |
- | |
| 761 | if ( !extra ) |
739 | if ( hasDuplicate ) { |
| 762 | val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0; |
740 | for ( var i = 1; i < results.length; i++ ) { |
| 763 | if ( extra === "margin" ) |
741 | if ( results[i] === results[i-1] ) { |
| 764 | val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0; |
- | |
| 765 | else
|
742 | results.splice(i--, 1); |
| 766 | val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0; |
- | |
| 767 | }); |
743 | }
|
| 768 | }
|
744 | }
|
| - | 745 | }
|
|
| - | 746 | }
|
|
| - | 747 | }; |
|
| 769 | 748 | ||
| 770 | if ( elem.offsetWidth !== 0 ) |
749 | Sizzle.matches = function(expr, set){ |
| 771 | getWH(); |
750 | return Sizzle(expr, null, null, set); |
| 772 | else
|
751 | }; |
| 773 | jQuery.swap( elem, props, getWH ); |
- | |
| 774 | 752 | ||
| 775 | return Math.max(0, Math.round(val)); |
753 | Sizzle.find = function(expr, context, isXML){ |
| 776 | }
|
754 | var set, match; |
| 777 | 755 | ||
| - | 756 | if ( !expr ) { |
|
| 778 | return jQuery.curCSS( elem, name, force ); |
757 | return []; |
| 779 | }, |
758 | }
|
| 780 | 759 | ||
| 781 | curCSS: function( elem, name, force ) { |
760 | for ( var i = 0, l = Expr.order.length; i < l; i++ ) { |
| 782 | var ret, style = elem.style; |
761 | var type = Expr.order[i], match; |
| 783 | 762 | ||
| 784 | // We need to handle opacity special in IE
|
- | |
| 785 | if ( name == "opacity" && !jQuery.support.opacity ) { |
763 | if ( (match = Expr.match[ type ].exec( expr )) ) { |
| 786 | ret = jQuery.attr( style, "opacity" ); |
764 | var left = RegExp.leftContext; |
| 787 | 765 | ||
| - | 766 | if ( left.substr( left.length - 1 ) !== "\\" ) { |
|
| - | 767 | match[1] = (match[1] || "").replace(/\\/g, ""); |
|
| - | 768 | set = Expr.find[ type ]( match, context, isXML ); |
|
| 788 | return ret == "" ? |
769 | if ( set != null ) { |
| - | 770 | expr = expr.replace( Expr.match[ type ], "" ); |
|
| 789 | "1" : |
771 | break; |
| 790 | ret;
|
772 | }
|
| - | 773 | }
|
|
| - | 774 | }
|
|
| 791 | }
|
775 | }
|
| 792 | 776 | ||
| 793 | // Make sure we're using the right name for getting the float value
|
- | |
| 794 | if ( name.match( /float/i ) ) |
777 | if ( !set ) { |
| 795 | name = styleFloat; |
778 | set = context.getElementsByTagName("*"); |
| 796 | 779 | }
|
|
| 797 | if ( !force && style && style[ name ] ) |
- | |
| 798 | ret = style[ name ]; |
- | |
| 799 | 780 | ||
| 800 | else if ( defaultView.getComputedStyle ) { |
781 | return {set: set, expr: expr}; |
| - | 782 | }; |
|
| 801 | 783 | ||
| 802 | // Only "float" is needed here
|
784 | Sizzle.filter = function(expr, set, inplace, not){ |
| 803 | if ( name.match( /float/i ) ) |
785 | var old = expr, result = [], curLoop = set, match, anyFound, |
| 804 | name = "float"; |
786 | isXMLFilter = set && set[0] && isXML(set[0]); |
| 805 | 787 | ||
| - | 788 | while ( expr && set.length ) { |
|
| - | 789 | for ( var type in Expr.filter ) { |
|
| - | 790 | if ( (match = Expr.match[ type ].exec( expr )) != null ) { |
|
| 806 | name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase(); |
791 | var filter = Expr.filter[ type ], found, item; |
| - | 792 | anyFound = false; |
|
| 807 | 793 | ||
| 808 | var computedStyle = defaultView.getComputedStyle( elem, null ); |
794 | if ( curLoop == result ) { |
| - | 795 | result = []; |
|
| - | 796 | }
|
|
| 809 | 797 | ||
| 810 | if ( computedStyle ) |
798 | if ( Expr.preFilter[ type ] ) { |
| 811 | ret = computedStyle.getPropertyValue( name ); |
799 | match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); |
| 812 | 800 | ||
| - | 801 | if ( !match ) { |
|
| 813 | // We should always get a number back from opacity
|
802 | anyFound = found = true; |
| 814 | if ( name == "opacity" && ret == "" ) |
803 | } else if ( match === true ) { |
| 815 | ret = "1"; |
804 | continue; |
| - | 805 | }
|
|
| - | 806 | }
|
|
| 816 | 807 | ||
| 817 | } else if ( elem.currentStyle ) { |
808 | if ( match ) { |
| 818 | var camelCase = name.replace(/\-(\w)/g, function(all, letter){ |
809 | for ( var i = 0; (item = curLoop[i]) != null; i++ ) { |
| - | 810 | if ( item ) { |
|
| 819 | return letter.toUpperCase(); |
811 | found = filter( item, match, i, curLoop ); |
| 820 | }); |
812 | var pass = not ^ !!found; |
| 821 | 813 | ||
| 822 | ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ]; |
814 | if ( inplace && found != null ) { |
| - | 815 | if ( pass ) { |
|
| - | 816 | anyFound = true; |
|
| - | 817 | } else { |
|
| - | 818 | curLoop[i] = false; |
|
| - | 819 | }
|
|
| - | 820 | } else if ( pass ) { |
|
| - | 821 | result.push( item ); |
|
| - | 822 | anyFound = true; |
|
| - | 823 | }
|
|
| - | 824 | }
|
|
| - | 825 | }
|
|
| - | 826 | }
|
|
| 823 | 827 | ||
| 824 | // From the awesome hack by Dean Edwards
|
828 | if ( found !== undefined ) { |
| - | 829 | if ( !inplace ) { |
|
| 825 | // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
|
830 | curLoop = result; |
| - | 831 | }
|
|
| 826 | 832 | ||
| 827 | // If we're not dealing with a regular pixel number
|
- | |
| 828 | // but a number that has a weird ending, we need to convert it to pixels
|
- | |
| 829 | if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) { |
- | |
| 830 | // Remember the original values
|
- | |
| 831 | var left = style.left, rsLeft = elem.runtimeStyle.left; |
833 | expr = expr.replace( Expr.match[ type ], "" ); |
| 832 | 834 | ||
| 833 | // Put in the new values to get a computed value out
|
835 | if ( !anyFound ) { |
| 834 | elem.runtimeStyle.left = elem.currentStyle.left; |
- | |
| 835 | style.left = ret || 0; |
836 | return []; |
| 836 | ret = style.pixelLeft + "px"; |
837 | }
|
| 837 | 838 | ||
| 838 | // Revert the changed values
|
839 | break; |
| 839 | style.left = left; |
840 | }
|
| 840 | elem.runtimeStyle.left = rsLeft; |
- | |
| 841 | }
|
841 | }
|
| 842 | }
|
842 | }
|
| 843 | 843 | ||
| - | 844 | // Improper expression
|
|
| - | 845 | if ( expr == old ) { |
|
| - | 846 | if ( anyFound == null ) { |
|
| - | 847 | throw "Syntax error, unrecognized expression: " + expr; |
|
| - | 848 | } else { |
|
| 844 | return ret; |
849 | break; |
| - | 850 | }
|
|
| 845 | }, |
851 | }
|
| 846 | 852 | ||
| 847 | clean: function( elems, context, fragment ) { |
- | |
| 848 | context = context || document; |
853 | old = expr; |
| - | 854 | }
|
|
| 849 | 855 | ||
| 850 | // !context.createElement fails in IE with an error but returns typeof 'object'
|
- | |
| 851 | if ( typeof context.createElement === "undefined" ) |
856 | return curLoop; |
| 852 | context = context.ownerDocument || context[0] && context[0].ownerDocument || document; |
- | |
| - | 857 | }; |
|
| 853 | 858 | ||
| - | 859 | var Expr = Sizzle.selectors = { |
|
| - | 860 | order: [ "ID", "NAME", "TAG" ], |
|
| - | 861 | match: { |
|
| - | 862 | ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, |
|
| - | 863 | CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, |
|
| 854 | // If a single string is passed in and it's a single tag
|
864 | NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/, |
| - | 865 | ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/, |
|
| 855 | // just do a createElement and skip the rest
|
866 | TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/, |
| 856 | if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) { |
867 | CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/, |
| 857 | var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); |
868 | POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/, |
| - | 869 | PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/ |
|
| - | 870 | }, |
|
| - | 871 | attrMap: { |
|
| - | 872 | "class": "className", |
|
| 858 | if ( match ) |
873 | "for": "htmlFor" |
| - | 874 | }, |
|
| - | 875 | attrHandle: { |
|
| - | 876 | href: function(elem){ |
|
| 859 | return [ context.createElement( match[1] ) ]; |
877 | return elem.getAttribute("href"); |
| 860 | }
|
878 | }
|
| - | 879 | }, |
|
| - | 880 | relative: { |
|
| - | 881 | "+": function(checkSet, part, isXML){ |
|
| - | 882 | var isPartStr = typeof part === "string", |
|
| - | 883 | isTag = isPartStr && !/\W/.test(part), |
|
| - | 884 | isPartStrNotTag = isPartStr && !isTag; |
|
| 861 | 885 | ||
| - | 886 | if ( isTag && !isXML ) { |
|
| 862 | var ret = [], scripts = [], div = context.createElement("div"); |
887 | part = part.toUpperCase(); |
| - | 888 | }
|
|
| 863 | 889 | ||
| 864 | jQuery.each(elems, function(i, elem){ |
- | |
| 865 | if ( typeof elem === "number" ) |
- | |
| 866 | elem += ''; |
- | |
| 867 | - | ||
| 868 | if ( !elem ) |
- | |
| 869 | return; |
- | |
| 870 | - | ||
| 871 | // Convert html string into DOM nodes
|
- | |
| 872 | if ( typeof elem === "string" ) { |
- | |
| 873 | // Fix "XHTML"-style tags in all browsers
|
- | |
| 874 | elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){ |
- | |
| 875 | return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ? |
- | |
| 876 | all :
|
- | |
| 877 | front + "></" + tag + ">"; |
- | |
| 878 | }); |
- | |
| 879 | - | ||
| 880 | // Trim whitespace, otherwise indexOf won't work as expected
|
- | |
| 881 | var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase(); |
- | |
| 882 | - | ||
| 883 | var wrap = |
- | |
| 884 | // option or optgroup
|
- | |
| 885 | !tags.indexOf("<opt") && |
- | |
| 886 | [ 1, "<select multiple='multiple'>", "</select>" ] || |
- | |
| 887 | - | ||
| 888 | !tags.indexOf("<leg") && |
- | |
| 889 | [ 1, "<fieldset>", "</fieldset>" ] || |
- | |
| 890 | - | ||
| 891 | tags.match(/^<(thead|tbody|tfoot|colg|cap)/) && |
- | |
| 892 | [ 1, "<table>", "</table>" ] || |
- | |
| 893 | - | ||
| 894 | !tags.indexOf("<tr") && |
- | |
| 895 | [ 2, "<table><tbody>", "</tbody></table>" ] || |
- | |
| 896 | - | ||
| 897 | // <thead> matched above
|
- | |
| 898 | (!tags.indexOf("<td") || !tags.indexOf("<th")) && |
- | |
| 899 | [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] || |
- | |
| 900 | - | ||
| 901 | !tags.indexOf("<col") && |
- | |
| 902 | [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] || |
- | |
| 903 | - | ||
| 904 | // IE can't serialize <link> and <script> tags normally
|
- | |
| 905 | !jQuery.support.htmlSerialize && |
- | |
| 906 | [ 1, "div<div>", "</div>" ] || |
- | |
| 907 | - | ||
| 908 | [ 0, "", "" ]; |
- | |
| 909 | - | ||
| 910 | // Go to html and back, then peel off extra wrappers
|
890 | for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { |
| 911 | div.innerHTML = wrap[1] + elem + wrap[2]; |
- | |
| 912 | - | ||
| 913 | // Move to the right depth
|
- | |
| 914 | while ( wrap[0]-- ) |
- | |
| 915 | div = div.lastChild; |
- | |
| 916 | - | ||
| 917 | // Remove IE's autoinserted <tbody> from table fragments
|
- | |
| 918 | if ( !jQuery.support.tbody ) { |
891 | if ( (elem = checkSet[i]) ) { |
| 919 | - | ||
| 920 | // String was a <table>, *may* have spurious <tbody>
|
- | |
| 921 | var hasBody = /<tbody/i.test(elem), |
- | |
| 922 | tbody = !tags.indexOf("<table") && !hasBody ? |
- | |
| 923 | div.firstChild && div.firstChild.childNodes : |
- | |
| 924 | - | ||
| 925 | // String was a bare <thead> or <tfoot>
|
- | |
| 926 | wrap[1] == "<table>" && !hasBody ? |
- | |
| 927 | div.childNodes : |
- | |
| 928 | []; |
- | |
| 929 | - | ||
| 930 | for ( var j = tbody.length - 1; j >= 0 ; --j ) |
892 | while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} |
| 931 | if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) |
- | |
| 932 | tbody[ j ].parentNode.removeChild( tbody[ j ] ); |
- | |
| 933 | 893 | ||
| - | 894 | checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ? |
|
| - | 895 | elem || false : |
|
| - | 896 | elem === part; |
|
| 934 | }
|
897 | }
|
| 935 | - | ||
| 936 | // IE completely kills leading whitespace when innerHTML is used
|
- | |
| 937 | if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) ) |
- | |
| 938 | div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild ); |
- | |
| 939 | - | ||
| 940 | elem = jQuery.makeArray( div.childNodes ); |
- | |
| 941 | }
|
898 | }
|
| 942 | 899 | ||
| 943 | if ( elem.nodeType ) |
900 | if ( isPartStrNotTag ) { |
| 944 | ret.push( elem ); |
901 | Sizzle.filter( part, checkSet, true ); |
| 945 | else
|
902 | }
|
| - | 903 | }, |
|
| 946 | ret = jQuery.merge( ret, elem ); |
904 | ">": function(checkSet, part, isXML){ |
| - | 905 | var isPartStr = typeof part === "string"; |
|
| 947 | 906 | ||
| - | 907 | if ( isPartStr && !/\W/.test(part) ) { |
|
| 948 | }); |
908 | part = isXML ? part : part.toUpperCase(); |
| 949 | 909 | ||
| - | 910 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
|
| - | 911 | var elem = checkSet[i]; |
|
| 950 | if ( fragment ) { |
912 | if ( elem ) { |
| 951 | for ( var i = 0; ret[i]; i++ ) { |
913 | var parent = elem.parentNode; |
| 952 | if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) { |
- | |
| 953 | scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] ); |
914 | checkSet[i] = parent.nodeName === part ? parent : false; |
| - | 915 | }
|
|
| - | 916 | }
|
|
| 954 | } else { |
917 | } else { |
| - | 918 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
|
| - | 919 | var elem = checkSet[i]; |
|
| 955 | if ( ret[i].nodeType === 1 ) |
920 | if ( elem ) { |
| 956 | ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) ); |
921 | checkSet[i] = isPartStr ? |
| - | 922 | elem.parentNode : |
|
| 957 | fragment.appendChild( ret[i] ); |
923 | elem.parentNode === part; |
| 958 | }
|
924 | }
|
| 959 | }
|
925 | }
|
| 960 | 926 | ||
| 961 | return scripts; |
927 | if ( isPartStr ) { |
| - | 928 | Sizzle.filter( part, checkSet, true ); |
|
| - | 929 | }
|
|
| 962 | }
|
930 | }
|
| 963 | - | ||
| 964 | return ret; |
- | |
| 965 | }, |
931 | }, |
| - | 932 | "": function(checkSet, part, isXML){ |
|
| - | 933 | var doneName = done++, checkFn = dirCheck; |
|
| 966 | 934 | ||
| 967 | attr: function( elem, name, value ) { |
- | |
| 968 | // don't set attributes on text and comment nodes
|
- | |
| 969 | if (!elem || elem.nodeType == 3 || elem.nodeType == 8) |
- | |
| 970 | return undefined; |
- | |
| 971 | - | ||
| 972 | var notxml = !jQuery.isXMLDoc( elem ), |
- | |
| 973 | // Whether we are setting (or getting)
|
- | |
| 974 | set = value !== undefined; |
- | |
| 975 | - | ||
| 976 | // Try to normalize/fix the name
|
- | |
| 977 | name = notxml && jQuery.props[ name ] || name; |
- | |
| 978 | - | ||
| 979 | // Only do all the following if this is a node (faster for style)
|
- | |
| 980 | // IE elem.getAttribute passes even for style
|
- | |
| 981 | if ( elem.tagName ) { |
935 | if ( !part.match(/\W/) ) { |
| 982 | - | ||
| 983 | // These attributes require special treatment
|
936 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
| 984 | var special = /href|src|style/.test( name ); |
937 | checkFn = dirNodeCheck; |
| 985 | 938 | }
|
|
| 986 | // Safari mis-reports the default selected property of a hidden option
|
- | |
| 987 | // Accessing the parent's selectedIndex property fixes it
|
- | |
| 988 | if ( name == "selected" && elem.parentNode ) |
- | |
| 989 | elem.parentNode.selectedIndex; |
- | |
| 990 | 939 | ||
| 991 | // If applicable, access the attribute via the DOM 0 way
|
940 | checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML); |
| 992 | if ( name in elem && notxml && !special ) { |
- | |
| 993 | if ( set ){ |
941 | }, |
| 994 | // We can't allow the type property to be changed (since it causes problems in IE)
|
- | |
| 995 | if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode ) |
942 | "~": function(checkSet, part, isXML){ |
| 996 | throw "type property can't be changed"; |
943 | var doneName = done++, checkFn = dirCheck; |
| 997 | 944 | ||
| - | 945 | if ( typeof part === "string" && !part.match(/\W/) ) { |
|
| - | 946 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
|
| 998 | elem[ name ] = value; |
947 | checkFn = dirNodeCheck; |
| 999 | }
|
948 | }
|
| 1000 | 949 | ||
| - | 950 | checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML); |
|
| - | 951 | }
|
|
| - | 952 | }, |
|
| - | 953 | find: { |
|
| - | 954 | ID: function(match, context, isXML){ |
|
| 1001 | // browsers index elements by id/name on forms, give priority to attributes.
|
955 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
| - | 956 | var m = context.getElementById(match[1]); |
|
| - | 957 | return m ? [m] : []; |
|
| - | 958 | }
|
|
| - | 959 | }, |
|
| - | 960 | NAME: function(match, context, isXML){ |
|
| 1002 | if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) |
961 | if ( typeof context.getElementsByName !== "undefined" ) { |
| 1003 | return elem.getAttributeNode( name ).nodeValue; |
962 | var ret = [], results = context.getElementsByName(match[1]); |
| 1004 | 963 | ||
| 1005 | // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
|
- | |
| 1006 | // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
- | |
| 1007 | if ( name == "tabIndex" ) { |
964 | for ( var i = 0, l = results.length; i < l; i++ ) { |
| 1008 | var attributeNode = elem.getAttributeNode( "tabIndex" ); |
965 | if ( results[i].getAttribute("name") === match[1] ) { |
| 1009 | return attributeNode && attributeNode.specified |
- | |
| 1010 | ? attributeNode.value |
966 | ret.push( results[i] ); |
| 1011 | : elem.nodeName.match(/(button|input|object|select|textarea)/i) |
- | |
| 1012 | ? 0 |
967 | }
|
| 1013 | : elem.nodeName.match(/^(a|area)$/i) && elem.href |
- | |
| 1014 | ? 0 |
- | |
| 1015 | : undefined; |
- | |
| 1016 | }
|
968 | }
|
| 1017 | 969 | ||
| 1018 | return elem[ name ]; |
970 | return ret.length === 0 ? null : ret; |
| - | 971 | }
|
|
| - | 972 | }, |
|
| - | 973 | TAG: function(match, context){ |
|
| - | 974 | return context.getElementsByTagName(match[1]); |
|
| 1019 | }
|
975 | }
|
| - | 976 | }, |
|
| - | 977 | preFilter: { |
|
| - | 978 | CLASS: function(match, curLoop, inplace, result, not, isXML){ |
|
| - | 979 | match = " " + match[1].replace(/\\/g, "") + " "; |
|
| 1020 | 980 | ||
| 1021 | if ( !jQuery.support.style && notxml && name == "style" ) |
981 | if ( isXML ) { |
| 1022 | return jQuery.attr( elem.style, "cssText", value ); |
982 | return match; |
| - | 983 | }
|
|
| 1023 | 984 | ||
| - | 985 | for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { |
|
| 1024 | if ( set ) |
986 | if ( elem ) { |
| 1025 | // convert the value to a string (all browsers do this but IE) see #1070
|
987 | if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) { |
| - | 988 | if ( !inplace ) |
|
| 1026 | elem.setAttribute( name, "" + value ); |
989 | result.push( elem ); |
| - | 990 | } else if ( inplace ) { |
|
| - | 991 | curLoop[i] = false; |
|
| - | 992 | }
|
|
| - | 993 | }
|
|
| - | 994 | }
|
|
| 1027 | 995 | ||
| - | 996 | return false; |
|
| - | 997 | }, |
|
| - | 998 | ID: function(match){ |
|
| 1028 | var attr = !jQuery.support.hrefNormalized && notxml && special |
999 | return match[1].replace(/\\/g, ""); |
| - | 1000 | }, |
|
| - | 1001 | TAG: function(match, curLoop){ |
|
| 1029 | // Some attributes require a special call on IE
|
1002 | for ( var i = 0; curLoop[i] === false; i++ ){} |
| - | 1003 | return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase(); |
|
| - | 1004 | }, |
|
| 1030 | ? elem.getAttribute( name, 2 ) |
1005 | CHILD: function(match){ |
| 1031 | : elem.getAttribute( name ); |
1006 | if ( match[1] == "nth" ) { |
| - | 1007 | // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
|
|
| - | 1008 | var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec( |
|
| - | 1009 | match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" || |
|
| - | 1010 | !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); |
|
| 1032 | 1011 | ||
| 1033 | // Non-existent attributes return null, we normalize to undefined
|
1012 | // calculate the numbers (first)n+(last) including if they are negative
|
| 1034 | return attr === null ? undefined : attr; |
1013 | match[2] = (test[1] + (test[2] || 1)) - 0; |
| - | 1014 | match[3] = test[3] - 0; |
|
| 1035 | }
|
1015 | }
|
| 1036 | 1016 | ||
| 1037 | // elem is actually elem.style ... set the style
|
1017 | // TODO: Move to normal caching system
|
| - | 1018 | match[0] = done++; |
|
| 1038 | 1019 | ||
| 1039 | // IE uses filters for opacity
|
1020 | return match; |
| 1040 | if ( !jQuery.support.opacity && name == "opacity" ) { |
- | |
| 1041 | if ( set ) { |
1021 | }, |
| 1042 | // IE has trouble with opacity if it does not have layout
|
1022 | ATTR: function(match, curLoop, inplace, result, not, isXML){ |
| 1043 | // Force it by setting the zoom level
|
1023 | var name = match[1].replace(/\\/g, ""); |
| 1044 | elem.zoom = 1; |
- | |
| 1045 | 1024 | ||
| 1046 | // Set the alpha filter to set the opacity
|
1025 | if ( !isXML && Expr.attrMap[name] ) { |
| 1047 | elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) + |
1026 | match[1] = Expr.attrMap[name]; |
| 1048 | (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")"); |
- | |
| 1049 | }
|
1027 | }
|
| 1050 | 1028 | ||
| 1051 | return elem.filter && elem.filter.indexOf("opacity=") >= 0 ? |
1029 | if ( match[2] === "~=" ) { |
| 1052 | (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '': |
1030 | match[4] = " " + match[4] + " "; |
| 1053 | ""; |
- | |
| 1054 | }
|
1031 | }
|
| 1055 | 1032 | ||
| 1056 | name = name.replace(/-([a-z])/ig, function(all, letter){ |
- | |
| 1057 | return letter.toUpperCase(); |
- | |
| 1058 | }); |
- | |
| 1059 | - | ||
| 1060 | if ( set ) |
- | |
| 1061 | elem[ name ] = value; |
- | |
| 1062 | - | ||
| 1063 | return elem[ name ]; |
1033 | return match; |
| 1064 | }, |
1034 | }, |
| - | 1035 | PSEUDO: function(match, curLoop, inplace, result, not){ |
|
| - | 1036 | if ( match[1] === "not" ) { |
|
| - | 1037 | // If we're dealing with a complex expression, or a simple one
|
|
| - | 1038 | if ( match[3].match(chunker).length > 1 || /^\w/.test(match[3]) ) { |
|
| - | 1039 | match[3] = Sizzle(match[3], null, null, curLoop); |
|
| - | 1040 | } else { |
|
| - | 1041 | var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); |
|
| - | 1042 | if ( !inplace ) { |
|
| - | 1043 | result.push.apply( result, ret ); |
|
| - | 1044 | }
|
|
| - | 1045 | return false; |
|
| - | 1046 | }
|
|
| - | 1047 | } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { |
|
| - | 1048 | return true; |
|
| - | 1049 | }
|
|
| 1065 | 1050 | ||
| 1066 | trim: function( text ) { |
1051 | return match; |
| 1067 | return (text || "").replace( /^\s+|\s+$/g, "" ); |
- | |
| 1068 | }, |
1052 | }, |
| 1069 | - | ||
| 1070 | makeArray: function( array ) { |
1053 | POS: function(match){ |
| 1071 | var ret = []; |
- | |
| 1072 | - | ||
| 1073 | if( array != null ){ |
- | |
| 1074 | var i = array.length; |
1054 | match.unshift( true ); |
| 1075 | // The window, strings (and functions) also have 'length'
|
- | |
| 1076 | if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval ) |
- | |
| 1077 | ret[0] = array; |
1055 | return match; |
| 1078 | else
|
- | |
| 1079 | while( i ) |
- | |
| 1080 | ret[--i] = array[i]; |
- | |
| 1081 | }
|
1056 | }
|
| 1082 | - | ||
| 1083 | return ret; |
- | |
| 1084 | }, |
1057 | }, |
| 1085 | 1058 | filters: { |
|
| 1086 | inArray: function( elem, array ) { |
1059 | enabled: function(elem){ |
| 1087 | for ( var i = 0, length = array.length; i < length; i++ ) |
- | |
| 1088 | // Use === because on IE, window == document
|
1060 | return elem.disabled === false && elem.type !== "hidden"; |
| 1089 | if ( array[ i ] === elem ) |
- | |
| 1090 | return i; |
- | |
| 1091 | - | ||
| 1092 | return -1; |
- | |
| 1093 | }, |
1061 | }, |
| 1094 | - | ||
| 1095 | merge: function( first, second ) { |
1062 | disabled: function(elem){ |
| 1096 | // We have to loop this way because IE & Opera overwrite the length
|
- | |
| 1097 | // expando of getElementsByTagName
|
- | |
| 1098 | var i = 0, elem, pos = first.length; |
- | |
| 1099 | // Also, we need to make sure that the correct elements are being returned
|
- | |
| 1100 | // (IE returns comment nodes in a '*' query)
|
- | |
| 1101 | if ( !jQuery.support.getAll ) { |
- | |
| 1102 | while ( (elem = second[ i++ ]) != null ) |
- | |
| 1103 | if ( elem.nodeType != 8 ) |
1063 | return elem.disabled === true; |
| 1104 | first[ pos++ ] = elem; |
- | |
| 1105 | - | ||
| 1106 | } else |
- | |
| 1107 | while ( (elem = second[ i++ ]) != null ) |
- | |
| 1108 | first[ pos++ ] = elem; |
- | |
| 1109 | - | ||
| 1110 | return first; |
- | |
| 1111 | }, |
1064 | }, |
| 1112 | - | ||
| 1113 | unique: function( array ) { |
1065 | checked: function(elem){ |
| 1114 | var ret = [], done = {}; |
- | |
| 1115 | - | ||
| 1116 | try { |
- | |
| 1117 | - | ||
| 1118 | for ( var i = 0, length = array.length; i < length; i++ ) { |
- | |
| 1119 | var id = jQuery.data( array[ i ] ); |
- | |
| 1120 | - | ||
| 1121 | if ( !done[ id ] ) { |
- | |
| 1122 | done[ id ] = true; |
1066 | return elem.checked === true; |
| 1123 | ret.push( array[ i ] ); |
- | |
| 1124 | }
|
- | |
| 1125 | }
|
- | |
| 1126 | - | ||
| 1127 | } catch( e ) { |
- | |
| 1128 | ret = array; |
- | |
| 1129 | }
|
- | |
| 1130 | - | ||
| 1131 | return ret; |
- | |
| 1132 | }, |
1067 | }, |
| 1133 | - | ||
| 1134 | grep: function( elems, callback, inv ) { |
1068 | selected: function(elem){ |
| 1135 | var ret = []; |
- | |
| 1136 | - | ||
| 1137 | // Go through the array, only saving the items
|
1069 | // Accessing this property makes selected-by-default
|
| 1138 | // that pass the validator function
|
1070 | // options in Safari work properly
|
| 1139 | for ( var i = 0, length = elems.length; i < length; i++ ) |
- | |
| 1140 | if ( !inv != !callback( elems[ i ], i ) ) |
- | |
| 1141 | ret.push( elems[ i ] ); |
1071 | elem.parentNode.selectedIndex; |
| 1142 | - | ||
| 1143 | return ret; |
1072 | return elem.selected === true; |
| 1144 | }, |
1073 | }, |
| 1145 | - | ||
| 1146 | map: function( elems, callback ) { |
- | |
| 1147 | var ret = []; |
- | |
| 1148 | - | ||
| 1149 | // Go through the array, translating each of the items to their
|
- | |
| 1150 | // new value (or values).
|
- | |
| 1151 | for ( var i = 0, length = elems.length; i < length; i++ ) { |
- | |
| 1152 | var value = callback( elems[ i ], i ); |
- | |
| 1153 | - | ||
| 1154 | if ( value != null ) |
- | |
| 1155 | ret[ ret.length ] = value; |
- | |
| 1156 | }
|
- | |
| 1157 | - | ||
| 1158 | return ret.concat.apply( [], ret ); |
- | |
| 1159 | }
|
- | |
| 1160 | }); |
- | |
| 1161 | - | ||
| 1162 | // Use of jQuery.browser is deprecated.
|
- | |
| 1163 | // It's included for backwards compatibility and plugins,
|
- | |
| 1164 | // although they should work to migrate away.
|
- | |
| 1165 | - | ||
| 1166 | var userAgent = navigator.userAgent.toLowerCase(); |
- | |
| 1167 | - | ||
| 1168 | // Figure out what browser is being used
|
- | |
| 1169 | jQuery.browser = { |
- | |
| 1170 | version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1], |
- | |
| 1171 | safari: /webkit/.test( userAgent ), |
- | |
| 1172 | opera: /opera/.test( userAgent ), |
- | |
| 1173 | msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ), |
- | |
| 1174 | mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent ) |
- | |
| 1175 | }; |
- | |
| 1176 | - | ||
| 1177 | jQuery.each({ |
- | |
| 1178 | parent: function(elem){return elem.parentNode;}, |
- | |
| 1179 | parents: function(elem){return jQuery.dir(elem,"parentNode");}, |
- | |
| 1180 | next: function(elem){return jQuery.nth(elem,2,"nextSibling");}, |
- | |
| 1181 | prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}, |
- | |
| 1182 | nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}, |
- | |
| 1183 | prevAll: function(elem){return jQuery.dir(elem,"previousSibling");}, |
- | |
| 1184 | siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);}, |
- | |
| 1185 | children: function(elem){return jQuery.sibling(elem.firstChild);}, |
- | |
| 1186 | contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);} |
- | |
| 1187 | }, function(name, fn){ |
- | |
| 1188 | jQuery.fn[ name ] = function( selector ) { |
- | |
| 1189 | var ret = jQuery.map( this, fn ); |
- | |
| 1190 | - | ||
| 1191 | if ( selector && typeof selector == "string" ) |
- | |
| 1192 | ret = jQuery.multiFilter( selector, ret ); |
- | |
| 1193 | - | ||
| 1194 | return this.pushStack( jQuery.unique( ret ), name, selector ); |
- | |
| 1195 | }; |
- | |
| 1196 | }); |
- | |
| 1197 | - | ||
| 1198 | jQuery.each({ |
- | |
| 1199 | appendTo: "append", |
- | |
| 1200 | prependTo: "prepend", |
- | |
| 1201 | insertBefore: "before", |
- | |
| 1202 | insertAfter: "after", |
- | |
| 1203 | replaceAll: "replaceWith" |
- | |
| 1204 | }, function(name, original){ |
- | |
| 1205 | jQuery.fn[ name ] = function( selector ) { |
- | |
| 1206 | var ret = [], insert = jQuery( selector ); |
- | |
| 1207 | - | ||
| 1208 | for ( var i = 0, l = insert.length; i < l; i++ ) { |
- | |
| 1209 | var elems = (i > 0 ? this.clone(true) : this).get(); |
- | |
| 1210 | jQuery.fn[ original ].apply( jQuery(insert[i]), elems ); |
- | |
| 1211 | ret = ret.concat( elems ); |
- | |
| 1212 | }
|
- | |
| 1213 | - | ||
| 1214 | return this.pushStack( ret, name, selector ); |
- | |
| 1215 | }; |
- | |
| 1216 | }); |
- | |
| 1217 | - | ||
| 1218 | jQuery.each({ |
- | |
| 1219 | removeAttr: function( name ) { |
1074 | parent: function(elem){ |
| 1220 | jQuery.attr( this, name, "" ); |
- | |
| 1221 | if (this.nodeType == 1) |
- | |
| 1222 | this.removeAttribute( name ); |
1075 | return !!elem.firstChild; |
| 1223 | }, |
1076 | }, |
| 1224 | - | ||
| 1225 | addClass: function( classNames ) { |
1077 | empty: function(elem){ |
| 1226 | jQuery.className.add( this, classNames ); |
1078 | return !elem.firstChild; |
| 1227 | }, |
1079 | }, |
| 1228 | - | ||
| 1229 | removeClass: function( classNames ) { |
1080 | has: function(elem, i, match){ |
| 1230 | jQuery.className.remove( this, classNames ); |
1081 | return !!Sizzle( match[3], elem ).length; |
| 1231 | }, |
1082 | }, |
| 1232 | - | ||
| 1233 | toggleClass: function( classNames, state ) { |
1083 | header: function(elem){ |
| 1234 | if( typeof state !== "boolean" ) |
- | |
| 1235 | state = !jQuery.className.has( this, classNames ); |
1084 | return /h\d/i.test( elem.nodeName ); |
| 1236 | jQuery.className[ state ? "add" : "remove" ]( this, classNames ); |
- | |
| 1237 | }, |
1085 | }, |
| 1238 | - | ||
| 1239 | remove: function( selector ) { |
1086 | text: function(elem){ |
| 1240 | if ( !selector || jQuery.filter( selector, [ this ] ).length ) { |
- | |
| 1241 | // Prevent memory leaks
|
- | |
| 1242 | jQuery( "*", this ).add([this]).each(function(){ |
- | |
| 1243 | jQuery.event.remove(this); |
1087 | return "text" === elem.type; |
| 1244 | jQuery.removeData(this); |
- | |
| 1245 | }); |
- | |
| 1246 | if (this.parentNode) |
- | |
| 1247 | this.parentNode.removeChild( this ); |
- | |
| 1248 | }
|
- | |
| 1249 | }, |
1088 | }, |
| 1250 | - | ||
| 1251 | empty: function() { |
1089 | radio: function(elem){ |
| 1252 | // Remove element nodes and prevent memory leaks
|
- | |
| 1253 | jQuery(this).children().remove(); |
- | |
| 1254 | - | ||
| 1255 | // Remove any remaining nodes
|
- | |
| 1256 | while ( this.firstChild ) |
- | |
| 1257 | this.removeChild( this.firstChild ); |
- | |
| 1258 | }
|
- | |
| 1259 | }, function(name, fn){ |
- | |
| 1260 | jQuery.fn[ name ] = function(){ |
- | |
| 1261 | return this.each( fn, arguments ); |
1090 | return "radio" === elem.type; |
| 1262 | }; |
- | |
| 1263 | }); |
- | |
| 1264 | - | ||
| 1265 | // Helper function used by the dimensions and offset modules
|
- | |
| 1266 | function num(elem, prop) { |
- | |
| 1267 | return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0; |
- | |
| 1268 | }
|
- | |
| 1269 | var expando = "jQuery" + now(), uuid = 0, windowData = {}; |
- | |
| 1270 | - | ||
| 1271 | jQuery.extend({ |
- | |
| 1272 | cache: {}, |
- | |
| 1273 | - | ||
| 1274 | data: function( elem, name, data ) { |
- | |
| 1275 | elem = elem == window ? |
- | |
| 1276 | windowData :
|
- | |
| 1277 | elem;
|
- | |
| 1278 | - | ||
| 1279 | var id = elem[ expando ]; |
- | |
| 1280 | - | ||
| 1281 | // Compute a unique ID for the element
|
- | |
| 1282 | if ( !id ) |
- | |
| 1283 | id = elem[ expando ] = ++uuid; |
- | |
| 1284 | - | ||
| 1285 | // Only generate the data cache if we're
|
- | |
| 1286 | // trying to access or manipulate it
|
- | |
| 1287 | if ( name && !jQuery.cache[ id ] ) |
- | |
| 1288 | jQuery.cache[ id ] = {}; |
- | |
| 1289 | - | ||
| 1290 | // Prevent overriding the named cache with undefined values
|
- | |
| 1291 | if ( data !== undefined ) |
- | |
| 1292 | jQuery.cache[ id ][ name ] = data; |
- | |
| 1293 | - | ||
| 1294 | // Return the named cache data, or the ID for the element
|
- | |
| 1295 | return name ? |
- | |
| 1296 | jQuery.cache[ id ][ name ] : |
- | |
| 1297 | id;
|
- | |
| 1298 | }, |
1091 | }, |
| 1299 | - | ||
| 1300 | removeData: function( elem, name ) { |
1092 | checkbox: function(elem){ |
| 1301 | elem = elem == window ? |
- | |
| 1302 | windowData :
|
- | |
| 1303 | elem;
|
- | |
| 1304 | - | ||
| 1305 | var id = elem[ expando ]; |
- | |
| 1306 | - | ||
| 1307 | // If we want to remove a specific section of the element's data
|
- | |
| 1308 | if ( name ) { |
- | |
| 1309 | if ( jQuery.cache[ id ] ) { |
- | |
| 1310 | // Remove the section of cache data
|
- | |
| 1311 | delete jQuery.cache[ id ][ name ]; |
- | |
| 1312 | - | ||
| 1313 | // If we've removed all the data, remove the element's cache
|
- | |
| 1314 | name = ""; |
- | |
| 1315 | - | ||
| 1316 | for ( name in jQuery.cache[ id ] ) |
- | |
| 1317 | break; |
- | |
| 1318 | - | ||
| 1319 | if ( !name ) |
- | |
| 1320 | jQuery.removeData( elem ); |
1093 | return "checkbox" === elem.type; |
| 1321 | }
|
- | |
| 1322 | - | ||
| 1323 | // Otherwise, we want to remove all of the element's data
|
- | |
| 1324 | } else { |
- | |
| 1325 | // Clean up the element expando
|
- | |
| 1326 | try { |
- | |
| 1327 | delete elem[ expando ]; |
- | |
| 1328 | } catch(e){ |
- | |
| 1329 | // IE has trouble directly removing the expando
|
- | |
| 1330 | // but it's ok with using removeAttribute
|
- | |
| 1331 | if ( elem.removeAttribute ) |
- | |
| 1332 | elem.removeAttribute( expando ); |
- | |
| 1333 | }
|
- | |
| 1334 | - | ||
| 1335 | // Completely remove the data cache
|
- | |
| 1336 | delete jQuery.cache[ id ]; |
- | |
| 1337 | }
|
- | |
| 1338 | }, |
1094 | }, |
| 1339 | queue: function( elem, type, data ) { |
1095 | file: function(elem){ |
| 1340 | if ( elem ){ |
- | |
| 1341 | - | ||
| 1342 | type = (type || "fx") + "queue"; |
- | |
| 1343 | - | ||
| 1344 | var q = jQuery.data( elem, type ); |
1096 | return "file" === elem.type; |
| 1345 | - | ||
| 1346 | if ( !q || jQuery.isArray(data) ) |
- | |
| 1347 | q = jQuery.data( elem, type, jQuery.makeArray(data) ); |
- | |
| 1348 | else if( data ) |
- | |
| 1349 | q.push( data ); |
- | |
| 1350 | - | ||
| 1351 | }
|
- | |
| 1352 | return q; |
- | |
| 1353 | }, |
1097 | }, |
| - | 1098 | password: function(elem){ |
|
| - | 1099 | return "password" === elem.type; |
|
| 1354 | 1100 | }, |
|
| 1355 | dequeue: function( elem, type ){ |
1101 | submit: function(elem){ |
| 1356 | var queue = jQuery.queue( elem, type ), |
1102 | return "submit" === elem.type; |
| - | 1103 | }, |
|
| 1357 | fn = queue.shift(); |
1104 | image: function(elem){ |
| - | 1105 | return "image" === elem.type; |
|
| 1358 | 1106 | }, |
|
| 1359 | if( !type || type === "fx" ) |
1107 | reset: function(elem){ |
| 1360 | fn = queue[0]; |
1108 | return "reset" === elem.type; |
| 1361 | 1109 | }, |
|
| 1362 | if( fn !== undefined ) |
1110 | button: function(elem){ |
| - | 1111 | return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON"; |
|
| - | 1112 | }, |
|
| 1363 | fn.call(elem); |
1113 | input: function(elem){ |
| - | 1114 | return /input|select|textarea|button/i.test(elem.nodeName); |
|
| 1364 | }
|
1115 | }
|
| 1365 | }); |
- | |
| 1366 | - | ||
| 1367 | jQuery.fn.extend({ |
- | |
| 1368 | data: function( key, value ){ |
- | |
| 1369 | var parts = key.split("."); |
- | |
| 1370 | parts[1] = parts[1] ? "." + parts[1] : ""; |
- | |
| 1371 | - | ||
| 1372 | if ( value === undefined ) { |
- | |
| 1373 | var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); |
- | |
| 1374 | - | ||
| 1375 | if ( data === undefined && this.length ) |
- | |
| 1376 | data = jQuery.data( this[0], key ); |
- | |
| 1377 | - | ||
| 1378 | return data === undefined && parts[1] ? |
- | |
| 1379 | this.data( parts[0] ) : |
- | |
| 1380 | data;
|
- | |
| 1381 | } else |
- | |
| 1382 | return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){ |
- | |
| 1383 | jQuery.data( this, key, value ); |
- | |
| 1384 | }); |
- | |
| 1385 | }, |
1116 | }, |
| 1386 | - | ||
| 1387 | removeData: function( key ){ |
1117 | setFilters: { |
| 1388 | return this.each(function(){ |
1118 | first: function(elem, i){ |
| 1389 | jQuery.removeData( this, key ); |
1119 | return i === 0; |
| 1390 | }); |
- | |
| 1391 | }, |
1120 | }, |
| 1392 | queue: function(type, data){ |
1121 | last: function(elem, i, match, array){ |
| 1393 | if ( typeof type !== "string" ) { |
1122 | return i === array.length - 1; |
| - | 1123 | }, |
|
| - | 1124 | even: function(elem, i){ |
|
| 1394 | data = type; |
1125 | return i % 2 === 0; |
| - | 1126 | }, |
|
| - | 1127 | odd: function(elem, i){ |
|
| 1395 | type = "fx"; |
1128 | return i % 2 === 1; |
| - | 1129 | }, |
|
| - | 1130 | lt: function(elem, i, match){ |
|
| - | 1131 | return i < match[3] - 0; |
|
| - | 1132 | }, |
|
| - | 1133 | gt: function(elem, i, match){ |
|
| - | 1134 | return i > match[3] - 0; |
|
| - | 1135 | }, |
|
| - | 1136 | nth: function(elem, i, match){ |
|
| - | 1137 | return match[3] - 0 == i; |
|
| - | 1138 | }, |
|
| - | 1139 | eq: function(elem, i, match){ |
|
| - | 1140 | return match[3] - 0 == i; |
|
| 1396 | }
|
1141 | }
|
| - | 1142 | }, |
|
| - | 1143 | filter: { |
|
| - | 1144 | PSEUDO: function(elem, match, i, array){ |
|
| - | 1145 | var name = match[1], filter = Expr.filters[ name ]; |
|
| 1397 | 1146 | ||
| 1398 | if ( data === undefined ) |
1147 | if ( filter ) { |
| 1399 | return jQuery.queue( this[0], type ); |
1148 | return filter( elem, i, match, array ); |
| - | 1149 | } else if ( name === "contains" ) { |
|
| - | 1150 | return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0; |
|
| - | 1151 | } else if ( name === "not" ) { |
|
| - | 1152 | var not = match[3]; |
|
| 1400 | 1153 | ||
| 1401 | return this.each(function(){ |
1154 | for ( var i = 0, l = not.length; i < l; i++ ) { |
| 1402 | var queue = jQuery.queue( this, type, data ); |
1155 | if ( not[i] === elem ) { |
| - | 1156 | return false; |
|
| - | 1157 | }
|
|
| - | 1158 | }
|
|
| 1403 | 1159 | ||
| 1404 | if( type == "fx" && queue.length == 1 ) |
- | |
| 1405 | queue[0].call(this); |
1160 | return true; |
| 1406 | }); |
1161 | }
|
| 1407 | }, |
1162 | }, |
| 1408 | dequeue: function(type){ |
1163 | CHILD: function(elem, match){ |
| 1409 | return this.each(function(){ |
1164 | var type = match[1], node = elem; |
| 1410 | jQuery.dequeue( this, type ); |
1165 | switch (type) { |
| 1411 | }); |
1166 | case 'only': |
| - | 1167 | case 'first': |
|
| - | 1168 | while (node = node.previousSibling) { |
|
| - | 1169 | if ( node.nodeType === 1 ) return false; |
|
| 1412 | }
|
1170 | }
|
| 1413 | });/*! |
- | |
| 1414 | * Sizzle CSS Selector Engine - v0.9.3
|
1171 | if ( type == 'first') return true; |
| 1415 | * Copyright 2009, The Dojo Foundation
|
1172 | node = elem; |
| - | 1173 | case 'last': |
|
| 1416 | * Released under the MIT, BSD, and GPL Licenses.
|
1174 | while (node = node.nextSibling) { |
| 1417 | * More information: http://sizzlejs.com/
|
1175 | if ( node.nodeType === 1 ) return false; |
| 1418 | */
|
1176 | }
|
| 1419 | (function(){ |
1177 | return true; |
| 1420 | - | ||
| 1421 | var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g, |
- | |
| 1422 | done = 0, |
1178 | case 'nth': |
| 1423 | toString = Object.prototype.toString; |
1179 | var first = match[2], last = match[3]; |
| 1424 | 1180 | ||
| 1425 | var Sizzle = function(selector, context, results, seed) { |
1181 | if ( first == 1 && last == 0 ) { |
| 1426 | results = results || []; |
1182 | return true; |
| 1427 | context = context || document; |
1183 | }
|
| 1428 | 1184 | ||
| 1429 | if ( context.nodeType !== 1 && context.nodeType !== 9 ) |
1185 | var doneName = match[0], |
| 1430 | return []; |
1186 | parent = elem.parentNode; |
| 1431 | 1187 | ||
| 1432 | if ( !selector || typeof selector !== "string" ) { |
1188 | if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { |
| 1433 | return results; |
1189 | var count = 0; |
| - | 1190 | for ( node = parent.firstChild; node; node = node.nextSibling ) { |
|
| - | 1191 | if ( node.nodeType === 1 ) { |
|
| - | 1192 | node.nodeIndex = ++count; |
|
| - | 1193 | }
|
|
| - | 1194 | }
|
|
| - | 1195 | parent.sizcache = doneName; |
|
| 1434 | }
|
1196 | }
|
| 1435 | 1197 | ||
| - | 1198 | var diff = elem.nodeIndex - last; |
|
| - | 1199 | if ( first == 0 ) { |
|
| - | 1200 | return diff == 0; |
|
| - | 1201 | } else { |
|
| - | 1202 | return ( diff % first == 0 && diff / first >= 0 ); |
|
| - | 1203 | }
|
|
| - | 1204 | }
|
|
| - | 1205 | }, |
|
| - | 1206 | ID: function(elem, match){ |
|
| - | 1207 | return elem.nodeType === 1 && elem.getAttribute("id") === match; |
|
| - | 1208 | }, |
|
| - | 1209 | TAG: function(elem, match){ |
|
| 1436 | var parts = [], m, set, checkSet, check, mode, extra, prune = true; |
1210 | return (match === "*" && elem.nodeType === 1) || elem.nodeName === match; |
| 1437 | 1211 | }, |
|
| - | 1212 | CLASS: function(elem, match){ |
|
| 1438 | // Reset the position of the chunker regexp (start from head)
|
1213 | return (" " + (elem.className || elem.getAttribute("class")) + " ") |
| - | 1214 | .indexOf( match ) > -1; |
|
| - | 1215 | }, |
|
| - | 1216 | ATTR: function(elem, match){ |
|
| - | 1217 | var name = match[1], |
|
| - | 1218 | result = Expr.attrHandle[ name ] ? |
|
| - | 1219 | Expr.attrHandle[ name ]( elem ) : |
|
| - | 1220 | elem[ name ] != null ? |
|
| 1439 | chunker.lastIndex = 0; |
1221 | elem[ name ] : |
| - | 1222 | elem.getAttribute( name ), |
|
| - | 1223 | value = result + "", |
|
| - | 1224 | type = match[2], |
|
| - | 1225 | check = match[4]; |
|
| 1440 | 1226 | ||
| - | 1227 | return result == null ? |
|
| - | 1228 | type === "!=" : |
|
| - | 1229 | type === "=" ? |
|
| - | 1230 | value === check : |
|
| - | 1231 | type === "*=" ? |
|
| - | 1232 | value.indexOf(check) >= 0 : |
|
| - | 1233 | type === "~=" ? |
|
| 1441 | while ( (m = chunker.exec(selector)) !== null ) { |
1234 | (" " + value + " ").indexOf(check) >= 0 : |
| - | 1235 | !check ? |
|
| - | 1236 | value && result !== false : |
|
| - | 1237 | type === "!=" ? |
|
| - | 1238 | value != check : |
|
| - | 1239 | type === "^=" ? |
|
| - | 1240 | value.indexOf(check) === 0 : |
|
| - | 1241 | type === "$=" ? |
|
| - | 1242 | value.substr(value.length - check.length) === check : |
|
| 1442 | parts.push( m[1] ); |
1243 | type === "|=" ? |
| - | 1244 | value === check || value.substr(0, check.length + 1) === check + "-" : |
|
| - | 1245 | false; |
|
| - | 1246 | }, |
|
| - | 1247 | POS: function(elem, match, i, array){ |
|
| - | 1248 | var name = match[2], filter = Expr.setFilters[ name ]; |
|
| 1443 | 1249 | ||
| 1444 | if ( m[2] ) { |
1250 | if ( filter ) { |
| 1445 | extra = RegExp.rightContext; |
1251 | return filter( elem, i, match, array ); |
| 1446 | break; |
1252 | }
|
| 1447 | }
|
1253 | }
|
| 1448 | }
|
1254 | }
|
| - | 1255 | }; |
|
| 1449 | 1256 | ||
| 1450 | if ( parts.length > 1 && origPOS.exec( selector ) ) { |
- | |
| 1451 | if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { |
- | |
| 1452 | set = posProcess( parts[0] + parts[1], context ); |
- | |
| 1453 | } else { |
- | |
| 1454 | set = Expr.relative[ parts[0] ] ? |
1257 | var origPOS = Expr.match.POS; |
| 1455 | [ context ] : |
- | |
| 1456 | Sizzle( parts.shift(), context ); |
- | |
| 1457 | 1258 | ||
| 1458 | while ( parts.length ) { |
1259 | for ( var type in Expr.match ) { |
| 1459 | selector = parts.shift(); |
1260 | Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source ); |
| - | 1261 | }
|
|
| 1460 | 1262 | ||
| 1461 | if ( Expr.relative[ selector ] ) |
1263 | var makeArray = function(array, results) { |
| 1462 | selector += parts.shift(); |
1264 | array = Array.prototype.slice.call( array ); |
| 1463 | 1265 | ||
| - | 1266 | if ( results ) { |
|
| 1464 | set = posProcess( selector, set ); |
1267 | results.push.apply( results, array ); |
| 1465 | }
|
1268 | return results; |
| 1466 | }
|
1269 | }
|
| 1467 | } else { |
- | |
| 1468 | var ret = seed ? |
- | |
| 1469 | { expr: parts.pop(), set: makeArray(seed) } : |
- | |
| 1470 | Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) ); |
- | |
| 1471 | set = Sizzle.filter( ret.expr, ret.set ); |
- | |
| 1472 | 1270 | ||
| 1473 | if ( parts.length > 0 ) { |
- | |
| 1474 | checkSet = makeArray(set); |
- | |
| 1475 | } else { |
- | |
| 1476 | prune = false; |
1271 | return array; |
| 1477 | }
|
1272 | }; |
| 1478 | 1273 | ||
| - | 1274 | // Perform a simple check to determine if the browser is capable of
|
|
| 1479 | while ( parts.length ) { |
1275 | // converting a NodeList to an array using builtin methods.
|
| - | 1276 | try { |
|
| 1480 | var cur = parts.pop(), pop = cur; |
1277 | Array.prototype.slice.call( document.documentElement.childNodes ); |
| 1481 | 1278 | ||
| - | 1279 | // Provide a fallback method if it does not work
|
|
| - | 1280 | } catch(e){ |
|
| 1482 | if ( !Expr.relative[ cur ] ) { |
1281 | makeArray = function(array, results) { |
| 1483 | cur = ""; |
1282 | var ret = results || []; |
| - | 1283 | ||
| - | 1284 | if ( toString.call(array) === "[object Array]" ) { |
|
| - | 1285 | Array.prototype.push.apply( ret, array ); |
|
| 1484 | } else { |
1286 | } else { |
| - | 1287 | if ( typeof array.length === "number" ) { |
|
| - | 1288 | for ( var i = 0, l = array.length; i < l; i++ ) { |
|
| 1485 | pop = parts.pop(); |
1289 | ret.push( array[i] ); |
| 1486 | }
|
1290 | }
|
| 1487 | 1291 | } else { |
|
| 1488 | if ( pop == null ) { |
1292 | for ( var i = 0; array[i]; i++ ) { |
| 1489 | pop = context; |
1293 | ret.push( array[i] ); |
| 1490 | }
|
1294 | }
|
| 1491 | - | ||
| 1492 | Expr.relative[ cur ]( checkSet, pop, isXML(context) ); |
- | |
| 1493 | }
|
1295 | }
|
| 1494 | }
|
1296 | }
|
| 1495 | 1297 | ||
| 1496 | if ( !checkSet ) { |
1298 | return ret; |
| 1497 | checkSet = set; |
1299 | }; |
| 1498 | }
|
1300 | }
|
| 1499 | 1301 | ||
| 1500 | if ( !checkSet ) { |
1302 | var sortOrder; |
| 1501 | throw "Syntax error, unrecognized expression: " + (cur || selector); |
- | |
| 1502 | }
|
- | |
| 1503 | 1303 | ||
| 1504 | if ( toString.call(checkSet) === "[object Array]" ) { |
1304 | if ( document.documentElement.compareDocumentPosition ) { |
| 1505 | if ( !prune ) { |
- | |
| 1506 | results.push.apply( results, checkSet ); |
- | |
| 1507 | } else if ( context.nodeType === 1 ) { |
1305 | sortOrder = function( a, b ) { |
| 1508 | for ( var i = 0; checkSet[i] != null; i++ ) { |
1306 | var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1; |
| 1509 | if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { |
- | |
| 1510 | results.push( set[i] ); |
- | |
| 1511 | }
|
- | |
| 1512 | }
|
- | |
| 1513 | } else { |
1307 | if ( ret === 0 ) { |
| 1514 | for ( var i = 0; checkSet[i] != null; i++ ) { |
- | |
| 1515 | if ( checkSet[i] && checkSet[i].nodeType === 1 ) { |
- | |
| 1516 | results.push( set[i] ); |
1308 | hasDuplicate = true; |
| 1517 | }
|
1309 | }
|
| - | 1310 | return ret; |
|
| - | 1311 | }; |
|
| - | 1312 | } else if ( "sourceIndex" in document.documentElement ) { |
|
| - | 1313 | sortOrder = function( a, b ) { |
|
| - | 1314 | var ret = a.sourceIndex - b.sourceIndex; |
|
| - | 1315 | if ( ret === 0 ) { |
|
| - | 1316 | hasDuplicate = true; |
|
| 1518 | }
|
1317 | }
|
| - | 1318 | return ret; |
|
| - | 1319 | }; |
|
| - | 1320 | } else if ( document.createRange ) { |
|
| - | 1321 | sortOrder = function( a, b ) { |
|
| - | 1322 | var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange(); |
|
| - | 1323 | aRange.selectNode(a); |
|
| - | 1324 | aRange.collapse(true); |
|
| - | 1325 | bRange.selectNode(b); |
|
| - | 1326 | bRange.collapse(true); |
|
| - | 1327 | var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange); |
|
| - | 1328 | if ( ret === 0 ) { |
|
| - | 1329 | hasDuplicate = true; |
|
| 1519 | }
|
1330 | }
|
| 1520 | } else { |
1331 | return ret; |
| 1521 | makeArray( checkSet, results ); |
1332 | }; |
| 1522 | }
|
1333 | }
|
| 1523 | 1334 | ||
| - | 1335 | // Check to see if the browser returns elements by name when
|
|
| - | 1336 | // querying by getElementById (and provide a workaround)
|
|
| 1524 | if ( extra ) { |
1337 | (function(){ |
| - | 1338 | // We're going to inject a fake input element with a specified name
|
|
| - | 1339 | var form = document.createElement("div"), |
|
| 1525 | Sizzle( extra, context, results, seed ); |
1340 | id = "script" + (new Date).getTime(); |
| - | 1341 | form.innerHTML = "<a name='" + id + "'/>"; |
|
| 1526 | 1342 | ||
| 1527 | if ( sortOrder ) { |
1343 | // Inject it into the root element, check its status, and remove it quickly
|
| 1528 | hasDuplicate = false; |
1344 | var root = document.documentElement; |
| 1529 | results.sort(sortOrder); |
1345 | root.insertBefore( form, root.firstChild ); |
| 1530 | 1346 | ||
| - | 1347 | // The workaround has to do additional checks after a getElementById
|
|
| - | 1348 | // Which slows things down for other browsers (hence the branching)
|
|
| 1531 | if ( hasDuplicate ) { |
1349 | if ( !!document.getElementById( id ) ) { |
| 1532 | for ( var i = 1; i < results.length; i++ ) { |
1350 | Expr.find.ID = function(match, context, isXML){ |
| 1533 | if ( results[i] === results[i-1] ) { |
1351 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
| 1534 | results.splice(i--, 1); |
1352 | var m = context.getElementById(match[1]); |
| - | 1353 | return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; |
|
| 1535 | }
|
1354 | }
|
| - | 1355 | }; |
|
| - | 1356 | ||
| - | 1357 | Expr.filter.ID = function(elem, match){ |
|
| - | 1358 | var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); |
|
| - | 1359 | return elem.nodeType === 1 && node && node.nodeValue === match; |
|
| - | 1360 | }; |
|
| 1536 | }
|
1361 | }
|
| - | 1362 | ||
| - | 1363 | root.removeChild( form ); |
|
| - | 1364 | })(); |
|
| - | 1365 | ||
| - | 1366 | (function(){ |
|
| - | 1367 | // Check to see if the browser returns only elements
|
|
| - | 1368 | // when doing getElementsByTagName("*")
|
|
| - | 1369 | ||
| - | 1370 | // Create a fake element
|
|
| - | 1371 | var div = document.createElement("div"); |
|
| - | 1372 | div.appendChild( document.createComment("") ); |
|
| - | 1373 | ||
| - | 1374 | // Make sure no comments are found
|
|
| - | 1375 | if ( div.getElementsByTagName("*").length > 0 ) { |
|
| - | 1376 | Expr.find.TAG = function(match, context){ |
|
| - | 1377 | var results = context.getElementsByTagName(match[1]); |
|
| - | 1378 | ||
| - | 1379 | // Filter out possible comments
|
|
| - | 1380 | if ( match[1] === "*" ) { |
|
| - | 1381 | var tmp = []; |
|
| - | 1382 | ||
| - | 1383 | for ( var i = 0; results[i]; i++ ) { |
|
| - | 1384 | if ( results[i].nodeType === 1 ) { |
|
| - | 1385 | tmp.push( results[i] ); |
|
| 1537 | }
|
1386 | }
|
| 1538 | }
|
1387 | }
|
| - | 1388 | ||
| - | 1389 | results = tmp; |
|
| 1539 | }
|
1390 | }
|
| 1540 | 1391 | ||
| 1541 | return results; |
1392 | return results; |
| 1542 | }; |
1393 | }; |
| - | 1394 | }
|
|
| 1543 | 1395 | ||
| - | 1396 | // Check to see if an attribute returns normalized href attributes
|
|
| - | 1397 | div.innerHTML = "<a href='#'></a>"; |
|
| - | 1398 | if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && |
|
| - | 1399 | div.firstChild.getAttribute("href") !== "#" ) { |
|
| 1544 | Sizzle.matches = function(expr, set){ |
1400 | Expr.attrHandle.href = function(elem){ |
| 1545 | return Sizzle(expr, null, null, set); |
1401 | return elem.getAttribute("href", 2); |
| 1546 | }; |
1402 | }; |
| - | 1403 | }
|
|
| - | 1404 | })(); |
|
| 1547 | 1405 | ||
| - | 1406 | if ( document.querySelectorAll ) (function(){ |
|
| 1548 | Sizzle.find = function(expr, context, isXML){ |
1407 | var oldSizzle = Sizzle, div = document.createElement("div"); |
| 1549 | var set, match; |
1408 | div.innerHTML = "<p class='TEST'></p>"; |
| 1550 | 1409 | ||
| - | 1410 | // Safari can't handle uppercase or unicode characters when
|
|
| 1551 | if ( !expr ) { |
1411 | // in quirks mode.
|
| - | 1412 | if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { |
|
| 1552 | return []; |
1413 | return; |
| 1553 | }
|
1414 | }
|
| 1554 | 1415 | ||
| 1555 | for ( var i = 0, l = Expr.order.length; i < l; i++ ) { |
- | |
| 1556 | var type = Expr.order[i], match; |
- | |
| 1557 | - | ||
| 1558 | if ( (match = Expr.match[ type ].exec( expr )) ) { |
1416 | Sizzle = function(query, context, extra, seed){ |
| 1559 | var left = RegExp.leftContext; |
1417 | context = context || document; |
| 1560 | 1418 | ||
| 1561 | if ( left.substr( left.length - 1 ) !== "\\" ) { |
1419 | // Only use querySelectorAll on non-XML documents
|
| 1562 | match[1] = (match[1] || "").replace(/\\/g, ""); |
1420 | // (ID selectors don't work in non-HTML documents)
|
| 1563 | set = Expr.find[ type ]( match, context, isXML ); |
1421 | if ( !seed && context.nodeType === 9 && !isXML(context) ) { |
| 1564 | if ( set != null ) { |
1422 | try { |
| 1565 | expr = expr.replace( Expr.match[ type ], "" ); |
1423 | return makeArray( context.querySelectorAll(query), extra ); |
| 1566 | break; |
1424 | } catch(e){} |
| 1567 | }
|
- | |
| 1568 | }
|
- | |
| 1569 | }
|
- | |
| 1570 | }
|
1425 | }
|
| 1571 | 1426 | ||
| - | 1427 | return oldSizzle(query, context, extra, seed); |
|
| - | 1428 | }; |
|
| - | 1429 | ||
| 1572 | if ( !set ) { |
1430 | for ( var prop in oldSizzle ) { |
| 1573 | set = context.getElementsByTagName("*"); |
1431 | Sizzle[ prop ] = oldSizzle[ prop ]; |
| 1574 | }
|
1432 | }
|
| - | 1433 | })(); |
|
| 1575 | 1434 | ||
| - | 1435 | if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){ |
|
| 1576 | return {set: set, expr: expr}; |
1436 | var div = document.createElement("div"); |
| 1577 | }; |
- | |
| - | 1437 | div.innerHTML = "<div class='test e'></div><div class='test'></div>"; |
|
| 1578 | 1438 | ||
| 1579 | Sizzle.filter = function(expr, set, inplace, not){ |
1439 | // Opera can't find a second classname (in 9.6)
|
| 1580 | var old = expr, result = [], curLoop = set, match, anyFound, |
1440 | if ( div.getElementsByClassName("e").length === 0 ) |
| 1581 | isXMLFilter = set && set[0] && isXML(set[0]); |
1441 | return; |
| 1582 | 1442 | ||
| 1583 | while ( expr && set.length ) { |
- | |
| 1584 | for ( var type in Expr.filter ) { |
- | |
| 1585 | if ( (match = Expr.match[ type ].exec( expr )) != null ) { |
1443 | // Safari caches class attributes, doesn't catch changes (in 3.2)
|
| 1586 | var filter = Expr.filter[ type ], found, item; |
- | |
| 1587 | anyFound = false; |
1444 | div.lastChild.className = "e"; |
| 1588 | 1445 | ||
| 1589 | if ( curLoop == result ) { |
1446 | if ( div.getElementsByClassName("e").length === 1 ) |
| 1590 | result = []; |
1447 | return; |
| 1591 | }
|
- | |
| 1592 | 1448 | ||
| 1593 | if ( Expr.preFilter[ type ] ) { |
1449 | Expr.order.splice(1, 0, "CLASS"); |
| - | 1450 | Expr.find.CLASS = function(match, context, isXML) { |
|
| 1594 | match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); |
1451 | if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { |
| - | 1452 | return context.getElementsByClassName(match[1]); |
|
| - | 1453 | }
|
|
| - | 1454 | }; |
|
| - | 1455 | })(); |
|
| 1595 | 1456 | ||
| - | 1457 | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
|
| - | 1458 | var sibDir = dir == "previousSibling" && !isXML; |
|
| - | 1459 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
|
| - | 1460 | var elem = checkSet[i]; |
|
| 1596 | if ( !match ) { |
1461 | if ( elem ) { |
| 1597 | anyFound = found = true; |
1462 | if ( sibDir && elem.nodeType === 1 ){ |
| 1598 | } else if ( match === true ) { |
1463 | elem.sizcache = doneName; |
| 1599 | continue; |
1464 | elem.sizset = i; |
| 1600 | }
|
1465 | }
|
| - | 1466 | elem = elem[dir]; |
|
| - | 1467 | var match = false; |
|
| - | 1468 | ||
| - | 1469 | while ( elem ) { |
|
| - | 1470 | if ( elem.sizcache === doneName ) { |
|
| - | 1471 | match = checkSet[elem.sizset]; |
|
| - | 1472 | break; |
|
| 1601 | }
|
1473 | }
|
| 1602 | 1474 | ||
| 1603 | if ( match ) { |
1475 | if ( elem.nodeType === 1 && !isXML ){ |
| 1604 | for ( var i = 0; (item = curLoop[i]) != null; i++ ) { |
1476 | elem.sizcache = doneName; |
| 1605 | if ( item ) { |
1477 | elem.sizset = i; |
| 1606 | found = filter( item, match, i, curLoop ); |
- | |
| 1607 | var pass = not ^ !!found; |
1478 | }
|
| 1608 | 1479 | ||
| 1609 | if ( inplace && found != null ) { |
1480 | if ( elem.nodeName === cur ) { |
| 1610 | if ( pass ) { |
- | |
| 1611 | anyFound = true; |
1481 | match = elem; |
| 1612 | } else { |
1482 | break; |
| 1613 | curLoop[i] = false; |
- | |
| 1614 | }
|
1483 | }
|
| - | 1484 | ||
| 1615 | } else if ( pass ) { |
1485 | elem = elem[dir]; |
| 1616 | result.push( item ); |
- | |
| 1617 | anyFound = true; |
- | |
| 1618 | }
|
1486 | }
|
| - | 1487 | ||
| - | 1488 | checkSet[i] = match; |
|
| 1619 | }
|
1489 | }
|
| 1620 | }
|
1490 | }
|
| 1621 | }
|
1491 | }
|
| 1622 | 1492 | ||
| - | 1493 | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
|
| - | 1494 | var sibDir = dir == "previousSibling" && !isXML; |
|
| - | 1495 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
|
| 1623 | if ( found !== undefined ) { |
1496 | var elem = checkSet[i]; |
| 1624 | if ( !inplace ) { |
1497 | if ( elem ) { |
| - | 1498 | if ( sibDir && elem.nodeType === 1 ) { |
|
| 1625 | curLoop = result; |
1499 | elem.sizcache = doneName; |
| - | 1500 | elem.sizset = i; |
|
| 1626 | }
|
1501 | }
|
| - | 1502 | elem = elem[dir]; |
|
| - | 1503 | var match = false; |
|
| 1627 | 1504 | ||
| - | 1505 | while ( elem ) { |
|
| 1628 | expr = expr.replace( Expr.match[ type ], "" ); |
1506 | if ( elem.sizcache === doneName ) { |
| - | 1507 | match = checkSet[elem.sizset]; |
|
| - | 1508 | break; |
|
| - | 1509 | }
|
|
| 1629 | 1510 | ||
| - | 1511 | if ( elem.nodeType === 1 ) { |
|
| 1630 | if ( !anyFound ) { |
1512 | if ( !isXML ) { |
| - | 1513 | elem.sizcache = doneName; |
|
| - | 1514 | elem.sizset = i; |
|
| - | 1515 | }
|
|
| - | 1516 | if ( typeof cur !== "string" ) { |
|
| - | 1517 | if ( elem === cur ) { |
|
| - | 1518 | match = true; |
|
| 1631 | return []; |
1519 | break; |
| 1632 | }
|
1520 | }
|
| 1633 | 1521 | ||
| - | 1522 | } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { |
|
| - | 1523 | match = elem; |
|
| 1634 | break; |
1524 | break; |
| 1635 | }
|
1525 | }
|
| 1636 | }
|
1526 | }
|
| - | 1527 | ||
| - | 1528 | elem = elem[dir]; |
|
| 1637 | }
|
1529 | }
|
| 1638 | 1530 | ||
| 1639 | // Improper expression
|
- | |
| 1640 | if ( expr == old ) { |
1531 | checkSet[i] = match; |
| 1641 | if ( anyFound == null ) { |
- | |
| 1642 | throw "Syntax error, unrecognized expression: " + expr; |
- | |
| 1643 | } else { |
- | |
| 1644 | break; |
- | |
| 1645 | }
|
1532 | }
|
| 1646 | }
|
1533 | }
|
| 1647 | - | ||
| 1648 | old = expr; |
- | |
| 1649 | }
|
1534 | }
|
| 1650 | 1535 | ||
| - | 1536 | var contains = document.compareDocumentPosition ? function(a, b){ |
|
| - | 1537 | return a.compareDocumentPosition(b) & 16; |
|
| 1651 | return curLoop; |
1538 | } : function(a, b){ |
| - | 1539 | return a !== b && (a.contains ? a.contains(b) : true); |
|
| 1652 | }; |
1540 | }; |
| 1653 | 1541 | ||
| 1654 | var Expr = Sizzle.selectors = { |
1542 | var isXML = function(elem){ |
| 1655 | order: [ "ID", "NAME", "TAG" ], |
- | |
| 1656 | match: { |
- | |
| 1657 | ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, |
- | |
| 1658 | CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, |
- | |
| 1659 | NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/, |
- | |
| 1660 | ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/, |
- | |
| 1661 | TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/, |
- | |
| 1662 | CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/, |
1543 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
| 1663 | POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/, |
1544 | !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML"; |
| 1664 | PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/ |
- | |
| 1665 | }, |
- | |
| 1666 | attrMap: { |
- | |
| 1667 | "class": "className", |
- | |
| 1668 | "for": "htmlFor" |
- | |
| 1669 | }, |
- | |
| 1670 | attrHandle: { |
- | |
| 1671 | href: function(elem){ |
- | |
| 1672 | return elem.getAttribute("href"); |
- | |
| 1673 | }
|
- | |
| 1674 | }, |
1545 | }; |
| 1675 | relative: { |
- | |
| 1676 | "+": function(checkSet, part, isXML){ |
- | |
| 1677 | var isPartStr = typeof part === "string", |
- | |
| 1678 | isTag = isPartStr && !/\W/.test(part), |
- | |
| 1679 | isPartStrNotTag = isPartStr && !isTag; |
- | |
| 1680 | 1546 | ||
| - | 1547 | var posProcess = function(selector, context){ |
|
| 1681 | if ( isTag && !isXML ) { |
1548 | var tmpSet = [], later = "", match, |
| - | 1549 | root = context.nodeType ? [context] : context; |
|
| - | 1550 | ||
| - | 1551 | // Position selectors must be done after the filter
|
|
| - | 1552 | // And so must :not(positional) so we move all PSEUDOs to the end
|
|
| - | 1553 | while ( (match = Expr.match.PSEUDO.exec( selector )) ) { |
|
| 1682 | part = part.toUpperCase(); |
1554 | later += match[0]; |
| - | 1555 | selector = selector.replace( Expr.match.PSEUDO, "" ); |
|
| 1683 | }
|
1556 | }
|
| 1684 | 1557 | ||
| 1685 | for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { |
1558 | selector = Expr.relative[selector] ? selector + "*" : selector; |
| 1686 | if ( (elem = checkSet[i]) ) { |
- | |
| 1687 | while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} |
- | |
| 1688 | 1559 | ||
| 1689 | checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ? |
1560 | for ( var i = 0, l = root.length; i < l; i++ ) { |
| 1690 | elem || false : |
- | |
| 1691 | elem === part; |
1561 | Sizzle( selector, root[i], tmpSet ); |
| 1692 | }
|
- | |
| 1693 | }
|
1562 | }
|
| 1694 | 1563 | ||
| 1695 | if ( isPartStrNotTag ) { |
- | |
| 1696 | Sizzle.filter( part, checkSet, true ); |
1564 | return Sizzle.filter( later, tmpSet ); |
| 1697 | }
|
- | |
| 1698 | }, |
1565 | }; |
| 1699 | ">": function(checkSet, part, isXML){ |
- | |
| 1700 | var isPartStr = typeof part === "string"; |
- | |
| 1701 | 1566 | ||
| - | 1567 | // EXPOSE
|
|
| - | 1568 | jQuery.find = Sizzle; |
|
| 1702 | if ( isPartStr && !/\W/.test(part) ) { |
1569 | jQuery.expr = Sizzle.selectors; |
| 1703 | part = isXML ? part : part.toUpperCase(); |
1570 | jQuery.expr[":"] = jQuery.expr.filters; |
| 1704 | 1571 | ||
| 1705 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
1572 | Sizzle.selectors.filters.hidden = function(elem){ |
| 1706 | var elem = checkSet[i]; |
- | |
| 1707 | if ( elem ) { |
- | |
| 1708 | var parent = elem.parentNode; |
- | |
| 1709 | checkSet[i] = parent.nodeName === part ? parent : false; |
- | |
| 1710 | }
|
- | |
| 1711 | }
|
- | |
| 1712 | } else { |
- | |
| 1713 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
1573 | return elem.offsetWidth === 0 && elem.offsetHeight === 0; |
| 1714 | var elem = checkSet[i]; |
- | |
| 1715 | if ( elem ) { |
- | |
| 1716 | checkSet[i] = isPartStr ? |
- | |
| 1717 | elem.parentNode : |
- | |
| 1718 | elem.parentNode === part; |
- | |
| 1719 | }
|
- | |
| 1720 | }
|
1574 | }; |
| 1721 | 1575 | ||
| 1722 | if ( isPartStr ) { |
1576 | Sizzle.selectors.filters.visible = function(elem){ |
| 1723 | Sizzle.filter( part, checkSet, true ); |
1577 | return elem.offsetWidth > 0 || elem.offsetHeight > 0; |
| 1724 | }
|
- | |
| 1725 | }
|
1578 | }; |
| 1726 | }, |
1579 | |
| - | 1580 | Sizzle.selectors.filters.animated = function(elem){ |
|
| 1727 | "": function(checkSet, part, isXML){ |
1581 | return jQuery.grep(jQuery.timers, function(fn){ |
| 1728 | var doneName = done++, checkFn = dirCheck; |
1582 | return elem === fn.elem; |
| - | 1583 | }).length; |
|
| - | 1584 | }; |
|
| 1729 | 1585 | ||
| - | 1586 | jQuery.filter = jQuery.multiFilter = function( expr, elems, not ) { |
|
| 1730 | if ( !part.match(/\W/) ) { |
1587 | if ( not ) { |
| 1731 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
- | |
| 1732 | checkFn = dirNodeCheck; |
1588 | expr = ":not(" + expr + ")"; |
| 1733 | }
|
1589 | }
|
| 1734 | 1590 | ||
| 1735 | checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML); |
1591 | return Sizzle.matches(expr, elems); |
| 1736 | }, |
1592 | }; |
| 1737 | "~": function(checkSet, part, isXML){ |
- | |
| 1738 | var doneName = done++, checkFn = dirCheck; |
- | |
| 1739 | 1593 | ||
| 1740 | if ( typeof part === "string" && !part.match(/\W/) ) { |
1594 | jQuery.dir = function( elem, dir ){ |
| 1741 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
1595 | var matched = [], cur = elem[dir]; |
| - | 1596 | while ( cur && cur != document ) { |
|
| - | 1597 | if ( cur.nodeType == 1 ) |
|
| - | 1598 | matched.push( cur ); |
|
| 1742 | checkFn = dirNodeCheck; |
1599 | cur = cur[dir]; |
| 1743 | }
|
1600 | }
|
| - | 1601 | return matched; |
|
| - | 1602 | }; |
|
| 1744 | 1603 | ||
| 1745 | checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML); |
- | |
| 1746 | }
|
- | |
| 1747 | }, |
- | |
| 1748 | find: { |
- | |
| 1749 | ID: function(match, context, isXML){ |
1604 | jQuery.nth = function(cur, result, dir, elem){ |
| 1750 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
- | |
| 1751 | var m = context.getElementById(match[1]); |
- | |
| 1752 | return m ? [m] : []; |
1605 | result = result || 1; |
| 1753 | }
|
- | |
| 1754 | }, |
1606 | var num = 0; |
| 1755 | NAME: function(match, context, isXML){ |
- | |
| 1756 | if ( typeof context.getElementsByName !== "undefined" ) { |
- | |
| 1757 | var ret = [], results = context.getElementsByName(match[1]); |
- | |
| 1758 | 1607 | ||
| 1759 | for ( var i = 0, l = results.length; i < l; i++ ) { |
1608 | for ( ; cur; cur = cur[dir] ) |
| 1760 | if ( results[i].getAttribute("name") === match[1] ) { |
1609 | if ( cur.nodeType == 1 && ++num == result ) |
| 1761 | ret.push( results[i] ); |
- | |
| 1762 | }
|
1610 | break; |
| 1763 | }
|
- | |
| 1764 | 1611 | ||
| 1765 | return ret.length === 0 ? null : ret; |
1612 | return cur; |
| 1766 | }
|
- | |
| 1767 | }, |
- | |
| 1768 | TAG: function(match, context){ |
- | |
| 1769 | return context.getElementsByTagName(match[1]); |
- | |
| 1770 | }
|
- | |
| 1771 | }, |
1613 | }; |
| 1772 | preFilter: { |
- | |
| 1773 | CLASS: function(match, curLoop, inplace, result, not, isXML){ |
- | |
| 1774 | match = " " + match[1].replace(/\\/g, "") + " "; |
- | |
| 1775 | 1614 | ||
| 1776 | if ( isXML ) { |
1615 | jQuery.sibling = function(n, elem){ |
| 1777 | return match; |
1616 | var r = []; |
| 1778 | }
|
- | |
| 1779 | 1617 | ||
| 1780 | for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { |
1618 | for ( ; n; n = n.nextSibling ) { |
| 1781 | if ( elem ) { |
- | |
| 1782 | if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) { |
- | |
| 1783 | if ( !inplace ) |
1619 | if ( n.nodeType == 1 && n != elem ) |
| 1784 | result.push( elem ); |
1620 | r.push( n ); |
| 1785 | } else if ( inplace ) { |
- | |
| 1786 | curLoop[i] = false; |
- | |
| 1787 | }
|
- | |
| 1788 | }
|
- | |
| 1789 | }
|
1621 | }
|
| 1790 | 1622 | ||
| 1791 | return false; |
1623 | return r; |
| 1792 | }, |
- | |
| 1793 | ID: function(match){ |
- | |
| 1794 | return match[1].replace(/\\/g, ""); |
- | |
| 1795 | }, |
- | |
| 1796 | TAG: function(match, curLoop){ |
- | |
| 1797 | for ( var i = 0; curLoop[i] === false; i++ ){} |
- | |
| 1798 | return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase(); |
- | |
| 1799 | }, |
1624 | }; |
| 1800 | CHILD: function(match){ |
- | |
| 1801 | if ( match[1] == "nth" ) { |
- | |
| 1802 | // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
|
- | |
| 1803 | var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec( |
- | |
| 1804 | match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" || |
- | |
| 1805 | !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); |
- | |
| 1806 | 1625 | ||
| 1807 | // calculate the numbers (first)n+(last) including if they are negative
|
- | |
| 1808 | match[2] = (test[1] + (test[2] || 1)) - 0; |
- | |
| 1809 | match[3] = test[3] - 0; |
- | |
| 1810 | }
|
1626 | return; |
| 1811 | 1627 | ||
| 1812 | // TODO: Move to normal caching system
|
- | |
| 1813 | match[0] = done++; |
1628 | window.Sizzle = Sizzle; |
| 1814 | 1629 | ||
| 1815 | return match; |
- | |
| 1816 | }, |
1630 | })(); |
| - | 1631 | jQuery.fn.extend({ |
|
| 1817 | ATTR: function(match, curLoop, inplace, result, not, isXML){ |
1632 | find: function( selector ) { |
| 1818 | var name = match[1].replace(/\\/g, ""); |
1633 | var ret = this.pushStack( "", "find", selector ), length = 0; |
| 1819 | 1634 | ||
| 1820 | if ( !isXML && Expr.attrMap[name] ) { |
1635 | for ( var i = 0, l = this.length; i < l; i++ ) { |
| 1821 | match[1] = Expr.attrMap[name]; |
1636 | length = ret.length; |
| 1822 | }
|
1637 | jQuery.find( selector, this[i], ret ); |
| 1823 | 1638 | ||
| 1824 | if ( match[2] === "~=" ) { |
1639 | if ( i > 0 ) { |
| - | 1640 | // Make sure that the results are unique
|
|
| - | 1641 | for ( var n = length; n < ret.length; n++ ) { |
|
| 1825 | match[4] = " " + match[4] + " "; |
1642 | for ( var r = 0; r < length; r++ ) { |
| - | 1643 | if ( ret[r] === ret[n] ) { |
|
| - | 1644 | ret.splice(n--, 1); |
|
| - | 1645 | break; |
|
| 1826 | }
|
1646 | }
|
| 1827 | - | ||
| 1828 | return match; |
- | |
| 1829 | }, |
- | |
| 1830 | PSEUDO: function(match, curLoop, inplace, result, not){ |
- | |
| 1831 | if ( match[1] === "not" ) { |
- | |
| 1832 | // If we're dealing with a complex expression, or a simple one
|
- | |
| 1833 | if ( match[3].match(chunker).length > 1 || /^\w/.test(match[3]) ) { |
- | |
| 1834 | match[3] = Sizzle(match[3], null, null, curLoop); |
- | |
| 1835 | } else { |
- | |
| 1836 | var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); |
- | |
| 1837 | if ( !inplace ) { |
- | |
| 1838 | result.push.apply( result, ret ); |
- | |
| 1839 | }
|
1647 | }
|
| 1840 | return false; |
- | |
| 1841 | }
|
1648 | }
|
| 1842 | } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { |
- | |
| 1843 | return true; |
- | |
| 1844 | }
|
1649 | }
|
| 1845 | - | ||
| 1846 | return match; |
- | |
| 1847 | }, |
- | |
| 1848 | POS: function(match){ |
- | |
| 1849 | match.unshift( true ); |
- | |
| 1850 | return match; |
- | |
| 1851 | }
|
1650 | }
|
| - | 1651 | ||
| - | 1652 | return ret; |
|
| 1852 | }, |
1653 | }, |
| 1853 | filters: { |
- | |
| 1854 | enabled: function(elem){ |
- | |
| 1855 | return elem.disabled === false && elem.type !== "hidden"; |
- | |
| 1856 | }, |
- | |
| 1857 | disabled: function(elem){ |
- | |
| 1858 | return elem.disabled === true; |
- | |
| 1859 | }, |
1654 | |
| 1860 | checked: function(elem){ |
- | |
| 1861 | return elem.checked === true; |
- | |
| 1862 | }, |
- | |
| 1863 | selected: function(elem){ |
1655 | filter: function( selector ) { |
| 1864 | // Accessing this property makes selected-by-default
|
- | |
| 1865 | // options in Safari work properly
|
- | |
| 1866 | elem.parentNode.selectedIndex; |
- | |
| 1867 | return elem.selected === true; |
- | |
| 1868 | }, |
- | |
| 1869 | parent: function(elem){ |
- | |
| 1870 | return !!elem.firstChild; |
- | |
| 1871 | }, |
- | |
| 1872 | empty: function(elem){ |
- | |
| 1873 | return !elem.firstChild; |
1656 | return this.pushStack( |
| 1874 | }, |
- | |
| 1875 | has: function(elem, i, match){ |
- | |
| 1876 | return !!Sizzle( match[3], elem ).length; |
- | |
| 1877 | }, |
- | |
| 1878 | header: function(elem){ |
1657 | jQuery.isFunction( selector ) && |
| 1879 | return /h\d/i.test( elem.nodeName ); |
- | |
| 1880 | }, |
- | |
| 1881 | text: function(elem){ |
1658 | jQuery.grep(this, function(elem, i){ |
| 1882 | return "text" === elem.type; |
1659 | return selector.call( elem, i ); |
| 1883 | }, |
1660 | }) || |
| 1884 | radio: function(elem){ |
- | |
| 1885 | return "radio" === elem.type; |
- | |
| 1886 | }, |
1661 | |
| 1887 | checkbox: function(elem){ |
1662 | jQuery.multiFilter( selector, jQuery.grep(this, function(elem){ |
| 1888 | return "checkbox" === elem.type; |
1663 | return elem.nodeType === 1; |
| 1889 | }, |
- | |
| 1890 | file: function(elem){ |
- | |
| 1891 | return "file" === elem.type; |
1664 | }) ), "filter", selector ); |
| 1892 | }, |
- | |
| 1893 | password: function(elem){ |
- | |
| 1894 | return "password" === elem.type; |
- | |
| 1895 | }, |
- | |
| 1896 | submit: function(elem){ |
- | |
| 1897 | return "submit" === elem.type; |
- | |
| 1898 | }, |
- | |
| 1899 | image: function(elem){ |
- | |
| 1900 | return "image" === elem.type; |
- | |
| 1901 | }, |
- | |
| 1902 | reset: function(elem){ |
- | |
| 1903 | return "reset" === elem.type; |
- | |
| 1904 | }, |
- | |
| 1905 | button: function(elem){ |
- | |
| 1906 | return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON"; |
- | |
| 1907 | }, |
1665 | }, |
| - | 1666 | ||
| 1908 | input: function(elem){ |
1667 | closest: function( selector ) { |
| - | 1668 | var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null, |
|
| - | 1669 | closer = 0; |
|
| - | 1670 | ||
| - | 1671 | return this.map(function(){ |
|
| - | 1672 | var cur = this; |
|
| - | 1673 | while ( cur && cur.ownerDocument ) { |
|
| 1909 | return /input|select|textarea|button/i.test(elem.nodeName); |
1674 | if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) { |
| - | 1675 | jQuery.data(cur, "closest", closer); |
|
| - | 1676 | return cur; |
|
| 1910 | }
|
1677 | }
|
| - | 1678 | cur = cur.parentNode; |
|
| - | 1679 | closer++;
|
|
| - | 1680 | }
|
|
| - | 1681 | }); |
|
| 1911 | }, |
1682 | }, |
| - | 1683 | ||
| 1912 | setFilters: { |
1684 | not: function( selector ) { |
| 1913 | first: function(elem, i){ |
1685 | if ( typeof selector === "string" ) |
| - | 1686 | // test special case where just one selector is passed in
|
|
| 1914 | return i === 0; |
1687 | if ( isSimple.test( selector ) ) |
| - | 1688 | return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector ); |
|
| 1915 | }, |
1689 | else
|
| 1916 | last: function(elem, i, match, array){ |
1690 | selector = jQuery.multiFilter( selector, this ); |
| - | 1691 | ||
| - | 1692 | var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType; |
|
| 1917 | return i === array.length - 1; |
1693 | return this.filter(function() { |
| - | 1694 | return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector; |
|
| - | 1695 | }); |
|
| 1918 | }, |
1696 | }, |
| - | 1697 | ||
| 1919 | even: function(elem, i){ |
1698 | add: function( selector ) { |
| - | 1699 | return this.pushStack( jQuery.unique( jQuery.merge( |
|
| - | 1700 | this.get(), |
|
| - | 1701 | typeof selector === "string" ? |
|
| 1920 | return i % 2 === 0; |
1702 | jQuery( selector ) : |
| - | 1703 | jQuery.makeArray( selector ) |
|
| - | 1704 | ))); |
|
| 1921 | }, |
1705 | }, |
| - | 1706 | ||
| 1922 | odd: function(elem, i){ |
1707 | eq: function( i ) { |
| 1923 | return i % 2 === 1; |
1708 | return this.slice( i, +i + 1 ); |
| 1924 | }, |
1709 | }, |
| - | 1710 | ||
| 1925 | lt: function(elem, i, match){ |
1711 | slice: function() { |
| 1926 | return i < match[3] - 0; |
1712 | return this.pushStack( Array.prototype.slice.apply( this, arguments ), |
| - | 1713 | "slice", Array.prototype.slice.call(arguments).join(",") ); |
|
| 1927 | }, |
1714 | }, |
| - | 1715 | ||
| 1928 | gt: function(elem, i, match){ |
1716 | map: function( callback ) { |
| - | 1717 | return this.pushStack( jQuery.map(this, function(elem, i){ |
|
| 1929 | return i > match[3] - 0; |
1718 | return callback.call( elem, i, elem ); |
| - | 1719 | })); |
|
| 1930 | }, |
1720 | }, |
| - | 1721 | ||
| 1931 | nth: function(elem, i, match){ |
1722 | andSelf: function() { |
| 1932 | return match[3] - 0 == i; |
1723 | return this.add( this.prevObject ); |
| 1933 | }, |
1724 | }, |
| - | 1725 | ||
| 1934 | eq: function(elem, i, match){ |
1726 | end: function() { |
| 1935 | return match[3] - 0 == i; |
1727 | return this.prevObject || jQuery(null); |
| 1936 | }
|
1728 | }
|
| 1937 | }, |
1729 | }); |
| 1938 | filter: { |
- | |
| 1939 | PSEUDO: function(elem, match, i, array){ |
- | |
| 1940 | var name = match[1], filter = Expr.filters[ name ]; |
- | |
| 1941 | 1730 | ||
| 1942 | if ( filter ) { |
1731 | jQuery.each({ |
| 1943 | return filter( elem, i, match, array ); |
1732 | parent: function(elem){return elem.parentNode;}, |
| - | 1733 | parents: function(elem){return jQuery.dir(elem,"parentNode");}, |
|
| 1944 | } else if ( name === "contains" ) { |
1734 | next: function(elem){return jQuery.nth(elem,2,"nextSibling");}, |
| - | 1735 | prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}, |
|
| - | 1736 | nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}, |
|
| - | 1737 | prevAll: function(elem){return jQuery.dir(elem,"previousSibling");}, |
|
| - | 1738 | siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);}, |
|
| 1945 | return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0; |
1739 | children: function(elem){return jQuery.sibling(elem.firstChild);}, |
| - | 1740 | contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);} |
|
| - | 1741 | }, function(name, fn){ |
|
| 1946 | } else if ( name === "not" ) { |
1742 | jQuery.fn[ name ] = function( selector ) { |
| 1947 | var not = match[3]; |
1743 | var ret = jQuery.map( this, fn ); |
| 1948 | 1744 | ||
| 1949 | for ( var i = 0, l = not.length; i < l; i++ ) { |
1745 | if ( selector && typeof selector == "string" ) |
| - | 1746 | ret = jQuery.multiFilter( selector, ret ); |
|
| - | 1747 | ||
| - | 1748 | return this.pushStack( jQuery.unique( ret ), name, selector ); |
|
| - | 1749 | }; |
|
| - | 1750 | });jQuery.fn.extend({ |
|
| - | 1751 | attr: function( name, value ) { |
|
| - | 1752 | var options = name, isFunction = jQuery.isFunction( value ); |
|
| - | 1753 | ||
| - | 1754 | if ( typeof name === "string" ) { |
|
| - | 1755 | // Are we setting the attribute?
|
|
| 1950 | if ( not[i] === elem ) { |
1756 | if ( value === undefined ) { |
| 1951 | return false; |
1757 | return this.length ? |
| - | 1758 | jQuery.attr( this[0], name ) : |
|
| - | 1759 | null; |
|
| - | 1760 | ||
| - | 1761 | // Convert name, value params to options hash format
|
|
| - | 1762 | } else { |
|
| - | 1763 | options = {}; |
|
| - | 1764 | options[ name ] = value; |
|
| 1952 | }
|
1765 | }
|
| 1953 | }
|
1766 | }
|
| 1954 | 1767 | ||
| - | 1768 | // For each element...
|
|
| - | 1769 | for ( var i = 0, l = this.length; i < l; i++ ) { |
|
| 1955 | return true; |
1770 | var elem = this[i]; |
| - | 1771 | ||
| - | 1772 | // Set all the attributes
|
|
| - | 1773 | for ( var prop in options ) { |
|
| - | 1774 | value = options[prop]; |
|
| - | 1775 | ||
| - | 1776 | if ( isFunction ) { |
|
| - | 1777 | value = value.call( elem, i ); |
|
| 1956 | }
|
1778 | }
|
| 1957 | }, |
1779 | |
| 1958 | CHILD: function(elem, match){ |
1780 | jQuery.attr( elem, prop, value ); |
| 1959 | var type = match[1], node = elem; |
- | |
| 1960 | switch (type) { |
- | |
| 1961 | case 'only': |
- | |
| 1962 | case 'first': |
- | |
| 1963 | while (node = node.previousSibling) { |
- | |
| 1964 | if ( node.nodeType === 1 ) return false; |
- | |
| 1965 | }
|
1781 | }
|
| 1966 | if ( type == 'first') return true; |
- | |
| 1967 | node = elem; |
- | |
| 1968 | case 'last': |
- | |
| 1969 | while (node = node.nextSibling) { |
- | |
| 1970 | if ( node.nodeType === 1 ) return false; |
- | |
| 1971 | }
|
1782 | }
|
| 1972 | return true; |
- | |
| 1973 | case 'nth': |
- | |
| 1974 | var first = match[2], last = match[3]; |
- | |
| 1975 | 1783 | ||
| 1976 | if ( first == 1 && last == 0 ) { |
- | |
| 1977 | return true; |
1784 | return this; |
| 1978 | }
|
1785 | }, |
| 1979 | 1786 | ||
| 1980 | var doneName = match[0], |
1787 | hasClass: function( selector ) { |
| 1981 | parent = elem.parentNode; |
1788 | return !!selector && this.is( "." + selector ); |
| - | 1789 | }, |
|
| 1982 | 1790 | ||
| - | 1791 | val: function( value ) { |
|
| - | 1792 | if ( value === undefined ) { |
|
| - | 1793 | var elem = this[0]; |
|
| - | 1794 | ||
| - | 1795 | if ( elem ) { |
|
| - | 1796 | if( jQuery.nodeName( elem, 'option' ) ) |
|
| - | 1797 | return (elem.attributes.value || {}).specified ? elem.value : elem.text; |
|
| - | 1798 | ||
| - | 1799 | // We need to handle select boxes special
|
|
| 1983 | if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { |
1800 | if ( jQuery.nodeName( elem, "select" ) ) { |
| - | 1801 | var index = elem.selectedIndex, |
|
| 1984 | var count = 0; |
1802 | values = [], |
| - | 1803 | options = elem.options, |
|
| - | 1804 | one = elem.type == "select-one"; |
|
| - | 1805 | ||
| - | 1806 | // Nothing was selected
|
|
| - | 1807 | if ( index < 0 ) |
|
| - | 1808 | return null; |
|
| - | 1809 | ||
| - | 1810 | // Loop through all the selected options
|
|
| 1985 | for ( node = parent.firstChild; node; node = node.nextSibling ) { |
1811 | for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { |
| - | 1812 | var option = options[ i ]; |
|
| - | 1813 | ||
| 1986 | if ( node.nodeType === 1 ) { |
1814 | if ( option.selected ) { |
| - | 1815 | // Get the specifc value for the option
|
|
| - | 1816 | value = jQuery(option).val(); |
|
| - | 1817 | ||
| - | 1818 | // We don't need an array for one selects
|
|
| - | 1819 | if ( one ) |
|
| 1987 | node.nodeIndex = ++count; |
1820 | return value; |
| - | 1821 | ||
| - | 1822 | // Multi-Selects return an array
|
|
| - | 1823 | values.push( value ); |
|
| 1988 | }
|
1824 | }
|
| 1989 | }
|
1825 | }
|
| - | 1826 | ||
| 1990 | parent.sizcache = doneName; |
1827 | return values; |
| 1991 | }
|
1828 | }
|
| 1992 | 1829 | ||
| 1993 | var diff = elem.nodeIndex - last; |
1830 | // Everything else, we just grab the value
|
| 1994 | if ( first == 0 ) { |
- | |
| 1995 | return diff == 0; |
1831 | return (elem.value || "").replace(/\r/g, ""); |
| - | 1832 | ||
| 1996 | } else { |
1833 | }
|
| - | 1834 | ||
| 1997 | return ( diff % first == 0 && diff / first >= 0 ); |
1835 | return undefined; |
| 1998 | }
|
1836 | }
|
| - | 1837 | ||
| - | 1838 | if ( typeof value === "number" ) |
|
| - | 1839 | value += ''; |
|
| - | 1840 | ||
| - | 1841 | return this.each(function(){ |
|
| - | 1842 | if ( this.nodeType != 1 ) |
|
| - | 1843 | return; |
|
| - | 1844 | ||
| - | 1845 | if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) ) |
|
| - | 1846 | this.checked = (jQuery.inArray(this.value, value) >= 0 || |
|
| - | 1847 | jQuery.inArray(this.name, value) >= 0); |
|
| - | 1848 | ||
| - | 1849 | else if ( jQuery.nodeName( this, "select" ) ) { |
|
| - | 1850 | var values = jQuery.makeArray(value); |
|
| - | 1851 | ||
| - | 1852 | jQuery( "option", this ).each(function(){ |
|
| - | 1853 | this.selected = (jQuery.inArray( this.value, values ) >= 0 || |
|
| - | 1854 | jQuery.inArray( this.text, values ) >= 0); |
|
| - | 1855 | }); |
|
| - | 1856 | ||
| - | 1857 | if ( !values.length ) |
|
| - | 1858 | this.selectedIndex = -1; |
|
| - | 1859 | ||
| - | 1860 | } else |
|
| - | 1861 | this.value = value; |
|
| - | 1862 | }); |
|
| 1999 | }
|
1863 | }
|
| - | 1864 | }); |
|
| - | 1865 | ||
| - | 1866 | jQuery.each({ |
|
| - | 1867 | removeAttr: function( name ) { |
|
| - | 1868 | jQuery.attr( this, name, "" ); |
|
| - | 1869 | if (this.nodeType == 1) |
|
| - | 1870 | this.removeAttribute( name ); |
|
| 2000 | }, |
1871 | }, |
| - | 1872 | ||
| 2001 | ID: function(elem, match){ |
1873 | addClass: function( classNames ) { |
| 2002 | return elem.nodeType === 1 && elem.getAttribute("id") === match; |
1874 | jQuery.className.add( this, classNames ); |
| 2003 | }, |
1875 | }, |
| - | 1876 | ||
| 2004 | TAG: function(elem, match){ |
1877 | removeClass: function( classNames ) { |
| 2005 | return (match === "*" && elem.nodeType === 1) || elem.nodeName === match; |
1878 | jQuery.className.remove( this, classNames ); |
| 2006 | }, |
1879 | }, |
| - | 1880 | ||
| 2007 | CLASS: function(elem, match){ |
1881 | toggleClass: function( classNames, state ) { |
| - | 1882 | if( typeof state !== "boolean" ) |
|
| 2008 | return (" " + (elem.className || elem.getAttribute("class")) + " ") |
1883 | state = !jQuery.className.has( this, classNames ); |
| - | 1884 | jQuery.className[ state ? "add" : "remove" ]( this, classNames ); |
|
| - | 1885 | }
|
|
| - | 1886 | }, function(name, fn){ |
|
| - | 1887 | jQuery.fn[ name ] = function(){ |
|
| 2009 | .indexOf( match ) > -1; |
1888 | return this.each( fn, arguments ); |
| - | 1889 | }; |
|
| - | 1890 | }); |
|
| - | 1891 | ||
| - | 1892 | jQuery.extend({ |
|
| - | 1893 | className: { |
|
| - | 1894 | // internal only, use addClass("class")
|
|
| - | 1895 | add: function( elem, classNames ) { |
|
| - | 1896 | jQuery.each((classNames || "").split(/\s+/), function(i, className){ |
|
| - | 1897 | if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) ) |
|
| - | 1898 | elem.className += (elem.className ? " " : "") + className; |
|
| - | 1899 | }); |
|
| 2010 | }, |
1900 | }, |
| 2011 | ATTR: function(elem, match){ |
- | |
| 2012 | var name = match[1], |
- | |
| 2013 | result = Expr.attrHandle[ name ] ? |
- | |
| 2014 | Expr.attrHandle[ name ]( elem ) : |
- | |
| 2015 | elem[ name ] != null ? |
- | |
| 2016 | elem[ name ] : |
- | |
| 2017 | elem.getAttribute( name ), |
- | |
| 2018 | value = result + "", |
- | |
| 2019 | type = match[2], |
- | |
| 2020 | check = match[4]; |
- | |
| 2021 | 1901 | ||
| 2022 | return result == null ? |
1902 | // internal only, use removeClass("class")
|
| 2023 | type === "!=" : |
- | |
| 2024 | type === "=" ? |
- | |
| 2025 | value === check : |
- | |
| 2026 | type === "*=" ? |
- | |
| 2027 | value.indexOf(check) >= 0 : |
1903 | remove: function( elem, classNames ) { |
| 2028 | type === "~=" ? |
1904 | if (elem.nodeType == 1) |
| 2029 | (" " + value + " ").indexOf(check) >= 0 : |
1905 | elem.className = classNames !== undefined ? |
| 2030 | !check ? |
- | |
| 2031 | value && result !== false : |
1906 | jQuery.grep(elem.className.split(/\s+/), function(className){ |
| 2032 | type === "!=" ? |
- | |
| 2033 | value != check : |
- | |
| 2034 | type === "^=" ? |
- | |
| 2035 | value.indexOf(check) === 0 : |
- | |
| 2036 | type === "$=" ? |
- | |
| 2037 | value.substr(value.length - check.length) === check : |
1907 | return !jQuery.className.has( classNames, className ); |
| 2038 | type === "|=" ? |
1908 | }).join(" ") : |
| 2039 | value === check || value.substr(0, check.length + 1) === check + "-" : |
- | |
| 2040 | false; |
1909 | ""; |
| 2041 | }, |
1910 | }, |
| 2042 | POS: function(elem, match, i, array){ |
- | |
| 2043 | var name = match[2], filter = Expr.setFilters[ name ]; |
- | |
| 2044 | 1911 | ||
| 2045 | if ( filter ) { |
1912 | // internal only, use hasClass("class")
|
| 2046 | return filter( elem, i, match, array ); |
1913 | has: function( elem, className ) { |
| 2047 | }
|
- | |
| 2048 | }
|
- | |
| - | 1914 | return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1; |
|
| 2049 | }
|
1915 | }
|
| 2050 | }; |
1916 | }, |
| 2051 | 1917 | ||
| 2052 | var origPOS = Expr.match.POS; |
1918 | attr: function( elem, name, value ) { |
| - | 1919 | // don't set attributes on text and comment nodes
|
|
| - | 1920 | if (!elem || elem.nodeType == 3 || elem.nodeType == 8) |
|
| - | 1921 | return undefined; |
|
| 2053 | 1922 | ||
| 2054 | for ( var type in Expr.match ) { |
1923 | var notxml = !elem.tagName || !jQuery.isXMLDoc( elem ), |
| 2055 | Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source ); |
1924 | // Whether we are setting (or getting)
|
| 2056 | }
|
- | |
| - | 1925 | set = value !== undefined; |
|
| 2057 | 1926 | ||
| 2058 | var makeArray = function(array, results) { |
1927 | // Try to normalize/fix the name
|
| 2059 | array = Array.prototype.slice.call( array ); |
1928 | name = notxml && jQuery.props[ name ] || name; |
| 2060 | 1929 | ||
| 2061 | if ( results ) { |
- | |
| 2062 | results.push.apply( results, array ); |
1930 | // Only do all the following if this is a node (faster for style)
|
| 2063 | return results; |
1931 | if ( elem.tagName ) { |
| 2064 | }
|
- | |
| 2065 | 1932 | ||
| 2066 | return array; |
1933 | // These attributes require special treatment
|
| 2067 | }; |
- | |
| - | 1934 | var special = /href|src|style/.test( name ); |
|
| 2068 | 1935 | ||
| 2069 | // Perform a simple check to determine if the browser is capable of
|
1936 | // Safari mis-reports the default selected property of a hidden option
|
| 2070 | // converting a NodeList to an array using builtin methods.
|
1937 | // Accessing the parent's selectedIndex property fixes it
|
| 2071 | try { |
- | |
| 2072 | Array.prototype.slice.call( document.documentElement.childNodes ); |
1938 | if ( name == "selected" && elem.parentNode ) |
| - | 1939 | elem.parentNode.selectedIndex; |
|
| 2073 | 1940 | ||
| 2074 | // Provide a fallback method if it does not work
|
1941 | // If applicable, access the attribute via the DOM 0 way
|
| - | 1942 | if ( name in elem && notxml && !special ) { |
|
| 2075 | } catch(e){ |
1943 | if ( set ){ |
| 2076 | makeArray = function(array, results) { |
1944 | // We can't allow the type property to be changed (since it causes problems in IE)
|
| - | 1945 | if ( name == "type" && elem.nodeName.match(/(button|input)/i) && elem.parentNode ) |
|
| 2077 | var ret = results || []; |
1946 | throw "type property can't be changed"; |
| 2078 | 1947 | ||
| 2079 | if ( toString.call(array) === "[object Array]" ) { |
- | |
| 2080 | Array.prototype.push.apply( ret, array ); |
- | |
| 2081 | } else { |
- | |
| 2082 | if ( typeof array.length === "number" ) { |
- | |
| 2083 | for ( var i = 0, l = array.length; i < l; i++ ) { |
- | |
| 2084 | ret.push( array[i] ); |
1948 | elem[ name ] = value; |
| 2085 | }
|
- | |
| 2086 | } else { |
- | |
| 2087 | for ( var i = 0; array[i]; i++ ) { |
- | |
| 2088 | ret.push( array[i] ); |
- | |
| 2089 | }
|
- | |
| 2090 | }
|
1949 | }
|
| - | 1950 | ||
| - | 1951 | // browsers index elements by id/name on forms, give priority to attributes.
|
|
| - | 1952 | if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) |
|
| - | 1953 | return elem.getAttributeNode( name ).nodeValue; |
|
| - | 1954 | ||
| - | 1955 | // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
|
|
| - | 1956 | // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
|
| - | 1957 | if ( name == "tabIndex" ) { |
|
| - | 1958 | var attributeNode = elem.getAttributeNode( "tabIndex" ); |
|
| - | 1959 | return attributeNode && attributeNode.specified |
|
| - | 1960 | ? attributeNode.value |
|
| - | 1961 | : elem.nodeName.match(/(button|input|object|select|textarea)/i) |
|
| - | 1962 | ? 0 |
|
| - | 1963 | : elem.nodeName.match(/^(a|area)$/i) && elem.href |
|
| - | 1964 | ? 0 |
|
| - | 1965 | : undefined; |
|
| 2091 | }
|
1966 | }
|
| 2092 | 1967 | ||
| 2093 | return ret; |
1968 | return elem[ name ]; |
| 2094 | }; |
- | |
| 2095 | }
|
1969 | }
|
| 2096 | 1970 | ||
| - | 1971 | if ( !jQuery.support.style && notxml && name == "style" ) { |
|
| 2097 | var sortOrder; |
1972 | if ( set ) |
| - | 1973 | elem.style.cssText = "" + value; |
|
| 2098 | 1974 | ||
| 2099 | if ( document.documentElement.compareDocumentPosition ) { |
- | |
| 2100 | sortOrder = function( a, b ) { |
- | |
| 2101 | var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1; |
- | |
| 2102 | if ( ret === 0 ) { |
- | |
| 2103 | hasDuplicate = true; |
- | |
| 2104 | }
|
- | |
| 2105 | return ret; |
- | |
| 2106 | }; |
- | |
| 2107 | } else if ( "sourceIndex" in document.documentElement ) { |
- | |
| 2108 | sortOrder = function( a, b ) { |
- | |
| 2109 | var ret = a.sourceIndex - b.sourceIndex; |
- | |
| 2110 | if ( ret === 0 ) { |
- | |
| 2111 | hasDuplicate = true; |
- | |
| 2112 | }
|
- | |
| 2113 | return ret; |
- | |
| 2114 | }; |
- | |
| 2115 | } else if ( document.createRange ) { |
- | |
| 2116 | sortOrder = function( a, b ) { |
- | |
| 2117 | var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange(); |
- | |
| 2118 | aRange.selectNode(a); |
1975 | return elem.style.cssText; |
| 2119 | aRange.collapse(true); |
- | |
| 2120 | bRange.selectNode(b); |
- | |
| 2121 | bRange.collapse(true); |
- | |
| 2122 | var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange); |
- | |
| 2123 | if ( ret === 0 ) { |
- | |
| 2124 | hasDuplicate = true; |
- | |
| 2125 | }
|
- | |
| 2126 | return ret; |
- | |
| 2127 | }; |
- | |
| 2128 | }
|
1976 | }
|
| 2129 | 1977 | ||
| 2130 | // Check to see if the browser returns elements by name when
|
- | |
| 2131 | // querying by getElementById (and provide a workaround)
|
- | |
| 2132 | (function(){ |
1978 | if ( set ) |
| 2133 | // We're going to inject a fake input element with a specified name
|
1979 | // convert the value to a string (all browsers do this but IE) see #1070
|
| 2134 | var form = document.createElement("form"), |
- | |
| 2135 | id = "script" + (new Date).getTime(); |
- | |
| 2136 | form.innerHTML = "<input name='" + id + "'/>"; |
1980 | elem.setAttribute( name, "" + value ); |
| 2137 | 1981 | ||
| 2138 | // Inject it into the root element, check its status, and remove it quickly
|
1982 | var attr = !jQuery.support.hrefNormalized && notxml && special |
| - | 1983 | // Some attributes require a special call on IE
|
|
| 2139 | var root = document.documentElement; |
1984 | ? elem.getAttribute( name, 2 ) |
| 2140 | root.insertBefore( form, root.firstChild ); |
1985 | : elem.getAttribute( name ); |
| 2141 | 1986 | ||
| 2142 | // The workaround has to do additional checks after a getElementById
|
- | |
| 2143 | // Which slows things down for other browsers (hence the branching)
|
1987 | // Non-existent attributes return null, we normalize to undefined
|
| 2144 | if ( !!document.getElementById( id ) ) { |
- | |
| 2145 | Expr.find.ID = function(match, context, isXML){ |
- | |
| 2146 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
- | |
| 2147 | var m = context.getElementById(match[1]); |
1988 | return attr === null ? undefined : attr; |
| 2148 | return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; |
- | |
| 2149 | }
|
1989 | }
|
| 2150 | }; |
- | |
| 2151 | 1990 | ||
| 2152 | Expr.filter.ID = function(elem, match){ |
1991 | // elem is actually elem.style ... set the style
|
| 2153 | var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); |
1992 | // Using attr for specific style information is now deprecated. Use style insead.
|
| 2154 | return elem.nodeType === 1 && node && node.nodeValue === match; |
1993 | return jQuery.style(elem, name, value); |
| 2155 | }; |
- | |
| 2156 | }
|
1994 | }
|
| - | 1995 | });jQuery.fn.extend({ |
|
| - | 1996 | text: function( text ) { |
|
| - | 1997 | if ( typeof text !== "object" && text != null ) |
|
| - | 1998 | return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) ); |
|
| 2157 | 1999 | ||
| 2158 | root.removeChild( form ); |
2000 | var ret = ""; |
| 2159 | })(); |
- | |
| 2160 | 2001 | ||
| 2161 | (function(){ |
2002 | jQuery.each( text || this, function(){ |
| 2162 | // Check to see if the browser returns only elements
|
2003 | jQuery.each( this.childNodes, function(){ |
| - | 2004 | if ( this.nodeType != 8 ) |
|
| 2163 | // when doing getElementsByTagName("*")
|
2005 | ret += this.nodeType != 1 ? |
| - | 2006 | this.nodeValue : |
|
| - | 2007 | jQuery.fn.text( [ this ] ); |
|
| - | 2008 | }); |
|
| - | 2009 | }); |
|
| 2164 | 2010 | ||
| 2165 | // Create a fake element
|
2011 | return ret; |
| 2166 | var div = document.createElement("div"); |
- | |
| 2167 | div.appendChild( document.createComment("") ); |
- | |
| - | 2012 | }, |
|
| 2168 | 2013 | ||
| 2169 | // Make sure no comments are found
|
2014 | wrapAll: function( html ) { |
| 2170 | if ( div.getElementsByTagName("*").length > 0 ) { |
2015 | if ( this[0] ) { |
| 2171 | Expr.find.TAG = function(match, context){ |
2016 | // The elements to wrap the target around
|
| 2172 | var results = context.getElementsByTagName(match[1]); |
2017 | var wrap = jQuery( html, this[0].ownerDocument ).clone(); |
| 2173 | 2018 | ||
| 2174 | // Filter out possible comments
|
- | |
| 2175 | if ( match[1] === "*" ) { |
2019 | if ( this[0].parentNode ) |
| 2176 | var tmp = []; |
2020 | wrap.insertBefore( this[0] ); |
| 2177 | 2021 | ||
| 2178 | for ( var i = 0; results[i]; i++ ) { |
2022 | wrap.map(function(){ |
| 2179 | if ( results[i].nodeType === 1 ) { |
- | |
| 2180 | tmp.push( results[i] ); |
2023 | var elem = this; |
| 2181 | }
|
- | |
| 2182 | }
|
- | |
| 2183 | 2024 | ||
| 2184 | results = tmp; |
2025 | while ( elem.firstChild ) |
| 2185 | }
|
2026 | elem = elem.firstChild; |
| 2186 | 2027 | ||
| 2187 | return results; |
2028 | return elem; |
| 2188 | }; |
2029 | }).append(this); |
| 2189 | }
|
2030 | }
|
| 2190 | 2031 | ||
| 2191 | // Check to see if an attribute returns normalized href attributes
|
- | |
| 2192 | div.innerHTML = "<a href='#'></a>"; |
- | |
| 2193 | if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && |
- | |
| 2194 | div.firstChild.getAttribute("href") !== "#" ) { |
- | |
| 2195 | Expr.attrHandle.href = function(elem){ |
- | |
| 2196 | return elem.getAttribute("href", 2); |
2032 | return this; |
| 2197 | }; |
- | |
| 2198 | }
|
2033 | }, |
| 2199 | })(); |
- | |
| 2200 | 2034 | ||
| 2201 | if ( document.querySelectorAll ) (function(){ |
2035 | wrapInner: function( html ) { |
| 2202 | var oldSizzle = Sizzle, div = document.createElement("div"); |
2036 | return this.each(function(){ |
| 2203 | div.innerHTML = "<p class='TEST'></p>"; |
2037 | jQuery( this ).contents().wrapAll( html ); |
| - | 2038 | }); |
|
| - | 2039 | }, |
|
| 2204 | 2040 | ||
| 2205 | // Safari can't handle uppercase or unicode characters when
|
2041 | wrap: function( html ) { |
| 2206 | // in quirks mode.
|
2042 | return this.each(function(){ |
| 2207 | if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { |
2043 | jQuery( this ).wrapAll( html ); |
| 2208 | return; |
2044 | }); |
| 2209 | }
|
2045 | }, |
| 2210 | 2046 | ||
| - | 2047 | append: function() { |
|
| 2211 | Sizzle = function(query, context, extra, seed){ |
2048 | return this.domManip(arguments, true, function(elem){ |
| - | 2049 | if (this.nodeType == 1) |
|
| 2212 | context = context || document; |
2050 | this.appendChild( elem ); |
| - | 2051 | }); |
|
| - | 2052 | }, |
|
| 2213 | 2053 | ||
| - | 2054 | prepend: function() { |
|
| - | 2055 | return this.domManip(arguments, true, function(elem){ |
|
| - | 2056 | if (this.nodeType == 1) |
|
| 2214 | // Only use querySelectorAll on non-XML documents
|
2057 | this.insertBefore( elem, this.firstChild ); |
| - | 2058 | }); |
|
| - | 2059 | }, |
|
| - | 2060 | ||
| - | 2061 | before: function() { |
|
| - | 2062 | return this.domManip(arguments, false, function(elem){ |
|
| - | 2063 | this.parentNode.insertBefore( elem, this ); |
|
| - | 2064 | }); |
|
| - | 2065 | }, |
|
| - | 2066 | ||
| - | 2067 | after: function() { |
|
| 2215 | // (ID selectors don't work in non-HTML documents)
|
2068 | return this.domManip(arguments, false, function(elem){ |
| 2216 | if ( !seed && context.nodeType === 9 && !isXML(context) ) { |
2069 | this.parentNode.insertBefore( elem, this.nextSibling ); |
| 2217 | try { |
2070 | }); |
| - | 2071 | }, |
|
| - | 2072 | ||
| - | 2073 | clone: function( events ) { |
|
| - | 2074 | // Do the clone
|
|
| - | 2075 | var ret = this.map(function(){ |
|
| - | 2076 | if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) { |
|
| - | 2077 | // IE copies events bound via attachEvent when
|
|
| - | 2078 | // using cloneNode. Calling detachEvent on the
|
|
| - | 2079 | // clone will also remove the events from the orignal
|
|
| - | 2080 | // In order to get around this, we use innerHTML.
|
|
| - | 2081 | // Unfortunately, this means some modifications to
|
|
| 2218 | return makeArray( context.querySelectorAll(query), extra ); |
2082 | // attributes in IE that are actually only stored
|
| - | 2083 | // as properties will not be copied (such as the
|
|
| - | 2084 | // the name attribute on an input).
|
|
| - | 2085 | var html = this.outerHTML, ownerDocument = this.ownerDocument; |
|
| 2219 | } catch(e){} |
2086 | if ( !html ) { |
| - | 2087 | var div = ownerDocument.createElement("div"); |
|
| - | 2088 | div.appendChild( this.cloneNode(true) ); |
|
| - | 2089 | html = div.innerHTML; |
|
| 2220 | }
|
2090 | }
|
| 2221 | 2091 | ||
| 2222 | return oldSizzle(query, context, extra, seed); |
2092 | return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")], ownerDocument)[0]; |
| 2223 | }; |
2093 | } else |
| 2224 | - | ||
| 2225 | Sizzle.find = oldSizzle.find; |
- | |
| 2226 | Sizzle.filter = oldSizzle.filter; |
- | |
| 2227 | Sizzle.selectors = oldSizzle.selectors; |
- | |
| 2228 | Sizzle.matches = oldSizzle.matches; |
2094 | return this.cloneNode(true); |
| 2229 | })(); |
2095 | }); |
| 2230 | 2096 | ||
| 2231 | if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){ |
2097 | // Copy the events from the original to the clone
|
| 2232 | var div = document.createElement("div"); |
2098 | if ( events === true ) { |
| 2233 | div.innerHTML = "<div class='test e'></div><div class='test'></div>"; |
2099 | var orig = this.find("*").andSelf(), i = 0; |
| 2234 | 2100 | ||
| 2235 | // Opera can't find a second classname (in 9.6)
|
2101 | ret.find("*").andSelf().each(function(){ |
| 2236 | if ( div.getElementsByClassName("e").length === 0 ) |
2102 | if ( this.nodeName !== orig[i].nodeName ) |
| 2237 | return; |
2103 | return; |
| 2238 | 2104 | ||
| 2239 | // Safari caches class attributes, doesn't catch changes (in 3.2)
|
- | |
| 2240 | div.lastChild.className = "e"; |
- | |
| 2241 | - | ||
| 2242 | if ( div.getElementsByClassName("e").length === 1 ) |
2105 | var events = jQuery.data( orig[i], "events" ); |
| 2243 | return; |
- | |
| 2244 | 2106 | ||
| 2245 | Expr.order.splice(1, 0, "CLASS"); |
2107 | for ( var type in events ) { |
| 2246 | Expr.find.CLASS = function(match, context, isXML) { |
2108 | for ( var handler in events[ type ] ) { |
| 2247 | if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { |
2109 | jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data ); |
| 2248 | return context.getElementsByClassName(match[1]); |
- | |
| 2249 | }
|
2110 | }
|
| 2250 | }; |
- | |
| 2251 | })(); |
- | |
| 2252 | - | ||
| 2253 | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
- | |
| 2254 | var sibDir = dir == "previousSibling" && !isXML; |
- | |
| 2255 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
- | |
| 2256 | var elem = checkSet[i]; |
- | |
| 2257 | if ( elem ) { |
- | |
| 2258 | if ( sibDir && elem.nodeType === 1 ){ |
- | |
| 2259 | elem.sizcache = doneName; |
- | |
| 2260 | elem.sizset = i; |
- | |
| 2261 | }
|
2111 | }
|
| 2262 | elem = elem[dir]; |
- | |
| 2263 | var match = false; |
- | |
| 2264 | 2112 | ||
| 2265 | while ( elem ) { |
2113 | i++;
|
| 2266 | if ( elem.sizcache === doneName ) { |
- | |
| 2267 | match = checkSet[elem.sizset]; |
- | |
| 2268 | break; |
2114 | }); |
| 2269 | }
|
2115 | }
|
| 2270 | 2116 | ||
| 2271 | if ( elem.nodeType === 1 && !isXML ){ |
- | |
| 2272 | elem.sizcache = doneName; |
2117 | // Return the cloned set
|
| 2273 | elem.sizset = i; |
2118 | return ret; |
| 2274 | }
|
2119 | }, |
| 2275 | 2120 | ||
| 2276 | if ( elem.nodeName === cur ) { |
2121 | html: function( value ) { |
| - | 2122 | return value === undefined ? |
|
| 2277 | match = elem; |
2123 | (this[0] ? |
| - | 2124 | this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") : |
|
| 2278 | break; |
2125 | null) : |
| - | 2126 | this.empty().append( value ); |
|
| 2279 | }
|
2127 | }, |
| 2280 | 2128 | ||
| - | 2129 | replaceWith: function( value ) { |
|
| 2281 | elem = elem[dir]; |
2130 | return this.after( value ).remove(); |
| 2282 | }
|
2131 | }, |
| 2283 | 2132 | ||
| - | 2133 | domManip: function( args, table, callback ) { |
|
| 2284 | checkSet[i] = match; |
2134 | if ( this[0] ) { |
| - | 2135 | var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(), |
|
| - | 2136 | scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ), |
|
| - | 2137 | first = fragment.firstChild; |
|
| - | 2138 | ||
| - | 2139 | if ( first ) |
|
| - | 2140 | for ( var i = 0, l = this.length; i < l; i++ ) |
|
| - | 2141 | callback.call( root(this[i], first), this.length > 1 || i > 0 ? |
|
| - | 2142 | fragment.cloneNode(true) : fragment ); |
|
| - | 2143 | ||
| - | 2144 | if ( scripts ) |
|
| - | 2145 | jQuery.each( scripts, evalScript ); |
|
| 2285 | }
|
2146 | }
|
| - | 2147 | ||
| - | 2148 | return this; |
|
| - | 2149 | ||
| - | 2150 | function root( elem, cur ) { |
|
| - | 2151 | return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ? |
|
| - | 2152 | (elem.getElementsByTagName("tbody")[0] || |
|
| - | 2153 | elem.appendChild(elem.ownerDocument.createElement("tbody"))) : |
|
| - | 2154 | elem;
|
|
| 2286 | }
|
2155 | }
|
| 2287 | }
|
2156 | }
|
| - | 2157 | }); |
|
| 2288 | 2158 | ||
| 2289 | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
2159 | jQuery.each({ |
| 2290 | var sibDir = dir == "previousSibling" && !isXML; |
2160 | appendTo: "append", |
| 2291 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
- | |
| 2292 | var elem = checkSet[i]; |
2161 | prependTo: "prepend", |
| 2293 | if ( elem ) { |
2162 | insertBefore: "before", |
| 2294 | if ( sibDir && elem.nodeType === 1 ) { |
2163 | insertAfter: "after", |
| 2295 | elem.sizcache = doneName; |
2164 | replaceAll: "replaceWith" |
| 2296 | elem.sizset = i; |
2165 | }, function(name, original){ |
| 2297 | }
|
- | |
| 2298 | elem = elem[dir]; |
2166 | jQuery.fn[ name ] = function( selector ) { |
| 2299 | var match = false; |
2167 | var ret = [], insert = jQuery( selector ); |
| 2300 | 2168 | ||
| 2301 | while ( elem ) { |
2169 | for ( var i = 0, l = insert.length; i < l; i++ ) { |
| 2302 | if ( elem.sizcache === doneName ) { |
2170 | var elems = (i > 0 ? this.clone(true) : this).get(); |
| 2303 | match = checkSet[elem.sizset]; |
2171 | jQuery.fn[ original ].apply( jQuery(insert[i]), elems ); |
| 2304 | break; |
2172 | ret = ret.concat( elems ); |
| 2305 | }
|
2173 | }
|
| 2306 | 2174 | ||
| 2307 | if ( elem.nodeType === 1 ) { |
2175 | return this.pushStack( ret, name, selector ); |
| - | 2176 | }; |
|
| 2308 | if ( !isXML ) { |
2177 | }); |
| - | 2178 | ||
| 2309 | elem.sizcache = doneName; |
2179 | jQuery.each({ |
| 2310 | elem.sizset = i; |
2180 | remove: function( selector ) { |
| 2311 | }
|
- | |
| 2312 | if ( typeof cur !== "string" ) { |
2181 | if ( !selector || jQuery.multiFilter( selector, [ this ] ).length ) { |
| 2313 | if ( elem === cur ) { |
2182 | if ( this.nodeType === 1 ) { |
| 2314 | match = true; |
2183 | cleanData( this.getElementsByTagName("*") ); |
| 2315 | break; |
2184 | cleanData( [this] ); |
| 2316 | }
|
2185 | }
|
| 2317 | 2186 | ||
| 2318 | } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { |
2187 | if ( this.parentNode ) { |
| 2319 | match = elem; |
2188 | this.parentNode.removeChild( this ); |
| 2320 | break; |
- | |
| 2321 | }
|
2189 | }
|
| 2322 | }
|
2190 | }
|
| - | 2191 | }, |
|
| 2323 | 2192 | ||
| 2324 | elem = elem[dir]; |
2193 | empty: function() { |
| - | 2194 | // Remove element nodes and prevent memory leaks
|
|
| - | 2195 | if ( this.nodeType === 1 ) { |
|
| - | 2196 | cleanData( this.getElementsByTagName("*") ); |
|
| 2325 | }
|
2197 | }
|
| 2326 | 2198 | ||
| 2327 | checkSet[i] = match; |
2199 | // Remove any remaining nodes
|
| 2328 | }
|
2200 | while ( this.firstChild ) { |
| - | 2201 | this.removeChild( this.firstChild ); |
|
| 2329 | }
|
2202 | }
|
| 2330 | }
|
2203 | }
|
| 2331 | - | ||
| 2332 | var contains = document.compareDocumentPosition ? function(a, b){ |
- | |
| 2333 | return a.compareDocumentPosition(b) & 16; |
2204 | }, function(name, fn){ |
| 2334 | } : function(a, b){ |
2205 | jQuery.fn[ name ] = function(){ |
| 2335 | return a !== b && (a.contains ? a.contains(b) : true); |
2206 | return this.each( fn, arguments ); |
| 2336 | }; |
2207 | }; |
| - | 2208 | }); |
|
| 2337 | 2209 | ||
| 2338 | var isXML = function(elem){ |
2210 | jQuery.extend({ |
| 2339 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
2211 | clean: function( elems, context, fragment ) { |
| 2340 | !!elem.ownerDocument && isXML( elem.ownerDocument ); |
2212 | context = context || document; |
| 2341 | }; |
- | |
| 2342 | 2213 | ||
| 2343 | var posProcess = function(selector, context){ |
2214 | // !context.createElement fails in IE with an error but returns typeof 'object'
|
| 2344 | var tmpSet = [], later = "", match, |
2215 | if ( typeof context.createElement === "undefined" ) |
| 2345 | root = context.nodeType ? [context] : context; |
2216 | context = context.ownerDocument || context[0] && context[0].ownerDocument || document; |
| 2346 | 2217 | ||
| - | 2218 | // If a single string is passed in and it's a single tag
|
|
| 2347 | // Position selectors must be done after the filter
|
2219 | // just do a createElement and skip the rest
|
| 2348 | // And so must :not(positional) so we move all PSEUDOs to the end
|
2220 | if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) { |
| 2349 | while ( (match = Expr.match.PSEUDO.exec( selector )) ) { |
2221 | var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); |
| 2350 | later += match[0]; |
2222 | if ( match ) |
| 2351 | selector = selector.replace( Expr.match.PSEUDO, "" ); |
2223 | return [ context.createElement( match[1] ) ]; |
| 2352 | }
|
2224 | }
|
| 2353 | 2225 | ||
| 2354 | selector = Expr.relative[selector] ? selector + "*" : selector; |
2226 | var ret = [], scripts = [], div = context.createElement("div"); |
| 2355 | 2227 | ||
| 2356 | for ( var i = 0, l = root.length; i < l; i++ ) { |
2228 | jQuery.each(elems, function(i, elem){ |
| 2357 | Sizzle( selector, root[i], tmpSet ); |
2229 | if ( typeof elem === "number" ) |
| 2358 | }
|
2230 | elem += ''; |
| 2359 | 2231 | ||
| 2360 | return Sizzle.filter( later, tmpSet ); |
2232 | if ( !elem ) |
| 2361 | }; |
2233 | return; |
| 2362 | 2234 | ||
| 2363 | // EXPOSE
|
- | |
| 2364 | jQuery.find = Sizzle; |
2235 | // Convert html string into DOM nodes
|
| 2365 | jQuery.filter = Sizzle.filter; |
2236 | if ( typeof elem === "string" ) { |
| 2366 | jQuery.expr = Sizzle.selectors; |
2237 | // Fix "XHTML"-style tags in all browsers
|
| - | 2238 | elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){ |
|
| - | 2239 | return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ? |
|
| - | 2240 | all :
|
|
| 2367 | jQuery.expr[":"] = jQuery.expr.filters; |
2241 | front + "></" + tag + ">"; |
| - | 2242 | }); |
|
| 2368 | 2243 | ||
| 2369 | Sizzle.selectors.filters.hidden = function(elem){ |
2244 | // Trim whitespace, otherwise indexOf won't work as expected
|
| 2370 | return elem.offsetWidth === 0 || elem.offsetHeight === 0; |
2245 | var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase(); |
| 2371 | }; |
- | |
| 2372 | 2246 | ||
| - | 2247 | var wrap = |
|
| - | 2248 | // option or optgroup
|
|
| 2373 | Sizzle.selectors.filters.visible = function(elem){ |
2249 | !tags.indexOf("<opt") && |
| 2374 | return elem.offsetWidth > 0 || elem.offsetHeight > 0; |
2250 | [ 1, "<select multiple='multiple'>", "</select>" ] || |
| 2375 | }; |
- | |
| 2376 | 2251 | ||
| - | 2252 | !tags.indexOf("<leg") && |
|
| - | 2253 | [ 1, "<fieldset>", "</fieldset>" ] || |
|
| - | 2254 | ||
| - | 2255 | tags.match(/^<(thead|tbody|tfoot|colg|cap)/) && |
|
| - | 2256 | [ 1, "<table>", "</table>" ] || |
|
| - | 2257 | ||
| - | 2258 | !tags.indexOf("<tr") && |
|
| - | 2259 | [ 2, "<table><tbody>", "</tbody></table>" ] || |
|
| - | 2260 | ||
| - | 2261 | // <thead> matched above
|
|
| - | 2262 | (!tags.indexOf("<td") || !tags.indexOf("<th")) && |
|
| - | 2263 | [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] || |
|
| - | 2264 | ||
| - | 2265 | !tags.indexOf("<col") && |
|
| - | 2266 | [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] || |
|
| - | 2267 | ||
| 2377 | Sizzle.selectors.filters.animated = function(elem){ |
2268 | // IE can't serialize <link> and <script> tags normally
|
| 2378 | return jQuery.grep(jQuery.timers, function(fn){ |
2269 | !jQuery.support.htmlSerialize && |
| - | 2270 | [ 1, "div<div>", "</div>" ] || |
|
| - | 2271 | ||
| - | 2272 | [ 0, "", "" ]; |
|
| - | 2273 | ||
| - | 2274 | // Go to html and back, then peel off extra wrappers
|
|
| - | 2275 | div.innerHTML = wrap[1] + elem + wrap[2]; |
|
| - | 2276 | ||
| 2379 | return elem === fn.elem; |
2277 | // Move to the right depth
|
| - | 2278 | while ( wrap[0]-- ) |
|
| 2380 | }).length; |
2279 | div = div.lastChild; |
| 2381 | }; |
2280 | |
| - | 2281 | // Remove IE's autoinserted <tbody> from table fragments
|
|
| - | 2282 | if ( !jQuery.support.tbody ) { |
|
| 2382 | 2283 | ||
| 2383 | jQuery.multiFilter = function( expr, elems, not ) { |
2284 | // String was a <table>, *may* have spurious <tbody>
|
| 2384 | if ( not ) { |
2285 | var hasBody = /<tbody/i.test(elem), |
| 2385 | expr = ":not(" + expr + ")"; |
2286 | tbody = !tags.indexOf("<table") && !hasBody ? |
| 2386 | }
|
- | |
| - | 2287 | div.firstChild && div.firstChild.childNodes : |
|
| 2387 | 2288 | ||
| 2388 | return Sizzle.matches(expr, elems); |
2289 | // String was a bare <thead> or <tfoot>
|
| - | 2290 | wrap[1] == "<table>" && !hasBody ? |
|
| - | 2291 | div.childNodes : |
|
| - | 2292 | []; |
|
| 2389 | }; |
2293 | |
| - | 2294 | for ( var j = tbody.length - 1; j >= 0 ; --j ) |
|
| - | 2295 | if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) |
|
| - | 2296 | tbody[ j ].parentNode.removeChild( tbody[ j ] ); |
|
| 2390 | 2297 | ||
| 2391 | jQuery.dir = function( elem, dir ){ |
- | |
| 2392 | var matched = [], cur = elem[dir]; |
- | |
| 2393 | while ( cur && cur != document ) { |
- | |
| 2394 | if ( cur.nodeType == 1 ) |
- | |
| 2395 | matched.push( cur ); |
- | |
| 2396 | cur = cur[dir]; |
- | |
| 2397 | }
|
2298 | }
|
| 2398 | return matched; |
- | |
| 2399 | }; |
- | |
| 2400 | 2299 | ||
| 2401 | jQuery.nth = function(cur, result, dir, elem){ |
2300 | // IE completely kills leading whitespace when innerHTML is used
|
| 2402 | result = result || 1; |
2301 | if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) ) |
| 2403 | var num = 0; |
2302 | div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild ); |
| 2404 | 2303 | ||
| 2405 | for ( ; cur; cur = cur[dir] ) |
- | |
| 2406 | if ( cur.nodeType == 1 && ++num == result ) |
2304 | elem = jQuery.makeArray( div.childNodes ); |
| 2407 | break; |
2305 | }
|
| 2408 | 2306 | ||
| - | 2307 | if ( elem.nodeType ) |
|
| 2409 | return cur; |
2308 | ret.push( elem ); |
| 2410 | }; |
2309 | else
|
| - | 2310 | ret = jQuery.merge( ret, elem ); |
|
| 2411 | 2311 | ||
| 2412 | jQuery.sibling = function(n, elem){ |
- | |
| 2413 | var r = []; |
2312 | }); |
| 2414 | 2313 | ||
| - | 2314 | if ( fragment ) { |
|
| 2415 | for ( ; n; n = n.nextSibling ) { |
2315 | for ( var i = 0; ret[i]; i++ ) { |
| - | 2316 | if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) { |
|
| - | 2317 | scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] ); |
|
| - | 2318 | } else { |
|
| 2416 | if ( n.nodeType == 1 && n != elem ) |
2319 | if ( ret[i].nodeType === 1 ) |
| - | 2320 | ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) ); |
|
| 2417 | r.push( n ); |
2321 | fragment.appendChild( ret[i] ); |
| - | 2322 | }
|
|
| 2418 | }
|
2323 | }
|
| 2419 | 2324 | ||
| 2420 | return r; |
2325 | return scripts; |
| 2421 | }; |
2326 | }
|
| 2422 | - | ||
| 2423 | return; |
- | |
| 2424 | 2327 | ||
| 2425 | window.Sizzle = Sizzle; |
2328 | return ret; |
| - | 2329 | }
|
|
| - | 2330 | }); |
|
| 2426 | 2331 | ||
| - | 2332 | function cleanData( elems ) { |
|
| - | 2333 | for ( var i = 0, l = elems.length; i < l; i++ ) { |
|
| - | 2334 | var id = elems[i][expando]; |
|
| - | 2335 | if ( id ) { |
|
| - | 2336 | delete jQuery.cache[ id ]; |
|
| - | 2337 | }
|
|
| - | 2338 | }
|
|
| 2427 | })(); |
2339 | }
|
| 2428 | /*
|
2340 | /*
|
| 2429 | * A number of helper functions used for managing events.
|
2341 | * A number of helper functions used for managing events.
|
| 2430 | * Many of the ideas behind this code originated from
|
2342 | * Many of the ideas behind this code originated from
|
| 2431 | * Dean Edwards' addEvent library.
|
2343 | * Dean Edwards' addEvent library.
|
| 2432 | */
|
2344 | */
|
| Строка 2541... | Строка 2453... | ||
| 2541 | // jQuery(...).unbind("mouseover mouseout", fn);
|
2453 | // jQuery(...).unbind("mouseover mouseout", fn);
|
| 2542 | jQuery.each(types.split(/\s+/), function(index, type){ |
2454 | jQuery.each(types.split(/\s+/), function(index, type){ |
| 2543 | // Namespaced event handlers
|
2455 | // Namespaced event handlers
|
| 2544 | var namespaces = type.split("."); |
2456 | var namespaces = type.split("."); |
| 2545 | type = namespaces.shift(); |
2457 | type = namespaces.shift(); |
| 2546 | var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)"); |
2458 | var namespace = new RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)"); |
| 2547 | 2459 | ||
| 2548 | if ( events[type] ) { |
2460 | if ( events[type] ) { |
| 2549 | // remove the given handler for the given type
|
2461 | // remove the given handler for the given type
|
| 2550 | if ( handler ) |
2462 | if ( handler ) |
| 2551 | delete events[type][handler.guid]; |
2463 | delete events[type][handler.guid]; |
| Строка 2674... | Строка 2586... | ||
| 2674 | event.type = namespaces.shift(); |
2586 | event.type = namespaces.shift(); |
| 2675 | 2587 | ||
| 2676 | // Cache this now, all = true means, any handler
|
2588 | // Cache this now, all = true means, any handler
|
| 2677 | all = !namespaces.length && !event.exclusive; |
2589 | all = !namespaces.length && !event.exclusive; |
| 2678 | 2590 | ||
| 2679 | var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)"); |
2591 | var namespace = new RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)"); |
| 2680 | 2592 | ||
| 2681 | handlers = ( jQuery.data(this, "events") || {} )[event.type]; |
2593 | handlers = ( jQuery.data(this, "events") || {} )[event.type]; |
| 2682 | 2594 | ||
| 2683 | for ( var j in handlers ) { |
2595 | for ( var j in handlers ) { |
| 2684 | var handler = handlers[j]; |
2596 | var handler = handlers[j]; |
| Строка 2779... | Строка 2691... | ||
| 2779 | setup: function( selector, namespaces ){ |
2691 | setup: function( selector, namespaces ){ |
| 2780 | jQuery.event.add( this, namespaces[0], liveHandler ); |
2692 | jQuery.event.add( this, namespaces[0], liveHandler ); |
| 2781 | }, |
2693 | }, |
| 2782 | teardown: function( namespaces ){ |
2694 | teardown: function( namespaces ){ |
| 2783 | if ( namespaces.length ) { |
2695 | if ( namespaces.length ) { |
| 2784 | var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)"); |
2696 | var remove = 0, name = new RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)"); |
| 2785 | 2697 | ||
| 2786 | jQuery.each( (jQuery.data(this, "events").live || {}), function(){ |
2698 | jQuery.each( (jQuery.data(this, "events").live || {}), function(){ |
| 2787 | if ( name.test(this.type) ) |
2699 | if ( name.test(this.type) ) |
| 2788 | remove++;
|
2700 | remove++;
|
| 2789 | }); |
2701 | }); |
| Строка 2973... | Строка 2885... | ||
| 2973 | 2885 | ||
| 2974 | live: function( type, fn ){ |
2886 | live: function( type, fn ){ |
| 2975 | var proxy = jQuery.event.proxy( fn ); |
2887 | var proxy = jQuery.event.proxy( fn ); |
| 2976 | proxy.guid += this.selector + type; |
2888 | proxy.guid += this.selector + type; |
| 2977 | 2889 | ||
| 2978 | jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy ); |
2890 | jQuery( this.context ).bind( liveConvert(type, this.selector), this.selector, proxy ); |
| 2979 | 2891 | ||
| 2980 | return this; |
2892 | return this; |
| 2981 | }, |
2893 | }, |
| 2982 | 2894 | ||
| 2983 | die: function( type, fn ){ |
2895 | die: function( type, fn ){ |
| 2984 | jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null ); |
2896 | jQuery( this.context ).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null ); |
| 2985 | return this; |
2897 | return this; |
| 2986 | }
|
2898 | }
|
| 2987 | }); |
2899 | }); |
| 2988 | 2900 | ||
| 2989 | function liveHandler( event ){ |
2901 | function liveHandler( event ){ |
| 2990 | var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"), |
2902 | var check = new RegExp("(^|\\.)" + event.type + "(\\.|$)"), |
| 2991 | stop = true, |
2903 | stop = true, |
| 2992 | elems = []; |
2904 | elems = []; |
| 2993 | 2905 | ||
| 2994 | jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){ |
2906 | jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){ |
| 2995 | if ( check.test(fn.type) ) { |
2907 | if ( check.test(fn.type) ) { |
| Строка 3002... | Строка 2914... | ||
| 3002 | elems.sort(function(a,b) { |
2914 | elems.sort(function(a,b) { |
| 3003 | return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "closest"); |
2915 | return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "closest"); |
| 3004 | }); |
2916 | }); |
| 3005 | 2917 | ||
| 3006 | jQuery.each(elems, function(){ |
2918 | jQuery.each(elems, function(){ |
| - | 2919 | event.currentTarget = this.elem; |
|
| 3007 | if ( this.fn.call(this.elem, event, this.fn.data) === false ) |
2920 | if ( this.fn.call(this.elem, event, this.fn.data) === false ) |
| 3008 | return (stop = false); |
2921 | return (stop = false); |
| 3009 | }); |
2922 | }); |
| 3010 | 2923 | ||
| 3011 | return stop; |
2924 | return stop; |
| Строка 3101... | Строка 3014... | ||
| 3101 | }); |
3014 | }); |
| 3102 | 3015 | ||
| 3103 | // Prevent memory leaks in IE
|
3016 | // Prevent memory leaks in IE
|
| 3104 | // And prevent errors on refresh with events like mouseover in other browsers
|
3017 | // And prevent errors on refresh with events like mouseover in other browsers
|
| 3105 | // Window isn't included so as not to unbind existing unload events
|
3018 | // Window isn't included so as not to unbind existing unload events
|
| - | 3019 | // More info:
|
|
| - | 3020 | // - http://isaacschlueter.com/2006/10/msie-memory-leaks/
|
|
| - | 3021 | // - https://bugzilla.mozilla.org/show_bug.cgi?id=252542
|
|
| 3106 | jQuery( window ).bind( 'unload', function(){ |
3022 | jQuery( window ).bind( 'unload', function(){ |
| 3107 | for ( var id in jQuery.cache ) |
3023 | for ( var id in jQuery.cache ) |
| 3108 | // Skip the window
|
3024 | // Skip the window
|
| 3109 | if ( id != 1 && jQuery.cache[ id ].handle ) |
3025 | if ( id != 1 && jQuery.cache[ id ].handle ) |
| 3110 | jQuery.event.remove( jQuery.cache[ id ].handle.elem ); |
3026 | jQuery.event.remove( jQuery.cache[ id ].handle.elem ); |
| Строка 3117... | Строка 3033... | ||
| 3117 | script = document.createElement("script"), |
3033 | script = document.createElement("script"), |
| 3118 | div = document.createElement("div"), |
3034 | div = document.createElement("div"), |
| 3119 | id = "script" + (new Date).getTime(); |
3035 | id = "script" + (new Date).getTime(); |
| 3120 | 3036 | ||
| 3121 | div.style.display = "none"; |
3037 | div.style.display = "none"; |
| 3122 | div.innerHTML = ' <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>'; |
3038 | div.innerHTML = ' <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select>'; |
| 3123 | 3039 | ||
| 3124 | var all = div.getElementsByTagName("*"), |
3040 | var all = div.getElementsByTagName("*"), |
| 3125 | a = div.getElementsByTagName("a")[0]; |
3041 | a = div.getElementsByTagName("a")[0]; |
| 3126 | 3042 | ||
| 3127 | // Can't get basic test support
|
3043 | // Can't get basic test support
|
| Строка 3135... | Строка 3051... | ||
| 3135 | 3051 | ||
| 3136 | // Make sure that tbody elements aren't automatically inserted
|
3052 | // Make sure that tbody elements aren't automatically inserted
|
| 3137 | // IE will insert them into empty tables
|
3053 | // IE will insert them into empty tables
|
| 3138 | tbody: !div.getElementsByTagName("tbody").length, |
3054 | tbody: !div.getElementsByTagName("tbody").length, |
| 3139 | 3055 | ||
| 3140 | // Make sure that you can get all elements in an <object> element
|
- | |
| 3141 | // IE 7 always returns no results
|
- | |
| 3142 | objectAll: !!div.getElementsByTagName("object")[0] |
- | |
| 3143 | .getElementsByTagName("*").length, |
- | |
| 3144 | - | ||
| 3145 | // Make sure that link elements get serialized correctly by innerHTML
|
3056 | // Make sure that link elements get serialized correctly by innerHTML
|
| 3146 | // This requires a wrapper element in IE
|
3057 | // This requires a wrapper element in IE
|
| 3147 | htmlSerialize: !!div.getElementsByTagName("link").length, |
3058 | htmlSerialize: !!div.getElementsByTagName("link").length, |
| 3148 | 3059 | ||
| 3149 | // Get the style information from getAttribute
|
3060 | // Get the style information from getAttribute
|
| Строка 3184... | Строка 3095... | ||
| 3184 | }
|
3095 | }
|
| 3185 | 3096 | ||
| 3186 | root.removeChild( script ); |
3097 | root.removeChild( script ); |
| 3187 | 3098 | ||
| 3188 | if ( div.attachEvent && div.fireEvent ) { |
3099 | if ( div.attachEvent && div.fireEvent ) { |
| 3189 | div.attachEvent("onclick", function(){ |
3100 | div.attachEvent("onclick", function click(){ |
| 3190 | // Cloning a node shouldn't copy over any
|
3101 | // Cloning a node shouldn't copy over any
|
| 3191 | // bound event handlers (IE does this)
|
3102 | // bound event handlers (IE does this)
|
| 3192 | jQuery.support.noCloneEvent = false; |
3103 | jQuery.support.noCloneEvent = false; |
| 3193 | div.detachEvent("onclick", arguments.callee); |
3104 | div.detachEvent("onclick", click); |
| 3194 | }); |
3105 | }); |
| 3195 | div.cloneNode(true).fireEvent("onclick"); |
3106 | div.cloneNode(true).fireEvent("onclick"); |
| 3196 | }
|
3107 | }
|
| 3197 | 3108 | ||
| 3198 | // Figure out if the W3C box model works as expected
|
3109 | // Figure out if the W3C box model works as expected
|
| Строка 3205... | Строка 3116... | ||
| 3205 | jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2; |
3116 | jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2; |
| 3206 | document.body.removeChild( div ).style.display = 'none'; |
3117 | document.body.removeChild( div ).style.display = 'none'; |
| 3207 | }); |
3118 | }); |
| 3208 | })(); |
3119 | })(); |
| 3209 | 3120 | ||
| 3210 | var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat"; |
- | |
| 3211 | - | ||
| 3212 | jQuery.props = { |
3121 | jQuery.props = { |
| 3213 | "for": "htmlFor", |
3122 | "for": "htmlFor", |
| 3214 | "class": "className", |
3123 | "class": "className", |
| 3215 | "float": styleFloat, |
- | |
| 3216 | cssFloat: styleFloat, |
- | |
| 3217 | styleFloat: styleFloat, |
- | |
| 3218 | readonly: "readOnly", |
3124 | readonly: "readOnly", |
| 3219 | maxlength: "maxLength", |
3125 | maxlength: "maxLength", |
| 3220 | cellspacing: "cellSpacing", |
3126 | cellspacing: "cellSpacing", |
| 3221 | rowspan: "rowSpan", |
3127 | rowspan: "rowSpan", |
| 3222 | tabindex: "tabIndex" |
3128 | tabindex: "tabIndex" |
| 3223 | }; |
3129 | }; |
| - | 3130 | // exclude the following css properties to add px
|
|
| - | 3131 | var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i, |
|
| - | 3132 | // cache defaultView
|
|
| - | 3133 | defaultView = document.defaultView || {}, |
|
| - | 3134 | // normalize float css property
|
|
| - | 3135 | styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat"; |
|
| - | 3136 | ||
| - | 3137 | jQuery.fn.css = function( name, value ) { |
|
| - | 3138 | var options = name, isFunction = jQuery.isFunction( value ); |
|
| - | 3139 | ||
| - | 3140 | // ignore negative width and height values
|
|
| - | 3141 | if ( (name == 'width' || name == 'height') && parseFloat(value) < 0 ) |
|
| - | 3142 | value = undefined; |
|
| - | 3143 | ||
| - | 3144 | if ( typeof name === "string" ) { |
|
| - | 3145 | // Are we setting the style?
|
|
| - | 3146 | if ( value === undefined ) { |
|
| - | 3147 | return this.length ? |
|
| - | 3148 | jQuery.css( this[0], name ) : |
|
| - | 3149 | null; |
|
| - | 3150 | ||
| - | 3151 | // Convert name, value params to options hash format
|
|
| - | 3152 | } else { |
|
| - | 3153 | options = {}; |
|
| - | 3154 | options[ name ] = value; |
|
| - | 3155 | }
|
|
| - | 3156 | }
|
|
| - | 3157 | ||
| - | 3158 | // For each element...
|
|
| - | 3159 | for ( var i = 0, l = this.length; i < l; i++ ) { |
|
| - | 3160 | var elem = this[i]; |
|
| - | 3161 | ||
| - | 3162 | // Set all the styles
|
|
| - | 3163 | for ( var prop in options ) { |
|
| - | 3164 | value = options[prop]; |
|
| - | 3165 | ||
| - | 3166 | if ( isFunction ) { |
|
| - | 3167 | value = value.call( elem, i ); |
|
| - | 3168 | }
|
|
| - | 3169 | ||
| - | 3170 | if ( typeof value === "number" && !exclude.test(prop) ) { |
|
| - | 3171 | value = value + "px"; |
|
| - | 3172 | }
|
|
| - | 3173 | ||
| - | 3174 | jQuery.style( elem, prop, value ); |
|
| - | 3175 | }
|
|
| - | 3176 | }
|
|
| - | 3177 | ||
| - | 3178 | return this; |
|
| - | 3179 | }; |
|
| - | 3180 | ||
| - | 3181 | jQuery.extend({ |
|
| - | 3182 | style: function( elem, name, value ) { |
|
| - | 3183 | // don't set styles on text and comment nodes
|
|
| - | 3184 | if (!elem || elem.nodeType == 3 || elem.nodeType == 8) |
|
| - | 3185 | return undefined; |
|
| - | 3186 | ||
| - | 3187 | var style = elem.style || elem, set = value !== undefined; |
|
| - | 3188 | ||
| - | 3189 | // IE uses filters for opacity
|
|
| - | 3190 | if ( !jQuery.support.opacity && name == "opacity" ) { |
|
| - | 3191 | if ( set ) { |
|
| - | 3192 | // IE has trouble with opacity if it does not have layout
|
|
| - | 3193 | // Force it by setting the zoom level
|
|
| - | 3194 | style.zoom = 1; |
|
| - | 3195 | ||
| - | 3196 | // Set the alpha filter to set the opacity
|
|
| - | 3197 | style.filter = (style.filter || "").replace( /alpha\([^)]*\)/, "" ) + |
|
| - | 3198 | (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")"); |
|
| - | 3199 | }
|
|
| - | 3200 | ||
| - | 3201 | return style.filter && style.filter.indexOf("opacity=") >= 0 ? |
|
| - | 3202 | (parseFloat( style.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '': |
|
| - | 3203 | ""; |
|
| - | 3204 | }
|
|
| - | 3205 | ||
| - | 3206 | // Make sure we're using the right name for getting the float value
|
|
| - | 3207 | if ( /float/i.test( name ) ) |
|
| - | 3208 | name = styleFloat; |
|
| - | 3209 | ||
| - | 3210 | name = name.replace(/-([a-z])/ig, function(all, letter){ |
|
| - | 3211 | return letter.toUpperCase(); |
|
| - | 3212 | }); |
|
| - | 3213 | ||
| - | 3214 | if ( set ) |
|
| - | 3215 | style[ name ] = value; |
|
| - | 3216 | ||
| - | 3217 | return style[ name ]; |
|
| - | 3218 | }, |
|
| - | 3219 | ||
| - | 3220 | css: function( elem, name, force, extra ) { |
|
| - | 3221 | if ( name == "width" || name == "height" ) { |
|
| - | 3222 | var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ]; |
|
| - | 3223 | ||
| - | 3224 | function getWH() { |
|
| - | 3225 | val = name == "width" ? elem.offsetWidth : elem.offsetHeight; |
|
| - | 3226 | ||
| - | 3227 | if ( extra === "border" ) |
|
| - | 3228 | return; |
|
| - | 3229 | ||
| - | 3230 | jQuery.each( which, function() { |
|
| - | 3231 | if ( !extra ) |
|
| - | 3232 | val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0; |
|
| - | 3233 | if ( extra === "margin" ) |
|
| - | 3234 | val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0; |
|
| - | 3235 | else
|
|
| - | 3236 | val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0; |
|
| - | 3237 | }); |
|
| - | 3238 | }
|
|
| - | 3239 | ||
| - | 3240 | if ( elem.offsetWidth !== 0 ) |
|
| - | 3241 | getWH(); |
|
| - | 3242 | else
|
|
| - | 3243 | jQuery.swap( elem, props, getWH ); |
|
| - | 3244 | ||
| - | 3245 | return Math.max(0, Math.round(val)); |
|
| - | 3246 | }
|
|
| - | 3247 | ||
| - | 3248 | return jQuery.curCSS( elem, name, force ); |
|
| - | 3249 | }, |
|
| - | 3250 | ||
| - | 3251 | curCSS: function( elem, name, force ) { |
|
| - | 3252 | var ret, style = elem.style; |
|
| - | 3253 | ||
| - | 3254 | // IE uses filters for opacity
|
|
| - | 3255 | if ( !jQuery.support.opacity && name == "opacity" ) { |
|
| - | 3256 | ret = style.filter && style.filter.indexOf("opacity=") >= 0 ? |
|
| - | 3257 | (parseFloat( style.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '': |
|
| - | 3258 | ""; |
|
| - | 3259 | ||
| - | 3260 | return ret === "" ? |
|
| - | 3261 | "1" : |
|
| - | 3262 | ret;
|
|
| - | 3263 | }
|
|
| - | 3264 | ||
| - | 3265 | // Make sure we're using the right name for getting the float value
|
|
| - | 3266 | if ( /float/i.test( name ) ) |
|
| - | 3267 | name = styleFloat; |
|
| - | 3268 | ||
| - | 3269 | if ( !force && style && style[ name ] ) { |
|
| - | 3270 | ret = style[ name ]; |
|
| - | 3271 | ||
| - | 3272 | } else if ( defaultView.getComputedStyle ) { |
|
| - | 3273 | ||
| - | 3274 | // Only "float" is needed here
|
|
| - | 3275 | if ( /float/i.test( name ) ) |
|
| - | 3276 | name = "float"; |
|
| - | 3277 | ||
| - | 3278 | name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase(); |
|
| - | 3279 | ||
| - | 3280 | var computedStyle = defaultView.getComputedStyle( elem, null ); |
|
| - | 3281 | ||
| - | 3282 | if ( computedStyle ) |
|
| - | 3283 | ret = computedStyle.getPropertyValue( name ); |
|
| - | 3284 | ||
| - | 3285 | // We should always get a number back from opacity
|
|
| - | 3286 | if ( name == "opacity" && ret == "" ) |
|
| - | 3287 | ret = "1"; |
|
| - | 3288 | ||
| - | 3289 | } else if ( elem.currentStyle ) { |
|
| - | 3290 | var camelCase = name.replace(/\-(\w)/g, function(all, letter){ |
|
| - | 3291 | return letter.toUpperCase(); |
|
| - | 3292 | }); |
|
| - | 3293 | ||
| - | 3294 | ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ]; |
|
| - | 3295 | ||
| - | 3296 | // From the awesome hack by Dean Edwards
|
|
| - | 3297 | // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
|
|
| - | 3298 | ||
| - | 3299 | // If we're not dealing with a regular pixel number
|
|
| - | 3300 | // but a number that has a weird ending, we need to convert it to pixels
|
|
| - | 3301 | if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) { |
|
| - | 3302 | // Remember the original values
|
|
| - | 3303 | var left = style.left, rsLeft = elem.runtimeStyle.left; |
|
| - | 3304 | ||
| - | 3305 | // Put in the new values to get a computed value out
|
|
| - | 3306 | elem.runtimeStyle.left = elem.currentStyle.left; |
|
| - | 3307 | style.left = ret || 0; |
|
| - | 3308 | ret = style.pixelLeft + "px"; |
|
| - | 3309 | ||
| - | 3310 | // Revert the changed values
|
|
| - | 3311 | style.left = left; |
|
| - | 3312 | elem.runtimeStyle.left = rsLeft; |
|
| - | 3313 | }
|
|
| - | 3314 | }
|
|
| - | 3315 | ||
| - | 3316 | return ret; |
|
| - | 3317 | }, |
|
| - | 3318 | ||
| - | 3319 | // A method for quickly swapping in/out CSS properties to get correct calculations
|
|
| - | 3320 | swap: function( elem, options, callback ) { |
|
| - | 3321 | var old = {}; |
|
| - | 3322 | // Remember the old values, and insert the new ones
|
|
| - | 3323 | for ( var name in options ) { |
|
| - | 3324 | old[ name ] = elem.style[ name ]; |
|
| - | 3325 | elem.style[ name ] = options[ name ]; |
|
| - | 3326 | }
|
|
| - | 3327 | ||
| - | 3328 | callback.call( elem ); |
|
| - | 3329 | ||
| - | 3330 | // Revert the old values
|
|
| - | 3331 | for ( var name in options ) |
|
| - | 3332 | elem.style[ name ] = old[ name ]; |
|
| - | 3333 | }
|
|
| 3224 | jQuery.fn.extend({ |
3334 | });jQuery.fn.extend({ |
| 3225 | // Keep a copy of the old load
|
3335 | // Keep a copy of the old load
|
| 3226 | _load: jQuery.fn.load, |
3336 | _load: jQuery.fn.load, |
| 3227 | 3337 | ||
| 3228 | load: function( url, params, callback ) { |
3338 | load: function( url, params, callback ) { |
| 3229 | if ( typeof url !== "string" ) |
3339 | if ( typeof url !== "string" ) |
| Строка 3496... | Строка 3606... | ||
| 3496 | head.removeChild( script ); |
3606 | head.removeChild( script ); |
| 3497 | }
|
3607 | }
|
| 3498 | }; |
3608 | }; |
| 3499 | }
|
3609 | }
|
| 3500 | 3610 | ||
| - | 3611 | // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
|
| - | 3612 | // This arises when a base node is used (#2709 and #4378).
|
|
| 3501 | head.appendChild(script); |
3613 | head.insertBefore( script, head.firstChild ); |
| 3502 | 3614 | ||
| 3503 | // We handle everything using the script element injection
|
3615 | // We handle everything using the script element injection
|
| 3504 | return undefined; |
3616 | return undefined; |
| 3505 | }
|
3617 | }
|
| 3506 | 3618 | ||
| Строка 3857... | Строка 3969... | ||
| 3857 | }) : |
3969 | }) : |
| 3858 | this.animate(genFx("toggle", 3), fn, fn2); |
3970 | this.animate(genFx("toggle", 3), fn, fn2); |
| 3859 | }, |
3971 | }, |
| 3860 | 3972 | ||
| 3861 | fadeTo: function(speed,to,callback){ |
3973 | fadeTo: function(speed,to,callback){ |
| - | 3974 | return this.filter(":hidden").css('opacity', 0).show().end() |
|
| 3862 | return this.animate({opacity: to}, speed, callback); |
3975 | .animate({opacity: to}, speed, callback); |
| 3863 | }, |
3976 | }, |
| 3864 | 3977 | ||
| 3865 | animate: function( prop, speed, easing, callback ) { |
3978 | animate: function( prop, speed, easing, callback ) { |
| 3866 | var optall = jQuery.speed(speed, easing, callback); |
3979 | var optall = jQuery.speed(speed, easing, callback); |
| 3867 | 3980 | ||
| Строка 4066... | Строка 4179... | ||
| 4066 | }, |
4179 | }, |
| 4067 | 4180 | ||
| 4068 | // Simple 'show' function
|
4181 | // Simple 'show' function
|
| 4069 | show: function(){ |
4182 | show: function(){ |
| 4070 | // Remember where we started, so that we can go back to it later
|
4183 | // Remember where we started, so that we can go back to it later
|
| 4071 | this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop ); |
4184 | this.options.orig[this.prop] = jQuery.style( this.elem, this.prop ); |
| 4072 | this.options.show = true; |
4185 | this.options.show = true; |
| 4073 | 4186 | ||
| 4074 | // Begin the animation
|
4187 | // Begin the animation
|
| 4075 | // Make sure that we start at a small width/height to avoid any
|
4188 | // Make sure that we start at a small width/height to avoid any
|
| 4076 | // flash of content
|
4189 | // flash of content
|
| Строка 4081... | Строка 4194... | ||
| 4081 | }, |
4194 | }, |
| 4082 | 4195 | ||
| 4083 | // Simple 'hide' function
|
4196 | // Simple 'hide' function
|
| 4084 | hide: function(){ |
4197 | hide: function(){ |
| 4085 | // Remember where we started, so that we can go back to it later
|
4198 | // Remember where we started, so that we can go back to it later
|
| 4086 | this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop ); |
4199 | this.options.orig[this.prop] = jQuery.style( this.elem, this.prop ); |
| 4087 | this.options.hide = true; |
4200 | this.options.hide = true; |
| 4088 | 4201 | ||
| 4089 | // Begin the animation
|
4202 | // Begin the animation
|
| 4090 | this.custom(this.cur(), 0); |
4203 | this.custom(this.cur(), 0); |
| 4091 | }, |
4204 | }, |
| Строка 4122... | Строка 4235... | ||
| 4122 | jQuery(this.elem).hide(); |
4235 | jQuery(this.elem).hide(); |
| 4123 | 4236 | ||
| 4124 | // Reset the properties, if the item has been hidden or shown
|
4237 | // Reset the properties, if the item has been hidden or shown
|
| 4125 | if ( this.options.hide || this.options.show ) |
4238 | if ( this.options.hide || this.options.show ) |
| 4126 | for ( var p in this.options.curAnim ) |
4239 | for ( var p in this.options.curAnim ) |
| 4127 | jQuery.attr(this.elem.style, p, this.options.orig[p]); |
4240 | jQuery.style(this.elem, p, this.options.orig[p]); |
| 4128 | 4241 | ||
| 4129 | // Execute the complete function
|
4242 | // Execute the complete function
|
| 4130 | this.options.complete.call( this.elem ); |
4243 | this.options.complete.call( this.elem ); |
| 4131 | }
|
4244 | }
|
| 4132 | 4245 | ||
| Строка 4156... | Строка 4269... | ||
| 4156 | _default: 400 |
4269 | _default: 400 |
| 4157 | }, |
4270 | }, |
| 4158 | step: { |
4271 | step: { |
| 4159 | 4272 | ||
| 4160 | opacity: function(fx){ |
4273 | opacity: function(fx){ |
| 4161 | jQuery.attr(fx.elem.style, "opacity", fx.now); |
4274 | jQuery.style(fx.elem, "opacity", fx.now); |
| 4162 | }, |
4275 | }, |
| 4163 | 4276 | ||
| 4164 | _default: function(fx){ |
4277 | _default: function(fx){ |
| 4165 | if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) |
4278 | if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) |
| 4166 | fx.elem.style[ fx.prop ] = fx.now + fx.unit; |
4279 | fx.elem.style[ fx.prop ] = fx.now + fx.unit; |
| 4167 | else
|
4280 | else
|
| 4168 | fx.elem[ fx.prop ] = fx.now; |
4281 | fx.elem[ fx.prop ] = fx.now; |
| 4169 | }
|
4282 | }
|
| 4170 | }
|
4283 | }
|
| 4171 | }); |
4284 | }); |
| 4172 | if ( document.documentElement["getBoundingClientRect"] ) |
4285 | if ( "getBoundingClientRect" in document.documentElement ) |
| 4173 | jQuery.fn.offset = function() { |
4286 | jQuery.fn.offset = function() { |
| - | 4287 | var elem = this[0]; |
|
| 4174 | if ( !this[0] ) return { top: 0, left: 0 }; |
4288 | if ( !elem ) return null; |
| 4175 | if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] ); |
4289 | if ( elem === elem.ownerDocument.body ) return jQuery.offset.bodyOffset( elem ); |
| 4176 | var box = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement, |
4290 | var box = elem.getBoundingClientRect(), doc = elem.ownerDocument, body = doc.body, docElem = doc.documentElement, |
| 4177 | clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, |
4291 | clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, |
| 4178 | top = box.top + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop || body.scrollTop ) - clientTop, |
4292 | top = box.top + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop || body.scrollTop ) - clientTop, |
| 4179 | left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft; |
4293 | left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft; |
| 4180 | return { top: top, left: left }; |
4294 | return { top: top, left: left }; |
| 4181 | }; |
4295 | }; |
| 4182 | else
|
4296 | else
|
| 4183 | jQuery.fn.offset = function() { |
4297 | jQuery.fn.offset = function() { |
| - | 4298 | var elem = this[0]; |
|
| 4184 | if ( !this[0] ) return { top: 0, left: 0 }; |
4299 | if ( !elem ) return null; |
| 4185 | if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] ); |
4300 | if ( elem === elem.ownerDocument.body ) return jQuery.offset.bodyOffset( elem ); |
| 4186 | jQuery.offset.initialized || jQuery.offset.initialize(); |
4301 | jQuery.offset.initialize(); |
| 4187 | 4302 | ||
| 4188 | var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem, |
4303 | var offsetParent = elem.offsetParent, prevOffsetParent = elem, |
| 4189 | doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement, |
4304 | doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement, |
| 4190 | body = doc.body, defaultView = doc.defaultView, |
4305 | body = doc.body, defaultView = doc.defaultView, |
| 4191 | prevComputedStyle = defaultView.getComputedStyle(elem, null), |
4306 | prevComputedStyle = defaultView.getComputedStyle(elem, null), |
| 4192 | top = elem.offsetTop, left = elem.offsetLeft; |
4307 | top = elem.offsetTop, left = elem.offsetLeft; |
| 4193 | 4308 | ||
| 4194 | while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) { |
4309 | while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) { |
| - | 4310 | if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) break; |
|
| 4195 | computedStyle = defaultView.getComputedStyle(elem, null); |
4311 | computedStyle = defaultView.getComputedStyle(elem, null); |
| 4196 | top -= elem.scrollTop, left -= elem.scrollLeft; |
4312 | top -= elem.scrollTop, left -= elem.scrollLeft; |
| 4197 | if ( elem === offsetParent ) { |
4313 | if ( elem === offsetParent ) { |
| 4198 | top += elem.offsetTop, left += elem.offsetLeft; |
4314 | top += elem.offsetTop, left += elem.offsetLeft; |
| 4199 | if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) ) |
4315 | if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) ) |
| 4200 | top += parseInt( computedStyle.borderTopWidth, 10) || 0, |
4316 | top += parseFloat( computedStyle.borderTopWidth, 10) || 0, |
| 4201 | left += parseInt( computedStyle.borderLeftWidth, 10) || 0; |
4317 | left += parseFloat( computedStyle.borderLeftWidth, 10) || 0; |
| 4202 | prevOffsetParent = offsetParent, offsetParent = elem.offsetParent; |
4318 | prevOffsetParent = offsetParent, offsetParent = elem.offsetParent; |
| 4203 | }
|
4319 | }
|
| 4204 | if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) |
4320 | if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) |
| 4205 | top += parseInt( computedStyle.borderTopWidth, 10) || 0, |
4321 | top += parseFloat( computedStyle.borderTopWidth, 10) || 0, |
| 4206 | left += parseInt( computedStyle.borderLeftWidth, 10) || 0; |
4322 | left += parseFloat( computedStyle.borderLeftWidth, 10) || 0; |
| 4207 | prevComputedStyle = computedStyle; |
4323 | prevComputedStyle = computedStyle; |
| 4208 | }
|
4324 | }
|
| 4209 | 4325 | ||
| 4210 | if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) |
4326 | if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) |
| 4211 | top += body.offsetTop, |
4327 | top += body.offsetTop, |
| 4212 | left += body.offsetLeft; |
4328 | left += body.offsetLeft; |
| 4213 | 4329 | ||
| 4214 | if ( prevComputedStyle.position === "fixed" ) |
4330 | if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) |
| 4215 | top += Math.max(docElem.scrollTop, body.scrollTop), |
4331 | top += Math.max(docElem.scrollTop, body.scrollTop), |
| 4216 | left += Math.max(docElem.scrollLeft, body.scrollLeft); |
4332 | left += Math.max(docElem.scrollLeft, body.scrollLeft); |
| 4217 | 4333 | ||
| 4218 | return { top: top, left: left }; |
4334 | return { top: top, left: left }; |
| 4219 | }; |
4335 | }; |
| 4220 | 4336 | ||
| 4221 | jQuery.offset = { |
4337 | jQuery.offset = { |
| 4222 | initialize: function() { |
4338 | initialize: function() { |
| 4223 | if ( this.initialized ) return; |
- | |
| 4224 | var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop, |
4339 | var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, prop, bodyMarginTop = body.style.marginTop, |
| 4225 | html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;" cellpadding="0" cellspacing="0"><tr><td></td></tr></table>'; |
4340 | html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;" cellpadding="0" cellspacing="0"><tr><td></td></tr></table>'; |
| 4226 | 4341 | ||
| 4227 | rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' }; |
4342 | jQuery.extend( container.style, { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' } ); |
| 4228 | for ( prop in rules ) container.style[prop] = rules[prop]; |
- | |
| 4229 | 4343 | ||
| 4230 | container.innerHTML = html; |
4344 | container.innerHTML = html; |
| 4231 | body.insertBefore(container, body.firstChild); |
4345 | body.insertBefore(container, body.firstChild); |
| 4232 | innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild; |
4346 | innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild; |
| 4233 | 4347 | ||
| 4234 | this.doesNotAddBorder = (checkDiv.offsetTop !== 5); |
4348 | this.doesNotAddBorder = (checkDiv.offsetTop !== 5); |
| 4235 | this.doesAddBorderForTableAndCells = (td.offsetTop === 5); |
4349 | this.doesAddBorderForTableAndCells = (td.offsetTop === 5); |
| 4236 | 4350 | ||
| - | 4351 | checkDiv.style.position = 'fixed', checkDiv.style.top = '20px'; |
|
| - | 4352 | this.supportsFixedPosition = (checkDiv.offsetTop >= 15); // safari subtracts parent border width here which is 5px |
|
| - | 4353 | checkDiv.style.position = '', checkDiv.style.top = ''; |
|
| - | 4354 | ||
| 4237 | innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative'; |
4355 | innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative'; |
| 4238 | this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5); |
4356 | this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5); |
| 4239 | 4357 | ||
| 4240 | body.style.marginTop = '1px'; |
4358 | body.style.marginTop = '1px'; |
| 4241 | this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0); |
4359 | this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0); |
| 4242 | body.style.marginTop = bodyMarginTop; |
4360 | body.style.marginTop = bodyMarginTop; |
| 4243 | 4361 | ||
| 4244 | body.removeChild(container); |
4362 | body.removeChild(container); |
| 4245 | this.initialized = true; |
4363 | jQuery.offset.initialize = function(){}; |
| 4246 | }, |
4364 | }, |
| 4247 | 4365 | ||
| 4248 | bodyOffset: function(body) { |
4366 | bodyOffset: function(body) { |
| 4249 | jQuery.offset.initialized || jQuery.offset.initialize(); |
4367 | jQuery.offset.initialize(); |
| 4250 | var top = body.offsetTop, left = body.offsetLeft; |
4368 | var top = body.offsetTop, left = body.offsetLeft; |
| 4251 | if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) |
4369 | if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) |
| 4252 | top += parseInt( jQuery.curCSS(body, 'marginTop', true), 10 ) || 0, |
4370 | top += parseFloat( jQuery.curCSS(body, 'marginTop', true), 10 ) || 0, |
| 4253 | left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0; |
4371 | left += parseFloat( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0; |
| 4254 | return { top: top, left: left }; |
4372 | return { top: top, left: left }; |
| 4255 | }
|
4373 | }
|
| 4256 | }; |
4374 | }; |
| 4257 | 4375 | ||
| 4258 | 4376 | ||
| 4259 | jQuery.fn.extend({ |
4377 | jQuery.fn.extend({ |
| 4260 | position: function() { |
4378 | position: function() { |
| - | 4379 | if ( !this[0] ) return null; |
|
| - | 4380 | ||
| 4261 | var left = 0, top = 0, results; |
4381 | var elem = this[0], left = 0, top = 0, results, |
| 4262 | 4382 | ||
| 4263 | if ( this[0] ) { |
- | |
| 4264 | // Get *real* offsetParent
|
4383 | // Get *real* offsetParent
|
| 4265 | var offsetParent = this.offsetParent(), |
4384 | offsetParent = this.offsetParent(), |
| 4266 | 4385 | ||
| 4267 | // Get correct offsets
|
4386 | // Get correct offsets
|
| 4268 | offset = this.offset(), |
4387 | offset = this.offset(), |
| 4269 | parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset(); |
4388 | parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset(); |
| 4270 | 4389 | ||
| 4271 | // Subtract element margins
|
4390 | // Subtract element margins
|
| 4272 | // note: when an element has margin: auto the offsetLeft and marginLeft
|
4391 | // note: when an element has margin: auto the offsetLeft and marginLeft
|
| 4273 | // are the same in Safari causing offset.left to incorrectly be 0
|
4392 | // are the same in Safari causing offset.left to incorrectly be 0
|
| 4274 | offset.top -= num( this, 'marginTop' ); |
4393 | offset.top -= parseFloat( jQuery.curCSS(elem, 'marginTop', true), 10 ) || 0; |
| 4275 | offset.left -= num( this, 'marginLeft' ); |
4394 | offset.left -= parseFloat( jQuery.curCSS(elem, 'marginLeft', true), 10 ) || 0; |
| 4276 | 4395 | ||
| 4277 | // Add offsetParent borders
|
4396 | // Add offsetParent borders
|
| 4278 | parentOffset.top += num( offsetParent, 'borderTopWidth' ); |
4397 | parentOffset.top += parseFloat( jQuery.curCSS(offsetParent[0], 'borderTopWidth', true), 10 ) || 0; |
| 4279 | parentOffset.left += num( offsetParent, 'borderLeftWidth' ); |
4398 | parentOffset.left += parseFloat( jQuery.curCSS(offsetParent[0], 'borderLeftWidth', true), 10 ) || 0; |
| 4280 | 4399 | ||
| 4281 | // Subtract the two offsets
|
4400 | // Subtract the two offsets
|
| 4282 | results = { |
4401 | results = { |
| 4283 | top: offset.top - parentOffset.top, |
4402 | top: offset.top - parentOffset.top, |
| 4284 | left: offset.left - parentOffset.left |
4403 | left: offset.left - parentOffset.left |
| 4285 | }; |
4404 | }; |
| 4286 | }
|
- | |
| 4287 | 4405 | ||
| 4288 | return results; |
4406 | return results; |
| 4289 | }, |
4407 | }, |
| 4290 | 4408 | ||
| 4291 | offsetParent: function() { |
4409 | offsetParent: function() { |
| Строка 4325... | Строка 4443... | ||
| 4325 | }; |
4443 | }; |
| 4326 | }); |
4444 | }); |
| 4327 | // Create innerHeight, innerWidth, outerHeight and outerWidth methods
|
4445 | // Create innerHeight, innerWidth, outerHeight and outerWidth methods
|
| 4328 | jQuery.each([ "Height", "Width" ], function(i, name){ |
4446 | jQuery.each([ "Height", "Width" ], function(i, name){ |
| 4329 | 4447 | ||
| 4330 | var tl = i ? "Left" : "Top", // top or left |
- | |
| 4331 | br = i ? "Right" : "Bottom", // bottom or right |
- | |
| 4332 | lower = name.toLowerCase(); |
4448 | var type = name.toLowerCase(); |
| 4333 | 4449 | ||
| 4334 | // innerHeight and innerWidth
|
4450 | // innerHeight and innerWidth
|
| 4335 | jQuery.fn["inner" + name] = function(){ |
4451 | jQuery.fn["inner" + name] = function(){ |
| 4336 | return this[0] ? |
4452 | return this[0] ? |
| 4337 | jQuery.css( this[0], lower, false, "padding" ) : |
4453 | jQuery.css( this[0], type, false, "padding" ) : |
| 4338 | null; |
4454 | null; |
| 4339 | }; |
4455 | }; |
| 4340 | 4456 | ||
| 4341 | // outerHeight and outerWidth
|
4457 | // outerHeight and outerWidth
|
| 4342 | jQuery.fn["outer" + name] = function(margin) { |
4458 | jQuery.fn["outer" + name] = function(margin) { |
| 4343 | return this[0] ? |
4459 | return this[0] ? |
| 4344 | jQuery.css( this[0], lower, false, margin ? "margin" : "border" ) : |
4460 | jQuery.css( this[0], type, false, margin ? "margin" : "border" ) : |
| 4345 | null; |
4461 | null; |
| 4346 | }; |
4462 | }; |
| 4347 | 4463 | ||
| 4348 | var type = name.toLowerCase(); |
- | |
| 4349 | - | ||
| 4350 | jQuery.fn[ type ] = function( size ) { |
4464 | jQuery.fn[ type ] = function( size ) { |
| 4351 | // Get window width or height
|
4465 | // Get window width or height
|
| 4352 | return this[0] == window ? |
4466 | return this[0] == window ? |
| 4353 | // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
|
4467 | // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
|
| 4354 | document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || |
4468 | document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || |