JSFiddle - React, Tailwind, and code Playground

JavaScript

Object.createPoly = (function() {
    // To save on memory, use a shared constructor
    function Temp() {}

    // make a safe reference to Object.prototype.hasOwnProperty
    var hasOwn = Object.prototype.hasOwnProperty;

    return function (O) {
      // 1. If Type(O) is not Object or Null throw a TypeError exception.
      if (typeof O != 'object') {
        throw TypeError('Object prototype may only be an Object or null');
      }

      // 2. Let obj be the result of creating a new object as if by the
      //    expression new Object() where Object is the standard built-in
      //    constructor with that name
      // 3. Set the [[Prototype]] internal property of obj to O.
      Temp.prototype = O;
      var obj = new Temp();
      Temp.prototype = null; // Let's not keep a stray reference to O...

      // 4. If the argument Properties is present and not undefined, add
      //    own properties to obj as if by calling the standard built-in
      //    function Object.defineProperties with arguments obj and
      //    Properties.
      if (arguments.length > 1) {
        // Object.defineProperties does ToObject on its first argument.
        var Properties = Object(arguments[1]);
        for (var prop in Properties) {
          if (hasOwn.call(Properties, prop)) {
            obj[prop] = Properties[prop];
          }
        }
      }

      // 5. Return obj
      return obj;
    };
  })();

function Foo(){
    this.foo = 42;
    Object.defineProperties(this, {
        bar: {
            writable:true,
            value: 42
        }
    })
}
Foo.prototype.method = function(){
   return "hi, foo!";
}

/// default
function FooChildOne (){

}
FooChildOne.prototype = Object.create(Foo.prototype, {
        zoo: {
            writable:false,
            configurable:true,
            value: 24
        }
    })

var fooChildOne = new FooChildOne();
console.dir(fooChildOne);
console.log([fooChildOne.foo, fooChildOne.bar, fooChildOne.zoo,...