ecomp-sdk-app/src/main/webapp/app/policyApp/libs/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/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 });