]>
Commit | Line | Data |
---|---|---|
24c7594d BB |
1 | define([ |
2 | "./core", | |
3 | "./var/concat", | |
4 | "./var/push", | |
5 | "./core/access", | |
6 | "./manipulation/var/rcheckableType", | |
7 | "./manipulation/support", | |
8 | "./data/var/data_priv", | |
9 | "./data/var/data_user", | |
10 | ||
11 | "./core/init", | |
12 | "./data/accepts", | |
13 | "./traversing", | |
14 | "./selector", | |
15 | "./event" | |
16 | ], function( jQuery, concat, push, access, rcheckableType, support, data_priv, data_user ) { | |
17 | ||
18 | var | |
19 | rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, | |
20 | rtagName = /<([\w:]+)/, | |
21 | rhtml = /<|&#?\w+;/, | |
22 | rnoInnerhtml = /<(?:script|style|link)/i, | |
23 | // checked="checked" or checked | |
24 | rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, | |
25 | rscriptType = /^$|\/(?:java|ecma)script/i, | |
26 | rscriptTypeMasked = /^true\/(.*)/, | |
27 | rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, | |
28 | ||
29 | // We have to close these tags to support XHTML (#13200) | |
30 | wrapMap = { | |
31 | ||
32 | // Support: IE9 | |
33 | option: [ 1, "<select multiple='multiple'>", "</select>" ], | |
34 | ||
35 | thead: [ 1, "<table>", "</table>" ], | |
36 | col: [ 2, "<table><colgroup>", "</colgroup></table>" ], | |
37 | tr: [ 2, "<table><tbody>", "</tbody></table>" ], | |
38 | td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], | |
39 | ||
40 | _default: [ 0, "", "" ] | |
41 | }; | |
42 | ||
43 | // Support: IE9 | |
44 | wrapMap.optgroup = wrapMap.option; | |
45 | ||
46 | wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; | |
47 | wrapMap.th = wrapMap.td; | |
48 | ||
49 | // Support: 1.x compatibility | |
50 | // Manipulating tables requires a tbody | |
51 | function manipulationTarget( elem, content ) { | |
52 | return jQuery.nodeName( elem, "table" ) && | |
53 | jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ? | |
54 | ||
55 | elem.getElementsByTagName("tbody")[0] || | |
56 | elem.appendChild( elem.ownerDocument.createElement("tbody") ) : | |
57 | elem; | |
58 | } | |
59 | ||
60 | // Replace/restore the type attribute of script elements for safe DOM manipulation | |
61 | function disableScript( elem ) { | |
62 | elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type; | |
63 | return elem; | |
64 | } | |
65 | function restoreScript( elem ) { | |
66 | var match = rscriptTypeMasked.exec( elem.type ); | |
67 | ||
68 | if ( match ) { | |
69 | elem.type = match[ 1 ]; | |
70 | } else { | |
71 | elem.removeAttribute("type"); | |
72 | } | |
73 | ||
74 | return elem; | |
75 | } | |
76 | ||
77 | // Mark scripts as having already been evaluated | |
78 | function setGlobalEval( elems, refElements ) { | |
79 | var i = 0, | |
80 | l = elems.length; | |
81 | ||
82 | for ( ; i < l; i++ ) { | |
83 | data_priv.set( | |
84 | elems[ i ], "globalEval", !refElements || data_priv.get( refElements[ i ], "globalEval" ) | |
85 | ); | |
86 | } | |
87 | } | |
88 | ||
89 | function cloneCopyEvent( src, dest ) { | |
90 | var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events; | |
91 | ||
92 | if ( dest.nodeType !== 1 ) { | |
93 | return; | |
94 | } | |
95 | ||
96 | // 1. Copy private data: events, handlers, etc. | |
97 | if ( data_priv.hasData( src ) ) { | |
98 | pdataOld = data_priv.access( src ); | |
99 | pdataCur = data_priv.set( dest, pdataOld ); | |
100 | events = pdataOld.events; | |
101 | ||
102 | if ( events ) { | |
103 | delete pdataCur.handle; | |
104 | pdataCur.events = {}; | |
105 | ||
106 | for ( type in events ) { | |
107 | for ( i = 0, l = events[ type ].length; i < l; i++ ) { | |
108 | jQuery.event.add( dest, type, events[ type ][ i ] ); | |
109 | } | |
110 | } | |
111 | } | |
112 | } | |
113 | ||
114 | // 2. Copy user data | |
115 | if ( data_user.hasData( src ) ) { | |
116 | udataOld = data_user.access( src ); | |
117 | udataCur = jQuery.extend( {}, udataOld ); | |
118 | ||
119 | data_user.set( dest, udataCur ); | |
120 | } | |
121 | } | |
122 | ||
123 | function getAll( context, tag ) { | |
124 | var ret = context.getElementsByTagName ? context.getElementsByTagName( tag || "*" ) : | |
125 | context.querySelectorAll ? context.querySelectorAll( tag || "*" ) : | |
126 | []; | |
127 | ||
128 | return tag === undefined || tag && jQuery.nodeName( context, tag ) ? | |
129 | jQuery.merge( [ context ], ret ) : | |
130 | ret; | |
131 | } | |
132 | ||
133 | // Fix IE bugs, see support tests | |
134 | function fixInput( src, dest ) { | |
135 | var nodeName = dest.nodeName.toLowerCase(); | |
136 | ||
137 | // Fails to persist the checked state of a cloned checkbox or radio button. | |
138 | if ( nodeName === "input" && rcheckableType.test( src.type ) ) { | |
139 | dest.checked = src.checked; | |
140 | ||
141 | // Fails to return the selected option to the default selected state when cloning options | |
142 | } else if ( nodeName === "input" || nodeName === "textarea" ) { | |
143 | dest.defaultValue = src.defaultValue; | |
144 | } | |
145 | } | |
146 | ||
147 | jQuery.extend({ | |
148 | clone: function( elem, dataAndEvents, deepDataAndEvents ) { | |
149 | var i, l, srcElements, destElements, | |
150 | clone = elem.cloneNode( true ), | |
151 | inPage = jQuery.contains( elem.ownerDocument, elem ); | |
152 | ||
153 | // Fix IE cloning issues | |
154 | if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && | |
155 | !jQuery.isXMLDoc( elem ) ) { | |
156 | ||
157 | // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2 | |
158 | destElements = getAll( clone ); | |
159 | srcElements = getAll( elem ); | |
160 | ||
161 | for ( i = 0, l = srcElements.length; i < l; i++ ) { | |
162 | fixInput( srcElements[ i ], destElements[ i ] ); | |
163 | } | |
164 | } | |
165 | ||
166 | // Copy the events from the original to the clone | |
167 | if ( dataAndEvents ) { | |
168 | if ( deepDataAndEvents ) { | |
169 | srcElements = srcElements || getAll( elem ); | |
170 | destElements = destElements || getAll( clone ); | |
171 | ||
172 | for ( i = 0, l = srcElements.length; i < l; i++ ) { | |
173 | cloneCopyEvent( srcElements[ i ], destElements[ i ] ); | |
174 | } | |
175 | } else { | |
176 | cloneCopyEvent( elem, clone ); | |
177 | } | |
178 | } | |
179 | ||
180 | // Preserve script evaluation history | |
181 | destElements = getAll( clone, "script" ); | |
182 | if ( destElements.length > 0 ) { | |
183 | setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); | |
184 | } | |
185 | ||
186 | // Return the cloned set | |
187 | return clone; | |
188 | }, | |
189 | ||
190 | buildFragment: function( elems, context, scripts, selection ) { | |
191 | var elem, tmp, tag, wrap, contains, j, | |
192 | fragment = context.createDocumentFragment(), | |
193 | nodes = [], | |
194 | i = 0, | |
195 | l = elems.length; | |
196 | ||
197 | for ( ; i < l; i++ ) { | |
198 | elem = elems[ i ]; | |
199 | ||
200 | if ( elem || elem === 0 ) { | |
201 | ||
202 | // Add nodes directly | |
203 | if ( jQuery.type( elem ) === "object" ) { | |
204 | // Support: QtWebKit, PhantomJS | |
205 | // push.apply(_, arraylike) throws on ancient WebKit | |
206 | jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); | |
207 | ||
208 | // Convert non-html into a text node | |
209 | } else if ( !rhtml.test( elem ) ) { | |
210 | nodes.push( context.createTextNode( elem ) ); | |
211 | ||
212 | // Convert html into DOM nodes | |
213 | } else { | |
214 | tmp = tmp || fragment.appendChild( context.createElement("div") ); | |
215 | ||
216 | // Deserialize a standard representation | |
217 | tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); | |
218 | wrap = wrapMap[ tag ] || wrapMap._default; | |
219 | tmp.innerHTML = wrap[ 1 ] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[ 2 ]; | |
220 | ||
221 | // Descend through wrappers to the right content | |
222 | j = wrap[ 0 ]; | |
223 | while ( j-- ) { | |
224 | tmp = tmp.lastChild; | |
225 | } | |
226 | ||
227 | // Support: QtWebKit, PhantomJS | |
228 | // push.apply(_, arraylike) throws on ancient WebKit | |
229 | jQuery.merge( nodes, tmp.childNodes ); | |
230 | ||
231 | // Remember the top-level container | |
232 | tmp = fragment.firstChild; | |
233 | ||
234 | // Ensure the created nodes are orphaned (#12392) | |
235 | tmp.textContent = ""; | |
236 | } | |
237 | } | |
238 | } | |
239 | ||
240 | // Remove wrapper from fragment | |
241 | fragment.textContent = ""; | |
242 | ||
243 | i = 0; | |
244 | while ( (elem = nodes[ i++ ]) ) { | |
245 | ||
246 | // #4087 - If origin and destination elements are the same, and this is | |
247 | // that element, do not do anything | |
248 | if ( selection && jQuery.inArray( elem, selection ) !== -1 ) { | |
249 | continue; | |
250 | } | |
251 | ||
252 | contains = jQuery.contains( elem.ownerDocument, elem ); | |
253 | ||
254 | // Append to fragment | |
255 | tmp = getAll( fragment.appendChild( elem ), "script" ); | |
256 | ||
257 | // Preserve script evaluation history | |
258 | if ( contains ) { | |
259 | setGlobalEval( tmp ); | |
260 | } | |
261 | ||
262 | // Capture executables | |
263 | if ( scripts ) { | |
264 | j = 0; | |
265 | while ( (elem = tmp[ j++ ]) ) { | |
266 | if ( rscriptType.test( elem.type || "" ) ) { | |
267 | scripts.push( elem ); | |
268 | } | |
269 | } | |
270 | } | |
271 | } | |
272 | ||
273 | return fragment; | |
274 | }, | |
275 | ||
276 | cleanData: function( elems ) { | |
277 | var data, elem, type, key, | |
278 | special = jQuery.event.special, | |
279 | i = 0; | |
280 | ||
281 | for ( ; (elem = elems[ i ]) !== undefined; i++ ) { | |
282 | if ( jQuery.acceptData( elem ) ) { | |
283 | key = elem[ data_priv.expando ]; | |
284 | ||
285 | if ( key && (data = data_priv.cache[ key ]) ) { | |
286 | if ( data.events ) { | |
287 | for ( type in data.events ) { | |
288 | if ( special[ type ] ) { | |
289 | jQuery.event.remove( elem, type ); | |
290 | ||
291 | // This is a shortcut to avoid jQuery.event.remove's overhead | |
292 | } else { | |
293 | jQuery.removeEvent( elem, type, data.handle ); | |
294 | } | |
295 | } | |
296 | } | |
297 | if ( data_priv.cache[ key ] ) { | |
298 | // Discard any remaining `private` data | |
299 | delete data_priv.cache[ key ]; | |
300 | } | |
301 | } | |
302 | } | |
303 | // Discard any remaining `user` data | |
304 | delete data_user.cache[ elem[ data_user.expando ] ]; | |
305 | } | |
306 | } | |
307 | }); | |
308 | ||
309 | jQuery.fn.extend({ | |
310 | text: function( value ) { | |
311 | return access( this, function( value ) { | |
312 | return value === undefined ? | |
313 | jQuery.text( this ) : | |
314 | this.empty().each(function() { | |
315 | if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { | |
316 | this.textContent = value; | |
317 | } | |
318 | }); | |
319 | }, null, value, arguments.length ); | |
320 | }, | |
321 | ||
322 | append: function() { | |
323 | return this.domManip( arguments, function( elem ) { | |
324 | if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { | |
325 | var target = manipulationTarget( this, elem ); | |
326 | target.appendChild( elem ); | |
327 | } | |
328 | }); | |
329 | }, | |
330 | ||
331 | prepend: function() { | |
332 | return this.domManip( arguments, function( elem ) { | |
333 | if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { | |
334 | var target = manipulationTarget( this, elem ); | |
335 | target.insertBefore( elem, target.firstChild ); | |
336 | } | |
337 | }); | |
338 | }, | |
339 | ||
340 | before: function() { | |
341 | return this.domManip( arguments, function( elem ) { | |
342 | if ( this.parentNode ) { | |
343 | this.parentNode.insertBefore( elem, this ); | |
344 | } | |
345 | }); | |
346 | }, | |
347 | ||
348 | after: function() { | |
349 | return this.domManip( arguments, function( elem ) { | |
350 | if ( this.parentNode ) { | |
351 | this.parentNode.insertBefore( elem, this.nextSibling ); | |
352 | } | |
353 | }); | |
354 | }, | |
355 | ||
356 | remove: function( selector, keepData /* Internal Use Only */ ) { | |
357 | var elem, | |
358 | elems = selector ? jQuery.filter( selector, this ) : this, | |
359 | i = 0; | |
360 | ||
361 | for ( ; (elem = elems[i]) != null; i++ ) { | |
362 | if ( !keepData && elem.nodeType === 1 ) { | |
363 | jQuery.cleanData( getAll( elem ) ); | |
364 | } | |
365 | ||
366 | if ( elem.parentNode ) { | |
367 | if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) { | |
368 | setGlobalEval( getAll( elem, "script" ) ); | |
369 | } | |
370 | elem.parentNode.removeChild( elem ); | |
371 | } | |
372 | } | |
373 | ||
374 | return this; | |
375 | }, | |
376 | ||
377 | empty: function() { | |
378 | var elem, | |
379 | i = 0; | |
380 | ||
381 | for ( ; (elem = this[i]) != null; i++ ) { | |
382 | if ( elem.nodeType === 1 ) { | |
383 | ||
384 | // Prevent memory leaks | |
385 | jQuery.cleanData( getAll( elem, false ) ); | |
386 | ||
387 | // Remove any remaining nodes | |
388 | elem.textContent = ""; | |
389 | } | |
390 | } | |
391 | ||
392 | return this; | |
393 | }, | |
394 | ||
395 | clone: function( dataAndEvents, deepDataAndEvents ) { | |
396 | dataAndEvents = dataAndEvents == null ? false : dataAndEvents; | |
397 | deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; | |
398 | ||
399 | return this.map(function() { | |
400 | return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); | |
401 | }); | |
402 | }, | |
403 | ||
404 | html: function( value ) { | |
405 | return access( this, function( value ) { | |
406 | var elem = this[ 0 ] || {}, | |
407 | i = 0, | |
408 | l = this.length; | |
409 | ||
410 | if ( value === undefined && elem.nodeType === 1 ) { | |
411 | return elem.innerHTML; | |
412 | } | |
413 | ||
414 | // See if we can take a shortcut and just use innerHTML | |
415 | if ( typeof value === "string" && !rnoInnerhtml.test( value ) && | |
416 | !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { | |
417 | ||
418 | value = value.replace( rxhtmlTag, "<$1></$2>" ); | |
419 | ||
420 | try { | |
421 | for ( ; i < l; i++ ) { | |
422 | elem = this[ i ] || {}; | |
423 | ||
424 | // Remove element nodes and prevent memory leaks | |
425 | if ( elem.nodeType === 1 ) { | |
426 | jQuery.cleanData( getAll( elem, false ) ); | |
427 | elem.innerHTML = value; | |
428 | } | |
429 | } | |
430 | ||
431 | elem = 0; | |
432 | ||
433 | // If using innerHTML throws an exception, use the fallback method | |
434 | } catch( e ) {} | |
435 | } | |
436 | ||
437 | if ( elem ) { | |
438 | this.empty().append( value ); | |
439 | } | |
440 | }, null, value, arguments.length ); | |
441 | }, | |
442 | ||
443 | replaceWith: function() { | |
444 | var arg = arguments[ 0 ]; | |
445 | ||
446 | // Make the changes, replacing each context element with the new content | |
447 | this.domManip( arguments, function( elem ) { | |
448 | arg = this.parentNode; | |
449 | ||
450 | jQuery.cleanData( getAll( this ) ); | |
451 | ||
452 | if ( arg ) { | |
453 | arg.replaceChild( elem, this ); | |
454 | } | |
455 | }); | |
456 | ||
457 | // Force removal if there was no new content (e.g., from empty arguments) | |
458 | return arg && (arg.length || arg.nodeType) ? this : this.remove(); | |
459 | }, | |
460 | ||
461 | detach: function( selector ) { | |
462 | return this.remove( selector, true ); | |
463 | }, | |
464 | ||
465 | domManip: function( args, callback ) { | |
466 | ||
467 | // Flatten any nested arrays | |
468 | args = concat.apply( [], args ); | |
469 | ||
470 | var fragment, first, scripts, hasScripts, node, doc, | |
471 | i = 0, | |
472 | l = this.length, | |
473 | set = this, | |
474 | iNoClone = l - 1, | |
475 | value = args[ 0 ], | |
476 | isFunction = jQuery.isFunction( value ); | |
477 | ||
478 | // We can't cloneNode fragments that contain checked, in WebKit | |
479 | if ( isFunction || | |
480 | ( l > 1 && typeof value === "string" && | |
481 | !support.checkClone && rchecked.test( value ) ) ) { | |
482 | return this.each(function( index ) { | |
483 | var self = set.eq( index ); | |
484 | if ( isFunction ) { | |
485 | args[ 0 ] = value.call( this, index, self.html() ); | |
486 | } | |
487 | self.domManip( args, callback ); | |
488 | }); | |
489 | } | |
490 | ||
491 | if ( l ) { | |
492 | fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this ); | |
493 | first = fragment.firstChild; | |
494 | ||
495 | if ( fragment.childNodes.length === 1 ) { | |
496 | fragment = first; | |
497 | } | |
498 | ||
499 | if ( first ) { | |
500 | scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); | |
501 | hasScripts = scripts.length; | |
502 | ||
503 | // Use the original fragment for the last item instead of the first because it can end up | |
504 | // being emptied incorrectly in certain situations (#8070). | |
505 | for ( ; i < l; i++ ) { | |
506 | node = fragment; | |
507 | ||
508 | if ( i !== iNoClone ) { | |
509 | node = jQuery.clone( node, true, true ); | |
510 | ||
511 | // Keep references to cloned scripts for later restoration | |
512 | if ( hasScripts ) { | |
513 | // Support: QtWebKit | |
514 | // jQuery.merge because push.apply(_, arraylike) throws | |
515 | jQuery.merge( scripts, getAll( node, "script" ) ); | |
516 | } | |
517 | } | |
518 | ||
519 | callback.call( this[ i ], node, i ); | |
520 | } | |
521 | ||
522 | if ( hasScripts ) { | |
523 | doc = scripts[ scripts.length - 1 ].ownerDocument; | |
524 | ||
525 | // Reenable scripts | |
526 | jQuery.map( scripts, restoreScript ); | |
527 | ||
528 | // Evaluate executable scripts on first document insertion | |
529 | for ( i = 0; i < hasScripts; i++ ) { | |
530 | node = scripts[ i ]; | |
531 | if ( rscriptType.test( node.type || "" ) && | |
532 | !data_priv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) { | |
533 | ||
534 | if ( node.src ) { | |
535 | // Optional AJAX dependency, but won't run scripts if not present | |
536 | if ( jQuery._evalUrl ) { | |
537 | jQuery._evalUrl( node.src ); | |
538 | } | |
539 | } else { | |
540 | jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) ); | |
541 | } | |
542 | } | |
543 | } | |
544 | } | |
545 | } | |
546 | } | |
547 | ||
548 | return this; | |
549 | } | |
550 | }); | |
551 | ||
552 | jQuery.each({ | |
553 | appendTo: "append", | |
554 | prependTo: "prepend", | |
555 | insertBefore: "before", | |
556 | insertAfter: "after", | |
557 | replaceAll: "replaceWith" | |
558 | }, function( name, original ) { | |
559 | jQuery.fn[ name ] = function( selector ) { | |
560 | var elems, | |
561 | ret = [], | |
562 | insert = jQuery( selector ), | |
563 | last = insert.length - 1, | |
564 | i = 0; | |
565 | ||
566 | for ( ; i <= last; i++ ) { | |
567 | elems = i === last ? this : this.clone( true ); | |
568 | jQuery( insert[ i ] )[ original ]( elems ); | |
569 | ||
570 | // Support: QtWebKit | |
571 | // .get() because push.apply(_, arraylike) throws | |
572 | push.apply( ret, elems.get() ); | |
573 | } | |
574 | ||
575 | return this.pushStack( ret ); | |
576 | }; | |
577 | }); | |
578 | ||
579 | return jQuery; | |
580 | }); |