@encharm/cws 4.5.1 → 4.5.2

package/src/headers/24/node_url.h

@@ -0,0 +1,101 @@
+#ifndef SRC_NODE_URL_H_
+#define SRC_NODE_URL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "ada.h"
+#include "aliased_buffer.h"
+#include "node.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <optional>
+#include <string>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace url {
+
+enum url_update_action {
+  kProtocol = 0,
+  kHost = 1,
+  kHostname = 2,
+  kPort = 3,
+  kUsername = 4,
+  kPassword = 5,
+  kPathname = 6,
+  kSearch = 7,
+  kHash = 8,
+  kHref = 9,
+};
+
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* realm, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(url_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void DomainToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DomainToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CanParse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool FastCanParse(v8::Local<v8::Value> receiver,
+                           v8::Local<v8::Value> input,
+                           // NOLINTNEXTLINE(runtime/references) This is V8 api.
+                           v8::FastApiCallbackOptions& options);
+  static bool FastCanParseWithBase(
+      v8::Local<v8::Value> receiver,
+      v8::Local<v8::Value> input,
+      v8::Local<v8::Value> base,
+      // NOLINTNEXTLINE(runtime/references) This is V8 api.
+      v8::FastApiCallbackOptions& options);
+
+  static void Format(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetOrigin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void PathToFileURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kURLComponentsLength = 9;
+  AliasedUint32Array url_components_buffer_;
+
+  void UpdateComponents(const ada::url_components& components,
+                        const ada::scheme::type type);
+
+  static v8::CFunction fast_can_parse_methods_[];
+};
+
+void ThrowInvalidURL(Environment* env,
+                     std::string_view input,
+                     std::optional<std::string> base);
+std::string FromFilePath(std::string_view file_path);
+std::optional<std::string> FileURLToPath(Environment* env,
+                                         const ada::url_aggregator& file_url);
+
+}  // namespace url
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_URL_H_

package/src/headers/24/node_url_pattern.h

@@ -0,0 +1,118 @@
+#ifndef SRC_NODE_URL_PATTERN_H_
+#define SRC_NODE_URL_PATTERN_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "ada.h"
+#include "base_object.h"
+#include "util.h"
+
+#include <v8.h>
+
+#include <optional>
+#include <string_view>
+
+namespace node::url_pattern {
+
+#define URL_PATTERN_COMPONENTS(V)                                              \
+  V(Protocol, protocol)                                                        \
+  V(Username, username)                                                        \
+  V(Password, password)                                                        \
+  V(Hostname, hostname)                                                        \
+  V(Port, port)                                                                \
+  V(Pathname, pathname)                                                        \
+  V(Search, search)                                                            \
+  V(Hash, hash)
+
+// By default, ada::url_pattern doesn't ship with any regex library.
+// Ada has a std::regex implementation, but it is considered unsafe and does
+// not have a fully compliant ecmascript syntax support. Therefore, Ada
+// supports passing custom regex provider that conforms to the following
+// class and function structure. For more information, please look into
+// url_pattern_regex.h inside github.com/ada-url/ada.
+class URLPatternRegexProvider {
+ public:
+  using regex_type = v8::Global<v8::RegExp>;
+  static std::optional<regex_type> create_instance(std::string_view pattern,
+                                                   bool ignore_case);
+  static std::optional<std::vector<std::optional<std::string>>> regex_search(
+      std::string_view input, const regex_type& pattern);
+  static bool regex_match(std::string_view input, const regex_type& pattern);
+};
+
+class URLPattern : public BaseObject {
+ public:
+  URLPattern(Environment* env,
+             v8::Local<v8::Object> object,
+             ada::url_pattern<URLPatternRegexProvider>&& url_pattern);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // V8 APIs
+  // - Functions
+  static void Exec(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Test(const v8::FunctionCallbackInfo<v8::Value>& info);
+  // - Component Getters
+#define URL_PATTERN_COMPONENT_GETTERS(name, _)                                 \
+  static void name(const v8::FunctionCallbackInfo<v8::Value>& info);
+  URL_PATTERN_COMPONENTS(URL_PATTERN_COMPONENT_GETTERS)
+#undef URL_PATTERN_COMPONENT_GETTERS
+  // - Has Regexp Groups
+  static void HasRegexpGroups(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(URLPattern)
+  SET_SELF_SIZE(URLPattern)
+
+  class URLPatternInit {
+   public:
+    static std::optional<ada::url_pattern_init> FromJsObject(
+        Environment* env, v8::Local<v8::Object> obj);
+    static v8::MaybeLocal<v8::Value> ToJsObject(
+        Environment* env, const ada::url_pattern_init& init);
+  };
+
+  class URLPatternOptions {
+   public:
+    static std::optional<ada::url_pattern_options> FromJsObject(
+        Environment* env, v8::Local<v8::Object> obj);
+  };
+
+  class URLPatternResult {
+   public:
+    static v8::MaybeLocal<v8::Value> ToJSValue(
+        Environment* env, const ada::url_pattern_result& result);
+  };
+
+  class URLPatternComponentResult {
+   public:
+    static v8::MaybeLocal<v8::Object> ToJSObject(
+        Environment* env, const ada::url_pattern_component_result& result);
+  };
+
+ private:
+  ada::url_pattern<URLPatternRegexProvider> url_pattern_;
+  // Getter methods
+#define URL_PATTERN_COMPONENT_GETTERS(name, _) v8::MaybeLocal<v8::Value> name();
+  URL_PATTERN_COMPONENTS(URL_PATTERN_COMPONENT_GETTERS)
+#undef URL_PATTERN_COMPONENT_GETTERS
+  bool HasRegExpGroups() const;
+  // Public API
+  v8::MaybeLocal<v8::Value> Exec(
+      Environment* env,
+      const ada::url_pattern_input& input,
+      std::optional<std::string_view>& baseURL);  // NOLINT (runtime/references)
+  bool Test(
+      Environment* env,
+      const ada::url_pattern_input& input,
+      std::optional<std::string_view>& baseURL);  // NOLINT (runtime/references)
+
+#define URL_PATTERN_CACHED_VALUES(_, name) v8::Global<v8::Value> name;
+  URL_PATTERN_COMPONENTS(URL_PATTERN_CACHED_VALUES)
+#undef URL_PATTERN_CACHED_VALUES
+};
+
+}  // namespace node::url_pattern
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_URL_PATTERN_H_

package/src/headers/24/node_v8.h

@@ -0,0 +1,77 @@
+#ifndef SRC_NODE_V8_H_
+#define SRC_NODE_V8_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <sstream>
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "json_utils.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+struct InternalFieldInfoBase;
+
+namespace v8_utils {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex heap_statistics_buffer;
+    AliasedBufferIndex heap_space_statistics_buffer;
+    AliasedBufferIndex heap_code_statistics_buffer;
+  };
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(v8_binding_data)
+
+  AliasedFloat64Array heap_statistics_buffer;
+  AliasedFloat64Array heap_space_statistics_buffer;
+  AliasedFloat64Array heap_code_statistics_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+class GCProfiler : public BaseObject {
+ public:
+  enum class GCProfilerState { kInitialized, kStarted, kStopped };
+  GCProfiler(Environment* env, v8::Local<v8::Object> object);
+  inline ~GCProfiler() override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  JSONWriter* writer();
+
+  std::ostringstream* out_stream();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(GCProfiler)
+  SET_SELF_SIZE(GCProfiler)
+
+  uint64_t start_time;
+  uint8_t current_gc_type;
+  GCProfilerState state;
+
+ private:
+  std::ostringstream out_stream_;
+  JSONWriter writer_;
+};
+
+}  // namespace v8_utils
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_H_

package/src/headers/24/node_v8_platform-inl.h

@@ -0,0 +1,185 @@
+#ifndef SRC_NODE_V8_PLATFORM_INL_H_
+#define SRC_NODE_V8_PLATFORM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <memory>
+#include <string_view>
+
+#include "env-inl.h"
+#include "node.h"
+#include "node_metadata.h"
+#include "node_platform.h"
+#include "node_options.h"
+#include "tracing/node_trace_writer.h"
+#include "tracing/trace_event.h"
+#include "tracing/traced_value.h"
+#include "util.h"
+
+namespace node {
+
+// Ensures that __metadata trace events are only emitted
+// when tracing is enabled.
+class NodeTraceStateObserver
+    : public v8::TracingController::TraceStateObserver {
+ public:
+  inline void OnTraceEnabled() override {
+    std::string title = GetProcessTitle("");
+    if (!title.empty()) {
+      // Only emit the metadata event if the title can be retrieved
+      // successfully. Ignore it otherwise.
+      TRACE_EVENT_METADATA1(
+          "__metadata", "process_name", "name", TRACE_STR_COPY(title.c_str()));
+    }
+    TRACE_EVENT_METADATA1("__metadata",
+                          "version",
+                          "node",
+                          per_process::metadata.versions.node.c_str());
+    TRACE_EVENT_METADATA1(
+        "__metadata", "thread_name", "name", "JavaScriptMainThread");
+
+    tracing::ProcessMeta trace_process;
+    TRACE_EVENT_METADATA1("__metadata",
+                          "node",
+                          "process",
+                          tracing::CastTracedValue(trace_process));
+    // This only runs the first time tracing is enabled
+    controller_->RemoveTraceStateObserver(this);
+  }
+
+  inline void OnTraceDisabled() override {
+    // Do nothing here. This should never be called because the
+    // observer removes itself when OnTraceEnabled() is called.
+    UNREACHABLE();
+  }
+
+  explicit NodeTraceStateObserver(v8::TracingController* controller)
+      : controller_(controller) {}
+  ~NodeTraceStateObserver() override = default;
+
+ private:
+  v8::TracingController* controller_;
+};
+
+struct V8Platform {
+  bool initialized_ = false;
+
+#if NODE_USE_V8_PLATFORM
+  inline void Initialize(int thread_pool_size) {
+    CHECK(!initialized_);
+    initialized_ = true;
+    tracing_agent_ = std::make_unique<tracing::Agent>();
+    node::tracing::TraceEventHelper::SetAgent(tracing_agent_.get());
+    node::tracing::TracingController* controller =
+        tracing_agent_->GetTracingController();
+    trace_state_observer_ =
+        std::make_unique<NodeTraceStateObserver>(controller);
+    controller->AddTraceStateObserver(trace_state_observer_.get());
+    tracing_file_writer_ = tracing_agent_->DefaultHandle();
+    // Only start the tracing agent if we enabled any tracing categories.
+    if (!per_process::cli_options->trace_event_categories.empty()) {
+      StartTracingAgent();
+    }
+    // Tracing must be initialized before platform threads are created.
+    platform_ = new NodePlatform(thread_pool_size, controller);
+    v8::V8::InitializePlatform(platform_);
+  }
+  // Make sure V8Platform don not call into Libuv threadpool,
+  // see DefaultProcessExitHandlerInternal in environment.cc
+  inline void Dispose() {
+    if (!initialized_)
+      return;
+    initialized_ = false;
+    node::tracing::TraceEventHelper::SetAgent(nullptr);
+    StopTracingAgent();
+    platform_->Shutdown();
+    delete platform_;
+    platform_ = nullptr;
+    // Destroy tracing after the platform (and platform threads) have been
+    // stopped.
+    tracing_agent_.reset(nullptr);
+    // The observer remove itself in OnTraceEnabled
+    trace_state_observer_.reset(nullptr);
+  }
+
+  inline void DrainVMTasks(v8::Isolate* isolate) {
+    platform_->DrainTasks(isolate);
+  }
+
+  inline void StartTracingAgent() {
+    constexpr auto convert_to_set =
+        [](auto& categories) -> std::set<std::string> {
+      std::set<std::string> out;
+      for (const auto& s : categories) {
+        out.emplace(std::string(s.data(), s.size()));
+      }
+      return out;
+    };
+    // Attach a new NodeTraceWriter only if this function hasn't been called
+    // before.
+    if (tracing_file_writer_.IsDefaultHandle()) {
+      using std::operator""sv;
+      auto categories = std::views::split(
+          per_process::cli_options->trace_event_categories, ","sv);
+
+      tracing_file_writer_ = tracing_agent_->AddClient(
+          convert_to_set(categories),
+          std::unique_ptr<tracing::AsyncTraceWriter>(
+              new tracing::NodeTraceWriter(
+                  per_process::cli_options->trace_event_file_pattern)),
+          tracing::Agent::kUseDefaultCategories);
+    }
+  }
+
+  inline void StopTracingAgent() { tracing_file_writer_.reset(); }
+
+  inline tracing::AgentWriterHandle* GetTracingAgentWriter() {
+    return &tracing_file_writer_;
+  }
+
+  inline NodePlatform* Platform() { return platform_; }
+
+  std::unique_ptr<NodeTraceStateObserver> trace_state_observer_;
+  std::unique_ptr<tracing::Agent> tracing_agent_;
+  tracing::AgentWriterHandle tracing_file_writer_;
+  NodePlatform* platform_;
+#else   // !NODE_USE_V8_PLATFORM
+  inline void Initialize(int thread_pool_size) {}
+  inline void Dispose() {}
+  inline void DrainVMTasks(v8::Isolate* isolate) {}
+  inline void StartTracingAgent() {
+    if (!per_process::cli_options->trace_event_categories.empty()) {
+      fprintf(stderr,
+              "Node compiled with NODE_USE_V8_PLATFORM=0, "
+              "so event tracing is not available.\n");
+    }
+  }
+  inline void StopTracingAgent() {}
+
+  inline tracing::AgentWriterHandle* GetTracingAgentWriter() { return nullptr; }
+
+  inline NodePlatform* Platform() { return nullptr; }
+#endif  // !NODE_USE_V8_PLATFORM
+};
+
+namespace per_process {
+extern struct V8Platform v8_platform;
+}
+
+inline void StartTracingAgent() {
+  return per_process::v8_platform.StartTracingAgent();
+}
+
+inline tracing::AgentWriterHandle* GetTracingAgentWriter() {
+  return per_process::v8_platform.GetTracingAgentWriter();
+}
+
+inline void DisposePlatform() {
+  per_process::v8_platform.Dispose();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_PLATFORM_INL_H_

package/src/headers/24/node_version.h

@@ -0,0 +1,110 @@
+// 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_NODE_VERSION_H_
+#define SRC_NODE_VERSION_H_
+
+#define NODE_MAJOR_VERSION 24
+#define NODE_MINOR_VERSION 7
+#define NODE_PATCH_VERSION 0
+
+#define NODE_VERSION_IS_LTS 0
+#define NODE_VERSION_LTS_CODENAME ""
+
+#define NODE_VERSION_IS_RELEASE 1
+
+#ifndef NODE_STRINGIFY
+#define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
+#define NODE_STRINGIFY_HELPER(n) #n
+#endif
+
+#ifndef NODE_RELEASE
+#define NODE_RELEASE "node"
+#endif
+
+#ifndef NODE_TAG
+# if NODE_VERSION_IS_RELEASE
+#  define NODE_TAG ""
+# else
+#  define NODE_TAG "-pre"
+# endif
+#else
+// NODE_TAG is passed without quotes when rc.exe is run from msbuild
+# define NODE_EXE_VERSION NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                          NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                          NODE_STRINGIFY(NODE_PATCH_VERSION)     \
+                          NODE_STRINGIFY(NODE_TAG)
+#endif
+
+# define NODE_VERSION_STRING  NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_PATCH_VERSION)     \
+                              NODE_TAG
+#ifndef NODE_EXE_VERSION
+# define NODE_EXE_VERSION NODE_VERSION_STRING
+#endif
+
+#define NODE_VERSION "v" NODE_VERSION_STRING
+
+
+#define NODE_VERSION_AT_LEAST(major, minor, patch) \
+  (( (major) < NODE_MAJOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && (minor) < NODE_MINOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && \
+      (minor) == NODE_MINOR_VERSION && (patch) <= NODE_PATCH_VERSION))
+
+/**
+ * Node.js will refuse to load modules that weren't compiled against its own
+ * module ABI number, exposed as the process.versions.modules property.
+ *
+ * Node.js will refuse to load modules with a non-matching ABI version. The
+ * version number here should be changed whenever an ABI-incompatible API change
+ * is made in the C++ side, including in V8 or other dependencies.
+ *
+ * Node.js will not change the module version during a Major release line
+ * We will, at times update the version of V8 shipped in the release line
+ * if it can be made ABI compatible with the previous version.
+ *
+ * Embedders building Node.js can define NODE_EMBEDDER_MODULE_VERSION to
+ * override the default value of NODE_MODULE_VERSION.
+ *
+ * The registry of used NODE_MODULE_VERSION numbers is located at
+ *   https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json
+ * Extenders, embedders and other consumers of Node.js that require ABI
+ * version matching should open a pull request to reserve a number in this
+ * registry.
+ */
+#if defined(NODE_EMBEDDER_MODULE_VERSION)
+#define NODE_MODULE_VERSION NODE_EMBEDDER_MODULE_VERSION
+#else
+#define NODE_MODULE_VERSION 137
+#endif
+
+// The NAPI_VERSION supported by the runtime. This is the inclusive range of
+// versions which the Node.js binary being built supports.
+#define NODE_API_SUPPORTED_VERSION_MAX 10
+#define NODE_API_SUPPORTED_VERSION_MIN 1
+
+// Node API modules use NAPI_VERSION 8 by default if it is not explicitly
+// specified. It must be always 8.
+#define NODE_API_DEFAULT_MODULE_API_VERSION 8
+
+#endif  // SRC_NODE_VERSION_H_