var FThread= new function(){
Version: 3
Descr: 'creates a wrapper for function that allows you to not be afraid of exceptions in'
License: 'public domain'

Implementation:
var root= document.documentElement
var FThread= function( proc ){
	var thread= root.addEventListener
	? function( ){
		var res, self= this, args= arguments
		root.addEventListener( 'launch thread', function( ){
			root.removeEventListener( 'launch thread', arguments.callee, false )
			res= thread.proc.apply( self, args )
		}, false )
		var event= document.createEvent( 'UIEvents' )
        event.initEvent( 'launch thread', false, false )
        root.dispatchEvent( event )
		return res
	}
	: function( ){
		var res, self= this, args= arguments
		root.attachEvent( 'onpropertychange', function( ){
			root.detachEvent( 'onpropertychange', arguments.callee )
			delete root[ 'launch thread' ]
			res= thread.proc.apply( self, args )
		} )
		root[ 'launch thread' ]= null
		return res
	}
	thread.proc= proc
	return thread
}

Export: return FThread

Usage:
var inverse= FThread(function( a ){
	if( a === 0 ) throw 'division by zero'
	return 1/a
})
console.log([ inverse( 0 ), inverse( 1 ) ])
// prints [ undefined, 1 ] and exception 'division by zero' in console log 

}

function A(flag) {
  this.a = 1;
  if(flag == 1) return {c: 3}; // typeof == "object"
  if(flag == 2) return 4; // typeof != "object"
}
A.prototype.b = 2;
console.log(new A()); // {a:1, b: 2}
console.log(new A(1)); // {c: 3}
console.log(new A(2)); // {a:1, b: 2}

var GThread= new function(){
//Version: 3
//Descr: 'creates a wrapper for function that allows you to not be afraid of exceptions in'
//License: 'public domain'

//Implementation:
var GThread=function(proc){
	var thread=function()
		{
		try
			{
			return proc.apply(this,arguments);
			}
		catch(e)
			{
			console.warn(e); 
			console.trace();
			return undefined;
			}
		}
	return thread;
}

//Export: return GThread

//Usage:
var inverse=GThread(function(a){
	if(a===0) 
		throw 'division by zero';
	return 1/a;
})
var inverse2=GThread(function(a){
	return -a;
})
console.log([inverse(0),inverse2(2),inverse(2)])
// prints [undefined, -2, 0.5] without( :( ) exception 'division by zero' in console log 

}

catch(e)
  {
  if (console) console.error(e);
  return undefined;
  }

console.warn(e);
console.trace();

var FThread= new function(){
//Version: 3
//Descr: 'creates a wrapper for function that allows you to not be afraid of exceptions in'
//License: 'public domain'

//Implementation:
var root= document.documentElement
var FThread= function( proc ){
	var thread= root.addEventListener
	? function( ){
		var res, self= this, args= arguments
		root.addEventListener( 'launch thread', function( ){
			root.removeEventListener( 'launch thread', arguments.callee, false )
			res= thread.proc.apply( self, args )
		}, false )
		var event= document.createEvent( 'UIEvents' )
        event.initEvent( 'launch thread', false, false )
        root.dispatchEvent( event )
		return res
	}
	: function( ){
		var res, self= this, args= arguments
		var image=document.createElement('img');
		image.onerror=function()
			{
			res= thread.proc.apply( self, args )
			}
		image.src='';//or 'about:blank'
		return res
	}
	thread.proc= proc
	return thread
}

//Export: return FThread

//Usage:
var inverse= FThread(function( a ){
	if( a === 0 ) throw 'division by zero'
	return 1/a
})
alert([ inverse( 0 ), inverse( 1 ) ])
// prints [ undefined, 1 ] and exception 'division by zero' in console log 

}

var FThread= new function(){

Version: 4
Descr: 'creates a wrapper for function that allows you to not be afraid of exceptions in'
License: 'public domain'
 
Implementation:

var scripts= document.getElementsByTagName( 'script' )
var script= scripts[ scripts.length - 1 ]
var starter= document.createElement( 'button' )
starter.id= 'thread starter'
starter.style.display= 'none'
script.parentNode.insertBefore( starter, script )

var FThread= function( proc ){
    var thread= function( ){
		var res, self= this, args= arguments
		starter.onclick= function( ev ){
		    ( ev || event ).cancelBubble= true
		    starter.onclick= null
		    res= thread.proc.apply( self, args )
		}
        starter.click()
        return res
    }
    thread.proc= proc
    return thread
}
 
Export: return FThread

Usage:

var inverse= FThread(function( a ){
    if( a === -1 ) throw (void 0)()
    if( a === 0 ) throw new Error( 'custom error' )
    return 1/a
})
alert([ inverse( -1 ), inverse( 0 ), inverse( 1 ) ])
// alerts ",,1" and two exceptions in console log

}

/**
 * Javascript ThreadBox
 *
 * DOM-independent implementation of FThread {@link http://habrahabr.ru/blogs/javascript/86852/}
 *
 * Usage: threadBox([context,] function);
 *
 * @author Vasiliy Aksyonov <outring@gmail.com>
 * @version 1.0
 */

var threadBox = (function() {

    var thread;

    try { thread = new ActiveXObject("Msxml2.XMLHTTP"); }

    catch (e) {

        try { thread = new ActiveXObject("Microsoft.XMLHTTP"); }

        catch (e) { thread = false; }
    }

    if (!thread && typeof XMLHttpRequest != 'undefined') {

        thread = new XMLHttpRequest();
    }

    if(thread) {

        var threadBox = function () {

            var context = arguments.length >= 2 ? arguments[0] : null;
            var process = arguments.length >= 2 ? arguments[1] : arguments[0];

            thread.onreadystatechange = function() {

                if (!process) {

                    return;
                }

                var innerProcess = process;

                process = null;

                innerProcess.call(context);
            };

            thread.open('GET', '#', true);
            thread.send(null);
        }
    }

    else {

        var threadBox = function () {

            var context = arguments.length >= 2 ? arguments[0] : null;
            var process = arguments.length >= 2 ? arguments[1] : arguments[0];

            try { process.call(context); }
            catch(e) { setTimeout(function() { throw e; }, 0); }
        }
    }

    return threadBox;
})();

var FThread= new function(){

Version: 5
Description: 'creates a wrapper for function that allows you to not be afraid of exceptions in'
License: 'public domain'
 
Implementation:

var FThread= function( proc ){
    var thread= function( ){
        var res, self= this, args= arguments
        var starter= new XMLHttpRequest
        starter.onreadystatechange= starter.onabort= function( ev ){
        	starter.onreadystatechange= starter.onabort= null
		    res= thread.proc.apply( self, args )
		}
        //console.dir( starter )
        starter.open( 'get', '#', true )
        starter.send( null )
        starter.abort()
        return res
    }
    thread.proc= proc
    return thread
}
 
//Export: return FThread

Usage:

var inverse= FThread(function( a ){
    if( a === -1 ) (void 0)()
    if( a === 0 ) throw Error( 'division by zero' )
    return 1/a
})
alert([ inverse( -1 ), inverse( 0 ), inverse( 1 ) ])
// alerts ",,1" and two exceptions in console log

}

var threadBox = function () {

    var context = arguments.length >= 2 ? arguments[0] : null;
    var process = arguments.length >= 2 ? arguments[1] : arguments[0];

    thread.open('GET', '#', Array.toSource ? true : false);

    thread.onreadystatechange = function () {

        thread.onreadystatechange = function () { };

        process.call(context);
    };

    thread.send(null);
}