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

   1 define( [
   2         "./core",
   3         "./var/document",
   4         "./var/rnotwhite",
   5         "./var/slice",
   6         "./data/var/dataPriv",
   7
   8         "./core/init",
   9         "./selector"
  10 ], function( jQuery, document, rnotwhite, slice, dataPriv ) {
  11
  12 var
  13         rkeyEvent = /^key/,
  14         rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
  15         rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
  16
  17 function returnTrue() {
  18         return true;
  19 }
  20
  21 function returnFalse() {
  22         return false;
  23 }
  24
  25 // Support: IE9
  26 // See #13393 for more info
  27 function safeActiveElement() {
  28         try {
  29                 return document.activeElement;
  30         } catch ( err ) { }
  31 }
  32
  33 function on( elem, types, selector, data, fn, one ) {
  34         var origFn, type;
  35
  36         // Types can be a map of types/handlers
  37         if ( typeof types === "object" ) {
  38
  39                 // ( types-Object, selector, data )
  40                 if ( typeof selector !== "string" ) {
  41
  42                         // ( types-Object, data )
  43                         data = data || selector;
  44                         selector = undefined;
  45                 }
  46                 for ( type in types ) {
  47                         on( elem, type, selector, data, types[ type ], one );
  48                 }
  49                 return elem;
  50         }
  51
  52         if ( data == null && fn == null ) {
  53
  54                 // ( types, fn )
  55                 fn = selector;
  56                 data = selector = undefined;
  57         } else if ( fn == null ) {
  58                 if ( typeof selector === "string" ) {
  59
  60                         // ( types, selector, fn )
  61                         fn = data;
  62                         data = undefined;
  63                 } else {
  64
  65                         // ( types, data, fn )
  66                         fn = data;
  67                         data = selector;
  68                         selector = undefined;
  69                 }
  70         }
  71         if ( fn === false ) {
  72                 fn = returnFalse;
  73         } else if ( !fn ) {
  74                 return elem;
  75         }
  76
  77         if ( one === 1 ) {
  78                 origFn = fn;
  79                 fn = function( event ) {
  80
  81                         // Can use an empty set, since event contains the info
  82                         jQuery().off( event );
  83                         return origFn.apply( this, arguments );
  84                 };
  85
  86                 // Use same guid so caller can remove using origFn
  87                 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
  88         }
  89         return elem.each( function() {
  90                 jQuery.event.add( this, types, fn, data, selector );
  91         } );
  92 }
  93
  94 /*
  95  * Helper functions for managing events -- not part of the public interface.
  96  * Props to Dean Edwards' addEvent library for many of the ideas.
  97  */
  98 jQuery.event = {
  99
 100         global: {},
 101
 102         add: function( elem, types, handler, data, selector ) {
 103
 104                 var handleObjIn, eventHandle, tmp,
 105                         events, t, handleObj,
 106                         special, handlers, type, namespaces, origType,
 107                         elemData = dataPriv.get( elem );
 108
 109                 // Don't attach events to noData or text/comment nodes (but allow plain objects)
 110                 if ( !elemData ) {
 111                         return;
 112                 }
 113
 114                 // Caller can pass in an object of custom data in lieu of the handler
 115                 if ( handler.handler ) {
 116                         handleObjIn = handler;
 117                         handler = handleObjIn.handler;
 118                         selector = handleObjIn.selector;
 119                 }
 120
 121                 // Make sure that the handler has a unique ID, used to find/remove it later
 122                 if ( !handler.guid ) {
 123                         handler.guid = jQuery.guid++;
 124                 }
 125
 126                 // Init the element's event structure and main handler, if this is the first
 127                 if ( !( events = elemData.events ) ) {
 128                         events = elemData.events = {};
 129                 }
 130                 if ( !( eventHandle = elemData.handle ) ) {
 131                         eventHandle = elemData.handle = function( e ) {
 132
 133                                 // Discard the second event of a jQuery.event.trigger() and
 134                                 // when an event is called after a page has unloaded
 135                                 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
 136                                         jQuery.event.dispatch.apply( elem, arguments ) : undefined;
 137                         };
 138                 }
 139
 140                 // Handle multiple events separated by a space
 141                 types = ( types || "" ).match( rnotwhite ) || [ "" ];
 142                 t = types.length;
 143                 while ( t-- ) {
 144                         tmp = rtypenamespace.exec( types[ t ] ) || [];
 145                         type = origType = tmp[ 1 ];
 146                         namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
 147
 148                         // There *must* be a type, no attaching namespace-only handlers
 149                         if ( !type ) {
 150                                 continue;
 151                         }
 152
 153                         // If event changes its type, use the special event handlers for the changed type
 154                         special = jQuery.event.special[ type ] || {};
 155
 156                         // If selector defined, determine special event api type, otherwise given type
 157                         type = ( selector ? special.delegateType : special.bindType ) || type;
 158
 159                         // Update special based on newly reset type
 160                         special = jQuery.event.special[ type ] || {};
 161
 162                         // handleObj is passed to all event handlers
 163                         handleObj = jQuery.extend( {
 164                                 type: type,
 165                                 origType: origType,
 166                                 data: data,
 167                                 handler: handler,
 168                                 guid: handler.guid,
 169                                 selector: selector,
 170                                 needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
 171                                 namespace: namespaces.join( "." )
 172                         }, handleObjIn );
 173
 174                         // Init the event handler queue if we're the first
 175                         if ( !( handlers = events[ type ] ) ) {
 176                                 handlers = events[ type ] = [];
 177                                 handlers.delegateCount = 0;
 178
 179                                 // Only use addEventListener if the special events handler returns false
 180                                 if ( !special.setup ||
 181                                         special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
 182
 183                                         if ( elem.addEventListener ) {
 184                                                 elem.addEventListener( type, eventHandle );
 185                                         }
 186                                 }
 187                         }
 188
 189                         if ( special.add ) {
 190                                 special.add.call( elem, handleObj );
 191
 192                                 if ( !handleObj.handler.guid ) {
 193                                         handleObj.handler.guid = handler.guid;
 194                                 }
 195                         }
 196
 197                         // Add to the element's handler list, delegates in front
 198                         if ( selector ) {
 199                                 handlers.splice( handlers.delegateCount++, 0, handleObj );
 200                         } else {
 201                                 handlers.push( handleObj );
 202                         }
 203
 204                         // Keep track of which events have ever been used, for event optimization
 205                         jQuery.event.global[ type ] = true;
 206                 }
 207
 208         },
 209
 210         // Detach an event or set of events from an element
 211         remove: function( elem, types, handler, selector, mappedTypes ) {
 212
 213                 var j, origCount, tmp,
 214                         events, t, handleObj,
 215                         special, handlers, type, namespaces, origType,
 216                         elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
 217
 218                 if ( !elemData || !( events = elemData.events ) ) {
 219                         return;
 220                 }
 221
 222                 // Once for each type.namespace in types; type may be omitted
 223                 types = ( types || "" ).match( rnotwhite ) || [ "" ];
 224                 t = types.length;
 225                 while ( t-- ) {
 226                         tmp = rtypenamespace.exec( types[ t ] ) || [];
 227                         type = origType = tmp[ 1 ];
 228                         namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
 229
 230                         // Unbind all events (on this namespace, if provided) for the element
 231                         if ( !type ) {
 232                                 for ( type in events ) {
 233                                         jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
 234                                 }
 235                                 continue;
 236                         }
 237
 238                         special = jQuery.event.special[ type ] || {};
 239                         type = ( selector ? special.delegateType : special.bindType ) || type;
 240                         handlers = events[ type ] || [];
 241                         tmp = tmp[ 2 ] &&
 242                                 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
 243
 244                         // Remove matching events
 245                         origCount = j = handlers.length;
 246                         while ( j-- ) {
 247                                 handleObj = handlers[ j ];
 248
 249                                 if ( ( mappedTypes || origType === handleObj.origType ) &&
 250                                         ( !handler || handler.guid === handleObj.guid ) &&
 251                                         ( !tmp || tmp.test( handleObj.namespace ) ) &&
 252                                         ( !selector || selector === handleObj.selector ||
 253                                                 selector === "**" && handleObj.selector ) ) {
 254                                         handlers.splice( j, 1 );
 255
 256                                         if ( handleObj.selector ) {
 257                                                 handlers.delegateCount--;
 258                                         }
 259                                         if ( special.remove ) {
 260                                                 special.remove.call( elem, handleObj );
 261                                         }
 262                                 }
 263                         }
 264
 265                         // Remove generic event handler if we removed something and no more handlers exist
 266                         // (avoids potential for endless recursion during removal of special event handlers)
 267                         if ( origCount && !handlers.length ) {
 268                                 if ( !special.teardown ||
 269                                         special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
 270
 271                                         jQuery.removeEvent( elem, type, elemData.handle );
 272                                 }
 273
 274                                 delete events[ type ];
 275                         }
 276                 }
 277
 278                 // Remove data and the expando if it's no longer used
 279                 if ( jQuery.isEmptyObject( events ) ) {
 280                         dataPriv.remove( elem, "handle events" );
 281                 }
 282         },
 283
 284         dispatch: function( event ) {
 285
 286                 // Make a writable jQuery.Event from the native event object
 287                 event = jQuery.event.fix( event );
 288
 289                 var i, j, ret, matched, handleObj,
 290                         handlerQueue = [],
 291                         args = slice.call( arguments ),
 292                         handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
 293                         special = jQuery.event.special[ event.type ] || {};
 294
 295                 // Use the fix-ed jQuery.Event rather than the (read-only) native event
 296                 args[ 0 ] = event;
 297                 event.delegateTarget = this;
 298
 299                 // Call the preDispatch hook for the mapped type, and let it bail if desired
 300                 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
 301                         return;
 302                 }
 303
 304                 // Determine handlers
 305                 handlerQueue = jQuery.event.handlers.call( this, event, handlers );
 306
 307                 // Run delegates first; they may want to stop propagation beneath us
 308                 i = 0;
 309                 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
 310                         event.currentTarget = matched.elem;
 311
 312                         j = 0;
 313                         while ( ( handleObj = matched.handlers[ j++ ] ) &&
 314                                 !event.isImmediatePropagationStopped() ) {
 315
 316                                 // Triggered event must either 1) have no namespace, or 2) have namespace(s)
 317                                 // a subset or equal to those in the bound event (both can have no namespace).
 318                                 if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
 319
 320                                         event.handleObj = handleObj;
 321                                         event.data = handleObj.data;
 322
 323                                         ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
 324                                                 handleObj.handler ).apply( matched.elem, args );
 325
 326                                         if ( ret !== undefined ) {
 327                                                 if ( ( event.result = ret ) === false ) {
 328                                                         event.preventDefault();
 329                                                         event.stopPropagation();
 330                                                 }
 331                                         }
 332                                 }
 333                         }
 334                 }
 335
 336                 // Call the postDispatch hook for the mapped type
 337                 if ( special.postDispatch ) {
 338                         special.postDispatch.call( this, event );
 339                 }
 340
 341                 return event.result;
 342         },
 343
 344         handlers: function( event, handlers ) {
 345                 var i, matches, sel, handleObj,
 346                         handlerQueue = [],
 347                         delegateCount = handlers.delegateCount,
 348                         cur = event.target;
 349
 350                 // Support (at least): Chrome, IE9
 351                 // Find delegate handlers
 352                 // Black-hole SVG <use> instance trees (#13180)
 353                 //
 354                 // Support: Firefox<=42+
 355                 // Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
 356                 if ( delegateCount && cur.nodeType &&
 357                         ( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
 358
 359                         for ( ; cur !== this; cur = cur.parentNode || this ) {
 360
 361                                 // Don't check non-elements (#13208)
 362                                 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
 363                                 if ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== "click" ) ) {
 364                                         matches = [];
 365                                         for ( i = 0; i < delegateCount; i++ ) {
 366                                                 handleObj = handlers[ i ];
 367
 368                                                 // Don't conflict with Object.prototype properties (#13203)
 369                                                 sel = handleObj.selector + " ";
 370
 371                                                 if ( matches[ sel ] === undefined ) {
 372                                                         matches[ sel ] = handleObj.needsContext ?
 373                                                                 jQuery( sel, this ).index( cur ) > -1 :
 374                                                                 jQuery.find( sel, this, null, [ cur ] ).length;
 375                                                 }
 376                                                 if ( matches[ sel ] ) {
 377                                                         matches.push( handleObj );
 378                                                 }
 379                                         }
 380                                         if ( matches.length ) {
 381                                                 handlerQueue.push( { elem: cur, handlers: matches } );
 382                                         }
 383                                 }
 384                         }
 385                 }
 386
 387                 // Add the remaining (directly-bound) handlers
 388                 if ( delegateCount < handlers.length ) {
 389                         handlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );
 390                 }
 391
 392                 return handlerQueue;
 393         },
 394
 395         // Includes some event props shared by KeyEvent and MouseEvent
 396         props: ( "altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " +
 397                 "metaKey relatedTarget shiftKey target timeStamp view which" ).split( " " ),
 398
 399         fixHooks: {},
 400
 401         keyHooks: {
 402                 props: "char charCode key keyCode".split( " " ),
 403                 filter: function( event, original ) {
 404
 405                         // Add which for key events
 406                         if ( event.which == null ) {
 407                                 event.which = original.charCode != null ? original.charCode : original.keyCode;
 408                         }
 409
 410                         return event;
 411                 }
 412         },
 413
 414         mouseHooks: {
 415                 props: ( "button buttons clientX clientY offsetX offsetY pageX pageY " +
 416                         "screenX screenY toElement" ).split( " " ),
 417                 filter: function( event, original ) {
 418                         var eventDoc, doc, body,
 419                                 button = original.button;
 420
 421                         // Calculate pageX/Y if missing and clientX/Y available
 422                         if ( event.pageX == null && original.clientX != null ) {
 423                                 eventDoc = event.target.ownerDocument || document;
 424                                 doc = eventDoc.documentElement;
 425                                 body = eventDoc.body;
 426
 427                                 event.pageX = original.clientX +
 428                                         ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
 429                                         ( doc && doc.clientLeft || body && body.clientLeft || 0 );
 430                                 event.pageY = original.clientY +
 431                                         ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) -
 432                                         ( doc && doc.clientTop  || body && body.clientTop  || 0 );
 433                         }
 434
 435                         // Add which for click: 1 === left; 2 === middle; 3 === right
 436                         // Note: button is not normalized, so don't use it
 437                         if ( !event.which && button !== undefined ) {
 438                                 event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
 439                         }
 440
 441                         return event;
 442                 }
 443         },
 444
 445         fix: function( event ) {
 446                 if ( event[ jQuery.expando ] ) {
 447                         return event;
 448                 }
 449
 450                 // Create a writable copy of the event object and normalize some properties
 451                 var i, prop, copy,
 452                         type = event.type,
 453                         originalEvent = event,
 454                         fixHook = this.fixHooks[ type ];
 455
 456                 if ( !fixHook ) {
 457                         this.fixHooks[ type ] = fixHook =
 458                                 rmouseEvent.test( type ) ? this.mouseHooks :
 459                                 rkeyEvent.test( type ) ? this.keyHooks :
 460                                 {};
 461                 }
 462                 copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
 463
 464                 event = new jQuery.Event( originalEvent );
 465
 466                 i = copy.length;
 467                 while ( i-- ) {
 468                         prop = copy[ i ];
 469                         event[ prop ] = originalEvent[ prop ];
 470                 }
 471
 472                 // Support: Cordova 2.5 (WebKit) (#13255)
 473                 // All events should have a target; Cordova deviceready doesn't
 474                 if ( !event.target ) {
 475                         event.target = document;
 476                 }
 477
 478                 // Support: Safari 6.0+, Chrome<28
 479                 // Target should not be a text node (#504, #13143)
 480                 if ( event.target.nodeType === 3 ) {
 481                         event.target = event.target.parentNode;
 482                 }
 483
 484                 return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
 485         },
 486
 487         special: {
 488                 load: {
 489
 490                         // Prevent triggered image.load events from bubbling to window.load
 491                         noBubble: true
 492                 },
 493                 focus: {
 494
 495                         // Fire native event if possible so blur/focus sequence is correct
 496                         trigger: function() {
 497                                 if ( this !== safeActiveElement() && this.focus ) {
 498                                         this.focus();
 499                                         return false;
 500                                 }
 501                         },
 502                         delegateType: "focusin"
 503                 },
 504                 blur: {
 505                         trigger: function() {
 506                                 if ( this === safeActiveElement() && this.blur ) {
 507                                         this.blur();
 508                                         return false;
 509                                 }
 510                         },
 511                         delegateType: "focusout"
 512                 },
 513                 click: {
 514
 515                         // For checkbox, fire native event so checked state will be right
 516                         trigger: function() {
 517                                 if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
 518                                         this.click();
 519                                         return false;
 520                                 }
 521                         },
 522
 523                         // For cross-browser consistency, don't fire native .click() on links
 524                         _default: function( event ) {
 525                                 return jQuery.nodeName( event.target, "a" );
 526                         }
 527                 },
 528
 529                 beforeunload: {
 530                         postDispatch: function( event ) {
 531
 532                                 // Support: Firefox 20+
 533                                 // Firefox doesn't alert if the returnValue field is not set.
 534                                 if ( event.result !== undefined && event.originalEvent ) {
 535                                         event.originalEvent.returnValue = event.result;
 536                                 }
 537                         }
 538                 }
 539         }
 540 };
 541
 542 jQuery.removeEvent = function( elem, type, handle ) {
 543
 544         // This "if" is needed for plain objects
 545         if ( elem.removeEventListener ) {
 546                 elem.removeEventListener( type, handle );
 547         }
 548 };
 549
 550 jQuery.Event = function( src, props ) {
 551
 552         // Allow instantiation without the 'new' keyword
 553         if ( !( this instanceof jQuery.Event ) ) {
 554                 return new jQuery.Event( src, props );
 555         }
 556
 557         // Event object
 558         if ( src && src.type ) {
 559                 this.originalEvent = src;
 560                 this.type = src.type;
 561
 562                 // Events bubbling up the document may have been marked as prevented
 563                 // by a handler lower down the tree; reflect the correct value.
 564                 this.isDefaultPrevented = src.defaultPrevented ||
 565                                 src.defaultPrevented === undefined &&
 566
 567                                 // Support: Android<4.0
 568                                 src.returnValue === false ?
 569                         returnTrue :
 570                         returnFalse;
 571
 572         // Event type
 573         } else {
 574                 this.type = src;
 575         }
 576
 577         // Put explicitly provided properties onto the event object
 578         if ( props ) {
 579                 jQuery.extend( this, props );
 580         }
 581
 582         // Create a timestamp if incoming event doesn't have one
 583         this.timeStamp = src && src.timeStamp || jQuery.now();
 584
 585         // Mark it as fixed
 586         this[ jQuery.expando ] = true;
 587 };
 588
 589 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
 590 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
 591 jQuery.Event.prototype = {
 592         constructor: jQuery.Event,
 593         isDefaultPrevented: returnFalse,
 594         isPropagationStopped: returnFalse,
 595         isImmediatePropagationStopped: returnFalse,
 596         isSimulated: false,
 597
 598         preventDefault: function() {
 599                 var e = this.originalEvent;
 600
 601                 this.isDefaultPrevented = returnTrue;
 602
 603                 if ( e && !this.isSimulated ) {
 604                         e.preventDefault();
 605                 }
 606         },
 607         stopPropagation: function() {
 608                 var e = this.originalEvent;
 609
 610                 this.isPropagationStopped = returnTrue;
 611
 612                 if ( e && !this.isSimulated ) {
 613                         e.stopPropagation();
 614                 }
 615         },
 616         stopImmediatePropagation: function() {
 617                 var e = this.originalEvent;
 618
 619                 this.isImmediatePropagationStopped = returnTrue;
 620
 621                 if ( e && !this.isSimulated ) {
 622                         e.stopImmediatePropagation();
 623                 }
 624
 625                 this.stopPropagation();
 626         }
 627 };
 628
 629 // Create mouseenter/leave events using mouseover/out and event-time checks
 630 // so that event delegation works in jQuery.
 631 // Do the same for pointerenter/pointerleave and pointerover/pointerout
 632 //
 633 // Support: Safari 7 only
 634 // Safari sends mouseenter too often; see:
 635 // https://code.google.com/p/chromium/issues/detail?id=470258
 636 // for the description of the bug (it existed in older Chrome versions as well).
 637 jQuery.each( {
 638         mouseenter: "mouseover",
 639         mouseleave: "mouseout",
 640         pointerenter: "pointerover",
 641         pointerleave: "pointerout"
 642 }, function( orig, fix ) {
 643         jQuery.event.special[ orig ] = {
 644                 delegateType: fix,
 645                 bindType: fix,
 646
 647                 handle: function( event ) {
 648                         var ret,
 649                                 target = this,
 650                                 related = event.relatedTarget,
 651                                 handleObj = event.handleObj;
 652
 653                         // For mouseenter/leave call the handler if related is outside the target.
 654                         // NB: No relatedTarget if the mouse left/entered the browser window
 655                         if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
 656                                 event.type = handleObj.origType;
 657                                 ret = handleObj.handler.apply( this, arguments );
 658                                 event.type = fix;
 659                         }
 660                         return ret;
 661                 }
 662         };
 663 } );
 664
 665 jQuery.fn.extend( {
 666         on: function( types, selector, data, fn ) {
 667                 return on( this, types, selector, data, fn );
 668         },
 669         one: function( types, selector, data, fn ) {
 670                 return on( this, types, selector, data, fn, 1 );
 671         },
 672         off: function( types, selector, fn ) {
 673                 var handleObj, type;
 674                 if ( types && types.preventDefault && types.handleObj ) {
 675
 676                         // ( event )  dispatched jQuery.Event
 677                         handleObj = types.handleObj;
 678                         jQuery( types.delegateTarget ).off(
 679                                 handleObj.namespace ?
 680                                         handleObj.origType + "." + handleObj.namespace :
 681                                         handleObj.origType,
 682                                 handleObj.selector,
 683                                 handleObj.handler
 684                         );
 685                         return this;
 686                 }
 687                 if ( typeof types === "object" ) {
 688
 689                         // ( types-object [, selector] )
 690                         for ( type in types ) {
 691                                 this.off( type, selector, types[ type ] );
 692                         }
 693                         return this;
 694                 }
 695                 if ( selector === false || typeof selector === "function" ) {
 696
 697                         // ( types [, fn] )
 698                         fn = selector;
 699                         selector = undefined;
 700                 }
 701                 if ( fn === false ) {
 702                         fn = returnFalse;
 703                 }
 704                 return this.each( function() {
 705                         jQuery.event.remove( this, types, fn, selector );
 706                 } );
 707         }
 708 } );
 709
 710 return jQuery;
 711 } );