device_home/node_modules/buffer/index.js

   1 /*!
   2  * The buffer module from node.js, for the browser.
   3  *
   4  * @author   Feross Aboukhadijeh <https://feross.org>
   5  * @license  MIT
   6  */
   7 /* eslint-disable no-proto */
   8
   9 'use strict'
  10
  11 var base64 = require('base64-js')
  12 var ieee754 = require('ieee754')
  13 var customInspectSymbol =
  14   (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation
  15     ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation
  16     : null
  17
  18 exports.Buffer = Buffer
  19 exports.SlowBuffer = SlowBuffer
  20 exports.INSPECT_MAX_BYTES = 50
  21
  22 var K_MAX_LENGTH = 0x7fffffff
  23 exports.kMaxLength = K_MAX_LENGTH
  24
  25 /**
  26  * If `Buffer.TYPED_ARRAY_SUPPORT`:
  27  *   === true    Use Uint8Array implementation (fastest)
  28  *   === false   Print warning and recommend using `buffer` v4.x which has an Object
  29  *               implementation (most compatible, even IE6)
  30  *
  31  * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
  32  * Opera 11.6+, iOS 4.2+.
  33  *
  34  * We report that the browser does not support typed arrays if the are not subclassable
  35  * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
  36  * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
  37  * for __proto__ and has a buggy typed array implementation.
  38  */
  39 Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
  40
  41 if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
  42     typeof console.error === 'function') {
  43   console.error(
  44     'This browser lacks typed array (Uint8Array) support which is required by ' +
  45     '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
  46   )
  47 }
  48
  49 function typedArraySupport () {
  50   // Can typed array instances can be augmented?
  51   try {
  52     var arr = new Uint8Array(1)
  53     var proto = { foo: function () { return 42 } }
  54     Object.setPrototypeOf(proto, Uint8Array.prototype)
  55     Object.setPrototypeOf(arr, proto)
  56     return arr.foo() === 42
  57   } catch (e) {
  58     return false
  59   }
  60 }
  61
  62 Object.defineProperty(Buffer.prototype, 'parent', {
  63   enumerable: true,
  64   get: function () {
  65     if (!Buffer.isBuffer(this)) return undefined
  66     return this.buffer
  67   }
  68 })
  69
  70 Object.defineProperty(Buffer.prototype, 'offset', {
  71   enumerable: true,
  72   get: function () {
  73     if (!Buffer.isBuffer(this)) return undefined
  74     return this.byteOffset
  75   }
  76 })
  77
  78 function createBuffer (length) {
  79   if (length > K_MAX_LENGTH) {
  80     throw new RangeError('The value "' + length + '" is invalid for option "size"')
  81   }
  82   // Return an augmented `Uint8Array` instance
  83   var buf = new Uint8Array(length)
  84   Object.setPrototypeOf(buf, Buffer.prototype)
  85   return buf
  86 }
  87
  88 /**
  89  * The Buffer constructor returns instances of `Uint8Array` that have their
  90  * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
  91  * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
  92  * and the `Uint8Array` methods. Square bracket notation works as expected -- it
  93  * returns a single octet.
  94  *
  95  * The `Uint8Array` prototype remains unmodified.
  96  */
  97
  98 function Buffer (arg, encodingOrOffset, length) {
  99   // Common case.
 100   if (typeof arg === 'number') {
 101     if (typeof encodingOrOffset === 'string') {
 102       throw new TypeError(
 103         'The "string" argument must be of type string. Received type number'
 104       )
 105     }
 106     return allocUnsafe(arg)
 107   }
 108   return from(arg, encodingOrOffset, length)
 109 }
 110
 111 Buffer.poolSize = 8192 // not used by this implementation
 112
 113 function from (value, encodingOrOffset, length) {
 114   if (typeof value === 'string') {
 115     return fromString(value, encodingOrOffset)
 116   }
 117
 118   if (ArrayBuffer.isView(value)) {
 119     return fromArrayView(value)
 120   }
 121
 122   if (value == null) {
 123     throw new TypeError(
 124       'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
 125       'or Array-like Object. Received type ' + (typeof value)
 126     )
 127   }
 128
 129   if (isInstance(value, ArrayBuffer) ||
 130       (value && isInstance(value.buffer, ArrayBuffer))) {
 131     return fromArrayBuffer(value, encodingOrOffset, length)
 132   }
 133
 134   if (typeof SharedArrayBuffer !== 'undefined' &&
 135       (isInstance(value, SharedArrayBuffer) ||
 136       (value && isInstance(value.buffer, SharedArrayBuffer)))) {
 137     return fromArrayBuffer(value, encodingOrOffset, length)
 138   }
 139
 140   if (typeof value === 'number') {
 141     throw new TypeError(
 142       'The "value" argument must not be of type number. Received type number'
 143     )
 144   }
 145
 146   var valueOf = value.valueOf && value.valueOf()
 147   if (valueOf != null && valueOf !== value) {
 148     return Buffer.from(valueOf, encodingOrOffset, length)
 149   }
 150
 151   var b = fromObject(value)
 152   if (b) return b
 153
 154   if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
 155       typeof value[Symbol.toPrimitive] === 'function') {
 156     return Buffer.from(
 157       value[Symbol.toPrimitive]('string'), encodingOrOffset, length
 158     )
 159   }
 160
 161   throw new TypeError(
 162     'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
 163     'or Array-like Object. Received type ' + (typeof value)
 164   )
 165 }
 166
 167 /**
 168  * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 169  * if value is a number.
 170  * Buffer.from(str[, encoding])
 171  * Buffer.from(array)
 172  * Buffer.from(buffer)
 173  * Buffer.from(arrayBuffer[, byteOffset[, length]])
 174  **/
 175 Buffer.from = function (value, encodingOrOffset, length) {
 176   return from(value, encodingOrOffset, length)
 177 }
 178
 179 // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
 180 // https://github.com/feross/buffer/pull/148
 181 Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)
 182 Object.setPrototypeOf(Buffer, Uint8Array)
 183
 184 function assertSize (size) {
 185   if (typeof size !== 'number') {
 186     throw new TypeError('"size" argument must be of type number')
 187   } else if (size < 0) {
 188     throw new RangeError('The value "' + size + '" is invalid for option "size"')
 189   }
 190 }
 191
 192 function alloc (size, fill, encoding) {
 193   assertSize(size)
 194   if (size <= 0) {
 195     return createBuffer(size)
 196   }
 197   if (fill !== undefined) {
 198     // Only pay attention to encoding if it's a string. This
 199     // prevents accidentally sending in a number that would
 200     // be interpreted as a start offset.
 201     return typeof encoding === 'string'
 202       ? createBuffer(size).fill(fill, encoding)
 203       : createBuffer(size).fill(fill)
 204   }
 205   return createBuffer(size)
 206 }
 207
 208 /**
 209  * Creates a new filled Buffer instance.
 210  * alloc(size[, fill[, encoding]])
 211  **/
 212 Buffer.alloc = function (size, fill, encoding) {
 213   return alloc(size, fill, encoding)
 214 }
 215
 216 function allocUnsafe (size) {
 217   assertSize(size)
 218   return createBuffer(size < 0 ? 0 : checked(size) | 0)
 219 }
 220
 221 /**
 222  * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 223  * */
 224 Buffer.allocUnsafe = function (size) {
 225   return allocUnsafe(size)
 226 }
 227 /**
 228  * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 229  */
 230 Buffer.allocUnsafeSlow = function (size) {
 231   return allocUnsafe(size)
 232 }
 233
 234 function fromString (string, encoding) {
 235   if (typeof encoding !== 'string' || encoding === '') {
 236     encoding = 'utf8'
 237   }
 238
 239   if (!Buffer.isEncoding(encoding)) {
 240     throw new TypeError('Unknown encoding: ' + encoding)
 241   }
 242
 243   var length = byteLength(string, encoding) | 0
 244   var buf = createBuffer(length)
 245
 246   var actual = buf.write(string, encoding)
 247
 248   if (actual !== length) {
 249     // Writing a hex string, for example, that contains invalid characters will
 250     // cause everything after the first invalid character to be ignored. (e.g.
 251     // 'abxxcd' will be treated as 'ab')
 252     buf = buf.slice(0, actual)
 253   }
 254
 255   return buf
 256 }
 257
 258 function fromArrayLike (array) {
 259   var length = array.length < 0 ? 0 : checked(array.length) | 0
 260   var buf = createBuffer(length)
 261   for (var i = 0; i < length; i += 1) {
 262     buf[i] = array[i] & 255
 263   }
 264   return buf
 265 }
 266
 267 function fromArrayView (arrayView) {
 268   if (isInstance(arrayView, Uint8Array)) {
 269     var copy = new Uint8Array(arrayView)
 270     return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)
 271   }
 272   return fromArrayLike(arrayView)
 273 }
 274
 275 function fromArrayBuffer (array, byteOffset, length) {
 276   if (byteOffset < 0 || array.byteLength < byteOffset) {
 277     throw new RangeError('"offset" is outside of buffer bounds')
 278   }
 279
 280   if (array.byteLength < byteOffset + (length || 0)) {
 281     throw new RangeError('"length" is outside of buffer bounds')
 282   }
 283
 284   var buf
 285   if (byteOffset === undefined && length === undefined) {
 286     buf = new Uint8Array(array)
 287   } else if (length === undefined) {
 288     buf = new Uint8Array(array, byteOffset)
 289   } else {
 290     buf = new Uint8Array(array, byteOffset, length)
 291   }
 292
 293   // Return an augmented `Uint8Array` instance
 294   Object.setPrototypeOf(buf, Buffer.prototype)
 295
 296   return buf
 297 }
 298
 299 function fromObject (obj) {
 300   if (Buffer.isBuffer(obj)) {
 301     var len = checked(obj.length) | 0
 302     var buf = createBuffer(len)
 303
 304     if (buf.length === 0) {
 305       return buf
 306     }
 307
 308     obj.copy(buf, 0, 0, len)
 309     return buf
 310   }
 311
 312   if (obj.length !== undefined) {
 313     if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
 314       return createBuffer(0)
 315     }
 316     return fromArrayLike(obj)
 317   }
 318
 319   if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
 320     return fromArrayLike(obj.data)
 321   }
 322 }
 323
 324 function checked (length) {
 325   // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
 326   // length is NaN (which is otherwise coerced to zero.)
 327   if (length >= K_MAX_LENGTH) {
 328     throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
 329                          'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
 330   }
 331   return length | 0
 332 }
 333
 334 function SlowBuffer (length) {
 335   if (+length != length) { // eslint-disable-line eqeqeq
 336     length = 0
 337   }
 338   return Buffer.alloc(+length)
 339 }
 340
 341 Buffer.isBuffer = function isBuffer (b) {
 342   return b != null && b._isBuffer === true &&
 343     b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
 344 }
 345
 346 Buffer.compare = function compare (a, b) {
 347   if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
 348   if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
 349   if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
 350     throw new TypeError(
 351       'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
 352     )
 353   }
 354
 355   if (a === b) return 0
 356
 357   var x = a.length
 358   var y = b.length
 359
 360   for (var i = 0, len = Math.min(x, y); i < len; ++i) {
 361     if (a[i] !== b[i]) {
 362       x = a[i]
 363       y = b[i]
 364       break
 365     }
 366   }
 367
 368   if (x < y) return -1
 369   if (y < x) return 1
 370   return 0
 371 }
 372
 373 Buffer.isEncoding = function isEncoding (encoding) {
 374   switch (String(encoding).toLowerCase()) {
 375     case 'hex':
 376     case 'utf8':
 377     case 'utf-8':
 378     case 'ascii':
 379     case 'latin1':
 380     case 'binary':
 381     case 'base64':
 382     case 'ucs2':
 383     case 'ucs-2':
 384     case 'utf16le':
 385     case 'utf-16le':
 386       return true
 387     default:
 388       return false
 389   }
 390 }
 391
 392 Buffer.concat = function concat (list, length) {
 393   if (!Array.isArray(list)) {
 394     throw new TypeError('"list" argument must be an Array of Buffers')
 395   }
 396
 397   if (list.length === 0) {
 398     return Buffer.alloc(0)
 399   }
 400
 401   var i
 402   if (length === undefined) {
 403     length = 0
 404     for (i = 0; i < list.length; ++i) {
 405       length += list[i].length
 406     }
 407   }
 408
 409   var buffer = Buffer.allocUnsafe(length)
 410   var pos = 0
 411   for (i = 0; i < list.length; ++i) {
 412     var buf = list[i]
 413     if (isInstance(buf, Uint8Array)) {
 414       if (pos + buf.length > buffer.length) {
 415         Buffer.from(buf).copy(buffer, pos)
 416       } else {
 417         Uint8Array.prototype.set.call(
 418           buffer,
 419           buf,
 420           pos
 421         )
 422       }
 423     } else if (!Buffer.isBuffer(buf)) {
 424       throw new TypeError('"list" argument must be an Array of Buffers')
 425     } else {
 426       buf.copy(buffer, pos)
 427     }
 428     pos += buf.length
 429   }
 430   return buffer
 431 }
 432
 433 function byteLength (string, encoding) {
 434   if (Buffer.isBuffer(string)) {
 435     return string.length
 436   }
 437   if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
 438     return string.byteLength
 439   }
 440   if (typeof string !== 'string') {
 441     throw new TypeError(
 442       'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
 443       'Received type ' + typeof string
 444     )
 445   }
 446
 447   var len = string.length
 448   var mustMatch = (arguments.length > 2 && arguments[2] === true)
 449   if (!mustMatch && len === 0) return 0
 450
 451   // Use a for loop to avoid recursion
 452   var loweredCase = false
 453   for (;;) {
 454     switch (encoding) {
 455       case 'ascii':
 456       case 'latin1':
 457       case 'binary':
 458         return len
 459       case 'utf8':
 460       case 'utf-8':
 461         return utf8ToBytes(string).length
 462       case 'ucs2':
 463       case 'ucs-2':
 464       case 'utf16le':
 465       case 'utf-16le':
 466         return len * 2
 467       case 'hex':
 468         return len >>> 1
 469       case 'base64':
 470         return base64ToBytes(string).length
 471       default:
 472         if (loweredCase) {
 473           return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
 474         }
 475         encoding = ('' + encoding).toLowerCase()
 476         loweredCase = true
 477     }
 478   }
 479 }
 480 Buffer.byteLength = byteLength
 481
 482 function slowToString (encoding, start, end) {
 483   var loweredCase = false
 484
 485   // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
 486   // property of a typed array.
 487
 488   // This behaves neither like String nor Uint8Array in that we set start/end
 489   // to their upper/lower bounds if the value passed is out of range.
 490   // undefined is handled specially as per ECMA-262 6th Edition,
 491   // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
 492   if (start === undefined || start < 0) {
 493     start = 0
 494   }
 495   // Return early if start > this.length. Done here to prevent potential uint32
 496   // coercion fail below.
 497   if (start > this.length) {
 498     return ''
 499   }
 500
 501   if (end === undefined || end > this.length) {
 502     end = this.length
 503   }
 504
 505   if (end <= 0) {
 506     return ''
 507   }
 508
 509   // Force coercion to uint32. This will also coerce falsey/NaN values to 0.
 510   end >>>= 0
 511   start >>>= 0
 512
 513   if (end <= start) {
 514     return ''
 515   }
 516
 517   if (!encoding) encoding = 'utf8'
 518
 519   while (true) {
 520     switch (encoding) {
 521       case 'hex':
 522         return hexSlice(this, start, end)
 523
 524       case 'utf8':
 525       case 'utf-8':
 526         return utf8Slice(this, start, end)
 527
 528       case 'ascii':
 529         return asciiSlice(this, start, end)
 530
 531       case 'latin1':
 532       case 'binary':
 533         return latin1Slice(this, start, end)
 534
 535       case 'base64':
 536         return base64Slice(this, start, end)
 537
 538       case 'ucs2':
 539       case 'ucs-2':
 540       case 'utf16le':
 541       case 'utf-16le':
 542         return utf16leSlice(this, start, end)
 543
 544       default:
 545         if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
 546         encoding = (encoding + '').toLowerCase()
 547         loweredCase = true
 548     }
 549   }
 550 }
 551
 552 // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
 553 // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
 554 // reliably in a browserify context because there could be multiple different
 555 // copies of the 'buffer' package in use. This method works even for Buffer
 556 // instances that were created from another copy of the `buffer` package.
 557 // See: https://github.com/feross/buffer/issues/154
 558 Buffer.prototype._isBuffer = true
 559
 560 function swap (b, n, m) {
 561   var i = b[n]
 562   b[n] = b[m]
 563   b[m] = i
 564 }
 565
 566 Buffer.prototype.swap16 = function swap16 () {
 567   var len = this.length
 568   if (len % 2 !== 0) {
 569     throw new RangeError('Buffer size must be a multiple of 16-bits')
 570   }
 571   for (var i = 0; i < len; i += 2) {
 572     swap(this, i, i + 1)
 573   }
 574   return this
 575 }
 576
 577 Buffer.prototype.swap32 = function swap32 () {
 578   var len = this.length
 579   if (len % 4 !== 0) {
 580     throw new RangeError('Buffer size must be a multiple of 32-bits')
 581   }
 582   for (var i = 0; i < len; i += 4) {
 583     swap(this, i, i + 3)
 584     swap(this, i + 1, i + 2)
 585   }
 586   return this
 587 }
 588
 589 Buffer.prototype.swap64 = function swap64 () {
 590   var len = this.length
 591   if (len % 8 !== 0) {
 592     throw new RangeError('Buffer size must be a multiple of 64-bits')
 593   }
 594   for (var i = 0; i < len; i += 8) {
 595     swap(this, i, i + 7)
 596     swap(this, i + 1, i + 6)
 597     swap(this, i + 2, i + 5)
 598     swap(this, i + 3, i + 4)
 599   }
 600   return this
 601 }
 602
 603 Buffer.prototype.toString = function toString () {
 604   var length = this.length
 605   if (length === 0) return ''
 606   if (arguments.length === 0) return utf8Slice(this, 0, length)
 607   return slowToString.apply(this, arguments)
 608 }
 609
 610 Buffer.prototype.toLocaleString = Buffer.prototype.toString
 611
 612 Buffer.prototype.equals = function equals (b) {
 613   if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
 614   if (this === b) return true
 615   return Buffer.compare(this, b) === 0
 616 }
 617
 618 Buffer.prototype.inspect = function inspect () {
 619   var str = ''
 620   var max = exports.INSPECT_MAX_BYTES
 621   str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
 622   if (this.length > max) str += ' ... '
 623   return '<Buffer ' + str + '>'
 624 }
 625 if (customInspectSymbol) {
 626   Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect
 627 }
 628
 629 Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
 630   if (isInstance(target, Uint8Array)) {
 631     target = Buffer.from(target, target.offset, target.byteLength)
 632   }
 633   if (!Buffer.isBuffer(target)) {
 634     throw new TypeError(
 635       'The "target" argument must be one of type Buffer or Uint8Array. ' +
 636       'Received type ' + (typeof target)
 637     )
 638   }
 639
 640   if (start === undefined) {
 641     start = 0
 642   }
 643   if (end === undefined) {
 644     end = target ? target.length : 0
 645   }
 646   if (thisStart === undefined) {
 647     thisStart = 0
 648   }
 649   if (thisEnd === undefined) {
 650     thisEnd = this.length
 651   }
 652
 653   if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
 654     throw new RangeError('out of range index')
 655   }
 656
 657   if (thisStart >= thisEnd && start >= end) {
 658     return 0
 659   }
 660   if (thisStart >= thisEnd) {
 661     return -1
 662   }
 663   if (start >= end) {
 664     return 1
 665   }
 666
 667   start >>>= 0
 668   end >>>= 0
 669   thisStart >>>= 0
 670   thisEnd >>>= 0
 671
 672   if (this === target) return 0
 673
 674   var x = thisEnd - thisStart
 675   var y = end - start
 676   var len = Math.min(x, y)
 677
 678   var thisCopy = this.slice(thisStart, thisEnd)
 679   var targetCopy = target.slice(start, end)
 680
 681   for (var i = 0; i < len; ++i) {
 682     if (thisCopy[i] !== targetCopy[i]) {
 683       x = thisCopy[i]
 684       y = targetCopy[i]
 685       break
 686     }
 687   }
 688
 689   if (x < y) return -1
 690   if (y < x) return 1
 691   return 0
 692 }
 693
 694 // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
 695 // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
 696 //
 697 // Arguments:
 698 // - buffer - a Buffer to search
 699 // - val - a string, Buffer, or number
 700 // - byteOffset - an index into `buffer`; will be clamped to an int32
 701 // - encoding - an optional encoding, relevant is val is a string
 702 // - dir - true for indexOf, false for lastIndexOf
 703 function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
 704   // Empty buffer means no match
 705   if (buffer.length === 0) return -1
 706
 707   // Normalize byteOffset
 708   if (typeof byteOffset === 'string') {
 709     encoding = byteOffset
 710     byteOffset = 0
 711   } else if (byteOffset > 0x7fffffff) {
 712     byteOffset = 0x7fffffff
 713   } else if (byteOffset < -0x80000000) {
 714     byteOffset = -0x80000000
 715   }
 716   byteOffset = +byteOffset // Coerce to Number.
 717   if (numberIsNaN(byteOffset)) {
 718     // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
 719     byteOffset = dir ? 0 : (buffer.length - 1)
 720   }
 721
 722   // Normalize byteOffset: negative offsets start from the end of the buffer
 723   if (byteOffset < 0) byteOffset = buffer.length + byteOffset
 724   if (byteOffset >= buffer.length) {
 725     if (dir) return -1
 726     else byteOffset = buffer.length - 1
 727   } else if (byteOffset < 0) {
 728     if (dir) byteOffset = 0
 729     else return -1
 730   }
 731
 732   // Normalize val
 733   if (typeof val === 'string') {
 734     val = Buffer.from(val, encoding)
 735   }
 736
 737   // Finally, search either indexOf (if dir is true) or lastIndexOf
 738   if (Buffer.isBuffer(val)) {
 739     // Special case: looking for empty string/buffer always fails
 740     if (val.length === 0) {
 741       return -1
 742     }
 743     return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
 744   } else if (typeof val === 'number') {
 745     val = val & 0xFF // Search for a byte value [0-255]
 746     if (typeof Uint8Array.prototype.indexOf === 'function') {
 747       if (dir) {
 748         return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
 749       } else {
 750         return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
 751       }
 752     }
 753     return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
 754   }
 755
 756   throw new TypeError('val must be string, number or Buffer')
 757 }
 758
 759 function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
 760   var indexSize = 1
 761   var arrLength = arr.length
 762   var valLength = val.length
 763
 764   if (encoding !== undefined) {
 765     encoding = String(encoding).toLowerCase()
 766     if (encoding === 'ucs2' || encoding === 'ucs-2' ||
 767         encoding === 'utf16le' || encoding === 'utf-16le') {
 768       if (arr.length < 2 || val.length < 2) {
 769         return -1
 770       }
 771       indexSize = 2
 772       arrLength /= 2
 773       valLength /= 2
 774       byteOffset /= 2
 775     }
 776   }
 777
 778   function read (buf, i) {
 779     if (indexSize === 1) {
 780       return buf[i]
 781     } else {
 782       return buf.readUInt16BE(i * indexSize)
 783     }
 784   }
 785
 786   var i
 787   if (dir) {
 788     var foundIndex = -1
 789     for (i = byteOffset; i < arrLength; i++) {
 790       if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
 791         if (foundIndex === -1) foundIndex = i
 792         if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
 793       } else {
 794         if (foundIndex !== -1) i -= i - foundIndex
 795         foundIndex = -1
 796       }
 797     }
 798   } else {
 799     if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
 800     for (i = byteOffset; i >= 0; i--) {
 801       var found = true
 802       for (var j = 0; j < valLength; j++) {
 803         if (read(arr, i + j) !== read(val, j)) {
 804           found = false
 805           break
 806         }
 807       }
 808       if (found) return i
 809     }
 810   }
 811
 812   return -1
 813 }
 814
 815 Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
 816   return this.indexOf(val, byteOffset, encoding) !== -1
 817 }
 818
 819 Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
 820   return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
 821 }
 822
 823 Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
 824   return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
 825 }
 826
 827 function hexWrite (buf, string, offset, length) {
 828   offset = Number(offset) || 0
 829   var remaining = buf.length - offset
 830   if (!length) {
 831     length = remaining
 832   } else {
 833     length = Number(length)
 834     if (length > remaining) {
 835       length = remaining
 836     }
 837   }
 838
 839   var strLen = string.length
 840
 841   if (length > strLen / 2) {
 842     length = strLen / 2
 843   }
 844   for (var i = 0; i < length; ++i) {
 845     var parsed = parseInt(string.substr(i * 2, 2), 16)
 846     if (numberIsNaN(parsed)) return i
 847     buf[offset + i] = parsed
 848   }
 849   return i
 850 }
 851
 852 function utf8Write (buf, string, offset, length) {
 853   return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
 854 }
 855
 856 function asciiWrite (buf, string, offset, length) {
 857   return blitBuffer(asciiToBytes(string), buf, offset, length)
 858 }
 859
 860 function base64Write (buf, string, offset, length) {
 861   return blitBuffer(base64ToBytes(string), buf, offset, length)
 862 }
 863
 864 function ucs2Write (buf, string, offset, length) {
 865   return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
 866 }
 867
 868 Buffer.prototype.write = function write (string, offset, length, encoding) {
 869   // Buffer#write(string)
 870   if (offset === undefined) {
 871     encoding = 'utf8'
 872     length = this.length
 873     offset = 0
 874   // Buffer#write(string, encoding)
 875   } else if (length === undefined && typeof offset === 'string') {
 876     encoding = offset
 877     length = this.length
 878     offset = 0
 879   // Buffer#write(string, offset[, length][, encoding])
 880   } else if (isFinite(offset)) {
 881     offset = offset >>> 0
 882     if (isFinite(length)) {
 883       length = length >>> 0
 884       if (encoding === undefined) encoding = 'utf8'
 885     } else {
 886       encoding = length
 887       length = undefined
 888     }
 889   } else {
 890     throw new Error(
 891       'Buffer.write(string, encoding, offset[, length]) is no longer supported'
 892     )
 893   }
 894
 895   var remaining = this.length - offset
 896   if (length === undefined || length > remaining) length = remaining
 897
 898   if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
 899     throw new RangeError('Attempt to write outside buffer bounds')
 900   }
 901
 902   if (!encoding) encoding = 'utf8'
 903
 904   var loweredCase = false
 905   for (;;) {
 906     switch (encoding) {
 907       case 'hex':
 908         return hexWrite(this, string, offset, length)
 909
 910       case 'utf8':
 911       case 'utf-8':
 912         return utf8Write(this, string, offset, length)
 913
 914       case 'ascii':
 915       case 'latin1':
 916       case 'binary':
 917         return asciiWrite(this, string, offset, length)
 918
 919       case 'base64':
 920         // Warning: maxLength not taken into account in base64Write
 921         return base64Write(this, string, offset, length)
 922
 923       case 'ucs2':
 924       case 'ucs-2':
 925       case 'utf16le':
 926       case 'utf-16le':
 927         return ucs2Write(this, string, offset, length)
 928
 929       default:
 930         if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
 931         encoding = ('' + encoding).toLowerCase()
 932         loweredCase = true
 933     }
 934   }
 935 }
 936
 937 Buffer.prototype.toJSON = function toJSON () {
 938   return {
 939     type: 'Buffer',
 940     data: Array.prototype.slice.call(this._arr || this, 0)
 941   }
 942 }
 943
 944 function base64Slice (buf, start, end) {
 945   if (start === 0 && end === buf.length) {
 946     return base64.fromByteArray(buf)
 947   } else {
 948     return base64.fromByteArray(buf.slice(start, end))
 949   }
 950 }
 951
 952 function utf8Slice (buf, start, end) {
 953   end = Math.min(buf.length, end)
 954   var res = []
 955
 956   var i = start
 957   while (i < end) {
 958     var firstByte = buf[i]
 959     var codePoint = null
 960     var bytesPerSequence = (firstByte > 0xEF)
 961       ? 4
 962       : (firstByte > 0xDF)
 963           ? 3
 964           : (firstByte > 0xBF)
 965               ? 2
 966               : 1
 967
 968     if (i + bytesPerSequence <= end) {
 969       var secondByte, thirdByte, fourthByte, tempCodePoint
 970
 971       switch (bytesPerSequence) {
 972         case 1:
 973           if (firstByte < 0x80) {
 974             codePoint = firstByte
 975           }
 976           break
 977         case 2:
 978           secondByte = buf[i + 1]
 979           if ((secondByte & 0xC0) === 0x80) {
 980             tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
 981             if (tempCodePoint > 0x7F) {
 982               codePoint = tempCodePoint
 983             }
 984           }
 985           break
 986         case 3:
 987           secondByte = buf[i + 1]
 988           thirdByte = buf[i + 2]
 989           if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
 990             tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
 991             if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
 992               codePoint = tempCodePoint
 993             }
 994           }
 995           break
 996         case 4:
 997           secondByte = buf[i + 1]
 998           thirdByte = buf[i + 2]
 999           fourthByte = buf[i + 3]
1000           if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
1001             tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
1002             if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
1003               codePoint = tempCodePoint
1004             }
1005           }
1006       }
1007     }
1008
1009     if (codePoint === null) {
1010       // we did not generate a valid codePoint so insert a
1011       // replacement char (U+FFFD) and advance only 1 byte
1012       codePoint = 0xFFFD
1013       bytesPerSequence = 1
1014     } else if (codePoint > 0xFFFF) {
1015       // encode to utf16 (surrogate pair dance)
1016       codePoint -= 0x10000
1017       res.push(codePoint >>> 10 & 0x3FF | 0xD800)
1018       codePoint = 0xDC00 | codePoint & 0x3FF
1019     }
1020
1021     res.push(codePoint)
1022     i += bytesPerSequence
1023   }
1024
1025   return decodeCodePointsArray(res)
1026 }
1027
1028 // Based on http://stackoverflow.com/a/22747272/680742, the browser with
1029 // the lowest limit is Chrome, with 0x10000 args.
1030 // We go 1 magnitude less, for safety
1031 var MAX_ARGUMENTS_LENGTH = 0x1000
1032
1033 function decodeCodePointsArray (codePoints) {
1034   var len = codePoints.length
1035   if (len <= MAX_ARGUMENTS_LENGTH) {
1036     return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
1037   }
1038
1039   // Decode in chunks to avoid "call stack size exceeded".
1040   var res = ''
1041   var i = 0
1042   while (i < len) {
1043     res += String.fromCharCode.apply(
1044       String,
1045       codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
1046     )
1047   }
1048   return res
1049 }
1050
1051 function asciiSlice (buf, start, end) {
1052   var ret = ''
1053   end = Math.min(buf.length, end)
1054
1055   for (var i = start; i < end; ++i) {
1056     ret += String.fromCharCode(buf[i] & 0x7F)
1057   }
1058   return ret
1059 }
1060
1061 function latin1Slice (buf, start, end) {
1062   var ret = ''
1063   end = Math.min(buf.length, end)
1064
1065   for (var i = start; i < end; ++i) {
1066     ret += String.fromCharCode(buf[i])
1067   }
1068   return ret
1069 }
1070
1071 function hexSlice (buf, start, end) {
1072   var len = buf.length
1073
1074   if (!start || start < 0) start = 0
1075   if (!end || end < 0 || end > len) end = len
1076
1077   var out = ''
1078   for (var i = start; i < end; ++i) {
1079     out += hexSliceLookupTable[buf[i]]
1080   }
1081   return out
1082 }
1083
1084 function utf16leSlice (buf, start, end) {
1085   var bytes = buf.slice(start, end)
1086   var res = ''
1087   // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)
1088   for (var i = 0; i < bytes.length - 1; i += 2) {
1089     res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
1090   }
1091   return res
1092 }
1093
1094 Buffer.prototype.slice = function slice (start, end) {
1095   var len = this.length
1096   start = ~~start
1097   end = end === undefined ? len : ~~end
1098
1099   if (start < 0) {
1100     start += len
1101     if (start < 0) start = 0
1102   } else if (start > len) {
1103     start = len
1104   }
1105
1106   if (end < 0) {
1107     end += len
1108     if (end < 0) end = 0
1109   } else if (end > len) {
1110     end = len
1111   }
1112
1113   if (end < start) end = start
1114
1115   var newBuf = this.subarray(start, end)
1116   // Return an augmented `Uint8Array` instance
1117   Object.setPrototypeOf(newBuf, Buffer.prototype)
1118
1119   return newBuf
1120 }
1121
1122 /*
1123  * Need to make sure that buffer isn't trying to write out of bounds.
1124  */
1125 function checkOffset (offset, ext, length) {
1126   if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
1127   if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
1128 }
1129
1130 Buffer.prototype.readUintLE =
1131 Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
1132   offset = offset >>> 0
1133   byteLength = byteLength >>> 0
1134   if (!noAssert) checkOffset(offset, byteLength, this.length)
1135
1136   var val = this[offset]
1137   var mul = 1
1138   var i = 0
1139   while (++i < byteLength && (mul *= 0x100)) {
1140     val += this[offset + i] * mul
1141   }
1142
1143   return val
1144 }
1145
1146 Buffer.prototype.readUintBE =
1147 Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
1148   offset = offset >>> 0
1149   byteLength = byteLength >>> 0
1150   if (!noAssert) {
1151     checkOffset(offset, byteLength, this.length)
1152   }
1153
1154   var val = this[offset + --byteLength]
1155   var mul = 1
1156   while (byteLength > 0 && (mul *= 0x100)) {
1157     val += this[offset + --byteLength] * mul
1158   }
1159
1160   return val
1161 }
1162
1163 Buffer.prototype.readUint8 =
1164 Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
1165   offset = offset >>> 0
1166   if (!noAssert) checkOffset(offset, 1, this.length)
1167   return this[offset]
1168 }
1169
1170 Buffer.prototype.readUint16LE =
1171 Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
1172   offset = offset >>> 0
1173   if (!noAssert) checkOffset(offset, 2, this.length)
1174   return this[offset] | (this[offset + 1] << 8)
1175 }
1176
1177 Buffer.prototype.readUint16BE =
1178 Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
1179   offset = offset >>> 0
1180   if (!noAssert) checkOffset(offset, 2, this.length)
1181   return (this[offset] << 8) | this[offset + 1]
1182 }
1183
1184 Buffer.prototype.readUint32LE =
1185 Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
1186   offset = offset >>> 0
1187   if (!noAssert) checkOffset(offset, 4, this.length)
1188
1189   return ((this[offset]) |
1190       (this[offset + 1] << 8) |
1191       (this[offset + 2] << 16)) +
1192       (this[offset + 3] * 0x1000000)
1193 }
1194
1195 Buffer.prototype.readUint32BE =
1196 Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
1197   offset = offset >>> 0
1198   if (!noAssert) checkOffset(offset, 4, this.length)
1199
1200   return (this[offset] * 0x1000000) +
1201     ((this[offset + 1] << 16) |
1202     (this[offset + 2] << 8) |
1203     this[offset + 3])
1204 }
1205
1206 Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
1207   offset = offset >>> 0
1208   byteLength = byteLength >>> 0
1209   if (!noAssert) checkOffset(offset, byteLength, this.length)
1210
1211   var val = this[offset]
1212   var mul = 1
1213   var i = 0
1214   while (++i < byteLength && (mul *= 0x100)) {
1215     val += this[offset + i] * mul
1216   }
1217   mul *= 0x80
1218
1219   if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1220
1221   return val
1222 }
1223
1224 Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
1225   offset = offset >>> 0
1226   byteLength = byteLength >>> 0
1227   if (!noAssert) checkOffset(offset, byteLength, this.length)
1228
1229   var i = byteLength
1230   var mul = 1
1231   var val = this[offset + --i]
1232   while (i > 0 && (mul *= 0x100)) {
1233     val += this[offset + --i] * mul
1234   }
1235   mul *= 0x80
1236
1237   if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1238
1239   return val
1240 }
1241
1242 Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
1243   offset = offset >>> 0
1244   if (!noAssert) checkOffset(offset, 1, this.length)
1245   if (!(this[offset] & 0x80)) return (this[offset])
1246   return ((0xff - this[offset] + 1) * -1)
1247 }
1248
1249 Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
1250   offset = offset >>> 0
1251   if (!noAssert) checkOffset(offset, 2, this.length)
1252   var val = this[offset] | (this[offset + 1] << 8)
1253   return (val & 0x8000) ? val | 0xFFFF0000 : val
1254 }
1255
1256 Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
1257   offset = offset >>> 0
1258   if (!noAssert) checkOffset(offset, 2, this.length)
1259   var val = this[offset + 1] | (this[offset] << 8)
1260   return (val & 0x8000) ? val | 0xFFFF0000 : val
1261 }
1262
1263 Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
1264   offset = offset >>> 0
1265   if (!noAssert) checkOffset(offset, 4, this.length)
1266
1267   return (this[offset]) |
1268     (this[offset + 1] << 8) |
1269     (this[offset + 2] << 16) |
1270     (this[offset + 3] << 24)
1271 }
1272
1273 Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
1274   offset = offset >>> 0
1275   if (!noAssert) checkOffset(offset, 4, this.length)
1276
1277   return (this[offset] << 24) |
1278     (this[offset + 1] << 16) |
1279     (this[offset + 2] << 8) |
1280     (this[offset + 3])
1281 }
1282
1283 Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
1284   offset = offset >>> 0
1285   if (!noAssert) checkOffset(offset, 4, this.length)
1286   return ieee754.read(this, offset, true, 23, 4)
1287 }
1288
1289 Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
1290   offset = offset >>> 0
1291   if (!noAssert) checkOffset(offset, 4, this.length)
1292   return ieee754.read(this, offset, false, 23, 4)
1293 }
1294
1295 Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
1296   offset = offset >>> 0
1297   if (!noAssert) checkOffset(offset, 8, this.length)
1298   return ieee754.read(this, offset, true, 52, 8)
1299 }
1300
1301 Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
1302   offset = offset >>> 0
1303   if (!noAssert) checkOffset(offset, 8, this.length)
1304   return ieee754.read(this, offset, false, 52, 8)
1305 }
1306
1307 function checkInt (buf, value, offset, ext, max, min) {
1308   if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
1309   if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
1310   if (offset + ext > buf.length) throw new RangeError('Index out of range')
1311 }
1312
1313 Buffer.prototype.writeUintLE =
1314 Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
1315   value = +value
1316   offset = offset >>> 0
1317   byteLength = byteLength >>> 0
1318   if (!noAssert) {
1319     var maxBytes = Math.pow(2, 8 * byteLength) - 1
1320     checkInt(this, value, offset, byteLength, maxBytes, 0)
1321   }
1322
1323   var mul = 1
1324   var i = 0
1325   this[offset] = value & 0xFF
1326   while (++i < byteLength && (mul *= 0x100)) {
1327     this[offset + i] = (value / mul) & 0xFF
1328   }
1329
1330   return offset + byteLength
1331 }
1332
1333 Buffer.prototype.writeUintBE =
1334 Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
1335   value = +value
1336   offset = offset >>> 0
1337   byteLength = byteLength >>> 0
1338   if (!noAssert) {
1339     var maxBytes = Math.pow(2, 8 * byteLength) - 1
1340     checkInt(this, value, offset, byteLength, maxBytes, 0)
1341   }
1342
1343   var i = byteLength - 1
1344   var mul = 1
1345   this[offset + i] = value & 0xFF
1346   while (--i >= 0 && (mul *= 0x100)) {
1347     this[offset + i] = (value / mul) & 0xFF
1348   }
1349
1350   return offset + byteLength
1351 }
1352
1353 Buffer.prototype.writeUint8 =
1354 Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
1355   value = +value
1356   offset = offset >>> 0
1357   if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
1358   this[offset] = (value & 0xff)
1359   return offset + 1
1360 }
1361
1362 Buffer.prototype.writeUint16LE =
1363 Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
1364   value = +value
1365   offset = offset >>> 0
1366   if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1367   this[offset] = (value & 0xff)
1368   this[offset + 1] = (value >>> 8)
1369   return offset + 2
1370 }
1371
1372 Buffer.prototype.writeUint16BE =
1373 Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
1374   value = +value
1375   offset = offset >>> 0
1376   if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1377   this[offset] = (value >>> 8)
1378   this[offset + 1] = (value & 0xff)
1379   return offset + 2
1380 }
1381
1382 Buffer.prototype.writeUint32LE =
1383 Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
1384   value = +value
1385   offset = offset >>> 0
1386   if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1387   this[offset + 3] = (value >>> 24)
1388   this[offset + 2] = (value >>> 16)
1389   this[offset + 1] = (value >>> 8)
1390   this[offset] = (value & 0xff)
1391   return offset + 4
1392 }
1393
1394 Buffer.prototype.writeUint32BE =
1395 Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
1396   value = +value
1397   offset = offset >>> 0
1398   if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1399   this[offset] = (value >>> 24)
1400   this[offset + 1] = (value >>> 16)
1401   this[offset + 2] = (value >>> 8)
1402   this[offset + 3] = (value & 0xff)
1403   return offset + 4
1404 }
1405
1406 Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
1407   value = +value
1408   offset = offset >>> 0
1409   if (!noAssert) {
1410     var limit = Math.pow(2, (8 * byteLength) - 1)
1411
1412     checkInt(this, value, offset, byteLength, limit - 1, -limit)
1413   }
1414
1415   var i = 0
1416   var mul = 1
1417   var sub = 0
1418   this[offset] = value & 0xFF
1419   while (++i < byteLength && (mul *= 0x100)) {
1420     if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
1421       sub = 1
1422     }
1423     this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1424   }
1425
1426   return offset + byteLength
1427 }
1428
1429 Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
1430   value = +value
1431   offset = offset >>> 0
1432   if (!noAssert) {
1433     var limit = Math.pow(2, (8 * byteLength) - 1)
1434
1435     checkInt(this, value, offset, byteLength, limit - 1, -limit)
1436   }
1437
1438   var i = byteLength - 1
1439   var mul = 1
1440   var sub = 0
1441   this[offset + i] = value & 0xFF
1442   while (--i >= 0 && (mul *= 0x100)) {
1443     if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
1444       sub = 1
1445     }
1446     this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1447   }
1448
1449   return offset + byteLength
1450 }
1451
1452 Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
1453   value = +value
1454   offset = offset >>> 0
1455   if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
1456   if (value < 0) value = 0xff + value + 1
1457   this[offset] = (value & 0xff)
1458   return offset + 1
1459 }
1460
1461 Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
1462   value = +value
1463   offset = offset >>> 0
1464   if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1465   this[offset] = (value & 0xff)
1466   this[offset + 1] = (value >>> 8)
1467   return offset + 2
1468 }
1469
1470 Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
1471   value = +value
1472   offset = offset >>> 0
1473   if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1474   this[offset] = (value >>> 8)
1475   this[offset + 1] = (value & 0xff)
1476   return offset + 2
1477 }
1478
1479 Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
1480   value = +value
1481   offset = offset >>> 0
1482   if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1483   this[offset] = (value & 0xff)
1484   this[offset + 1] = (value >>> 8)
1485   this[offset + 2] = (value >>> 16)
1486   this[offset + 3] = (value >>> 24)
1487   return offset + 4
1488 }
1489
1490 Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
1491   value = +value
1492   offset = offset >>> 0
1493   if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1494   if (value < 0) value = 0xffffffff + value + 1
1495   this[offset] = (value >>> 24)
1496   this[offset + 1] = (value >>> 16)
1497   this[offset + 2] = (value >>> 8)
1498   this[offset + 3] = (value & 0xff)
1499   return offset + 4
1500 }
1501
1502 function checkIEEE754 (buf, value, offset, ext, max, min) {
1503   if (offset + ext > buf.length) throw new RangeError('Index out of range')
1504   if (offset < 0) throw new RangeError('Index out of range')
1505 }
1506
1507 function writeFloat (buf, value, offset, littleEndian, noAssert) {
1508   value = +value
1509   offset = offset >>> 0
1510   if (!noAssert) {
1511     checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
1512   }
1513   ieee754.write(buf, value, offset, littleEndian, 23, 4)
1514   return offset + 4
1515 }
1516
1517 Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
1518   return writeFloat(this, value, offset, true, noAssert)
1519 }
1520
1521 Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
1522   return writeFloat(this, value, offset, false, noAssert)
1523 }
1524
1525 function writeDouble (buf, value, offset, littleEndian, noAssert) {
1526   value = +value
1527   offset = offset >>> 0
1528   if (!noAssert) {
1529     checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
1530   }
1531   ieee754.write(buf, value, offset, littleEndian, 52, 8)
1532   return offset + 8
1533 }
1534
1535 Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
1536   return writeDouble(this, value, offset, true, noAssert)
1537 }
1538
1539 Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
1540   return writeDouble(this, value, offset, false, noAssert)
1541 }
1542
1543 // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
1544 Buffer.prototype.copy = function copy (target, targetStart, start, end) {
1545   if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
1546   if (!start) start = 0
1547   if (!end && end !== 0) end = this.length
1548   if (targetStart >= target.length) targetStart = target.length
1549   if (!targetStart) targetStart = 0
1550   if (end > 0 && end < start) end = start
1551
1552   // Copy 0 bytes; we're done
1553   if (end === start) return 0
1554   if (target.length === 0 || this.length === 0) return 0
1555
1556   // Fatal error conditions
1557   if (targetStart < 0) {
1558     throw new RangeError('targetStart out of bounds')
1559   }
1560   if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
1561   if (end < 0) throw new RangeError('sourceEnd out of bounds')
1562
1563   // Are we oob?
1564   if (end > this.length) end = this.length
1565   if (target.length - targetStart < end - start) {
1566     end = target.length - targetStart + start
1567   }
1568
1569   var len = end - start
1570
1571   if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
1572     // Use built-in when available, missing from IE11
1573     this.copyWithin(targetStart, start, end)
1574   } else {
1575     Uint8Array.prototype.set.call(
1576       target,
1577       this.subarray(start, end),
1578       targetStart
1579     )
1580   }
1581
1582   return len
1583 }
1584
1585 // Usage:
1586 //    buffer.fill(number[, offset[, end]])
1587 //    buffer.fill(buffer[, offset[, end]])
1588 //    buffer.fill(string[, offset[, end]][, encoding])
1589 Buffer.prototype.fill = function fill (val, start, end, encoding) {
1590   // Handle string cases:
1591   if (typeof val === 'string') {
1592     if (typeof start === 'string') {
1593       encoding = start
1594       start = 0
1595       end = this.length
1596     } else if (typeof end === 'string') {
1597       encoding = end
1598       end = this.length
1599     }
1600     if (encoding !== undefined && typeof encoding !== 'string') {
1601       throw new TypeError('encoding must be a string')
1602     }
1603     if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
1604       throw new TypeError('Unknown encoding: ' + encoding)
1605     }
1606     if (val.length === 1) {
1607       var code = val.charCodeAt(0)
1608       if ((encoding === 'utf8' && code < 128) ||
1609           encoding === 'latin1') {
1610         // Fast path: If `val` fits into a single byte, use that numeric value.
1611         val = code
1612       }
1613     }
1614   } else if (typeof val === 'number') {
1615     val = val & 255
1616   } else if (typeof val === 'boolean') {
1617     val = Number(val)
1618   }
1619
1620   // Invalid ranges are not set to a default, so can range check early.
1621   if (start < 0 || this.length < start || this.length < end) {
1622     throw new RangeError('Out of range index')
1623   }
1624
1625   if (end <= start) {
1626     return this
1627   }
1628
1629   start = start >>> 0
1630   end = end === undefined ? this.length : end >>> 0
1631
1632   if (!val) val = 0
1633
1634   var i
1635   if (typeof val === 'number') {
1636     for (i = start; i < end; ++i) {
1637       this[i] = val
1638     }
1639   } else {
1640     var bytes = Buffer.isBuffer(val)
1641       ? val
1642       : Buffer.from(val, encoding)
1643     var len = bytes.length
1644     if (len === 0) {
1645       throw new TypeError('The value "' + val +
1646         '" is invalid for argument "value"')
1647     }
1648     for (i = 0; i < end - start; ++i) {
1649       this[i + start] = bytes[i % len]
1650     }
1651   }
1652
1653   return this
1654 }
1655
1656 // HELPER FUNCTIONS
1657 // ================
1658
1659 var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
1660
1661 function base64clean (str) {
1662   // Node takes equal signs as end of the Base64 encoding
1663   str = str.split('=')[0]
1664   // Node strips out invalid characters like \n and \t from the string, base64-js does not
1665   str = str.trim().replace(INVALID_BASE64_RE, '')
1666   // Node converts strings with length < 2 to ''
1667   if (str.length < 2) return ''
1668   // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
1669   while (str.length % 4 !== 0) {
1670     str = str + '='
1671   }
1672   return str
1673 }
1674
1675 function utf8ToBytes (string, units) {
1676   units = units || Infinity
1677   var codePoint
1678   var length = string.length
1679   var leadSurrogate = null
1680   var bytes = []
1681
1682   for (var i = 0; i < length; ++i) {
1683     codePoint = string.charCodeAt(i)
1684
1685     // is surrogate component
1686     if (codePoint > 0xD7FF && codePoint < 0xE000) {
1687       // last char was a lead
1688       if (!leadSurrogate) {
1689         // no lead yet
1690         if (codePoint > 0xDBFF) {
1691           // unexpected trail
1692           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1693           continue
1694         } else if (i + 1 === length) {
1695           // unpaired lead
1696           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1697           continue
1698         }
1699
1700         // valid lead
1701         leadSurrogate = codePoint
1702
1703         continue
1704       }
1705
1706       // 2 leads in a row
1707       if (codePoint < 0xDC00) {
1708         if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1709         leadSurrogate = codePoint
1710         continue
1711       }
1712
1713       // valid surrogate pair
1714       codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
1715     } else if (leadSurrogate) {
1716       // valid bmp char, but last char was a lead
1717       if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
1718     }
1719
1720     leadSurrogate = null
1721
1722     // encode utf8
1723     if (codePoint < 0x80) {
1724       if ((units -= 1) < 0) break
1725       bytes.push(codePoint)
1726     } else if (codePoint < 0x800) {
1727       if ((units -= 2) < 0) break
1728       bytes.push(
1729         codePoint >> 0x6 | 0xC0,
1730         codePoint & 0x3F | 0x80
1731       )
1732     } else if (codePoint < 0x10000) {
1733       if ((units -= 3) < 0) break
1734       bytes.push(
1735         codePoint >> 0xC | 0xE0,
1736         codePoint >> 0x6 & 0x3F | 0x80,
1737         codePoint & 0x3F | 0x80
1738       )
1739     } else if (codePoint < 0x110000) {
1740       if ((units -= 4) < 0) break
1741       bytes.push(
1742         codePoint >> 0x12 | 0xF0,
1743         codePoint >> 0xC & 0x3F | 0x80,
1744         codePoint >> 0x6 & 0x3F | 0x80,
1745         codePoint & 0x3F | 0x80
1746       )
1747     } else {
1748       throw new Error('Invalid code point')
1749     }
1750   }
1751
1752   return bytes
1753 }
1754
1755 function asciiToBytes (str) {
1756   var byteArray = []
1757   for (var i = 0; i < str.length; ++i) {
1758     // Node's code seems to be doing this and not & 0x7F..
1759     byteArray.push(str.charCodeAt(i) & 0xFF)
1760   }
1761   return byteArray
1762 }
1763
1764 function utf16leToBytes (str, units) {
1765   var c, hi, lo
1766   var byteArray = []
1767   for (var i = 0; i < str.length; ++i) {
1768     if ((units -= 2) < 0) break
1769
1770     c = str.charCodeAt(i)
1771     hi = c >> 8
1772     lo = c % 256
1773     byteArray.push(lo)
1774     byteArray.push(hi)
1775   }
1776
1777   return byteArray
1778 }
1779
1780 function base64ToBytes (str) {
1781   return base64.toByteArray(base64clean(str))
1782 }
1783
1784 function blitBuffer (src, dst, offset, length) {
1785   for (var i = 0; i < length; ++i) {
1786     if ((i + offset >= dst.length) || (i >= src.length)) break
1787     dst[i + offset] = src[i]
1788   }
1789   return i
1790 }
1791
1792 // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
1793 // the `instanceof` check but they should be treated as of that type.
1794 // See: https://github.com/feross/buffer/issues/166
1795 function isInstance (obj, type) {
1796   return obj instanceof type ||
1797     (obj != null && obj.constructor != null && obj.constructor.name != null &&
1798       obj.constructor.name === type.name)
1799 }
1800 function numberIsNaN (obj) {
1801   // For IE11 support
1802   return obj !== obj // eslint-disable-line no-self-compare
1803 }
1804
1805 // Create lookup table for `toString('hex')`
1806 // See: https://github.com/feross/buffer/issues/219
1807 var hexSliceLookupTable = (function () {
1808   var alphabet = '0123456789abcdef'
1809   var table = new Array(256)
1810   for (var i = 0; i < 16; ++i) {
1811     var i16 = i * 16
1812     for (var j = 0; j < 16; ++j) {
1813       table[i16 + j] = alphabet[i] + alphabet[j]
1814     }
1815   }
1816   return table
1817 })()