In true prototype languages like IO, there is no inheritance vs. instantiation of classes, there is differential inheritance aka cloning. New objects are derived from existing objects. The old object serves as a prototype of the new one.

In Javascript there is no proper cloning -- instead, a prototype to be assigned to a freshly created object depends on the prototype property of the constructor function. All the elements are there but they are insanely incoherent.

To take Crockford's Object.create pattern one micro-step closer to IO, here's how IO-style cloning can be implemented in Javascript:

var yobject = {  
  clone : function () {
    var F = function() {};
    F.prototype = this;
    return new F();
  }
};

Now the objects (or, rather, "yobjects") can be easily cloned like this:

var car = yobject.clone();  
car.wheels = 4;  
var ferrari = car.clone();  
ferrari.color = red;  
console.log(ferrari.wheels); //prints 4  

You can even implement singleton pattern, IO-style:

var elvisCadillac = car.clone();  
elvisCadillac.color = 'pink';  
elvisCadillac.clone = function () {return this;};

var fake = elvisCadillac.clone();  
console.log(fake === elvisCadillac ); //prints true  

I thereby name you The Yobject Pattern!