npm install comb-proxy

var comb = require("comb-proxy");

//create an object that can use properties or as a function through the new operator
var MyObject = comb.define(null, {
    instance : {
        hello : "hello",
        constructor : function(){
            this.args = comb.argsToArray(arguments);
        }
    }
});

//NOTE: this will not work properly for native objects like Date.
var createNewMyObject = function(){
   try {
     p = new MyObject();
    } catch (ignore) {
         //ignore the error because its probably from missing arguments
    }
    //Now lets take care of arguments supplied!!!
    MyObject.apply(p, comb.argsToArray(arguments));
    return p;
};

//This example creates an object with a world property but its not a function!
var handle = comb.createFunctionWrapper({world : "world"}, createNewMyObject, createNewMyObject);

handle.world //=> "world"
var a = handle(1);
a.hello;  //=>"hello"
a.args; //=> [1];
a = new handle(1,2);
a.hello; //=>"hello"
a.args; //=> [1,2];

function (obj,handler,constructTrap,opts){
   var args = comb.argsToArray(arguments), ret;
   if (args.length != 4) {
       opts = comb.isHash(args[args.length - 1]) ? args.pop() : null;
       constructTrap = comb.isFunction(args[args.length - 1]) ? args.pop() : null;
       handler = comb.isFunction(args[args.length - 1]) ? args.pop() : null;
   }
   if (comb.isUndefined(obj)) throw new Error("obj required when using create function wrapper");
   if (comb.isFunction(constructTrap) && !comb.isFunction(handler)) {
       ret = Proxy.createFunction(handlerMaker(obj), constructTrap);
   } else {
       ret = Proxy.createFunction(handlerMaker(obj), handler, constructTrap);
   }
   if (opts) {
       Proxy.setPrototype(ret, comb.isHash(opts) ? opts : opts.prototype);
   }
   return ret;
}

var staticValueFunction = function (value) {
     return comb.argsToArray(arguments).join(" ");
};

var promiseValueFunction = function (value) {
     var ret = new comb.Promise();
     setTimeout(comb.hitch(ret, "callback", comb.argsToArray(arguments).join(" ")), 100);
     return ret;
};

var hash = {
     staticValueFunction:staticValueFunction,
     promiseValueFunction:promiseValueFunction
};

var p = comb.executeInOrder(hash, staticValueFunction, promiseValueFunction, function (hash, staticValueFunction, promiseValueFunction) {
    var toBe = staticValueFunction(promiseValueFunction("to"), "be");
    var notToBe = hash.promiseValueFunction("or", hash.staticValueFunction("not", toBe));
    return hash.promiseValueFunction(toBe, notToBe);
});
p.addCallback(function(ret){
    console.log(ret); //=>"to be or not to be"
});

function (args,cb){
   args = comb.argsToArray(arguments);
   cb = comb.isFunction(args[args.length - 1]) ? args.pop() : null;
   var ret = new Promise();
   if (cb) {
       var stack = [];
       var newArgs = args.map(function (a) {
           return [a, getHandler(a, stack)];
       });
       var cbRet = cb.apply(null, newArgs.map(function (h) {
           return h[1];
       }));
       executeStack(stack, newArgs).then(function (results, pMap) {
           if (comb.isUndefined(cbRet)) {
               ret.callback(results);
           }
           else {
               var cbResults;
               if (comb.isArray(cbRet)) {
                   cbResults = cbRet.map(
                       function (arg) {
                           return getValueFromArrayMap(arg, pMap, newArgs);
                       }).filter(function (r) {
                           return !comb.isUndefined(r)
                       });
               } else if (comb.isHash(cbRet)) {
                   cbResults = {};
                   for (var i in cbRet) {
                       cbResults[i] = getValueFromArrayMap(cbRet[i], pMap, newArgs);
                   }
               } else if (comb.isProxy(cbRet)) {
                   cbResults = getValueFromArrayMap(cbRet, pMap, newArgs);
               } else {
                   cbResults = cbRet;
               }
               ret.callback(cbResults);
           }
       }, hitch(ret, "errback"));
   } else {
       ret.callback();
   }
   return ret;
       
}

function (obj,opts,proto){
   opts = opts || {};
   if (comb.isUndefined(proto)) {
       return  Proxy.create(merge(handlerMaker(obj), opts));
   } else {
       return  Proxy.create(merge(handlerMaker(obj), opts), comb.isHash(proto) ? proto : proto.prototype);
   }
}

function (obj){
   var undef;
   return obj !== undef && obj !== null && Proxy.isProxy(obj);
}

var x = {hello:function () {return "hello"}, world:"world"};
 var xHandler = comb.methodMissing(x, function (m) {
             //you can do more interesting stuff in here!
              return function () {
                  return [m].concat(comb.argsToArray(arguments));
              }
  });
 xHandler.hello(); //=> "hello"
 xHandler.world //=> "world"
 xHandler.someMethod("hello", "world"); //=> [ 'someMethod', 'hello', 'world' ]

function (obj,handler,proto){
   proto = proto || {};
   return  Proxy.create(merge(handlerMaker(obj), noSuchMethodHandler(obj, handler)), comb.isHash(proto) ? proto : proto.prototype);
}

var MyClass = comb.define(comb.plugins.MethodMissing, {
    instance : {

        constructor : function(){
             this._attributes = {};
        },

        getMissingProperty : function(name){
            return this._attributes[name];
        },

        setMissingProperty : function(name, value){
            return this._attributes[name] = value;
        }
    }
});

function (name){
   //return defaults
   return undefined;
           
}

function (name,value){
   //return defaults
   return this[name] = value;
           
}