source: trip-planner-front/node_modules/buffer/index.js@ 571e0df

Last change on this file since 571e0df was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 48.9 KB
Line 
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
11var base64 = require('base64-js')
12var ieee754 = require('ieee754')
13var 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
18exports.Buffer = Buffer
19exports.SlowBuffer = SlowBuffer
20exports.INSPECT_MAX_BYTES = 50
21
22var K_MAX_LENGTH = 0x7fffffff
23exports.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 */
39Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
40
41if (!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
49function 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
62Object.defineProperty(Buffer.prototype, 'parent', {
63 enumerable: true,
64 get: function () {
65 if (!Buffer.isBuffer(this)) return undefined
66 return this.buffer
67 }
68})
69
70Object.defineProperty(Buffer.prototype, 'offset', {
71 enumerable: true,
72 get: function () {
73 if (!Buffer.isBuffer(this)) return undefined
74 return this.byteOffset
75 }
76})
77
78function 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
98function 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
111Buffer.poolSize = 8192 // not used by this implementation
112
113function 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 **/
175Buffer.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
181Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)
182Object.setPrototypeOf(Buffer, Uint8Array)
183
184function 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
192function 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 **/
212Buffer.alloc = function (size, fill, encoding) {
213 return alloc(size, fill, encoding)
214}
215
216function 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 * */
224Buffer.allocUnsafe = function (size) {
225 return allocUnsafe(size)
226}
227/**
228 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
229 */
230Buffer.allocUnsafeSlow = function (size) {
231 return allocUnsafe(size)
232}
233
234function 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
258function 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
267function 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
275function 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
299function 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
324function 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
334function SlowBuffer (length) {
335 if (+length != length) { // eslint-disable-line eqeqeq
336 length = 0
337 }
338 return Buffer.alloc(+length)
339}
340
341Buffer.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
346Buffer.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
373Buffer.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
392Buffer.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
433function 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}
480Buffer.byteLength = byteLength
481
482function 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
558Buffer.prototype._isBuffer = true
559
560function swap (b, n, m) {
561 var i = b[n]
562 b[n] = b[m]
563 b[m] = i
564}
565
566Buffer.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
577Buffer.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
589Buffer.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
603Buffer.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
610Buffer.prototype.toLocaleString = Buffer.prototype.toString
611
612Buffer.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
618Buffer.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}
625if (customInspectSymbol) {
626 Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect
627}
628
629Buffer.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
703function 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
759function 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
815Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
816 return this.indexOf(val, byteOffset, encoding) !== -1
817}
818
819Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
820 return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
821}
822
823Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
824 return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
825}
826
827function 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
852function utf8Write (buf, string, offset, length) {
853 return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
854}
855
856function asciiWrite (buf, string, offset, length) {
857 return blitBuffer(asciiToBytes(string), buf, offset, length)
858}
859
860function base64Write (buf, string, offset, length) {
861 return blitBuffer(base64ToBytes(string), buf, offset, length)
862}
863
864function ucs2Write (buf, string, offset, length) {
865 return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
866}
867
868Buffer.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
937Buffer.prototype.toJSON = function toJSON () {
938 return {
939 type: 'Buffer',
940 data: Array.prototype.slice.call(this._arr || this, 0)
941 }
942}
943
944function 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
952function 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
1031var MAX_ARGUMENTS_LENGTH = 0x1000
1032
1033function 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
1051function 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
1061function 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
1071function 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
1084function 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
1094Buffer.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 */
1125function 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
1130Buffer.prototype.readUintLE =
1131Buffer.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
1146Buffer.prototype.readUintBE =
1147Buffer.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
1163Buffer.prototype.readUint8 =
1164Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
1165 offset = offset >>> 0
1166 if (!noAssert) checkOffset(offset, 1, this.length)
1167 return this[offset]
1168}
1169
1170Buffer.prototype.readUint16LE =
1171Buffer.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
1177Buffer.prototype.readUint16BE =
1178Buffer.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
1184Buffer.prototype.readUint32LE =
1185Buffer.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
1195Buffer.prototype.readUint32BE =
1196Buffer.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
1206Buffer.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
1224Buffer.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
1242Buffer.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
1249Buffer.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
1256Buffer.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
1263Buffer.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
1273Buffer.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
1283Buffer.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
1289Buffer.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
1295Buffer.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
1301Buffer.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
1307function 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
1313Buffer.prototype.writeUintLE =
1314Buffer.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
1333Buffer.prototype.writeUintBE =
1334Buffer.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
1353Buffer.prototype.writeUint8 =
1354Buffer.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
1362Buffer.prototype.writeUint16LE =
1363Buffer.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
1372Buffer.prototype.writeUint16BE =
1373Buffer.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
1382Buffer.prototype.writeUint32LE =
1383Buffer.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
1394Buffer.prototype.writeUint32BE =
1395Buffer.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
1406Buffer.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
1429Buffer.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
1452Buffer.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
1461Buffer.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
1470Buffer.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
1479Buffer.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
1490Buffer.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
1502function 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
1507function 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
1517Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
1518 return writeFloat(this, value, offset, true, noAssert)
1519}
1520
1521Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
1522 return writeFloat(this, value, offset, false, noAssert)
1523}
1524
1525function 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
1535Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
1536 return writeDouble(this, value, offset, true, noAssert)
1537}
1538
1539Buffer.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)
1544Buffer.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])
1589Buffer.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
1659var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
1660
1661function 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
1675function 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
1755function 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
1764function 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
1780function base64ToBytes (str) {
1781 return base64.toByteArray(base64clean(str))
1782}
1783
1784function 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
1795function 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}
1800function 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
1807var 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})()
Note: See TracBrowser for help on using the repository browser.