src: move all 1-byte encodings to native

Author: ChALkeR

lib/internal/encoding.js

@@ -4,11 +4,13 @@
 // https://encoding.spec.whatwg.org
 
 const {
+  ArrayPrototypeMap,
   Boolean,
   ObjectDefineProperties,
   ObjectGetOwnPropertyDescriptors,
   ObjectSetPrototypeOf,
   ObjectValues,
+  SafeArrayIterator,
   SafeMap,
   StringPrototypeSlice,
   Symbol,
@@ -32,8 +34,6 @@ const kFatal = Symbol('kFatal');
 const kUTF8FastPath = Symbol('kUTF8FastPath');
 const kIgnoreBOM = Symbol('kIgnoreBOM');
 
-const { isSinglebyteEncoding, createSinglebyteDecoder } = require('internal/encoding/single-byte');
-
 const {
   getConstructorOf,
   customInspectSymbol: inspect,
@@ -58,6 +58,7 @@ const {
   encodeIntoResults,
   encodeUtf8String,
   decodeUTF8,
+  decodeSingleByte,
 } = binding;
 
 function validateDecoder(obj) {
@@ -71,6 +72,47 @@ const CONVERTER_FLAGS_IGNORE_BOM = 0x4;
 
 const empty = new FastBuffer();
 
+// Has to be synced with src/
+const encodingsSinglebyte = new SafeMap(new SafeArrayIterator(ArrayPrototypeMap([
+  'ibm866',
+  'koi8-r',
+  'koi8-u',
+  'macintosh',
+  'x-mac-cyrillic',
+  'iso-8859-2',
+  'iso-8859-3',
+  'iso-8859-4',
+  'iso-8859-5',
+  'iso-8859-6',
+  'iso-8859-7',
+  'iso-8859-8',
+  'iso-8859-8-i',
+  'iso-8859-10',
+  'iso-8859-13',
+  'iso-8859-14',
+  'iso-8859-15',
+  'iso-8859-16',
+  'windows-874',
+  'windows-1250',
+  'windows-1251',
+  'windows-1252',
+  'windows-1253',
+  'windows-1254',
+  'windows-1255',
+  'windows-1256',
+  'windows-1257',
+  'windows-1258',
+  'x-user-defined', // Has to be last, special case
+], (e, i) => [e, i])));
+
+const isSinglebyteEncoding = (enc) => encodingsSinglebyte.has(enc);
+
+function createSinglebyteDecoder(encoding, fatal) {
+  const key = encodingsSinglebyte.get(encoding);
+  if (key === undefined) throw new ERR_ENCODING_NOT_SUPPORTED(encoding);
+  return (buf) => decodeSingleByte(buf, key, fatal);
+}
+
 const encodings = new SafeMap([
   ['unicode-1-1-utf-8', 'utf-8'],
   ['unicode11utf8', 'utf-8'],
@@ -462,7 +504,7 @@ function makeTextDecoderICU() {
       validateDecoder(this);
       validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);
 
-      if (this[kMethod]) return this[kMethod](parseInput(input));
+      if (this[kMethod]) return this[kMethod](input);
 
       this[kUTF8FastPath] &&= !(options?.stream);
 

lib/internal/encoding/single-byte.js

@@ -1,5 +1,6 @@
 #include "encoding_binding.h"
 #include "ada.h"
+#include "encoding_singlebyte.h"
 #include "env-inl.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
@@ -389,6 +390,66 @@ void BindingData::DecodeUTF8(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+void BindingData::DecodeSingleByte(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK_GE(args.Length(), 2);
+
+  if (!(args[0]->IsArrayBuffer() || args[0]->IsSharedArrayBuffer() ||
+        args[0]->IsArrayBufferView())) {
+    return node::THROW_ERR_INVALID_ARG_TYPE(
+        env->isolate(),
+        "The \"input\" argument must be an instance of SharedArrayBuffer, "
+        "ArrayBuffer or ArrayBufferView.");
+  }
+
+  CHECK(args[1]->IsInt32());
+  const int encoding = args[1].As<v8::Int32>()->Value();
+  CHECK(encoding >= 0 && encoding < 29);
+
+  ArrayBufferViewContents<uint8_t> buffer(args[0]);
+  const uint8_t* data = buffer.data();
+  size_t length = buffer.length();
+
+  if (length == 0) return args.GetReturnValue().SetEmptyString();
+
+  const char* dataChar = reinterpret_cast<const char*>(data);
+  if (!simdutf::validate_ascii_with_errors(dataChar, length).error) {
+    Local<Value> ret;
+    if (StringBytes::Encode(env->isolate(), dataChar, length, LATIN1)
+            .ToLocal(&ret)) {
+      args.GetReturnValue().Set(ret);
+    }
+    return;
+  }
+
+  uint16_t* dst = node::UncheckedMalloc<uint16_t>(length);
+
+  if (encoding == 28) {
+    // x-user-defined
+    for (size_t i = 0; i < length; i++) {
+      dst[i] = data[i] >= 0x80 ? data[i] + 0xf700 : data[i];
+    }
+  } else {
+    bool has_fatal = args[2]->IsTrue();
+
+    const uint16_t* table = tSingleByteEncodings[encoding];
+    for (size_t i = 0; i < length; i++) dst[i] = table[data[i]];
+
+    const char16_t* dst16 = reinterpret_cast<char16_t*>(dst);
+    if (has_fatal && fSingleByteEncodings[encoding] &&
+        simdutf::find(dst16, dst16 + length, 0xfffd) != dst16 + length) {
+      return node::THROW_ERR_ENCODING_INVALID_ENCODED_DATA(
+          env->isolate(), "The encoded data was not valid for this encoding");
+    }
+  }
+
+  Local<Value> ret;
+  if (StringBytes::Raw(env->isolate(), dst, length).ToLocal(&ret)) {
+    args.GetReturnValue().Set(ret);
+  }
+}
+
 void BindingData::ToASCII(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK_GE(args.Length(), 1);
@@ -421,6 +482,7 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "encodeInto", EncodeInto);
   SetMethodNoSideEffect(isolate, target, "encodeUtf8String", EncodeUtf8String);
   SetMethodNoSideEffect(isolate, target, "decodeUTF8", DecodeUTF8);
+  SetMethodNoSideEffect(isolate, target, "decodeSingleByte", DecodeSingleByte);
   SetMethodNoSideEffect(isolate, target, "toASCII", ToASCII);
   SetMethodNoSideEffect(isolate, target, "toUnicode", ToUnicode);
 }
@@ -438,6 +500,7 @@ void BindingData::RegisterTimerExternalReferences(
   registry->Register(EncodeInto);
   registry->Register(EncodeUtf8String);
   registry->Register(DecodeUTF8);
+  registry->Register(DecodeSingleByte);
   registry->Register(ToASCII);
   registry->Register(ToUnicode);
 }

src/encoding_binding.cc

@@ -31,6 +31,7 @@ class BindingData : public SnapshotableObject {
   static void EncodeInto(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void EncodeUtf8String(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DecodeUTF8(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DecodeSingleByte(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void ToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);