07-event.js

var rnamespaces = /\.(.*)$/,
  rformElems = /^(?:textarea|input|select)$/i,
  rperiod = /\./g,
  rspaces = / /g,
  rescape = /[^\w\s.|`]/g,
  fcleanup = function( nm ) {
    return nm.replace(rescape, "\\$&");
  };

jQuery.event = {

  add: function( elem, types, handler, data ) {
    if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
      return;
    }

    if ( handler === false ) {
      handler = returnFalse;
    } else if ( !handler ) {

      return;
    }

    var handleObjIn, handleObj;

    if ( handler.handler ) {
      handleObjIn = handler;
      handler = handleObjIn.handler;
    }

    if ( !handler.guid ) {
      handler.guid = jQuery.guid++;
    }

    var elemData = jQuery._data( elem );

    if ( !elemData ) {
      return;
    }

    var events = elemData.events,
      eventHandle = elemData.handle;

    if ( !events ) {
      elemData.events = events = {};
    }

    if ( !eventHandle ) {
      elemData.handle = eventHandle = function( e ) {

        return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
          jQuery.event.handle.apply( eventHandle.elem, arguments ) :
          undefined;
      };
    }

    eventHandle.elem = elem;

    types = types.split(" ");

    var type, i = 0, namespaces;

    while ( (type = types[ i++ ]) ) {
      handleObj = handleObjIn ?
        jQuery.extend({}, handleObjIn) :
        { handler: handler, data: data };

      if ( type.indexOf(".") > -1 ) {
        namespaces = type.split(".");
        type = namespaces.shift();
        handleObj.namespace = namespaces.slice(0).sort().join(".");

      } else {
        namespaces = [];
        handleObj.namespace = "";
      }

      handleObj.type = type;
      if ( !handleObj.guid ) {
        handleObj.guid = handler.guid;
      }

      var handlers = events[ type ],
        special = jQuery.event.special[ type ] || {};

      if ( !handlers ) {
        handlers = events[ type ] = [];

        if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {

          if ( elem.addEventListener ) {
            elem.addEventListener( type, eventHandle, false );

          } else if ( elem.attachEvent ) {
            elem.attachEvent( "on" + type, eventHandle );
          }
        }
      }

      if ( special.add ) {
        special.add.call( elem, handleObj );

        if ( !handleObj.handler.guid ) {
          handleObj.handler.guid = handler.guid;
        }
      }

      handlers.push( handleObj );

      jQuery.event.global[ type ] = true;
    }

    elem = null;
  },

  global: {},

  remove: function( elem, types, handler, pos ) {

    if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
      return;
    }

    if ( handler === false ) {
      handler = returnFalse;
    }

    var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
      elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
      events = elemData && elemData.events;

    if ( !elemData || !events ) {
      return;
    }

    if ( types && types.type ) {
      handler = types.handler;
      types = types.type;
    }

    if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
      types = types || "";

      for ( type in events ) {
        jQuery.event.remove( elem, type + types );
      }

      return;
    }

    types = types.split(" ");

    while ( (type = types[ i++ ]) ) {
      origType = type;
      handleObj = null;
      all = type.indexOf(".") < 0;
      namespaces = [];

      if ( !all ) {

        namespaces = type.split(".");
        type = namespaces.shift();

        namespace = new RegExp("(^|\\.)" +
          jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
      }

      eventType = events[ type ];

      if ( !eventType ) {
        continue;
      }

      if ( !handler ) {
        for ( j = 0; j < eventType.length; j++ ) {
          handleObj = eventType[ j ];

          if ( all || namespace.test( handleObj.namespace ) ) {
            jQuery.event.remove( elem, origType, handleObj.handler, j );
            eventType.splice( j--, 1 );
          }
        }

        continue;
      }

      special = jQuery.event.special[ type ] || {};

      for ( j = pos || 0; j < eventType.length; j++ ) {
        handleObj = eventType[ j ];

        if ( handler.guid === handleObj.guid ) {

          if ( all || namespace.test( handleObj.namespace ) ) {
            if ( pos == null ) {
              eventType.splice( j--, 1 );
            }

            if ( special.remove ) {
              special.remove.call( elem, handleObj );
            }
          }

          if ( pos != null ) {
            break;
          }
        }
      }

      if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
        if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
          jQuery.removeEvent( elem, type, elemData.handle );
        }

        ret = null;
        delete events[ type ];
      }
    }

    if ( jQuery.isEmptyObject( events ) ) {
      var handle = elemData.handle;
      if ( handle ) {
        handle.elem = null;
      }

      delete elemData.events;
      delete elemData.handle;

      if ( jQuery.isEmptyObject( elemData ) ) {
        jQuery.removeData( elem, undefined, true );
      }
    }
  },
  

  customEvent: {
    "getData": true,
    "setData": true,
    "changeData": true
  },

  trigger: function( event, data, elem, onlyHandlers ) {

    var type = event.type || event,
      namespaces = [],
      exclusive;

    if ( type.indexOf("!") >= 0 ) {

      type = type.slice(0, -1);
      exclusive = true;
    }

    if ( type.indexOf(".") >= 0 ) {

      namespaces = type.split(".");
      type = namespaces.shift();
      namespaces.sort();
    }

    if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {

      return;
    }

    event = typeof event === "object" ?

      event[ jQuery.expando ] ? event :

      new jQuery.Event( type, event ) :

      new jQuery.Event( type );

    event.type = type;
    event.exclusive = exclusive;
    event.namespace = namespaces.join(".");
    event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
    

    if ( onlyHandlers || !elem ) {
      event.preventDefault();
      event.stopPropagation();
    }

    if ( !elem ) {

      jQuery.each( jQuery.cache, function() {

        var internalKey = jQuery.expando,
          internalCache = this[ internalKey ];
        if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
          jQuery.event.trigger( event, data, internalCache.handle.elem );
        }
      });
      return;
    }

    if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
      return;
    }

    event.result = undefined;
    event.target = elem;

    data = data != null ? jQuery.makeArray( data ) : [];
    data.unshift( event );

    var cur = elem,

      ontype = type.indexOf(":") < 0 ? "on" + type : "";

    do {
      var handle = jQuery._data( cur, "handle" );

      event.currentTarget = cur;
      if ( handle ) {
        handle.apply( cur, data );
      }

      if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
        event.result = false;
        event.preventDefault();
      }

      cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
    } while ( cur && !event.isPropagationStopped() );

    if ( !event.isDefaultPrevented() ) {
      var old,
        special = jQuery.event.special[ type ] || {};

      if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
        !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {

        try {
          if ( ontype && elem[ type ] ) {

            old = elem[ ontype ];

            if ( old ) {
              elem[ ontype ] = null;
            }

            jQuery.event.triggered = type;
            elem[ type ]();
          }
        } catch ( ieError ) {}

        if ( old ) {
          elem[ ontype ] = old;
        }

        jQuery.event.triggered = undefined;
      }
    }
    
    return event.result;
  },

  handle: function( event ) {
    event = jQuery.event.fix( event || window.event );

    var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
      run_all = !event.exclusive && !event.namespace,
      args = Array.prototype.slice.call( arguments, 0 );

    args[0] = event;
    event.currentTarget = this;

    for ( var j = 0, l = handlers.length; j < l; j++ ) {
      var handleObj = handlers[ j ];

      if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {

        event.handler = handleObj.handler;
        event.data = handleObj.data;
        event.handleObj = handleObj;

        var ret = handleObj.handler.apply( this, args );

        if ( ret !== undefined ) {
          event.result = ret;
          if ( ret === false ) {
            event.preventDefault();
            event.stopPropagation();
          }
        }

        if ( event.isImmediatePropagationStopped() ) {
          break;
        }
      }
    }
    return event.result;
  },

  props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),

  fix: function( event ) {
    if ( event[ jQuery.expando ] ) {
      return event;
    }

    var originalEvent = event;
    event = jQuery.Event( originalEvent );

    for ( var i = this.props.length, prop; i; ) {
      prop = this.props[ --i ];
      event[ prop ] = originalEvent[ prop ];
    }

    if ( !event.target ) {

      event.target = event.srcElement || document;
    }

    if ( event.target.nodeType === 3 ) {
      event.target = event.target.parentNode;
    }

    if ( !event.relatedTarget && event.fromElement ) {
      event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
    }

    if ( event.pageX == null && event.clientX != null ) {
      var eventDocument = event.target.ownerDocument || document,
        doc = eventDocument.documentElement,
        body = eventDocument.body;

      event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
      event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
    }

    if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
      event.which = event.charCode != null ? event.charCode : event.keyCode;
    }

    if ( !event.metaKey && event.ctrlKey ) {
      event.metaKey = event.ctrlKey;
    }

    if ( !event.which && event.button !== undefined ) {
      event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
    }

    return event;
  },

  guid: 1E8,

  proxy: jQuery.proxy,

  special: {
    ready: {

      setup: jQuery.bindReady,
      teardown: jQuery.noop
    },

    live: {
      add: function( handleObj ) {
        jQuery.event.add( this,
          liveConvert( handleObj.origType, handleObj.selector ),
          jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
      },

      remove: function( handleObj ) {
        jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
      }
    },

    beforeunload: {
      setup: function( data, namespaces, eventHandle ) {

        if ( jQuery.isWindow( this ) ) {
          this.onbeforeunload = eventHandle;
        }
      },

      teardown: function( namespaces, eventHandle ) {
        if ( this.onbeforeunload === eventHandle ) {
          this.onbeforeunload = null;
        }
      }
    }
  }
};

jQuery.removeEvent = document.removeEventListener ?
  function( elem, type, handle ) {
    if ( elem.removeEventListener ) {
      elem.removeEventListener( type, handle, false );
    }
  } :
  function( elem, type, handle ) {
    if ( elem.detachEvent ) {
      elem.detachEvent( "on" + type, handle );
    }
  };

jQuery.Event = function( src, props ) {

  if ( !this.preventDefault ) {
    return new jQuery.Event( src, props );
  }

  if ( src && src.type ) {
    this.originalEvent = src;
    this.type = src.type;

    this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
      src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;

  } else {
    this.type = src;
  }

  if ( props ) {
    jQuery.extend( this, props );
  }

  this.timeStamp = jQuery.now();

  this[ jQuery.expando ] = true;
};

function returnFalse() {
  return false;
}
function returnTrue() {
  return true;
}

jQuery.Event.prototype = {
  preventDefault: function() {
    this.isDefaultPrevented = returnTrue;

    var e = this.originalEvent;
    if ( !e ) {
      return;
    }

    if ( e.preventDefault ) {
      e.preventDefault();

    } else {
      e.returnValue = false;
    }
  },
  stopPropagation: function() {
    this.isPropagationStopped = returnTrue;

    var e = this.originalEvent;
    if ( !e ) {
      return;
    }

    if ( e.stopPropagation ) {
      e.stopPropagation();
    }

    e.cancelBubble = true;
  },
  stopImmediatePropagation: function() {
    this.isImmediatePropagationStopped = returnTrue;
    this.stopPropagation();
  },
  isDefaultPrevented: returnFalse,
  isPropagationStopped: returnFalse,
  isImmediatePropagationStopped: returnFalse
};

var withinElement = function( event ) {

  var related = event.relatedTarget,
    inside = false,
    eventType = event.type;

  event.type = event.data;

  if ( related !== this ) {

    if ( related ) {
      inside = jQuery.contains( this, related );
    }

    if ( !inside ) {

      jQuery.event.handle.apply( this, arguments );

      event.type = eventType;
    }
  }
},

delegate = function( event ) {
  event.type = event.data;
  jQuery.event.handle.apply( this, arguments );
};

jQuery.each({
  mouseenter: "mouseover",
  mouseleave: "mouseout"
}, function( orig, fix ) {
  jQuery.event.special[ orig ] = {
    setup: function( data ) {
      jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
    },
    teardown: function( data ) {
      jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
    }
  };
});

if ( !jQuery.support.submitBubbles ) {

  jQuery.event.special.submit = {
    setup: function( data, namespaces ) {
      if ( !jQuery.nodeName( this, "form" ) ) {
        jQuery.event.add(this, "click.specialSubmit", function( e ) {
          var elem = e.target,
            type = elem.type;

          if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
            trigger( "submit", this, arguments );
          }
        });

        jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
          var elem = e.target,
            type = elem.type;

          if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
            trigger( "submit", this, arguments );
          }
        });

      } else {
        return false;
      }
    },

    teardown: function( namespaces ) {
      jQuery.event.remove( this, ".specialSubmit" );
    }
  };

}

if ( !jQuery.support.changeBubbles ) {

  var changeFilters,

  getVal = function( elem ) {
    var type = elem.type, val = elem.value;

    if ( type === "radio" || type === "checkbox" ) {
      val = elem.checked;

    } else if ( type === "select-multiple" ) {
      val = elem.selectedIndex > -1 ?
        jQuery.map( elem.options, function( elem ) {
          return elem.selected;
        }).join("-") :
        "";

    } else if ( jQuery.nodeName( elem, "select" ) ) {
      val = elem.selectedIndex;
    }

    return val;
  },

  testChange = function testChange( e ) {
    var elem = e.target, data, val;

    if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
      return;
    }

    data = jQuery._data( elem, "_change_data" );
    val = getVal(elem);

    if ( e.type !== "focusout" || elem.type !== "radio" ) {
      jQuery._data( elem, "_change_data", val );
    }

    if ( data === undefined || val === data ) {
      return;
    }

    if ( data != null || val ) {
      e.type = "change";
      e.liveFired = undefined;
      jQuery.event.trigger( e, arguments[1], elem );
    }
  };

  jQuery.event.special.change = {
    filters: {
      focusout: testChange,

      beforedeactivate: testChange,

      click: function( e ) {
        var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";

        if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
          testChange.call( this, e );
        }
      },

      keydown: function( e ) {
        var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";

        if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
          (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
          type === "select-multiple" ) {
          testChange.call( this, e );
        }
      },

      beforeactivate: function( e ) {
        var elem = e.target;
        jQuery._data( elem, "_change_data", getVal(elem) );
      }
    },

    setup: function( data, namespaces ) {
      if ( this.type === "file" ) {
        return false;
      }

      for ( var type in changeFilters ) {
        jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
      }

      return rformElems.test( this.nodeName );
    },

    teardown: function( namespaces ) {
      jQuery.event.remove( this, ".specialChange" );

      return rformElems.test( this.nodeName );
    }
  };

  changeFilters = jQuery.event.special.change.filters;

  changeFilters.focus = changeFilters.beforeactivate;
}

function trigger( type, elem, args ) {

  var event = jQuery.extend( {}, args[ 0 ] );
  event.type = type;
  event.originalEvent = {};
  event.liveFired = undefined;
  jQuery.event.handle.call( elem, event );
  if ( event.isDefaultPrevented() ) {
    args[ 0 ].preventDefault();
  }
}

if ( !jQuery.support.focusinBubbles ) {
  jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {

    var attaches = 0;

    jQuery.event.special[ fix ] = {
      setup: function() {
        if ( attaches++ === 0 ) {
          document.addEventListener( orig, handler, true );
        }
      },
      teardown: function() {
        if ( --attaches === 0 ) {
          document.removeEventListener( orig, handler, true );
        }
      }
    };

    function handler( donor ) {

      var e = jQuery.event.fix( donor );
      e.type = fix;
      e.originalEvent = {};
      jQuery.event.trigger( e, null, e.target );
      if ( e.isDefaultPrevented() ) {
        donor.preventDefault();
      }
    }
  });
}

jQuery.each(["bind", "one"], function( i, name ) {
  jQuery.fn[ name ] = function( type, data, fn ) {
    var handler;

    if ( typeof type === "object" ) {
      for ( var key in type ) {
        this[ name ](key, data, type[key], fn);
      }
      return this;
    }

    if ( arguments.length === 2 || data === false ) {
      fn = data;
      data = undefined;
    }

    if ( name === "one" ) {
      handler = function( event ) {
        jQuery( this ).unbind( event, handler );
        return fn.apply( this, arguments );
      };
      handler.guid = fn.guid || jQuery.guid++;
    } else {
      handler = fn;
    }

    if ( type === "unload" && name !== "one" ) {
      this.one( type, data, fn );

    } else {
      for ( var i = 0, l = this.length; i < l; i++ ) {
        jQuery.event.add( this[i], type, handler, data );
      }
    }

    return this;
  };
});

jQuery.fn.extend({
  unbind: function( type, fn ) {

    if ( typeof type === "object" && !type.preventDefault ) {
      for ( var key in type ) {
        this.unbind(key, type[key]);
      }

    } else {
      for ( var i = 0, l = this.length; i < l; i++ ) {
        jQuery.event.remove( this[i], type, fn );
      }
    }

    return this;
  },

  delegate: function( selector, types, data, fn ) {
    return this.live( types, data, fn, selector );
  },

  undelegate: function( selector, types, fn ) {
    if ( arguments.length === 0 ) {
      return this.unbind( "live" );

    } else {
      return this.die( types, null, fn, selector );
    }
  },

  trigger: function( type, data ) {
    return this.each(function() {
      jQuery.event.trigger( type, data, this );
    });
  },

  triggerHandler: function( type, data ) {
    if ( this[0] ) {
      return jQuery.event.trigger( type, data, this[0], true );
    }
  },

  toggle: function( fn ) {

    var args = arguments,
      guid = fn.guid || jQuery.guid++,
      i = 0,
      toggler = function( event ) {

        var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
        jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );

        event.preventDefault();

        return args[ lastToggle ].apply( this, arguments ) || false;
      };

    toggler.guid = guid;
    while ( i < args.length ) {
      args[ i++ ].guid = guid;
    }

    return this.click( toggler );
  },

  hover: function( fnOver, fnOut ) {
    return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
  }
});

var liveMap = {
  focus: "focusin",
  blur: "focusout",
  mouseenter: "mouseover",
  mouseleave: "mouseout"
};

jQuery.each(["live", "die"], function( i, name ) {
  jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
    var type, i = 0, match, namespaces, preType,
      selector = origSelector || this.selector,
      context = origSelector ? this : jQuery( this.context );

    if ( typeof types === "object" && !types.preventDefault ) {
      for ( var key in types ) {
        context[ name ]( key, data, types[key], selector );
      }

      return this;
    }

    if ( name === "die" && !types &&
          origSelector && origSelector.charAt(0) === "." ) {

      context.unbind( origSelector );

      return this;
    }

    if ( data === false || jQuery.isFunction( data ) ) {
      fn = data || returnFalse;
      data = undefined;
    }

    types = (types || "").split(" ");

    while ( (type = types[ i++ ]) != null ) {
      match = rnamespaces.exec( type );
      namespaces = "";

      if ( match )  {
        namespaces = match[0];
        type = type.replace( rnamespaces, "" );
      }

      if ( type === "hover" ) {
        types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
        continue;
      }

      preType = type;

      if ( liveMap[ type ] ) {
        types.push( liveMap[ type ] + namespaces );
        type = type + namespaces;

      } else {
        type = (liveMap[ type ] || type) + namespaces;
      }

      if ( name === "live" ) {

        for ( var j = 0, l = context.length; j < l; j++ ) {
          jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
            { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
        }

      } else {

        context.unbind( "live." + liveConvert( type, selector ), fn );
      }
    }

    return this;
  };
});

function liveHandler( event ) {
  var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
    elems = [],
    selectors = [],
    events = jQuery._data( this, "events" );

  if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
    return;
  }

  if ( event.namespace ) {
    namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
  }

  event.liveFired = this;

  var live = events.live.slice(0);

  for ( j = 0; j < live.length; j++ ) {
    handleObj = live[j];

    if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
      selectors.push( handleObj.selector );

    } else {
      live.splice( j--, 1 );
    }
  }

  match = jQuery( event.target ).closest( selectors, event.currentTarget );

  for ( i = 0, l = match.length; i < l; i++ ) {
    close = match[i];

    for ( j = 0; j < live.length; j++ ) {
      handleObj = live[j];

      if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
        elem = close.elem;
        related = null;

        if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
          event.type = handleObj.preType;
          related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];

          if ( related && jQuery.contains( elem, related ) ) {
            related = elem;
          }
        }

        if ( !related || related !== elem ) {
          elems.push({ elem: elem, handleObj: handleObj, level: close.level });
        }
      }
    }
  }

  for ( i = 0, l = elems.length; i < l; i++ ) {
    match = elems[i];

    if ( maxLevel && match.level > maxLevel ) {
      break;
    }

    event.currentTarget = match.elem;
    event.data = match.handleObj.data;
    event.handleObj = match.handleObj;

    ret = match.handleObj.origHandler.apply( match.elem, arguments );

    if ( ret === false || event.isPropagationStopped() ) {
      maxLevel = match.level;

      if ( ret === false ) {
        stop = false;
      }
      if ( event.isImmediatePropagationStopped() ) {
        break;
      }
    }
  }

  return stop;
}

function liveConvert( type, selector ) {
  return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
}

jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
  "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
  "change select submit keydown keypress keyup error").split(" "), function( i, name ) {

  jQuery.fn[ name ] = function( data, fn ) {
    if ( fn == null ) {
      fn = data;
      data = null;
    }

    return arguments.length > 0 ?
      this.bind( name, data, fn ) :
      this.trigger( name );
  };

  if ( jQuery.attrFn ) {
    jQuery.attrFn[ name ] = true;
  }
});