buffer: treat detached ArrayBuffers as empty

Treat detached ArrayBuffers and Buffer or TypedArray views backed by
them as zero-length inputs in buffer.isUtf8() and buffer.isAscii(). Both
functions now return true for these inputs, consistent with other empty
inputs.
Signed-off-by: Archkon <180910180+Archkon@users.noreply.github.com>
PR-URL: #64504Fixes: #64503
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: Archkon

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }

doc/api/buffer.md

@@ -5317,6 +5317,11 @@ npx codemod@latest @nodejs/buffer-atob-btoa
 added:
  - v19.6.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5325,14 +5330,19 @@ added:
 This function returns `true` if `input` contains only valid ASCII-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.isUtf8(input)`
 
 <!-- YAML
 added:
  - v19.4.0
  - v18.14.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/64504
+ description: Detached `ArrayBuffer`s and views backed by them are treated
+ as empty.
 -->
 
 *`input` {Buffer | ArrayBuffer | TypedArray} The input to validate.
@@ -5341,7 +5351,7 @@ added:
 This function returns `true` if `input` contains only valid UTF-8-encoded data,
 including the case in which `input` is empty.
 
-Throws if the `input` is a detached array buffer.
+A detached `ArrayBuffer`, or a `TypedArray` backed by one, is treated as empty.
 
 ### `buffer.INSPECT_MAX_BYTES`
 

src/node_buffer.cc

@@ -1360,31 +1360,17 @@ void FastSwap64(Local<Value> receiver,
 
 static CFunction fast_swap64(CFunction::Make(FastSwap64));
 
-structValidationResult {
-bool is_valid;
-bool was_detached;
-};
-
-static ValidationResult ValidateUtf8(Local<Value> value) {
+staticboolValidateUtf8(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {!was_detached && simdutf::validate_utf8(abv.data(), abv.length()),
- was_detached};
+return abv.length() == 0 || simdutf::validate_utf8(abv.data(), abv.length());
 }
 
 staticvoidIsUtf8(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateUtf8(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateUtf8(args[0]));
 }
 
 staticboolFastIsUtf8(Local<Value> receiver,
@@ -1393,40 +1379,23 @@ static bool FastIsUtf8(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isUtf8");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateUtf8(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateUtf8(value);
 }
 
 static CFunction fast_is_utf8(CFunction::Make(FastIsUtf8));
 
-staticValidationResultValidateAscii(Local<Value> value) {
+staticboolValidateAscii(Local<Value> value) {
  ArrayBufferViewContents<char> abv(value);
-bool was_detached = abv.WasDetached();
-return {
- !was_detached &&
- !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error,
- was_detached};
+return abv.length() == 0 ||
+ !simdutf::validate_ascii_with_errors(abv.data(), abv.length()).error;
 }
 
 staticvoidIsAscii(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsTypedArray() || args[0]->IsArrayBuffer() ||
  args[0]->IsSharedArrayBuffer());
 
-const ValidationResult result = ValidateAscii(args[0]);
-if (result.was_detached) {
-returnnode::THROW_ERR_INVALID_STATE(
- env, "Cannot validate on a detached buffer");
- }
-
- args.GetReturnValue().Set(result.is_valid);
+ args.GetReturnValue().Set(ValidateAscii(args[0]));
 }
 
 staticboolFastIsAscii(Local<Value> receiver,
@@ -1435,14 +1404,7 @@ static bool FastIsAscii(Local<Value> receiver,
  FastApiCallbackOptions& options) {
 TRACK_V8_FAST_API_CALL("buffer.isAscii");
  HandleScope scope(options.isolate);
-
-const ValidationResult result = ValidateAscii(value);
-if (result.was_detached) {
-node::THROW_ERR_INVALID_STATE(options.isolate,
-"Cannot validate on a detached buffer");
-returnfalse;
- }
-return result.is_valid;
+returnValidateAscii(value);
 }
 
 static CFunction fast_is_ascii(CFunction::Make(FastIsAscii));

test/parallel/test-buffer-isascii.js

@@ -30,13 +30,20 @@ assert.strictEqual(isAscii(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isAscii(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isAscii(input),true);
+}
 }

test/parallel/test-buffer-isutf8.js

@@ -74,13 +74,20 @@ assert.strictEqual(isUtf8(Buffer.from([])), true);
 });
 
 {
-// Test with detached array buffers
-constarrayBuffer=newArrayBuffer(1024);
+// Detached array buffers and views are treated as empty.
+constarrayBuffer=newArrayBuffer(1);
+consttypedArray=newUint8Array(arrayBuffer);
+typedArray[0]=0xff;
+constinputs=[
+arrayBuffer,
+typedArray,
+Buffer.from(arrayBuffer),
+];
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),false);
+}
 structuredClone(arrayBuffer,{transfer: [arrayBuffer]});
-assert.throws(
-()=>{isUtf8(arrayBuffer);},
-{
-code: 'ERR_INVALID_STATE'
-}
-);
+for(constinputofinputs){
+assert.strictEqual(isUtf8(input),true);
+}
 }