Редакция 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.
|
16 | window = this, |
16 | window = this, |
17 | // Will speed up references to undefined, and allows munging its name.
|
17 | // Will speed up references to undefined, and allows munging its name.
|
18 | undefined, |
18 | undefined, |
19 | // Map over jQuery in case of overwrite
|
19 | // Map over jQuery in case of overwrite
|
Строка 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 | ||
230 | while ( elem.firstChild ) |
243 | // Prevent never-ending loop
|
231 | elem = elem.firstChild; |
244 | if ( target === copy ) |
- | 245 | continue; |
|
232 | 246 | ||
233 | return elem; |
247 | // Recurse if we're merging object values
|
- | 248 | if ( deep && copy && typeof copy === "object" && !copy.nodeType ) |
|
234 | }).append(this); |
249 | target[ name ] = jQuery.extend( deep, |
- | 250 | // Never move original objects, clone them
|
|
- | 251 | src || ( copy.length != null ? [ ] : { } ) |
|
235 | }
|
252 | , copy ); |
236 | 253 | ||
- | 254 | // Don't bring in undefined values
|
|
- | 255 | else if ( copy !== undefined ) |
|
237 | return this; |
256 | target[ name ] = copy; |
238 | }, |
- | |
239 | 257 | ||
240 | wrapInner: function( html ) { |
- | |
241 | return this.each(function(){ |
- | |
242 | jQuery( this ).contents().wrapAll( html ); |
- | |
243 | }); |
258 | }
|
244 | }, |
- | |
245 | 259 | ||
246 | wrap: function( html ) { |
260 | // Return the modified object
|
247 | return this.each(function(){ |
261 | return target; |
248 | jQuery( this ).wrapAll( html ); |
- | |
249 | }); |
- | |
250 | }, |
262 | }; |
251 | 263 | ||
252 | append: function() { |
- | |
253 | return this.domManip(arguments, true, function(elem){ |
264 | var toString = Object.prototype.toString; |
254 | if (this.nodeType == 1) |
- | |
255 | this.appendChild( elem ); |
- | |
256 | }); |
- | |
257 | }, |
- | |
258 | 265 | ||
259 | prepend: function() { |
266 | jQuery.extend({ |
260 | return this.domManip(arguments, true, function(elem){ |
267 | noConflict: function( deep ) { |
- | 268 | window.$ = _$; |
|
- | 269 | ||
261 | if (this.nodeType == 1) |
270 | if ( deep ) |
262 | this.insertBefore( elem, this.firstChild ); |
271 | window.jQuery = _jQuery; |
- | 272 | ||
263 | }); |
273 | return jQuery; |
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 ) && |
- | |
352 | jQuery.grep(this, function(elem, i){ |
- | |
353 | return selector.call( elem, i ); |
- | |
354 | }) || |
- | |
355 | - | ||
356 | jQuery.multiFilter( selector, jQuery.grep(this, function(elem){ |
367 | for ( var i = 0, length = array.length; i < length; i++ ) |
357 | return elem.nodeType === 1; |
- | |
358 | }) ), "filter", selector ); |
- | |
359 | }, |
- | |
360 | - | ||
361 | closest: function( selector ) { |
- | |
362 | var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null, |
- | |
363 | closer = 0; |
- | |
364 | - | ||
365 | return this.map(function(){ |
- | |
366 | var cur = this; |
- | |
367 | while ( cur && cur.ownerDocument ) { |
368 | // Use === because on IE, window == document
|
368 | if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) { |
- | |
369 | jQuery.data(cur, "closest", closer); |
369 | if ( array[ i ] === elem ) |
370 | return cur; |
370 | return i; |
371 | }
|
- | |
372 | cur = cur.parentNode; |
- | |
373 | closer++;
|
- | |
374 | }
|
- | |
375 | }); |
- | |
376 | }, |
- | |
377 | - | ||
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
|
- | |
384 | selector = jQuery.multiFilter( selector, this ); |
- | |
385 | 371 | ||
386 | var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType; |
- | |
387 | return this.filter(function() { |
- | |
388 | return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector; |
- | |
389 | }); |
372 | return -1; |
390 | }, |
373 | }, |
391 | 374 | ||
392 | add: function( selector ) { |
375 | merge: function( first, second ) { |
393 | return this.pushStack( jQuery.unique( jQuery.merge( |
376 | // We have to loop this way because IE & Opera overwrite the length
|
394 | this.get(), |
377 | // expando of getElementsByTagName
|
395 | typeof selector === "string" ? |
378 | var i = 0, elem, pos = first.length; |
- | 379 | // Also, we need to make sure that the correct elements are being returned
|
|
- | 380 | // (IE returns comment nodes in a '*' query)
|
|
396 | jQuery( selector ) : |
381 | if ( !jQuery.support.getAll ) { |
- | 382 | while ( (elem = second[ i++ ]) != null ) |
|
397 | jQuery.makeArray( selector ) |
383 | if ( elem.nodeType != 8 ) |
398 | ))); |
384 | first[ pos++ ] = elem; |
399 | }, |
- | |
400 | 385 | ||
401 | is: function( selector ) { |
386 | } else |
402 | return !!selector && jQuery.multiFilter( selector, this ).length > 0; |
387 | while ( (elem = second[ i++ ]) != null ) |
403 | }, |
388 | first[ pos++ ] = elem; |
404 | 389 | ||
405 | hasClass: function( selector ) { |
390 | return first; |
406 | return !!selector && this.is( "." + selector ); |
- | |
407 | }, |
391 | }, |
408 | 392 | ||
409 | val: function( value ) { |
393 | unique: function( array ) { |
410 | if ( value === undefined ) { |
- | |
411 | var elem = this[0]; |
- | |
412 | - | ||
413 | if ( elem ) { |
- | |
414 | if( jQuery.nodeName( elem, 'option' ) ) |
- | |
415 | return (elem.attributes.value || {}).specified ? elem.value : elem.text; |
- | |
416 | - | ||
417 | // We need to handle select boxes special
|
- | |
418 | if ( jQuery.nodeName( elem, "select" ) ) { |
- | |
419 | var index = elem.selectedIndex, |
- | |
420 | values = [], |
- | |
421 | options = elem.options, |
- | |
422 | one = elem.type == "select-one"; |
- | |
423 | - | ||
424 | // Nothing was selected
|
- | |
425 | if ( index < 0 ) |
- | |
426 | return null; |
- | |
427 | - | ||
428 | // Loop through all the selected options
|
- | |
429 | for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { |
- | |
430 | var option = options[ i ]; |
394 | var ret = [], done = {}; |
431 | - | ||
432 | if ( option.selected ) { |
- | |
433 | // Get the specifc value for the option
|
- | |
434 | value = jQuery(option).val(); |
- | |
435 | 395 | ||
436 | // We don't need an array for one selects
|
- | |
437 | if ( one ) |
- | |
438 | return value; |
396 | try { |
439 | 397 | ||
440 | // Multi-Selects return an array
|
398 | for ( var i = 0, length = array.length; i < length; i++ ) { |
441 | values.push( value ); |
399 | var id = jQuery.data( array[ i ] ); |
442 | }
|
- | |
443 | }
|
- | |
444 | 400 | ||
- | 401 | if ( !done[ id ] ) { |
|
445 | return values; |
402 | done[ id ] = true; |
- | 403 | ret.push( array[ i ] ); |
|
446 | }
|
404 | }
|
447 | - | ||
448 | // Everything else, we just grab the value
|
- | |
449 | return (elem.value || "").replace(/\r/g, ""); |
- | |
450 | - | ||
451 | }
|
405 | }
|
452 | 406 | ||
- | 407 | } catch( e ) { |
|
453 | return undefined; |
408 | ret = array; |
454 | }
|
409 | }
|
455 | 410 | ||
456 | if ( typeof value === "number" ) |
- | |
457 | value += ''; |
- | |
458 | - | ||
459 | return this.each(function(){ |
- | |
460 | if ( this.nodeType != 1 ) |
- | |
461 | return; |
411 | return ret; |
462 | - | ||
463 | if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) ) |
- | |
464 | this.checked = (jQuery.inArray(this.value, value) >= 0 || |
- | |
465 | jQuery.inArray(this.name, value) >= 0); |
- | |
466 | - | ||
467 | else if ( jQuery.nodeName( this, "select" ) ) { |
- | |
468 | var values = jQuery.makeArray(value); |
- | |
469 | - | ||
470 | jQuery( "option", this ).each(function(){ |
- | |
471 | this.selected = (jQuery.inArray( this.value, values ) >= 0 || |
- | |
472 | jQuery.inArray( this.text, values ) >= 0); |
- | |
473 | }); |
- | |
474 | - | ||
475 | if ( !values.length ) |
- | |
476 | this.selectedIndex = -1; |
- | |
477 | - | ||
478 | } else |
- | |
479 | this.value = value; |
- | |
480 | }); |
- | |
481 | }, |
- | |
482 | - | ||
483 | html: function( value ) { |
- | |
484 | return value === undefined ? |
- | |
485 | (this[0] ? |
- | |
486 | this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") : |
- | |
487 | null) : |
- | |
488 | this.empty().append( value ); |
- | |
489 | }, |
- | |
490 | - | ||
491 | replaceWith: function( value ) { |
- | |
492 | return this.after( value ).remove(); |
- | |
493 | }, |
412 | }, |
494 | 413 | ||
495 | eq: function( i ) { |
414 | grep: function( elems, callback, inv ) { |
496 | return this.slice( i, +i + 1 ); |
415 | var ret = []; |
497 | }, |
- | |
498 | 416 | ||
- | 417 | // Go through the array, only saving the items
|
|
499 | slice: function() { |
418 | // that pass the validator function
|
500 | return this.pushStack( Array.prototype.slice.apply( this, arguments ), |
419 | for ( var i = 0, length = elems.length; i < length; i++ ) |
501 | "slice", Array.prototype.slice.call(arguments).join(",") ); |
420 | if ( !inv != !callback( elems[ i ], i ) ) |
502 | }, |
421 | ret.push( elems[ i ] ); |
503 | 422 | ||
504 | map: function( callback ) { |
- | |
505 | return this.pushStack( jQuery.map(this, function(elem, i){ |
- | |
506 | return callback.call( elem, i, elem ); |
- | |
507 | })); |
423 | return ret; |
508 | }, |
424 | }, |
509 | 425 | ||
510 | andSelf: function() { |
426 | map: function( elems, callback ) { |
511 | return this.add( this.prevObject ); |
427 | var ret = []; |
512 | }, |
- | |
513 | 428 | ||
514 | domManip: function( args, table, callback ) { |
429 | // Go through the array, translating each of the items to their
|
515 | if ( this[0] ) { |
430 | // new value (or values).
|
516 | var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(), |
- | |
517 | scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ), |
431 | for ( var i = 0, length = elems.length; i < length; i++ ) { |
518 | first = fragment.firstChild; |
432 | var value = callback( elems[ i ], i ); |
519 | 433 | ||
520 | if ( first ) |
434 | if ( value != null ) |
521 | for ( var i = 0, l = this.length; i < l; i++ ) |
- | |
522 | callback.call( root(this[i], first), this.length > 1 || i > 0 ? |
- | |
523 | fragment.cloneNode(true) : fragment ); |
435 | ret[ ret.length ] = value; |
524 | - | ||
525 | if ( scripts ) |
- | |
526 | jQuery.each( scripts, evalScript ); |
- | |
527 | }
|
436 | }
|
528 | 437 | ||
529 | return this; |
- | |
530 | - | ||
531 | function root( elem, cur ) { |
438 | return ret.concat.apply( [], ret ); |
532 | return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ? |
- | |
533 | (elem.getElementsByTagName("tbody")[0] || |
- | |
534 | elem.appendChild(elem.ownerDocument.createElement("tbody"))) : |
- | |
535 | elem;
|
- | |
536 | }
|
- | |
537 | }
|
439 | }
|
538 | }; |
440 | }); |
539 | - | ||
540 | // Give the init function the jQuery prototype for later instantiation
|
- | |
541 | jQuery.fn.init.prototype = jQuery.fn; |
- | |
542 | - | ||
543 | function evalScript( i, elem ) { |
- | |
544 | if ( elem.src ) |
- | |
545 | jQuery.ajax({ |
- | |
546 | url: elem.src, |
- | |
547 | async: false, |
- | |
548 | dataType: "script" |
- | |
549 | }); |
- | |
550 | - | ||
551 | else
|
- | |
552 | jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); |
- | |
553 | - | ||
554 | if ( elem.parentNode ) |
- | |
555 | elem.parentNode.removeChild( elem ); |
- | |
556 | }
|
- | |
557 | - | ||
558 | function now(){ |
- | |
559 | return +new Date; |
- | |
560 | }
|
- | |
561 | - | ||
562 | jQuery.extend = jQuery.fn.extend = function() { |
- | |
563 | // copy reference to target object
|
- | |
564 | var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options; |
- | |
565 | 441 | ||
566 | // Handle a deep copy situation
|
442 | // All jQuery objects should point back to these
|
567 | if ( typeof target === "boolean" ) { |
- | |
568 | deep = target; |
- | |
569 | target = arguments[1] || {}; |
443 | var rootjQuery = jQuery(document); |
570 | // skip the boolean and the target
|
- | |
571 | i = 2; |
- | |
572 | }
|
- | |
573 | 444 | ||
574 | // Handle case when target is a string or something (possible in deep copy)
|
445 | // Use of jQuery.browser is deprecated.
|
575 | if ( typeof target !== "object" && !jQuery.isFunction(target) ) |
446 | // It's included for backwards compatibility and plugins,
|
576 | target = {}; |
447 | // although they should work to migrate away.
|
577 | 448 | ||
578 | // extend jQuery itself if only one argument is passed
|
449 | var userAgent = navigator.userAgent.toLowerCase(); |
579 | if ( length == i ) { |
- | |
580 | target = this; |
- | |
581 | --i; |
- | |
582 | }
|
- | |
583 | 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 ), |
|
- | 456 | msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ), |
|
- | 457 | mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent ) |
|
- | 458 | };var expando = "jQuery" + now(), uuid = 0, windowData = {}; |
|
- | 459 | ||
- | 460 | jQuery.extend({ |
|
- | 461 | cache: {}, |
|
- | 462 | ||
- | 463 | data: function( elem, name, data ) { |
|
- | 464 | elem = elem == window ? |
|
- | 465 | windowData :
|
|
- | 466 | elem;
|
|
- | 467 | ||
- | 468 | var id = elem[ expando ]; |
|
- | 469 | ||
- | 470 | // Compute a unique ID for the element
|
|
- | 471 | if ( !id ) |
|
- | 472 | id = elem[ expando ] = ++uuid; |
|
- | 473 | ||
- | 474 | // Only generate the data cache if we're
|
|
- | 475 | // trying to access or manipulate it
|
|
584 | for ( ; i < length; i++ ) |
476 | if ( name && !jQuery.cache[ id ] ) |
- | 477 | jQuery.cache[ id ] = {}; |
|
- | 478 | ||
585 | // Only deal with non-null/undefined values
|
479 | // Prevent overriding the named cache with undefined values
|
586 | if ( (options = arguments[ i ]) != null ) |
480 | if ( data !== undefined ) |
- | 481 | jQuery.cache[ id ][ name ] = data; |
|
- | 482 | ||
- | 483 | // Return the named cache data, or the ID for the element
|
|
- | 484 | return name ? |
|
- | 485 | jQuery.cache[ id ][ name ] : |
|
- | 486 | id;
|
|
- | 487 | }, |
|
- | 488 | ||
- | 489 | removeData: function( elem, name ) { |
|
- | 490 | elem = elem == window ? |
|
- | 491 | windowData :
|
|
- | 492 | elem;
|
|
- | 493 | ||
- | 494 | var id = elem[ expando ]; |
|
- | 495 | ||
- | 496 | // If we want to remove a specific section of the element's data
|
|
- | 497 | if ( name ) { |
|
- | 498 | if ( jQuery.cache[ id ] ) { |
|
- | 499 | // Remove the section of cache data
|
|
- | 500 | delete jQuery.cache[ id ][ name ]; |
|
- | 501 | ||
- | 502 | // If we've removed all the data, remove the element's cache
|
|
- | 503 | name = ""; |
|
- | 504 | ||
- | 505 | for ( name in jQuery.cache[ id ] ) |
|
- | 506 | break; |
|
- | 507 | ||
- | 508 | if ( !name ) |
|
- | 509 | jQuery.removeData( elem ); |
|
- | 510 | }
|
|
- | 511 | ||
- | 512 | // Otherwise, we want to remove all of the element's data
|
|
- | 513 | } else { |
|
587 | // Extend the base object
|
514 | // Clean up the element expando
|
- | 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 | }
|
|
- | 523 | ||
- | 524 | // Completely remove the data cache
|
|
- | 525 | delete jQuery.cache[ id ]; |
|
- | 526 | }
|
|
- | 527 | }, |
|
- | 528 | queue: function( elem, type, data ) { |
|
- | 529 | if ( elem ){ |
|
- | 530 | ||
- | 531 | type = (type || "fx") + "queue"; |
|
- | 532 | ||
- | 533 | var q = jQuery.data( elem, type ); |
|
- | 534 | ||
- | 535 | if ( !q || jQuery.isArray(data) ) |
|
- | 536 | q = jQuery.data( elem, type, jQuery.makeArray(data) ); |
|
- | 537 | else if( data ) |
|
- | 538 | q.push( data ); |
|
- | 539 | ||
- | 540 | }
|
|
- | 541 | return q; |
|
- | 542 | }, |
|
- | 543 | ||
- | 544 | dequeue: function( elem, type ){ |
|
- | 545 | var queue = jQuery.queue( elem, type ), |
|
- | 546 | fn = queue.shift(); |
|
- | 547 | ||
- | 548 | if( !type || type === "fx" ) |
|
- | 549 | fn = queue[0]; |
|
- | 550 | ||
- | 551 | if( fn !== undefined ) |
|
- | 552 | fn.call(elem); |
|
- | 553 | }
|
|
- | 554 | }); |
|
- | 555 | ||
- | 556 | jQuery.fn.extend({ |
|
- | 557 | data: function( key, value ){ |
|
- | 558 | var parts = key.split("."); |
|
- | 559 | parts[1] = parts[1] ? "." + parts[1] : ""; |
|
- | 560 | ||
588 | for ( var name in options ) { |
561 | if ( value === undefined ) { |
- | 562 | var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); |
|
- | 563 | ||
- | 564 | if ( data === undefined && this.length ) |
|
- | 565 | data = jQuery.data( this[0], key ); |
|
- | 566 | ||
- | 567 | return data === undefined && parts[1] ? |
|
- | 568 | this.data( parts[0] ) : |
|
- | 569 | data;
|
|
- | 570 | } else |
|
- | 571 | return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){ |
|
- | 572 | jQuery.data( this, key, value ); |
|
- | 573 | }); |
|
- | 574 | }, |
|
- | 575 | ||
- | 576 | removeData: function( key ){ |
|
- | 577 | return this.each(function(){ |
|
- | 578 | jQuery.removeData( this, key ); |
|
- | 579 | }); |
|
- | 580 | }, |
|
- | 581 | queue: function(type, data){ |
|
- | 582 | if ( typeof type !== "string" ) { |
|
- | 583 | data = type; |
|
- | 584 | type = "fx"; |
|
- | 585 | }
|
|
- | 586 | ||
- | 587 | if ( data === undefined ) |
|
- | 588 | return jQuery.queue( this[0], type ); |
|
- | 589 | ||
- | 590 | return this.each(function(){ |
|
589 | var src = target[ name ], copy = options[ name ]; |
591 | var queue = jQuery.queue( this, type, data ); |
- | 592 | ||
- | 593 | if( type == "fx" && queue.length == 1 ) |
|
- | 594 | queue[0].call(this); |
|
- | 595 | }); |
|
- | 596 | }, |
|
- | 597 | dequeue: function(type){ |
|
- | 598 | return this.each(function(){ |
|
- | 599 | jQuery.dequeue( this, type ); |
|
- | 600 | }); |
|
- | 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(){ |
|
590 | 609 | ||
- | 610 | var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g, |
|
591 | // Prevent never-ending loop
|
611 | done = 0, |
592 | if ( target === copy ) |
612 | toString = Object.prototype.toString; |
593 | continue; |
- | |
594 | 613 | ||
595 | // Recurse if we're merging object values
|
- | |
596 | if ( deep && copy && typeof copy === "object" && !copy.nodeType ) |
614 | var Sizzle = function(selector, context, results, seed) { |
597 | target[ name ] = jQuery.extend( deep, |
615 | results = results || []; |
598 | // Never move original objects, clone them
|
- | |
599 | src || ( copy.length != null ? [ ] : { } ) |
616 | var origContext = context = context || document; |
600 | , copy ); |
- | |
601 | 617 | ||
602 | // Don't bring in undefined values
|
- | |
603 | else if ( copy !== undefined ) |
618 | if ( context.nodeType !== 1 && context.nodeType !== 9 ) { |
604 | target[ name ] = copy; |
619 | return []; |
- | 620 | }
|
|
605 | 621 | ||
- | 622 | if ( !selector || typeof selector !== "string" ) { |
|
- | 623 | return results; |
|
606 | }
|
624 | }
|
607 | 625 | ||
608 | // Return the modified object
|
626 | var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context); |
609 | return target; |
- | |
610 | }; |
- | |
611 | 627 | ||
612 | // exclude the following css properties to add px
|
628 | // Reset the position of the chunker regexp (start from head)
|
613 | var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i, |
- | |
614 | // cache defaultView
|
629 | chunker.lastIndex = 0; |
615 | defaultView = document.defaultView || {}, |
- | |
616 | toString = Object.prototype.toString; |
- | |
617 | 630 | ||
618 | jQuery.extend({ |
- | |
619 | noConflict: function( deep ) { |
631 | while ( (m = chunker.exec(selector)) !== null ) { |
620 | window.$ = _$; |
632 | parts.push( m[1] ); |
621 | 633 | ||
622 | if ( deep ) |
634 | if ( m[2] ) { |
623 | window.jQuery = _jQuery; |
635 | extra = RegExp.rightContext; |
- | 636 | break; |
|
- | 637 | }
|
|
- | 638 | }
|
|
624 | 639 | ||
- | 640 | if ( parts.length > 1 && origPOS.exec( selector ) ) { |
|
- | 641 | if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { |
|
- | 642 | set = posProcess( parts[0] + parts[1], context ); |
|
625 | return jQuery; |
643 | } else { |
- | 644 | set = Expr.relative[ parts[0] ] ? |
|
626 | }, |
645 | [ context ] : |
- | 646 | Sizzle( parts.shift(), context ); |
|
627 | 647 | ||
628 | // See test/unit/core.js for details concerning isFunction.
|
- | |
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 ) { |
648 | while ( parts.length ) { |
632 | return toString.call(obj) === "[object Function]"; |
649 | selector = parts.shift(); |
633 | }, |
- | |
634 | 650 | ||
635 | isArray: function( obj ) { |
651 | if ( Expr.relative[ selector ] ) |
636 | return toString.call(obj) === "[object Array]"; |
652 | selector += parts.shift(); |
637 | }, |
- | |
638 | 653 | ||
- | 654 | set = posProcess( selector, set ); |
|
- | 655 | }
|
|
- | 656 | }
|
|
- | 657 | } else { |
|
639 | // check if an element is in a (or is an) XML document
|
658 | // Take a shortcut and set the context if the root selector is an ID
|
640 | isXMLDoc: function( elem ) { |
659 | // (but not if it'll be faster if the inner selector is an ID)
|
641 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
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]) ) { |
|
642 | !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument ); |
662 | var ret = Sizzle.find( parts.shift(), context, contextXML ); |
- | 663 | context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0]; |
|
643 | }, |
664 | }
|
- | 665 | ||
- | 666 | if ( context ) { |
|
- | 667 | var ret = seed ? |
|
- | 668 | { expr: parts.pop(), set: makeArray(seed) } : |
|
- | 669 | Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); |
|
- | 670 | set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set; |
|
644 | 671 | ||
645 | // Evalulates a script in a global context
|
- | |
646 | globalEval: function( data ) { |
672 | if ( parts.length > 0 ) { |
647 | if ( data && /\S/.test(data) ) { |
673 | checkSet = makeArray(set); |
648 | // Inspired by code by Andrea Giammarchi
|
674 | } else { |
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"); |
675 | prune = false; |
- | 676 | }
|
|
652 | 677 | ||
653 | script.type = "text/javascript"; |
- | |
654 | if ( jQuery.support.scriptEval ) |
678 | while ( parts.length ) { |
655 | script.appendChild( document.createTextNode( data ) ); |
- | |
656 | else
|
- | |
657 | script.text = data; |
679 | var cur = parts.pop(), pop = cur; |
658 | 680 | ||
659 | // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
681 | if ( !Expr.relative[ cur ] ) { |
660 | // This arises when a base node is used (#2709).
|
682 | cur = ""; |
661 | head.insertBefore( script, head.firstChild ); |
683 | } else { |
662 | head.removeChild( script ); |
684 | pop = parts.pop(); |
663 | }
|
685 | }
|
664 | }, |
- | |
665 | 686 | ||
666 | nodeName: function( elem, name ) { |
687 | if ( pop == null ) { |
667 | return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase(); |
688 | pop = context; |
668 | }, |
689 | }
|
669 | 690 | ||
670 | // args is for internal usage only
|
- | |
671 | each: function( object, callback, args ) { |
- | |
672 | var name, i = 0, length = object.length; |
- | |
673 | - | ||
674 | if ( args ) { |
- | |
675 | if ( length === undefined ) { |
- | |
676 | for ( name in object ) |
- | |
677 | if ( callback.apply( object[ name ], args ) === false ) |
691 | Expr.relative[ cur ]( checkSet, pop, contextXML ); |
678 | break; |
- | |
679 | } else |
692 | }
|
680 | for ( ; i < length; ) |
- | |
681 | if ( callback.apply( object[ i++ ], args ) === false ) |
- | |
682 | break; |
- | |
683 | - | ||
684 | // A special, fast, case for the most common use of each
|
- | |
685 | } else { |
693 | } else { |
686 | if ( length === undefined ) { |
- | |
687 | for ( name in object ) |
- | |
688 | if ( callback.call( object[ name ], name, object[ name ] ) === false ) |
- | |
689 | break; |
- | |
690 | } else |
- | |
691 | for ( var value = object[0]; |
694 | checkSet = parts = []; |
692 | i < length && callback.call( value, i, value ) !== false; value = object[++i] ){} |
- | |
693 | }
|
695 | }
|
- | 696 | }
|
|
694 | 697 | ||
695 | return object; |
- | |
696 | }, |
- | |
697 | - | ||
698 | prop: function( elem, value, type, i, name ) { |
- | |
699 | // Handle executable functions
|
- | |
700 | if ( jQuery.isFunction( value ) ) |
698 | if ( !checkSet ) { |
701 | value = value.call( elem, i ); |
- | |
702 | - | ||
703 | // Handle passing in a number to a CSS property
|
- | |
704 | return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ? |
- | |
705 | value + "px" : |
699 | checkSet = set; |
706 | value;
|
- | |
707 | }, |
700 | }
|
708 | - | ||
709 | className: { |
- | |
710 | // internal only, use addClass("class")
|
- | |
711 | add: function( elem, classNames ) { |
- | |
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; |
- | |
715 | }); |
- | |
716 | }, |
- | |
717 | - | ||
718 | // internal only, use removeClass("class")
|
- | |
719 | remove: function( elem, classNames ) { |
- | |
720 | if (elem.nodeType == 1) |
- | |
721 | elem.className = classNames !== undefined ? |
- | |
722 | jQuery.grep(elem.className.split(/\s+/), function(className){ |
- | |
723 | return !jQuery.className.has( classNames, className ); |
- | |
724 | }).join(" ") : |
- | |
725 | ""; |
- | |
726 | }, |
- | |
727 | 701 | ||
728 | // internal only, use hasClass("class")
|
- | |
729 | has: function( elem, className ) { |
702 | if ( !checkSet ) { |
730 | return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1; |
703 | throw "Syntax error, unrecognized expression: " + (cur || selector); |
731 | }
|
704 | }
|
732 | }, |
- | |
733 | 705 | ||
734 | // A method for quickly swapping in/out CSS properties to get correct calculations
|
706 | if ( toString.call(checkSet) === "[object Array]" ) { |
- | 707 | if ( !prune ) { |
|
735 | swap: function( elem, options, callback ) { |
708 | results.push.apply( results, checkSet ); |
736 | var old = {}; |
709 | } else if ( context && context.nodeType === 1 ) { |
737 | // Remember the old values, and insert the new ones
|
710 | for ( var i = 0; checkSet[i] != null; i++ ) { |
- | 711 | if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { |
|
- | 712 | results.push( set[i] ); |
|
- | 713 | }
|
|
- | 714 | }
|
|
- | 715 | } else { |
|
738 | for ( var name in options ) { |
716 | for ( var i = 0; checkSet[i] != null; i++ ) { |
739 | old[ name ] = elem.style[ name ]; |
717 | if ( checkSet[i] && checkSet[i].nodeType === 1 ) { |
740 | elem.style[ name ] = options[ name ]; |
718 | results.push( set[i] ); |
- | 719 | }
|
|
- | 720 | }
|
|
741 | }
|
721 | }
|
- | 722 | } else { |
|
- | 723 | makeArray( checkSet, results ); |
|
- | 724 | }
|
|
742 | 725 | ||
743 | callback.call( elem ); |
- | |
744 | - | ||
745 | // Revert the old values
|
726 | if ( extra ) { |
746 | for ( var name in options ) |
727 | Sizzle( extra, origContext, results, seed ); |
747 | elem.style[ name ] = old[ name ]; |
728 | Sizzle.uniqueSort( results ); |
748 | }, |
729 | }
|
749 | - | ||
750 | css: function( elem, name, force, extra ) { |
- | |
751 | if ( name == "width" || name == "height" ) { |
- | |
752 | var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ]; |
- | |
753 | - | ||
754 | function getWH() { |
- | |
755 | val = name == "width" ? elem.offsetWidth : elem.offsetHeight; |
- | |
756 | 730 | ||
757 | if ( extra === "border" ) |
731 | return results; |
758 | return; |
732 | }; |
759 | 733 | ||
760 | jQuery.each( which, function() { |
734 | Sizzle.uniqueSort = function(results){ |
761 | if ( !extra ) |
735 | if ( sortOrder ) { |
- | 736 | hasDuplicate = false; |
|
762 | val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0; |
737 | results.sort(sortOrder); |
- | 738 | ||
763 | if ( extra === "margin" ) |
739 | if ( hasDuplicate ) { |
764 | val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0; |
740 | for ( var i = 1; i < results.length; i++ ) { |
765 | else
|
741 | if ( results[i] === results[i-1] ) { |
766 | val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0; |
742 | results.splice(i--, 1); |
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 | }
|
|
791 | }
|
774 | }
|
- | 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 | return ret; |
844 | // Improper expression
|
845 | }, |
- | |
846 | - | ||
847 | clean: function( elems, context, fragment ) { |
- | |
848 | context = context || document; |
845 | if ( expr == old ) { |
849 | - | ||
850 | // !context.createElement fails in IE with an error but returns typeof 'object'
|
- | |
851 | if ( typeof context.createElement === "undefined" ) |
846 | if ( anyFound == null ) { |
852 | context = context.ownerDocument || context[0] && context[0].ownerDocument || document; |
- | |
853 | - | ||
854 | // If a single string is passed in and it's a single tag
|
847 | throw "Syntax error, unrecognized expression: " + expr; |
855 | // just do a createElement and skip the rest
|
- | |
856 | if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) { |
- | |
857 | var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); |
- | |
858 | if ( match ) |
848 | } else { |
859 | return [ context.createElement( match[1] ) ]; |
849 | break; |
- | 850 | }
|
|
860 | }
|
851 | }
|
861 | 852 | ||
862 | var ret = [], scripts = [], div = context.createElement("div"); |
853 | old = expr; |
- | 854 | }
|
|
863 | 855 | ||
864 | jQuery.each(elems, function(i, elem){ |
- | |
865 | if ( typeof elem === "number" ) |
- | |
866 | elem += ''; |
- | |
867 | - | ||
868 | if ( !elem ) |
- | |
869 | return; |
856 | return curLoop; |
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 | 857 | }; |
|
897 | // <thead> matched above
|
- | |
898 | (!tags.indexOf("<td") || !tags.indexOf("<th")) && |
- | |
899 | [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] || |
- | |
900 | 858 | ||
901 | !tags.indexOf("<col") && |
859 | var Expr = Sizzle.selectors = { |
- | 860 | order: [ "ID", "NAME", "TAG" ], |
|
- | 861 | match: { |
|
- | 862 | ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, |
|
- | 863 | CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, |
|
- | 864 | NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/, |
|
- | 865 | ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/, |
|
- | 866 | TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/, |
|
902 | [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] || |
867 | CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/, |
- | 868 | POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/, |
|
- | 869 | PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/ |
|
- | 870 | }, |
|
- | 871 | attrMap: { |
|
- | 872 | "class": "className", |
|
- | 873 | "for": "htmlFor" |
|
- | 874 | }, |
|
- | 875 | attrHandle: { |
|
- | 876 | href: function(elem){ |
|
- | 877 | return elem.getAttribute("href"); |
|
- | 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; |
|
903 | 885 | ||
904 | // IE can't serialize <link> and <script> tags normally
|
886 | if ( isTag && !isXML ) { |
905 | !jQuery.support.htmlSerialize && |
887 | part = part.toUpperCase(); |
906 | [ 1, "div<div>", "</div>" ] || |
888 | }
|
907 | 889 | ||
- | 890 | for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { |
|
908 | [ 0, "", "" ]; |
891 | if ( (elem = checkSet[i]) ) { |
- | 892 | while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} |
|
909 | 893 | ||
910 | // Go to html and back, then peel off extra wrappers
|
894 | checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ? |
- | 895 | elem || false : |
|
911 | div.innerHTML = wrap[1] + elem + wrap[2]; |
896 | elem === part; |
- | 897 | }
|
|
- | 898 | }
|
|
912 | 899 | ||
913 | // Move to the right depth
|
900 | if ( isPartStrNotTag ) { |
914 | while ( wrap[0]-- ) |
901 | Sizzle.filter( part, checkSet, true ); |
- | 902 | }
|
|
- | 903 | }, |
|
- | 904 | ">": function(checkSet, part, isXML){ |
|
915 | div = div.lastChild; |
905 | var isPartStr = typeof part === "string"; |
916 | 906 | ||
917 | // Remove IE's autoinserted <tbody> from table fragments
|
907 | if ( isPartStr && !/\W/.test(part) ) { |
918 | if ( !jQuery.support.tbody ) { |
908 | part = isXML ? part : part.toUpperCase(); |
919 | 909 | ||
920 | // String was a <table>, *may* have spurious <tbody>
|
910 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
- | 911 | var elem = checkSet[i]; |
|
- | 912 | if ( elem ) { |
|
921 | var hasBody = /<tbody/i.test(elem), |
913 | var parent = elem.parentNode; |
922 | tbody = !tags.indexOf("<table") && !hasBody ? |
914 | checkSet[i] = parent.nodeName === part ? parent : false; |
- | 915 | }
|
|
- | 916 | }
|
|
- | 917 | } else { |
|
923 | div.firstChild && div.firstChild.childNodes : |
918 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
- | 919 | var elem = checkSet[i]; |
|
- | 920 | if ( elem ) { |
|
- | 921 | checkSet[i] = isPartStr ? |
|
- | 922 | elem.parentNode : |
|
- | 923 | elem.parentNode === part; |
|
- | 924 | }
|
|
- | 925 | }
|
|
924 | 926 | ||
925 | // String was a bare <thead> or <tfoot>
|
927 | if ( isPartStr ) { |
926 | wrap[1] == "<table>" && !hasBody ? |
928 | Sizzle.filter( part, checkSet, true ); |
927 | div.childNodes : |
929 | }
|
928 | []; |
930 | }
|
- | 931 | }, |
|
- | 932 | "": function(checkSet, part, isXML){ |
|
- | 933 | var doneName = done++, checkFn = dirCheck; |
|
929 | 934 | ||
930 | for ( var j = tbody.length - 1; j >= 0 ; --j ) |
935 | if ( !part.match(/\W/) ) { |
931 | if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) |
936 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
932 | tbody[ j ].parentNode.removeChild( tbody[ j ] ); |
937 | checkFn = dirNodeCheck; |
- | 938 | }
|
|
933 | 939 | ||
- | 940 | checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML); |
|
934 | }
|
941 | }, |
- | 942 | "~": function(checkSet, part, isXML){ |
|
- | 943 | var doneName = done++, checkFn = dirCheck; |
|
935 | 944 | ||
936 | // IE completely kills leading whitespace when innerHTML is used
|
945 | if ( typeof part === "string" && !part.match(/\W/) ) { |
937 | if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) ) |
946 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
938 | div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild ); |
- | |
939 | - | ||
940 | elem = jQuery.makeArray( div.childNodes ); |
947 | checkFn = dirNodeCheck; |
941 | }
|
948 | }
|
942 | 949 | ||
943 | if ( elem.nodeType ) |
950 | checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML); |
944 | ret.push( elem ); |
951 | }
|
- | 952 | }, |
|
945 | else
|
953 | find: { |
- | 954 | ID: function(match, context, isXML){ |
|
- | 955 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
|
946 | ret = jQuery.merge( ret, elem ); |
956 | var m = context.getElementById(match[1]); |
- | 957 | return m ? [m] : []; |
|
947 | 958 | }
|
|
948 | }); |
959 | }, |
- | 960 | NAME: function(match, context, isXML){ |
|
- | 961 | if ( typeof context.getElementsByName !== "undefined" ) { |
|
- | 962 | var ret = [], results = context.getElementsByName(match[1]); |
|
949 | 963 | ||
950 | if ( fragment ) { |
- | |
951 | for ( var i = 0; ret[i]; i++ ) { |
964 | for ( var i = 0, l = results.length; i < l; i++ ) { |
952 | if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) { |
965 | if ( results[i].getAttribute("name") === match[1] ) { |
953 | scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] ); |
966 | ret.push( results[i] ); |
954 | } else { |
967 | }
|
955 | if ( ret[i].nodeType === 1 ) |
- | |
956 | ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) ); |
- | |
957 | fragment.appendChild( ret[i] ); |
- | |
958 | }
|
968 | }
|
- | 969 | ||
- | 970 | return ret.length === 0 ? null : ret; |
|
959 | }
|
971 | }
|
960 | 972 | }, |
|
961 | return scripts; |
973 | TAG: function(match, context){ |
- | 974 | return context.getElementsByTagName(match[1]); |
|
962 | }
|
975 | }
|
963 | - | ||
964 | return ret; |
- | |
965 | }, |
976 | }, |
- | 977 | preFilter: { |
|
- | 978 | CLASS: function(match, curLoop, inplace, result, not, isXML){ |
|
- | 979 | match = " " + match[1].replace(/\\/g, "") + " "; |
|
966 | 980 | ||
967 | attr: function( elem, name, value ) { |
981 | if ( isXML ) { |
968 | // don't set attributes on text and comment nodes
|
- | |
969 | if (!elem || elem.nodeType == 3 || elem.nodeType == 8) |
- | |
970 | return undefined; |
982 | return match; |
- | 983 | }
|
|
971 | 984 | ||
- | 985 | for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { |
|
- | 986 | if ( elem ) { |
|
- | 987 | if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) { |
|
- | 988 | if ( !inplace ) |
|
972 | var notxml = !jQuery.isXMLDoc( elem ), |
989 | result.push( elem ); |
973 | // Whether we are setting (or getting)
|
990 | } else if ( inplace ) { |
974 | set = value !== undefined; |
991 | curLoop[i] = false; |
- | 992 | }
|
|
- | 993 | }
|
|
- | 994 | }
|
|
975 | 995 | ||
- | 996 | return false; |
|
- | 997 | }, |
|
- | 998 | ID: function(match){ |
|
976 | // Try to normalize/fix the name
|
999 | return match[1].replace(/\\/g, ""); |
- | 1000 | }, |
|
- | 1001 | TAG: function(match, curLoop){ |
|
977 | name = notxml && jQuery.props[ name ] || name; |
1002 | for ( var i = 0; curLoop[i] === false; i++ ){} |
- | 1003 | return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase(); |
|
- | 1004 | }, |
|
- | 1005 | CHILD: function(match){ |
|
- | 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]); |
|
978 | 1011 | ||
979 | // Only do all the following if this is a node (faster for style)
|
1012 | // calculate the numbers (first)n+(last) including if they are negative
|
980 | // IE elem.getAttribute passes even for style
|
1013 | match[2] = (test[1] + (test[2] || 1)) - 0; |
981 | if ( elem.tagName ) { |
1014 | match[3] = test[3] - 0; |
- | 1015 | }
|
|
982 | 1016 | ||
983 | // These attributes require special treatment
|
1017 | // TODO: Move to normal caching system
|
984 | var special = /href|src|style/.test( name ); |
1018 | match[0] = done++; |
985 | 1019 | ||
986 | // Safari mis-reports the default selected property of a hidden option
|
1020 | return match; |
- | 1021 | }, |
|
987 | // Accessing the parent's selectedIndex property fixes it
|
1022 | ATTR: function(match, curLoop, inplace, result, not, isXML){ |
988 | if ( name == "selected" && elem.parentNode ) |
1023 | var name = match[1].replace(/\\/g, ""); |
989 | elem.parentNode.selectedIndex; |
- | |
990 | 1024 | ||
991 | // If applicable, access the attribute via the DOM 0 way
|
1025 | if ( !isXML && Expr.attrMap[name] ) { |
992 | if ( name in elem && notxml && !special ) { |
1026 | match[1] = Expr.attrMap[name]; |
993 | if ( set ){ |
1027 | }
|
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 ) |
- | |
996 | throw "type property can't be changed"; |
- | |
997 | 1028 | ||
998 | elem[ name ] = value; |
1029 | if ( match[2] === "~=" ) { |
- | 1030 | match[4] = " " + match[4] + " "; |
|
999 | }
|
1031 | }
|
1000 | 1032 | ||
1001 | // browsers index elements by id/name on forms, give priority to attributes.
|
- | |
1002 | if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) |
- | |
1003 | return elem.getAttributeNode( name ).nodeValue; |
1033 | return match; |
1004 | 1034 | }, |
|
1005 | // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
|
1035 | PSEUDO: function(match, curLoop, inplace, result, not){ |
1006 | // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
- | |
1007 | if ( name == "tabIndex" ) { |
1036 | if ( match[1] === "not" ) { |
- | 1037 | // If we're dealing with a complex expression, or a simple one
|
|
1008 | var attributeNode = elem.getAttributeNode( "tabIndex" ); |
1038 | if ( match[3].match(chunker).length > 1 || /^\w/.test(match[3]) ) { |
1009 | return attributeNode && attributeNode.specified |
1039 | match[3] = Sizzle(match[3], null, null, curLoop); |
1010 | ? attributeNode.value |
1040 | } else { |
1011 | : elem.nodeName.match(/(button|input|object|select|textarea)/i) |
1041 | var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); |
1012 | ? 0 |
1042 | if ( !inplace ) { |
1013 | : elem.nodeName.match(/^(a|area)$/i) && elem.href |
1043 | result.push.apply( result, ret ); |
1014 | ? 0 |
1044 | }
|
1015 | : undefined; |
1045 | return false; |
1016 | }
|
1046 | }
|
1017 | - | ||
1018 | return elem[ name ]; |
- | |
1019 | }
|
- | |
1020 | - | ||
1021 | if ( !jQuery.support.style && notxml && name == "style" ) |
- | |
1022 | return jQuery.attr( elem.style, "cssText", value ); |
- | |
1023 | - | ||
1024 | if ( set ) |
- | |
1025 | // convert the value to a string (all browsers do this but IE) see #1070
|
1047 | } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { |
1026 | elem.setAttribute( name, "" + value ); |
- | |
1027 | - | ||
1028 | var attr = !jQuery.support.hrefNormalized && notxml && special |
- | |
1029 | // Some attributes require a special call on IE
|
- | |
1030 | ? elem.getAttribute( name, 2 ) |
- | |
1031 | : elem.getAttribute( name ); |
- | |
1032 | - | ||
1033 | // Non-existent attributes return null, we normalize to undefined
|
- | |
1034 | return attr === null ? undefined : attr; |
- | |
1035 | }
|
- | |
1036 | - | ||
1037 | // elem is actually elem.style ... set the style
|
- | |
1038 | - | ||
1039 | // IE uses filters for opacity
|
- | |
1040 | if ( !jQuery.support.opacity && name == "opacity" ) { |
- | |
1041 | if ( set ) { |
- | |
1042 | // IE has trouble with opacity if it does not have layout
|
- | |
1043 | // Force it by setting the zoom level
|
- | |
1044 | elem.zoom = 1; |
1048 | return true; |
1045 | - | ||
1046 | // Set the alpha filter to set the opacity
|
- | |
1047 | elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) + |
- | |
1048 | (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")"); |
- | |
1049 | }
|
1049 | }
|
1050 | 1050 | ||
- | 1051 | return match; |
|
- | 1052 | }, |
|
1051 | return elem.filter && elem.filter.indexOf("opacity=") >= 0 ? |
1053 | POS: function(match){ |
1052 | (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '': |
1054 | match.unshift( true ); |
1053 | ""; |
1055 | return match; |
1054 | }
|
1056 | }
|
1055 | - | ||
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 ]; |
- | |
1064 | }, |
- | |
1065 | - | ||
1066 | trim: function( text ) { |
- | |
1067 | return (text || "").replace( /^\s+|\s+$/g, "" ); |
- | |
1068 | }, |
1057 | }, |
- | 1058 | filters: { |
|
- | 1059 | enabled: function(elem){ |
|
- | 1060 | return elem.disabled === false && elem.type !== "hidden"; |
|
- | 1061 | }, |
|
- | 1062 | disabled: function(elem){ |
|
- | 1063 | return elem.disabled === true; |
|
1069 | 1064 | }, |
|
1070 | makeArray: function( array ) { |
1065 | checked: function(elem){ |
- | 1066 | return elem.checked === true; |
|
- | 1067 | }, |
|
- | 1068 | selected: function(elem){ |
|
- | 1069 | // Accessing this property makes selected-by-default
|
|
- | 1070 | // options in Safari work properly
|
|
- | 1071 | elem.parentNode.selectedIndex; |
|
- | 1072 | return elem.selected === true; |
|
- | 1073 | }, |
|
1071 | var ret = []; |
1074 | parent: function(elem){ |
- | 1075 | return !!elem.firstChild; |
|
1072 | 1076 | }, |
|
1073 | if( array != null ){ |
1077 | empty: function(elem){ |
1074 | var i = array.length; |
1078 | return !elem.firstChild; |
- | 1079 | }, |
|
- | 1080 | has: function(elem, i, match){ |
|
1075 | // The window, strings (and functions) also have 'length'
|
1081 | return !!Sizzle( match[3], elem ).length; |
- | 1082 | }, |
|
- | 1083 | header: function(elem){ |
|
1076 | if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval ) |
1084 | return /h\d/i.test( elem.nodeName ); |
- | 1085 | }, |
|
- | 1086 | text: function(elem){ |
|
1077 | ret[0] = array; |
1087 | return "text" === elem.type; |
- | 1088 | }, |
|
- | 1089 | radio: function(elem){ |
|
- | 1090 | return "radio" === elem.type; |
|
- | 1091 | }, |
|
- | 1092 | checkbox: function(elem){ |
|
- | 1093 | return "checkbox" === elem.type; |
|
1078 | else
|
1094 | }, |
1079 | while( i ) |
1095 | file: function(elem){ |
1080 | ret[--i] = array[i]; |
1096 | return "file" === elem.type; |
- | 1097 | }, |
|
- | 1098 | password: function(elem){ |
|
- | 1099 | return "password" === elem.type; |
|
- | 1100 | }, |
|
- | 1101 | submit: function(elem){ |
|
- | 1102 | return "submit" === elem.type; |
|
- | 1103 | }, |
|
- | 1104 | image: function(elem){ |
|
- | 1105 | return "image" === elem.type; |
|
- | 1106 | }, |
|
- | 1107 | reset: function(elem){ |
|
- | 1108 | return "reset" === elem.type; |
|
- | 1109 | }, |
|
- | 1110 | button: function(elem){ |
|
- | 1111 | return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON"; |
|
- | 1112 | }, |
|
- | 1113 | input: function(elem){ |
|
- | 1114 | return /input|select|textarea|button/i.test(elem.nodeName); |
|
1081 | }
|
1115 | }
|
1082 | - | ||
1083 | return ret; |
- | |
1084 | }, |
1116 | }, |
- | 1117 | setFilters: { |
|
- | 1118 | first: function(elem, i){ |
|
- | 1119 | return i === 0; |
|
1085 | 1120 | }, |
|
1086 | inArray: function( elem, array ) { |
1121 | last: function(elem, i, match, array){ |
1087 | for ( var i = 0, length = array.length; i < length; i++ ) |
1122 | return i === array.length - 1; |
- | 1123 | }, |
|
1088 | // Use === because on IE, window == document
|
1124 | even: function(elem, i){ |
1089 | if ( array[ i ] === elem ) |
1125 | return i % 2 === 0; |
- | 1126 | }, |
|
- | 1127 | odd: function(elem, i){ |
|
1090 | return i; |
1128 | return i % 2 === 1; |
- | 1129 | }, |
|
- | 1130 | lt: function(elem, i, match){ |
|
- | 1131 | return i < match[3] - 0; |
|
1091 | 1132 | }, |
|
- | 1133 | gt: function(elem, i, match){ |
|
1092 | return -1; |
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; |
|
- | 1141 | }
|
|
1093 | }, |
1142 | }, |
- | 1143 | filter: { |
|
- | 1144 | PSEUDO: function(elem, match, i, array){ |
|
- | 1145 | var name = match[1], filter = Expr.filters[ name ]; |
|
1094 | 1146 | ||
1095 | merge: function( first, second ) { |
1147 | if ( filter ) { |
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)
|
1148 | return filter( elem, i, match, array ); |
1101 | if ( !jQuery.support.getAll ) { |
1149 | } else if ( name === "contains" ) { |
1102 | while ( (elem = second[ i++ ]) != null ) |
1150 | return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0; |
1103 | if ( elem.nodeType != 8 ) |
1151 | } else if ( name === "not" ) { |
1104 | first[ pos++ ] = elem; |
1152 | var not = match[3]; |
1105 | 1153 | ||
1106 | } else |
- | |
1107 | while ( (elem = second[ i++ ]) != null ) |
1154 | for ( var i = 0, l = not.length; i < l; i++ ) { |
1108 | first[ pos++ ] = elem; |
1155 | if ( not[i] === elem ) { |
- | 1156 | return false; |
|
- | 1157 | }
|
|
- | 1158 | }
|
|
1109 | 1159 | ||
1110 | return first; |
1160 | return true; |
- | 1161 | }
|
|
1111 | }, |
1162 | }, |
- | 1163 | CHILD: function(elem, match){ |
|
- | 1164 | var type = match[1], node = elem; |
|
- | 1165 | switch (type) { |
|
- | 1166 | case 'only': |
|
- | 1167 | case 'first': |
|
- | 1168 | while (node = node.previousSibling) { |
|
- | 1169 | if ( node.nodeType === 1 ) return false; |
|
- | 1170 | }
|
|
- | 1171 | if ( type == 'first') return true; |
|
- | 1172 | node = elem; |
|
- | 1173 | case 'last': |
|
- | 1174 | while (node = node.nextSibling) { |
|
- | 1175 | if ( node.nodeType === 1 ) return false; |
|
- | 1176 | }
|
|
- | 1177 | return true; |
|
- | 1178 | case 'nth': |
|
- | 1179 | var first = match[2], last = match[3]; |
|
1112 | 1180 | ||
1113 | unique: function( array ) { |
1181 | if ( first == 1 && last == 0 ) { |
1114 | var ret = [], done = {}; |
1182 | return true; |
- | 1183 | }
|
|
1115 | 1184 | ||
1116 | try { |
1185 | var doneName = match[0], |
- | 1186 | parent = elem.parentNode; |
|
1117 | 1187 | ||
- | 1188 | if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { |
|
- | 1189 | var count = 0; |
|
1118 | for ( var i = 0, length = array.length; i < length; i++ ) { |
1190 | for ( node = parent.firstChild; node; node = node.nextSibling ) { |
1119 | var id = jQuery.data( array[ i ] ); |
1191 | if ( node.nodeType === 1 ) { |
- | 1192 | node.nodeIndex = ++count; |
|
- | 1193 | }
|
|
- | 1194 | }
|
|
- | 1195 | parent.sizcache = doneName; |
|
- | 1196 | }
|
|
1120 | 1197 | ||
- | 1198 | var diff = elem.nodeIndex - last; |
|
1121 | if ( !done[ id ] ) { |
1199 | if ( first == 0 ) { |
1122 | done[ id ] = true; |
1200 | return diff == 0; |
- | 1201 | } else { |
|
1123 | ret.push( array[ i ] ); |
1202 | return ( diff % first == 0 && diff / first >= 0 ); |
1124 | }
|
1203 | }
|
1125 | }
|
1204 | }
|
- | 1205 | }, |
|
- | 1206 | ID: function(elem, match){ |
|
- | 1207 | return elem.nodeType === 1 && elem.getAttribute("id") === match; |
|
- | 1208 | }, |
|
- | 1209 | TAG: function(elem, match){ |
|
- | 1210 | return (match === "*" && elem.nodeType === 1) || elem.nodeName === match; |
|
- | 1211 | }, |
|
- | 1212 | CLASS: function(elem, match){ |
|
- | 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 ? |
|
- | 1221 | elem[ name ] : |
|
- | 1222 | elem.getAttribute( name ), |
|
- | 1223 | value = result + "", |
|
- | 1224 | type = match[2], |
|
- | 1225 | check = match[4]; |
|
1126 | 1226 | ||
- | 1227 | return result == null ? |
|
- | 1228 | type === "!=" : |
|
- | 1229 | type === "=" ? |
|
- | 1230 | value === check : |
|
- | 1231 | type === "*=" ? |
|
- | 1232 | value.indexOf(check) >= 0 : |
|
- | 1233 | type === "~=" ? |
|
- | 1234 | (" " + value + " ").indexOf(check) >= 0 : |
|
1127 | } catch( e ) { |
1235 | !check ? |
- | 1236 | value && result !== false : |
|
- | 1237 | type === "!=" ? |
|
- | 1238 | value != check : |
|
- | 1239 | type === "^=" ? |
|
- | 1240 | value.indexOf(check) === 0 : |
|
1128 | ret = array; |
1241 | type === "$=" ? |
- | 1242 | value.substr(value.length - check.length) === check : |
|
- | 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 ]; |
|
- | 1249 | ||
- | 1250 | if ( filter ) { |
|
- | 1251 | return filter( elem, i, match, array ); |
|
- | 1252 | }
|
|
1129 | }
|
1253 | }
|
- | 1254 | }
|
|
- | 1255 | }; |
|
1130 | 1256 | ||
1131 | return ret; |
1257 | var origPOS = Expr.match.POS; |
1132 | }, |
- | |
1133 | 1258 | ||
1134 | grep: function( elems, callback, inv ) { |
1259 | for ( var type in Expr.match ) { |
- | 1260 | Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source ); |
|
1135 | var ret = []; |
1261 | }
|
1136 | 1262 | ||
1137 | // Go through the array, only saving the items
|
1263 | var makeArray = function(array, results) { |
1138 | // that pass the validator function
|
1264 | array = Array.prototype.slice.call( array ); |
1139 | for ( var i = 0, length = elems.length; i < length; i++ ) |
- | |
1140 | if ( !inv != !callback( elems[ i ], i ) ) |
- | |
1141 | ret.push( elems[ i ] ); |
- | |
1142 | 1265 | ||
- | 1266 | if ( results ) { |
|
- | 1267 | results.push.apply( results, array ); |
|
1143 | return ret; |
1268 | return results; |
1144 | }, |
1269 | }
|
1145 | 1270 | ||
1146 | map: function( elems, callback ) { |
- | |
1147 | var ret = []; |
1271 | return array; |
- | 1272 | }; |
|
1148 | 1273 | ||
1149 | // Go through the array, translating each of the items to their
|
1274 | // Perform a simple check to determine if the browser is capable of
|
1150 | // new value (or values).
|
- | |
1151 | for ( var i = 0, length = elems.length; i < length; i++ ) { |
1275 | // converting a NodeList to an array using builtin methods.
|
- | 1276 | try { |
|
1152 | var value = callback( elems[ i ], i ); |
1277 | Array.prototype.slice.call( document.documentElement.childNodes ); |
1153 | 1278 | ||
- | 1279 | // Provide a fallback method if it does not work
|
|
- | 1280 | } catch(e){ |
|
- | 1281 | makeArray = function(array, results) { |
|
- | 1282 | var ret = results || []; |
|
- | 1283 | ||
- | 1284 | if ( toString.call(array) === "[object Array]" ) { |
|
- | 1285 | Array.prototype.push.apply( ret, array ); |
|
- | 1286 | } else { |
|
- | 1287 | if ( typeof array.length === "number" ) { |
|
- | 1288 | for ( var i = 0, l = array.length; i < l; i++ ) { |
|
1154 | if ( value != null ) |
1289 | ret.push( array[i] ); |
- | 1290 | }
|
|
- | 1291 | } else { |
|
- | 1292 | for ( var i = 0; array[i]; i++ ) { |
|
1155 | ret[ ret.length ] = value; |
1293 | ret.push( array[i] ); |
- | 1294 | }
|
|
- | 1295 | }
|
|
1156 | }
|
1296 | }
|
1157 | 1297 | ||
1158 | return ret.concat.apply( [], ret ); |
1298 | return ret; |
1159 | }
|
1299 | }; |
1160 | }); |
1300 | }
|
1161 | 1301 | ||
1162 | // Use of jQuery.browser is deprecated.
|
1302 | var sortOrder; |
1163 | // It's included for backwards compatibility and plugins,
|
- | |
1164 | // although they should work to migrate away.
|
- | |
1165 | 1303 | ||
- | 1304 | if ( document.documentElement.compareDocumentPosition ) { |
|
- | 1305 | sortOrder = function( a, b ) { |
|
- | 1306 | var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1; |
|
- | 1307 | if ( ret === 0 ) { |
|
- | 1308 | hasDuplicate = true; |
|
- | 1309 | }
|
|
- | 1310 | return ret; |
|
- | 1311 | }; |
|
- | 1312 | } else if ( "sourceIndex" in document.documentElement ) { |
|
- | 1313 | sortOrder = function( a, b ) { |
|
1166 | var userAgent = navigator.userAgent.toLowerCase(); |
1314 | var ret = a.sourceIndex - b.sourceIndex; |
- | 1315 | if ( ret === 0 ) { |
|
- | 1316 | hasDuplicate = true; |
|
- | 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; |
|
- | 1330 | }
|
|
- | 1331 | return ret; |
|
- | 1332 | }; |
|
- | 1333 | }
|
|
1167 | 1334 | ||
1168 | // Figure out what browser is being used
|
1335 | // Check to see if the browser returns elements by name when
|
- | 1336 | // querying by getElementById (and provide a workaround)
|
|
1169 | jQuery.browser = { |
1337 | (function(){ |
1170 | version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1], |
1338 | // We're going to inject a fake input element with a specified name
|
1171 | safari: /webkit/.test( userAgent ), |
1339 | var form = document.createElement("div"), |
1172 | opera: /opera/.test( userAgent ), |
1340 | id = "script" + (new Date).getTime(); |
1173 | msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ), |
1341 | form.innerHTML = "<a name='" + id + "'/>"; |
1174 | mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent ) |
- | |
1175 | }; |
- | |
1176 | 1342 | ||
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);}, |
1343 | // Inject it into the root element, check its status, and remove it quickly
|
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 ) { |
1344 | var root = document.documentElement; |
1189 | var ret = jQuery.map( this, fn ); |
1345 | root.insertBefore( form, root.firstChild ); |
1190 | 1346 | ||
- | 1347 | // The workaround has to do additional checks after a getElementById
|
|
- | 1348 | // Which slows things down for other browsers (hence the branching)
|
|
1191 | if ( selector && typeof selector == "string" ) |
1349 | if ( !!document.getElementById( id ) ) { |
- | 1350 | Expr.find.ID = function(match, context, isXML){ |
|
- | 1351 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
|
1192 | ret = jQuery.multiFilter( selector, ret ); |
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 : []; |
|
- | 1354 | }
|
|
- | 1355 | }; |
|
1193 | 1356 | ||
- | 1357 | Expr.filter.ID = function(elem, match){ |
|
- | 1358 | var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); |
|
1194 | return this.pushStack( jQuery.unique( ret ), name, selector ); |
1359 | return elem.nodeType === 1 && node && node.nodeValue === match; |
1195 | }; |
1360 | }; |
1196 | }); |
1361 | }
|
1197 | 1362 | ||
1198 | jQuery.each({ |
- | |
1199 | appendTo: "append", |
- | |
1200 | prependTo: "prepend", |
- | |
1201 | insertBefore: "before", |
1363 | root.removeChild( form ); |
1202 | insertAfter: "after", |
- | |
1203 | replaceAll: "replaceWith" |
- | |
1204 | }, function(name, original){ |
1364 | })(); |
1205 | jQuery.fn[ name ] = function( selector ) { |
- | |
1206 | var ret = [], insert = jQuery( selector ); |
- | |
1207 | 1365 | ||
1208 | for ( var i = 0, l = insert.length; i < l; i++ ) { |
1366 | (function(){ |
1209 | var elems = (i > 0 ? this.clone(true) : this).get(); |
1367 | // Check to see if the browser returns only elements
|
1210 | jQuery.fn[ original ].apply( jQuery(insert[i]), elems ); |
- | |
1211 | ret = ret.concat( elems ); |
1368 | // when doing getElementsByTagName("*")
|
1212 | }
|
- | |
1213 | 1369 | ||
- | 1370 | // Create a fake element
|
|
1214 | return this.pushStack( ret, name, selector ); |
1371 | var div = document.createElement("div"); |
1215 | }; |
- | |
1216 | }); |
- | |
- | 1372 | div.appendChild( document.createComment("") ); |
|
1217 | 1373 | ||
1218 | jQuery.each({ |
- | |
1219 | removeAttr: function( name ) { |
1374 | // Make sure no comments are found
|
1220 | jQuery.attr( this, name, "" ); |
1375 | if ( div.getElementsByTagName("*").length > 0 ) { |
1221 | if (this.nodeType == 1) |
1376 | Expr.find.TAG = function(match, context){ |
1222 | this.removeAttribute( name ); |
1377 | var results = context.getElementsByTagName(match[1]); |
1223 | }, |
- | |
1224 | 1378 | ||
1225 | addClass: function( classNames ) { |
1379 | // Filter out possible comments
|
1226 | jQuery.className.add( this, classNames ); |
1380 | if ( match[1] === "*" ) { |
1227 | }, |
1381 | var tmp = []; |
1228 | 1382 | ||
1229 | removeClass: function( classNames ) { |
1383 | for ( var i = 0; results[i]; i++ ) { |
- | 1384 | if ( results[i].nodeType === 1 ) { |
|
1230 | jQuery.className.remove( this, classNames ); |
1385 | tmp.push( results[i] ); |
- | 1386 | }
|
|
1231 | }, |
1387 | }
|
1232 | 1388 | ||
1233 | toggleClass: function( classNames, state ) { |
- | |
1234 | if( typeof state !== "boolean" ) |
1389 | results = tmp; |
1235 | state = !jQuery.className.has( this, classNames ); |
- | |
1236 | jQuery.className[ state ? "add" : "remove" ]( this, classNames ); |
- | |
1237 | }, |
1390 | }
|
1238 | 1391 | ||
1239 | remove: function( selector ) { |
- | |
1240 | if ( !selector || jQuery.filter( selector, [ this ] ).length ) { |
- | |
1241 | // Prevent memory leaks
|
- | |
1242 | jQuery( "*", this ).add([this]).each(function(){ |
- | |
1243 | jQuery.event.remove(this); |
- | |
1244 | jQuery.removeData(this); |
1392 | return results; |
1245 | }); |
- | |
1246 | if (this.parentNode) |
- | |
1247 | this.parentNode.removeChild( this ); |
- | |
1248 | }
|
1393 | }; |
1249 | }, |
1394 | }
|
1250 | 1395 | ||
1251 | empty: function() { |
- | |
1252 | // Remove element nodes and prevent memory leaks
|
1396 | // Check to see if an attribute returns normalized href attributes
|
1253 | jQuery(this).children().remove(); |
1397 | div.innerHTML = "<a href='#'></a>"; |
1254 | - | ||
- | 1398 | if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && |
|
1255 | // Remove any remaining nodes
|
1399 | div.firstChild.getAttribute("href") !== "#" ) { |
1256 | while ( this.firstChild ) |
1400 | Expr.attrHandle.href = function(elem){ |
1257 | this.removeChild( this.firstChild ); |
1401 | return elem.getAttribute("href", 2); |
- | 1402 | }; |
|
1258 | }
|
1403 | }
|
1259 | }, function(name, fn){ |
- | |
1260 | jQuery.fn[ name ] = function(){ |
- | |
1261 | return this.each( fn, arguments ); |
- | |
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 | }, |
- | |
1299 | - | ||
1300 | removeData: function( elem, name ) { |
- | |
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 ); |
- | |
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 | }, |
- | |
1339 | queue: function( elem, type, data ) { |
- | |
1340 | if ( elem ){ |
- | |
1341 | - | ||
1342 | type = (type || "fx") + "queue"; |
- | |
1343 | - | ||
1344 | var q = jQuery.data( 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 | }, |
- | |
1354 | - | ||
1355 | dequeue: function( elem, type ){ |
- | |
1356 | var queue = jQuery.queue( elem, type ), |
- | |
1357 | fn = queue.shift(); |
- | |
1358 | - | ||
1359 | if( !type || type === "fx" ) |
- | |
1360 | fn = queue[0]; |
- | |
1361 | - | ||
1362 | if( fn !== undefined ) |
- | |
1363 | fn.call(elem); |
- | |
1364 | }
|
- | |
1365 | }); |
1404 | })(); |
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 | }, |
- | |
1386 | - | ||
1387 | removeData: function( key ){ |
- | |
1388 | return this.each(function(){ |
- | |
1389 | jQuery.removeData( this, key ); |
- | |
1390 | }); |
- | |
1391 | }, |
- | |
1392 | queue: function(type, data){ |
- | |
1393 | if ( typeof type !== "string" ) { |
- | |
1394 | data = type; |
- | |
1395 | type = "fx"; |
- | |
1396 | }
|
- | |
1397 | - | ||
1398 | if ( data === undefined ) |
- | |
1399 | return jQuery.queue( this[0], type ); |
- | |
1400 | - | ||
1401 | return this.each(function(){ |
- | |
1402 | var queue = jQuery.queue( this, type, data ); |
- | |
1403 | - | ||
1404 | if( type == "fx" && queue.length == 1 ) |
- | |
1405 | queue[0].call(this); |
- | |
1406 | }); |
- | |
1407 | }, |
- | |
1408 | dequeue: function(type){ |
- | |
1409 | return this.each(function(){ |
- | |
1410 | jQuery.dequeue( this, type ); |
- | |
1411 | }); |
- | |
1412 | }
|
- | |
1413 | });/*! |
- | |
1414 | * Sizzle CSS Selector Engine - v0.9.3
|
- | |
1415 | * Copyright 2009, The Dojo Foundation
|
- | |
1416 | * Released under the MIT, BSD, and GPL Licenses.
|
- | |
1417 | * More information: http://sizzlejs.com/
|
- | |
1418 | */
|
- | |
1419 | (function(){ |
- | |
1420 | - | ||
1421 | var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g, |
- | |
1422 | done = 0, |
- | |
1423 | toString = Object.prototype.toString; |
- | |
1424 | 1405 | ||
1425 | var Sizzle = function(selector, context, results, seed) { |
1406 | if ( document.querySelectorAll ) (function(){ |
1426 | results = results || []; |
1407 | var oldSizzle = Sizzle, div = document.createElement("div"); |
1427 | context = context || document; |
1408 | div.innerHTML = "<p class='TEST'></p>"; |
1428 | 1409 | ||
1429 | if ( context.nodeType !== 1 && context.nodeType !== 9 ) |
1410 | // Safari can't handle uppercase or unicode characters when
|
1430 | return []; |
1411 | // in quirks mode.
|
1431 | - | ||
1432 | if ( !selector || typeof selector !== "string" ) { |
1412 | if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { |
1433 | return results; |
1413 | return; |
1434 | }
|
1414 | }
|
1435 | 1415 | ||
1436 | var parts = [], m, set, checkSet, check, mode, extra, prune = true; |
- | |
1437 | - | ||
1438 | // Reset the position of the chunker regexp (start from head)
|
1416 | Sizzle = function(query, context, extra, seed){ |
1439 | chunker.lastIndex = 0; |
1417 | context = context || document; |
1440 | 1418 | ||
1441 | while ( (m = chunker.exec(selector)) !== null ) { |
1419 | // Only use querySelectorAll on non-XML documents
|
1442 | parts.push( m[1] ); |
1420 | // (ID selectors don't work in non-HTML documents)
|
1443 | - | ||
- | 1421 | if ( !seed && context.nodeType === 9 && !isXML(context) ) { |
|
1444 | if ( m[2] ) { |
1422 | try { |
1445 | extra = RegExp.rightContext; |
1423 | return makeArray( context.querySelectorAll(query), extra ); |
1446 | break; |
1424 | } catch(e){} |
1447 | }
|
1425 | }
|
- | 1426 | ||
- | 1427 | return oldSizzle(query, context, extra, seed); |
|
- | 1428 | }; |
|
- | 1429 | ||
- | 1430 | for ( var prop in oldSizzle ) { |
|
- | 1431 | Sizzle[ prop ] = oldSizzle[ prop ]; |
|
1448 | }
|
1432 | }
|
- | 1433 | })(); |
|
1449 | 1434 | ||
1450 | if ( parts.length > 1 && origPOS.exec( selector ) ) { |
1435 | if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){ |
1451 | if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { |
1436 | var div = document.createElement("div"); |
1452 | set = posProcess( parts[0] + parts[1], context ); |
1437 | div.innerHTML = "<div class='test e'></div><div class='test'></div>"; |
1453 | } else { |
- | |
1454 | set = Expr.relative[ parts[0] ] ? |
- | |
1455 | [ context ] : |
- | |
1456 | Sizzle( parts.shift(), context ); |
- | |
1457 | 1438 | ||
- | 1439 | // Opera can't find a second classname (in 9.6)
|
|
1458 | while ( parts.length ) { |
1440 | if ( div.getElementsByClassName("e").length === 0 ) |
1459 | selector = parts.shift(); |
1441 | return; |
1460 | 1442 | ||
1461 | if ( Expr.relative[ selector ] ) |
1443 | // Safari caches class attributes, doesn't catch changes (in 3.2)
|
1462 | selector += parts.shift(); |
1444 | div.lastChild.className = "e"; |
1463 | 1445 | ||
1464 | set = posProcess( selector, set ); |
1446 | if ( div.getElementsByClassName("e").length === 1 ) |
1465 | }
|
- | |
1466 | }
|
- | |
1467 | } else { |
1447 | return; |
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 | 1448 | ||
1473 | if ( parts.length > 0 ) { |
1449 | Expr.order.splice(1, 0, "CLASS"); |
1474 | checkSet = makeArray(set); |
1450 | Expr.find.CLASS = function(match, context, isXML) { |
1475 | } else { |
1451 | if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { |
1476 | prune = false; |
1452 | return context.getElementsByClassName(match[1]); |
1477 | }
|
1453 | }
|
- | 1454 | }; |
|
- | 1455 | })(); |
|
1478 | 1456 | ||
1479 | while ( parts.length ) { |
1457 | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
1480 | var cur = parts.pop(), pop = cur; |
1458 | var sibDir = dir == "previousSibling" && !isXML; |
1481 | - | ||
1482 | if ( !Expr.relative[ cur ] ) { |
1459 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
1483 | cur = ""; |
1460 | var elem = checkSet[i]; |
1484 | } else { |
1461 | if ( elem ) { |
- | 1462 | if ( sibDir && elem.nodeType === 1 ){ |
|
- | 1463 | elem.sizcache = doneName; |
|
1485 | pop = parts.pop(); |
1464 | elem.sizset = i; |
1486 | }
|
1465 | }
|
- | 1466 | elem = elem[dir]; |
|
- | 1467 | var match = false; |
|
1487 | 1468 | ||
1488 | if ( pop == null ) { |
1469 | while ( elem ) { |
- | 1470 | if ( elem.sizcache === doneName ) { |
|
- | 1471 | match = checkSet[elem.sizset]; |
|
1489 | pop = context; |
1472 | break; |
1490 | }
|
1473 | }
|
1491 | 1474 | ||
1492 | Expr.relative[ cur ]( checkSet, pop, isXML(context) ); |
1475 | if ( elem.nodeType === 1 && !isXML ){ |
- | 1476 | elem.sizcache = doneName; |
|
1493 | }
|
1477 | elem.sizset = i; |
1494 | }
|
1478 | }
|
1495 | 1479 | ||
1496 | if ( !checkSet ) { |
1480 | if ( elem.nodeName === cur ) { |
1497 | checkSet = set; |
1481 | match = elem; |
- | 1482 | break; |
|
1498 | }
|
1483 | }
|
1499 | 1484 | ||
1500 | if ( !checkSet ) { |
1485 | elem = elem[dir]; |
- | 1486 | }
|
|
- | 1487 | ||
1501 | throw "Syntax error, unrecognized expression: " + (cur || selector); |
1488 | checkSet[i] = match; |
- | 1489 | }
|
|
1502 | }
|
1490 | }
|
- | 1491 | }
|
|
1503 | 1492 | ||
1504 | if ( toString.call(checkSet) === "[object Array]" ) { |
1493 | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
1505 | if ( !prune ) { |
1494 | var sibDir = dir == "previousSibling" && !isXML; |
1506 | results.push.apply( results, checkSet ); |
1495 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
1507 | } else if ( context.nodeType === 1 ) { |
1496 | var elem = checkSet[i]; |
1508 | for ( var i = 0; checkSet[i] != null; i++ ) { |
1497 | if ( elem ) { |
1509 | if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { |
1498 | if ( sibDir && elem.nodeType === 1 ) { |
1510 | results.push( set[i] ); |
1499 | elem.sizcache = doneName; |
1511 | }
|
1500 | elem.sizset = i; |
1512 | }
|
1501 | }
|
- | 1502 | elem = elem[dir]; |
|
- | 1503 | var match = false; |
|
- | 1504 | ||
1513 | } else { |
1505 | while ( elem ) { |
1514 | for ( var i = 0; checkSet[i] != null; i++ ) { |
1506 | if ( elem.sizcache === doneName ) { |
1515 | if ( checkSet[i] && checkSet[i].nodeType === 1 ) { |
1507 | match = checkSet[elem.sizset]; |
1516 | results.push( set[i] ); |
1508 | break; |
1517 | }
|
1509 | }
|
1518 | }
|
- | |
1519 | }
|
- | |
1520 | } else { |
- | |
1521 | makeArray( checkSet, results ); |
- | |
1522 | }
|
- | |
1523 | 1510 | ||
- | 1511 | if ( elem.nodeType === 1 ) { |
|
1524 | if ( extra ) { |
1512 | if ( !isXML ) { |
- | 1513 | elem.sizcache = doneName; |
|
- | 1514 | elem.sizset = i; |
|
- | 1515 | }
|
|
1525 | Sizzle( extra, context, results, seed ); |
1516 | if ( typeof cur !== "string" ) { |
- | 1517 | if ( elem === cur ) { |
|
- | 1518 | match = true; |
|
- | 1519 | break; |
|
- | 1520 | }
|
|
1526 | 1521 | ||
1527 | if ( sortOrder ) { |
- | |
1528 | hasDuplicate = false; |
- | |
1529 | results.sort(sortOrder); |
- | |
1530 | - | ||
1531 | if ( hasDuplicate ) { |
- | |
1532 | for ( var i = 1; i < results.length; i++ ) { |
1522 | } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { |
1533 | if ( results[i] === results[i-1] ) { |
1523 | match = elem; |
1534 | results.splice(i--, 1); |
1524 | break; |
1535 | }
|
1525 | }
|
1536 | }
|
1526 | }
|
- | 1527 | ||
- | 1528 | elem = elem[dir]; |
|
1537 | }
|
1529 | }
|
- | 1530 | ||
- | 1531 | checkSet[i] = match; |
|
1538 | }
|
1532 | }
|
1539 | }
|
1533 | }
|
- | 1534 | }
|
|
1540 | 1535 | ||
- | 1536 | var contains = document.compareDocumentPosition ? function(a, b){ |
|
1541 | return results; |
1537 | return a.compareDocumentPosition(b) & 16; |
- | 1538 | } : function(a, b){ |
|
- | 1539 | return a !== b && (a.contains ? a.contains(b) : true); |
|
1542 | }; |
1540 | }; |
1543 | 1541 | ||
1544 | Sizzle.matches = function(expr, set){ |
1542 | var isXML = function(elem){ |
1545 | return Sizzle(expr, null, null, set); |
1543 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
- | 1544 | !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML"; |
|
1546 | }; |
1545 | }; |
1547 | 1546 | ||
1548 | Sizzle.find = function(expr, context, isXML){ |
1547 | var posProcess = function(selector, context){ |
1549 | var set, match; |
1548 | var tmpSet = [], later = "", match, |
- | 1549 | root = context.nodeType ? [context] : context; |
|
1550 | 1550 | ||
- | 1551 | // Position selectors must be done after the filter
|
|
- | 1552 | // And so must :not(positional) so we move all PSEUDOs to the end
|
|
1551 | if ( !expr ) { |
1553 | while ( (match = Expr.match.PSEUDO.exec( selector )) ) { |
1552 | return []; |
1554 | later += match[0]; |
- | 1555 | selector = selector.replace( Expr.match.PSEUDO, "" ); |
|
1553 | }
|
1556 | }
|
1554 | 1557 | ||
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 )) ) { |
- | |
1559 | var left = RegExp.leftContext; |
- | |
1560 | - | ||
1561 | if ( left.substr( left.length - 1 ) !== "\\" ) { |
- | |
1562 | match[1] = (match[1] || "").replace(/\\/g, ""); |
- | |
1563 | set = Expr.find[ type ]( match, context, isXML ); |
- | |
1564 | if ( set != null ) { |
- | |
1565 | expr = expr.replace( Expr.match[ type ], "" ); |
1558 | selector = Expr.relative[selector] ? selector + "*" : selector; |
1566 | break; |
- | |
1567 | }
|
- | |
1568 | }
|
- | |
1569 | }
|
- | |
1570 | }
|
- | |
1571 | 1559 | ||
1572 | if ( !set ) { |
1560 | for ( var i = 0, l = root.length; i < l; i++ ) { |
1573 | set = context.getElementsByTagName("*"); |
1561 | Sizzle( selector, root[i], tmpSet ); |
1574 | }
|
1562 | }
|
1575 | 1563 | ||
1576 | return {set: set, expr: expr}; |
1564 | return Sizzle.filter( later, tmpSet ); |
1577 | }; |
1565 | }; |
1578 | 1566 | ||
1579 | Sizzle.filter = function(expr, set, inplace, not){ |
- | |
1580 | var old = expr, result = [], curLoop = set, match, anyFound, |
- | |
1581 | isXMLFilter = set && set[0] && isXML(set[0]); |
- | |
1582 | 1567 | // EXPOSE
|
|
1583 | while ( expr && set.length ) { |
1568 | jQuery.find = Sizzle; |
1584 | for ( var type in Expr.filter ) { |
1569 | jQuery.expr = Sizzle.selectors; |
1585 | if ( (match = Expr.match[ type ].exec( expr )) != null ) { |
- | |
1586 | var filter = Expr.filter[ type ], found, item; |
1570 | jQuery.expr[":"] = jQuery.expr.filters; |
1587 | anyFound = false; |
- | |
1588 | 1571 | ||
1589 | if ( curLoop == result ) { |
1572 | Sizzle.selectors.filters.hidden = function(elem){ |
1590 | result = []; |
1573 | return elem.offsetWidth === 0 && elem.offsetHeight === 0; |
1591 | }
|
1574 | }; |
1592 | 1575 | ||
1593 | if ( Expr.preFilter[ type ] ) { |
1576 | Sizzle.selectors.filters.visible = function(elem){ |
1594 | match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); |
1577 | return elem.offsetWidth > 0 || elem.offsetHeight > 0; |
- | 1578 | }; |
|
1595 | 1579 | ||
1596 | if ( !match ) { |
1580 | Sizzle.selectors.filters.animated = function(elem){ |
1597 | anyFound = found = true; |
1581 | return jQuery.grep(jQuery.timers, function(fn){ |
1598 | } else if ( match === true ) { |
1582 | return elem === fn.elem; |
1599 | continue; |
1583 | }).length; |
1600 | }
|
- | |
1601 | }
|
1584 | }; |
1602 | 1585 | ||
1603 | if ( match ) { |
- | |
1604 | for ( var i = 0; (item = curLoop[i]) != null; i++ ) { |
1586 | jQuery.filter = jQuery.multiFilter = function( expr, elems, not ) { |
1605 | if ( item ) { |
1587 | if ( not ) { |
1606 | found = filter( item, match, i, curLoop ); |
- | |
1607 | var pass = not ^ !!found; |
1588 | expr = ":not(" + expr + ")"; |
- | 1589 | }
|
|
1608 | 1590 | ||
1609 | if ( inplace && found != null ) { |
- | |
1610 | if ( pass ) { |
- | |
1611 | anyFound = true; |
- | |
1612 | } else { |
- | |
1613 | curLoop[i] = false; |
- | |
1614 | }
|
- | |
1615 | } else if ( pass ) { |
- | |
1616 | result.push( item ); |
1591 | return Sizzle.matches(expr, elems); |
1617 | anyFound = true; |
- | |
1618 | }
|
- | |
1619 | }
|
- | |
1620 | }
|
- | |
1621 | }
|
1592 | }; |
1622 | 1593 | ||
- | 1594 | jQuery.dir = function( elem, dir ){ |
|
- | 1595 | var matched = [], cur = elem[dir]; |
|
1623 | if ( found !== undefined ) { |
1596 | while ( cur && cur != document ) { |
1624 | if ( !inplace ) { |
1597 | if ( cur.nodeType == 1 ) |
1625 | curLoop = result; |
1598 | matched.push( cur ); |
- | 1599 | cur = cur[dir]; |
|
1626 | }
|
1600 | }
|
- | 1601 | return matched; |
|
- | 1602 | }; |
|
1627 | 1603 | ||
1628 | expr = expr.replace( Expr.match[ type ], "" ); |
1604 | jQuery.nth = function(cur, result, dir, elem){ |
- | 1605 | result = result || 1; |
|
- | 1606 | var num = 0; |
|
1629 | 1607 | ||
1630 | if ( !anyFound ) { |
1608 | for ( ; cur; cur = cur[dir] ) |
1631 | return []; |
1609 | if ( cur.nodeType == 1 && ++num == result ) |
1632 | }
|
1610 | break; |
1633 | 1611 | ||
1634 | break; |
1612 | return cur; |
1635 | }
|
- | |
1636 | }
|
- | |
1637 | }
|
1613 | }; |
1638 | 1614 | ||
1639 | // Improper expression
|
- | |
1640 | if ( expr == old ) { |
- | |
1641 | if ( anyFound == null ) { |
1615 | jQuery.sibling = function(n, elem){ |
1642 | throw "Syntax error, unrecognized expression: " + expr; |
- | |
1643 | } else { |
- | |
1644 | break; |
1616 | var r = []; |
1645 | }
|
- | |
1646 | }
|
- | |
1647 | 1617 | ||
- | 1618 | for ( ; n; n = n.nextSibling ) { |
|
- | 1619 | if ( n.nodeType == 1 && n != elem ) |
|
1648 | old = expr; |
1620 | r.push( n ); |
1649 | }
|
1621 | }
|
1650 | 1622 | ||
1651 | return curLoop; |
1623 | return r; |
1652 | }; |
1624 | }; |
1653 | 1625 | ||
1654 | var Expr = Sizzle.selectors = { |
- | |
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+-]*)\))?/, |
- | |
1663 | POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/, |
- | |
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 | }, |
- | |
1675 | relative: { |
1626 | return; |
1676 | "+": function(checkSet, part, isXML){ |
- | |
1677 | var isPartStr = typeof part === "string", |
- | |
1678 | isTag = isPartStr && !/\W/.test(part), |
- | |
1679 | isPartStrNotTag = isPartStr && !isTag; |
- | |
1680 | 1627 | ||
1681 | if ( isTag && !isXML ) { |
1628 | window.Sizzle = Sizzle; |
1682 | part = part.toUpperCase(); |
- | |
1683 | }
|
- | |
1684 | 1629 | ||
- | 1630 | })(); |
|
1685 | for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { |
1631 | jQuery.fn.extend({ |
1686 | if ( (elem = checkSet[i]) ) { |
1632 | find: function( selector ) { |
1687 | while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} |
1633 | var ret = this.pushStack( "", "find", selector ), length = 0; |
1688 | 1634 | ||
- | 1635 | for ( var i = 0, l = this.length; i < l; i++ ) { |
|
- | 1636 | length = ret.length; |
|
- | 1637 | jQuery.find( selector, this[i], ret ); |
|
- | 1638 | ||
- | 1639 | if ( i > 0 ) { |
|
- | 1640 | // Make sure that the results are unique
|
|
1689 | checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ? |
1641 | for ( var n = length; n < ret.length; n++ ) { |
- | 1642 | for ( var r = 0; r < length; r++ ) { |
|
- | 1643 | if ( ret[r] === ret[n] ) { |
|
1690 | elem || false : |
1644 | ret.splice(n--, 1); |
1691 | elem === part; |
1645 | break; |
- | 1646 | }
|
|
- | 1647 | }
|
|
1692 | }
|
1648 | }
|
1693 | }
|
1649 | }
|
- | 1650 | }
|
|
1694 | 1651 | ||
1695 | if ( isPartStrNotTag ) { |
1652 | return ret; |
1696 | Sizzle.filter( part, checkSet, true ); |
- | |
1697 | }
|
- | |
1698 | }, |
1653 | }, |
1699 | ">": function(checkSet, part, isXML){ |
- | |
1700 | var isPartStr = typeof part === "string"; |
- | |
1701 | 1654 | ||
- | 1655 | filter: function( selector ) { |
|
- | 1656 | return this.pushStack( |
|
- | 1657 | jQuery.isFunction( selector ) && |
|
1702 | if ( isPartStr && !/\W/.test(part) ) { |
1658 | jQuery.grep(this, function(elem, i){ |
1703 | part = isXML ? part : part.toUpperCase(); |
1659 | return selector.call( elem, i ); |
- | 1660 | }) || |
|
1704 | 1661 | ||
1705 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
1662 | jQuery.multiFilter( selector, jQuery.grep(this, function(elem){ |
1706 | var elem = checkSet[i]; |
1663 | return elem.nodeType === 1; |
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++ ) { |
- | |
1714 | var elem = checkSet[i]; |
1664 | }) ), "filter", selector ); |
1715 | if ( elem ) { |
- | |
1716 | checkSet[i] = isPartStr ? |
- | |
1717 | elem.parentNode : |
- | |
1718 | elem.parentNode === part; |
- | |
1719 | }
|
- | |
1720 | }
|
1665 | }, |
1721 | 1666 | ||
- | 1667 | closest: function( selector ) { |
|
- | 1668 | var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null, |
|
- | 1669 | closer = 0; |
|
- | 1670 | ||
1722 | if ( isPartStr ) { |
1671 | return this.map(function(){ |
- | 1672 | var cur = this; |
|
- | 1673 | while ( cur && cur.ownerDocument ) { |
|
- | 1674 | if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) { |
|
1723 | Sizzle.filter( part, checkSet, true ); |
1675 | jQuery.data(cur, "closest", closer); |
- | 1676 | return cur; |
|
1724 | }
|
1677 | }
|
- | 1678 | cur = cur.parentNode; |
|
- | 1679 | closer++;
|
|
1725 | }
|
1680 | }
|
- | 1681 | }); |
|
1726 | }, |
1682 | }, |
1727 | "": function(checkSet, part, isXML){ |
- | |
1728 | var doneName = done++, checkFn = dirCheck; |
- | |
1729 | 1683 | ||
1730 | if ( !part.match(/\W/) ) { |
1684 | not: function( selector ) { |
- | 1685 | if ( typeof selector === "string" ) |
|
1731 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
1686 | // test special case where just one selector is passed in
|
1732 | checkFn = dirNodeCheck; |
1687 | if ( isSimple.test( selector ) ) |
- | 1688 | return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector ); |
|
1733 | }
|
1689 | else
|
- | 1690 | selector = jQuery.multiFilter( selector, this ); |
|
1734 | 1691 | ||
- | 1692 | var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType; |
|
- | 1693 | return this.filter(function() { |
|
1735 | checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML); |
1694 | return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector; |
- | 1695 | }); |
|
1736 | }, |
1696 | }, |
1737 | "~": function(checkSet, part, isXML){ |
- | |
1738 | var doneName = done++, checkFn = dirCheck; |
- | |
1739 | 1697 | ||
- | 1698 | add: function( selector ) { |
|
1740 | if ( typeof part === "string" && !part.match(/\W/) ) { |
1699 | return this.pushStack( jQuery.unique( jQuery.merge( |
- | 1700 | this.get(), |
|
1741 | var nodeCheck = part = isXML ? part : part.toUpperCase(); |
1701 | typeof selector === "string" ? |
- | 1702 | jQuery( selector ) : |
|
1742 | checkFn = dirNodeCheck; |
1703 | jQuery.makeArray( selector ) |
- | 1704 | ))); |
|
1743 | }
|
1705 | }, |
1744 | 1706 | ||
- | 1707 | eq: function( i ) { |
|
1745 | checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML); |
1708 | return this.slice( i, +i + 1 ); |
1746 | }
|
- | |
1747 | }, |
1709 | }, |
- | 1710 | ||
- | 1711 | slice: function() { |
|
- | 1712 | return this.pushStack( Array.prototype.slice.apply( this, arguments ), |
|
- | 1713 | "slice", Array.prototype.slice.call(arguments).join(",") ); |
|
- | 1714 | }, |
|
- | 1715 | ||
- | 1716 | map: function( callback ) { |
|
- | 1717 | return this.pushStack( jQuery.map(this, function(elem, i){ |
|
- | 1718 | return callback.call( elem, i, elem ); |
|
1748 | find: { |
1719 | })); |
- | 1720 | }, |
|
- | 1721 | ||
- | 1722 | andSelf: function() { |
|
- | 1723 | return this.add( this.prevObject ); |
|
- | 1724 | }, |
|
- | 1725 | ||
- | 1726 | end: function() { |
|
- | 1727 | return this.prevObject || jQuery(null); |
|
- | 1728 | }
|
|
- | 1729 | }); |
|
- | 1730 | ||
- | 1731 | jQuery.each({ |
|
- | 1732 | parent: function(elem){return elem.parentNode;}, |
|
- | 1733 | parents: function(elem){return jQuery.dir(elem,"parentNode");}, |
|
- | 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);}, |
|
- | 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){ |
|
- | 1742 | jQuery.fn[ name ] = function( selector ) { |
|
- | 1743 | var ret = jQuery.map( this, fn ); |
|
- | 1744 | ||
- | 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({ |
|
1749 | ID: function(match, context, isXML){ |
1751 | attr: function( name, value ) { |
- | 1752 | var options = name, isFunction = jQuery.isFunction( value ); |
|
- | 1753 | ||
1750 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
1754 | if ( typeof name === "string" ) { |
1751 | var m = context.getElementById(match[1]); |
1755 | // Are we setting the attribute?
|
- | 1756 | if ( value === undefined ) { |
|
1752 | return m ? [m] : []; |
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; |
|
1753 | }
|
1765 | }
|
1754 | }, |
1766 | }
|
1755 | NAME: function(match, context, isXML){ |
- | |
1756 | if ( typeof context.getElementsByName !== "undefined" ) { |
- | |
1757 | var ret = [], results = context.getElementsByName(match[1]); |
- | |
1758 | 1767 | ||
- | 1768 | // For each element...
|
|
1759 | for ( var i = 0, l = results.length; i < l; i++ ) { |
1769 | for ( var i = 0, l = this.length; i < l; i++ ) { |
- | 1770 | var elem = this[i]; |
|
- | 1771 | ||
- | 1772 | // Set all the attributes
|
|
1760 | if ( results[i].getAttribute("name") === match[1] ) { |
1773 | for ( var prop in options ) { |
1761 | ret.push( results[i] ); |
1774 | value = options[prop]; |
- | 1775 | ||
1762 | }
|
1776 | if ( isFunction ) { |
- | 1777 | value = value.call( elem, i ); |
|
1763 | }
|
1778 | }
|
1764 | 1779 | ||
1765 | return ret.length === 0 ? null : ret; |
1780 | jQuery.attr( elem, prop, value ); |
1766 | }
|
1781 | }
|
1767 | }, |
- | |
1768 | TAG: function(match, context){ |
- | |
1769 | return context.getElementsByTagName(match[1]); |
- | |
1770 | }
|
1782 | }
|
- | 1783 | ||
- | 1784 | return this; |
|
1771 | }, |
1785 | }, |
1772 | preFilter: { |
- | |
1773 | CLASS: function(match, curLoop, inplace, result, not, isXML){ |
- | |
1774 | match = " " + match[1].replace(/\\/g, "") + " "; |
- | |
1775 | 1786 | ||
1776 | if ( isXML ) { |
1787 | hasClass: function( selector ) { |
1777 | return match; |
1788 | return !!selector && this.is( "." + selector ); |
1778 | }
|
1789 | }, |
1779 | 1790 | ||
1780 | for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { |
- | |
1781 | if ( elem ) { |
1791 | val: function( value ) { |
1782 | if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) { |
- | |
1783 | if ( !inplace ) |
- | |
1784 | result.push( elem ); |
- | |
1785 | } else if ( inplace ) { |
1792 | if ( value === undefined ) { |
1786 | curLoop[i] = false; |
1793 | var elem = this[0]; |
1787 | }
|
- | |
1788 | }
|
- | |
1789 | }
|
- | |
1790 | 1794 | ||
1791 | return false; |
1795 | if ( elem ) { |
1792 | }, |
- | |
1793 | ID: function(match){ |
- | |
1794 | return match[1].replace(/\\/g, ""); |
1796 | if( jQuery.nodeName( elem, 'option' ) ) |
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(); |
1797 | return (elem.attributes.value || {}).specified ? elem.value : elem.text; |
1799 | }, |
- | |
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 | 1798 | ||
1807 | // calculate the numbers (first)n+(last) including if they are negative
|
1799 | // We need to handle select boxes special
|
1808 | match[2] = (test[1] + (test[2] || 1)) - 0; |
1800 | if ( jQuery.nodeName( elem, "select" ) ) { |
1809 | match[3] = test[3] - 0; |
1801 | var index = elem.selectedIndex, |
1810 | }
|
1802 | values = [], |
- | 1803 | options = elem.options, |
|
- | 1804 | one = elem.type == "select-one"; |
|
1811 | 1805 | ||
1812 | // TODO: Move to normal caching system
|
1806 | // Nothing was selected
|
- | 1807 | if ( index < 0 ) |
|
1813 | match[0] = done++; |
1808 | return null; |
1814 | 1809 | ||
1815 | return match; |
- | |
1816 | }, |
- | |
1817 | ATTR: function(match, curLoop, inplace, result, not, isXML){ |
- | |
1818 | var name = match[1].replace(/\\/g, ""); |
1810 | // Loop through all the selected options
|
1819 | - | ||
1820 | if ( !isXML && Expr.attrMap[name] ) { |
1811 | for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { |
1821 | match[1] = Expr.attrMap[name]; |
1812 | var option = options[ i ]; |
1822 | }
|
- | |
1823 | 1813 | ||
1824 | if ( match[2] === "~=" ) { |
1814 | if ( option.selected ) { |
- | 1815 | // Get the specifc value for the option
|
|
1825 | match[4] = " " + match[4] + " "; |
1816 | value = jQuery(option).val(); |
1826 | }
|
- | |
1827 | 1817 | ||
- | 1818 | // We don't need an array for one selects
|
|
- | 1819 | if ( one ) |
|
1828 | return match; |
1820 | return value; |
1829 | }, |
1821 | |
1830 | PSEUDO: function(match, curLoop, inplace, result, not){ |
1822 | // Multi-Selects return an array
|
1831 | if ( match[1] === "not" ) { |
1823 | values.push( value ); |
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 { |
1824 | }
|
1836 | var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); |
- | |
1837 | if ( !inplace ) { |
- | |
1838 | result.push.apply( result, ret ); |
- | |
1839 | }
|
1825 | }
|
- | 1826 | ||
1840 | return false; |
1827 | return values; |
1841 | }
|
1828 | }
|
- | 1829 | ||
1842 | } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { |
1830 | // Everything else, we just grab the value
|
1843 | return true; |
1831 | return (elem.value || "").replace(/\r/g, ""); |
- | 1832 | ||
1844 | }
|
1833 | }
|
1845 | 1834 | ||
1846 | return match; |
- | |
1847 | }, |
- | |
1848 | POS: function(match){ |
- | |
1849 | match.unshift( true ); |
- | |
1850 | return match; |
1835 | return undefined; |
1851 | }
|
- | |
1852 | }, |
- | |
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 | }, |
- | |
1860 | checked: function(elem){ |
- | |
1861 | return elem.checked === true; |
- | |
1862 | }, |
- | |
1863 | selected: function(elem){ |
- | |
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; |
- | |
1874 | }, |
- | |
1875 | has: function(elem, i, match){ |
- | |
1876 | return !!Sizzle( match[3], elem ).length; |
- | |
1877 | }, |
- | |
1878 | header: function(elem){ |
- | |
1879 | return /h\d/i.test( elem.nodeName ); |
- | |
1880 | }, |
- | |
1881 | text: function(elem){ |
- | |
1882 | return "text" === elem.type; |
- | |
1883 | }, |
- | |
1884 | radio: function(elem){ |
- | |
1885 | return "radio" === elem.type; |
- | |
1886 | }, |
- | |
1887 | checkbox: function(elem){ |
- | |
1888 | return "checkbox" === elem.type; |
- | |
1889 | }, |
- | |
1890 | file: function(elem){ |
- | |
1891 | return "file" === elem.type; |
- | |
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 | }, |
- | |
1908 | input: function(elem){ |
- | |
1909 | return /input|select|textarea|button/i.test(elem.nodeName); |
- | |
1910 | }
|
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 | }); |
|
- | 1863 | }
|
|
- | 1864 | }); |
|
- | 1865 | ||
- | 1866 | jQuery.each({ |
|
- | 1867 | removeAttr: function( name ) { |
|
- | 1868 | jQuery.attr( this, name, "" ); |
|
- | 1869 | if (this.nodeType == 1) |
|
- | 1870 | this.removeAttribute( name ); |
|
1911 | }, |
1871 | }, |
1912 | setFilters: { |
1872 | |
1913 | first: function(elem, i){ |
1873 | addClass: function( classNames ) { |
1914 | return i === 0; |
1874 | jQuery.className.add( this, classNames ); |
1915 | }, |
1875 | }, |
- | 1876 | ||
1916 | last: function(elem, i, match, array){ |
1877 | removeClass: function( classNames ) { |
1917 | return i === array.length - 1; |
1878 | jQuery.className.remove( this, classNames ); |
1918 | }, |
1879 | }, |
- | 1880 | ||
1919 | even: function(elem, i){ |
1881 | toggleClass: function( classNames, state ) { |
1920 | return i % 2 === 0; |
1882 | if( typeof state !== "boolean" ) |
- | 1883 | state = !jQuery.className.has( this, classNames ); |
|
- | 1884 | jQuery.className[ state ? "add" : "remove" ]( this, classNames ); |
|
1921 | }, |
1885 | }
|
1922 | odd: function(elem, i){ |
1886 | }, function(name, fn){ |
- | 1887 | jQuery.fn[ name ] = function(){ |
|
1923 | return i % 2 === 1; |
1888 | return this.each( fn, arguments ); |
1924 | }, |
1889 | }; |
- | 1890 | }); |
|
- | 1891 | ||
- | 1892 | jQuery.extend({ |
|
1925 | lt: function(elem, i, match){ |
1893 | className: { |
1926 | return i < match[3] - 0; |
1894 | // internal only, use addClass("class")
|
1927 | }, |
- | |
1928 | gt: function(elem, i, match){ |
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 ) ) |
|
1929 | return i > match[3] - 0; |
1898 | elem.className += (elem.className ? " " : "") + className; |
- | 1899 | }); |
|
1930 | }, |
1900 | }, |
- | 1901 | ||
- | 1902 | // internal only, use removeClass("class")
|
|
1931 | nth: function(elem, i, match){ |
1903 | remove: function( elem, classNames ) { |
1932 | return match[3] - 0 == i; |
1904 | if (elem.nodeType == 1) |
- | 1905 | elem.className = classNames !== undefined ? |
|
- | 1906 | jQuery.grep(elem.className.split(/\s+/), function(className){ |
|
- | 1907 | return !jQuery.className.has( classNames, className ); |
|
- | 1908 | }).join(" ") : |
|
- | 1909 | ""; |
|
1933 | }, |
1910 | }, |
- | 1911 | ||
- | 1912 | // internal only, use hasClass("class")
|
|
1934 | eq: function(elem, i, match){ |
1913 | has: function( elem, className ) { |
1935 | return match[3] - 0 == i; |
1914 | return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1; |
1936 | }
|
1915 | }
|
1937 | }, |
1916 | }, |
1938 | filter: { |
- | |
1939 | PSEUDO: function(elem, match, i, array){ |
- | |
1940 | var name = match[1], filter = Expr.filters[ name ]; |
- | |
1941 | 1917 | ||
1942 | if ( filter ) { |
- | |
1943 | return filter( elem, i, match, array ); |
1918 | attr: function( elem, name, value ) { |
1944 | } else if ( name === "contains" ) { |
1919 | // don't set attributes on text and comment nodes
|
1945 | return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0; |
1920 | if (!elem || elem.nodeType == 3 || elem.nodeType == 8) |
1946 | } else if ( name === "not" ) { |
- | |
1947 | var not = match[3]; |
1921 | return undefined; |
1948 | 1922 | ||
- | 1923 | var notxml = !elem.tagName || !jQuery.isXMLDoc( elem ), |
|
1949 | for ( var i = 0, l = not.length; i < l; i++ ) { |
1924 | // Whether we are setting (or getting)
|
- | 1925 | set = value !== undefined; |
|
- | 1926 | ||
- | 1927 | // Try to normalize/fix the name
|
|
- | 1928 | name = notxml && jQuery.props[ name ] || name; |
|
- | 1929 | ||
- | 1930 | // Only do all the following if this is a node (faster for style)
|
|
1950 | if ( not[i] === elem ) { |
1931 | if ( elem.tagName ) { |
- | 1932 | ||
- | 1933 | // These attributes require special treatment
|
|
- | 1934 | var special = /href|src|style/.test( name ); |
|
- | 1935 | ||
- | 1936 | // Safari mis-reports the default selected property of a hidden option
|
|
- | 1937 | // Accessing the parent's selectedIndex property fixes it
|
|
- | 1938 | if ( name == "selected" && elem.parentNode ) |
|
1951 | return false; |
1939 | elem.parentNode.selectedIndex; |
- | 1940 | ||
- | 1941 | // If applicable, access the attribute via the DOM 0 way
|
|
- | 1942 | if ( name in elem && notxml && !special ) { |
|
1952 | }
|
1943 | if ( set ){ |
- | 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 ) |
|
- | 1946 | throw "type property can't be changed"; |
|
- | 1947 | ||
- | 1948 | elem[ name ] = value; |
|
1953 | }
|
1949 | }
|
1954 | 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; |
|
- | 1966 | }
|
|
- | 1967 | ||
1955 | return true; |
1968 | return elem[ name ]; |
1956 | }
|
1969 | }
|
1957 | }, |
- | |
1958 | CHILD: function(elem, match){ |
- | |
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 | }
|
- | |
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 | }
|
- | |
1972 | return true; |
- | |
1973 | case 'nth': |
- | |
1974 | var first = match[2], last = match[3]; |
- | |
1975 | 1970 | ||
1976 | if ( first == 1 && last == 0 ) { |
- | |
1977 | return true; |
- | |
1978 | }
|
- | |
1979 | - | ||
1980 | var doneName = match[0], |
- | |
1981 | parent = elem.parentNode; |
- | |
1982 | - | ||
1983 | if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { |
1971 | if ( !jQuery.support.style && notxml && name == "style" ) { |
1984 | var count = 0; |
1972 | if ( set ) |
1985 | for ( node = parent.firstChild; node; node = node.nextSibling ) { |
- | |
1986 | if ( node.nodeType === 1 ) { |
- | |
1987 | node.nodeIndex = ++count; |
- | |
1988 | }
|
- | |
1989 | }
|
- | |
1990 | parent.sizcache = doneName; |
1973 | elem.style.cssText = "" + value; |
1991 | }
|
- | |
1992 | 1974 | ||
1993 | var diff = elem.nodeIndex - last; |
1975 | return elem.style.cssText; |
1994 | if ( first == 0 ) { |
- | |
1995 | return diff == 0; |
- | |
1996 | } else { |
- | |
1997 | return ( diff % first == 0 && diff / first >= 0 ); |
- | |
1998 | }
|
- | |
1999 | }
|
1976 | }
|
2000 | }, |
- | |
2001 | ID: function(elem, match){ |
- | |
2002 | return elem.nodeType === 1 && elem.getAttribute("id") === match; |
- | |
2003 | }, |
- | |
2004 | TAG: function(elem, match){ |
- | |
2005 | return (match === "*" && elem.nodeType === 1) || elem.nodeName === match; |
- | |
2006 | }, |
- | |
2007 | CLASS: function(elem, match){ |
- | |
2008 | return (" " + (elem.className || elem.getAttribute("class")) + " ") |
- | |
2009 | .indexOf( match ) > -1; |
- | |
2010 | }, |
- | |
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 | 1977 | ||
2022 | return result == null ? |
- | |
2023 | type === "!=" : |
- | |
2024 | type === "=" ? |
1978 | if ( set ) |
2025 | value === check : |
- | |
2026 | type === "*=" ? |
- | |
2027 | value.indexOf(check) >= 0 : |
- | |
2028 | type === "~=" ? |
- | |
2029 | (" " + value + " ").indexOf(check) >= 0 : |
1979 | // convert the value to a string (all browsers do this but IE) see #1070
|
2030 | !check ? |
- | |
2031 | value && result !== false : |
1980 | elem.setAttribute( name, "" + value ); |
2032 | type === "!=" ? |
- | |
2033 | value != check : |
- | |
2034 | type === "^=" ? |
- | |
2035 | value.indexOf(check) === 0 : |
- | |
2036 | type === "$=" ? |
- | |
- | 1981 | ||
2037 | value.substr(value.length - check.length) === check : |
1982 | var attr = !jQuery.support.hrefNormalized && notxml && special |
2038 | type === "|=" ? |
- | |
2039 | value === check || value.substr(0, check.length + 1) === check + "-" : |
1983 | // Some attributes require a special call on IE
|
2040 | false; |
- | |
2041 | }, |
- | |
2042 | POS: function(elem, match, i, array){ |
1984 | ? elem.getAttribute( name, 2 ) |
2043 | var name = match[2], filter = Expr.setFilters[ name ]; |
1985 | : elem.getAttribute( name ); |
2044 | 1986 | ||
2045 | if ( filter ) { |
1987 | // Non-existent attributes return null, we normalize to undefined
|
2046 | return filter( elem, i, match, array ); |
1988 | return attr === null ? undefined : attr; |
2047 | }
|
- | |
2048 | }
|
1989 | }
|
- | 1990 | ||
- | 1991 | // elem is actually elem.style ... set the style
|
|
- | 1992 | // Using attr for specific style information is now deprecated. Use style insead.
|
|
- | 1993 | return jQuery.style(elem, name, value); |
|
2049 | }
|
1994 | }
|
2050 | }; |
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 ) ); |
|
2051 | 1999 | ||
2052 | var origPOS = Expr.match.POS; |
2000 | var ret = ""; |
2053 | 2001 | ||
2054 | for ( var type in Expr.match ) { |
2002 | jQuery.each( text || this, function(){ |
2055 | Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source ); |
2003 | jQuery.each( this.childNodes, function(){ |
- | 2004 | if ( this.nodeType != 8 ) |
|
- | 2005 | ret += this.nodeType != 1 ? |
|
- | 2006 | this.nodeValue : |
|
- | 2007 | jQuery.fn.text( [ this ] ); |
|
- | 2008 | }); |
|
2056 | }
|
2009 | }); |
2057 | 2010 | ||
2058 | var makeArray = function(array, results) { |
2011 | return ret; |
2059 | array = Array.prototype.slice.call( array ); |
- | |
- | 2012 | }, |
|
2060 | 2013 | ||
- | 2014 | wrapAll: function( html ) { |
|
2061 | if ( results ) { |
2015 | if ( this[0] ) { |
2062 | results.push.apply( results, array ); |
2016 | // The elements to wrap the target around
|
2063 | return results; |
2017 | var wrap = jQuery( html, this[0].ownerDocument ).clone(); |
2064 | }
|
- | |
2065 | - | ||
2066 | return array; |
- | |
2067 | }; |
- | |
2068 | 2018 | ||
2069 | // Perform a simple check to determine if the browser is capable of
|
- | |
2070 | // converting a NodeList to an array using builtin methods.
|
2019 | if ( this[0].parentNode ) |
2071 | try { |
- | |
2072 | Array.prototype.slice.call( document.documentElement.childNodes ); |
2020 | wrap.insertBefore( this[0] ); |
2073 | 2021 | ||
2074 | // Provide a fallback method if it does not work
|
- | |
2075 | } catch(e){ |
- | |
2076 | makeArray = function(array, results) { |
2022 | wrap.map(function(){ |
2077 | var ret = results || []; |
2023 | var elem = this; |
2078 | 2024 | ||
2079 | if ( toString.call(array) === "[object Array]" ) { |
- | |
2080 | Array.prototype.push.apply( ret, array ); |
- | |
2081 | } else { |
- | |
2082 | if ( typeof array.length === "number" ) { |
2025 | while ( elem.firstChild ) |
2083 | for ( var i = 0, l = array.length; i < l; i++ ) { |
- | |
2084 | ret.push( array[i] ); |
2026 | elem = elem.firstChild; |
2085 | }
|
2027 | |
2086 | } else { |
2028 | return elem; |
2087 | for ( var i = 0; array[i]; i++ ) { |
- | |
2088 | ret.push( array[i] ); |
2029 | }).append(this); |
2089 | }
|
- | |
2090 | }
|
- | |
2091 | }
|
2030 | }
|
2092 | 2031 | ||
2093 | return ret; |
2032 | return this; |
2094 | }; |
2033 | }, |
2095 | }
|
- | |
2096 | 2034 | ||
2097 | var sortOrder; |
2035 | wrapInner: function( html ) { |
- | 2036 | return this.each(function(){ |
|
- | 2037 | jQuery( this ).contents().wrapAll( html ); |
|
- | 2038 | }); |
|
- | 2039 | }, |
|
2098 | 2040 | ||
2099 | if ( document.documentElement.compareDocumentPosition ) { |
- | |
2100 | sortOrder = function( a, b ) { |
2041 | wrap: function( html ) { |
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 ) { |
2042 | return this.each(function(){ |
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 ) { |
2043 | jQuery( this ).wrapAll( html ); |
2117 | var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange(); |
- | |
2118 | aRange.selectNode(a); |
- | |
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 | }
|
2044 | }); |
2126 | return ret; |
- | |
2127 | }; |
2045 | }, |
2128 | }
|
- | |
2129 | 2046 | ||
2130 | // Check to see if the browser returns elements by name when
|
- | |
2131 | // querying by getElementById (and provide a workaround)
|
- | |
2132 | (function(){ |
2047 | append: function() { |
2133 | // We're going to inject a fake input element with a specified name
|
2048 | return this.domManip(arguments, true, function(elem){ |
2134 | var form = document.createElement("form"), |
2049 | if (this.nodeType == 1) |
2135 | id = "script" + (new Date).getTime(); |
2050 | this.appendChild( elem ); |
2136 | form.innerHTML = "<input name='" + id + "'/>"; |
- | |
- | 2051 | }); |
|
- | 2052 | }, |
|
2137 | 2053 | ||
- | 2054 | prepend: function() { |
|
2138 | // Inject it into the root element, check its status, and remove it quickly
|
2055 | return this.domManip(arguments, true, function(elem){ |
2139 | var root = document.documentElement; |
2056 | if (this.nodeType == 1) |
2140 | root.insertBefore( form, root.firstChild ); |
2057 | this.insertBefore( elem, this.firstChild ); |
- | 2058 | }); |
|
- | 2059 | }, |
|
2141 | 2060 | ||
2142 | // The workaround has to do additional checks after a getElementById
|
- | |
2143 | // Which slows things down for other browsers (hence the branching)
|
- | |
2144 | if ( !!document.getElementById( id ) ) { |
2061 | before: function() { |
2145 | Expr.find.ID = function(match, context, isXML){ |
2062 | return this.domManip(arguments, false, function(elem){ |
2146 | if ( typeof context.getElementById !== "undefined" && !isXML ) { |
- | |
2147 | var m = context.getElementById(match[1]); |
2063 | this.parentNode.insertBefore( elem, this ); |
2148 | return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; |
- | |
2149 | }
|
2064 | }); |
2150 | }; |
2065 | }, |
2151 | 2066 | ||
2152 | Expr.filter.ID = function(elem, match){ |
2067 | after: function() { |
2153 | var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); |
2068 | return this.domManip(arguments, false, function(elem){ |
2154 | return elem.nodeType === 1 && node && node.nodeValue === match; |
2069 | this.parentNode.insertBefore( elem, this.nextSibling ); |
2155 | }; |
2070 | }); |
2156 | }
|
2071 | }, |
2157 | 2072 | ||
2158 | root.removeChild( form ); |
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
|
|
- | 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; |
|
- | 2086 | if ( !html ) { |
|
- | 2087 | var div = ownerDocument.createElement("div"); |
|
- | 2088 | div.appendChild( this.cloneNode(true) ); |
|
- | 2089 | html = div.innerHTML; |
|
2159 | })(); |
2090 | }
|
2160 | 2091 | ||
- | 2092 | return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")], ownerDocument)[0]; |
|
2161 | (function(){ |
2093 | } else |
2162 | // Check to see if the browser returns only elements
|
- | |
2163 | // when doing getElementsByTagName("*")
|
2094 | return this.cloneNode(true); |
- | 2095 | }); |
|
2164 | 2096 | ||
2165 | // Create a fake element
|
2097 | // Copy the events from the original to the clone
|
2166 | var div = document.createElement("div"); |
2098 | if ( events === true ) { |
2167 | div.appendChild( document.createComment("") ); |
2099 | var orig = this.find("*").andSelf(), i = 0; |
2168 | 2100 | ||
2169 | // Make sure no comments are found
|
2101 | ret.find("*").andSelf().each(function(){ |
2170 | if ( div.getElementsByTagName("*").length > 0 ) { |
2102 | if ( this.nodeName !== orig[i].nodeName ) |
2171 | Expr.find.TAG = function(match, context){ |
2103 | return; |
2172 | var results = context.getElementsByTagName(match[1]); |
- | |
2173 | 2104 | ||
2174 | // Filter out possible comments
|
2105 | var events = jQuery.data( orig[i], "events" ); |
2175 | if ( match[1] === "*" ) { |
- | |
2176 | var tmp = []; |
- | |
2177 | 2106 | ||
2178 | for ( var i = 0; results[i]; i++ ) { |
2107 | for ( var type in events ) { |
2179 | if ( results[i].nodeType === 1 ) { |
2108 | for ( var handler in events[ type ] ) { |
2180 | tmp.push( results[i] ); |
2109 | jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data ); |
2181 | }
|
2110 | }
|
2182 | }
|
2111 | }
|
2183 | 2112 | ||
2184 | results = tmp; |
- | |
2185 | }
|
2113 | i++;
|
2186 | - | ||
2187 | return results; |
- | |
2188 | }; |
2114 | }); |
2189 | }
|
2115 | }
|
2190 | 2116 | ||
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){ |
2117 | // Return the cloned set
|
2196 | return elem.getAttribute("href", 2); |
- | |
2197 | }; |
2118 | return ret; |
2198 | }
|
2119 | }, |
2199 | })(); |
- | |
2200 | 2120 | ||
- | 2121 | html: function( value ) { |
|
2201 | if ( document.querySelectorAll ) (function(){ |
2122 | return value === undefined ? |
- | 2123 | (this[0] ? |
|
2202 | var oldSizzle = Sizzle, div = document.createElement("div"); |
2124 | this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") : |
- | 2125 | null) : |
|
2203 | div.innerHTML = "<p class='TEST'></p>"; |
2126 | this.empty().append( value ); |
- | 2127 | }, |
|
2204 | 2128 | ||
2205 | // Safari can't handle uppercase or unicode characters when
|
2129 | replaceWith: function( value ) { |
2206 | // in quirks mode.
|
2130 | return this.after( value ).remove(); |
2207 | if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { |
- | |
2208 | return; |
- | |
2209 | }
|
2131 | }, |
2210 | - | ||
2211 | Sizzle = function(query, context, extra, seed){ |
- | |
2212 | context = context || document; |
- | |
2213 | 2132 | ||
2214 | // Only use querySelectorAll on non-XML documents
|
2133 | domManip: function( args, table, callback ) { |
2215 | // (ID selectors don't work in non-HTML documents)
|
2134 | if ( this[0] ) { |
2216 | if ( !seed && context.nodeType === 9 && !isXML(context) ) { |
2135 | var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(), |
2217 | try { |
- | |
2218 | return makeArray( context.querySelectorAll(query), extra ); |
2136 | scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ), |
2219 | } catch(e){} |
- | |
2220 | }
|
- | |
2221 | - | ||
2222 | return oldSizzle(query, context, extra, seed); |
2137 | first = fragment.firstChild; |
2223 | }; |
- | |
2224 | 2138 | ||
2225 | Sizzle.find = oldSizzle.find; |
2139 | if ( first ) |
2226 | Sizzle.filter = oldSizzle.filter; |
2140 | for ( var i = 0, l = this.length; i < l; i++ ) |
2227 | Sizzle.selectors = oldSizzle.selectors; |
2141 | callback.call( root(this[i], first), this.length > 1 || i > 0 ? |
2228 | Sizzle.matches = oldSizzle.matches; |
2142 | fragment.cloneNode(true) : fragment ); |
2229 | })(); |
- | |
2230 | 2143 | ||
2231 | if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){ |
- | |
2232 | var div = document.createElement("div"); |
2144 | if ( scripts ) |
2233 | div.innerHTML = "<div class='test e'></div><div class='test'></div>"; |
2145 | jQuery.each( scripts, evalScript ); |
- | 2146 | }
|
|
2234 | 2147 | ||
2235 | // Opera can't find a second classname (in 9.6)
|
- | |
2236 | if ( div.getElementsByClassName("e").length === 0 ) |
- | |
2237 | return; |
2148 | return this; |
2238 | 2149 | ||
- | 2150 | function root( elem, cur ) { |
|
2239 | // Safari caches class attributes, doesn't catch changes (in 3.2)
|
2151 | return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ? |
2240 | div.lastChild.className = "e"; |
2152 | (elem.getElementsByTagName("tbody")[0] || |
- | 2153 | elem.appendChild(elem.ownerDocument.createElement("tbody"))) : |
|
- | 2154 | elem;
|
|
- | 2155 | }
|
|
- | 2156 | }
|
|
- | 2157 | }); |
|
2241 | 2158 | ||
- | 2159 | jQuery.each({ |
|
- | 2160 | appendTo: "append", |
|
- | 2161 | prependTo: "prepend", |
|
2242 | if ( div.getElementsByClassName("e").length === 1 ) |
2162 | insertBefore: "before", |
2243 | return; |
2163 | insertAfter: "after", |
- | 2164 | replaceAll: "replaceWith" |
|
- | 2165 | }, function(name, original){ |
|
- | 2166 | jQuery.fn[ name ] = function( selector ) { |
|
- | 2167 | var ret = [], insert = jQuery( selector ); |
|
2244 | 2168 | ||
2245 | Expr.order.splice(1, 0, "CLASS"); |
2169 | for ( var i = 0, l = insert.length; i < l; i++ ) { |
2246 | Expr.find.CLASS = function(match, context, isXML) { |
2170 | var elems = (i > 0 ? this.clone(true) : this).get(); |
2247 | if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { |
2171 | jQuery.fn[ original ].apply( jQuery(insert[i]), elems ); |
2248 | return context.getElementsByClassName(match[1]); |
2172 | ret = ret.concat( elems ); |
2249 | }
|
2173 | }
|
- | 2174 | ||
- | 2175 | return this.pushStack( ret, name, selector ); |
|
2250 | }; |
2176 | }; |
2251 | })(); |
2177 | }); |
2252 | 2178 | ||
2253 | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
2179 | jQuery.each({ |
2254 | var sibDir = dir == "previousSibling" && !isXML; |
2180 | remove: function( selector ) { |
2255 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
2181 | if ( !selector || jQuery.multiFilter( selector, [ this ] ).length ) { |
2256 | var elem = checkSet[i]; |
- | |
2257 | if ( elem ) { |
- | |
2258 | if ( sibDir && elem.nodeType === 1 ){ |
2182 | if ( this.nodeType === 1 ) { |
2259 | elem.sizcache = doneName; |
2183 | cleanData( this.getElementsByTagName("*") ); |
2260 | elem.sizset = i; |
2184 | cleanData( [this] ); |
2261 | }
|
2185 | }
|
2262 | elem = elem[dir]; |
- | |
2263 | var match = false; |
- | |
2264 | - | ||
2265 | while ( elem ) { |
- | |
2266 | if ( elem.sizcache === doneName ) { |
- | |
2267 | match = checkSet[elem.sizset]; |
- | |
2268 | break; |
- | |
2269 | }
|
- | |
2270 | - | ||
2271 | if ( elem.nodeType === 1 && !isXML ){ |
- | |
2272 | elem.sizcache = doneName; |
- | |
2273 | elem.sizset = i; |
- | |
2274 | }
|
- | |
2275 | - | ||
2276 | if ( elem.nodeName === cur ) { |
- | |
2277 | match = elem; |
- | |
2278 | break; |
- | |
2279 | }
|
- | |
2280 | 2186 | ||
2281 | elem = elem[dir]; |
2187 | if ( this.parentNode ) { |
- | 2188 | this.parentNode.removeChild( this ); |
|
2282 | }
|
2189 | }
|
- | 2190 | }
|
|
- | 2191 | }, |
|
2283 | 2192 | ||
- | 2193 | empty: function() { |
|
- | 2194 | // Remove element nodes and prevent memory leaks
|
|
- | 2195 | if ( this.nodeType === 1 ) { |
|
- | 2196 | cleanData( this.getElementsByTagName("*") ); |
|
- | 2197 | }
|
|
- | 2198 | ||
- | 2199 | // Remove any remaining nodes
|
|
2284 | checkSet[i] = match; |
2200 | while ( this.firstChild ) { |
- | 2201 | this.removeChild( this.firstChild ); |
|
2285 | }
|
2202 | }
|
2286 | }
|
2203 | }
|
- | 2204 | }, function(name, fn){ |
|
- | 2205 | jQuery.fn[ name ] = function(){ |
|
- | 2206 | return this.each( fn, arguments ); |
|
2287 | }
|
2207 | }; |
- | 2208 | }); |
|
2288 | 2209 | ||
2289 | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { |
- | |
2290 | var sibDir = dir == "previousSibling" && !isXML; |
- | |
2291 | for ( var i = 0, l = checkSet.length; i < l; i++ ) { |
- | |
2292 | var elem = checkSet[i]; |
- | |
2293 | if ( elem ) { |
2210 | jQuery.extend({ |
2294 | if ( sibDir && elem.nodeType === 1 ) { |
2211 | clean: function( elems, context, fragment ) { |
2295 | elem.sizcache = doneName; |
2212 | context = context || document; |
2296 | elem.sizset = i; |
- | |
2297 | }
|
- | |
2298 | elem = elem[dir]; |
- | |
2299 | var match = false; |
- | |
2300 | 2213 | ||
2301 | while ( elem ) { |
2214 | // !context.createElement fails in IE with an error but returns typeof 'object'
|
2302 | if ( elem.sizcache === doneName ) { |
2215 | if ( typeof context.createElement === "undefined" ) |
2303 | match = checkSet[elem.sizset]; |
2216 | context = context.ownerDocument || context[0] && context[0].ownerDocument || document; |
2304 | break; |
- | |
2305 | }
|
- | |
2306 | 2217 | ||
2307 | if ( elem.nodeType === 1 ) { |
2218 | // If a single string is passed in and it's a single tag
|
2308 | if ( !isXML ) { |
- | |
2309 | elem.sizcache = doneName; |
2219 | // just do a createElement and skip the rest
|
2310 | elem.sizset = i; |
- | |
2311 | }
|
- | |
2312 | if ( typeof cur !== "string" ) { |
2220 | if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) { |
2313 | if ( elem === cur ) { |
2221 | var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); |
2314 | match = true; |
2222 | if ( match ) |
2315 | break; |
2223 | return [ context.createElement( match[1] ) ]; |
2316 | }
|
2224 | }
|
2317 | 2225 | ||
2318 | } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { |
2226 | var ret = [], scripts = [], div = context.createElement("div"); |
2319 | match = elem; |
- | |
2320 | break; |
- | |
2321 | }
|
- | |
2322 | }
|
- | |
2323 | 2227 | ||
- | 2228 | jQuery.each(elems, function(i, elem){ |
|
2324 | elem = elem[dir]; |
2229 | if ( typeof elem === "number" ) |
2325 | }
|
2230 | elem += ''; |
2326 | 2231 | ||
2327 | checkSet[i] = match; |
2232 | if ( !elem ) |
2328 | }
|
2233 | return; |
2329 | }
|
- | |
2330 | }
|
- | |
2331 | 2234 | ||
2332 | var contains = document.compareDocumentPosition ? function(a, b){ |
2235 | // Convert html string into DOM nodes
|
2333 | return a.compareDocumentPosition(b) & 16; |
2236 | if ( typeof elem === "string" ) { |
2334 | } : function(a, b){ |
2237 | // Fix "XHTML"-style tags in all browsers
|
- | 2238 | elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){ |
|
2335 | return a !== b && (a.contains ? a.contains(b) : true); |
2239 | return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ? |
- | 2240 | all :
|
|
- | 2241 | front + "></" + tag + ">"; |
|
2336 | }; |
2242 | }); |
2337 | 2243 | ||
2338 | var isXML = function(elem){ |
- | |
2339 | return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" || |
2244 | // Trim whitespace, otherwise indexOf won't work as expected
|
2340 | !!elem.ownerDocument && isXML( elem.ownerDocument ); |
2245 | var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase(); |
2341 | }; |
- | |
2342 | 2246 | ||
- | 2247 | var wrap = |
|
2343 | var posProcess = function(selector, context){ |
2248 | // option or optgroup
|
2344 | var tmpSet = [], later = "", match, |
2249 | !tags.indexOf("<opt") && |
2345 | root = context.nodeType ? [context] : context; |
2250 | [ 1, "<select multiple='multiple'>", "</select>" ] || |
2346 | 2251 | ||
2347 | // Position selectors must be done after the filter
|
- | |
2348 | // And so must :not(positional) so we move all PSEUDOs to the end
|
- | |
2349 | while ( (match = Expr.match.PSEUDO.exec( selector )) ) { |
- | |
2350 | later += match[0]; |
2252 | !tags.indexOf("<leg") && |
2351 | selector = selector.replace( Expr.match.PSEUDO, "" ); |
2253 | [ 1, "<fieldset>", "</fieldset>" ] || |
2352 | }
|
- | |
2353 | 2254 | ||
2354 | selector = Expr.relative[selector] ? selector + "*" : selector; |
2255 | tags.match(/^<(thead|tbody|tfoot|colg|cap)/) && |
- | 2256 | [ 1, "<table>", "</table>" ] || |
|
2355 | 2257 | ||
2356 | for ( var i = 0, l = root.length; i < l; i++ ) { |
2258 | !tags.indexOf("<tr") && |
2357 | Sizzle( selector, root[i], tmpSet ); |
2259 | [ 2, "<table><tbody>", "</tbody></table>" ] || |
2358 | }
|
- | |
2359 | 2260 | ||
2360 | return Sizzle.filter( later, tmpSet ); |
2261 | // <thead> matched above
|
2361 | }; |
- | |
- | 2262 | (!tags.indexOf("<td") || !tags.indexOf("<th")) && |
|
- | 2263 | [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] || |
|
2362 | 2264 | ||
2363 | // EXPOSE
|
- | |
2364 | jQuery.find = Sizzle; |
2265 | !tags.indexOf("<col") && |
2365 | jQuery.filter = Sizzle.filter; |
- | |
2366 | jQuery.expr = Sizzle.selectors; |
- | |
2367 | jQuery.expr[":"] = jQuery.expr.filters; |
2266 | [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] || |
2368 | 2267 | ||
2369 | Sizzle.selectors.filters.hidden = function(elem){ |
2268 | // IE can't serialize <link> and <script> tags normally
|
2370 | return elem.offsetWidth === 0 || elem.offsetHeight === 0; |
2269 | !jQuery.support.htmlSerialize && |
2371 | }; |
- | |
- | 2270 | [ 1, "div<div>", "</div>" ] || |
|
2372 | 2271 | ||
2373 | Sizzle.selectors.filters.visible = function(elem){ |
- | |
2374 | return elem.offsetWidth > 0 || elem.offsetHeight > 0; |
2272 | [ 0, "", "" ]; |
2375 | }; |
- | |
2376 | 2273 | ||
2377 | Sizzle.selectors.filters.animated = function(elem){ |
2274 | // Go to html and back, then peel off extra wrappers
|
2378 | return jQuery.grep(jQuery.timers, function(fn){ |
2275 | div.innerHTML = wrap[1] + elem + wrap[2]; |
2379 | return elem === fn.elem; |
- | |
2380 | }).length; |
- | |
2381 | }; |
- | |
2382 | 2276 | ||
2383 | jQuery.multiFilter = function( expr, elems, not ) { |
2277 | // Move to the right depth
|
2384 | if ( not ) { |
2278 | while ( wrap[0]-- ) |
2385 | expr = ":not(" + expr + ")"; |
2279 | div = div.lastChild; |
2386 | }
|
- | |
2387 | 2280 | ||
- | 2281 | // Remove IE's autoinserted <tbody> from table fragments
|
|
2388 | return Sizzle.matches(expr, elems); |
2282 | if ( !jQuery.support.tbody ) { |
2389 | }; |
- | |
2390 | 2283 | ||
2391 | jQuery.dir = function( elem, dir ){ |
2284 | // String was a <table>, *may* have spurious <tbody>
|
2392 | var matched = [], cur = elem[dir]; |
2285 | var hasBody = /<tbody/i.test(elem), |
2393 | while ( cur && cur != document ) { |
2286 | tbody = !tags.indexOf("<table") && !hasBody ? |
2394 | if ( cur.nodeType == 1 ) |
2287 | div.firstChild && div.firstChild.childNodes : |
2395 | matched.push( cur ); |
- | |
2396 | cur = cur[dir]; |
- | |
2397 | }
|
- | |
2398 | return matched; |
- | |
2399 | }; |
- | |
2400 | 2288 | ||
2401 | jQuery.nth = function(cur, result, dir, elem){ |
2289 | // String was a bare <thead> or <tfoot>
|
- | 2290 | wrap[1] == "<table>" && !hasBody ? |
|
2402 | result = result || 1; |
2291 | div.childNodes : |
2403 | var num = 0; |
2292 | []; |
- | 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 ] ); |
|
- | 2297 | ||
- | 2298 | }
|
|
2404 | 2299 | ||
2405 | for ( ; cur; cur = cur[dir] ) |
2300 | // IE completely kills leading whitespace when innerHTML is used
|
2406 | if ( cur.nodeType == 1 && ++num == result ) |
2301 | if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) ) |
2407 | break; |
- | |
- | 2302 | div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild ); |
|
2408 | 2303 | ||
2409 | return cur; |
2304 | elem = jQuery.makeArray( div.childNodes ); |
2410 | }; |
2305 | }
|
2411 | 2306 | ||
2412 | jQuery.sibling = function(n, elem){ |
2307 | if ( elem.nodeType ) |
2413 | var r = []; |
2308 | ret.push( elem ); |
- | 2309 | else
|
|
- | 2310 | ret = jQuery.merge( ret, elem ); |
|
2414 | 2311 | ||
2415 | for ( ; n; n = n.nextSibling ) { |
- | |
2416 | if ( n.nodeType == 1 && n != elem ) |
- | |
2417 | r.push( n ); |
- | |
2418 | }
|
2312 | }); |
2419 | 2313 | ||
- | 2314 | if ( fragment ) { |
|
- | 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] ); |
|
2420 | return r; |
2318 | } else { |
- | 2319 | if ( ret[i].nodeType === 1 ) |
|
- | 2320 | ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) ); |
|
- | 2321 | fragment.appendChild( ret[i] ); |
|
- | 2322 | }
|
|
2421 | }; |
2323 | }
|
2422 | 2324 | ||
2423 | return; |
2325 | return scripts; |
- | 2326 | }
|
|
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 | */
|
Строка 2481... | Строка 2393... | ||
2481 | type = namespaces.shift(); |
2393 | type = namespaces.shift(); |
2482 | handler.type = namespaces.slice().sort().join("."); |
2394 | handler.type = namespaces.slice().sort().join("."); |
2483 | 2395 | ||
2484 | // Get the current list of functions bound to this event
|
2396 | // Get the current list of functions bound to this event
|
2485 | var handlers = events[type]; |
2397 | var handlers = events[type]; |
2486 | 2398 | ||
2487 | if ( jQuery.event.specialAll[type] ) |
2399 | if ( jQuery.event.specialAll[type] ) |
2488 | jQuery.event.specialAll[type].setup.call(elem, data, namespaces); |
2400 | jQuery.event.specialAll[type].setup.call(elem, data, namespaces); |
2489 | 2401 | ||
2490 | // Init the event handler queue
|
2402 | // Init the event handler queue
|
2491 | if (!handlers) { |
2403 | if (!handlers) { |
Строка 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]; |
Строка 2554... | Строка 2466... | ||
2554 | else
|
2466 | else
|
2555 | for ( var handle in events[type] ) |
2467 | for ( var handle in events[type] ) |
2556 | // Handle the removal of namespaced events
|
2468 | // Handle the removal of namespaced events
|
2557 | if ( namespace.test(events[type][handle].type) ) |
2469 | if ( namespace.test(events[type][handle].type) ) |
2558 | delete events[type][handle]; |
2470 | delete events[type][handle]; |
2559 | 2471 | ||
2560 | if ( jQuery.event.specialAll[type] ) |
2472 | if ( jQuery.event.specialAll[type] ) |
2561 | jQuery.event.specialAll[type].teardown.call(elem, namespaces); |
2473 | jQuery.event.specialAll[type].teardown.call(elem, namespaces); |
2562 | 2474 | ||
2563 | // remove generic event handler if no more handlers exist
|
2475 | // remove generic event handler if no more handlers exist
|
2564 | for ( ret in events[type] ) break; |
2476 | for ( ret in events[type] ) break; |
Строка 2621... | Строка 2533... | ||
2621 | // Handle triggering a single element
|
2533 | // Handle triggering a single element
|
2622 | 2534 | ||
2623 | // don't do events on text and comment nodes
|
2535 | // don't do events on text and comment nodes
|
2624 | if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 ) |
2536 | if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 ) |
2625 | return undefined; |
2537 | return undefined; |
2626 | 2538 | ||
2627 | // Clean up in case it is reused
|
2539 | // Clean up in case it is reused
|
2628 | event.result = undefined; |
2540 | event.result = undefined; |
2629 | event.target = elem; |
2541 | event.target = elem; |
2630 | 2542 | ||
2631 | // Clone the incoming data, if any
|
2543 | // Clone the incoming data, if any
|
2632 | data = jQuery.makeArray(data); |
2544 | data = jQuery.makeArray(data); |
2633 | data.unshift( event ); |
2545 | data.unshift( event ); |
2634 | }
|
2546 | }
|
2635 | 2547 | ||
Строка 2666... | Строка 2578... | ||
2666 | // returned undefined or false
|
2578 | // returned undefined or false
|
2667 | var all, handlers; |
2579 | var all, handlers; |
2668 | 2580 | ||
2669 | event = arguments[0] = jQuery.event.fix( event || window.event ); |
2581 | event = arguments[0] = jQuery.event.fix( event || window.event ); |
2670 | event.currentTarget = this; |
2582 | event.currentTarget = this; |
2671 | 2583 | ||
2672 | // Namespaced event handlers
|
2584 | // Namespaced event handlers
|
2673 | var namespaces = event.type.split("."); |
2585 | var namespaces = event.type.split("."); |
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]; |
Строка 2771... | Строка 2683... | ||
2771 | // Make sure the ready event is setup
|
2683 | // Make sure the ready event is setup
|
2772 | setup: bindReady, |
2684 | setup: bindReady, |
2773 | teardown: function() {} |
2685 | teardown: function() {} |
2774 | }
|
2686 | }
|
2775 | }, |
2687 | }, |
2776 | 2688 | ||
2777 | specialAll: { |
2689 | specialAll: { |
2778 | live: { |
2690 | live: { |
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 | }); |
2790 | 2702 | ||
2791 | if ( remove < 1 ) |
2703 | if ( remove < 1 ) |
2792 | jQuery.event.remove( this, namespaces[0], liveHandler ); |
2704 | jQuery.event.remove( this, namespaces[0], liveHandler ); |
2793 | }
|
2705 | }
|
2794 | }
|
2706 | }
|
2795 | }
|
2707 | }
|
Строка 2798... | Строка 2710... | ||
2798 | 2710 | ||
2799 | jQuery.Event = function( src ){ |
2711 | jQuery.Event = function( src ){ |
2800 | // Allow instantiation without the 'new' keyword
|
2712 | // Allow instantiation without the 'new' keyword
|
2801 | if( !this.preventDefault ) |
2713 | if( !this.preventDefault ) |
2802 | return new jQuery.Event(src); |
2714 | return new jQuery.Event(src); |
2803 | 2715 | ||
2804 | // Event object
|
2716 | // Event object
|
2805 | if( src && src.type ){ |
2717 | if( src && src.type ){ |
2806 | this.originalEvent = src; |
2718 | this.originalEvent = src; |
2807 | this.type = src.type; |
2719 | this.type = src.type; |
2808 | // Event type
|
2720 | // Event type
|
Строка 2810... | Строка 2722... | ||
2810 | this.type = src; |
2722 | this.type = src; |
2811 | 2723 | ||
2812 | // timeStamp is buggy for some events on Firefox(#3843)
|
2724 | // timeStamp is buggy for some events on Firefox(#3843)
|
2813 | // So we won't rely on the native value
|
2725 | // So we won't rely on the native value
|
2814 | this.timeStamp = now(); |
2726 | this.timeStamp = now(); |
2815 | 2727 | ||
2816 | // Mark it as fixed
|
2728 | // Mark it as fixed
|
2817 | this[expando] = true; |
2729 | this[expando] = true; |
2818 | }; |
2730 | }; |
2819 | 2731 | ||
2820 | function returnFalse(){ |
2732 | function returnFalse(){ |
Строка 2866... | Строка 2778... | ||
2866 | var parent = event.relatedTarget; |
2778 | var parent = event.relatedTarget; |
2867 | // Traverse up the tree
|
2779 | // Traverse up the tree
|
2868 | while ( parent && parent != this ) |
2780 | while ( parent && parent != this ) |
2869 | try { parent = parent.parentNode; } |
2781 | try { parent = parent.parentNode; } |
2870 | catch(e) { parent = this; } |
2782 | catch(e) { parent = this; } |
2871 | 2783 | ||
2872 | if( parent != this ){ |
2784 | if( parent != this ){ |
2873 | // set the correct event type
|
2785 | // set the correct event type
|
2874 | event.type = event.data; |
2786 | event.type = event.data; |
2875 | // handle event if we actually just moused on to a non sub-element
|
2787 | // handle event if we actually just moused on to a non sub-element
|
2876 | jQuery.event.handle.apply( this, arguments ); |
2788 | jQuery.event.handle.apply( this, arguments ); |
2877 | }
|
2789 | }
|
2878 | }; |
2790 | }; |
2879 | 2791 | ||
2880 | jQuery.each({ |
2792 | jQuery.each({ |
2881 | mouseover: 'mouseenter', |
2793 | mouseover: 'mouseenter', |
2882 | mouseout: 'mouseleave' |
2794 | mouseout: 'mouseleave' |
2883 | }, function( orig, fix ){ |
2795 | }, function( orig, fix ){ |
2884 | jQuery.event.special[ fix ] = { |
2796 | jQuery.event.special[ fix ] = { |
2885 | setup: function(){ |
2797 | setup: function(){ |
2886 | jQuery.event.add( this, orig, withinElement, fix ); |
2798 | jQuery.event.add( this, orig, withinElement, fix ); |
2887 | }, |
2799 | }, |
2888 | teardown: function(){ |
2800 | teardown: function(){ |
2889 | jQuery.event.remove( this, orig, withinElement ); |
2801 | jQuery.event.remove( this, orig, withinElement ); |
2890 | }
|
2802 | }
|
2891 | }; |
2803 | }; |
2892 | }); |
2804 | }); |
2893 | 2805 | ||
2894 | jQuery.fn.extend({ |
2806 | jQuery.fn.extend({ |
2895 | bind: function( type, data, fn ) { |
2807 | bind: function( type, data, fn ) { |
2896 | return type == "unload" ? this.one(type, data, fn) : this.each(function(){ |
2808 | return type == "unload" ? this.one(type, data, fn) : this.each(function(){ |
Строка 2925... | Строка 2837... | ||
2925 | var event = jQuery.Event(type); |
2837 | var event = jQuery.Event(type); |
2926 | event.preventDefault(); |
2838 | event.preventDefault(); |
2927 | event.stopPropagation(); |
2839 | event.stopPropagation(); |
2928 | jQuery.event.trigger( event, data, this[0] ); |
2840 | jQuery.event.trigger( event, data, this[0] ); |
2929 | return event.result; |
2841 | return event.result; |
2930 | }
|
2842 | }
|
2931 | }, |
2843 | }, |
2932 | 2844 | ||
2933 | toggle: function( fn ) { |
2845 | toggle: function( fn ) { |
2934 | // Save reference to arguments for access in closure
|
2846 | // Save reference to arguments for access in closure
|
2935 | var args = arguments, i = 1; |
2847 | var args = arguments, i = 1; |
Строка 2968... | Строка 2880... | ||
2968 | // Add the function to the wait list
|
2880 | // Add the function to the wait list
|
2969 | jQuery.readyList.push( fn ); |
2881 | jQuery.readyList.push( fn ); |
2970 | 2882 | ||
2971 | return this; |
2883 | return this; |
2972 | }, |
2884 | }, |
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) ) { |
Строка 3000... | Строка 2912... | ||
3000 | }); |
2912 | }); |
3001 | 2913 | ||
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 ); |
3111 | }); |
3027 | }); |
3112 | (function(){ |
3028 | (function(){ |
3113 | 3029 | ||
3114 | jQuery.support = {}; |
3030 | jQuery.support = {}; |
3115 | 3031 | ||
3116 | var root = document.documentElement, |
3032 | var root = document.documentElement, |
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
|
Строка 3130... | Строка 3046... | ||
3130 | }
|
3046 | }
|
3131 | 3047 | ||
3132 | jQuery.support = { |
3048 | jQuery.support = { |
3133 | // IE strips leading whitespace when .innerHTML is used
|
3049 | // IE strips leading whitespace when .innerHTML is used
|
3134 | leadingWhitespace: div.firstChild.nodeType == 3, |
3050 | leadingWhitespace: div.firstChild.nodeType == 3, |
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
|
3150 | // (IE uses .cssText insted)
|
3061 | // (IE uses .cssText insted)
|
3151 | style: /red/.test( a.getAttribute("style") ), |
3062 | style: /red/.test( a.getAttribute("style") ), |
3152 | 3063 | ||
3153 | // Make sure that URLs aren't manipulated
|
3064 | // Make sure that URLs aren't manipulated
|
3154 | // (IE normalizes it by default)
|
3065 | // (IE normalizes it by default)
|
3155 | hrefNormalized: a.getAttribute("href") === "/a", |
3066 | hrefNormalized: a.getAttribute("href") === "/a", |
3156 | 3067 | ||
3157 | // Make sure that element opacity exists
|
3068 | // Make sure that element opacity exists
|
3158 | // (IE uses filter instead)
|
3069 | // (IE uses filter instead)
|
3159 | opacity: a.style.opacity === "0.5", |
3070 | opacity: a.style.opacity === "0.5", |
3160 | 3071 | ||
3161 | // Verify style float existence
|
3072 | // Verify style float existence
|
3162 | // (IE uses styleFloat instead of cssFloat)
|
3073 | // (IE uses styleFloat instead of cssFloat)
|
3163 | cssFloat: !!a.style.cssFloat, |
3074 | cssFloat: !!a.style.cssFloat, |
3164 | 3075 | ||
3165 | // Will be defined later
|
3076 | // Will be defined later
|
3166 | scriptEval: false, |
3077 | scriptEval: false, |
3167 | noCloneEvent: true, |
3078 | noCloneEvent: true, |
3168 | boxModel: null |
3079 | boxModel: null |
3169 | }; |
3080 | }; |
3170 | 3081 | ||
3171 | script.type = "text/javascript"; |
3082 | script.type = "text/javascript"; |
3172 | try { |
3083 | try { |
3173 | script.appendChild( document.createTextNode( "window." + id + "=1;" ) ); |
3084 | script.appendChild( document.createTextNode( "window." + id + "=1;" ) ); |
3174 | } catch(e){} |
3085 | } catch(e){} |
3175 | 3086 | ||
3176 | root.insertBefore( script, root.firstChild ); |
3087 | root.insertBefore( script, root.firstChild ); |
3177 | 3088 | ||
3178 | // Make sure that the execution of code works by injecting a script
|
3089 | // Make sure that the execution of code works by injecting a script
|
3179 | // tag with appendChild/createTextNode
|
3090 | // tag with appendChild/createTextNode
|
3180 | // (IE doesn't support this, fails, and uses .text instead)
|
3091 | // (IE doesn't support this, fails, and uses .text instead)
|
3181 | if ( window[ id ] ) { |
3092 | if ( window[ id ] ) { |
3182 | jQuery.support.scriptEval = true; |
3093 | jQuery.support.scriptEval = true; |
Строка 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" ) |
Строка 3316... | Строка 3426... | ||
3316 | }); |
3426 | }); |
3317 | 3427 | ||
3318 | var jsc = now(); |
3428 | var jsc = now(); |
3319 | 3429 | ||
3320 | jQuery.extend({ |
3430 | jQuery.extend({ |
3321 | 3431 | ||
3322 | get: function( url, data, callback, type ) { |
3432 | get: function( url, data, callback, type ) { |
3323 | // shift arguments if data argument was ommited
|
3433 | // shift arguments if data argument was ommited
|
3324 | if ( jQuery.isFunction( data ) ) { |
3434 | if ( jQuery.isFunction( data ) ) { |
3325 | callback = data; |
3435 | callback = data; |
3326 | data = null; |
3436 | data = null; |
Строка 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 | ||
Строка 3705... | Строка 3817... | ||
3705 | xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0, |
3817 | xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0, |
3706 | data = xml ? xhr.responseXML : xhr.responseText; |
3818 | data = xml ? xhr.responseXML : xhr.responseText; |
3707 | 3819 | ||
3708 | if ( xml && data.documentElement.tagName == "parsererror" ) |
3820 | if ( xml && data.documentElement.tagName == "parsererror" ) |
3709 | throw "parsererror"; |
3821 | throw "parsererror"; |
3710 | 3822 | ||
3711 | // Allow a pre-filtering function to sanitize the response
|
3823 | // Allow a pre-filtering function to sanitize the response
|
3712 | // s != null is checked to keep backwards compatibility
|
3824 | // s != null is checked to keep backwards compatibility
|
3713 | if( s && s.dataFilter ) |
3825 | if( s && s.dataFilter ) |
3714 | data = s.dataFilter( data, type ); |
3826 | data = s.dataFilter( data, type ); |
3715 | 3827 | ||
Строка 3722... | Строка 3834... | ||
3722 | 3834 | ||
3723 | // Get the JavaScript object, if JSON is used.
|
3835 | // Get the JavaScript object, if JSON is used.
|
3724 | if ( type == "json" ) |
3836 | if ( type == "json" ) |
3725 | data = window["eval"]("(" + data + ")"); |
3837 | data = window["eval"]("(" + data + ")"); |
3726 | }
|
3838 | }
|
3727 | 3839 | ||
3728 | return data; |
3840 | return data; |
3729 | }, |
3841 | }, |
3730 | 3842 | ||
3731 | // Serialize an array of form elements or a set of
|
3843 | // Serialize an array of form elements or a set of
|
3732 | // key/values into a query string
|
3844 | // key/values into a query string
|
Строка 3786... | Строка 3898... | ||
3786 | if ( speed ) { |
3898 | if ( speed ) { |
3787 | return this.animate( genFx("show", 3), speed, callback); |
3899 | return this.animate( genFx("show", 3), speed, callback); |
3788 | } else { |
3900 | } else { |
3789 | for ( var i = 0, l = this.length; i < l; i++ ){ |
3901 | for ( var i = 0, l = this.length; i < l; i++ ){ |
3790 | var old = jQuery.data(this[i], "olddisplay"); |
3902 | var old = jQuery.data(this[i], "olddisplay"); |
3791 | 3903 | ||
3792 | this[i].style.display = old || ""; |
3904 | this[i].style.display = old || ""; |
3793 | 3905 | ||
3794 | if ( jQuery.css(this[i], "display") === "none" ) { |
3906 | if ( jQuery.css(this[i], "display") === "none" ) { |
3795 | var tagName = this[i].tagName, display; |
3907 | var tagName = this[i].tagName, display; |
3796 | 3908 | ||
3797 | if ( elemdisplay[ tagName ] ) { |
3909 | if ( elemdisplay[ tagName ] ) { |
3798 | display = elemdisplay[ tagName ]; |
3910 | display = elemdisplay[ tagName ]; |
3799 | } else { |
3911 | } else { |
3800 | var elem = jQuery("<" + tagName + " />").appendTo("body"); |
3912 | var elem = jQuery("<" + tagName + " />").appendTo("body"); |
3801 | 3913 | ||
3802 | display = elem.css("display"); |
3914 | display = elem.css("display"); |
3803 | if ( display === "none" ) |
3915 | if ( display === "none" ) |
3804 | display = "block"; |
3916 | display = "block"; |
3805 | 3917 | ||
3806 | elem.remove(); |
3918 | elem.remove(); |
3807 | 3919 | ||
3808 | elemdisplay[ tagName ] = display; |
3920 | elemdisplay[ tagName ] = display; |
3809 | }
|
3921 | }
|
3810 | 3922 | ||
3811 | jQuery.data(this[i], "olddisplay", display); |
3923 | jQuery.data(this[i], "olddisplay", display); |
3812 | }
|
3924 | }
|
3813 | }
|
3925 | }
|
3814 | 3926 | ||
3815 | // Set the display of the elements in a second loop
|
3927 | // Set the display of the elements in a second loop
|
3816 | // to avoid the constant reflow
|
3928 | // to avoid the constant reflow
|
3817 | for ( var i = 0, l = this.length; i < l; i++ ){ |
3929 | for ( var i = 0, l = this.length; i < l; i++ ){ |
3818 | this[i].style.display = jQuery.data(this[i], "olddisplay") || ""; |
3930 | this[i].style.display = jQuery.data(this[i], "olddisplay") || ""; |
3819 | }
|
3931 | }
|
3820 | 3932 | ||
3821 | return this; |
3933 | return this; |
3822 | }
|
3934 | }
|
3823 | }, |
3935 | }, |
3824 | 3936 | ||
3825 | hide: function(speed,callback){ |
3937 | hide: function(speed,callback){ |
Строка 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 | ||
3868 | return this[ optall.queue === false ? "each" : "queue" ](function(){ |
3981 | return this[ optall.queue === false ? "each" : "queue" ](function(){ |
3869 | 3982 | ||
3870 | var opt = jQuery.extend({}, optall), p, |
3983 | var opt = jQuery.extend({}, optall), p, |
3871 | hidden = this.nodeType == 1 && jQuery(this).is(":hidden"), |
3984 | hidden = this.nodeType == 1 && jQuery(this).is(":hidden"), |
3872 | self = this; |
3985 | self = this; |
3873 | 3986 | ||
3874 | for ( p in prop ) { |
3987 | for ( p in prop ) { |
3875 | if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden ) |
3988 | if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden ) |
3876 | return opt.complete.call(this); |
3989 | return opt.complete.call(this); |
3877 | 3990 | ||
3878 | if ( ( p == "height" || p == "width" ) && this.style ) { |
3991 | if ( ( p == "height" || p == "width" ) && this.style ) { |
Строка 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 | ||
4133 | return false; |
4246 | return false; |
Строка 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() { |
4261 | var left = 0, top = 0, results; |
4379 | if ( !this[0] ) return null; |
4262 | 4380 | ||
4263 | if ( this[0] ) { |
- | |
4264 | // Get *real* offsetParent
|
- | |
4265 | var offsetParent = this.offsetParent(), |
4381 | var elem = this[0], left = 0, top = 0, results, |
4266 | 4382 | ||
- | 4383 | // Get *real* offsetParent
|
|
- | 4384 | offsetParent = this.offsetParent(), |
|
- | 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() { |
Строка 4298... | Строка 4416... | ||
4298 | 4416 | ||
4299 | 4417 | ||
4300 | // Create scrollLeft and scrollTop methods
|
4418 | // Create scrollLeft and scrollTop methods
|
4301 | jQuery.each( ['Left', 'Top'], function(i, name) { |
4419 | jQuery.each( ['Left', 'Top'], function(i, name) { |
4302 | var method = 'scroll' + name; |
4420 | var method = 'scroll' + name; |
4303 | 4421 | ||
4304 | jQuery.fn[ method ] = function(val) { |
4422 | jQuery.fn[ method ] = function(val) { |
4305 | if (!this[0]) return null; |
4423 | if ( !this[0] ) return null; |
4306 | 4424 | ||
4307 | return val !== undefined ? |
4425 | return val !== undefined ? |
4308 | 4426 | ||
4309 | // Set the scroll offset
|
4427 | // Set the scroll offset
|
4310 | this.each(function() { |
4428 | this.each(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 | - | ||
4348 | var type = name.toLowerCase(); |
- | |
4349 | 4463 | ||
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
|