docs: function $TypedArray$() {
  
        // %TypedArray% ( length )
        if (!arguments.length || typeof arguments[0] !== 'object') {
          return (function(length) {
            length = ToInt32(length);
            if (length < 0) throw RangeError('length is not a small enough positive integer.');
            Object.defineProperty(this, 'length', {value: length});
            Object.defineProperty(this, 'byteLength', {value: length * this.BYTES_PER_ELEMENT});
            Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(this.byteLength)});
            Object.defineProperty(this, 'byteOffset', {value: 0});
  
          }).apply(this, arguments);
        }
  
        // %TypedArray% ( typedArray )
        if (arguments.length >= 1 &&
          Type(arguments[0]) === 'object' &&
          arguments[0] instanceof $TypedArray$) {
          return (function(typedArray){
            if (this.constructor !== typedArray.constructor) throw TypeError();
  
            var byteLength = typedArray.length * this.BYTES_PER_ELEMENT;
            Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
            Object.defineProperty(this, 'byteLength', {value: byteLength});
            Object.defineProperty(this, 'byteOffset', {value: 0});
            Object.defineProperty(this, 'length', {value: typedArray.length});
  
            for (var i = 0; i < this.length; i += 1)
              this._setter(i, typedArray._getter(i));
  
          }).apply(this, arguments);
        }
  
        // %TypedArray% ( array )
        if (arguments.length >= 1 &&
          Type(arguments[0]) === 'object' &&
          !(arguments[0] instanceof $TypedArray$) &&
          !(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
          return (function(array) {
  
            var byteLength = array.length * this.BYTES_PER_ELEMENT;
            Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
            Object.defineProperty(this, 'byteLength', {value: byteLength});
            Object.defineProperty(this, 'byteOffset', {value: 0});
            Object.defineProperty(this, 'length', {value: array.length});
  
            for (var i = 0; i < this.length; i += 1) {
              var s = array[i];
              this._setter(i, Number(s));
            }
          }).apply(this, arguments);
        }
  
        // %TypedArray% ( buffer, byteOffset=0, length=undefined )
        if (arguments.length >= 1 &&
          Type(arguments[0]) === 'object' &&
          (arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
          return (function(buffer, byteOffset, length) {
  
            byteOffset = ToUint32(byteOffset);
            if (byteOffset > buffer.byteLength)
              throw RangeError('byteOffset out of range');
  
            // The given byteOffset must be a multiple of the element
            // size of the specific type, otherwise an exception is raised.
            if (byteOffset % this.BYTES_PER_ELEMENT)
              throw RangeError('buffer length minus the byteOffset is not a multiple of the element size.');
  
            if (length === undefined) {
              var byteLength = buffer.byteLength - byteOffset;
              if (byteLength % this.BYTES_PER_ELEMENT)
                throw RangeError('length of buffer minus byteOffset not a multiple of the element size');
              length = byteLength / this.BYTES_PER_ELEMENT;
  
            } else {
              length = ToUint32(length);
              byteLength = length * this.BYTES_PER_ELEMENT;
            }
  
            if ((byteOffset + byteLength) > buffer.byteLength)
              throw RangeError('byteOffset and length reference an area beyond the end of the buffer');
  
            Object.defineProperty(this, 'buffer', {value: buffer});
            Object.defineProperty(this, 'byteLength', {value: byteLength});
            Object.defineProperty(this, 'byteOffset', {value: byteOffset});
            Object.defineProperty(this, 'length', {value: length});
  
          }).apply(this, arguments);
        }
  
        // %TypedArray% ( all other argument combinations )
        throw TypeError();
      }