avsc currently runs on all versions of node since 0.11, it would be good to keep compatibility the same. Can you remove all features not supported by ECMAScript 5 (template literals, let, etc.)?

@mtth It is easier to remove the usage of template literals and other es6 features but one of the core parts of the refactor is the use of spread operator to pass in the arguments without any function signature change. If not for it we will be forced to change the signature which I was not sure would be better.

For instance, in the existing implementation we do something like,

 body += '  return new ' + uname + '(' + innerArgs.join() + ');\n};';

this will eventually resolve to something like,

return new Person(arg1, arg2, arg3);

However when we want to flatten it out into a function we would not able to refactor it as,

innerArgs = [arg1, arg2, arg3];
return new self._constructor(innerArgs)

we need the spread operator to maintain the same implementation like,

innerArgs = [arg1, arg2, arg3]
return new self._constructor(...innerArgs);

Let me know if it makes sense. I am open to other ideas as well if this something that can be solved with js that is compatible with Node 0.11

I went with ES6 implementation since our primary usage is in modern browsers.

Would you be open to the idea of introducing a build step which will compile and build files that are compatible for Node 0.11? Just throwing it out to see if thats a possibility that we are open to.

You can emulate the spread operator by applying on bind:

function Foo(a, b) { this.a = a; this.b = b; } // Example constructor.
var args = [undefined, 1, 2]; // The dynamic array of arguments to apply.
var BoundFoo = Foo.bind.apply(Foo, args); // Bind the array to the constructor.
var foo = new BoundFoo(); // Foo { a: 1, b: 2 }

Introducing a build step sounds acceptable if it doesn't introduce too much complexity. It should be done separately from this PR though.

Why nest the function inside an object here?

This is so that the function can get a dynamic name. This is again only available in ES2015. An example of it would be something like this,

var fun1 = function() { console.log('fun1'); }
var funname = 'fun2';
var dfun = ({
  [funname]: function() { console.log('dynamic function'); }
})[funname];

dfuninstance = new dfun()
dynamic function
dfun {}
dfun.name
"fun2"

The aim was to have the constructor function with proper name when being invoked.

Interesting, pretty cool. Let's extract the logic to a function and document it to help future readers.