resolved feedback

Author: thisalihassan

lib/buffer.js

@@ -378,46 +378,35 @@ Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
   }
 
   const viewLength = TypedArrayPrototypeGetLength(view);
-  if (viewLength === 0) {
-    return new FastBuffer();
-  }
+  if (viewLength === 0) return new FastBuffer();
 
-  const byteLength = TypedArrayPrototypeGetByteLength(view);
+  let start = 0;
+  let end = viewLength;
 
-  if (offset !== undefined || length !== undefined) {
-    if (offset !== undefined) {
-      validateInteger(offset, 'offset', 0);
-      if (offset >= viewLength) return new FastBuffer();
-    } else {
-      offset = 0;
-    }
-
-    let end;
-    if (length !== undefined) {
-      validateInteger(length, 'length', 0);
-      // The old code used TypedArrayPrototypeSlice which clamps internally.
-      end = MathMin(offset + length, viewLength);
-    } else {
-      end = viewLength;
-    }
+  if (offset !== undefined) {
+    validateInteger(offset, 'offset', 0);
+    if (offset >= viewLength) return new FastBuffer();
+    start = offset;
+  }
 
-    if (end <= offset) return new FastBuffer();
+  if (length !== undefined) {
+    validateInteger(length, 'length', 0);
+    // The old code used TypedArrayPrototypeSlice which clamps internally.
+    end = MathMin(start + length, viewLength);
+  }
 
-    const elementSize = byteLength / viewLength;
-    const srcByteOffset = TypedArrayPrototypeGetByteOffset(view) +
-                          offset * elementSize;
-    const srcByteLength = (end - offset) * elementSize;
+  if (end <= start) return new FastBuffer();
 
-    return fromArrayLike(new Uint8Array(
-      TypedArrayPrototypeGetBuffer(view),
-      srcByteOffset,
-      srcByteLength));
-  }
+  const byteLength = TypedArrayPrototypeGetByteLength(view);
+  const elementSize = byteLength / viewLength;
+  const srcByteOffset = TypedArrayPrototypeGetByteOffset(view) +
+                        start * elementSize;
+  const srcByteLength = (end - start) * elementSize;
 
   return fromArrayLike(new Uint8Array(
     TypedArrayPrototypeGetBuffer(view),
-    TypedArrayPrototypeGetByteOffset(view),
-    byteLength));
+    srcByteOffset,
+    srcByteLength));
 };
 
 // Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
@@ -564,15 +553,15 @@ function fromArrayBuffer(obj, byteOffset, length) {
 }
 
 function fromArrayLike(obj) {
-  const len = obj.length;
-  if (len <= 0)
+  const { length } = obj;
+  if (length <= 0)
     return new FastBuffer();
-  if (len < (Buffer.poolSize >>> 1)) {
-    if (len > (poolSize - poolOffset))
+  if (length < (Buffer.poolSize >>> 1)) {
+    if (length > (poolSize - poolOffset))
       createPool();
-    const b = new FastBuffer(allocPool, poolOffset, len);
+    const b = new FastBuffer(allocPool, poolOffset, length);
     TypedArrayPrototypeSet(b, obj, 0);
-    poolOffset += len;
+    poolOffset += length;
     alignPool();
     return b;
   }
@@ -1270,9 +1259,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.
-  if (!isUint8Array(this))
-    throw new ERR_INVALID_ARG_TYPE('this', ['Buffer', 'Uint8Array'], this);
-  const len = this.length;
+  const len = TypedArrayPrototypeGetLength(this);
   if (len % 2 !== 0)
     throw new ERR_INVALID_BUFFER_SIZE('16-bits');
   if (len <= 32) {
@@ -1288,9 +1275,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.
-  if (!isUint8Array(this))
-    throw new ERR_INVALID_ARG_TYPE('this', ['Buffer', 'Uint8Array'], this);
-  const len = this.length;
+  const len = TypedArrayPrototypeGetLength(this);
   if (len % 4 !== 0)
     throw new ERR_INVALID_BUFFER_SIZE('32-bits');
   if (len <= 32) {
@@ -1308,9 +1293,7 @@ Buffer.prototype.swap64 = function swap64() {
   // For Buffer.length < 48, it's generally faster to
   // do the swap in javascript. For larger buffers,
   // dropping down to the native code is faster.
-  if (!isUint8Array(this))
-    throw new ERR_INVALID_ARG_TYPE('this', ['Buffer', 'Uint8Array'], this);
-  const len = this.length;
+  const len = TypedArrayPrototypeGetLength(this);
   if (len % 8 !== 0)
     throw new ERR_INVALID_BUFFER_SIZE('64-bits');
   if (len < 48) {