@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/crypto/crypto_scrypt.h

@@ -1,87 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_SCRYPT_H_
-#define SRC_CRYPTO_CRYPTO_SCRYPT_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_util.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-#ifndef OPENSSL_NO_SCRYPT
-
-// Scrypt is a password-based key derivation algorithm
-// defined in https://tools.ietf.org/html/rfc7914
-
-// It takes as input a password, a salt value, and a
-// handful of additional parameters that control the
-// cost of the operation. In this case, the higher
-// the cost, the better the result. The length parameter
-// defines the number of bytes that are generated.
-
-// The salt must be as random as possible and should be
-// at least 16 bytes in length.
-
-struct ScryptConfig final : public MemoryRetainer {
-  CryptoJobMode mode;
-  ByteSource pass;
-  ByteSource salt;
-  uint32_t N;
-  uint32_t r;
-  uint32_t p;
-  uint64_t maxmem;
-  int32_t length;
-
-  ScryptConfig() = default;
-
-  explicit ScryptConfig(ScryptConfig&& other) noexcept;
-
-  ScryptConfig& operator=(ScryptConfig&& other) noexcept;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(ScryptConfig)
-  SET_SELF_SIZE(ScryptConfig)
-};
-
-struct ScryptTraits final {
-  using AdditionalParameters = ScryptConfig;
-  static constexpr const char* JobName = "ScryptJob";
-  static constexpr AsyncWrap::ProviderType Provider =
-      AsyncWrap::PROVIDER_SCRYPTREQUEST;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int offset,
-      ScryptConfig* params);
-
-  static bool DeriveBits(
-      Environment* env,
-      const ScryptConfig& params,
-      ByteSource* out);
-
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const ScryptConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
-};
-
-using ScryptJob = DeriveBitsJob<ScryptTraits>;
-
-#else
-// If there is no Scrypt support, ScryptJob becomes a non-op
-struct ScryptJob {
-  static void Initialize(
-      Environment* env,
-      v8::Local<v8::Object> target) {}
-};
-#endif  // !OPENSSL_NO_SCRYPT
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_SCRYPT_H_

package/src/headers/18/crypto/crypto_sig.h

@@ -1,168 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_SIG_H_
-#define SRC_CRYPTO_CRYPTO_SIG_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "env.h"
-#include "memory_tracker.h"
-
-namespace node {
-namespace crypto {
-static const unsigned int kNoDsaSignature = static_cast<unsigned int>(-1);
-
-enum DSASigEnc {
-  kSigEncDER,
-  kSigEncP1363
-};
-
-class SignBase : public BaseObject {
- public:
-  typedef enum {
-    kSignOk,
-    kSignUnknownDigest,
-    kSignInit,
-    kSignNotInitialised,
-    kSignUpdate,
-    kSignPrivateKey,
-    kSignPublicKey,
-    kSignMalformedSignature
-  } Error;
-
-  SignBase(Environment* env, v8::Local<v8::Object> wrap);
-
-  Error Init(const char* sign_type);
-  Error Update(const char* data, size_t len);
-
-  // TODO(joyeecheung): track the memory used by OpenSSL types
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(SignBase)
-  SET_SELF_SIZE(SignBase)
-
- protected:
-  EVPMDPointer mdctx_;
-};
-
-class Sign : public SignBase {
- public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-
-  struct SignResult {
-    Error error;
-    std::unique_ptr<v8::BackingStore> signature;
-
-    explicit SignResult(
-        Error err,
-        std::unique_ptr<v8::BackingStore>&& sig = nullptr)
-      : error(err), signature(std::move(sig)) {}
-  };
-
-  SignResult SignFinal(
-      const ManagedEVPPKey& pkey,
-      int padding,
-      const v8::Maybe<int>& saltlen,
-      DSASigEnc dsa_sig_enc);
-
-  static void SignSync(const v8::FunctionCallbackInfo<v8::Value>& args);
-
- protected:
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SignInit(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SignUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SignFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  Sign(Environment* env, v8::Local<v8::Object> wrap);
-};
-
-class Verify : public SignBase {
- public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-
-  Error VerifyFinal(const ManagedEVPPKey& key,
-                    const ByteSource& sig,
-                    int padding,
-                    const v8::Maybe<int>& saltlen,
-                    bool* verify_result);
-
-  static void VerifySync(const v8::FunctionCallbackInfo<v8::Value>& args);
-
- protected:
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void VerifyInit(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void VerifyUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void VerifyFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  Verify(Environment* env, v8::Local<v8::Object> wrap);
-};
-
-struct SignConfiguration final : public MemoryRetainer {
-  enum Mode {
-    kSign,
-    kVerify
-  };
-  enum Flags {
-    kHasNone = 0,
-    kHasSaltLength = 1,
-    kHasPadding = 2
-  };
-
-  CryptoJobMode job_mode;
-  Mode mode;
-  ManagedEVPPKey key;
-  ByteSource data;
-  ByteSource signature;
-  const EVP_MD* digest = nullptr;
-  int flags = SignConfiguration::kHasNone;
-  int padding = 0;
-  int salt_length = 0;
-  DSASigEnc dsa_encoding = kSigEncDER;
-
-  SignConfiguration() = default;
-
-  explicit SignConfiguration(SignConfiguration&& other) noexcept;
-
-  SignConfiguration& operator=(SignConfiguration&& other) noexcept;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(SignConfiguration)
-  SET_SELF_SIZE(SignConfiguration)
-};
-
-struct SignTraits final {
-  using AdditionalParameters = SignConfiguration;
-  static constexpr const char* JobName = "SignJob";
-
-// TODO(@jasnell): Sign request vs. Verify request
-
-  static constexpr AsyncWrap::ProviderType Provider =
-      AsyncWrap::PROVIDER_SIGNREQUEST;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int offset,
-      SignConfiguration* params);
-
-  static bool DeriveBits(
-      Environment* env,
-      const SignConfiguration& params,
-      ByteSource* out);
-
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const SignConfiguration& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
-};
-
-using SignJob = DeriveBitsJob<SignTraits>;
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_SIG_H_

package/src/headers/18/crypto/crypto_spkac.h

@@ -1,21 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_SPKAC_H_
-#define SRC_CRYPTO_CRYPTO_SPKAC_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "v8.h"
-
-#include <openssl/evp.h>
-
-namespace node {
-namespace crypto {
-namespace SPKAC {
-void Initialize(Environment* env, v8::Local<v8::Object>);
-void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-}  // namespace SPKAC
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_SPKAC_H_

package/src/headers/18/crypto/crypto_timing.h

@@ -1,20 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_TIMING_H_
-#define SRC_CRYPTO_CRYPTO_TIMING_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-namespace Timing {
-void Initialize(Environment* env, v8::Local<v8::Object> target);
-void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-}  // namespace Timing
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_CRYPTO_CRYPTO_TIMING_H_

package/src/headers/18/crypto/crypto_x509.h

@@ -1,143 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_X509_H_
-#define SRC_CRYPTO_CRYPTO_X509_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "crypto/crypto_util.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "node_worker.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-
-// The ManagedX509 class is essentially a smart pointer for
-// X509 objects that allows an X509Certificate instance to
-// be cloned at the JS level while pointing at the same
-// underlying X509 instance.
-class ManagedX509 : public MemoryRetainer {
- public:
-  ManagedX509() = default;
-  explicit ManagedX509(X509Pointer&& cert);
-  ManagedX509(const ManagedX509& that);
-  ManagedX509& operator=(const ManagedX509& that);
-
-  operator bool() const { return !!cert_; }
-  X509* get() const { return cert_.get(); }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(ManagedX509)
-  SET_SELF_SIZE(ManagedX509)
-
- private:
-  X509Pointer cert_;
-};
-
-class X509Certificate : public BaseObject {
- public:
-  enum class GetPeerCertificateFlag {
-    NONE,
-    SERVER
-  };
-
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-  static bool HasInstance(Environment* env, v8::Local<v8::Object> object);
-
-  static v8::MaybeLocal<v8::Object> New(
-      Environment* env,
-      X509Pointer cert,
-      STACK_OF(X509)* issuer_chain = nullptr);
-
-  static v8::MaybeLocal<v8::Object> New(
-      Environment* env,
-      std::shared_ptr<ManagedX509> cert,
-      STACK_OF(X509)* issuer_chain = nullptr);
-
-  static v8::MaybeLocal<v8::Object> GetCert(
-      Environment* env,
-      const SSLPointer& ssl);
-
-  static v8::MaybeLocal<v8::Object> GetPeerCert(
-      Environment* env,
-      const SSLPointer& ssl,
-      GetPeerCertificateFlag flag);
-
-  static v8::Local<v8::Object> Wrap(
-      Environment* env,
-      v8::Local<v8::Object> object,
-      X509Pointer cert);
-
-  static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Subject(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SubjectAltName(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Issuer(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void InfoAccess(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ValidFrom(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ValidTo(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Fingerprint(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Fingerprint256(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Fingerprint512(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void KeyUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SerialNumber(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Raw(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void PublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Pem(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckCA(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckHost(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckEmail(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckIP(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckIssued(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Verify(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ToLegacy(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetIssuerCert(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  X509* get() { return cert_->get(); }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(X509Certificate)
-  SET_SELF_SIZE(X509Certificate)
-
-  class X509CertificateTransferData : public worker::TransferData {
-   public:
-    explicit X509CertificateTransferData(
-        const std::shared_ptr<ManagedX509>& data)
-        : data_(data) {}
-
-    BaseObjectPtr<BaseObject> Deserialize(
-        Environment* env,
-        v8::Local<v8::Context> context,
-        std::unique_ptr<worker::TransferData> self) override;
-
-    SET_MEMORY_INFO_NAME(X509CertificateTransferData)
-    SET_SELF_SIZE(X509CertificateTransferData)
-    SET_NO_MEMORY_INFO()
-
-   private:
-    std::shared_ptr<ManagedX509> data_;
-  };
-
-  BaseObject::TransferMode GetTransferMode() const override;
-  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
-
- private:
-  X509Certificate(
-      Environment* env,
-      v8::Local<v8::Object> object,
-      std::shared_ptr<ManagedX509> cert,
-      STACK_OF(X509)* issuer_chain = nullptr);
-
-  std::shared_ptr<ManagedX509> cert_;
-  BaseObjectPtr<X509Certificate> issuer_cert_;
-};
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_X509_H_

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

@@ -1,223 +0,0 @@
-#ifndef SRC_DEBUG_UTILS_INL_H_
-#define SRC_DEBUG_UTILS_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "debug_utils.h"
-#include "env.h"
-
-#include <type_traits>
-
-namespace node {
-
-struct ToStringHelper {
-  template <typename T>
-  static std::string Convert(
-      const T& value,
-      std::string(T::* to_string)() const = &T::ToString) {
-    return (value.*to_string)();
-  }
-  template <typename T,
-            typename test_for_number = typename std::
-                enable_if<std::is_arithmetic<T>::value, bool>::type,
-            typename dummy = bool>
-  static std::string Convert(const T& value) { return std::to_string(value); }
-  static std::string Convert(const char* value) {
-    return value != nullptr ? value : "(null)";
-  }
-  static std::string Convert(const std::string& value) { return value; }
-  static std::string Convert(bool value) { return value ? "true" : "false"; }
-  template <unsigned BASE_BITS,
-            typename T,
-            typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
-  static std::string BaseConvert(const T& value) {
-    auto v = static_cast<uint64_t>(value);
-    char ret[3 * sizeof(T)];
-    char* ptr = ret + 3 * sizeof(T) - 1;
-    *ptr = '\0';
-    const char* digits = "0123456789abcdef";
-    do {
-      unsigned digit = v & ((1 << BASE_BITS) - 1);
-      *--ptr =
-          (BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
-    } while ((v >>= BASE_BITS) != 0);
-    return ptr;
-  }
-  template <unsigned BASE_BITS,
-            typename T,
-            typename std::enable_if<!std::is_integral<T>::value, int>::type = 0>
-  static std::string BaseConvert(T value) {
-    return Convert(std::forward<T>(value));
-  }
-};
-
-template <typename T>
-std::string ToString(const T& value) {
-  return ToStringHelper::Convert(value);
-}
-
-template <unsigned BASE_BITS, typename T>
-std::string ToBaseString(const T& value) {
-  return ToStringHelper::BaseConvert<BASE_BITS>(value);
-}
-
-inline std::string SPrintFImpl(const char* format) {
-  const char* p = strchr(format, '%');
-  if (LIKELY(p == nullptr)) return format;
-  CHECK_EQ(p[1], '%');  // Only '%%' allowed when there are no arguments.
-
-  return std::string(format, p + 1) + SPrintFImpl(p + 2);
-}
-
-template <typename Arg, typename... Args>
-std::string COLD_NOINLINE SPrintFImpl(  // NOLINT(runtime/string)
-    const char* format, Arg&& arg, Args&&... args) {
-  const char* p = strchr(format, '%');
-  CHECK_NOT_NULL(p);  // If you hit this, you passed in too many arguments.
-  std::string ret(format, p);
-  // Ignore long / size_t modifiers
-  while (strchr("lz", *++p) != nullptr) {}
-  switch (*p) {
-    case '%': {
-      return ret + '%' + SPrintFImpl(p + 1,
-                                     std::forward<Arg>(arg),
-                                     std::forward<Args>(args)...);
-    }
-    default: {
-      return ret + '%' + SPrintFImpl(p,
-                                     std::forward<Arg>(arg),
-                                     std::forward<Args>(args)...);
-    }
-    case 'd':
-    case 'i':
-    case 'u':
-    case 's':
-      ret += ToString(arg);
-      break;
-    case 'o':
-      ret += ToBaseString<3>(arg);
-      break;
-    case 'x':
-      ret += ToBaseString<4>(arg);
-      break;
-    case 'X':
-      ret += node::ToUpper(ToBaseString<4>(arg));
-      break;
-    case 'p': {
-      CHECK(std::is_pointer<typename std::remove_reference<Arg>::type>::value);
-      char out[20];
-      int n = snprintf(out,
-                       sizeof(out),
-                       "%p",
-                       *reinterpret_cast<const void* const*>(&arg));
-      CHECK_GE(n, 0);
-      ret += out;
-      break;
-    }
-  }
-  return ret + SPrintFImpl(p + 1, std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-std::string COLD_NOINLINE SPrintF(  // NOLINT(runtime/string)
-    const char* format, Args&&... args) {
-  return SPrintFImpl(format, std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-void COLD_NOINLINE FPrintF(FILE* file, const char* format, Args&&... args) {
-  FWrite(file, SPrintF(format, std::forward<Args>(args)...));
-}
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(EnabledDebugList* list,
-                               DebugCategory cat,
-                               const char* format,
-                               Args&&... args) {
-  if (!UNLIKELY(list->enabled(cat))) return;
-  FPrintF(stderr, format, std::forward<Args>(args)...);
-}
-
-inline void FORCE_INLINE Debug(EnabledDebugList* list,
-                               DebugCategory cat,
-                               const char* message) {
-  if (!UNLIKELY(list->enabled(cat))) return;
-  FPrintF(stderr, "%s", message);
-}
-
-template <typename... Args>
-inline void FORCE_INLINE
-Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args) {
-  Debug(env->enabled_debug_list(), cat, format, std::forward<Args>(args)...);
-}
-
-inline void FORCE_INLINE Debug(Environment* env,
-                               DebugCategory cat,
-                               const char* message) {
-  Debug(env->enabled_debug_list(), cat, message);
-}
-
-template <typename... Args>
-inline void Debug(Environment* env,
-                  DebugCategory cat,
-                  const std::string& format,
-                  Args&&... args) {
-  Debug(env->enabled_debug_list(),
-        cat,
-        format.c_str(),
-        std::forward<Args>(args)...);
-}
-
-// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
-// the FORCE_INLINE flag on them doesn't apply to the contents of this function
-// as well.
-// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
-// this function for speed and it should rather focus on keeping it out of
-// hot code paths. In particular, we want to keep the string concatenating code
-// out of the function containing the original `Debug()` call.
-template <typename... Args>
-void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
-                                               const char* format,
-                                               Args&&... args) {
-  Debug(async_wrap->env(),
-        static_cast<DebugCategory>(async_wrap->provider_type()),
-        async_wrap->diagnostic_name() + " " + format + "\n",
-        std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
-                               const char* format,
-                               Args&&... args) {
-  DCHECK_NOT_NULL(async_wrap);
-  DebugCategory cat = static_cast<DebugCategory>(async_wrap->provider_type());
-  if (!UNLIKELY(async_wrap->env()->enabled_debug_list()->enabled(cat))) return;
-  UnconditionalAsyncWrapDebug(async_wrap, format, std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
-                               const std::string& format,
-                               Args&&... args) {
-  Debug(async_wrap, format.c_str(), std::forward<Args>(args)...);
-}
-
-namespace per_process {
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(DebugCategory cat,
-                               const char* format,
-                               Args&&... args) {
-  Debug(&enabled_debug_list, cat, format, std::forward<Args>(args)...);
-}
-
-inline void FORCE_INLINE Debug(DebugCategory cat, const char* message) {
-  Debug(&enabled_debug_list, cat, message);
-}
-
-}  // namespace per_process
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_DEBUG_UTILS_INL_H_

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

@@ -1,33 +0,0 @@
-#ifndef SRC_DIAGNOSTICFILENAME_INL_H_
-#define SRC_DIAGNOSTICFILENAME_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_internals.h"
-namespace node {
-
-class Environment;
-
-inline DiagnosticFilename::DiagnosticFilename(
-    Environment* env,
-    const char* prefix,
-    const char* ext) :
-  filename_(MakeFilename(env->thread_id(), prefix, ext)) {
-}
-
-inline DiagnosticFilename::DiagnosticFilename(
-    uint64_t thread_id,
-    const char* prefix,
-    const char* ext) :
-  filename_(MakeFilename(thread_id, prefix, ext)) {
-}
-
-inline const char* DiagnosticFilename::operator*() const {
-  return filename_.c_str();
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_DIAGNOSTICFILENAME_INL_H_