title: extending class SharedArrayBuffer results in "Constructor SharedArrayBuffer required 'new'"
body: <p>I'm attempting to extend the <code>SharedArrayBuffer</code> class to easily pass around Component data for use within worker threads as we're processing tens of thousands of entities per second. This is my code at the moment.</p>
  <pre><code>export default abstract class Component extends SharedArrayBuffer {
    public name: String; 
    public data: DataView;
  
    public constructor(size) {
        super(size); 
        this.data = new DataView(this); 
        this.name = this.constructor.name.toLowerCase(); 
    }
  }
  </code></pre>
  <p>I then have a component that extends the abstract class component called <code>Position</code>.</p>
  <pre><code>export default class Position extends Component {
      public constructor(x: number = 0, y: number = 0, layer: number = 0) {
          super(12); 
          this.data.setUint32(0, x);
          this.data.setUint32(4, y);
          this.data.setUint32(8, layer);
      }
  
      get x() { return this.data.getUint32(0); }
      set x(value: number) { this.data.setUint32(0, value); }
  
      get y() { return this.data.getUint32(4); }
      set y(value: number) { this.data.setUint32(4, value); }
  
      get layer() { return this.data.getUint32(8); }
      set layer(value: number) { this.data.setUint32(8, value); }
  }
  </code></pre>
  <p>When creating a Position component through <code>new Position(...)</code> I receive the following error:</p>
  <blockquote>
  <p>Component.js:19
  var _this = _super.call(this, size) || this;
  ^</p>
  <p>TypeError: Constructor SharedArrayBuffer requires 'new'</p>
  </blockquote>
  <p>Below you can find the JavaScript that is created from the TypeScript code.</p>
  <pre><code>&quot;use strict&quot;;
  var __extends = (this &amp;&amp; this.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array &amp;&amp; function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  Object.defineProperty(exports, &quot;__esModule&quot;, { value: true });
  var Component = /** @class */ (function (_super) {
      __extends(Component, _super);
      function Component(size) {
          var _this = _super.call(this, size) || this;
          _this.data = new DataView(_this);
          _this.name = _this.constructor.name.toLowerCase();
          return _this;
      }
      return Component;
  }(SharedArrayBuffer));
  exports.default = Component;
  </code></pre>
  <p>What is the best way to ensure that the constructor of SharedArrayBuffer is called when <code>super</code> is executed to prevent this error?</p>