@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/handle_wrap.h

@@ -0,0 +1,123 @@
+// 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_HANDLE_WRAP_H_
+#define SRC_HANDLE_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+class ExternalReferenceRegistry;
+
+// Rules:
+//
+// - Do not throw from handle methods. Set errno.
+//
+// - MakeCallback may only be made directly off the event loop.
+//   That is there can be no JavaScript stack frames underneath it.
+//   (Is there any way to assert that?)
+//
+// - No use of v8::WeakReferenceCallback. The close callback signifies that
+//   we're done with a handle - external resources can be freed.
+//
+// - Reusable?
+//
+// - The uv_close_cb is used to free the c++ object. The close callback
+//   is not made into javascript land.
+//
+// - uv_ref, uv_unref counts are managed at this layer to avoid needless
+//   js/c++ boundary crossing. At the javascript layer that should all be
+//   taken care of.
+
+class HandleWrap : public AsyncWrap {
+ public:
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static inline bool IsAlive(const HandleWrap* wrap) {
+    return wrap != nullptr &&
+        wrap->IsDoneInitializing() &&
+        wrap->state_ != kClosed;
+  }
+
+  static inline bool HasRef(const HandleWrap* wrap) {
+    return IsAlive(wrap) && uv_has_ref(wrap->GetHandle());
+  }
+
+  inline uv_handle_t* GetHandle() const { return handle_; }
+
+  virtual void Close(
+      v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ protected:
+  HandleWrap(Environment* env,
+             v8::Local<v8::Object> object,
+             uv_handle_t* handle,
+             AsyncWrap::ProviderType provider);
+  virtual void OnClose() {}
+  void OnGCCollect() final;
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
+
+  void MarkAsInitialized();
+  void MarkAsUninitialized();
+
+  inline bool IsHandleClosing() const {
+    return state_ == kClosing || state_ == kClosed;
+  }
+
+  static void OnClose(uv_handle_t* handle);
+  enum { kInitialized, kClosing, kClosed } state_;
+
+ private:
+  friend class Environment;
+  friend void GetActiveHandles(const v8::FunctionCallbackInfo<v8::Value>&);
+
+  // handle_wrap_queue_ needs to be at a fixed offset from the start of the
+  // class because it is used by src/node_postmortem_metadata.cc to calculate
+  // offsets and generate debug symbols for HandleWrap, which assumes that the
+  // position of members in memory are predictable. For more information please
+  // refer to `doc/contributing/node-postmortem-support.md`
+  friend int GenDebugSymbols();
+  ListNode<HandleWrap> handle_wrap_queue_;
+  uv_handle_t* const handle_;
+};
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HANDLE_WRAP_H_

package/dist/node/include/histogram-inl.h

@@ -0,0 +1,107 @@
+#ifndef SRC_HISTOGRAM_INL_H_
+#define SRC_HISTOGRAM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "histogram.h"
+#include "base_object-inl.h"
+#include "node_internals.h"
+
+namespace node {
+
+void Histogram::Reset() {
+  Mutex::ScopedLock lock(mutex_);
+  hdr_reset(histogram_.get());
+  exceeds_ = 0;
+  count_ = 0;
+  prev_ = 0;
+}
+
+double Histogram::Add(const Histogram& other) {
+  Mutex::ScopedLock lock(mutex_);
+  count_ += other.count_;
+  exceeds_ += other.exceeds_;
+  if (other.prev_ > prev_)
+    prev_ = other.prev_;
+  return static_cast<double>(hdr_add(histogram_.get(), other.histogram_.get()));
+}
+
+size_t Histogram::Count() const {
+  Mutex::ScopedLock lock(mutex_);
+  return count_;
+}
+
+int64_t Histogram::Min() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_min(histogram_.get());
+}
+
+int64_t Histogram::Max() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_max(histogram_.get());
+}
+
+double Histogram::Mean() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_mean(histogram_.get());
+}
+
+double Histogram::Stddev() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_stddev(histogram_.get());
+}
+
+int64_t Histogram::Percentile(double percentile) const {
+  Mutex::ScopedLock lock(mutex_);
+  CHECK_GT(percentile, 0);
+  CHECK_LE(percentile, 100);
+  return hdr_value_at_percentile(histogram_.get(), percentile);
+}
+
+template <typename Iterator>
+void Histogram::Percentiles(Iterator&& fn) {
+  Mutex::ScopedLock lock(mutex_);
+  hdr_iter iter;
+  hdr_iter_percentile_init(&iter, histogram_.get(), 1);
+  while (hdr_iter_next(&iter)) {
+    double key = iter.specifics.percentiles.percentile;
+    fn(key, iter.value);
+  }
+}
+
+bool Histogram::Record(int64_t value) {
+  Mutex::ScopedLock lock(mutex_);
+  bool recorded = hdr_record_value(histogram_.get(), value);
+  if (!recorded)
+    exceeds_++;
+  else
+    count_++;
+  return recorded;
+}
+
+uint64_t Histogram::RecordDelta() {
+  Mutex::ScopedLock lock(mutex_);
+  uint64_t time = uv_hrtime();
+  int64_t delta = 0;
+  if (prev_ > 0) {
+    CHECK_GE(time, prev_);
+    delta = time - prev_;
+    if (hdr_record_value(histogram_.get(), delta))
+      count_++;
+    else
+      exceeds_++;
+  }
+  prev_ = time;
+  return delta;
+}
+
+size_t Histogram::GetMemorySize() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_get_memory_size(histogram_.get());
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HISTOGRAM_INL_H_

package/dist/node/include/histogram.h

@@ -0,0 +1,279 @@
+#ifndef SRC_HISTOGRAM_H_
+#define SRC_HISTOGRAM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <hdr/hdr_histogram.h>
+#include "base_object.h"
+#include "memory_tracker.h"
+#include "node_messaging.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <functional>
+#include <limits>
+#include <map>
+#include <string>
+
+namespace node {
+
+class ExternalReferenceRegistry;
+
+constexpr int kDefaultHistogramFigures = 3;
+
+class Histogram : public MemoryRetainer {
+ public:
+  struct Options {
+    int64_t lowest = 1;
+    int64_t highest = std::numeric_limits<int64_t>::max();
+    int figures = kDefaultHistogramFigures;
+  };
+
+  explicit Histogram(const Options& options);
+  virtual ~Histogram() = default;
+
+  inline bool Record(int64_t value);
+  inline void Reset();
+  inline int64_t Min() const;
+  inline int64_t Max() const;
+  inline double Mean() const;
+  inline double Stddev() const;
+  inline int64_t Percentile(double percentile) const;
+  inline size_t Exceeds() const { return exceeds_; }
+  inline size_t Count() const;
+
+  inline uint64_t RecordDelta();
+
+  inline double Add(const Histogram& other);
+
+  // Iterator is a function type that takes two doubles as argument, one for
+  // percentile and one for the value at that percentile.
+  template <typename Iterator>
+  inline void Percentiles(Iterator&& fn);
+
+  inline size_t GetMemorySize() const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Histogram)
+  SET_SELF_SIZE(Histogram)
+
+ private:
+  using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
+  HistogramPointer histogram_;
+  uint64_t prev_ = 0;
+  size_t exceeds_ = 0;
+  size_t count_ = 0;
+  Mutex mutex_;
+};
+
+class HistogramImpl {
+ public:
+  enum InternalFields {
+    kSlot = BaseObject::kSlot,
+    kImplField = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
+
+  explicit HistogramImpl(
+      const Histogram::Options& options = Histogram::Options {});
+  explicit HistogramImpl(std::shared_ptr<Histogram> histogram);
+
+  Histogram* operator->() { return histogram_.get(); }
+
+  const std::shared_ptr<Histogram>& histogram() const { return histogram_; }
+
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentileBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentilesBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastReset(v8::Local<v8::Value> unused,
+                        v8::Local<v8::Value> receiver);
+  static double FastGetCount(v8::Local<v8::Value> unused,
+                             v8::Local<v8::Value> receiver);
+  static double FastGetMin(v8::Local<v8::Value> unused,
+                           v8::Local<v8::Value> receiver);
+  static double FastGetMax(v8::Local<v8::Value> unused,
+                           v8::Local<v8::Value> receiver);
+  static double FastGetMean(v8::Local<v8::Value> unused,
+                            v8::Local<v8::Value> receiver);
+  static double FastGetExceeds(v8::Local<v8::Value> unused,
+                               v8::Local<v8::Value> receiver);
+  static double FastGetStddev(v8::Local<v8::Value> unused,
+                              v8::Local<v8::Value> receiver);
+  static double FastGetPercentile(v8::Local<v8::Value> unused,
+                                  v8::Local<v8::Value> receiver,
+                                  const double percentile);
+
+  static void AddMethods(v8::Isolate* isolate,
+                         v8::Local<v8::FunctionTemplate> tmpl);
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static HistogramImpl* FromJSObject(v8::Local<v8::Value> value);
+
+ private:
+  std::shared_ptr<Histogram> histogram_;
+
+  static v8::CFunction fast_reset_;
+  static v8::CFunction fast_get_count_;
+  static v8::CFunction fast_get_min_;
+  static v8::CFunction fast_get_max_;
+  static v8::CFunction fast_get_mean_;
+  static v8::CFunction fast_get_exceeds_;
+  static v8::CFunction fast_get_stddev_;
+  static v8::CFunction fast_get_percentile_;
+};
+
+class HistogramBase final : public BaseObject, public HistogramImpl {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+  static void Initialize(IsolateData* isolate_data,
+                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      const Histogram::Options& options = Histogram::Options {});
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      std::shared_ptr<Histogram> histogram);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HistogramBase)
+  SET_SELF_SIZE(HistogramBase)
+
+  static void Record(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RecordDelta(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Add(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastRecord(
+      v8::Local<v8::Value> unused,
+      v8::Local<v8::Value> receiver,
+      const int64_t value,
+      v8::FastApiCallbackOptions& options);  // NOLINT(runtime/references)
+  static void FastRecordDelta(v8::Local<v8::Value> unused,
+                              v8::Local<v8::Value> receiver);
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      const Histogram::Options& options = Histogram::Options {});
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      std::shared_ptr<Histogram> histogram);
+
+  BaseObject::TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class HistogramTransferData : public worker::TransferData {
+   public:
+    explicit HistogramTransferData(const HistogramBase* histogram)
+        : histogram_(histogram->histogram()) {}
+
+    explicit HistogramTransferData(std::shared_ptr<Histogram> histogram)
+        : histogram_(std::move(histogram)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(HistogramTransferData)
+    SET_SELF_SIZE(HistogramTransferData)
+
+   private:
+    std::shared_ptr<Histogram> histogram_;
+  };
+
+ private:
+  static v8::CFunction fast_record_;
+  static v8::CFunction fast_record_delta_;
+};
+
+class IntervalHistogram final : public HandleWrap, public HistogramImpl {
+ public:
+  enum class StartFlags {
+    NONE,
+    RESET
+  };
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<IntervalHistogram> Create(
+      Environment* env,
+      int32_t interval,
+      std::function<void(Histogram&)> on_interval,
+      const Histogram::Options& options);
+
+  IntervalHistogram(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      AsyncWrap::ProviderType type,
+      int32_t interval,
+      std::function<void(Histogram&)> on_interval,
+      const Histogram::Options& options = Histogram::Options {});
+
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastStart(v8::Local<v8::Value> unused,
+                        v8::Local<v8::Value> receiver,
+                        bool reset);
+  static void FastStop(v8::Local<v8::Value> unused,
+                       v8::Local<v8::Value> receiver);
+
+  BaseObject::TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(IntervalHistogram)
+  SET_SELF_SIZE(IntervalHistogram)
+
+ private:
+  static void TimerCB(uv_timer_t* handle);
+  void OnStart(StartFlags flags = StartFlags::RESET);
+  void OnStop();
+
+  bool enabled_ = false;
+  int32_t interval_ = 0;
+  std::function<void(Histogram&)> on_interval_;
+  uv_timer_t timer_;
+
+  static v8::CFunction fast_start_;
+  static v8::CFunction fast_stop_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HISTOGRAM_H_

package/dist/node/include/inspector/io_agent.h

@@ -0,0 +1,30 @@
+#ifndef SRC_INSPECTOR_IO_AGENT_H_
+#define SRC_INSPECTOR_IO_AGENT_H_
+
+#include <memory>
+#include "inspector/network_resource_manager.h"
+#include "node/inspector/protocol/IO.h"
+
+namespace node::inspector::protocol {
+
+class IoAgent : public IO::Backend {
+ public:
+  explicit IoAgent(
+      std::shared_ptr<NetworkResourceManager> network_resource_manager)
+      : network_resource_manager_(std::move(network_resource_manager)) {}
+  void Wire(UberDispatcher* dispatcher);
+  DispatchResponse read(const String& in_handle,
+                        std::optional<int> in_offset,
+                        std::optional<int> in_size,
+                        String* out_data,
+                        bool* out_eof) override;
+  DispatchResponse close(const String& in_handle) override;
+
+ private:
+  std::shared_ptr<IO::Frontend> frontend_;
+  std::unordered_map<std::string, int> offset_map_ =
+      {};  // Maps stream_id to offset
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+}  // namespace node::inspector::protocol
+#endif  // SRC_INSPECTOR_IO_AGENT_H_

package/dist/node/include/inspector/main_thread_interface.h

@@ -0,0 +1,116 @@
+#ifndef SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+#define SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "inspector_agent.h"
+#include "node_mutex.h"
+
+#include <atomic>
+#include <deque>
+#include <memory>
+#include <unordered_map>
+
+namespace v8_inspector {
+class StringBuffer;
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+namespace inspector {
+class MainThreadInterface;
+
+class Request {
+ public:
+  virtual void Call(MainThreadInterface*) = 0;
+  virtual ~Request() = default;
+};
+
+class Deletable {
+ public:
+  virtual ~Deletable() = default;
+};
+
+std::unique_ptr<v8_inspector::StringBuffer> Utf8ToStringView(
+    const std::string_view message);
+
+using MessageQueue = std::deque<std::unique_ptr<Request>>;
+
+class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
+ public:
+  explicit MainThreadHandle(MainThreadInterface* main_thread)
+                            : main_thread_(main_thread) {
+  }
+  ~MainThreadHandle() {
+    Mutex::ScopedLock scoped_lock(block_lock_);
+    CHECK_NULL(main_thread_);  // main_thread_ should have called Reset
+  }
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+  int newObjectId() {
+    return ++next_object_id_;
+  }
+  bool Post(std::unique_ptr<Request> request);
+  std::unique_ptr<InspectorSessionDelegate> MakeDelegateThreadSafe(
+      std::unique_ptr<InspectorSessionDelegate> delegate);
+  bool Expired();
+  void SetTargetSessionId(int target_session_id) {
+    target_session_id_ = target_session_id;
+  }
+  std::optional<int> GetTargetSessionId() { return target_session_id_; }
+
+ private:
+  void Reset();
+
+  MainThreadInterface* main_thread_;
+  Mutex block_lock_;
+  int next_session_id_ = 0;
+  std::atomic_int next_object_id_ = {1};
+  std::optional<int> target_session_id_ = std::nullopt;
+
+  friend class MainThreadInterface;
+};
+
+class MainThreadInterface :
+    public std::enable_shared_from_this<MainThreadInterface> {
+ public:
+  explicit MainThreadInterface(Agent* agent);
+  ~MainThreadInterface();
+
+  void DispatchMessages();
+  void Post(std::unique_ptr<Request> request);
+  bool WaitForFrontendEvent();
+  void StopWaitingForFrontendEvent();
+  std::shared_ptr<MainThreadHandle> GetHandle();
+  Agent* inspector_agent() {
+    return agent_;
+  }
+  void AddObject(int handle, std::unique_ptr<Deletable> object);
+  Deletable* GetObject(int id);
+  Deletable* GetObjectIfExists(int id);
+  void RemoveObject(int handle);
+
+ private:
+  MessageQueue requests_;
+  Mutex requests_lock_;   // requests_ live across threads
+  // This queue is to maintain the order of the messages for the cases
+  // when we reenter the DispatchMessages function.
+  MessageQueue dispatching_message_queue_;
+  bool dispatching_messages_ = false;
+  // This flag indicates an internal request to exit the loop in
+  // WaitForFrontendEvent(). It's set to true by calling
+  // StopWaitingForFrontendEvent().
+  bool stop_waiting_for_frontend_event_requested_ = false;
+  ConditionVariable incoming_message_cond_;
+  // Used from any thread
+  Agent* const agent_;
+  std::shared_ptr<MainThreadHandle> handle_;
+  std::unordered_map<int, std::unique_ptr<Deletable>> managed_objects_;
+};
+
+}  // namespace inspector
+}  // namespace node
+#endif  // SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_