@encharm/cws 4.3.0 → 4.4.0

package/README.md

@@ -12,13 +12,11 @@
 
 This table is true if you run ssl directly with `cws` (`Node.js`). In case if you use proxy for example `nginx`, `cws` can be run on bigger coverage.
 
-|  CWS Version | Node 10  | Node 11 | Node 12          |  Node 13  | Node 14 | Node 16  |
-|--------------|----------|---------|------------------|-----------|---------|----------|
-| 4.x.x        | >=10.0   |    X    | >=12.16          | >=13.9    | >=14.5  | >= 16.11 |
-| *The versions below are available via @clusterws/cws*                                   |
-| 3.0.0        | >=10.0   |    X    | >=12.16          | >=13.9    | >=14.5  |    X     |
-| 2.0.0        | >=10.0   |    X    | >=12.16          | >=13.9    |   X     |    X     |
-| 1.6.0        | >=10.0   | >=11.0  | >=12.0 & <12.16  | >=13.9    |   X     |    X     |
+| cWS Version | Node 14  | Node 16 | Node 18 | Node 20 |
+|-------------|----------|---------|-------------------|
+| 4.4.x       |    X     |    X    |   X     |    X    |
+
+Node <14 are supported with @clusterws/cws.
 
 ## Documentation
 

package/dist/shared.js

@@ -15,7 +15,7 @@ exports.native = (() => {
         return require(`../dist/bindings/cws_${process.platform}_${process.arch}_node${process.versions.modules}`);
     }
     catch (err) {
-        err.message = err.message + ` check './node_modules/@clusterws/cws/build_log.txt' for post install build logs`;
+        err.message = err.message + ` check './node_modules/@encharm/cws/build_log.txt' for post install build logs`;
         throw err;
     }
 })();

package/package.json

@@ -1,6 +1,6 @@
- {
+{
   "name": "@encharm/cws",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "description": "cWS - fast C++ WebSocket implementation for Node.js",
@@ -30,12 +30,12 @@
     "@types/node": "^13.11.1",
     "chai": "^4.2.0",
     "mocha": "^7.1.1",
-    "nyc": "^15.0.1",
+    "nyc": "^15.1.0",
     "rimraf": "^3.0.2",
     "ts-node": "^8.8.2",
-    "tslint": "^6.1.1",
     "tslint-eslint-rules": "^5.4.0",
-    "typescript": "^3.8.3"
+    "typescript": "^3.8.3",
+    "ws": "^8.8.0"
   },
   "nyc": {
     "all": true,

package/src/Addon.cpp

@@ -4,18 +4,10 @@
 
 void Initialize(Local<Object> exports) {
   Isolate *isolate = exports->GetIsolate();
-
-  #if NODE_MAJOR_VERSION >= 13
-    exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "server").ToLocalChecked(),
-                Namespace<cWS::SERVER>(isolate).object);
-    exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "client").ToLocalChecked(),
-                Namespace<cWS::CLIENT>(isolate).object);
-  #else
-    exports->Set(String::NewFromUtf8(isolate, "server"),
-                Namespace<cWS::SERVER>(isolate).object);
-    exports->Set(String::NewFromUtf8(isolate, "client"),
-                Namespace<cWS::CLIENT>(isolate).object);
-  #endif
+  exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "server").ToLocalChecked(),
+              Namespace<cWS::SERVER>(isolate).object);
+  exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "client").ToLocalChecked(),
+              Namespace<cWS::CLIENT>(isolate).object);
 
   NODE_SET_METHOD(exports, "getSSLContext", getSSLContext);
   NODE_SET_METHOD(exports, "getBufferedAmount", getBufferedAmount<cWS::SERVER>);

package/src/Addon.h

@@ -1,3 +1,5 @@
+#define NODE_API_DEFAULT_MODULE_API_VERSION 115
+
 #include <node.h>
 #include <node_buffer.h>
 #include <openssl/bio.h>
@@ -5,23 +7,10 @@
 #include <uv.h>
 #include <cstring>
 
+// TODO: remove below
 #if NODE_MAJOR_VERSION>=10
 #define NODE_WANT_INTERNALS 1
 
-#if NODE_MAJOR_VERSION==10
-  #include "headers/10/tls_wrap.h"
-#endif
-
-#if NODE_MAJOR_VERSION==12
-  #include "headers/12/tls_wrap.h"
-  #include "headers/12/base_object-inl.h"
-#endif
-
-#if NODE_MAJOR_VERSION==13
-  #include "headers/13/tls_wrap.h"
-  #include "headers/13/base_object-inl.h"
-#endif
-
 #if NODE_MAJOR_VERSION==14
   #include "headers/14/tls_wrap.h"
   #include "headers/14/base_object-inl.h"
@@ -37,8 +26,15 @@
   #include "headers/18/base_object-inl.h"
 #endif
 
+#if NODE_MAJOR_VERSION==20
+  #include "headers/20/crypto/crypto_tls.h"
+  #include "headers/20/base_object-inl.h"
+#endif
+
+#include <tcp_wrap.h>
+
 using BaseObject = node::BaseObject;
-#if NODE_MAJOR_VERSION==16 || NODE_MAJOR_VERSION==18
+#if NODE_MAJOR_VERSION==16 || NODE_MAJOR_VERSION==18 || NODE_MAJOR_VERSION==20
 using TLSWrap = node::crypto::TLSWrap;
 #else
 using TLSWrap = node::TLSWrap;
@@ -59,32 +55,15 @@ public:
 
 // Fix windows not resolved symbol issue
 #if defined(_MSC_VER)
-  #if NODE_MAJOR_VERSION>10
-    [[noreturn]] void node::Assert(const node::AssertionInfo& info) {
-      char name[1024];
-      char title[1024] = "Node.js";
-      uv_get_process_title(title, sizeof(title));
-      snprintf(name, sizeof(name), "%s[%d]", title, uv_os_getpid());
-      fprintf(stderr, "%s: Assertion failed.\n", name);
-      fflush(stderr);
-      ABORT_NO_BACKTRACE();
-    }
-  #else
-    [[noreturn]] void node::Assert(const char* const (*args)[4]) {
-      auto filename = (*args)[0];
-      auto linenum = (*args)[1];
-      auto message = (*args)[2];
-      auto function = (*args)[3];
-      char name[1024];
-      char title[1024] = "Node.js";
-      uv_get_process_title(title, sizeof(title));
-      snprintf(name, sizeof(name), "%s[%d]", title, uv_os_getpid());
-      fprintf(stderr, "%s: %s:%s:%s%s Assertion `%s' failed.\n",
-              name, filename, linenum, function, *function ? ":" : "", message);
-      fflush(stderr);
-      ABORT_NO_BACKTRACE();
-    }
-  #endif
+[[noreturn]] void node::Assert(const node::AssertionInfo& info) {
+  char name[1024];
+  char title[1024] = "Node.js";
+  uv_get_process_title(title, sizeof(title));
+  snprintf(name, sizeof(name), "%s[%d]", title, uv_os_getpid());
+  fprintf(stderr, "%s: Assertion failed.\n", name);
+  fflush(stderr);
+  ABORT_NO_BACKTRACE();
+}
 #endif
 
  #undef NODE_WANT_INTERNALS
@@ -130,10 +109,10 @@ class NativeString {
     } else if (value->IsTypedArray()) {
       Local<ArrayBufferView> arrayBufferView =
           Local<ArrayBufferView>::Cast(value);
-#if NODE_MAJOR_VERSION == 18
-      std::shared_ptr<v8::BackingStore> contents = arrayBufferView->Buffer()->GetBackingStore();
+#if NODE_MAJOR_VERSION >= 18
       length = arrayBufferView->ByteLength();
-      data = (char *)contents->Data();
+      auto store = arrayBufferView->Buffer()->GetBackingStore();
+      data = reinterpret_cast<char*>(store->Data());
 #else
       ArrayBuffer::Contents contents = arrayBufferView->Buffer()->GetContents();
       length = contents.ByteLength();
@@ -141,10 +120,10 @@ class NativeString {
 #endif
     } else if (value->IsArrayBuffer()) {
       Local<ArrayBuffer> arrayBuffer = Local<ArrayBuffer>::Cast(value);
-#if NODE_MAJOR_VERSION == 18
-      std::shared_ptr<v8::BackingStore> contents = arrayBuffer->GetBackingStore();
+#if NODE_MAJOR_VERSION >= 18
       length = arrayBuffer->ByteLength();
-      data = (char *)contents->Data();
+      auto store = arrayBuffer->GetBackingStore();
+      data = reinterpret_cast<char*>(store->Data());
 #else
       ArrayBuffer::Contents contents = arrayBuffer->GetContents();
       length = contents.ByteLength();
@@ -212,11 +191,7 @@ inline Local<Value> wrapMessage(const char *message, size_t length,
     return (Local<Value>)v8::ArrayBuffer::New(isolate, std::move(backing));
   }
 
-  #if NODE_MAJOR_VERSION >= 13
-    return (Local<Value>)String::NewFromUtf8(isolate, message, NewStringType::kNormal, length).ToLocalChecked();
-  #else
-    return (Local<Value>)String::NewFromUtf8(isolate, message, String::kNormalString, length);
-  #endif
+  return (Local<Value>)String::NewFromUtf8(isolate, message, NewStringType::kNormal, length).ToLocalChecked();
 }
 
 template <bool isServer>
@@ -271,28 +246,26 @@ void getAddress(const FunctionCallbackInfo<Value> &args) {
       unwrapSocket<isServer>(args[0].As<External>())->getAddress();
   Local<Array> array = Array::New(args.GetIsolate(), 3);
 
-  #if NODE_MAJOR_VERSION >= 13
-    array->Set(args.GetIsolate()->GetCurrentContext(), 0, Integer::New(args.GetIsolate(), address.port));
-    array->Set(args.GetIsolate()->GetCurrentContext(), 1, String::NewFromUtf8(args.GetIsolate(), address.address).ToLocalChecked());
-    array->Set(args.GetIsolate()->GetCurrentContext(), 2, String::NewFromUtf8(args.GetIsolate(), address.family).ToLocalChecked());
-  #else
-    array->Set(0, Integer::New(args.GetIsolate(), address.port));
-    array->Set(1, String::NewFromUtf8(args.GetIsolate(), address.address));
-    array->Set(2, String::NewFromUtf8(args.GetIsolate(), address.family));
-  #endif
+  array->Set(args.GetIsolate()->GetCurrentContext(), 0, Integer::New(args.GetIsolate(), address.port));
+  array->Set(args.GetIsolate()->GetCurrentContext(), 1, String::NewFromUtf8(args.GetIsolate(), address.address).ToLocalChecked());
+  array->Set(args.GetIsolate()->GetCurrentContext(), 2, String::NewFromUtf8(args.GetIsolate(), address.family).ToLocalChecked());
 
   args.GetReturnValue().Set(array);
 }
 
 uv_handle_t *getTcpHandle(void *handleWrap) {
-  volatile char *memory = (volatile char *)handleWrap;
-  for (volatile uv_handle_t *tcpHandle = (volatile uv_handle_t *)memory;
-       tcpHandle->type != UV_TCP || tcpHandle->data != handleWrap ||
-       tcpHandle->loop != uv_default_loop();
-       tcpHandle = (volatile uv_handle_t *)memory) {
-    memory++;
-  }
-  return (uv_handle_t *)memory;
+  // volatile char *memory = (volatile char *)handleWrap;
+  // for (volatile uv_handle_t *tcpHandle = (volatile uv_handle_t *)memory;
+  //      tcpHandle->type != UV_TCP || tcpHandle->data != handleWrap ||
+  //      tcpHandle->loop != uv_default_loop();
+  //      tcpHandle = (volatile uv_handle_t *)memory) {
+  //   memory++;
+  // }
+  // return (uv_handle_t *)memory;
+
+  // TODO? above is the old @clusterws/cWS code. Is the above needed for TLS handles?
+  // Below is the proper way to get the handle in a type-safe way.
+  return static_cast<node::TCPWrap*>(handleWrap)->GetHandle();
 }
 
 struct SendCallbackData {
@@ -372,6 +345,10 @@ void upgrade(const FunctionCallbackInfo<Value> &args) {
   delete ticket;
 }
 
+constexpr uint16_t kDefaultCppGCEmebdderID = 0x90de;
+// https://github.com/nodejs/node/blob/22f383dcd529d6bf790856db614a35fea78e825f/src/env.cc#L506
+
+
 void transfer(const FunctionCallbackInfo<Value> &args) {
   // (_handle.fd OR _handle), SSL
   uv_handle_t *handle = nullptr;
@@ -379,9 +356,11 @@ void transfer(const FunctionCallbackInfo<Value> &args) {
   if (args[0]->IsObject()) {
     Isolate* isolate = args.GetIsolate();
     Local<Context> context = isolate->GetCurrentContext();
+    auto arg_0 = args[0]->ToObject(context).ToLocalChecked();
+    auto field_to_get = arg_0->InternalFieldCount() > 3 ? 1 : 0;
 
     uv_fileno((handle = getTcpHandle(
-                   args[0]->ToObject(context).ToLocalChecked()->GetAlignedPointerFromInternalField(0))),
+                   arg_0->GetAlignedPointerFromInternalField(field_to_get))),
               (uv_os_fd_t *)&ticket->fd);
   } else {
     ticket->fd = args[0].As<Integer>()->Value();
@@ -637,13 +616,8 @@ void getSSLContext(const FunctionCallbackInfo<Value> &args) {
     Isolate* isolate = args.GetIsolate();
     if(args.Length() < 1 || !args[0]->IsObject()){
 
-      #if NODE_MAJOR_VERSION >= 13
-        isolate->ThrowException(Exception::TypeError(
-          String::NewFromUtf8(isolate, "Error: One object expected").ToLocalChecked()));
-      #else
-        isolate->ThrowException(Exception::TypeError(
-          String::NewFromUtf8(isolate, "Error: One object expected")));
-      #endif
+      isolate->ThrowException(Exception::TypeError(
+        String::NewFromUtf8(isolate, "Error: One object expected").ToLocalChecked()));
 
       return;
     }
@@ -651,14 +625,9 @@ void getSSLContext(const FunctionCallbackInfo<Value> &args) {
     Local<Context> context = isolate->GetCurrentContext();
     Local<Object> obj = args[0]->ToObject(context).ToLocalChecked();
 
-    #if NODE_MAJOR_VERSION < 10
-      Local<Value> ext = obj->Get(String::NewFromUtf8(isolate, "_external"));
-      args.GetReturnValue().Set(ext);
-    #else
-      TLSWrapSSLGetter* tw;
-      ASSIGN_OR_RETURN_UNWRAP(&tw, obj);
-      tw->setSSL(args);
-    #endif
+    TLSWrapSSLGetter* tw;
+    ASSIGN_OR_RETURN_UNWRAP(&tw, obj);
+    tw->setSSL(args);
 }
 
 void setNoop(const FunctionCallbackInfo<Value> &args) {
@@ -705,10 +674,6 @@ struct Namespace {
     NODE_SET_METHOD(group, "terminate", terminateGroup<isServer>);
     NODE_SET_METHOD(group, "broadcast", broadcast<isServer>);
 
-    #if NODE_MAJOR_VERSION >= 13
-      object->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "group").ToLocalChecked(), group);
-    #else
-      object->Set(String::NewFromUtf8(isolate, "group"), group);
-    #endif
+    object->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "group").ToLocalChecked(), group);
   }
 };

package/src/Socket.h

@@ -407,6 +407,7 @@ protected:
                 }
             }
         } else {
+            printf("Enqueue\n");
             Queue::Message *messagePtr = allocMessage(estimatedLength - sizeof(Queue::Message));
             messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
             messagePtr->callback = callback;

package/src/cSNode.cpp

@@ -56,14 +56,9 @@ Node::Node(int recvLength, int prePadding, int postPadding, bool useDefaultLoop)
         nodeData->preAlloc[i] = nullptr;
     }   
 
-    #if (NODE_MAJOR_VERSION>=10)
-        nodeData->clientContext = SSL_CTX_new(TLS_method());
-        SSL_CTX_set_min_proto_version(nodeData->clientContext, TLS1_VERSION);
-        SSL_CTX_set_max_proto_version(nodeData->clientContext, TLS1_2_VERSION);
-    #else
-        nodeData->clientContext = SSL_CTX_new(SSLv23_client_method());
-        SSL_CTX_set_options(nodeData->clientContext, SSL_OP_NO_SSLv3);
-    #endif
+    nodeData->clientContext = SSL_CTX_new(TLS_method());
+    SSL_CTX_set_min_proto_version(nodeData->clientContext, TLS1_VERSION);
+    SSL_CTX_set_max_proto_version(nodeData->clientContext, TLS1_2_VERSION);
 }
 
 void Node::run() {

package/src/headers/20/acorn_version.h

@@ -0,0 +1,6 @@
+// This is an auto generated file, please do not edit.
+// Refer to tools/update-acorn.sh
+#ifndef SRC_ACORN_VERSION_H_
+#define SRC_ACORN_VERSION_H_
+#define ACORN_VERSION "8.10.0"
+#endif  // SRC_ACORN_VERSION_H_

package/src/headers/20/aliased_buffer-inl.h

@@ -0,0 +1,243 @@
+#ifndef SRC_ALIASED_BUFFER_INL_H_
+#define SRC_ALIASED_BUFFER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "util-inl.h"
+
+namespace node {
+
+typedef size_t AliasedBufferIndex;
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
+    v8::Isolate* isolate, const size_t count, const AliasedBufferIndex* index)
+    : isolate_(isolate), count_(count), byte_offset_(0), index_(index) {
+  CHECK_GT(count, 0);
+  if (index != nullptr) {
+    // Will be deserialized later.
+    return;
+  }
+  const v8::HandleScope handle_scope(isolate_);
+  const size_t size_in_bytes =
+      MultiplyWithOverflowCheck(sizeof(NativeT), count);
+
+  // allocate v8 ArrayBuffer
+  v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate_, size_in_bytes);
+  buffer_ = static_cast<NativeT*>(ab->Data());
+
+  // allocate v8 TypedArray
+  v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
+  js_array_ = v8::Global<V8T>(isolate, js_array);
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
+    v8::Isolate* isolate,
+    const size_t byte_offset,
+    const size_t count,
+    const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
+    const AliasedBufferIndex* index)
+    : isolate_(isolate),
+      count_(count),
+      byte_offset_(byte_offset),
+      index_(index) {
+  if (index != nullptr) {
+    // Will be deserialized later.
+    return;
+  }
+  const v8::HandleScope handle_scope(isolate_);
+  v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
+
+  // validate that the byte_offset is aligned with sizeof(NativeT)
+  CHECK_EQ(byte_offset & (sizeof(NativeT) - 1), 0);
+  // validate this fits inside the backing buffer
+  CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count),
+           ab->ByteLength() - byte_offset);
+
+  buffer_ = reinterpret_cast<NativeT*>(
+      const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset));
+
+  v8::Local<V8T> js_array = V8T::New(ab, byte_offset, count);
+  js_array_ = v8::Global<V8T>(isolate, js_array);
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
+    const AliasedBufferBase& that)
+    : isolate_(that.isolate_),
+      count_(that.count_),
+      byte_offset_(that.byte_offset_),
+      buffer_(that.buffer_) {
+  js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
+  DCHECK(is_valid());
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferIndex AliasedBufferBase<NativeT, V8T>::Serialize(
+    v8::Local<v8::Context> context, v8::SnapshotCreator* creator) {
+  DCHECK(is_valid());
+  return creator->AddData(context, GetJSArray());
+}
+
+template <typename NativeT, typename V8T>
+inline void AliasedBufferBase<NativeT, V8T>::Deserialize(
+    v8::Local<v8::Context> context) {
+  DCHECK_NOT_NULL(index_);
+  v8::Local<V8T> arr =
+      context->GetDataFromSnapshotOnce<V8T>(*index_).ToLocalChecked();
+  // These may not hold true for AliasedBuffers that have grown, so should
+  // be removed when we expand the snapshot support.
+  DCHECK_EQ(count_, arr->Length());
+  DCHECK_EQ(byte_offset_, arr->ByteOffset());
+  uint8_t* raw = static_cast<uint8_t*>(arr->Buffer()->Data());
+  buffer_ = reinterpret_cast<NativeT*>(raw + byte_offset_);
+  js_array_.Reset(isolate_, arr);
+  index_ = nullptr;
+}
+
+template <typename NativeT, typename V8T>
+AliasedBufferBase<NativeT, V8T>& AliasedBufferBase<NativeT, V8T>::operator=(
+    AliasedBufferBase<NativeT, V8T>&& that) noexcept {
+  DCHECK(is_valid());
+  this->~AliasedBufferBase();
+  isolate_ = that.isolate_;
+  count_ = that.count_;
+  byte_offset_ = that.byte_offset_;
+  buffer_ = that.buffer_;
+
+  js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
+
+  that.buffer_ = nullptr;
+  that.js_array_.Reset();
+  return *this;
+}
+
+template <typename NativeT, typename V8T>
+v8::Local<V8T> AliasedBufferBase<NativeT, V8T>::GetJSArray() const {
+  DCHECK(is_valid());
+  return js_array_.Get(isolate_);
+}
+
+template <typename NativeT, typename V8T>
+void AliasedBufferBase<NativeT, V8T>::Release() {
+  DCHECK_NULL(index_);
+  js_array_.Reset();
+}
+
+template <typename NativeT, typename V8T>
+inline void AliasedBufferBase<NativeT, V8T>::MakeWeak() {
+  DCHECK(is_valid());
+  js_array_.SetWeak();
+}
+
+template <typename NativeT, typename V8T>
+v8::Local<v8::ArrayBuffer> AliasedBufferBase<NativeT, V8T>::GetArrayBuffer()
+    const {
+  return GetJSArray()->Buffer();
+}
+
+template <typename NativeT, typename V8T>
+inline const NativeT* AliasedBufferBase<NativeT, V8T>::GetNativeBuffer() const {
+  DCHECK(is_valid());
+  return buffer_;
+}
+
+template <typename NativeT, typename V8T>
+inline const NativeT* AliasedBufferBase<NativeT, V8T>::operator*() const {
+  return GetNativeBuffer();
+}
+
+template <typename NativeT, typename V8T>
+inline void AliasedBufferBase<NativeT, V8T>::SetValue(const size_t index,
+                                                      NativeT value) {
+  DCHECK_LT(index, count_);
+  DCHECK(is_valid());
+  buffer_[index] = value;
+}
+
+template <typename NativeT, typename V8T>
+inline const NativeT AliasedBufferBase<NativeT, V8T>::GetValue(
+    const size_t index) const {
+  DCHECK(is_valid());
+  DCHECK_LT(index, count_);
+  return buffer_[index];
+}
+
+template <typename NativeT, typename V8T>
+typename AliasedBufferBase<NativeT, V8T>::Reference
+AliasedBufferBase<NativeT, V8T>::operator[](size_t index) {
+  DCHECK(is_valid());
+  return Reference(this, index);
+}
+
+template <typename NativeT, typename V8T>
+NativeT AliasedBufferBase<NativeT, V8T>::operator[](size_t index) const {
+  return GetValue(index);
+}
+
+template <typename NativeT, typename V8T>
+size_t AliasedBufferBase<NativeT, V8T>::Length() const {
+  return count_;
+}
+
+template <typename NativeT, typename V8T>
+void AliasedBufferBase<NativeT, V8T>::reserve(size_t new_capacity) {
+  DCHECK(is_valid());
+  DCHECK_GE(new_capacity, count_);
+  DCHECK_EQ(byte_offset_, 0);
+  const v8::HandleScope handle_scope(isolate_);
+
+  const size_t old_size_in_bytes = sizeof(NativeT) * count_;
+  const size_t new_size_in_bytes =
+      MultiplyWithOverflowCheck(sizeof(NativeT), new_capacity);
+
+  // allocate v8 new ArrayBuffer
+  v8::Local<v8::ArrayBuffer> ab =
+      v8::ArrayBuffer::New(isolate_, new_size_in_bytes);
+
+  // allocate new native buffer
+  NativeT* new_buffer = static_cast<NativeT*>(ab->Data());
+  // copy old content
+  memcpy(new_buffer, buffer_, old_size_in_bytes);
+
+  // allocate v8 TypedArray
+  v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, new_capacity);
+
+  // move over old v8 TypedArray
+  js_array_ = std::move(v8::Global<V8T>(isolate_, js_array));
+
+  buffer_ = new_buffer;
+  count_ = new_capacity;
+}
+
+template <typename NativeT, typename V8T>
+inline bool AliasedBufferBase<NativeT, V8T>::is_valid() const {
+  return index_ == nullptr && !js_array_.IsEmpty();
+}
+
+template <typename NativeT, typename V8T>
+inline size_t AliasedBufferBase<NativeT, V8T>::SelfSize() const {
+  return sizeof(*this);
+}
+
+#define VM(NativeT, V8T)                                                       \
+  template <>                                                                  \
+  inline const char* AliasedBufferBase<NativeT, v8::V8T>::MemoryInfoName()     \
+      const {                                                                  \
+    return "Aliased" #V8T;                                                     \
+  }                                                                            \
+  template <>                                                                  \
+  inline void AliasedBufferBase<NativeT, v8::V8T>::MemoryInfo(                 \
+      node::MemoryTracker* tracker) const {                                    \
+    tracker->TrackField("js_array", js_array_);                                \
+  }
+ALIASED_BUFFER_LIST(VM)
+#undef VM
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_BUFFER_INL_H_