function TypedArray() {
		var byteOffset;
		var endianness;
		var nargs;
		var isLE;
		var buf;
		var len;
		var arg;
		var tmp;

		nargs = arguments.length;
		if ( !(this instanceof TypedArray) ) {
			if ( nargs < 2 ) {
				return new TypedArray( arguments[0] );
			}
			if ( nargs === 2 ) {
				return new TypedArray( arguments[0], arguments[1] );
			}
			if ( nargs === 3 ) {
				return new TypedArray( arguments[0], arguments[1], arguments[2] );
			}
			return new TypedArray( arguments[0], arguments[1], arguments[2], arguments[3] );
		}
		endianness = byteOrder( arguments[ 0 ] );
		if ( endianness === null || !isByteOrder( endianness ) ) {
			throw new TypeError( format( 'invalid argument. First argument must be a supported byte order. Value: `%s`.', arguments[ 0 ] ) );
		}
		isLE = isLittleEndian( endianness );

		nargs -= 1;

		// Create the underlying data buffer...
		if ( nargs === 0 ) {
			buf = new DataView( new ArrayBuffer( 0 ) ); // backward-compatibility
		} else if ( nargs === 1 ) {
			arg = arguments[ nargs ];
			if ( isNonNegativeInteger( arg ) ) {
				buf = new DataView( new ArrayBuffer( arg*BYTES_PER_ELEMENT ) );
			} else if ( isCollection( arg ) ) {
				buf = fromArray( new DataView( new ArrayBuffer( arg.length*BYTES_PER_ELEMENT ) ), arg, isLE );
			} else if ( isArrayBuffer( arg ) ) {
				buf = new DataView( arg );
			} else if ( isObject( arg ) ) {
				if ( HAS_ITERATOR_SYMBOL === false ) {
					throw new TypeError( format( 'invalid argument. Environment lacks Symbol.iterator support. Must provide a length, ArrayBuffer, typed array, or array-like object. Value: `%s`.', arg ) );
				}
				if ( !isFunction( arg[ ITERATOR_SYMBOL ] ) ) {
					throw new TypeError( format( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `%s`.', arg ) );
				}
				buf = arg[ ITERATOR_SYMBOL ]();
				if ( !isFunction( buf.next ) ) {
					throw new TypeError( format( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `%s`.', arg ) );
				}
				tmp = fromIterator( buf );
				buf = fromArray( new DataView( new ArrayBuffer( tmp.length*BYTES_PER_ELEMENT ) ), tmp, isLE );
			} else {
				throw new TypeError( format( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `%s`.', arg ) );
			}
		} else {
			buf = arguments[ 1 ];
			if ( !isArrayBuffer( buf ) ) {
				throw new TypeError( format( 'invalid argument. Must provide an ArrayBuffer. Value: `%s`.', buf ) );
			}
			byteOffset = arguments[ 2 ];
			if ( !isNonNegativeInteger( byteOffset ) ) {
				throw new TypeError( format( 'invalid argument. Byte offset must be a nonnegative integer. Value: `%s`.', byteOffset ) );
			}
			if ( nargs === 2 ) {
				buf = new DataView( buf, byteOffset );
			} else {
				len = arguments[ 3 ];
				if ( !isNonNegativeInteger( len ) ) {
					throw new TypeError( format( 'invalid argument. Length must be a nonnegative integer. Value: `%s`.', len ) );
				}
				len *= BYTES_PER_ELEMENT;
				if ( len > (buf.byteLength-byteOffset) ) {
					throw new RangeError( format( 'invalid arguments. ArrayBuffer has insufficient capacity. Either decrease the array length or provide a bigger buffer. Minimum capacity: `%u`.', len ) );
				}
				buf = new DataView( buf, byteOffset, len );
			}
		}
		setReadOnly( this, '_buffer', buf );
		setReadOnly( this, '_length', buf.byteLength/BYTES_PER_ELEMENT );
		setReadOnly( this, '_isLE', isLE );

		return this;
	}
Typed array constructor which returns a typed array representing an array of values in a specified byte order.

@private
@constructor
@param {string} endianness - byte order
@param {(NonNegativeInteger|Collection|ArrayBuffer|Iterable)} [arg] - length, typed array, array-like object, buffer, or an iterable
@param {NonNegativeInteger} [byteOffset=0] - byte offset
@param {NonNegativeInteger} [length] - view length
@throws {TypeError} first argument must be a supported byte order
@throws {TypeError} if provided only two arguments, the second argument must be a valid argument
@throws {TypeError} byte offset must be a nonnegative integer
@throws {RangeError} must provide sufficient memory to accommodate byte offset and view length requirements
@returns {TypedArray} typed array instance