// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

const {

Array,

ArrayBufferIsView,

ArrayIsArray,

ArrayPrototypeForEach,

MathCeil,

MathFloor,

MathMin,

MathTrunc,

NumberIsInteger,

NumberIsNaN,

NumberMAX_SAFE_INTEGER,

NumberMIN_SAFE_INTEGER,

ObjectDefineProperties,

ObjectDefineProperty,

ObjectPrototypeHasOwnProperty,

ObjectSetPrototypeOf,

RegExpPrototypeSymbolReplace,

StringPrototypeCharCodeAt,

StringPrototypeSlice,

StringPrototypeToLowerCase,

StringPrototypeTrim,

SymbolSpecies,

SymbolToPrimitive,

TypedArrayPrototypeFill,

TypedArrayPrototypeGetBuffer,

TypedArrayPrototypeGetByteLength,

TypedArrayPrototypeGetByteOffset,

TypedArrayPrototypeGetLength,

TypedArrayPrototypeSet,

TypedArrayPrototypeSubarray,

Uint8Array,

} = primordials;

const {

byteLengthUtf8,

compare: _compare,

compareOffset,

copy: _copy,

fill: bindingFill,

isAscii: bindingIsAscii,

isUtf8: bindingIsUtf8,

stringLengthUtf8: bindingStringLengthUtf8,

indexOfBuffer,

indexOfNumber,

indexOfString,

swap16: _swap16,

swap32: _swap32,

swap64: _swap64,

kMaxLength,

kStringMaxLength,

atob: _atob,

btoa: _btoa,

asciiSlice,

base64Slice,

base64urlSlice,

latin1Slice,

hexSlice,

ucs2Slice,

utf8Slice,

base64Write,

base64urlWrite,

hexWrite,

ucs2Write,

} = internalBinding('buffer');

const {

constants: {

ALL_PROPERTIES,

ONLY_ENUMERABLE,

},

getOwnNonIndexProperties,

isInsideNodeModules,

} = internalBinding('util');

const {

customInspectSymbol,

lazyDOMException,

normalizeEncoding,

kIsEncodingSymbol,

defineLazyProperties,

encodingsMap,

} = require('internal/util');

const {

isAnyArrayBuffer,

isArrayBufferView,

isUint8Array,

isTypedArray,

} = require('internal/util/types');

const {

inspect: utilInspect,

} = require('internal/util/inspect');

const assert = require('internal/assert');

const {

codes: {

ERR_BUFFER_OUT_OF_BOUNDS,

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_BUFFER_SIZE,

ERR_MISSING_ARGS,

ERR_OUT_OF_RANGE,

ERR_UNKNOWN_ENCODING,

},

genericNodeError,

} = require('internal/errors');

const {

validateArray,

validateBuffer,

validateInteger,

validateNumber,

validateString,

} = require('internal/validators');

// Provide validateInteger() but with kMaxLength as the default maximum value.

const validateOffset = (value, name, min = 0, max = kMaxLength) =>

validateInteger(value, name, min, max);

const {

FastBuffer,

markAsUntransferable,

addBufferPrototypeMethods,

createUnsafeBuffer,

createUnsafeAlignedBuffer,

alignmentPadding,

asciiWrite,

latin1Write,

utf8Write,

} = require('internal/buffer');

const {

namespace: {

addDeserializeCallback,

isBuildingSnapshot,

},

} = require('internal/v8/startup_snapshot');

FastBuffer.prototype.constructor = Buffer;

Buffer.prototype = FastBuffer.prototype;

addBufferPrototypeMethods(Buffer.prototype);

const constants = ObjectDefineProperties({}, {

MAX_LENGTH: {

__proto__: null,

value: kMaxLength,

writable: false,

enumerable: true,

},

MAX_STRING_LENGTH: {

__proto__: null,

value: kStringMaxLength,

writable: false,

enumerable: true,

},

});

// The largest alignment accepted by `Buffer.allocUnsafeSlow()`. Any plausible

// I/O alignment requirement (logical block size, memory page size, huge page

// size) is well below this.

const kMaxAlignment = 2 ** 30;

// Slices handed out of the pool are 8 byte aligned relative to the start of the

// pool, so aligning the pool itself to a cache line keeps them from straddling

// one more cache line than their size requires.

const kPoolAlignment = 64;

Buffer.poolSize = 64 * 1024;

// `poolOffset` is relative to `poolBase`, which is where the pool starts inside

// `allocPool`. The pool is over-allocated to be able to align it, so `poolBase`

// is not necessarily 0.

let poolSize, poolOffset, poolBase, allocPool, allocBuffer;

function createPool() {

poolSize = Buffer.poolSize;

allocBuffer = createUnsafeAlignedBuffer(poolSize, kPoolAlignment);

allocPool = allocBuffer.buffer;

poolBase = TypedArrayPrototypeGetByteOffset(allocBuffer);

markAsUntransferable(allocPool);

poolOffset = 0;

}

createPool();

if (isBuildingSnapshot()) {

addDeserializeCallback(() => {

// TODO(legendecas): ArrayBuffer.[[ArrayBufferDetachKey]] is not been serialized.

// Remove this callback when snapshot serialization supports it.

createPool();

});

}

function alignPool() {

// Ensure aligned slices

if (poolOffset & 0x7) {

poolOffset |= 0x7;

poolOffset++;

}

}

let bufferWarningAlreadyEmitted = false;

let nodeModulesCheckCounter = 0;

const bufferWarning = 'Buffer() is deprecated due to security and usability ' +

'issues. Please use the Buffer.alloc(), ' +

'Buffer.allocUnsafe(), or Buffer.from() methods instead.';

function showFlaggedDeprecation() {

if (bufferWarningAlreadyEmitted ||

++nodeModulesCheckCounter > 10000 ||

(!require('internal/options').getOptionValue('--pending-deprecation') &&

isInsideNodeModules(3))) {

// We don't emit a warning, because we either:

// - Already did so, or

// - Already checked too many times whether a call is coming

// from node_modules and want to stop slowing down things, or

// - We aren't running with `--pending-deprecation` enabled,

// and the code is inside `node_modules`.

// - If the topmost non-internal frame is not inside `node_modules`.

return;

}

process.emitWarning(bufferWarning, 'DeprecationWarning', 'DEP0005');

bufferWarningAlreadyEmitted = true;

}

function toInteger(n, defaultVal) {

n = +n;

if (!NumberIsNaN(n) &&

n >= NumberMIN_SAFE_INTEGER &&

n <= NumberMAX_SAFE_INTEGER) {

return ((n % 1) === 0 ? n : MathFloor(n));

}

return defaultVal;

}

function copyImpl(source, target, targetStart, sourceStart, sourceEnd) {

if (!ArrayBufferIsView(source))

throw new ERR_INVALID_ARG_TYPE('source', ['Buffer', 'Uint8Array'], source);

if (!ArrayBufferIsView(target))

throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);

if (targetStart === undefined) {

targetStart = 0;

} else {

targetStart = NumberIsInteger(targetStart) ? targetStart : toInteger(targetStart, 0);

if (targetStart < 0)

throw new ERR_OUT_OF_RANGE('targetStart', '>= 0', targetStart);

}

if (sourceStart === undefined) {

sourceStart = 0;

} else {

sourceStart = NumberIsInteger(sourceStart) ? sourceStart : toInteger(sourceStart, 0);

if (sourceStart < 0 || sourceStart > source.byteLength)

throw new ERR_OUT_OF_RANGE('sourceStart', `>= 0 && <= ${source.byteLength}`, sourceStart);

}

if (sourceEnd === undefined) {

sourceEnd = source.byteLength;

} else {

sourceEnd = NumberIsInteger(sourceEnd) ? sourceEnd : toInteger(sourceEnd, 0);

if (sourceEnd < 0)

throw new ERR_OUT_OF_RANGE('sourceEnd', '>= 0', sourceEnd);

}

if (targetStart >= target.byteLength || sourceStart >= sourceEnd)

return 0;

return _copyActual(source, target, targetStart, sourceStart, sourceEnd);

}

function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {

if (sourceEnd - sourceStart > target.byteLength - targetStart)

sourceEnd = sourceStart + target.byteLength - targetStart;

let nb = sourceEnd - sourceStart;

const sourceLen = source.byteLength - sourceStart;

if (nb > sourceLen)

nb = sourceLen;

if (nb <= 0)

return 0;

// `_copy` returns the number of bytes actually copied, which is `nb` except

// when the target is backed by a detached or immutable ArrayBuffer, in which

// case nothing is copied and it returns 0.

return _copy(source, target, targetStart, sourceStart, nb);

}

/**

* The Buffer() constructor is deprecated in 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 runtime deprecation because of the extent

* to which the Buffer constructor is used in the ecosystem currently -- a

* runtime deprecation would introduce too much breakage at this time. It's not

* likely that the Buffer constructors would ever actually be removed.

* Deprecation Code: DEP0005

* @returns {Buffer}

*/

function Buffer(arg, encodingOrOffset, length) {

showFlaggedDeprecation();

// Common case.

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

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

throw new ERR_INVALID_ARG_TYPE('string', 'string', arg);

}

return Buffer.alloc(arg);

}

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

}

ObjectDefineProperty(Buffer, SymbolSpecies, {

__proto__: null,

enumerable: false,

configurable: true,

get() { return FastBuffer; },

});

/**

* 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]])

* @param {any} value

* @param {BufferEncoding|number} encodingOrOffset

* @param {number} [length]

* @returns {Buffer}

*/

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

if (typeof value === 'string')

return fromString(value, encodingOrOffset);

if (typeof value === 'object' && value !== null) {

if (isAnyArrayBuffer(value))

return fromArrayBuffer(value, encodingOrOffset, length);

const valueOf = value.valueOf && value.valueOf();

if (valueOf != null &&

valueOf !== value &&

(typeof valueOf === 'string' || typeof valueOf === 'object')) {

return from(valueOf, encodingOrOffset, length);

}

const b = fromObject(value);

if (b)

return b;

if (typeof value[SymbolToPrimitive] === 'function') {

const primitive = value[SymbolToPrimitive]('string');

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

return fromString(primitive, encodingOrOffset);

}

}

}

throw new ERR_INVALID_ARG_TYPE(

'first argument',

['string', 'Buffer', 'ArrayBuffer', 'Array', 'Array-like Object'],

value,

);

};

/**

* Creates the Buffer as a copy of the underlying ArrayBuffer of the view

* rather than the contents of the view.

* @param {TypedArray} view

* @param {number} [offset]

* @param {number} [length]

* @returns {Buffer}

*/

Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {

if (!isTypedArray(view)) {

throw new ERR_INVALID_ARG_TYPE('view', [ 'TypedArray' ], view);

}

const viewLength = TypedArrayPrototypeGetLength(view);

if (viewLength === 0) {

return new FastBuffer();

}

let start = 0;

let end = viewLength;

if (offset !== undefined) {

validateInteger(offset, 'offset', 0);

if (offset >= viewLength) return new FastBuffer();

start = offset;

}

if (length !== undefined) {

validateInteger(length, 'length', 0);

// The old code used TypedArrayPrototypeSlice which clamps internally.

end = MathMin(start + length, viewLength);

}

if (end <= start) return new FastBuffer();

const viewByteLength = TypedArrayPrototypeGetByteLength(view);

const elementSize = viewByteLength / viewLength;

const srcByteOffset = TypedArrayPrototypeGetByteOffset(view) +

start * elementSize;

const srcByteLength = (end - start) * elementSize;

return fromArrayLike(new Uint8Array(

TypedArrayPrototypeGetBuffer(view),

srcByteOffset,

srcByteLength));

};

// Identical to the built-in %TypedArray%.of(), but avoids using the deprecated

// Buffer() constructor. Must use arrow function syntax to avoid automatically

// adding a `prototype` property and making the function a constructor.

//

// Refs: https://tc39.github.io/ecma262/#sec-%typedarray%.of

// Refs: https://esdiscuss.org/topic/isconstructor#content-11

const of = (...items) => {

const len = items.length;

const newObj = new FastBuffer(len); // In heap for small sizes

for (let k = 0; k < len; k++)

newObj[k] = items[k];

return newObj;

};

Buffer.of = of;

ObjectSetPrototypeOf(Buffer, Uint8Array);

/**

* Creates a new filled Buffer instance.

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

* @returns {FastBuffer}

*/

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

validateNumber(size, 'size', 0, kMaxLength);

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

const buf = createUnsafeBuffer(size);

return _fill(buf, fill, 0, buf.length, 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.

*

* If `alignment` is given, the memory backing the returned buffer starts at an

* address that is a multiple of `alignment`. See `Buffer.allocUnsafeSlow()`.

* @param {number} size

* @param {number} [alignment] A power of two, at most 2 ** 30

* @returns {FastBuffer}

*/

Buffer.allocUnsafe = function allocUnsafe(size, alignment) {

validateNumber(size, 'size', 0, kMaxLength);

if (alignment === undefined) {

return allocate(size);

}

validateAlignment(size, alignment);

return allocateAligned(size, alignment);

};

/**

* 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.

*

* If `alignment` is given, the memory backing the returned buffer starts at an

* address that is a multiple of `alignment`, which is required by e.g. reads

* and writes on file descriptors opened with `O_DIRECT`. Note that at least

* `alignment` extra bytes are allocated to satisfy the request, and that the

* returned buffer's `byteOffset` is therefore usually non-zero.

* @param {number} size

* @param {number} [alignment] A power of two, at most 2 ** 30

* @returns {FastBuffer}

*/

Buffer.allocUnsafeSlow = function allocUnsafeSlow(size, alignment) {

validateNumber(size, 'size', 0, kMaxLength);

if (alignment === undefined) {

return createUnsafeBuffer(size);

}

validateAlignment(size, alignment);

return createUnsafeAlignedBuffer(size, alignment);

};

function validateAlignment(size, alignment) {

validateInteger(alignment, 'alignment', 1, kMaxAlignment);

if ((alignment & (alignment - 1)) !== 0) {

throw new ERR_INVALID_ARG_VALUE(

'alignment', alignment, 'must be a power of two');

}

const padding = alignmentPadding(alignment);

if (size > kMaxLength - padding) {

throw new ERR_OUT_OF_RANGE(

'size', `<= ${kMaxLength - padding}`, size);

}

}

function allocate(size) {

if (size <= 0) {

return new FastBuffer();

}

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

if (size > (poolSize - poolOffset))

createPool();

const b = new FastBuffer(allocPool, poolBase + poolOffset, size);

poolOffset += size;

alignPool();

return b;

}

return createUnsafeBuffer(size);

}

function allocateAligned(size, alignment) {

if (size <= 0) {

return new FastBuffer();

}

// The pool starts at a `kPoolAlignment` aligned address, so any alignment up

// to that can be satisfied by padding the offset into the pool. Stricter

// alignments need an allocation of their own.

if (alignment > kPoolAlignment || size >= (Buffer.poolSize >>> 1)) {

return createUnsafeAlignedBuffer(size, alignment);

}

poolOffset = (poolOffset + alignment - 1) & ~(alignment - 1);

if (size > (poolSize - poolOffset))

createPool();

const b = new FastBuffer(allocPool, poolBase + poolOffset, size);

poolOffset += size;

alignPool();

return b;

}

function fromStringFast(string, ops) {

const maxLength = Buffer.poolSize >>> 1;

let length = string.length; // Min length

if (length >= maxLength)

return createFromString(string, ops);

length *= 4; // Max length (4 bytes per character)

if (length >= maxLength)

length = ops.byteLength(string); // Actual length

if (length >= maxLength)

return createFromString(string, ops, length);

if (length > (poolSize - poolOffset))

createPool();

const actual = ops.write(allocBuffer, string, poolOffset, length);

const b = new FastBuffer(allocPool, poolBase + poolOffset, actual);

poolOffset += actual;

alignPool();

return b;

}

function createFromString(string, ops, length = ops.byteLength(string)) {

const buf = Buffer.allocUnsafeSlow(length);

const actual = ops.write(buf, string, 0, length);

return actual < length ? new FastBuffer(buf.buffer, 0, actual) : buf;

}

function fromString(string, encoding) {

let ops;

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

ops = encodingOps.utf8;

} else {

ops = getEncodingOps(encoding);

if (ops === undefined)

throw new ERR_UNKNOWN_ENCODING(encoding);

}

return string.length === 0 ? new FastBuffer() : fromStringFast(string, ops);

}

function fromArrayBuffer(obj, byteOffset, length) {

// Convert byteOffset to integer

if (byteOffset === undefined) {

byteOffset = 0;

} else {

byteOffset = +byteOffset;

if (NumberIsNaN(byteOffset))

byteOffset = 0;

}

const maxLength = obj.byteLength - byteOffset;

if (maxLength < 0)

throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');

if (length !== undefined) {

// Convert length to non-negative integer.

length = +length;

if (length > 0) {

if (length > maxLength)

throw new ERR_BUFFER_OUT_OF_BOUNDS('length');

} else {

length = 0;

}

}

return new FastBuffer(obj, byteOffset, length);

}

function fromArrayLike(obj) {

const { length } = obj;

if (length <= 0)

return new FastBuffer();

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

if (length > (poolSize - poolOffset))

createPool();

const b = new FastBuffer(allocPool, poolBase + poolOffset, length);

TypedArrayPrototypeSet(b, obj, 0);

poolOffset += length;

alignPool();

return b;

}

return new FastBuffer(obj);

}

function fromObject(obj) {

if (obj.length !== undefined || isAnyArrayBuffer(obj.buffer)) {

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

return new FastBuffer();

}

return fromArrayLike(obj);

}

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

return fromArrayLike(obj.data);

}

}

// Static methods

Buffer.isBuffer = function isBuffer(b) {

return b instanceof Buffer;

};

Buffer.compare = function compare(buf1, buf2) {

if (!isUint8Array(buf1)) {

throw new ERR_INVALID_ARG_TYPE('buf1', ['Buffer', 'Uint8Array'], buf1);

}

if (!isUint8Array(buf2)) {

throw new ERR_INVALID_ARG_TYPE('buf2', ['Buffer', 'Uint8Array'], buf2);

}

if (buf1 === buf2) {

return 0;

}

return _compare(buf1, buf2);

};

Buffer.isEncoding = function isEncoding(encoding) {

return typeof encoding === 'string' && encoding.length !== 0 &&

normalizeEncoding(encoding) !== undefined;

};

Buffer[kIsEncodingSymbol] = Buffer.isEncoding;

Buffer.concat = function concat(list, length) {

validateArray(list, 'list');

if (list.length === 0)

return new FastBuffer();

if (length === undefined) {

length = 0;

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

const buf = list[i];

if (!isUint8Array(buf)) {

// TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.

// Instead, find the proper error code for this.

throw new ERR_INVALID_ARG_TYPE(

`list[${i}]`, ['Buffer', 'Uint8Array'], buf);

}

length += TypedArrayPrototypeGetByteLength(buf);

}

const buffer = allocate(length);

let pos = 0;

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

const buf = list[i];

const bufLength = TypedArrayPrototypeGetByteLength(buf);

TypedArrayPrototypeSet(buffer, buf, pos);

pos += bufLength;

}

if (pos < length) {

TypedArrayPrototypeFill(buffer, 0, pos, length);

}

return buffer;

}

validateOffset(length, 'length');

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

if (!isUint8Array(list[i])) {

// TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.

// Instead, find the proper error code for this.

throw new ERR_INVALID_ARG_TYPE(

`list[${i}]`, ['Buffer', 'Uint8Array'], list[i]);

}

}

const buffer = allocate(length);

let pos = 0;

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

const buf = list[i];

const bufLength = TypedArrayPrototypeGetByteLength(buf);

if (pos + bufLength > length) {

TypedArrayPrototypeSet(buffer,

TypedArrayPrototypeSubarray(buf, 0, length - pos),

pos);

pos = length;

break;

}

TypedArrayPrototypeSet(buffer, buf, pos);

pos += bufLength;

}

// 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.

TypedArrayPrototypeFill(buffer, 0, pos, length);

}

return buffer;

};

function base64ByteLength(str, bytes) {

// Handle padding

if (StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)

bytes--;

if (bytes > 1 && StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)

bytes--;

// Base64 ratio: 3/4

return (bytes * 3) >>> 2;

}

const encodingOps = {

utf8: {

encoding: 'utf8',

encodingVal: encodingsMap.utf8,

byteLength: byteLengthUtf8,

write: utf8Write,

slice: utf8Slice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfString(buf, val, byteOffset, encodingsMap.utf8, dir, end),

},

ucs2: {

encoding: 'ucs2',

encodingVal: encodingsMap.utf16le,

byteLength: (string) => string.length * 2,

write: ucs2Write,

slice: ucs2Slice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir, end),

},

utf16le: {

encoding: 'utf16le',

encodingVal: encodingsMap.utf16le,

byteLength: (string) => string.length * 2,

write: ucs2Write,

slice: ucs2Slice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir, end),

},

latin1: {

encoding: 'latin1',

encodingVal: encodingsMap.latin1,

byteLength: (string) => string.length,

write: latin1Write,

slice: latin1Slice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir, end),

},

ascii: {

encoding: 'ascii',

encodingVal: encodingsMap.ascii,

byteLength: (string) => string.length,

write: asciiWrite,

slice: asciiSlice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfBuffer(buf,

fromStringFast(val, encodingOps.ascii),

byteOffset,

encodingsMap.ascii,

dir,

end),

},

base64: {

encoding: 'base64',

encodingVal: encodingsMap.base64,

byteLength: (string) => base64ByteLength(string, string.length),

write: base64Write,

slice: base64Slice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfBuffer(buf,

fromStringFast(val, encodingOps.base64),

byteOffset,

encodingsMap.base64,

dir,

end),

},

base64url: {

encoding: 'base64url',

encodingVal: encodingsMap.base64url,

byteLength: (string) => base64ByteLength(string, string.length),

write: base64urlWrite,

slice: base64urlSlice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfBuffer(buf,

fromStringFast(val, encodingOps.base64url),

byteOffset,

encodingsMap.base64url,

dir,

end),

},

hex: {

encoding: 'hex',

encodingVal: encodingsMap.hex,

byteLength: (string) => string.length >>> 1,

write: hexWrite,

slice: hexSlice,

indexOf: (buf, val, byteOffset, dir, end) =>

indexOfBuffer(buf,

fromStringFast(val, encodingOps.hex),

byteOffset,

encodingsMap.hex,

dir,

end),

},

};

function getEncodingOps(encoding) {

encoding += '';

switch (encoding.length) {

case 4:

if (encoding === 'utf8') return encodingOps.utf8;

if (encoding === 'ucs2') return encodingOps.ucs2;

encoding = StringPrototypeToLowerCase(encoding);

if (encoding === 'utf8') return encodingOps.utf8;

if (encoding === 'ucs2') return encodingOps.ucs2;

break;

case 5:

if (encoding === 'utf-8') return encodingOps.utf8;

if (encoding === 'ascii') return encodingOps.ascii;

if (encoding === 'ucs-2') return encodingOps.ucs2;

encoding = StringPrototypeToLowerCase(encoding);

if (encoding === 'utf-8') return encodingOps.utf8;

if (encoding === 'ascii') return encodingOps.ascii;

if (encoding === 'ucs-2') return encodingOps.ucs2;

break;

case 7:

if (encoding === 'utf16le' ||

StringPrototypeToLowerCase(encoding) === 'utf16le')

return encodingOps.utf16le;

break;

case 8:

if (encoding === 'utf-16le' ||

StringPrototypeToLowerCase(encoding) === 'utf-16le')

return encodingOps.utf16le;

break;

case 6:

if (encoding === 'latin1' || encoding === 'binary')

return encodingOps.latin1;

if (encoding === 'base64') return encodingOps.base64;

encoding = StringPrototypeToLowerCase(encoding);

if (encoding === 'latin1' || encoding === 'binary')

return encodingOps.latin1;

if (encoding === 'base64') return encodingOps.base64;

break;

case 3:

if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')

return encodingOps.hex;

break;

case 9:

if (encoding === 'base64url' ||

StringPrototypeToLowerCase(encoding) === 'base64url')

return encodingOps.base64url;

break;

}

}

function byteLength(string, encoding) {

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

if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {

return string.byteLength;

}

throw new ERR_INVALID_ARG_TYPE(

'string', ['string', 'Buffer', 'ArrayBuffer'], string,

);

}

const len = string.length;

if (len === 0)

return 0;

if (!encoding || encoding === 'utf8') {

return byteLengthUtf8(string);

}

if (encoding === 'ascii') {

return len;

}

const ops = getEncodingOps(encoding);

if (ops === undefined) {

// TODO (ronag): Makes more sense to throw here.

// throw new ERR_UNKNOWN_ENCODING(encoding);

return byteLengthUtf8(string);

}

return ops.byteLength(string);

}

Buffer.byteLength = byteLength;

Buffer.stringLength = stringLength;

// For backwards compatibility.

ObjectDefineProperty(Buffer.prototype, 'parent', {

__proto__: null,

enumerable: true,

get() {

if (!(this instanceof Buffer))

return undefined;

return this.buffer;

},

});

ObjectDefineProperty(Buffer.prototype, 'offset', {

__proto__: null,

enumerable: true,

get() {

if (!(this instanceof Buffer))

return undefined;

return this.byteOffset;

},

});

Buffer.prototype.copy =

function copy(target, targetStart, sourceStart, sourceEnd) {

return copyImpl(this, target, targetStart, sourceStart, sourceEnd);

};

// No need to verify that "buf.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.

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

if (arguments.length === 0) {

return utf8Slice(this, 0, this.length);

}

const bufferLength = TypedArrayPrototypeGetLength(this);

if (start <= 0)

start = 0;

else if (start >= bufferLength)

return '';

else

start = MathTrunc(start) || 0;

if (end === undefined || end > bufferLength)

end = bufferLength;

else

end = MathTrunc(end) || 0;

if (end <= start)

return '';

if (encoding === undefined)

return utf8Slice(this, start, end);

const ops = getEncodingOps(encoding);

if (ops === undefined)