/* eslint-disable require-buffer */

'use strict';

const binding = process.binding('buffer');

const { isArrayBuffer, isSharedArrayBuffer, isUint8Array } =

process.binding('util');

const bindingObj = {};

const internalUtil = require('internal/util');

class FastBuffer extends Uint8Array {

constructor(arg1, arg2, arg3) {

super(arg1, arg2, arg3);

}

}

FastBuffer.prototype.constructor = Buffer;

Buffer.prototype = FastBuffer.prototype;

exports.Buffer = Buffer;

exports.SlowBuffer = SlowBuffer;

exports.INSPECT_MAX_BYTES = 50;

exports.kMaxLength = binding.kMaxLength;

const kFromErrorMsg = 'First argument must be a string, Buffer, ' +

'ArrayBuffer, Array, or array-like object.';

Buffer.poolSize = 8 * 1024;

var poolSize, poolOffset, allocPool;

binding.setupBufferJS(Buffer.prototype, bindingObj);

// |binding.zeroFill| can be undefined when running inside an isolate where we

// do not own the ArrayBuffer allocator. Zero fill is always on in that case.

const zeroFill = bindingObj.zeroFill || [0];

function createUnsafeBuffer(size) {

return new FastBuffer(createUnsafeArrayBuffer(size));

}

function createUnsafeArrayBuffer(size) {

zeroFill[0] = 0;

try {

return new ArrayBuffer(size);

} finally {

zeroFill[0] = 1;

}

}

function createPool() {

poolSize = Buffer.poolSize;

allocPool = createUnsafeArrayBuffer(poolSize);

poolOffset = 0;

}

createPool();

function alignPool() {

// Ensure aligned slices

if (poolOffset & 0x7) {

poolOffset |= 0x7;

poolOffset++;

}

}

/**

* The Buffer() construtor is "soft deprecated" ... that is, it is deprecated

* in the documentation and should not be used moving forward. Rather,

* developers should use one of the three new factory APIs: Buffer.from(),

* Buffer.allocUnsafe() or Buffer.alloc() based on their specific needs. There

* is no hard deprecation because of the extent to which the Buffer constructor

* is used in the ecosystem currently -- a hard deprecation would introduce too

* much breakage at this time. It's not likely that the Buffer constructors

* would ever actually be removed.

**/

function Buffer(arg, encodingOrOffset, length) {

// Common case.

if (typeof arg === 'number') {

if (typeof encodingOrOffset === 'string') {

throw new Error(

'If encoding is specified then the first argument must be a string'

);

}

return Buffer.allocUnsafe(arg);

}

return Buffer.from(arg, encodingOrOffset, length);

}

/**

* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError

* if value is a number.

* Buffer.from(str[, encoding])

* Buffer.from(array)

* Buffer.from(buffer)

* Buffer.from(arrayBuffer[, byteOffset[, length]])

**/

Buffer.from = function(value, encodingOrOffset, length) {

if (typeof value === 'number')

throw new TypeError('"value" argument must not be a number');

if (isArrayBuffer(value) || isSharedArrayBuffer(value))

return fromArrayBuffer(value, encodingOrOffset, length);

if (typeof value === 'string')

return fromString(value, encodingOrOffset);

return fromObject(value);

};

Object.setPrototypeOf(Buffer, Uint8Array);

// The 'assertSize' method will remove itself from the callstack when an error

// occurs. This is done simply to keep the internal details of the

// implementation from bleeding out to users.

function assertSize(size) {

let err = null;

if (typeof size !== 'number')

err = new TypeError('"size" argument must be a number');

else if (size < 0)

err = new RangeError('"size" argument must not be negative');

else if (size > binding.kMaxLength)

err = new RangeError('"size" argument must not be larger ' +

'than ' + binding.kMaxLength);

if (err) {

Error.captureStackTrace(err, assertSize);

throw err;

}

}

/**

* Creates a new filled Buffer instance.

* alloc(size[, fill[, encoding]])

**/

Buffer.alloc = function(size, fill, encoding) {

assertSize(size);

if (size > 0 && fill !== undefined) {

// Since we are filling anyway, don't zero fill initially.

// Only pay attention to encoding if it's a string. This

// prevents accidentally sending in a number that would

// be interpretted as a start offset.

if (typeof encoding !== 'string')

encoding = undefined;

return createUnsafeBuffer(size).fill(fill, encoding);

}

return new FastBuffer(size);

};

/**

* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer

* instance. If `--zero-fill-buffers` is set, will zero-fill the buffer.

**/

Buffer.allocUnsafe = function(size) {

assertSize(size);

return allocate(size);

};

/**

* Equivalent to SlowBuffer(num), by default creates a non-zero-filled

* Buffer instance that is not allocated off the pre-initialized pool.

* If `--zero-fill-buffers` is set, will zero-fill the buffer.

**/

Buffer.allocUnsafeSlow = function(size) {

assertSize(size);

return createUnsafeBuffer(size);

};

// If --zero-fill-buffers command line argument is set, a zero-filled

// buffer is returned.

function SlowBuffer(length) {

if (+length != length)

length = 0;

assertSize(+length);

return createUnsafeBuffer(+length);

}

Object.setPrototypeOf(SlowBuffer.prototype, Uint8Array.prototype);

Object.setPrototypeOf(SlowBuffer, Uint8Array);

function allocate(size) {

if (size <= 0) {

return new FastBuffer();

}

if (size < (Buffer.poolSize >>> 1)) {

if (size > (poolSize - poolOffset))

createPool();

var b = new FastBuffer(allocPool, poolOffset, size);

poolOffset += size;

alignPool();

return b;

} else {

return createUnsafeBuffer(size);

}

}

function fromString(string, encoding) {

if (typeof encoding !== 'string' || encoding === '')

encoding = 'utf8';

if (!Buffer.isEncoding(encoding))

throw new TypeError('"encoding" must be a valid string encoding');

if (string.length === 0)

return new FastBuffer();

var length = byteLength(string, encoding);

if (length >= (Buffer.poolSize >>> 1))

return binding.createFromString(string, encoding);

if (length > (poolSize - poolOffset))

createPool();

var b = new FastBuffer(allocPool, poolOffset, length);

var actual = b.write(string, encoding);

if (actual !== length) {

// byteLength() may overestimate. That’s a rare case, though.

b = new FastBuffer(allocPool, poolOffset, actual);

}

poolOffset += actual;

alignPool();

return b;

}

function fromArrayLike(obj) {

const length = obj.length;

const b = allocate(length);

for (var i = 0; i < length; i++)

b[i] = obj[i];

return b;

}

function fromArrayBuffer(obj, byteOffset, length) {

byteOffset = internalUtil.toInteger(byteOffset);

const maxLength = obj.byteLength - byteOffset;

if (maxLength < 0)

throw new RangeError("'offset' is out of bounds");

if (length === undefined) {

length = maxLength;

} else {

length = internalUtil.toLength(length);

if (length > maxLength)

throw new RangeError("'length' is out of bounds");

}

return new FastBuffer(obj, byteOffset, length);

}

function fromObject(obj) {

if (isUint8Array(obj)) {

const b = allocate(obj.length);

if (b.length === 0)

return b;

binding.copy(obj, b, 0, 0, obj.length);

return b;

}

if (obj) {

if (obj.length !== undefined || isArrayBuffer(obj.buffer) ||

isSharedArrayBuffer(obj.buffer)) {

if (typeof obj.length !== 'number' || obj.length !== obj.length) {

return new FastBuffer();

}

return fromArrayLike(obj);

}

if (obj.type === 'Buffer' && Array.isArray(obj.data)) {

return fromArrayLike(obj.data);

}

}

throw new TypeError(kFromErrorMsg);

}

// Static methods

Buffer.isBuffer = function isBuffer(b) {

return b instanceof Buffer;

};

Buffer.compare = function compare(a, b) {

if (!isUint8Array(a) || !isUint8Array(b)) {

throw new TypeError('Arguments must be Buffers or Uint8Arrays');

}

if (a === b) {

return 0;

}

return binding.compare(a, b);

};

Buffer.isEncoding = function(encoding) {

return typeof encoding === 'string' &&

typeof internalUtil.normalizeEncoding(encoding) === 'string';

};

Buffer[internalUtil.kIsEncodingSymbol] = Buffer.isEncoding;

const kConcatErrMsg = '"list" argument must be an Array ' +

'of Buffer or Uint8Array instances';

Buffer.concat = function(list, length) {

var i;

if (!Array.isArray(list))

throw new TypeError(kConcatErrMsg);

if (list.length === 0)

return new FastBuffer();

if (length === undefined) {

length = 0;

for (i = 0; i < list.length; i++)

length += list[i].length;

} else {

length = length >>> 0;

}

var buffer = Buffer.allocUnsafe(length);

var pos = 0;

for (i = 0; i < list.length; i++) {

var buf = list[i];

if (!isUint8Array(buf))

throw new TypeError(kConcatErrMsg);

binding.copy(buf, buffer, pos);

pos += buf.length;

}

// Note: `length` is always equal to `buffer.length` at this point

if (pos < length) {

// Zero-fill the remaining bytes if the specified `length` was more than

// the actual total length, i.e. if we have some remaining allocated bytes

// there were not initialized.

buffer.fill(0, pos, length);

}

return buffer;

};

function base64ByteLength(str, bytes) {

// Handle padding

if (str.charCodeAt(bytes - 1) === 0x3D)

bytes--;

if (bytes > 1 && str.charCodeAt(bytes - 1) === 0x3D)

bytes--;

// Base64 ratio: 3/4

return (bytes * 3) >>> 2;

}

function byteLength(string, encoding) {

if (typeof string !== 'string') {

if (ArrayBuffer.isView(string) || isArrayBuffer(string) ||

isSharedArrayBuffer(string)) {

return string.byteLength;

}

throw new TypeError('"string" must be a string, Buffer, or ArrayBuffer');

}

var len = string.length;

if (len === 0)

return 0;

// Use a for loop to avoid recursion

var loweredCase = false;

for (;;) {

switch (encoding) {

case 'ascii':

case 'latin1':

case 'binary':

return len;

case 'utf8':

case 'utf-8':

case undefined:

return binding.byteLengthUtf8(string);

case 'ucs2':

case 'ucs-2':

case 'utf16le':

case 'utf-16le':

return len * 2;

case 'hex':

return len >>> 1;

case 'base64':

return base64ByteLength(string, len);

default:

// The C++ binding defaulted to UTF8, we should too.

if (loweredCase)

return binding.byteLengthUtf8(string);

encoding = ('' + encoding).toLowerCase();

loweredCase = true;

}

}

}

Buffer.byteLength = byteLength;

// For backwards compatibility.

Object.defineProperty(Buffer.prototype, 'parent', {

enumerable: true,

get: function() {

if (!(this instanceof Buffer))

return undefined;

return this.buffer;

}

});

Object.defineProperty(Buffer.prototype, 'offset', {

enumerable: true,

get: function() {

if (!(this instanceof Buffer))

return undefined;

return this.byteOffset;

}

});

function slowToString(encoding, start, end) {

var loweredCase = false;

// No need to verify that "this.length <= MAX_UINT32" since it's a read-only

// property of a typed array.

// This behaves neither like String nor Uint8Array in that we set start/end

// to their upper/lower bounds if the value passed is out of range.

// undefined is handled specially as per ECMA-262 6th Edition,

// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.

if (start === undefined || start < 0)

start = 0;

// Return early if start > this.length. Done here to prevent potential uint32

// coercion fail below.

if (start > this.length)

return '';

if (end === undefined || end > this.length)

end = this.length;

if (end <= 0)

return '';

// Force coersion to uint32. This will also coerce falsey/NaN values to 0.

end >>>= 0;

start >>>= 0;

if (end <= start)

return '';

if (!encoding) encoding = 'utf8';

while (true) {

switch (encoding) {

case 'hex':

return this.hexSlice(start, end);

case 'utf8':

case 'utf-8':

return this.utf8Slice(start, end);

case 'ascii':

return this.asciiSlice(start, end);

case 'latin1':

case 'binary':

return this.latin1Slice(start, end);

case 'base64':

return this.base64Slice(start, end);

case 'ucs2':

case 'ucs-2':

case 'utf16le':

case 'utf-16le':

return this.ucs2Slice(start, end);

default:

if (loweredCase)

throw new TypeError('Unknown encoding: ' + encoding);

encoding = (encoding + '').toLowerCase();

loweredCase = true;

}

}

}

Buffer.prototype.copy = function(target, targetStart, sourceStart, sourceEnd) {

return binding.copy(this, target, targetStart, sourceStart, sourceEnd);

};

Buffer.prototype.toString = function() {

let result;

if (arguments.length === 0) {

result = this.utf8Slice(0, this.length);

} else {

result = slowToString.apply(this, arguments);

}

if (result === undefined)

throw new Error('"toString()" failed');

return result;

};

Buffer.prototype.equals = function equals(b) {

if (!isUint8Array(b))

throw new TypeError('Argument must be a Buffer or Uint8Array');

if (this === b)

return true;

return binding.compare(this, b) === 0;

};

// Override how buffers are presented by util.inspect().

Buffer.prototype[internalUtil.customInspectSymbol] = function inspect() {

var str = '';

var max = exports.INSPECT_MAX_BYTES;

if (this.length > 0) {

str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');

if (this.length > max)

str += ' ... ';

}

return '<' + this.constructor.name + ' ' + str + '>';

};

Buffer.prototype.inspect = Buffer.prototype[internalUtil.customInspectSymbol];

Buffer.prototype.compare = function compare(target,

start,

end,

thisStart,

thisEnd) {

if (!isUint8Array(target))

throw new TypeError('Argument must be a Buffer or Uint8Array');

if (start === undefined)

start = 0;

if (end === undefined)

end = target.length;

if (thisStart === undefined)

thisStart = 0;

if (thisEnd === undefined)

thisEnd = this.length;

if (start < 0 ||

end > target.length ||

thisStart < 0 ||

thisEnd > this.length) {

throw new RangeError('out of range index');

}

if (thisStart >= thisEnd && start >= end)

return 0;

if (thisStart >= thisEnd)

return -1;

if (start >= end)

return 1;

start >>>= 0;

end >>>= 0;

thisStart >>>= 0;

thisEnd >>>= 0;

return binding.compareOffset(this, target, start, thisStart, end, thisEnd);

};

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,

// OR the last index of `val` in `buffer` at offset <= `byteOffset`.

//

// Arguments:

// - buffer - a Buffer to search

// - val - a string, Buffer, or number

// - byteOffset - an index into `buffer`; will be clamped to an int32

// - encoding - an optional encoding, relevant is val is a string

// - dir - true for indexOf, false for lastIndexOf

function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {

if (typeof byteOffset === 'string') {

encoding = byteOffset;

byteOffset = undefined;

} else if (byteOffset > 0x7fffffff) {

byteOffset = 0x7fffffff;

} else if (byteOffset < -0x80000000) {

byteOffset = -0x80000000;

}

byteOffset = +byteOffset; // Coerce to Number.

if (isNaN(byteOffset)) {

// If the offset is undefined, null, NaN, "foo", etc, search whole buffer.

byteOffset = dir ? 0 : (buffer.length - 1);

}

dir = !!dir; // Cast to bool.

if (typeof val === 'string') {

if (encoding === undefined) {

return binding.indexOfString(buffer, val, byteOffset, encoding, dir);

}

return slowIndexOf(buffer, val, byteOffset, encoding, dir);

} else if (isUint8Array(val)) {

return binding.indexOfBuffer(buffer, val, byteOffset, encoding, dir);

} else if (typeof val === 'number') {

return binding.indexOfNumber(buffer, val, byteOffset, dir);

}

throw new TypeError('"val" argument must be string, number, Buffer ' +

'or Uint8Array');

}

function slowIndexOf(buffer, val, byteOffset, encoding, dir) {

var loweredCase = false;

for (;;) {

switch (encoding) {

case 'utf8':

case 'utf-8':

case 'ucs2':

case 'ucs-2':

case 'utf16le':

case 'utf-16le':

case 'latin1':

case 'binary':

return binding.indexOfString(buffer, val, byteOffset, encoding, dir);

case 'base64':

case 'ascii':

case 'hex':

return binding.indexOfBuffer(

buffer, Buffer.from(val, encoding), byteOffset, encoding, dir);

default:

if (loweredCase) {

throw new TypeError('Unknown encoding: ' + encoding);

}

encoding = ('' + encoding).toLowerCase();

loweredCase = true;

}

}

}

Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {

return bidirectionalIndexOf(this, val, byteOffset, encoding, true);

};

Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {

return bidirectionalIndexOf(this, val, byteOffset, encoding, false);

};

Buffer.prototype.includes = function includes(val, byteOffset, encoding) {

return this.indexOf(val, byteOffset, encoding) !== -1;

};

// Usage:

// buffer.fill(number[, offset[, end]])

// buffer.fill(buffer[, offset[, end]])

// buffer.fill(string[, offset[, end]][, encoding])

Buffer.prototype.fill = function fill(val, start, end, encoding) {

// Handle string cases:

if (typeof val === 'string') {

if (typeof start === 'string') {

encoding = start;

start = 0;

end = this.length;

} else if (typeof end === 'string') {

encoding = end;

end = this.length;

}

if (encoding !== undefined && typeof encoding !== 'string') {

throw new TypeError('encoding must be a string');

}

var normalizedEncoding = internalUtil.normalizeEncoding(encoding);

if (normalizedEncoding === undefined) {

throw new TypeError('Unknown encoding: ' + encoding);

}

if (val.length === 0) {

// Previously, if val === '', the Buffer would not fill,

// which is rather surprising.

val = 0;

} else if (val.length === 1) {

var code = val.charCodeAt(0);

if ((normalizedEncoding === 'utf8' && code < 128) ||

normalizedEncoding === 'latin1') {

// Fast path: If `val` fits into a single byte, use that numeric value.

val = code;

}

}

} else if (typeof val === 'number') {

val = val & 255;

}

// Invalid ranges are not set to a default, so can range check early.

if (start < 0 || end > this.length)

throw new RangeError('Out of range index');

if (end <= start)

return this;

start = start >>> 0;

end = end === undefined ? this.length : end >>> 0;

binding.fill(this, val, start, end, encoding);

return this;

};

Buffer.prototype.write = function(string, offset, length, encoding) {

// Buffer#write(string);

if (offset === undefined) {

encoding = 'utf8';

length = this.length;

offset = 0;

// Buffer#write(string, encoding)

} else if (length === undefined && typeof offset === 'string') {

encoding = offset;

length = this.length;

offset = 0;

// Buffer#write(string, offset[, length][, encoding])

} else if (isFinite(offset)) {

offset = offset >>> 0;

if (isFinite(length)) {

length = length >>> 0;

if (encoding === undefined)

encoding = 'utf8';

} else {

encoding = length;

length = undefined;

}

} else {

// if someone is still calling the obsolete form of write(), tell them.

// we don't want eg buf.write("foo", "utf8", 10) to silently turn into

// buf.write("foo", "utf8"), so we can't ignore extra args

throw new Error('Buffer.write(string, encoding, offset[, length]) ' +

'is no longer supported');

}

var remaining = this.length - offset;

if (length === undefined || length > remaining)

length = remaining;

if (string.length > 0 && (length < 0 || offset < 0))

throw new RangeError('Attempt to write outside buffer bounds');

if (!encoding)

encoding = 'utf8';

var loweredCase = false;

for (;;) {

switch (encoding) {

case 'hex':

return this.hexWrite(string, offset, length);

case 'utf8':

case 'utf-8':

return this.utf8Write(string, offset, length);

case 'ascii':

return this.asciiWrite(string, offset, length);

case 'latin1':

case 'binary':

return this.latin1Write(string, offset, length);

case 'base64':

// Warning: maxLength not taken into account in base64Write

return this.base64Write(string, offset, length);

case 'ucs2':

case 'ucs-2':

case 'utf16le':

case 'utf-16le':

return this.ucs2Write(string, offset, length);

default:

if (loweredCase)

throw new TypeError('Unknown encoding: ' + encoding);

encoding = ('' + encoding).toLowerCase();

loweredCase = true;

}

}

};

Buffer.prototype.toJSON = function() {

return {

type: 'Buffer',

data: Array.prototype.slice.call(this, 0)

};

};

function adjustOffset(offset, length) {

// Use Math.trunc() to convert offset to an integer value that can be larger

// than an Int32. Hence, don't use offset | 0 or similar techniques.

offset = Math.trunc(offset);

if (offset === 0 || Number.isNaN(offset)) {

return 0;

} else if (offset < 0) {

offset += length;

return offset > 0 ? offset : 0;

} else {

return offset < length ? offset : length;

}

}

Buffer.prototype.slice = function slice(start, end) {

const srcLength = this.length;

start = adjustOffset(start, srcLength);

end = end !== undefined ? adjustOffset(end, srcLength) : srcLength;

const newLength = end > start ? end - start : 0;

return new FastBuffer(this.buffer, this.byteOffset + start, newLength);

};

function checkOffset(offset, ext, length) {

if (offset + ext > length)

throw new RangeError('Index out of range');

}

Buffer.prototype.readUIntLE = function(offset, byteLength, noAssert) {

offset = offset >>> 0;

byteLength = byteLength >>> 0;

if (!noAssert)

checkOffset(offset, byteLength, this.length);

var val = this[offset];

var mul = 1;

var i = 0;

while (++i < byteLength && (mul *= 0x100))

val += this[offset + i] * mul;

return val;

};

Buffer.prototype.readUIntBE = function(offset, byteLength, noAssert) {

offset = offset >>> 0;

byteLength = byteLength >>> 0;

if (!noAssert)

checkOffset(offset, byteLength, this.length);

var val = this[offset + --byteLength];

var mul = 1;

while (byteLength > 0 && (mul *= 0x100))

val += this[offset + --byteLength] * mul;

return val;

};

Buffer.prototype.readUInt8 = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 1, this.length);

return this[offset];

};

Buffer.prototype.readUInt16LE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 2, this.length);

return this[offset] | (this[offset + 1] << 8);

};

Buffer.prototype.readUInt16BE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 2, this.length);

return (this[offset] << 8) | this[offset + 1];

};

Buffer.prototype.readUInt32LE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 4, this.length);

return ((this[offset]) |

(this[offset + 1] << 8) |

(this[offset + 2] << 16)) +

(this[offset + 3] * 0x1000000);

};

Buffer.prototype.readUInt32BE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 4, this.length);

return (this[offset] * 0x1000000) +

((this[offset + 1] << 16) |

(this[offset + 2] << 8) |

this[offset + 3]);

};

Buffer.prototype.readIntLE = function(offset, byteLength, noAssert) {

offset = offset >>> 0;

byteLength = byteLength >>> 0;

if (!noAssert)

checkOffset(offset, byteLength, this.length);

var val = this[offset];

var mul = 1;

var i = 0;

while (++i < byteLength && (mul *= 0x100))

val += this[offset + i] * mul;

mul *= 0x80;

if (val >= mul)

val -= Math.pow(2, 8 * byteLength);

return val;

};

Buffer.prototype.readIntBE = function(offset, byteLength, noAssert) {

offset = offset >>> 0;

byteLength = byteLength >>> 0;

if (!noAssert)

checkOffset(offset, byteLength, this.length);

var i = byteLength;

var mul = 1;

var val = this[offset + --i];

while (i > 0 && (mul *= 0x100))

val += this[offset + --i] * mul;

mul *= 0x80;

if (val >= mul)

val -= Math.pow(2, 8 * byteLength);

return val;

};

Buffer.prototype.readInt8 = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 1, this.length);

var val = this[offset];

return !(val & 0x80) ? val : (0xff - val + 1) * -1;

};

Buffer.prototype.readInt16LE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 2, this.length);

var val = this[offset] | (this[offset + 1] << 8);

return (val & 0x8000) ? val | 0xFFFF0000 : val;

};

Buffer.prototype.readInt16BE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 2, this.length);

var val = this[offset + 1] | (this[offset] << 8);

return (val & 0x8000) ? val | 0xFFFF0000 : val;

};

Buffer.prototype.readInt32LE = function(offset, noAssert) {

offset = offset >>> 0;

if (!noAssert)

checkOffset(offset, 4, this.length);

return (this[offset]) |

(this[offset + 1] << 8) |

(this[offset + 2] << 16) |

(this[offset + 3] << 24);

};