tools/side_chain_tool/web/node_modules/jquery/src/event.js

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