@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/aliased_buffer.h

@@ -1,315 +0,0 @@
-#ifndef SRC_ALIASED_BUFFER_H_
-#define SRC_ALIASED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cinttypes>
-#include "util-inl.h"
-#include "v8.h"
-
-namespace node {
-
-typedef size_t AliasedBufferIndex;
-
-/**
- * Do not use this class directly when creating instances of it - use the
- * Aliased*Array defined at the end of this file instead.
- *
- * This class encapsulates the technique of having a native buffer mapped to
- * a JS object. Writes to the native buffer can happen efficiently without
- * going through JS, and the data is then available to user's via the exposed
- * JS object.
- *
- * While this technique is computationally efficient, it is effectively a
- * write to JS program state w/out going through the standard
- * (monitored) API. Thus any VM capabilities to detect the modification are
- * circumvented.
- *
- * The encapsulation herein provides a placeholder where such writes can be
- * observed. Any notification APIs will be left as a future exercise.
- */
-template <class NativeT,
-          class V8T,
-          // SFINAE NativeT to be scalar
-          typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
-class AliasedBufferBase {
- public:
-  AliasedBufferBase(v8::Isolate* isolate,
-                    const size_t count,
-                    const AliasedBufferIndex* index = nullptr)
-      : 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->GetBackingStore()->Data());
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  /**
-   * Create an AliasedBufferBase over a sub-region of another aliased buffer.
-   * The two will share a v8::ArrayBuffer instance &
-   * a native buffer, but will each read/write to different sections of the
-   * native buffer.
-   *
-   *  Note that byte_offset must by aligned by sizeof(NativeT).
-   */
-  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`
-  AliasedBufferBase(
-      v8::Isolate* isolate,
-      const size_t byte_offset,
-      const size_t count,
-      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
-      const AliasedBufferIndex* index = nullptr)
-      : 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);
-  }
-
-  AliasedBufferBase(const AliasedBufferBase& that)
-      : isolate_(that.isolate_),
-        count_(that.count_),
-        byte_offset_(that.byte_offset_),
-        buffer_(that.buffer_) {
-    DCHECK_NULL(index_);
-    js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
-  }
-
-  AliasedBufferIndex Serialize(v8::Local<v8::Context> context,
-                              v8::SnapshotCreator* creator) {
-    DCHECK_NULL(index_);
-    return creator->AddData(context, GetJSArray());
-  }
-
-  inline void 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()->GetBackingStore()->Data());
-    buffer_ = reinterpret_cast<NativeT*>(raw + byte_offset_);
-    js_array_.Reset(isolate_, arr);
-    index_ = nullptr;
-  }
-
-  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
-    DCHECK_NULL(index_);
-    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;
-  }
-
-  /**
-   * Helper class that is returned from operator[] to support assignment into
-   * a specified location.
-   */
-  class Reference {
-   public:
-    Reference(AliasedBufferBase<NativeT, V8T>* aliased_buffer, size_t index)
-        : aliased_buffer_(aliased_buffer), index_(index) {}
-
-    Reference(const Reference& that)
-        : aliased_buffer_(that.aliased_buffer_),
-          index_(that.index_) {
-    }
-
-    inline Reference& operator=(const NativeT& val) {
-      aliased_buffer_->SetValue(index_, val);
-      return *this;
-    }
-
-    inline Reference& operator=(const Reference& val) {
-      return *this = static_cast<NativeT>(val);
-    }
-
-    operator NativeT() const {
-      return aliased_buffer_->GetValue(index_);
-    }
-
-    inline Reference& operator+=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current + val);
-      return *this;
-    }
-
-    inline Reference& operator+=(const Reference& val) {
-      return this->operator+=(static_cast<NativeT>(val));
-    }
-
-    inline Reference& operator-=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current - val);
-      return *this;
-    }
-
-   private:
-    AliasedBufferBase<NativeT, V8T>* aliased_buffer_;
-    size_t index_;
-  };
-
-  /**
-   *  Get the underlying v8 TypedArray overlayed on top of the native buffer
-   */
-  v8::Local<V8T> GetJSArray() const {
-    DCHECK_NULL(index_);
-    return js_array_.Get(isolate_);
-  }
-
-  void Release() {
-    DCHECK_NULL(index_);
-    js_array_.Reset();
-  }
-
-  /**
-  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
-  *  overlaying the native buffer
-  */
-  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
-    return GetJSArray()->Buffer();
-  }
-
-  /**
-   *  Get the underlying native buffer. Note that all reads/writes should occur
-   *  through the GetValue/SetValue/operator[] methods
-   */
-  inline const NativeT* GetNativeBuffer() const {
-    DCHECK_NULL(index_);
-    return buffer_;
-  }
-
-  /**
-   *  Synonym for GetBuffer()
-   */
-  inline const NativeT* operator * () const {
-    return GetNativeBuffer();
-  }
-
-  /**
-   *  Set position index to given value.
-   */
-  inline void SetValue(const size_t index, NativeT value) {
-    DCHECK_LT(index, count_);
-    DCHECK_NULL(index_);
-    buffer_[index] = value;
-  }
-
-  /**
-   *  Get value at position index
-   */
-  inline const NativeT GetValue(const size_t index) const {
-    DCHECK_NULL(index_);
-    DCHECK_LT(index, count_);
-    return buffer_[index];
-  }
-
-  /**
-   *  Effectively, a synonym for GetValue/SetValue
-   */
-  Reference operator[](size_t index) {
-    DCHECK_NULL(index_);
-    return Reference(this, index);
-  }
-
-  NativeT operator[](size_t index) const {
-    return GetValue(index);
-  }
-
-  size_t Length() const {
-    return count_;
-  }
-
-  // Should only be used to extend the array.
-  // Should only be used on an owning array, not one created as a sub array of
-  // an owning `AliasedBufferBase`.
-  void reserve(size_t new_capacity) {
-    DCHECK_NULL(index_);
-    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->GetBackingStore()->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;
-  }
-
- private:
-  v8::Isolate* isolate_ = nullptr;
-  size_t count_ = 0;
-  size_t byte_offset_ = 0;
-  NativeT* buffer_ = nullptr;
-  v8::Global<V8T> js_array_;
-
-  // Deserialize data
-  const AliasedBufferIndex* index_ = nullptr;
-};
-
-typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;
-typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;
-typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;
-typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;
-typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_BUFFER_H_

package/src/headers/18/aliased_struct-inl.h

@@ -1,54 +0,0 @@
-#ifndef SRC_ALIASED_STRUCT_INL_H_
-#define SRC_ALIASED_STRUCT_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "aliased_struct.h"
-#include "v8.h"
-#include <memory>
-
-namespace node {
-
-template <typename T>
-template <typename... Args>
-AliasedStruct<T>::AliasedStruct(v8::Isolate* isolate, Args&&... args)
-    : isolate_(isolate) {
-  const v8::HandleScope handle_scope(isolate);
-
-  store_ = v8::ArrayBuffer::NewBackingStore(isolate, sizeof(T));
-  ptr_ = new (store_->Data()) T(std::forward<Args>(args)...);
-  DCHECK_NOT_NULL(ptr_);
-
-  v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, store_);
-  buffer_ = v8::Global<v8::ArrayBuffer>(isolate, buffer);
-}
-
-template <typename T>
-AliasedStruct<T>::AliasedStruct(const AliasedStruct& that)
-    : AliasedStruct(that.isolate_, *that) {}
-
-template <typename T>
-AliasedStruct<T>& AliasedStruct<T>::operator=(
-    AliasedStruct<T>&& that) noexcept {
-  this->~AliasedStruct();
-  isolate_ = that.isolate_;
-  store_ = that.store_;
-  ptr_ = that.ptr_;
-
-  buffer_ = std::move(that.buffer_);
-
-  that.ptr_ = nullptr;
-  that.store_.reset();
-  return *this;
-}
-
-template <typename T>
-AliasedStruct<T>::~AliasedStruct() {
-  if (ptr_ != nullptr) ptr_->~T();
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_STRUCT_INL_H_

package/src/headers/18/aliased_struct.h

@@ -1,63 +0,0 @@
-#ifndef SRC_ALIASED_STRUCT_H_
-#define SRC_ALIASED_STRUCT_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_internals.h"
-#include "v8.h"
-#include <memory>
-
-namespace node {
-
-// AliasedStruct is a utility that allows uses a V8 Backing Store
-// to be exposed to the C++/C side as a struct and to the
-// JavaScript side as an ArrayBuffer to efficiently share
-// data without marshalling. It is similar in nature to
-// AliasedBuffer.
-//
-//   struct Foo { int x; }
-//
-//   AliasedStruct<Foo> foo;
-//   foo->x = 1;
-//
-//   Local<ArrayBuffer> ab = foo.GetArrayBuffer();
-template <typename T>
-class AliasedStruct final {
- public:
-  template <typename... Args>
-  explicit AliasedStruct(v8::Isolate* isolate, Args&&... args);
-
-  inline AliasedStruct(const AliasedStruct& that);
-
-  inline ~AliasedStruct();
-
-  inline AliasedStruct& operator=(AliasedStruct&& that) noexcept;
-
-  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
-    return buffer_.Get(isolate_);
-  }
-
-  const T* Data() const { return ptr_; }
-
-  T* Data() { return ptr_; }
-
-  const T& operator*() const { return *ptr_; }
-
-  T& operator*()  { return *ptr_; }
-
-  const T* operator->() const { return ptr_; }
-
-  T* operator->() { return ptr_; }
-
- private:
-  v8::Isolate* isolate_;
-  std::shared_ptr<v8::BackingStore> store_;
-  T* ptr_;
-  v8::Global<v8::ArrayBuffer> buffer_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_STRUCT_H_

package/src/headers/18/base64-inl.h

@@ -1,189 +0,0 @@
-#ifndef SRC_BASE64_INL_H_
-#define SRC_BASE64_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base64.h"
-#include "util.h"
-
-namespace node {
-
-extern const int8_t unbase64_table[256];
-
-
-inline static int8_t unbase64(uint8_t x) {
-  return unbase64_table[x];
-}
-
-
-inline uint32_t ReadUint32BE(const unsigned char* p) {
-  return static_cast<uint32_t>(p[0] << 24U) |
-         static_cast<uint32_t>(p[1] << 16U) |
-         static_cast<uint32_t>(p[2] << 8U) |
-         static_cast<uint32_t>(p[3]);
-}
-
-#ifdef _MSC_VER
-#pragma warning(push)
-// MSVC C4003: not enough actual parameters for macro 'identifier'
-#pragma warning(disable : 4003)
-#endif
-
-template <typename TypeName>
-bool base64_decode_group_slow(char* const dst, const size_t dstlen,
-                              const TypeName* const src, const size_t srclen,
-                              size_t* const i, size_t* const k) {
-  uint8_t hi;
-  uint8_t lo;
-#define V(expr)                                                                \
-  for (;;) {                                                                   \
-    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
-    lo = unbase64(c);                                                          \
-    *i += 1;                                                                   \
-    if (lo < 64) break;                         /* Legal character. */         \
-    if (c == '=' || *i >= srclen) return false; /* Stop decoding. */           \
-  }                                                                            \
-  expr;                                                                        \
-  if (*i >= srclen) return false;                                              \
-  if (*k >= dstlen) return false;                                              \
-  hi = lo;
-  V(/* Nothing. */);
-  V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
-  V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
-  V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
-#undef V
-  return true;  // Continue decoding.
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-template <typename TypeName>
-size_t base64_decode_fast(char* const dst, const size_t dstlen,
-                          const TypeName* const src, const size_t srclen,
-                          const size_t decoded_size) {
-  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
-  const size_t max_k = available / 3 * 3;
-  size_t max_i = srclen / 4 * 4;
-  size_t i = 0;
-  size_t k = 0;
-  while (i < max_i && k < max_k) {
-    const unsigned char txt[] = {
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
-    };
-
-    const uint32_t v = ReadUint32BE(txt);
-    // If MSB is set, input contains whitespace or is not valid base64.
-    if (v & 0x80808080) {
-      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
-        return k;
-      max_i = i + (srclen - i) / 4 * 4;  // Align max_i again.
-    } else {
-      dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
-      dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
-      dst[k + 2] = ((v >>  2) & 0xC0) | ((v >>  0) & 0x3F);
-      i += 4;
-      k += 3;
-    }
-  }
-  if (i < srclen && k < dstlen) {
-    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
-  }
-  return k;
-}
-
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName* src, size_t size) {
-  // 1-byte input cannot be decoded
-  if (size < 2)
-    return 0;
-
-  if (src[size - 1] == '=') {
-    size--;
-    if (src[size - 1] == '=')
-      size--;
-  }
-  return base64_decoded_size_fast(size);
-}
-
-
-template <typename TypeName>
-size_t base64_decode(char* const dst, const size_t dstlen,
-                     const TypeName* const src, const size_t srclen) {
-  const size_t decoded_size = base64_decoded_size(src, srclen);
-  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
-}
-
-
-inline size_t base64_encode(const char* src,
-                            size_t slen,
-                            char* dst,
-                            size_t dlen,
-                            Base64Mode mode) {
-  // We know how much we'll write, just make sure that there's space.
-  CHECK(dlen >= base64_encoded_size(slen, mode) &&
-        "not enough space provided for base64 encode");
-
-  dlen = base64_encoded_size(slen, mode);
-
-  unsigned a;
-  unsigned b;
-  unsigned c;
-  unsigned i;
-  unsigned k;
-  unsigned n;
-
-  const char* table = base64_select_table(mode);
-
-  i = 0;
-  k = 0;
-  n = slen / 3 * 3;
-
-  while (i < n) {
-    a = src[i + 0] & 0xff;
-    b = src[i + 1] & 0xff;
-    c = src[i + 2] & 0xff;
-
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
-    dst[k + 3] = table[c & 0x3f];
-
-    i += 3;
-    k += 4;
-  }
-
-  switch (slen - n) {
-    case 1:
-      a = src[i + 0] & 0xff;
-      dst[k + 0] = table[a >> 2];
-      dst[k + 1] = table[(a & 3) << 4];
-      if (mode == Base64Mode::NORMAL) {
-        dst[k + 2] = '=';
-        dst[k + 3] = '=';
-      }
-      break;
-    case 2:
-      a = src[i + 0] & 0xff;
-      b = src[i + 1] & 0xff;
-      dst[k + 0] = table[a >> 2];
-      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-      dst[k + 2] = table[(b & 0x0f) << 2];
-      if (mode == Base64Mode::NORMAL)
-        dst[k + 3] = '=';
-      break;
-  }
-
-  return dlen;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE64_INL_H_

package/src/headers/18/base64.h

@@ -1,69 +0,0 @@
-#ifndef SRC_BASE64_H_
-#define SRC_BASE64_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "util.h"
-
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-
-namespace node {
-//// Base 64 ////
-
-enum class Base64Mode {
-  NORMAL,
-  URL
-};
-
-static constexpr char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                       "abcdefghijklmnopqrstuvwxyz"
-                                       "0123456789+/";
-
-static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                           "abcdefghijklmnopqrstuvwxyz"
-                                           "0123456789-_";
-
-static inline const char* base64_select_table(Base64Mode mode) {
-  switch (mode) {
-    case Base64Mode::NORMAL: return base64_table;
-    case Base64Mode::URL: return base64_table_url;
-    default: UNREACHABLE();
-  }
-}
-
-static inline constexpr size_t base64_encoded_size(
-    size_t size,
-    Base64Mode mode = Base64Mode::NORMAL) {
-  return mode == Base64Mode::NORMAL ? ((size + 2) / 3 * 4)
-                                    : static_cast<size_t>(std::ceil(
-                                          static_cast<double>(size * 4) / 3));
-}
-
-// Doesn't check for padding at the end.  Can be 1-2 bytes over.
-static inline constexpr size_t base64_decoded_size_fast(size_t size) {
-  // 1-byte input cannot be decoded
-  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
-}
-
-inline uint32_t ReadUint32BE(const unsigned char* p);
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName* src, size_t size);
-
-template <typename TypeName>
-size_t base64_decode(char* const dst, const size_t dstlen,
-                     const TypeName* const src, const size_t srclen);
-
-inline size_t base64_encode(const char* src,
-                            size_t slen,
-                            char* dst,
-                            size_t dlen,
-                            Base64Mode mode = Base64Mode::NORMAL);
-}  // namespace node
-
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE64_H_