gistfile1.js

// Fixed for prototype extend issue
function hackjQuery(jQuery){
    if(jQuery.fn.jquery == '1.3.2'){
        jQuery.event.handle = function(event) {
            // returned undefined or false
            var all, handlers;

            event = arguments[0] = jQuery.event.fix( event || window.event );
            event.currentTarget = this;

            // Namespaced event handlers
            var namespaces = event.type.split(".");
            event.type = namespaces.shift();

            // Cache this now, all = true means, any handler
            all = !namespaces.length && !event.exclusive;

            var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");

            handlers = ( jQuery.data(this, "events") || {} )[event.type];

            for ( var j in handlers ) {
                if({}[j])continue; // Fixed for prototype extend
                var handler = handlers[j];

                // Filter the functions by class
                if ( all || namespace.test(handler.type) ) {
                    // Pass in a reference to the handler function itself
                    // So that we can later remove it
                    event.handler = handler;
                    event.data = handler.data;

                    var ret = handler.apply(this, arguments);

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

                    if( event.isImmediatePropagationStopped() )
                        break;

                }
            }
        };

        // Detach an event or set of events from an element
        jQuery.event.remove= function(elem, types, handler) {
            // don't do events on text and comment nodes
            if ( elem.nodeType == 3 || elem.nodeType == 8 )
                return;

            var events = jQuery.data(elem, "events"), ret, index;

            if ( events ) {
                // Unbind all events for the element
                if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
                    for ( var type in events ){
                        if(!{}[type])this.remove( elem, type + (types || "") ); // Fixed for prototype extend
                    }
                else {
                    // types is actually an event object here
                    if ( types.type ) {
                        handler = types.handler;
                        types = types.type;
                    }

                    // Handle multiple events seperated by a space
                    // jQuery(...).unbind("mouseover mouseout", fn);
                    jQuery.each(types.split(/\s+/), function(index, type){
                        // Namespaced event handlers
                        var namespaces = type.split(".");
                        type = namespaces.shift();
                        var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");

                        if ( events[type] ) {
                            // remove the given handler for the given type
                            if ( handler )
                                delete events[type][handler.guid];

                            // remove all handlers for the given type
                            else
                                for ( var handle in events[type] )
                                    // Handle the removal of namespaced events
                                    if ( namespace.test(events[type][handle].type) )
                                        delete events[type][handle];

                            if ( jQuery.event.specialAll[type] )
                                jQuery.event.specialAll[type].teardown.call(elem, namespaces);

                            // remove generic event handler if no more handlers exist
                            for ( ret in events[type] ) break;
                            if ( !ret ) {
                                if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
                                    if (elem.removeEventListener)
                                        elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
                                    else if (elem.detachEvent)
                                        elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
                                }
                                ret = null;
                                delete events[type];
                            }
                        }
                    });
                }

                // Remove the expando if it's no longer used
                for ( ret in events ) break;
                if ( !ret ) {
                    var handle = jQuery.data( elem, "handle" );
                    if ( handle ) handle.elem = null;
                    jQuery.removeData( elem, "events" );
                    jQuery.removeData( elem, "handle" );
                }
            }
        };


        jQuery.prototype.attr = function( name, value, type ) {
            var options = name;

            // Look for the case where we're accessing a style value
            if ( typeof name === "string" )
                if ( value === undefined )
                    return this[0] && jQuery[ type || "attr" ]( this[0], name );

            else {
                options = {};
                options[ name ] = value;
            }

            // Check to see if we're setting style values
            return this.each(function(i){
                // Set all the styles
                for ( name in options )
                    if(!{}[name])jQuery.attr( // Fixed for prototype extend
                        type ?
                            this.style :
                            this,
                        name, jQuery.prop( this, options[ name ], type, i, name )
                    );
            });
        };
        
        var isXML = function(elem){
            return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
                !!elem.ownerDocument && isXML( elem.ownerDocument );
        };
        var Expr = jQuery.expr;
        jQuery.find.filter = function(expr, set, inplace, not){
            var old = expr, result = [], curLoop = set, match, anyFound,
                isXMLFilter = set && set[0] && isXML(set[0]);

            while ( expr && set.length ) {
                for ( var type in Expr.filter ) {
                    if({}[type])continue; // Fixed for prototype extend
                    
                    if ( (match = Expr.match[ type ].exec( expr )) != null ) {
                        var filter = Expr.filter[ type ], found, item;
                        anyFound = false;

                        if ( curLoop == result ) {
                            result = [];
                        }

                        if ( Expr.preFilter[ type ] ) {
                            match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );

                            if ( !match ) {
                                anyFound = found = true;
                            } else if ( match === true ) {
                                continue;
                            }
                        }

                        if ( match ) {
                            for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
                                if ( item ) {
                                    found = filter( item, match, i, curLoop );
                                    var pass = not ^ !!found;

                                    if ( inplace && found != null ) {
                                        if ( pass ) {
                                            anyFound = true;
                                        } else {
                                            curLoop[i] = false;
                                        }
                                    } else if ( pass ) {
                                        result.push( item );
                                        anyFound = true;
                                    }
                                }
                            }
                        }

                        if ( found !== undefined ) {
                            if ( !inplace ) {
                                curLoop = result;
                            }

                            expr = expr.replace( Expr.match[ type ], "" );

                            if ( !anyFound ) {
                                return [];
                            }

                            break;
                        }
                    }
                }

                // Improper expression
                if ( expr == old ) {
                    if ( anyFound == null ) {
                        throw "Syntax error, unrecognized expression: " + expr;
                    } else {
                        break;
                    }
                }

                old = expr;
            }

            return curLoop;
        };
    }
 }