@encharm/cws 4.4.1 → 4.5.1

package/src/headers/14/allocated_buffer-inl.h

@@ -1,110 +0,0 @@
-#ifndef SRC_ALLOCATED_BUFFER_INL_H_
-#define SRC_ALLOCATED_BUFFER_INL_H_
-
-#include "allocated_buffer.h"
-#include "base_object-inl.h"
-#include "node_buffer.h"
-#include "env-inl.h"
-#include "uv.h"
-#include "v8.h"
-#include "util-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-// It's a bit awkward to define this Buffer::New() overload here, but it
-// avoids a circular dependency with node_internals.h.
-namespace Buffer {
-v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
-                                   v8::Local<v8::ArrayBuffer> ab,
-                                   size_t byte_offset,
-                                   size_t length);
-}
-
-NoArrayBufferZeroFillScope::NoArrayBufferZeroFillScope(
-    IsolateData* isolate_data)
-  : node_allocator_(isolate_data->node_allocator()) {
-  if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 0;
-}
-
-NoArrayBufferZeroFillScope::~NoArrayBufferZeroFillScope() {
-  if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 1;
-}
-
-AllocatedBuffer AllocatedBuffer::AllocateManaged(
-    Environment* env,
-    size_t size) {
-  NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-  std::unique_ptr<v8::BackingStore> bs =
-      v8::ArrayBuffer::NewBackingStore(env->isolate(), size);
-  return AllocatedBuffer(env, std::move(bs));
-}
-
-AllocatedBuffer::AllocatedBuffer(
-    Environment* env, std::unique_ptr<v8::BackingStore> bs)
-    : env_(env), backing_store_(std::move(bs)) {}
-
-AllocatedBuffer::AllocatedBuffer(
-    Environment* env, uv_buf_t buffer)
-    : env_(env) {
-  if (buffer.base == nullptr) return;
-  auto map = env->released_allocated_buffers();
-  auto it = map->find(buffer.base);
-  CHECK_NE(it, map->end());
-  backing_store_ = std::move(it->second);
-  map->erase(it);
-}
-
-void AllocatedBuffer::Resize(size_t len) {
-  if (len == 0) {
-    backing_store_ = v8::ArrayBuffer::NewBackingStore(env_->isolate(), 0);
-    return;
-  }
-  NoArrayBufferZeroFillScope no_zero_fill_scope(env_->isolate_data());
-  backing_store_ = v8::BackingStore::Reallocate(
-      env_->isolate(), std::move(backing_store_), len);
-}
-
-uv_buf_t AllocatedBuffer::release() {
-  if (data() == nullptr) return uv_buf_init(nullptr, 0);
-
-  CHECK_NOT_NULL(env_);
-  uv_buf_t ret = uv_buf_init(data(), size());
-  env_->released_allocated_buffers()->emplace(
-      ret.base, std::move(backing_store_));
-  return ret;
-}
-
-char* AllocatedBuffer::data() {
-  if (!backing_store_) return nullptr;
-  return static_cast<char*>(backing_store_->Data());
-}
-
-const char* AllocatedBuffer::data() const {
-  if (!backing_store_) return nullptr;
-  return static_cast<char*>(backing_store_->Data());
-}
-
-
-size_t AllocatedBuffer::size() const {
-  if (!backing_store_) return 0;
-  return backing_store_->ByteLength();
-}
-
-void AllocatedBuffer::clear() {
-  backing_store_.reset();
-}
-
-v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
-  v8::Local<v8::ArrayBuffer> ab = ToArrayBuffer();
-  return Buffer::New(env_, ab, 0, ab->ByteLength())
-      .FromMaybe(v8::Local<v8::Uint8Array>());
-}
-
-v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
-  return v8::ArrayBuffer::New(env_->isolate(), std::move(backing_store_));
-}
-
-}  // namespace node
-
-#endif  // SRC_ALLOCATED_BUFFER_INL_H_

package/src/headers/14/allocated_buffer.h

@@ -1,73 +0,0 @@
-#ifndef SRC_ALLOCATED_BUFFER_H_
-#define SRC_ALLOCATED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "uv.h"
-#include "v8.h"
-#include "env.h"
-
-namespace node {
-
-class Environment;
-
-// Disables zero-filling for ArrayBuffer allocations in this scope. This is
-// similar to how we implement Buffer.allocUnsafe() in JS land.
-class NoArrayBufferZeroFillScope{
- public:
-  inline explicit NoArrayBufferZeroFillScope(IsolateData* isolate_data);
-  inline ~NoArrayBufferZeroFillScope();
-
- private:
-  NodeArrayBufferAllocator* node_allocator_;
-
-  friend class Environment;
-};
-
-// A unique-pointer-ish object that is compatible with the JS engine's
-// ArrayBuffer::Allocator.
-// TODO(addaleax): We may want to start phasing this out as it's only a
-// thin wrapper around v8::BackingStore at this point
-struct AllocatedBuffer {
- public:
-  // Utilities that allocate memory using the Isolate's ArrayBuffer::Allocator.
-  // In particular, using AllocateManaged() will provide a RAII-style object
-  // with easy conversion to `Buffer` and `ArrayBuffer` objects.
-  inline static AllocatedBuffer AllocateManaged(Environment* env, size_t size);
-
-  AllocatedBuffer() = default;
-  inline AllocatedBuffer(
-      Environment* env, std::unique_ptr<v8::BackingStore> bs);
-  // For this constructor variant, `buffer` *must* come from an earlier call
-  // to .release
-  inline AllocatedBuffer(Environment* env, uv_buf_t buffer);
-
-  inline void Resize(size_t len);
-
-  inline uv_buf_t release();
-  inline char* data();
-  inline const char* data() const;
-  inline size_t size() const;
-  inline void clear();
-
-  inline v8::MaybeLocal<v8::Object> ToBuffer();
-  inline v8::Local<v8::ArrayBuffer> ToArrayBuffer();
-
-  AllocatedBuffer(AllocatedBuffer&& other) = default;
-  AllocatedBuffer& operator=(AllocatedBuffer&& other) = default;
-  AllocatedBuffer(const AllocatedBuffer& other) = delete;
-  AllocatedBuffer& operator=(const AllocatedBuffer& other) = delete;
-
- private:
-  Environment* env_ = nullptr;
-  std::unique_ptr<v8::BackingStore> backing_store_;
-
-  friend class Environment;
-};
-
-}  // namespace node
-
-#endif  // NODE_WANT_INTERNALS
-
-#endif  // SRC_ALLOCATED_BUFFER_H_

package/src/headers/14/async_wrap-inl.h

@@ -1,94 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_ASYNC_WRAP_INL_H_
-#define SRC_ASYNC_WRAP_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "base_object-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-inline AsyncWrap::ProviderType AsyncWrap::provider_type() const {
-  return provider_type_;
-}
-
-inline AsyncWrap::ProviderType AsyncWrap::set_provider_type(
-    AsyncWrap::ProviderType provider) {
-  provider_type_ = provider;
-  return provider_type_;
-}
-
-inline double AsyncWrap::get_async_id() const {
-  return async_id_;
-}
-
-
-inline double AsyncWrap::get_trigger_async_id() const {
-  return trigger_async_id_;
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::String> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  return MakeCallback(symbol.As<v8::Name>(), argc, argv);
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::Symbol> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  return MakeCallback(symbol.As<v8::Name>(), argc, argv);
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::Name> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  v8::Local<v8::Value> cb_v;
-  if (!object()->Get(env()->context(), symbol).ToLocal(&cb_v))
-    return v8::MaybeLocal<v8::Value>();
-  if (!cb_v->IsFunction()) {
-    v8::Isolate* isolate = env()->isolate();
-    return Undefined(isolate);
-  }
-  return MakeCallback(cb_v.As<v8::Function>(), argc, argv);
-}
-
-
-// Defined here to avoid a circular dependency with env-inl.h.
-inline AsyncHooks::DefaultTriggerAsyncIdScope ::DefaultTriggerAsyncIdScope(
-    AsyncWrap* async_wrap)
-    : DefaultTriggerAsyncIdScope(async_wrap->env(),
-                                 async_wrap->get_async_id()) {}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ASYNC_WRAP_INL_H_

package/src/headers/14/async_wrap.h

@@ -1,230 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_ASYNC_WRAP_H_
-#define SRC_ASYNC_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "v8.h"
-
-#include <cstdint>
-
-namespace node {
-
-#define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                               \
-  V(NONE)                                                                     \
-  V(DIRHANDLE)                                                                \
-  V(DNSCHANNEL)                                                               \
-  V(ELDHISTOGRAM)                                                             \
-  V(FILEHANDLE)                                                               \
-  V(FILEHANDLECLOSEREQ)                                                       \
-  V(FSEVENTWRAP)                                                              \
-  V(FSREQCALLBACK)                                                            \
-  V(FSREQPROMISE)                                                             \
-  V(GETADDRINFOREQWRAP)                                                       \
-  V(GETNAMEINFOREQWRAP)                                                       \
-  V(HEAPSNAPSHOT)                                                             \
-  V(HTTP2SESSION)                                                             \
-  V(HTTP2STREAM)                                                              \
-  V(HTTP2PING)                                                                \
-  V(HTTP2SETTINGS)                                                            \
-  V(HTTPINCOMINGMESSAGE)                                                      \
-  V(HTTPCLIENTREQUEST)                                                        \
-  V(JSSTREAM)                                                                 \
-  V(JSUDPWRAP)                                                                \
-  V(MESSAGEPORT)                                                              \
-  V(PIPECONNECTWRAP)                                                          \
-  V(PIPESERVERWRAP)                                                           \
-  V(PIPEWRAP)                                                                 \
-  V(PROCESSWRAP)                                                              \
-  V(PROMISE)                                                                  \
-  V(QUERYWRAP)                                                                \
-  V(SHUTDOWNWRAP)                                                             \
-  V(SIGNALWRAP)                                                               \
-  V(STATWATCHER)                                                              \
-  V(STREAMPIPE)                                                               \
-  V(TCPCONNECTWRAP)                                                           \
-  V(TCPSERVERWRAP)                                                            \
-  V(TCPWRAP)                                                                  \
-  V(TTYWRAP)                                                                  \
-  V(UDPSENDWRAP)                                                              \
-  V(UDPWRAP)                                                                  \
-  V(SIGINTWATCHDOG)                                                           \
-  V(WORKER)                                                                   \
-  V(WORKERHEAPSNAPSHOT)                                                       \
-  V(WRITEWRAP)                                                                \
-  V(ZLIB)
-
-#if HAVE_OPENSSL
-#define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                   \
-  V(PBKDF2REQUEST)                                                            \
-  V(KEYPAIRGENREQUEST)                                                        \
-  V(RANDOMBYTESREQUEST)                                                       \
-  V(SCRYPTREQUEST)                                                            \
-  V(TLSWRAP)
-#else
-#define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)
-#endif  // HAVE_OPENSSL
-
-#if HAVE_INSPECTOR
-#define NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)                                \
-  V(INSPECTORJSBINDING)
-#else
-#define NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)
-#endif  // HAVE_INSPECTOR
-
-#define NODE_ASYNC_PROVIDER_TYPES(V)                                          \
-  NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                                     \
-  NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                         \
-  NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)
-
-class Environment;
-class DestroyParam;
-
-class AsyncWrap : public BaseObject {
- public:
-  enum ProviderType {
-#define V(PROVIDER)                                                           \
-    PROVIDER_ ## PROVIDER,
-    NODE_ASYNC_PROVIDER_TYPES(V)
-#undef V
-    PROVIDERS_LENGTH,
-  };
-
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> object,
-            ProviderType provider,
-            double execution_async_id = kInvalidAsyncId);
-
-  // This constructor creates a reusable instance where user is responsible
-  // to call set_provider_type() and AsyncReset() before use.
-  AsyncWrap(Environment* env, v8::Local<v8::Object> object);
-
-  ~AsyncWrap() override;
-
-  AsyncWrap() = delete;
-
-  static constexpr double kInvalidAsyncId = -1;
-
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-
-  static void GetAsyncId(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void PushAsyncContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void PopAsyncContext(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void AsyncReset(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetProviderType(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void QueueDestroyAsyncId(
-    const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetCallbackTrampoline(
-    const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void EmitAsyncInit(Environment* env,
-                            v8::Local<v8::Object> object,
-                            v8::Local<v8::String> type,
-                            double async_id,
-                            double trigger_async_id);
-
-  static void EmitDestroy(Environment* env, double async_id);
-  static void EmitBefore(Environment* env, double async_id);
-  static void EmitAfter(Environment* env, double async_id);
-  static void EmitPromiseResolve(Environment* env, double async_id);
-
-  void EmitDestroy(bool from_gc = false);
-
-  void EmitTraceEventBefore();
-  static void EmitTraceEventAfter(ProviderType type, double async_id);
-  void EmitTraceEventDestroy();
-
-  static void DestroyAsyncIdsCallback(Environment* env);
-
-  inline ProviderType provider_type() const;
-  inline ProviderType set_provider_type(ProviderType provider);
-
-  inline double get_async_id() const;
-  inline double get_trigger_async_id() const;
-
-  void AsyncReset(v8::Local<v8::Object> resource,
-                  double execution_async_id = kInvalidAsyncId,
-                  bool silent = false);
-
-  // Only call these within a valid HandleScope.
-  v8::MaybeLocal<v8::Value> MakeCallback(const v8::Local<v8::Function> cb,
-                                         int argc,
-                                         v8::Local<v8::Value>* argv);
-  inline v8::MaybeLocal<v8::Value> MakeCallback(
-      const v8::Local<v8::Symbol> symbol,
-      int argc,
-      v8::Local<v8::Value>* argv);
-  inline v8::MaybeLocal<v8::Value> MakeCallback(
-      const v8::Local<v8::String> symbol,
-      int argc,
-      v8::Local<v8::Value>* argv);
-  inline v8::MaybeLocal<v8::Value> MakeCallback(
-      const v8::Local<v8::Name> symbol,
-      int argc,
-      v8::Local<v8::Value>* argv);
-
-  virtual std::string diagnostic_name() const;
-  std::string MemoryInfoName() const override;
-
-  static void WeakCallback(const v8::WeakCallbackInfo<DestroyParam> &info);
-
-  // Returns the object that 'owns' an async wrap. For example, for a
-  // TCP connection handle, this is the corresponding net.Socket.
-  v8::Local<v8::Object> GetOwner();
-  static v8::Local<v8::Object> GetOwner(Environment* env,
-                                        v8::Local<v8::Object> obj);
-
-  bool IsDoneInitializing() const override;
-
- private:
-  friend class PromiseWrap;
-
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> promise,
-            ProviderType provider,
-            double execution_async_id,
-            bool silent);
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> promise,
-            ProviderType provider,
-            double execution_async_id,
-            double trigger_async_id);
-  ProviderType provider_type_ = PROVIDER_NONE;
-  bool init_hook_ran_ = false;
-  // Because the values may be Reset(), cannot be made const.
-  double async_id_ = kInvalidAsyncId;
-  double trigger_async_id_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ASYNC_WRAP_H_

package/src/headers/14/base64.h

@@ -1,183 +0,0 @@
-#ifndef SRC_BASE64_H_
-#define SRC_BASE64_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "util.h"
-
-#include <cstddef>
-#include <cstdint>
-
-namespace node {
-//// Base 64 ////
-static inline constexpr size_t base64_encoded_size(size_t size) {
-  return ((size + 2) / 3 * 4);
-}
-
-// 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;
-}
-
-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);
-}
-
-
-extern const int8_t unbase64_table[256];
-
-
-inline static int8_t unbase64(uint8_t x) {
-  return unbase64_table[x];
-}
-
-
-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 = 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.
-}
-
-
-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 uint32_t v =
-        unbase64(src[i + 0]) << 24 |
-        unbase64(src[i + 1]) << 16 |
-        unbase64(src[i + 2]) << 8 |
-        unbase64(src[i + 3]);
-    // 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_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);
-}
-
-static size_t base64_encode(const char* src,
-                            size_t slen,
-                            char* dst,
-                            size_t dlen) {
-  // We know how much we'll write, just make sure that there's space.
-  CHECK(dlen >= base64_encoded_size(slen) &&
-        "not enough space provided for base64 encode");
-
-  dlen = base64_encoded_size(slen);
-
-  unsigned a;
-  unsigned b;
-  unsigned c;
-  unsigned i;
-  unsigned k;
-  unsigned n;
-
-  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                              "abcdefghijklmnopqrstuvwxyz"
-                              "0123456789+/";
-
-  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];
-      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];
-      dst[k + 3] = '=';
-      break;
-  }
-
-  return dlen;
-}
-}  // namespace node
-
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE64_H_