buffer: cleanup handling different types buffers

PR-URL: #54439
Assisted-by: Claude Code:Opus 4.6

Author: ronag

lib/buffer.js

@@ -45,12 +45,7 @@ const {
   SymbolSpecies,
   SymbolToPrimitive,
   TypedArrayPrototypeFill,
-  TypedArrayPrototypeGetBuffer,
-  TypedArrayPrototypeGetByteLength,
-  TypedArrayPrototypeGetByteOffset,
-  TypedArrayPrototypeGetLength,
   TypedArrayPrototypeSet,
-  TypedArrayPrototypeSubarray,
   Uint8Array,
 } = primordials;
 
@@ -104,7 +99,6 @@ const {
   isAnyArrayBuffer,
   isArrayBufferView,
   isUint8Array,
-  isTypedArray,
 } = require('internal/util/types');
 const {
   inspect: utilInspect,
@@ -154,6 +148,15 @@ FastBuffer.prototype.constructor = Buffer;
 Buffer.prototype = FastBuffer.prototype;
 addBufferPrototypeMethods(Buffer.prototype);
 
+const BUFFER_NAMES = [
+  'ArrayBuffer',
+  'Buffer',
+  'TypedArray',
+  'DataView',
+  'ArrayBuffer',
+  'SharedArrayBuffer',
+];
+
 const constants = ObjectDefineProperties({}, {
   MAX_LENGTH: {
     __proto__: null,
@@ -232,10 +235,13 @@ function toInteger(n, 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 (isArrayBufferView(target)) {
+    // Do nothing..
+  } else if (isAnyArrayBuffer(target)) {
+    target = new Uint8Array(target);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('target', BUFFER_NAMES, target);
+  }
 
   if (targetStart === undefined) {
     targetStart = 0;
@@ -359,25 +365,29 @@ Buffer.from = function from(value, encodingOrOffset, length) {
 
   throw new ERR_INVALID_ARG_TYPE(
     'first argument',
-    ['string', 'Buffer', 'ArrayBuffer', 'Array', 'Array-like Object'],
+    ['string', 'Array', 'Array-like Object', ...BUFFER_NAMES],
     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 {Buffer|TypedArray|DataView} 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);
+  if (isArrayBufferView(view)) {
+    // Do nothing..
+  } else if (isAnyArrayBuffer(view)) {
+    view = new Uint8Array(view);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('view', BUFFER_NAMES, view);
   }
 
-  const viewLength = TypedArrayPrototypeGetLength(view);
+  const viewLength = view.byteLength;
   if (viewLength === 0) {
     return new FastBuffer();
   }
@@ -399,16 +409,16 @@ Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
 
   if (end <= start) return new FastBuffer();
 
-  const viewByteLength = TypedArrayPrototypeGetByteLength(view);
+  const viewByteLength = view.byteLength;
   const elementSize = viewByteLength / viewLength;
-  const srcByteOffset = TypedArrayPrototypeGetByteOffset(view) +
+  const srcByteOffset = view.byteOffset +
                         start * elementSize;
   const srcByteLength = (end - start) * elementSize;
 
   return fromArrayLike(new Uint8Array(
-    TypedArrayPrototypeGetBuffer(view),
+    view.buffer,
     srcByteOffset,
-    srcByteLength));
+    srcByteLength))
 };
 
 // Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
@@ -621,20 +631,20 @@ Buffer.concat = function concat(list, length) {
     length = 0;
     for (let i = 0; i < list.length; i++) {
       const buf = list[i];
-      if (!isUint8Array(buf)) {
+      if (!isArrayBufferView(buf) && !isAnyArrayBuffer(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);
+          `list[${i}]`, BUFFER_NAMES, buf);
       }
-      length += TypedArrayPrototypeGetByteLength(buf);
+      length += buf.byteLength;
     }
 
     const buffer = allocate(length);
     let pos = 0;
     for (let i = 0; i < list.length; i++) {
       const buf = list[i];
-      const bufLength = TypedArrayPrototypeGetByteLength(buf);
+      const bufLength = buf.byteLength;
       TypedArrayPrototypeSet(buffer, buf, pos);
       pos += bufLength;
     }
@@ -647,22 +657,22 @@ Buffer.concat = function concat(list, length) {
 
   validateOffset(length, 'length');
   for (let i = 0; i < list.length; i++) {
-    if (!isUint8Array(list[i])) {
+    if (!isArrayBufferView(list[i]) && !isAnyArrayBuffer(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]);
+        `list[${i}]`, BUFFER_NAMES, 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);
+    const bufLength = buf.byteLength;
     if (pos + bufLength > length) {
       TypedArrayPrototypeSet(buffer,
-                             TypedArrayPrototypeSubarray(buf, 0, length - pos),
+                             buf.subarray(0, length - pos),
                              pos);
       pos = length;
       break;
@@ -834,10 +844,7 @@ function byteLength(string, encoding) {
     if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {
       return string.byteLength;
     }
-
-    throw new ERR_INVALID_ARG_TYPE(
-      'string', ['string', 'Buffer', 'ArrayBuffer'], string,
-    );
+    throw new ERR_INVALID_ARG_TYPE('string', ['string', ...BUFFER_NAMES], string);
   }
 
   const len = string.length;
@@ -898,7 +905,7 @@ Buffer.prototype.toString = function toString(encoding, start, end) {
     return utf8Slice(this, 0, this.length);
   }
 
-  const bufferLength = TypedArrayPrototypeGetLength(this);
+  const bufferLength = this.length;
 
   if (start <= 0)
     start = 0;
@@ -926,15 +933,18 @@ Buffer.prototype.toString = function toString(encoding, start, end) {
 };
 
 Buffer.prototype.equals = function equals(otherBuffer) {
-  if (!isUint8Array(otherBuffer)) {
-    throw new ERR_INVALID_ARG_TYPE(
-      'otherBuffer', ['Buffer', 'Uint8Array'], otherBuffer);
+  if (isArrayBufferView(otherBuffer)) {
+    // Do nothing..
+  } else if (isAnyArrayBuffer(otherBuffer)) {
+    otherBuffer = new Uint8Array(otherBuffer);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('otherBuffer', BUFFER_NAMES, otherBuffer);
   }
 
   if (this === otherBuffer)
     return true;
-  const len = TypedArrayPrototypeGetByteLength(this);
-  if (len !== TypedArrayPrototypeGetByteLength(otherBuffer))
+  const len = this.byteLength;
+  if (len !== otherBuffer.byteLength)
     return false;
 
   return len === 0 || _compare(this, otherBuffer) === 0;
@@ -988,9 +998,14 @@ Buffer.prototype.compare = function compare(target,
                                             targetEnd,
                                             sourceStart,
                                             sourceEnd) {
-  if (!isUint8Array(target)) {
-    throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+  if (isArrayBufferView(target)) {
+    // Do nothing..
+  } else if (isAnyArrayBuffer(target)) {
+    target = new Uint8Array(target);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('target', BUFFER_NAMES, target);
   }
+
   if (arguments.length === 1)
     return _compare(this, target);
 
@@ -1066,14 +1081,14 @@ function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
     return ops.indexOf(buffer, val, byteOffset, dir);
   }
 
-  if (isUint8Array(val)) {
+  if (isArrayBufferView(val) || isAnyArrayBuffer(val)) {
     const encodingVal =
       (ops === undefined ? encodingsMap.utf8 : ops.encodingVal);
     return indexOfBuffer(buffer, val, byteOffset, encodingVal, dir);
   }
 
   throw new ERR_INVALID_ARG_TYPE(
-    'value', ['number', 'string', 'Buffer', 'Uint8Array'], val,
+    'value', ['number', 'string', ...BUFFER_NAMES], val,
   );
 }
 
@@ -1152,7 +1167,7 @@ function _fill(buf, value, offset, end, encoding) {
 
   if (typeof value === 'number') {
     // OOB check
-    const byteLen = TypedArrayPrototypeGetByteLength(buf);
+    const byteLen = buf.byteLength;
     const fillLength = end - offset;
     if (offset > end || fillLength + offset > byteLen)
       throw new ERR_BUFFER_OUT_OF_BOUNDS();
@@ -1171,7 +1186,7 @@ function _fill(buf, value, offset, end, encoding) {
 }
 
 Buffer.prototype.write = function write(string, offset, length, encoding) {
-  const bufferLength = TypedArrayPrototypeGetLength(this);
+  const bufferLength = this.length;
   // Buffer#write(string);
   if (offset === undefined) {
     return utf8Write(this, string, 0, bufferLength);
@@ -1212,7 +1227,7 @@ Buffer.prototype.write = function write(string, offset, length, encoding) {
 };
 
 Buffer.prototype.toJSON = function toJSON() {
-  const bufferLength = TypedArrayPrototypeGetLength(this);
+  const bufferLength = this.length;
   if (bufferLength > 0) {
     const data = new Array(bufferLength);
     for (let i = 0; i < bufferLength; ++i)
@@ -1240,7 +1255,7 @@ function adjustOffset(offset, length) {
 }
 
 Buffer.prototype.subarray = function subarray(start, end) {
-  const srcLength = TypedArrayPrototypeGetLength(this);
+  const srcLength = this.length;
   start = adjustOffset(start, srcLength);
   end = end !== undefined ? adjustOffset(end, srcLength) : srcLength;
   const newLength = end > start ? end - start : 0;
@@ -1262,7 +1277,7 @@ Buffer.prototype.swap16 = function swap16() {
   // For Buffer.length <= 32, it's generally faster to
   // do the swap in javascript. For larger buffers,
   // dropping down to the native code is faster.
-  const len = TypedArrayPrototypeGetLength(this);
+  const len = this.length;
   if (len % 2 !== 0)
     throw new ERR_INVALID_BUFFER_SIZE('16-bits');
   if (len <= 32) {
@@ -1279,7 +1294,7 @@ Buffer.prototype.swap32 = function swap32() {
   // For Buffer.length <= 32, it's generally faster to
   // do the swap in javascript. For larger buffers,
   // dropping down to the native code is faster.
-  const len = TypedArrayPrototypeGetLength(this);
+  const len = this.length;
   if (len % 4 !== 0)
     throw new ERR_INVALID_BUFFER_SIZE('32-bits');
   if (len <= 32) {
@@ -1300,7 +1315,7 @@ Buffer.prototype.swap64 = function swap64() {
   // dropping down to the native code is faster.
   // Threshold differs from swap16/swap32 (<=32) because swap64's
   // crossover is between 40 and 48 (native wins at 48, loses at 40).
-  const len = TypedArrayPrototypeGetLength(this);
+  const len = this.length;
   if (len % 8 !== 0)
     throw new ERR_INVALID_BUFFER_SIZE('64-bits');
   if (len < 48) {
@@ -1328,9 +1343,8 @@ if (internalBinding('config').hasIntl) {
   // Transcodes the Buffer from one encoding to another, returning a new
   // Buffer instance.
   transcode = function transcode(source, fromEncoding, toEncoding) {
-    if (!isUint8Array(source)) {
-      throw new ERR_INVALID_ARG_TYPE('source',
-                                     ['Buffer', 'Uint8Array'], source);
+    if (!ArrayBufferIsView(source) && !isAnyArrayBuffer(source)) {
+      throw new ERR_INVALID_ARG_TYPE('source', BUFFER_NAMES, source);
     }
     if (source.length === 0) return new FastBuffer();
 
@@ -1386,19 +1400,19 @@ function atob(input) {
 }
 
 function isUtf8(input) {
-  if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+  if (isArrayBufferView(input) || isAnyArrayBuffer(input)) {
     return bindingIsUtf8(input);
   }
 
-  throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+  throw new ERR_INVALID_ARG_TYPE('input', BUFFER_NAMES, input);
 }
 
 function isAscii(input) {
-  if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+  if (isArrayBufferView(input) || isAnyArrayBuffer(input)) {
     return bindingIsAscii(input);
   }
 
-  throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+  throw new ERR_INVALID_ARG_TYPE('input', BUFFER_NAMES, input);
 }
 
 module.exports = {