ecomp-portal-FE/client/bower_components/jquery/src/manipulation.js

   1 define( [
   2         "./core",
   3         "./var/concat",
   4         "./var/push",
   5         "./core/access",
   6         "./manipulation/var/rcheckableType",
   7         "./manipulation/var/rtagName",
   8         "./manipulation/var/rscriptType",
   9         "./manipulation/wrapMap",
  10         "./manipulation/getAll",
  11         "./manipulation/setGlobalEval",
  12         "./manipulation/buildFragment",
  13         "./manipulation/support",
  14
  15         "./data/var/dataPriv",
  16         "./data/var/dataUser",
  17         "./data/var/acceptData",
  18
  19         "./core/init",
  20         "./traversing",
  21         "./selector",
  22         "./event"
  23 ], function( jQuery, concat, push, access,
  24         rcheckableType, rtagName, rscriptType,
  25         wrapMap, getAll, setGlobalEval, buildFragment, support,
  26         dataPriv, dataUser, acceptData ) {
  27
  28 var
  29         rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
  30
  31         // Support: IE 10-11, Edge 10240+
  32         // In IE/Edge using regex groups here causes severe slowdowns.
  33         // See https://connect.microsoft.com/IE/feedback/details/1736512/
  34         rnoInnerhtml = /<script|<style|<link/i,
  35
  36         // checked="checked" or checked
  37         rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  38         rscriptTypeMasked = /^true\/(.*)/,
  39         rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  40
  41 // Manipulating tables requires a tbody
  42 function manipulationTarget( elem, content ) {
  43         return jQuery.nodeName( elem, "table" ) &&
  44                 jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
  45
  46                 elem.getElementsByTagName( "tbody" )[ 0 ] ||
  47                         elem.appendChild( elem.ownerDocument.createElement( "tbody" ) ) :
  48                 elem;
  49 }
  50
  51 // Replace/restore the type attribute of script elements for safe DOM manipulation
  52 function disableScript( elem ) {
  53         elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
  54         return elem;
  55 }
  56 function restoreScript( elem ) {
  57         var match = rscriptTypeMasked.exec( elem.type );
  58
  59         if ( match ) {
  60                 elem.type = match[ 1 ];
  61         } else {
  62                 elem.removeAttribute( "type" );
  63         }
  64
  65         return elem;
  66 }
  67
  68 function cloneCopyEvent( src, dest ) {
  69         var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
  70
  71         if ( dest.nodeType !== 1 ) {
  72                 return;
  73         }
  74
  75         // 1. Copy private data: events, handlers, etc.
  76         if ( dataPriv.hasData( src ) ) {
  77                 pdataOld = dataPriv.access( src );
  78                 pdataCur = dataPriv.set( dest, pdataOld );
  79                 events = pdataOld.events;
  80
  81                 if ( events ) {
  82                         delete pdataCur.handle;
  83                         pdataCur.events = {};
  84
  85                         for ( type in events ) {
  86                                 for ( i = 0, l = events[ type ].length; i < l; i++ ) {
  87                                         jQuery.event.add( dest, type, events[ type ][ i ] );
  88                                 }
  89                         }
  90                 }
  91         }
  92
  93         // 2. Copy user data
  94         if ( dataUser.hasData( src ) ) {
  95                 udataOld = dataUser.access( src );
  96                 udataCur = jQuery.extend( {}, udataOld );
  97
  98                 dataUser.set( dest, udataCur );
  99         }
 100 }
 101
 102 // Fix IE bugs, see support tests
 103 function fixInput( src, dest ) {
 104         var nodeName = dest.nodeName.toLowerCase();
 105
 106         // Fails to persist the checked state of a cloned checkbox or radio button.
 107         if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
 108                 dest.checked = src.checked;
 109
 110         // Fails to return the selected option to the default selected state when cloning options
 111         } else if ( nodeName === "input" || nodeName === "textarea" ) {
 112                 dest.defaultValue = src.defaultValue;
 113         }
 114 }
 115
 116 function domManip( collection, args, callback, ignored ) {
 117
 118         // Flatten any nested arrays
 119         args = concat.apply( [], args );
 120
 121         var fragment, first, scripts, hasScripts, node, doc,
 122                 i = 0,
 123                 l = collection.length,
 124                 iNoClone = l - 1,
 125                 value = args[ 0 ],
 126                 isFunction = jQuery.isFunction( value );
 127
 128         // We can't cloneNode fragments that contain checked, in WebKit
 129         if ( isFunction ||
 130                         ( l > 1 && typeof value === "string" &&
 131                                 !support.checkClone && rchecked.test( value ) ) ) {
 132                 return collection.each( function( index ) {
 133                         var self = collection.eq( index );
 134                         if ( isFunction ) {
 135                                 args[ 0 ] = value.call( this, index, self.html() );
 136                         }
 137                         domManip( self, args, callback, ignored );
 138                 } );
 139         }
 140
 141         if ( l ) {
 142                 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
 143                 first = fragment.firstChild;
 144
 145                 if ( fragment.childNodes.length === 1 ) {
 146                         fragment = first;
 147                 }
 148
 149                 // Require either new content or an interest in ignored elements to invoke the callback
 150                 if ( first || ignored ) {
 151                         scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
 152                         hasScripts = scripts.length;
 153
 154                         // Use the original fragment for the last item
 155                         // instead of the first because it can end up
 156                         // being emptied incorrectly in certain situations (#8070).
 157                         for ( ; i < l; i++ ) {
 158                                 node = fragment;
 159
 160                                 if ( i !== iNoClone ) {
 161                                         node = jQuery.clone( node, true, true );
 162
 163                                         // Keep references to cloned scripts for later restoration
 164                                         if ( hasScripts ) {
 165
 166                                                 // Support: Android<4.1, PhantomJS<2
 167                                                 // push.apply(_, arraylike) throws on ancient WebKit
 168                                                 jQuery.merge( scripts, getAll( node, "script" ) );
 169                                         }
 170                                 }
 171
 172                                 callback.call( collection[ i ], node, i );
 173                         }
 174
 175                         if ( hasScripts ) {
 176                                 doc = scripts[ scripts.length - 1 ].ownerDocument;
 177
 178                                 // Reenable scripts
 179                                 jQuery.map( scripts, restoreScript );
 180
 181                                 // Evaluate executable scripts on first document insertion
 182                                 for ( i = 0; i < hasScripts; i++ ) {
 183                                         node = scripts[ i ];
 184                                         if ( rscriptType.test( node.type || "" ) &&
 185                                                 !dataPriv.access( node, "globalEval" ) &&
 186                                                 jQuery.contains( doc, node ) ) {
 187
 188                                                 if ( node.src ) {
 189
 190                                                         // Optional AJAX dependency, but won't run scripts if not present
 191                                                         if ( jQuery._evalUrl ) {
 192                                                                 jQuery._evalUrl( node.src );
 193                                                         }
 194                                                 } else {
 195                                                         jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
 196                                                 }
 197                                         }
 198                                 }
 199                         }
 200                 }
 201         }
 202
 203         return collection;
 204 }
 205
 206 function remove( elem, selector, keepData ) {
 207         var node,
 208                 nodes = selector ? jQuery.filter( selector, elem ) : elem,
 209                 i = 0;
 210
 211         for ( ; ( node = nodes[ i ] ) != null; i++ ) {
 212                 if ( !keepData && node.nodeType === 1 ) {
 213                         jQuery.cleanData( getAll( node ) );
 214                 }
 215
 216                 if ( node.parentNode ) {
 217                         if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
 218                                 setGlobalEval( getAll( node, "script" ) );
 219                         }
 220                         node.parentNode.removeChild( node );
 221                 }
 222         }
 223
 224         return elem;
 225 }
 226
 227 jQuery.extend( {
 228         htmlPrefilter: function( html ) {
 229                 return html.replace( rxhtmlTag, "<$1></$2>" );
 230         },
 231
 232         clone: function( elem, dataAndEvents, deepDataAndEvents ) {
 233                 var i, l, srcElements, destElements,
 234                         clone = elem.cloneNode( true ),
 235                         inPage = jQuery.contains( elem.ownerDocument, elem );
 236
 237                 // Fix IE cloning issues
 238                 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
 239                                 !jQuery.isXMLDoc( elem ) ) {
 240
 241                         // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
 242                         destElements = getAll( clone );
 243                         srcElements = getAll( elem );
 244
 245                         for ( i = 0, l = srcElements.length; i < l; i++ ) {
 246                                 fixInput( srcElements[ i ], destElements[ i ] );
 247                         }
 248                 }
 249
 250                 // Copy the events from the original to the clone
 251                 if ( dataAndEvents ) {
 252                         if ( deepDataAndEvents ) {
 253                                 srcElements = srcElements || getAll( elem );
 254                                 destElements = destElements || getAll( clone );
 255
 256                                 for ( i = 0, l = srcElements.length; i < l; i++ ) {
 257                                         cloneCopyEvent( srcElements[ i ], destElements[ i ] );
 258                                 }
 259                         } else {
 260                                 cloneCopyEvent( elem, clone );
 261                         }
 262                 }
 263
 264                 // Preserve script evaluation history
 265                 destElements = getAll( clone, "script" );
 266                 if ( destElements.length > 0 ) {
 267                         setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
 268                 }
 269
 270                 // Return the cloned set
 271                 return clone;
 272         },
 273
 274         cleanData: function( elems ) {
 275                 var data, elem, type,
 276                         special = jQuery.event.special,
 277                         i = 0;
 278
 279                 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
 280                         if ( acceptData( elem ) ) {
 281                                 if ( ( data = elem[ dataPriv.expando ] ) ) {
 282                                         if ( data.events ) {
 283                                                 for ( type in data.events ) {
 284                                                         if ( special[ type ] ) {
 285                                                                 jQuery.event.remove( elem, type );
 286
 287                                                         // This is a shortcut to avoid jQuery.event.remove's overhead
 288                                                         } else {
 289                                                                 jQuery.removeEvent( elem, type, data.handle );
 290                                                         }
 291                                                 }
 292                                         }
 293
 294                                         // Support: Chrome <= 35-45+
 295                                         // Assign undefined instead of using delete, see Data#remove
 296                                         elem[ dataPriv.expando ] = undefined;
 297                                 }
 298                                 if ( elem[ dataUser.expando ] ) {
 299
 300                                         // Support: Chrome <= 35-45+
 301                                         // Assign undefined instead of using delete, see Data#remove
 302                                         elem[ dataUser.expando ] = undefined;
 303                                 }
 304                         }
 305                 }
 306         }
 307 } );
 308
 309 jQuery.fn.extend( {
 310
 311         // Keep domManip exposed until 3.0 (gh-2225)
 312         domManip: domManip,
 313
 314         detach: function( selector ) {
 315                 return remove( this, selector, true );
 316         },
 317
 318         remove: function( selector ) {
 319                 return remove( this, selector );
 320         },
 321
 322         text: function( value ) {
 323                 return access( this, function( value ) {
 324                         return value === undefined ?
 325                                 jQuery.text( this ) :
 326                                 this.empty().each( function() {
 327                                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 328                                                 this.textContent = value;
 329                                         }
 330                                 } );
 331                 }, null, value, arguments.length );
 332         },
 333
 334         append: function() {
 335                 return domManip( this, arguments, function( elem ) {
 336                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 337                                 var target = manipulationTarget( this, elem );
 338                                 target.appendChild( elem );
 339                         }
 340                 } );
 341         },
 342
 343         prepend: function() {
 344                 return domManip( this, arguments, function( elem ) {
 345                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 346                                 var target = manipulationTarget( this, elem );
 347                                 target.insertBefore( elem, target.firstChild );
 348                         }
 349                 } );
 350         },
 351
 352         before: function() {
 353                 return domManip( this, arguments, function( elem ) {
 354                         if ( this.parentNode ) {
 355                                 this.parentNode.insertBefore( elem, this );
 356                         }
 357                 } );
 358         },
 359
 360         after: function() {
 361                 return domManip( this, arguments, function( elem ) {
 362                         if ( this.parentNode ) {
 363                                 this.parentNode.insertBefore( elem, this.nextSibling );
 364                         }
 365                 } );
 366         },
 367
 368         empty: function() {
 369                 var elem,
 370                         i = 0;
 371
 372                 for ( ; ( elem = this[ i ] ) != null; i++ ) {
 373                         if ( elem.nodeType === 1 ) {
 374
 375                                 // Prevent memory leaks
 376                                 jQuery.cleanData( getAll( elem, false ) );
 377
 378                                 // Remove any remaining nodes
 379                                 elem.textContent = "";
 380                         }
 381                 }
 382
 383                 return this;
 384         },
 385
 386         clone: function( dataAndEvents, deepDataAndEvents ) {
 387                 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
 388                 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
 389
 390                 return this.map( function() {
 391                         return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
 392                 } );
 393         },
 394
 395         html: function( value ) {
 396                 return access( this, function( value ) {
 397                         var elem = this[ 0 ] || {},
 398                                 i = 0,
 399                                 l = this.length;
 400
 401                         if ( value === undefined && elem.nodeType === 1 ) {
 402                                 return elem.innerHTML;
 403                         }
 404
 405                         // See if we can take a shortcut and just use innerHTML
 406                         if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
 407                                 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
 408
 409                                 value = jQuery.htmlPrefilter( value );
 410
 411                                 try {
 412                                         for ( ; i < l; i++ ) {
 413                                                 elem = this[ i ] || {};
 414
 415                                                 // Remove element nodes and prevent memory leaks
 416                                                 if ( elem.nodeType === 1 ) {
 417                                                         jQuery.cleanData( getAll( elem, false ) );
 418                                                         elem.innerHTML = value;
 419                                                 }
 420                                         }
 421
 422                                         elem = 0;
 423
 424                                 // If using innerHTML throws an exception, use the fallback method
 425                                 } catch ( e ) {}
 426                         }
 427
 428                         if ( elem ) {
 429                                 this.empty().append( value );
 430                         }
 431                 }, null, value, arguments.length );
 432         },
 433
 434         replaceWith: function() {
 435                 var ignored = [];
 436
 437                 // Make the changes, replacing each non-ignored context element with the new content
 438                 return domManip( this, arguments, function( elem ) {
 439                         var parent = this.parentNode;
 440
 441                         if ( jQuery.inArray( this, ignored ) < 0 ) {
 442                                 jQuery.cleanData( getAll( this ) );
 443                                 if ( parent ) {
 444                                         parent.replaceChild( elem, this );
 445                                 }
 446                         }
 447
 448                 // Force callback invocation
 449                 }, ignored );
 450         }
 451 } );
 452
 453 jQuery.each( {
 454         appendTo: "append",
 455         prependTo: "prepend",
 456         insertBefore: "before",
 457         insertAfter: "after",
 458         replaceAll: "replaceWith"
 459 }, function( name, original ) {
 460         jQuery.fn[ name ] = function( selector ) {
 461                 var elems,
 462                         ret = [],
 463                         insert = jQuery( selector ),
 464                         last = insert.length - 1,
 465                         i = 0;
 466
 467                 for ( ; i <= last; i++ ) {
 468                         elems = i === last ? this : this.clone( true );
 469                         jQuery( insert[ i ] )[ original ]( elems );
 470
 471                         // Support: QtWebKit
 472                         // .get() because push.apply(_, arraylike) throws
 473                         push.apply( ret, elems.get() );
 474                 }
 475
 476                 return this.pushStack( ret );
 477         };
 478 } );
 479
 480 return jQuery;
 481 } );