AK-21/Graphite-Industrial-Intelligence
0
1/*!2 * The buffer module from node.js, for the browser.3 *4 * @author Feross Aboukhadijeh <https://feross.org>5 * @license MIT6 */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-notation15 ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation16 : null17 18exports.Buffer = Buffer19exports.SlowBuffer = SlowBuffer20exports.INSPECT_MAX_BYTES = 5021 22var K_MAX_LENGTH = 0x7fffffff23exports.kMaxLength = K_MAX_LENGTH24 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 Object29 * 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 subclassable35 * 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 support37 * 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() === 4257 } catch (e) {58 return false59 }60}61 62Object.defineProperty(Buffer.prototype, 'parent', {63 enumerable: true,64 get: function () {65 if (!Buffer.isBuffer(this)) return undefined66 return this.buffer67 }68})69 70Object.defineProperty(Buffer.prototype, 'offset', {71 enumerable: true,72 get: function () {73 if (!Buffer.isBuffer(this)) return undefined74 return this.byteOffset75 }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` instance83 var buf = new Uint8Array(length)84 Object.setPrototypeOf(buf, Buffer.prototype)85 return buf86}87 88/**89 * The Buffer constructor returns instances of `Uint8Array` that have their90 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of91 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods92 * and the `Uint8Array` methods. Square bracket notation works as expected -- it93 * 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 implementation112 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 b153 154 if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&155 typeof value[Symbol.toPrimitive] === 'function') {156 return Buffer.from(157 value[Symbol.toPrimitive]('string'), encodingOrOffset, length158 )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 TypeError169 * 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/148181Object.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. This199 // prevents accidentally sending in a number that would200 // 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) | 0244 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 will250 // 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 buf256}257 258function fromArrayLike (array) {259 var length = array.length < 0 ? 0 : checked(array.length) | 0260 var buf = createBuffer(length)261 for (var i = 0; i < length; i += 1) {262 buf[i] = array[i] & 255263 }264 return buf265}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 buf285 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` instance294 Object.setPrototypeOf(buf, Buffer.prototype)295 296 return buf297}298 299function fromObject (obj) {300 if (Buffer.isBuffer(obj)) {301 var len = checked(obj.length) | 0302 var buf = createBuffer(len)303 304 if (buf.length === 0) {305 return buf306 }307 308 obj.copy(buf, 0, 0, len)309 return buf310 }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 when326 // 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 | 0332}333 334function SlowBuffer (length) {335 if (+length != length) { // eslint-disable-line eqeqeq336 length = 0337 }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 false344}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 0356 357 var x = a.length358 var y = b.length359 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 break365 }366 }367 368 if (x < y) return -1369 if (y < x) return 1370 return 0371}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 true387 default:388 return false389 }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 i402 if (length === undefined) {403 length = 0404 for (i = 0; i < list.length; ++i) {405 length += list[i].length406 }407 }408 409 var buffer = Buffer.allocUnsafe(length)410 var pos = 0411 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 pos421 )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.length429 }430 return buffer431}432 433function byteLength (string, encoding) {434 if (Buffer.isBuffer(string)) {435 return string.length436 }437 if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {438 return string.byteLength439 }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 string444 )445 }446 447 var len = string.length448 var mustMatch = (arguments.length > 2 && arguments[2] === true)449 if (!mustMatch && len === 0) return 0450 451 // Use a for loop to avoid recursion452 var loweredCase = false453 for (;;) {454 switch (encoding) {455 case 'ascii':456 case 'latin1':457 case 'binary':458 return len459 case 'utf8':460 case 'utf-8':461 return utf8ToBytes(string).length462 case 'ucs2':463 case 'ucs-2':464 case 'utf16le':465 case 'utf-16le':466 return len * 2467 case 'hex':468 return len >>> 1469 case 'base64':470 return base64ToBytes(string).length471 default:472 if (loweredCase) {473 return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8474 }475 encoding = ('' + encoding).toLowerCase()476 loweredCase = true477 }478 }479}480Buffer.byteLength = byteLength481 482function slowToString (encoding, start, end) {483 var loweredCase = false484 485 // No need to verify that "this.length <= MAX_UINT32" since it's a read-only486 // property of a typed array.487 488 // This behaves neither like String nor Uint8Array in that we set start/end489 // 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 = 0494 }495 // Return early if start > this.length. Done here to prevent potential uint32496 // coercion fail below.497 if (start > this.length) {498 return ''499 }500 501 if (end === undefined || end > this.length) {502 end = this.length503 }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 >>>= 0511 start >>>= 0512 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 = true548 }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 different555// copies of the 'buffer' package in use. This method works even for Buffer556// instances that were created from another copy of the `buffer` package.557// See: https://github.com/feross/buffer/issues/154558Buffer.prototype._isBuffer = true559 560function swap (b, n, m) {561 var i = b[n]562 b[n] = b[m]563 b[m] = i564}565 566Buffer.prototype.swap16 = function swap16 () {567 var len = this.length568 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 this575}576 577Buffer.prototype.swap32 = function swap32 () {578 var len = this.length579 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 this587}588 589Buffer.prototype.swap64 = function swap64 () {590 var len = this.length591 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 this601}602 603Buffer.prototype.toString = function toString () {604 var length = this.length605 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.toString611 612Buffer.prototype.equals = function equals (b) {613 if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')614 if (this === b) return true615 return Buffer.compare(this, b) === 0616}617 618Buffer.prototype.inspect = function inspect () {619 var str = ''620 var max = exports.INSPECT_MAX_BYTES621 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.inspect627}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 = 0642 }643 if (end === undefined) {644 end = target ? target.length : 0645 }646 if (thisStart === undefined) {647 thisStart = 0648 }649 if (thisEnd === undefined) {650 thisEnd = this.length651 }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 0659 }660 if (thisStart >= thisEnd) {661 return -1662 }663 if (start >= end) {664 return 1665 }666 667 start >>>= 0668 end >>>= 0669 thisStart >>>= 0670 thisEnd >>>= 0671 672 if (this === target) return 0673 674 var x = thisEnd - thisStart675 var y = end - start676 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 break686 }687 }688 689 if (x < y) return -1690 if (y < x) return 1691 return 0692}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 search699// - val - a string, Buffer, or number700// - byteOffset - an index into `buffer`; will be clamped to an int32701// - encoding - an optional encoding, relevant is val is a string702// - dir - true for indexOf, false for lastIndexOf703function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {704 // Empty buffer means no match705 if (buffer.length === 0) return -1706 707 // Normalize byteOffset708 if (typeof byteOffset === 'string') {709 encoding = byteOffset710 byteOffset = 0711 } else if (byteOffset > 0x7fffffff) {712 byteOffset = 0x7fffffff713 } else if (byteOffset < -0x80000000) {714 byteOffset = -0x80000000715 }716 byteOffset = +byteOffset // Coerce to Number.717 if (numberIsNaN(byteOffset)) {718 // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer719 byteOffset = dir ? 0 : (buffer.length - 1)720 }721 722 // Normalize byteOffset: negative offsets start from the end of the buffer723 if (byteOffset < 0) byteOffset = buffer.length + byteOffset724 if (byteOffset >= buffer.length) {725 if (dir) return -1726 else byteOffset = buffer.length - 1727 } else if (byteOffset < 0) {728 if (dir) byteOffset = 0729 else return -1730 }731 732 // Normalize val733 if (typeof val === 'string') {734 val = Buffer.from(val, encoding)735 }736 737 // Finally, search either indexOf (if dir is true) or lastIndexOf738 if (Buffer.isBuffer(val)) {739 // Special case: looking for empty string/buffer always fails740 if (val.length === 0) {741 return -1742 }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 = 1761 var arrLength = arr.length762 var valLength = val.length763 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 -1770 }771 indexSize = 2772 arrLength /= 2773 valLength /= 2774 byteOffset /= 2775 }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 i787 if (dir) {788 var foundIndex = -1789 for (i = byteOffset; i < arrLength; i++) {790 if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {791 if (foundIndex === -1) foundIndex = i792 if (i - foundIndex + 1 === valLength) return foundIndex * indexSize793 } else {794 if (foundIndex !== -1) i -= i - foundIndex795 foundIndex = -1796 }797 }798 } else {799 if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength800 for (i = byteOffset; i >= 0; i--) {801 var found = true802 for (var j = 0; j < valLength; j++) {803 if (read(arr, i + j) !== read(val, j)) {804 found = false805 break806 }807 }808 if (found) return i809 }810 }811 812 return -1813}814 815Buffer.prototype.includes = function includes (val, byteOffset, encoding) {816 return this.indexOf(val, byteOffset, encoding) !== -1817}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) || 0829 var remaining = buf.length - offset830 if (!length) {831 length = remaining832 } else {833 length = Number(length)834 if (length > remaining) {835 length = remaining836 }837 }838 839 var strLen = string.length840 841 if (length > strLen / 2) {842 length = strLen / 2843 }844 for (var i = 0; i < length; ++i) {845 var parsed = parseInt(string.substr(i * 2, 2), 16)846 if (numberIsNaN(parsed)) return i847 buf[offset + i] = parsed848 }849 return i850}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.length873 offset = 0874 // Buffer#write(string, encoding)875 } else if (length === undefined && typeof offset === 'string') {876 encoding = offset877 length = this.length878 offset = 0879 // Buffer#write(string, offset[, length][, encoding])880 } else if (isFinite(offset)) {881 offset = offset >>> 0882 if (isFinite(length)) {883 length = length >>> 0884 if (encoding === undefined) encoding = 'utf8'885 } else {886 encoding = length887 length = undefined888 }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 - offset896 if (length === undefined || length > remaining) length = remaining897 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 = false905 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 base64Write921 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 = true933 }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 = start957 while (i < end) {958 var firstByte = buf[i]959 var codePoint = null960 var bytesPerSequence = (firstByte > 0xEF)961 ? 4962 : (firstByte > 0xDF)963 ? 3964 : (firstByte > 0xBF)965 ? 2966 : 1967 968 if (i + bytesPerSequence <= end) {969 var secondByte, thirdByte, fourthByte, tempCodePoint970 971 switch (bytesPerSequence) {972 case 1:973 if (firstByte < 0x80) {974 codePoint = firstByte975 }976 break977 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 = tempCodePoint983 }984 }985 break986 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 = tempCodePoint993 }994 }995 break996 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 = tempCodePoint1004 }1005 }1006 }1007 }1008 1009 if (codePoint === null) {1010 // we did not generate a valid codePoint so insert a1011 // replacement char (U+FFFD) and advance only 1 byte1012 codePoint = 0xFFFD1013 bytesPerSequence = 11014 } else if (codePoint > 0xFFFF) {1015 // encode to utf16 (surrogate pair dance)1016 codePoint -= 0x100001017 res.push(codePoint >>> 10 & 0x3FF | 0xD800)1018 codePoint = 0xDC00 | codePoint & 0x3FF1019 }1020 1021 res.push(codePoint)1022 i += bytesPerSequence1023 }1024 1025 return decodeCodePointsArray(res)1026}1027 1028// Based on http://stackoverflow.com/a/22747272/680742, the browser with1029// the lowest limit is Chrome, with 0x10000 args.1030// We go 1 magnitude less, for safety1031var MAX_ARGUMENTS_LENGTH = 0x10001032 1033function decodeCodePointsArray (codePoints) {1034 var len = codePoints.length1035 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 = 01042 while (i < len) {1043 res += String.fromCharCode.apply(1044 String,1045 codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)1046 )1047 }1048 return res1049}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 ret1059}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 ret1069}1070 1071function hexSlice (buf, start, end) {1072 var len = buf.length1073 1074 if (!start || start < 0) start = 01075 if (!end || end < 0 || end > len) end = len1076 1077 var out = ''1078 for (var i = start; i < end; ++i) {1079 out += hexSliceLookupTable[buf[i]]1080 }1081 return out1082}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 res1092}1093 1094Buffer.prototype.slice = function slice (start, end) {1095 var len = this.length1096 start = ~~start1097 end = end === undefined ? len : ~~end1098 1099 if (start < 0) {1100 start += len1101 if (start < 0) start = 01102 } else if (start > len) {1103 start = len1104 }1105 1106 if (end < 0) {1107 end += len1108 if (end < 0) end = 01109 } else if (end > len) {1110 end = len1111 }1112 1113 if (end < start) end = start1114 1115 var newBuf = this.subarray(start, end)1116 // Return an augmented `Uint8Array` instance1117 Object.setPrototypeOf(newBuf, Buffer.prototype)1118 1119 return newBuf1120}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 >>> 01133 byteLength = byteLength >>> 01134 if (!noAssert) checkOffset(offset, byteLength, this.length)1135 1136 var val = this[offset]1137 var mul = 11138 var i = 01139 while (++i < byteLength && (mul *= 0x100)) {1140 val += this[offset + i] * mul1141 }1142 1143 return val1144}1145 1146Buffer.prototype.readUintBE =1147Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {1148 offset = offset >>> 01149 byteLength = byteLength >>> 01150 if (!noAssert) {1151 checkOffset(offset, byteLength, this.length)1152 }1153 1154 var val = this[offset + --byteLength]1155 var mul = 11156 while (byteLength > 0 && (mul *= 0x100)) {1157 val += this[offset + --byteLength] * mul1158 }1159 1160 return val1161}1162 1163Buffer.prototype.readUint8 =1164Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {1165 offset = offset >>> 01166 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 >>> 01173 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 >>> 01180 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 >>> 01187 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 >>> 01198 if (!noAssert) checkOffset(offset, 4, this.length)1199 1200 return (this[offset] * 0x1000000) +