baf99d52d90626792b8c966b6dda28e45dd6e097
[jquery.git] / src / manipulation.js
1 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
2         rleadingWhitespace = /^\s+/,
3         rxhtmlTag = /(<([\w:]+)[^>]*?)\/>/g,
4         rselfClosing = /^(?:abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i,
5         rtagName = /<([\w:]+)/,
6         rtbody = /<tbody/i,
7         rhtml = /<|&\w+;/,
8         fcloseTag = function(all, front, tag){
9                 return rselfClosing.test(tag) ?
10                         all :
11                         front + "></" + tag + ">";
12         },
13         wrapMap = {
14                 option: [ 1, "<select multiple='multiple'>", "</select>" ],
15                 legend: [ 1, "<fieldset>", "</fieldset>" ],
16                 thead: [ 1, "<table>", "</table>" ],
17                 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
18                 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
19                 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
20                 _default: [ 0, "", "" ]
21         };
22
23 wrapMap.optgroup = wrapMap.option;
24 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
25 wrapMap.th = wrapMap.td;
26
27 // IE can't serialize <link> and <script> tags normally
28 if ( !jQuery.support.htmlSerialize ) {
29         wrapMap._default = [ 1, "div<div>", "</div>" ];
30 }
31
32 jQuery.fn.extend({
33         text: function( text ) {
34                 if ( typeof text !== "object" && text !== undefined ) {
35                         return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
36                 }
37
38                 var ret = "";
39
40                 jQuery.each( this, function() {
41                         // Get the text from text nodes and CDATA nodes
42                         if ( this.nodeType === 3 || this.nodeType === 4 ) {
43                                 ret += this.nodeValue;
44
45                         // Traverse everything else, except comment nodes
46                         } else if ( this.nodeType !== 8 ) {
47                                 ret += jQuery.fn.text.call( this.childNodes );
48                         }
49                 });
50
51                 return ret;
52         },
53
54         wrapAll: function( html ) {
55                 if ( jQuery.isFunction( html ) ) {
56                         return this.each(function() {
57                                 jQuery(this).wrapAll( html.apply(this, arguments) );
58                         });
59                 }
60
61                 if ( this[0] ) {
62                         // The elements to wrap the target around
63                         var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone();
64
65                         if ( this[0].parentNode ) {
66                                 wrap.insertBefore( this[0] );
67                         }
68
69                         wrap.map(function(){
70                                 var elem = this;
71
72                                 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
73                                         elem = elem.firstChild;
74                                 }
75
76                                 return elem;
77                         }).append(this);
78                 }
79
80                 return this;
81         },
82
83         wrapInner: function( html ) {
84                 return this.each(function(){
85                         jQuery( this ).contents().wrapAll( html );
86                 });
87         },
88
89         wrap: function( html ) {
90                 return this.each(function(){
91                         jQuery( this ).wrapAll( html );
92                 });
93         },
94
95         unwrap: function() {
96                 return this.parent().each(function(){
97                         if ( !jQuery.nodeName( this, "body" ) ) {
98                                 jQuery( this ).replaceWith( this.childNodes );
99                         }
100                 }).end();
101         },
102         
103         append: function() {
104                 return this.domManip(arguments, true, function(elem){
105                         if ( this.nodeType === 1 ) {
106                                 this.appendChild( elem );
107                         }
108                 });
109         },
110
111         prepend: function() {
112                 return this.domManip(arguments, true, function(elem){
113                         if ( this.nodeType === 1 ) {
114                                 this.insertBefore( elem, this.firstChild );
115                         }
116                 });
117         },
118
119         before: function() {
120                 if ( this[0] && this[0].parentNode ) {
121                         return this.domManip(arguments, false, function(elem){
122                                 this.parentNode.insertBefore( elem, this );
123                         });
124                 } else if ( arguments.length ) {
125                         var set = jQuery(arguments[0]);
126                         set.push.apply( set, this.toArray() );
127                         return this.pushStack( set, "before", arguments );
128                 }
129         },
130
131         after: function() {
132                 if ( this[0] && this[0].parentNode ) {
133                         return this.domManip(arguments, false, function(elem){
134                                 this.parentNode.insertBefore( elem, this.nextSibling );
135                         });
136                 } else if ( arguments.length ) {
137                         var set = this.pushStack( this, "after", arguments );
138                         set.push.apply( set, jQuery(arguments[0]).toArray() );
139                         return set;
140                 }
141         },
142
143         clone: function( events ) {
144                 // Do the clone
145                 var ret = this.map(function(){
146                         if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
147                                 // IE copies events bound via attachEvent when
148                                 // using cloneNode. Calling detachEvent on the
149                                 // clone will also remove the events from the orignal
150                                 // In order to get around this, we use innerHTML.
151                                 // Unfortunately, this means some modifications to
152                                 // attributes in IE that are actually only stored
153                                 // as properties will not be copied (such as the
154                                 // the name attribute on an input).
155                                 var html = this.outerHTML, ownerDocument = this.ownerDocument;
156                                 if ( !html ) {
157                                         var div = ownerDocument.createElement("div");
158                                         div.appendChild( this.cloneNode(true) );
159                                         html = div.innerHTML;
160                                 }
161
162                                 return jQuery.clean([html.replace(rinlinejQuery, "")
163                                         .replace(rleadingWhitespace, "")], ownerDocument)[0];
164                         } else {
165                                 return this.cloneNode(true);
166                         }
167                 });
168
169                 // Copy the events from the original to the clone
170                 if ( events === true ) {
171                         cloneCopyEvent( this, ret );
172                         cloneCopyEvent( this.find("*"), ret.find("*") );
173                 }
174
175                 // Return the cloned set
176                 return ret;
177         },
178
179         html: function( value ) {
180                 if ( value === undefined ) {
181                         return this[0] ?
182                                 this[0].innerHTML.replace(rinlinejQuery, "") :
183                                 null;
184
185                 // See if we can take a shortcut and just use innerHTML
186                 } else if ( typeof value === "string" && !/<script/i.test( value ) &&
187                         (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
188                         !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
189
190                         try {
191                                 for ( var i = 0, l = this.length; i < l; i++ ) {
192                                         // Remove element nodes and prevent memory leaks
193                                         if ( this[i].nodeType === 1 ) {
194                                                 cleanData( this[i].getElementsByTagName("*") );
195                                                 this[i].innerHTML = value;
196                                         }
197                                 }
198
199                         // If using innerHTML throws an exception, use the fallback method
200                         } catch(e) {
201                                 this.empty().append( value );
202                         }
203
204                 } else {
205                         this.empty().append( value );
206                 }
207
208                 return this;
209         },
210
211         replaceWith: function( value ) {
212                 if ( this[0] && this[0].parentNode ) {
213                         return this.after( value ).remove();
214                 } else {
215                         return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
216                 }
217         },
218
219         detach: function( selector ) {
220                 return this.remove( selector, true );
221         },
222
223         domManip: function( args, table, callback ) {
224                 var results, first, value = args[0], scripts = [];
225
226                 if ( jQuery.isFunction(value) ) {
227                         return this.each(function() {
228                                 args[0] = value.call(this);
229                                 return jQuery(this).domManip( args, table, callback );
230                         });
231                 }
232
233                 if ( this[0] ) {
234                         // If we're in a fragment, just use that instead of building a new one
235                         if ( args[0] && args[0].parentNode && args[0].parentNode.nodeType === 11 ) {
236                                 results = { fragment: args[0].parentNode };
237                         } else {
238                                 results = buildFragment( args, this, scripts );
239                         }
240
241                         first = results.fragment.firstChild;
242
243                         if ( first ) {
244                                 table = table && jQuery.nodeName( first, "tr" );
245
246                                 for ( var i = 0, l = this.length; i < l; i++ ) {
247                                         callback.call(
248                                                 table ?
249                                                         root(this[i], first) :
250                                                         this[i],
251                                                 results.cacheable || this.length > 1 || i > 0 ?
252                                                         results.fragment.cloneNode(true) :
253                                                         results.fragment
254                                         );
255                                 }
256                         }
257
258                         if ( scripts ) {
259                                 jQuery.each( scripts, evalScript );
260                         }
261                 }
262
263                 return this;
264
265                 function root( elem, cur ) {
266                         return jQuery.nodeName(elem, "table") ?
267                                 (elem.getElementsByTagName("tbody")[0] ||
268                                 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
269                                 elem;
270                 }
271         }
272 });
273
274 function cloneCopyEvent(orig, ret) {
275         var i = 0;
276
277         ret.each(function(){
278                 if ( this.nodeName !== orig[i].nodeName ) {
279                         return;
280                 }
281
282                 var events = jQuery.data( orig[i], "events" );
283
284                 for ( var type in events ) {
285                         for ( var handler in events[ type ] ) {
286                                 jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
287                         }
288                 }
289         });
290 }
291
292 function buildFragment(args, nodes, scripts){
293         var fragment, cacheable, cached, cacheresults, doc;
294
295         if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && args[0].indexOf("<option") < 0 ) {
296                 cacheable = true;
297                 cacheresults = jQuery.fragments[ args[0] ];
298                 if ( cacheresults ) {
299                         if ( cacheresults !== 1 ) {
300                                 fragment = cacheresults;
301                         }
302                         cached = true;
303                 }
304         }
305
306         if ( !fragment ) {
307                 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
308                 fragment = doc.createDocumentFragment();
309                 jQuery.clean( args, doc, fragment, scripts );
310         }
311
312         if ( cacheable ) {
313                 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
314         }
315
316         return { fragment: fragment, cacheable: cacheable };
317 }
318
319 jQuery.fragments = {};
320
321 jQuery.each({
322         appendTo: "append",
323         prependTo: "prepend",
324         insertBefore: "before",
325         insertAfter: "after",
326         replaceAll: "replaceWith"
327 }, function(name, original){
328         jQuery.fn[ name ] = function( selector ) {
329                 var ret = [], insert = jQuery( selector );
330
331                 for ( var i = 0, l = insert.length; i < l; i++ ) {
332                         var elems = (i > 0 ? this.clone(true) : this).get();
333                         jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
334                         ret = ret.concat( elems );
335                 }
336                 return this.pushStack( ret, name, insert.selector );
337         };
338 });
339
340 jQuery.each({
341         // keepData is for internal use only--do not document
342         remove: function( selector, keepData ) {
343                 if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
344                         if ( !keepData && this.nodeType === 1 ) {
345                                 cleanData( this.getElementsByTagName("*") );
346                                 cleanData( [ this ] );
347                         }
348
349                         if ( this.parentNode ) {
350                                  this.parentNode.removeChild( this );
351                         }
352                 }
353         },
354
355         empty: function() {
356                 // Remove element nodes and prevent memory leaks
357                 if ( this.nodeType === 1 ) {
358                         cleanData( this.getElementsByTagName("*") );
359                 }
360
361                 // Remove any remaining nodes
362                 while ( this.firstChild ) {
363                         this.removeChild( this.firstChild );
364                 }
365         }
366 }, function(name, fn){
367         jQuery.fn[ name ] = function(){
368                 return this.each( fn, arguments );
369         };
370 });
371
372 jQuery.extend({
373         clean: function( elems, context, fragment, scripts ) {
374                 context = context || document;
375
376                 // !context.createElement fails in IE with an error but returns typeof 'object'
377                 if ( typeof context.createElement === "undefined" ) {
378                         context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
379                 }
380
381                 var ret = [], div = context.createElement("div");
382
383                 jQuery.each(elems, function(i, elem){
384                         if ( typeof elem === "number" ) {
385                                 elem += '';
386                         }
387
388                         if ( !elem ) { return; }
389
390                         // Convert html string into DOM nodes
391                         if ( typeof elem === "string" && !rhtml.test( elem ) ) {
392                                 elem = context.createTextNode( elem );
393
394                         } else if ( typeof elem === "string" ) {
395                                 // Fix "XHTML"-style tags in all browsers
396                                 elem = elem.replace(rxhtmlTag, fcloseTag);
397
398                                 // Trim whitespace, otherwise indexOf won't work as expected
399                                 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
400                                         wrap = wrapMap[ tag ] || wrapMap._default,
401                                         depth = wrap[0];
402
403                                 // Go to html and back, then peel off extra wrappers
404                                 div.innerHTML = wrap[1] + elem + wrap[2];
405
406                                 // Move to the right depth
407                                 while ( depth-- ) {
408                                         div = div.lastChild;
409                                 }
410
411                                 // Remove IE's autoinserted <tbody> from table fragments
412                                 if ( !jQuery.support.tbody ) {
413
414                                         // String was a <table>, *may* have spurious <tbody>
415                                         var hasBody = rtbody.test(elem),
416                                                 tbody = tag === "table" && !hasBody ?
417                                                         div.firstChild && div.firstChild.childNodes :
418
419                                                         // String was a bare <thead> or <tfoot>
420                                                         wrap[1] == "<table>" && !hasBody ?
421                                                                 div.childNodes :
422                                                                 [];
423
424                                         for ( var j = tbody.length - 1; j >= 0 ; --j ) {
425                                                 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
426                                                         tbody[ j ].parentNode.removeChild( tbody[ j ] );
427                                                 }
428                                         }
429
430                                 }
431
432                                 // IE completely kills leading whitespace when innerHTML is used
433                                 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
434                                         div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
435                                 }
436
437                                 elem = jQuery.makeArray( div.childNodes );
438                         }
439
440                         if ( elem.nodeType ) {
441                                 ret.push( elem );
442                         } else {
443                                 ret = jQuery.merge( ret, elem );
444                         }
445
446                 });
447
448                 if ( fragment ) {
449                         for ( var i = 0; ret[i]; i++ ) {
450                                 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
451                                         scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
452                                 } else {
453                                         if ( ret[i].nodeType === 1 ) {
454                                                 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
455                                         }
456                                         fragment.appendChild( ret[i] );
457                                 }
458                         }
459                 }
460
461                 return ret;
462         }
463 });
464
465 function cleanData( elems ) {
466         for ( var i = 0, elem, id; (elem = elems[i]) != null; i++ ) {
467                 if ( (id = elem[expando]) ) {
468                         delete jQuery.cache[ id ];
469                 }
470         }
471 }