"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/typedarray/index.js" (7 Feb 2017, 21325 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 var undefined = (void 0); // Paranoia
    2 
    3 // Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
    4 // create, and consume so much memory, that the browser appears frozen.
    5 var MAX_ARRAY_LENGTH = 1e5;
    6 
    7 // Approximations of internal ECMAScript conversion functions
    8 var ECMAScript = (function() {
    9   // Stash a copy in case other scripts modify these
   10   var opts = Object.prototype.toString,
   11       ophop = Object.prototype.hasOwnProperty;
   12 
   13   return {
   14     // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
   15     Class: function(v) { return opts.call(v).replace(/^\[object *|\]$/g, ''); },
   16     HasProperty: function(o, p) { return p in o; },
   17     HasOwnProperty: function(o, p) { return ophop.call(o, p); },
   18     IsCallable: function(o) { return typeof o === 'function'; },
   19     ToInt32: function(v) { return v >> 0; },
   20     ToUint32: function(v) { return v >>> 0; }
   21   };
   22 }());
   23 
   24 // Snapshot intrinsics
   25 var LN2 = Math.LN2,
   26     abs = Math.abs,
   27     floor = Math.floor,
   28     log = Math.log,
   29     min = Math.min,
   30     pow = Math.pow,
   31     round = Math.round;
   32 
   33 // ES5: lock down object properties
   34 function configureProperties(obj) {
   35   if (getOwnPropNames && defineProp) {
   36     var props = getOwnPropNames(obj), i;
   37     for (i = 0; i < props.length; i += 1) {
   38       defineProp(obj, props[i], {
   39         value: obj[props[i]],
   40         writable: false,
   41         enumerable: false,
   42         configurable: false
   43       });
   44     }
   45   }
   46 }
   47 
   48 // emulate ES5 getter/setter API using legacy APIs
   49 // http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
   50 // (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
   51 // note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)
   52 var defineProp
   53 if (Object.defineProperty && (function() {
   54       try {
   55         Object.defineProperty({}, 'x', {});
   56         return true;
   57       } catch (e) {
   58         return false;
   59       }
   60     })()) {
   61   defineProp = Object.defineProperty;
   62 } else {
   63   defineProp = function(o, p, desc) {
   64     if (!o === Object(o)) throw new TypeError("Object.defineProperty called on non-object");
   65     if (ECMAScript.HasProperty(desc, 'get') && Object.prototype.__defineGetter__) { Object.prototype.__defineGetter__.call(o, p, desc.get); }
   66     if (ECMAScript.HasProperty(desc, 'set') && Object.prototype.__defineSetter__) { Object.prototype.__defineSetter__.call(o, p, desc.set); }
   67     if (ECMAScript.HasProperty(desc, 'value')) { o[p] = desc.value; }
   68     return o;
   69   };
   70 }
   71 
   72 var getOwnPropNames = Object.getOwnPropertyNames || function (o) {
   73   if (o !== Object(o)) throw new TypeError("Object.getOwnPropertyNames called on non-object");
   74   var props = [], p;
   75   for (p in o) {
   76     if (ECMAScript.HasOwnProperty(o, p)) {
   77       props.push(p);
   78     }
   79   }
   80   return props;
   81 };
   82 
   83 // ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
   84 // for index in 0 ... obj.length
   85 function makeArrayAccessors(obj) {
   86   if (!defineProp) { return; }
   87 
   88   if (obj.length > MAX_ARRAY_LENGTH) throw new RangeError("Array too large for polyfill");
   89 
   90   function makeArrayAccessor(index) {
   91     defineProp(obj, index, {
   92       'get': function() { return obj._getter(index); },
   93       'set': function(v) { obj._setter(index, v); },
   94       enumerable: true,
   95       configurable: false
   96     });
   97   }
   98 
   99   var i;
  100   for (i = 0; i < obj.length; i += 1) {
  101     makeArrayAccessor(i);
  102   }
  103 }
  104 
  105 // Internal conversion functions:
  106 //    pack<Type>()   - take a number (interpreted as Type), output a byte array
  107 //    unpack<Type>() - take a byte array, output a Type-like number
  108 
  109 function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
  110 function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
  111 
  112 function packI8(n) { return [n & 0xff]; }
  113 function unpackI8(bytes) { return as_signed(bytes[0], 8); }
  114 
  115 function packU8(n) { return [n & 0xff]; }
  116 function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }
  117 
  118 function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }
  119 
  120 function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
  121 function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); }
  122 
  123 function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
  124 function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); }
  125 
  126 function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
  127 function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
  128 
  129 function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
  130 function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
  131 
  132 function packIEEE754(v, ebits, fbits) {
  133 
  134   var bias = (1 << (ebits - 1)) - 1,
  135       s, e, f, ln,
  136       i, bits, str, bytes;
  137 
  138   function roundToEven(n) {
  139     var w = floor(n), f = n - w;
  140     if (f < 0.5)
  141       return w;
  142     if (f > 0.5)
  143       return w + 1;
  144     return w % 2 ? w + 1 : w;
  145   }
  146 
  147   // Compute sign, exponent, fraction
  148   if (v !== v) {
  149     // NaN
  150     // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
  151     e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
  152   } else if (v === Infinity || v === -Infinity) {
  153     e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
  154   } else if (v === 0) {
  155     e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
  156   } else {
  157     s = v < 0;
  158     v = abs(v);
  159 
  160     if (v >= pow(2, 1 - bias)) {
  161       e = min(floor(log(v) / LN2), 1023);
  162       f = roundToEven(v / pow(2, e) * pow(2, fbits));
  163       if (f / pow(2, fbits) >= 2) {
  164         e = e + 1;
  165         f = 1;
  166       }
  167       if (e > bias) {
  168         // Overflow
  169         e = (1 << ebits) - 1;
  170         f = 0;
  171       } else {
  172         // Normalized
  173         e = e + bias;
  174         f = f - pow(2, fbits);
  175       }
  176     } else {
  177       // Denormalized
  178       e = 0;
  179       f = roundToEven(v / pow(2, 1 - bias - fbits));
  180     }
  181   }
  182 
  183   // Pack sign, exponent, fraction
  184   bits = [];
  185   for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
  186   for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
  187   bits.push(s ? 1 : 0);
  188   bits.reverse();
  189   str = bits.join('');
  190 
  191   // Bits to bytes
  192   bytes = [];
  193   while (str.length) {
  194     bytes.push(parseInt(str.substring(0, 8), 2));
  195     str = str.substring(8);
  196   }
  197   return bytes;
  198 }
  199 
  200 function unpackIEEE754(bytes, ebits, fbits) {
  201 
  202   // Bytes to bits
  203   var bits = [], i, j, b, str,
  204       bias, s, e, f;
  205 
  206   for (i = bytes.length; i; i -= 1) {
  207     b = bytes[i - 1];
  208     for (j = 8; j; j -= 1) {
  209       bits.push(b % 2 ? 1 : 0); b = b >> 1;
  210     }
  211   }
  212   bits.reverse();
  213   str = bits.join('');
  214 
  215   // Unpack sign, exponent, fraction
  216   bias = (1 << (ebits - 1)) - 1;
  217   s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
  218   e = parseInt(str.substring(1, 1 + ebits), 2);
  219   f = parseInt(str.substring(1 + ebits), 2);
  220 
  221   // Produce number
  222   if (e === (1 << ebits) - 1) {
  223     return f !== 0 ? NaN : s * Infinity;
  224   } else if (e > 0) {
  225     // Normalized
  226     return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
  227   } else if (f !== 0) {
  228     // Denormalized
  229     return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
  230   } else {
  231     return s < 0 ? -0 : 0;
  232   }
  233 }
  234 
  235 function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
  236 function packF64(v) { return packIEEE754(v, 11, 52); }
  237 function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
  238 function packF32(v) { return packIEEE754(v, 8, 23); }
  239 
  240 
  241 //
  242 // 3 The ArrayBuffer Type
  243 //
  244 
  245 (function() {
  246 
  247   /** @constructor */
  248   var ArrayBuffer = function ArrayBuffer(length) {
  249     length = ECMAScript.ToInt32(length);
  250     if (length < 0) throw new RangeError('ArrayBuffer size is not a small enough positive integer');
  251 
  252     this.byteLength = length;
  253     this._bytes = [];
  254     this._bytes.length = length;
  255 
  256     var i;
  257     for (i = 0; i < this.byteLength; i += 1) {
  258       this._bytes[i] = 0;
  259     }
  260 
  261     configureProperties(this);
  262   };
  263 
  264   exports.ArrayBuffer = exports.ArrayBuffer || ArrayBuffer;
  265 
  266   //
  267   // 4 The ArrayBufferView Type
  268   //
  269 
  270   // NOTE: this constructor is not exported
  271   /** @constructor */
  272   var ArrayBufferView = function ArrayBufferView() {
  273     //this.buffer = null;
  274     //this.byteOffset = 0;
  275     //this.byteLength = 0;
  276   };
  277 
  278   //
  279   // 5 The Typed Array View Types
  280   //
  281 
  282   function makeConstructor(bytesPerElement, pack, unpack) {
  283     // Each TypedArray type requires a distinct constructor instance with
  284     // identical logic, which this produces.
  285 
  286     var ctor;
  287     ctor = function(buffer, byteOffset, length) {
  288       var array, sequence, i, s;
  289 
  290       if (!arguments.length || typeof arguments[0] === 'number') {
  291         // Constructor(unsigned long length)
  292         this.length = ECMAScript.ToInt32(arguments[0]);
  293         if (length < 0) throw new RangeError('ArrayBufferView size is not a small enough positive integer');
  294 
  295         this.byteLength = this.length * this.BYTES_PER_ELEMENT;
  296         this.buffer = new ArrayBuffer(this.byteLength);
  297         this.byteOffset = 0;
  298       } else if (typeof arguments[0] === 'object' && arguments[0].constructor === ctor) {
  299         // Constructor(TypedArray array)
  300         array = arguments[0];
  301 
  302         this.length = array.length;
  303         this.byteLength = this.length * this.BYTES_PER_ELEMENT;
  304         this.buffer = new ArrayBuffer(this.byteLength);
  305         this.byteOffset = 0;
  306 
  307         for (i = 0; i < this.length; i += 1) {
  308           this._setter(i, array._getter(i));
  309         }
  310       } else if (typeof arguments[0] === 'object' &&
  311                  !(arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) {
  312         // Constructor(sequence<type> array)
  313         sequence = arguments[0];
  314 
  315         this.length = ECMAScript.ToUint32(sequence.length);
  316         this.byteLength = this.length * this.BYTES_PER_ELEMENT;
  317         this.buffer = new ArrayBuffer(this.byteLength);
  318         this.byteOffset = 0;
  319 
  320         for (i = 0; i < this.length; i += 1) {
  321           s = sequence[i];
  322           this._setter(i, Number(s));
  323         }
  324       } else if (typeof arguments[0] === 'object' &&
  325                  (arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) {
  326         // Constructor(ArrayBuffer buffer,
  327         //             optional unsigned long byteOffset, optional unsigned long length)
  328         this.buffer = buffer;
  329 
  330         this.byteOffset = ECMAScript.ToUint32(byteOffset);
  331         if (this.byteOffset > this.buffer.byteLength) {
  332           throw new RangeError("byteOffset out of range");
  333         }
  334 
  335         if (this.byteOffset % this.BYTES_PER_ELEMENT) {
  336           // The given byteOffset must be a multiple of the element
  337           // size of the specific type, otherwise an exception is raised.
  338           throw new RangeError("ArrayBuffer length minus the byteOffset is not a multiple of the element size.");
  339         }
  340 
  341         if (arguments.length < 3) {
  342           this.byteLength = this.buffer.byteLength - this.byteOffset;
  343 
  344           if (this.byteLength % this.BYTES_PER_ELEMENT) {
  345             throw new RangeError("length of buffer minus byteOffset not a multiple of the element size");
  346           }
  347           this.length = this.byteLength / this.BYTES_PER_ELEMENT;
  348         } else {
  349           this.length = ECMAScript.ToUint32(length);
  350           this.byteLength = this.length * this.BYTES_PER_ELEMENT;
  351         }
  352 
  353         if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) {
  354           throw new RangeError("byteOffset and length reference an area beyond the end of the buffer");
  355         }
  356       } else {
  357         throw new TypeError("Unexpected argument type(s)");
  358       }
  359 
  360       this.constructor = ctor;
  361 
  362       configureProperties(this);
  363       makeArrayAccessors(this);
  364     };
  365 
  366     ctor.prototype = new ArrayBufferView();
  367     ctor.prototype.BYTES_PER_ELEMENT = bytesPerElement;
  368     ctor.prototype._pack = pack;
  369     ctor.prototype._unpack = unpack;
  370     ctor.BYTES_PER_ELEMENT = bytesPerElement;
  371 
  372     // getter type (unsigned long index);
  373     ctor.prototype._getter = function(index) {
  374       if (arguments.length < 1) throw new SyntaxError("Not enough arguments");
  375 
  376       index = ECMAScript.ToUint32(index);
  377       if (index >= this.length) {
  378         return undefined;
  379       }
  380 
  381       var bytes = [], i, o;
  382       for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
  383            i < this.BYTES_PER_ELEMENT;
  384            i += 1, o += 1) {
  385         bytes.push(this.buffer._bytes[o]);
  386       }
  387       return this._unpack(bytes);
  388     };
  389 
  390     // NONSTANDARD: convenience alias for getter: type get(unsigned long index);
  391     ctor.prototype.get = ctor.prototype._getter;
  392 
  393     // setter void (unsigned long index, type value);
  394     ctor.prototype._setter = function(index, value) {
  395       if (arguments.length < 2) throw new SyntaxError("Not enough arguments");
  396 
  397       index = ECMAScript.ToUint32(index);
  398       if (index >= this.length) {
  399         return undefined;
  400       }
  401 
  402       var bytes = this._pack(value), i, o;
  403       for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
  404            i < this.BYTES_PER_ELEMENT;
  405            i += 1, o += 1) {
  406         this.buffer._bytes[o] = bytes[i];
  407       }
  408     };
  409 
  410     // void set(TypedArray array, optional unsigned long offset);
  411     // void set(sequence<type> array, optional unsigned long offset);
  412     ctor.prototype.set = function(index, value) {
  413       if (arguments.length < 1) throw new SyntaxError("Not enough arguments");
  414       var array, sequence, offset, len,
  415           i, s, d,
  416           byteOffset, byteLength, tmp;
  417 
  418       if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) {
  419         // void set(TypedArray array, optional unsigned long offset);
  420         array = arguments[0];
  421         offset = ECMAScript.ToUint32(arguments[1]);
  422 
  423         if (offset + array.length > this.length) {
  424           throw new RangeError("Offset plus length of array is out of range");
  425         }
  426 
  427         byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
  428         byteLength = array.length * this.BYTES_PER_ELEMENT;
  429 
  430         if (array.buffer === this.buffer) {
  431           tmp = [];
  432           for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) {
  433             tmp[i] = array.buffer._bytes[s];
  434           }
  435           for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) {
  436             this.buffer._bytes[d] = tmp[i];
  437           }
  438         } else {
  439           for (i = 0, s = array.byteOffset, d = byteOffset;
  440                i < byteLength; i += 1, s += 1, d += 1) {
  441             this.buffer._bytes[d] = array.buffer._bytes[s];
  442           }
  443         }
  444       } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') {
  445         // void set(sequence<type> array, optional unsigned long offset);
  446         sequence = arguments[0];
  447         len = ECMAScript.ToUint32(sequence.length);
  448         offset = ECMAScript.ToUint32(arguments[1]);
  449 
  450         if (offset + len > this.length) {
  451           throw new RangeError("Offset plus length of array is out of range");
  452         }
  453 
  454         for (i = 0; i < len; i += 1) {
  455           s = sequence[i];
  456           this._setter(offset + i, Number(s));
  457         }
  458       } else {
  459         throw new TypeError("Unexpected argument type(s)");
  460       }
  461     };
  462 
  463     // TypedArray subarray(long begin, optional long end);
  464     ctor.prototype.subarray = function(start, end) {
  465       function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }
  466 
  467       start = ECMAScript.ToInt32(start);
  468       end = ECMAScript.ToInt32(end);
  469 
  470       if (arguments.length < 1) { start = 0; }
  471       if (arguments.length < 2) { end = this.length; }
  472 
  473       if (start < 0) { start = this.length + start; }
  474       if (end < 0) { end = this.length + end; }
  475 
  476       start = clamp(start, 0, this.length);
  477       end = clamp(end, 0, this.length);
  478 
  479       var len = end - start;
  480       if (len < 0) {
  481         len = 0;
  482       }
  483 
  484       return new this.constructor(
  485         this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
  486     };
  487 
  488     return ctor;
  489   }
  490 
  491   var Int8Array = makeConstructor(1, packI8, unpackI8);
  492   var Uint8Array = makeConstructor(1, packU8, unpackU8);
  493   var Uint8ClampedArray = makeConstructor(1, packU8Clamped, unpackU8);
  494   var Int16Array = makeConstructor(2, packI16, unpackI16);
  495   var Uint16Array = makeConstructor(2, packU16, unpackU16);
  496   var Int32Array = makeConstructor(4, packI32, unpackI32);
  497   var Uint32Array = makeConstructor(4, packU32, unpackU32);
  498   var Float32Array = makeConstructor(4, packF32, unpackF32);
  499   var Float64Array = makeConstructor(8, packF64, unpackF64);
  500 
  501   exports.Int8Array = exports.Int8Array || Int8Array;
  502   exports.Uint8Array = exports.Uint8Array || Uint8Array;
  503   exports.Uint8ClampedArray = exports.Uint8ClampedArray || Uint8ClampedArray;
  504   exports.Int16Array = exports.Int16Array || Int16Array;
  505   exports.Uint16Array = exports.Uint16Array || Uint16Array;
  506   exports.Int32Array = exports.Int32Array || Int32Array;
  507   exports.Uint32Array = exports.Uint32Array || Uint32Array;
  508   exports.Float32Array = exports.Float32Array || Float32Array;
  509   exports.Float64Array = exports.Float64Array || Float64Array;
  510 }());
  511 
  512 //
  513 // 6 The DataView View Type
  514 //
  515 
  516 (function() {
  517   function r(array, index) {
  518     return ECMAScript.IsCallable(array.get) ? array.get(index) : array[index];
  519   }
  520 
  521   var IS_BIG_ENDIAN = (function() {
  522     var u16array = new(exports.Uint16Array)([0x1234]),
  523         u8array = new(exports.Uint8Array)(u16array.buffer);
  524     return r(u8array, 0) === 0x12;
  525   }());
  526 
  527   // Constructor(ArrayBuffer buffer,
  528   //             optional unsigned long byteOffset,
  529   //             optional unsigned long byteLength)
  530   /** @constructor */
  531   var DataView = function DataView(buffer, byteOffset, byteLength) {
  532     if (arguments.length === 0) {
  533       buffer = new exports.ArrayBuffer(0);
  534     } else if (!(buffer instanceof exports.ArrayBuffer || ECMAScript.Class(buffer) === 'ArrayBuffer')) {
  535       throw new TypeError("TypeError");
  536     }
  537 
  538     this.buffer = buffer || new exports.ArrayBuffer(0);
  539 
  540     this.byteOffset = ECMAScript.ToUint32(byteOffset);
  541     if (this.byteOffset > this.buffer.byteLength) {
  542       throw new RangeError("byteOffset out of range");
  543     }
  544 
  545     if (arguments.length < 3) {
  546       this.byteLength = this.buffer.byteLength - this.byteOffset;
  547     } else {
  548       this.byteLength = ECMAScript.ToUint32(byteLength);
  549     }
  550 
  551     if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) {
  552       throw new RangeError("byteOffset and length reference an area beyond the end of the buffer");
  553     }
  554 
  555     configureProperties(this);
  556   };
  557 
  558   function makeGetter(arrayType) {
  559     return function(byteOffset, littleEndian) {
  560 
  561       byteOffset = ECMAScript.ToUint32(byteOffset);
  562 
  563       if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) {
  564         throw new RangeError("Array index out of range");
  565       }
  566       byteOffset += this.byteOffset;
  567 
  568       var uint8Array = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT),
  569           bytes = [], i;
  570       for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) {
  571         bytes.push(r(uint8Array, i));
  572       }
  573 
  574       if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) {
  575         bytes.reverse();
  576       }
  577 
  578       return r(new arrayType(new exports.Uint8Array(bytes).buffer), 0);
  579     };
  580   }
  581 
  582   DataView.prototype.getUint8 = makeGetter(exports.Uint8Array);
  583   DataView.prototype.getInt8 = makeGetter(exports.Int8Array);
  584   DataView.prototype.getUint16 = makeGetter(exports.Uint16Array);
  585   DataView.prototype.getInt16 = makeGetter(exports.Int16Array);
  586   DataView.prototype.getUint32 = makeGetter(exports.Uint32Array);
  587   DataView.prototype.getInt32 = makeGetter(exports.Int32Array);
  588   DataView.prototype.getFloat32 = makeGetter(exports.Float32Array);
  589   DataView.prototype.getFloat64 = makeGetter(exports.Float64Array);
  590 
  591   function makeSetter(arrayType) {
  592     return function(byteOffset, value, littleEndian) {
  593 
  594       byteOffset = ECMAScript.ToUint32(byteOffset);
  595       if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) {
  596         throw new RangeError("Array index out of range");
  597       }
  598 
  599       // Get bytes
  600       var typeArray = new arrayType([value]),
  601           byteArray = new exports.Uint8Array(typeArray.buffer),
  602           bytes = [], i, byteView;
  603 
  604       for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) {
  605         bytes.push(r(byteArray, i));
  606       }
  607 
  608       // Flip if necessary
  609       if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) {
  610         bytes.reverse();
  611       }
  612 
  613       // Write them
  614       byteView = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT);
  615       byteView.set(bytes);
  616     };
  617   }
  618 
  619   DataView.prototype.setUint8 = makeSetter(exports.Uint8Array);
  620   DataView.prototype.setInt8 = makeSetter(exports.Int8Array);
  621   DataView.prototype.setUint16 = makeSetter(exports.Uint16Array);
  622   DataView.prototype.setInt16 = makeSetter(exports.Int16Array);
  623   DataView.prototype.setUint32 = makeSetter(exports.Uint32Array);
  624   DataView.prototype.setInt32 = makeSetter(exports.Int32Array);
  625   DataView.prototype.setFloat32 = makeSetter(exports.Float32Array);
  626   DataView.prototype.setFloat64 = makeSetter(exports.Float64Array);
  627 
  628   exports.DataView = exports.DataView || DataView;
  629 
  630 }());