@encharm/cws 4.0.2 → 4.3.0

package/src/headers/10/tracing/traced_value.h

@@ -1,68 +0,0 @@
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SRC_TRACING_TRACED_VALUE_H_
-#define SRC_TRACING_TRACED_VALUE_H_
-
-#include "node_internals.h"
-#include "v8.h"
-
-#include <stddef.h>
-#include <memory>
-#include <string>
-
-namespace node {
-namespace tracing {
-
-class TracedValue : public v8::ConvertableToTraceFormat {
- public:
-  ~TracedValue() override;
-
-  static std::unique_ptr<TracedValue> Create();
-  static std::unique_ptr<TracedValue> CreateArray();
-
-  void EndDictionary();
-  void EndArray();
-
-  // These methods assume that |name| is a long lived "quoted" string.
-  void SetInteger(const char* name, int value);
-  void SetDouble(const char* name, double value);
-  void SetBoolean(const char* name, bool value);
-  void SetNull(const char* name);
-  void SetString(const char* name, const char* value);
-  void SetString(const char* name, const std::string& value) {
-    SetString(name, value.c_str());
-  }
-  void BeginDictionary(const char* name);
-  void BeginArray(const char* name);
-
-  void AppendInteger(int);
-  void AppendDouble(double);
-  void AppendBoolean(bool);
-  void AppendNull();
-  void AppendString(const char*);
-  void AppendString(const std::string& value) { AppendString(value.c_str()); }
-  void BeginArray();
-  void BeginDictionary();
-
-  // ConvertableToTraceFormat implementation.
-  void AppendAsTraceFormat(std::string* out) const override;
-
- private:
-  explicit TracedValue(bool root_is_array = false);
-
-  void WriteComma();
-  void WriteName(const char* name);
-
-  std::string data_;
-  bool first_item_;
-  bool root_is_array_;
-
-  DISALLOW_COPY_AND_ASSIGN(TracedValue);
-};
-
-}  // namespace tracing
-}  // namespace node
-
-#endif  // SRC_TRACING_TRACED_VALUE_H_

package/src/headers/10/tty_wrap.h

@@ -1,63 +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_TTY_WRAP_H_
-#define SRC_TTY_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "uv.h"
-#include "stream_wrap.h"
-
-namespace node {
-
-class TTYWrap : public LibuvStreamWrap {
- public:
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(TTYWrap)
-  SET_SELF_SIZE(TTYWrap)
-
- private:
-  TTYWrap(Environment* env,
-          v8::Local<v8::Object> object,
-          int fd,
-          bool readable,
-          int* init_err);
-
-  static void GuessHandleType(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void IsTTY(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetWindowSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetRawMode(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  uv_tty_t handle_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_TTY_WRAP_H_

package/src/headers/10/udp_wrap.h

@@ -1,102 +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_UDP_WRAP_H_
-#define SRC_UDP_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "env.h"
-#include "handle_wrap.h"
-#include "uv.h"
-#include "v8.h"
-
-namespace node {
-
-class UDPWrap: public HandleWrap {
- public:
-  enum SocketType {
-    SOCKET
-  };
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context);
-  static void GetFD(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Bind(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Bind6(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Send6(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RecvStart(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RecvStop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void AddMembership(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void DropMembership(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetMulticastInterface(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetMulticastTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetMulticastLoopback(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetBroadcast(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void BufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static v8::Local<v8::Object> Instantiate(Environment* env,
-                                           AsyncWrap* parent,
-                                           SocketType type);
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(UDPWrap)
-  SET_SELF_SIZE(UDPWrap)
-
- private:
-  typedef uv_udp_t HandleType;
-
-  template <typename T,
-            int (*F)(const typename T::HandleType*, sockaddr*, int*)>
-  friend void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>&);
-
-  UDPWrap(Environment* env, v8::Local<v8::Object> object);
-
-  static void DoBind(const v8::FunctionCallbackInfo<v8::Value>& args,
-                     int family);
-  static void DoSend(const v8::FunctionCallbackInfo<v8::Value>& args,
-                     int family);
-  static void SetMembership(const v8::FunctionCallbackInfo<v8::Value>& args,
-                            uv_membership membership);
-
-  static void OnAlloc(uv_handle_t* handle,
-                      size_t suggested_size,
-                      uv_buf_t* buf);
-  static void OnSend(uv_udp_send_t* req, int status);
-  static void OnRecv(uv_udp_t* handle,
-                     ssize_t nread,
-                     const uv_buf_t* buf,
-                     const struct sockaddr* addr,
-                     unsigned int flags);
-
-  uv_udp_t handle_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_UDP_WRAP_H_

package/src/headers/10/util-inl.h

@@ -1,459 +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_UTIL_INL_H_
-#define SRC_UTIL_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cstring>
-#include "util.h"
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#define BSWAP_2(x) _byteswap_ushort(x)
-#define BSWAP_4(x) _byteswap_ulong(x)
-#define BSWAP_8(x) _byteswap_uint64(x)
-#else
-#define BSWAP_2(x) ((x) << 8) | ((x) >> 8)
-#define BSWAP_4(x)                                                            \
-  (((x) & 0xFF) << 24) |                                                      \
-  (((x) & 0xFF00) << 8) |                                                     \
-  (((x) >> 8) & 0xFF00) |                                                     \
-  (((x) >> 24) & 0xFF)
-#define BSWAP_8(x)                                                            \
-  (((x) & 0xFF00000000000000ull) >> 56) |                                     \
-  (((x) & 0x00FF000000000000ull) >> 40) |                                     \
-  (((x) & 0x0000FF0000000000ull) >> 24) |                                     \
-  (((x) & 0x000000FF00000000ull) >> 8) |                                      \
-  (((x) & 0x00000000FF000000ull) << 8) |                                      \
-  (((x) & 0x0000000000FF0000ull) << 24) |                                     \
-  (((x) & 0x000000000000FF00ull) << 40) |                                     \
-  (((x) & 0x00000000000000FFull) << 56)
-#endif
-
-namespace node {
-
-template <typename T>
-ListNode<T>::ListNode() : prev_(this), next_(this) {}
-
-template <typename T>
-ListNode<T>::~ListNode() {
-  Remove();
-}
-
-template <typename T>
-void ListNode<T>::Remove() {
-  prev_->next_ = next_;
-  next_->prev_ = prev_;
-  prev_ = this;
-  next_ = this;
-}
-
-template <typename T>
-bool ListNode<T>::IsEmpty() const {
-  return prev_ == this;
-}
-
-template <typename T, ListNode<T> (T::*M)>
-ListHead<T, M>::Iterator::Iterator(ListNode<T>* node) : node_(node) {}
-
-template <typename T, ListNode<T> (T::*M)>
-T* ListHead<T, M>::Iterator::operator*() const {
-  return ContainerOf(M, node_);
-}
-
-template <typename T, ListNode<T> (T::*M)>
-const typename ListHead<T, M>::Iterator&
-ListHead<T, M>::Iterator::operator++() {
-  node_ = node_->next_;
-  return *this;
-}
-
-template <typename T, ListNode<T> (T::*M)>
-bool ListHead<T, M>::Iterator::operator!=(const Iterator& that) const {
-  return node_ != that.node_;
-}
-
-template <typename T, ListNode<T> (T::*M)>
-ListHead<T, M>::~ListHead() {
-  while (IsEmpty() == false)
-    head_.next_->Remove();
-}
-
-template <typename T, ListNode<T> (T::*M)>
-void ListHead<T, M>::PushBack(T* element) {
-  ListNode<T>* that = &(element->*M);
-  head_.prev_->next_ = that;
-  that->prev_ = head_.prev_;
-  that->next_ = &head_;
-  head_.prev_ = that;
-}
-
-template <typename T, ListNode<T> (T::*M)>
-void ListHead<T, M>::PushFront(T* element) {
-  ListNode<T>* that = &(element->*M);
-  head_.next_->prev_ = that;
-  that->prev_ = &head_;
-  that->next_ = head_.next_;
-  head_.next_ = that;
-}
-
-template <typename T, ListNode<T> (T::*M)>
-bool ListHead<T, M>::IsEmpty() const {
-  return head_.IsEmpty();
-}
-
-template <typename T, ListNode<T> (T::*M)>
-T* ListHead<T, M>::PopFront() {
-  if (IsEmpty())
-    return nullptr;
-  ListNode<T>* node = head_.next_;
-  node->Remove();
-  return ContainerOf(M, node);
-}
-
-template <typename T, ListNode<T> (T::*M)>
-typename ListHead<T, M>::Iterator ListHead<T, M>::begin() const {
-  return Iterator(head_.next_);
-}
-
-template <typename T, ListNode<T> (T::*M)>
-typename ListHead<T, M>::Iterator ListHead<T, M>::end() const {
-  return Iterator(const_cast<ListNode<T>*>(&head_));
-}
-
-template <typename Inner, typename Outer>
-constexpr uintptr_t OffsetOf(Inner Outer::*field) {
-  return reinterpret_cast<uintptr_t>(&(static_cast<Outer*>(0)->*field));
-}
-
-template <typename Inner, typename Outer>
-ContainerOfHelper<Inner, Outer>::ContainerOfHelper(Inner Outer::*field,
-                                                   Inner* pointer)
-    : pointer_(
-        reinterpret_cast<Outer*>(
-            reinterpret_cast<uintptr_t>(pointer) - OffsetOf(field))) {}
-
-template <typename Inner, typename Outer>
-template <typename TypeName>
-ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
-  return static_cast<TypeName*>(pointer_);
-}
-
-template <typename Inner, typename Outer>
-inline ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
-                                                   Inner* pointer) {
-  return ContainerOfHelper<Inner, Outer>(field, pointer);
-}
-
-template <class TypeName>
-inline v8::Local<TypeName> PersistentToLocal(
-    v8::Isolate* isolate,
-    const Persistent<TypeName>& persistent) {
-  if (persistent.IsWeak()) {
-    return WeakPersistentToLocal(isolate, persistent);
-  } else {
-    return StrongPersistentToLocal(persistent);
-  }
-}
-
-template <class TypeName>
-inline v8::Local<TypeName> StrongPersistentToLocal(
-    const Persistent<TypeName>& persistent) {
-  return *reinterpret_cast<v8::Local<TypeName>*>(
-      const_cast<Persistent<TypeName>*>(&persistent));
-}
-
-template <class TypeName>
-inline v8::Local<TypeName> WeakPersistentToLocal(
-    v8::Isolate* isolate,
-    const Persistent<TypeName>& persistent) {
-  return v8::Local<TypeName>::New(isolate, persistent);
-}
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const char* data,
-                                           int length) {
-  return v8::String::NewFromOneByte(isolate,
-                                    reinterpret_cast<const uint8_t*>(data),
-                                    v8::NewStringType::kNormal,
-                                    length).ToLocalChecked();
-}
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const signed char* data,
-                                           int length) {
-  return v8::String::NewFromOneByte(isolate,
-                                    reinterpret_cast<const uint8_t*>(data),
-                                    v8::NewStringType::kNormal,
-                                    length).ToLocalChecked();
-}
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const unsigned char* data,
-                                           int length) {
-  return v8::String::NewFromOneByte(
-             isolate, data, v8::NewStringType::kNormal, length)
-      .ToLocalChecked();
-}
-
-void SwapBytes16(char* data, size_t nbytes) {
-  CHECK_EQ(nbytes % 2, 0);
-
-#if defined(_MSC_VER)
-  int align = reinterpret_cast<uintptr_t>(data) % sizeof(uint16_t);
-  if (align == 0) {
-    // MSVC has no strict aliasing, and is able to highly optimize this case.
-    uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
-    size_t len16 = nbytes / sizeof(*data16);
-    for (size_t i = 0; i < len16; i++) {
-      data16[i] = BSWAP_2(data16[i]);
-    }
-    return;
-  }
-#endif
-
-  uint16_t temp;
-  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
-    memcpy(&temp, &data[i], sizeof(temp));
-    temp = BSWAP_2(temp);
-    memcpy(&data[i], &temp, sizeof(temp));
-  }
-}
-
-void SwapBytes32(char* data, size_t nbytes) {
-  CHECK_EQ(nbytes % 4, 0);
-
-#if defined(_MSC_VER)
-  int align = reinterpret_cast<uintptr_t>(data) % sizeof(uint32_t);
-  // MSVC has no strict aliasing, and is able to highly optimize this case.
-  if (align == 0) {
-    uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
-    size_t len32 = nbytes / sizeof(*data32);
-    for (size_t i = 0; i < len32; i++) {
-      data32[i] = BSWAP_4(data32[i]);
-    }
-    return;
-  }
-#endif
-
-  uint32_t temp;
-  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
-    memcpy(&temp, &data[i], sizeof(temp));
-    temp = BSWAP_4(temp);
-    memcpy(&data[i], &temp, sizeof(temp));
-  }
-}
-
-void SwapBytes64(char* data, size_t nbytes) {
-  CHECK_EQ(nbytes % 8, 0);
-
-#if defined(_MSC_VER)
-  int align = reinterpret_cast<uintptr_t>(data) % sizeof(uint64_t);
-  if (align == 0) {
-    // MSVC has no strict aliasing, and is able to highly optimize this case.
-    uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
-    size_t len64 = nbytes / sizeof(*data64);
-    for (size_t i = 0; i < len64; i++) {
-      data64[i] = BSWAP_8(data64[i]);
-    }
-    return;
-  }
-#endif
-
-  uint64_t temp;
-  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
-    memcpy(&temp, &data[i], sizeof(temp));
-    temp = BSWAP_8(temp);
-    memcpy(&data[i], &temp, sizeof(temp));
-  }
-}
-
-char ToLower(char c) {
-  return c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c;
-}
-
-std::string ToLower(const std::string& in) {
-  std::string out(in.size(), 0);
-  for (size_t i = 0; i < in.size(); ++i)
-    out[i] = ToLower(in[i]);
-  return out;
-}
-
-bool StringEqualNoCase(const char* a, const char* b) {
-  do {
-    if (*a == '\0')
-      return *b == '\0';
-    if (*b == '\0')
-      return *a == '\0';
-  } while (ToLower(*a++) == ToLower(*b++));
-  return false;
-}
-
-bool StringEqualNoCaseN(const char* a, const char* b, size_t length) {
-  for (size_t i = 0; i < length; i++) {
-    if (ToLower(a[i]) != ToLower(b[i]))
-      return false;
-    if (a[i] == '\0')
-      return true;
-  }
-  return true;
-}
-
-template <typename T>
-inline T MultiplyWithOverflowCheck(T a, T b) {
-  auto ret = a * b;
-  if (a != 0)
-    CHECK_EQ(b, ret / a);
-
-  return ret;
-}
-
-// These should be used in our code as opposed to the native
-// versions as they abstract out some platform and or
-// compiler version specific functionality.
-// malloc(0) and realloc(ptr, 0) have implementation-defined behavior in
-// that the standard allows them to either return a unique pointer or a
-// nullptr for zero-sized allocation requests.  Normalize by always using
-// a nullptr.
-template <typename T>
-T* UncheckedRealloc(T* pointer, size_t n) {
-  size_t full_size = MultiplyWithOverflowCheck(sizeof(T), n);
-
-  if (full_size == 0) {
-    free(pointer);
-    return nullptr;
-  }
-
-  void* allocated = realloc(pointer, full_size);
-
-  if (UNLIKELY(allocated == nullptr)) {
-    // Tell V8 that memory is low and retry.
-    LowMemoryNotification();
-    allocated = realloc(pointer, full_size);
-  }
-
-  return static_cast<T*>(allocated);
-}
-
-// As per spec realloc behaves like malloc if passed nullptr.
-template <typename T>
-inline T* UncheckedMalloc(size_t n) {
-  if (n == 0) n = 1;
-  return UncheckedRealloc<T>(nullptr, n);
-}
-
-template <typename T>
-inline T* UncheckedCalloc(size_t n) {
-  if (n == 0) n = 1;
-  MultiplyWithOverflowCheck(sizeof(T), n);
-  return static_cast<T*>(calloc(n, sizeof(T)));
-}
-
-template <typename T>
-inline T* Realloc(T* pointer, size_t n) {
-  T* ret = UncheckedRealloc(pointer, n);
-  CHECK_IMPLIES(n > 0, ret != nullptr);
-  return ret;
-}
-
-template <typename T>
-inline T* Malloc(size_t n) {
-  T* ret = UncheckedMalloc<T>(n);
-  CHECK_IMPLIES(n > 0, ret != nullptr);
-  return ret;
-}
-
-template <typename T>
-inline T* Calloc(size_t n) {
-  T* ret = UncheckedCalloc<T>(n);
-  CHECK_IMPLIES(n > 0, ret != nullptr);
-  return ret;
-}
-
-// Shortcuts for char*.
-inline char* Malloc(size_t n) { return Malloc<char>(n); }
-inline char* Calloc(size_t n) { return Calloc<char>(n); }
-inline char* UncheckedMalloc(size_t n) { return UncheckedMalloc<char>(n); }
-inline char* UncheckedCalloc(size_t n) { return UncheckedCalloc<char>(n); }
-
-// This is a helper in the .cc file so including util-inl.h doesn't include more
-// headers than we really need to.
-void ThrowErrStringTooLong(v8::Isolate* isolate);
-
-v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
-                                    const std::string& str) {
-  v8::Isolate* isolate = context->GetIsolate();
-  if (UNLIKELY(str.size() >= static_cast<size_t>(v8::String::kMaxLength))) {
-    // V8 only has a TODO comment about adding an exception when the maximum
-    // string size is exceeded.
-    ThrowErrStringTooLong(isolate);
-    return v8::MaybeLocal<v8::Value>();
-  }
-
-  return v8::String::NewFromUtf8(
-             isolate, str.data(), v8::NewStringType::kNormal, str.size())
-      .FromMaybe(v8::Local<v8::String>());
-}
-
-template <typename T>
-v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
-                                    const std::vector<T>& vec) {
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::EscapableHandleScope handle_scope(isolate);
-
-  v8::Local<v8::Array> arr = v8::Array::New(isolate, vec.size());
-  for (size_t i = 0; i < vec.size(); ++i) {
-    v8::Local<v8::Value> val;
-    if (!ToV8Value(context, vec[i]).ToLocal(&val) ||
-        arr->Set(context, i, val).IsNothing()) {
-      return v8::MaybeLocal<v8::Value>();
-    }
-  }
-
-  return handle_scope.Escape(arr);
-}
-
-template <typename T, typename U>
-v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
-                                    const std::unordered_map<T, U>& map) {
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::EscapableHandleScope handle_scope(isolate);
-
-  v8::Local<v8::Map> ret = v8::Map::New(isolate);
-  for (const auto& item : map) {
-    v8::Local<v8::Value> first, second;
-    if (!ToV8Value(context, item.first).ToLocal(&first) ||
-        !ToV8Value(context, item.second).ToLocal(&second) ||
-        ret->Set(context, first, second).IsEmpty()) {
-      return v8::MaybeLocal<v8::Value>();
-    }
-  }
-
-  return handle_scope.Escape(ret);
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_UTIL_INL_H_