From fe0bc1c892925719a46cec659e06f31be53e48a4 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 4 Feb 2023 14:02:10 -0800
Subject: [PATCH] buffer: add Buffer.copyFrom(...)

Fixes: https://github.com/nodejs/node/issues/43862
---
 doc/api/buffer.md                 | 22 ++++++++++++++
 lib/buffer.js                     | 50 +++++++++++++++++++++++++++++++
 test/parallel/test-buffer-from.js | 45 +++++++++++++++++++++++++++-
 3 files changed, 116 insertions(+), 1 deletion(-)

diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index 5c8b661e76e9cd..459c23688ecd08 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -1058,6 +1058,28 @@ console.log(bufA.length);
 `Buffer.concat()` may also use the internal `Buffer` pool like
 [`Buffer.allocUnsafe()`][] does.
 
+### Static method: `Buffer.copyFrom(view[, offset[, length]])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `view` {TypedArray} The {TypedArray} to copy.
+* `offset` {integer} The starting offset within `view`. **Default:**: `0`.
+* `length` {integer} The number of elements from `view` to copy.
+  **Default:** `view\.length - offset`.
+
+Copies the underlying memory of `view` into a new `Buffer`.
+
+```js
+const u16 = new Uint16Array([0, 0xffff]);
+const buf = Buffer.copyFrom(u16, 0, 1);
+u16[1] = 0;
+console.log(buf.length); // 2
+console.log(buf[0]); // 255
+console.log(buf[1]); // 255
+```
+
 ### Static method: `Buffer.from(array)`
 
 <!-- YAML
diff --git a/lib/buffer.js b/lib/buffer.js
index 13654da10d3850..9f0fa86fc62615 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -43,9 +43,13 @@ const {
   StringPrototypeTrim,
   SymbolSpecies,
   SymbolToPrimitive,
+  TypedArrayPrototypeGetBuffer,
   TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeGetByteOffset,
   TypedArrayPrototypeFill,
+  TypedArrayPrototypeGetLength,
   TypedArrayPrototypeSet,
+  TypedArrayPrototypeSlice,
   Uint8Array,
   Uint8ArrayPrototype,
 } = primordials;
@@ -330,6 +334,52 @@ Buffer.from = function from(value, encodingOrOffset, length) {
   );
 };
 
+/**
+ * Creates the Buffer as a copy of the underlying ArrayBuffer of the view
+ * rather than the contents of the view.
+ * @param {ArrayBufferView} view
+ * @param {number} [offset]
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.copyFrom = function copyFrom(view, offset, length) {
+  if (!isTypedArray(view)) {
+    throw new ERR_INVALID_ARG_TYPE('view', [ 'TypedArray' ], view);
+  }
+
+  const viewLength = TypedArrayPrototypeGetLength(view);
+  if (viewLength === 0) {
+    return Buffer.alloc(0);
+  }
+
+  if (offset !== undefined || length !== undefined) {
+    if (offset !== undefined) {
+      validateInteger(offset, 'offset', 0);
+    } else {
+      offset = 0;
+    }
+    if (length !== undefined) {
+      validateInteger(length, 'length', 0);
+    } else {
+      length = viewLength;
+    }
+
+    offset = MathMin(offset, viewLength);
+    length = MathMin(length, viewLength - offset);
+
+    if (length === 0) {
+      return Buffer.alloc(0);
+    }
+
+    view = TypedArrayPrototypeSlice(view, offset, offset + length);
+  }
+
+  return fromArrayLike(new Uint8Array(
+    TypedArrayPrototypeGetBuffer(view),
+    TypedArrayPrototypeGetByteOffset(view),
+    TypedArrayPrototypeGetByteLength(view)));
+};
+
 // 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.
diff --git a/test/parallel/test-buffer-from.js b/test/parallel/test-buffer-from.js
index 04f52b3f325637..0059e2a8db47eb 100644
--- a/test/parallel/test-buffer-from.js
+++ b/test/parallel/test-buffer-from.js
@@ -1,7 +1,7 @@
 'use strict';
 
 const common = require('../common');
-const { deepStrictEqual, throws } = require('assert');
+const { deepStrictEqual, strictEqual, throws } = require('assert');
 const { runInNewContext } = require('vm');
 
 const checkString = 'test';
@@ -62,3 +62,46 @@ deepStrictEqual(
 
 Buffer.allocUnsafe(10); // Should not throw.
 Buffer.from('deadbeaf', 'hex'); // Should not throw.
+
+
+{
+  const u16 = new Uint16Array([0xffff]);
+  const b16 = Buffer.copyFrom(u16);
+  u16[0] = 0;
+  strictEqual(b16.length, 2);
+  strictEqual(b16[0], 255);
+  strictEqual(b16[1], 255);
+}
+
+{
+  const u16 = new Uint16Array([0, 0xffff]);
+  const b16 = Buffer.copyFrom(u16, 1, 5);
+  u16[0] = 0xffff;
+  u16[1] = 0;
+  strictEqual(b16.length, 2);
+  strictEqual(b16[0], 255);
+  strictEqual(b16[1], 255);
+}
+
+{
+  const u32 = new Uint32Array([0xffffffff]);
+  const b32 = Buffer.copyFrom(u32);
+  u32[0] = 0;
+  strictEqual(b32.length, 4);
+  strictEqual(b32[0], 255);
+  strictEqual(b32[1], 255);
+  strictEqual(b32[2], 255);
+  strictEqual(b32[3], 255);
+}
+
+throws(() => {
+  Buffer.copyFrom('nope');
+}, {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+
+throws(() => {
+  Buffer.copyFrom(new Uint8Array(1), 'a');
+}, {
+  code: 'ERR_INVALID_ARG_TYPE',
+});