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