My comments on ...

var w = window;
if(!w.HTMLElement&&(typeof document.createElement)=="function" // check basics
   &&(var t=document.createElement('a').__proto__) // '__proto__' supported?
   &&t==document.createElement('p').__proto__){ // all HTMLElements the same?
   w.HTMLElement={}; // prevent people from constructing
   w.HTMLElement.prototype=t;
}

javascript:alert(Function.prototype.call.call(document.createElement,document,'p'))

) Element. You can change the string to any valid value. And now the annotated minimised version of the wrapDOMf function:

function wrapDOMf (scope,func)
{
    if(!(scope && typeof func == "string" && scope[func])) return; //ensure proper usage; no type checking

    var storage = arguments.callee; //using wrapDOMf as temporary storage
    storage.orig = scope[func];
    scope[func] = function WRAP()
            {
                return Function.prototype.apply.call(arguments.callee.$original,this,arguments);
            };
    scope[func].$original = storage.orig;
    delete storage.orig; //get rid of any unnecessary references, optional
}

function wrapDOMf (s,f) //scope, function
{
    if(!(s && typeof f == "string" && s[f])) return;

    var m = s[f]; //using local var instead of property
    s[f] = function WRAP()
            {
                return Function.prototype.apply.call(arguments.callee.$original,this,arguments);
            };
    s[f].$original = m;
}

function wrapFunc (scope,func,hijack)
{
    if(!(scope && typeof func == "string" && scope[func])) return; //ensure proper usage
    if(!(hijack && hijack instanceof Function)) hijack = function(x){return x}; //if no hijack exists, f(x)=x

    var storage = arguments.callee;
    storage.orig = scope[func];
    scope[func] = function WRAP()
            {
                var obj = Function.prototype.apply.call(arguments.callee.$original,this,arguments)
                return hijack.call(this,obj,arguments); // 'hijack' is passed the output object and all the arguments
            };
    scope[func].$original = storage.orig;
    delete storage.orig; //now mandatory, since we retain closure
}

function wrapFuncBefore (scope,func,hijack)
{
    if(!(scope && typeof func == "string" && scope[func])) return; //ensure proper usage
    if(!(hijack && hijack instanceof Function)) hijack = function(){return [this,arguments]};

    var storage = arguments.callee;
    storage.orig = scope[func];
    scope[func] = function WRAP()
            {
                var temp = hijack.apply(this,arguments); //I want destructuring assignment
                var that = temp[0];
                var args = temp[1];
                return Function.prototype.apply.call(arguments.callee.$original,that,args);
            };
    scope[func].$original = storage.orig;
    delete storage.orig; //now mandatory, since we retain closure
}

Inspired by hallvors' Capability Detection and a follow-up post from Crisp, I tried to improve on the "classic example"...

if (!document.getElementById)
{
   (function()
    {
     var obj = {};
     if (document.all)
     {
       obj = document.all;
     }
     else if (document.layers)
     {
       obj = document.layers;
     }
     document.getElementById = function(id){return obj[id]};
    }
   )();
}

edit: I also thought about really fixing this, as to change the output from "undefined" to "null" in the case that there is no element with that Id (according to spec), but I figured if someone is stupid enough to check explicitly against null or undefined, instead of normal object detection, then he earned the burn. I really can't imagine a scenario where this "feature" of the function is mandatory.

If there ever occurred such a scenario, however... replace

document.getElementById = function(id){return obj[id]};

by

document.getElementById = function(id){return obj[id] ? obj[id] : null};

or, if there are browsers out there that return "undefined" instead of "null" (natively), you might want to add this instead (update 2007/08/28: Don't use, it's dirty)

if (!document.getElementById(null) && document.getElementById(null) !== null)
{
   (function()
    {
     var obj = document;
     var func = 'getElementById';
     var key = '_';
     while (obj[key+func]) {key+=key};
     obj[key+func] = obj[func];
     obj[func] = function(id){return obj[key+func](id) || null}
    }
   )();
}

if (!window.XMLHttpRequest)
{
     var temp;
     var types = [
         'MSXML2.XMLHTTP.6.0',
         'MSXML2.XMLHTTP.3.0'
     ];
 
     for (var i = 0; i < types.length; i++)
     {
         try
         {
             temp = function(){return new ActiveXObject(types[i])};
             void(temp());
         }
         catch(e) {temp = null;}
         finally {if(temp) break;}
     }
     window.XMLHttpRequest = temp || function(){return undefined};
}