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

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

@@ -0,0 +1,36 @@
+#ifndef SRC_NODE_BOB_INL_H_
+#define SRC_NODE_BOB_INL_H_
+
+#include "node_bob.h"
+
+#include <functional>
+
+namespace node {
+namespace bob {
+
+template <typename T>
+int SourceImpl<T>::Pull(
+    Next<T> next,
+    int options,
+    T* data,
+    size_t count,
+    size_t max_count_hint) {
+
+  int status;
+  if (eos_) {
+    status = bob::Status::STATUS_EOS;
+    std::move(next)(status, nullptr, 0, [](size_t len) {});
+    return status;
+  }
+
+  status = DoPull(std::move(next), options, data, count, max_count_hint);
+
+  if (status == bob::Status::STATUS_EOS) eos_ = true;
+
+  return status;
+}
+
+}  // namespace bob
+}  // namespace node
+
+#endif  // SRC_NODE_BOB_INL_H_

package/dist/node/include/node_bob.h

@@ -0,0 +1,107 @@
+#ifndef SRC_NODE_BOB_H_
+#define SRC_NODE_BOB_H_
+
+#include <functional>
+
+namespace node {
+namespace bob {
+
+constexpr size_t kMaxCountHint = 16;
+
+// Negative status codes indicate error conditions.
+enum Status : int {
+  // Indicates that an attempt was made to pull after end.
+  STATUS_EOS = 0,
+
+  // Indicates that there is additional data available
+  // and the consumer may continue to pull.
+  STATUS_CONTINUE = 1,
+
+  // Indicates that there is no additional data available
+  // but the stream has not ended. The consumer should not
+  // continue to pull but may resume pulling later when
+  // data is available.
+  STATUS_BLOCK = 2,
+
+  // Indicates that there is no additional data available
+  // but the stream has not ended and the source will call
+  // next again later when data is available. STATUS_WAIT
+  // must not be used with the OPTIONS_SYNC option.
+  STATUS_WAIT = 3,
+};
+
+enum Options : int {
+  OPTIONS_NONE = 0,
+
+  // Indicates that the consumer is requesting the end
+  // of the stream.
+  OPTIONS_END = 1,
+
+  // Indicates that the consumer requires the source to
+  // invoke Next synchronously. If the source is
+  // unable to provide data immediately but the
+  // stream has not yet ended, it should call Next
+  // using STATUS_BLOCK. When not set, the source
+  // may call Next asynchronously.
+  OPTIONS_SYNC = 2
+};
+
+// There are Sources and there are Consumers.
+//
+// Consumers get data by calling Source::Pull,
+// optionally passing along a status and allocated
+// buffer space for the source to fill, and a Next
+// function the Source will call when data is
+// available.
+//
+// The source calls Next to deliver the data. It can
+// choose to either use the allocated buffer space
+// provided by the consumer or it can allocate its own
+// buffers and push those instead. If it allocates
+// its own, it can send a Done function that the
+// Sink will call when it is done consuming the data.
+using Done = std::function<void(size_t)>;
+template <typename T>
+using Next = std::function<void(int, const T*, size_t count, Done done)>;
+
+template <typename T>
+class Source {
+ public:
+  virtual ~Source() = default;
+  virtual int Pull(
+      Next<T> next,
+      int options,
+      T* data,
+      size_t count,
+      size_t max_count_hint = kMaxCountHint) = 0;
+};
+
+
+template <typename T>
+class SourceImpl : public Source<T> {
+ public:
+  int Pull(
+      Next<T> next,
+      int options,
+      T* data,
+      size_t count,
+      size_t max_count_hint = kMaxCountHint) override;
+
+  bool is_eos() const { return eos_; }
+
+ protected:
+  virtual int DoPull(
+      Next<T> next,
+      int options,
+      T* data,
+      size_t count,
+      size_t max_count_hint) = 0;
+
+ private:
+  bool eos_ = false;
+};
+
+}  // namespace bob
+}  // namespace node
+
+#endif  // SRC_NODE_BOB_H_

package/dist/node/include/node_buffer.h

@@ -0,0 +1,92 @@
+// 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_BUFFER_H_
+#define SRC_NODE_BUFFER_H_
+
+#include "node.h"
+#include "v8.h"
+
+namespace node {
+
+namespace Buffer {
+
+static const size_t kMaxLength = v8::Uint8Array::kMaxLength;
+
+typedef void (*FreeCallback)(char* data, void* hint);
+
+NODE_EXTERN bool HasInstance(v8::Local<v8::Value> val);
+NODE_EXTERN bool HasInstance(v8::Local<v8::Object> val);
+NODE_EXTERN char* Data(v8::Local<v8::Value> val);
+NODE_EXTERN char* Data(v8::Local<v8::Object> val);
+NODE_EXTERN size_t Length(v8::Local<v8::Value> val);
+NODE_EXTERN size_t Length(v8::Local<v8::Object> val);
+
+// public constructor - data is copied
+NODE_EXTERN v8::MaybeLocal<v8::Object> Copy(v8::Isolate* isolate,
+                                            const char* data,
+                                            size_t len);
+
+// public constructor
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, size_t length);
+
+// public constructor from string
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           v8::Local<v8::String> string,
+                                           enum encoding enc = UTF8);
+
+// public constructor - data is used, callback is passed data on object gc
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           char* data,
+                                           size_t length,
+                                           FreeCallback callback,
+                                           void* hint);
+
+// public constructor - data is used.
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           char* data,
+                                           size_t len);
+
+// Creates a Buffer instance over an existing ArrayBuffer.
+NODE_EXTERN v8::MaybeLocal<v8::Uint8Array> New(v8::Isolate* isolate,
+                                               v8::Local<v8::ArrayBuffer> ab,
+                                               size_t byte_offset,
+                                               size_t length);
+
+// This is verbose to be explicit with inline commenting
+static inline bool IsWithinBounds(size_t off, size_t len, size_t max) {
+  // Asking to seek too far into the buffer
+  // check to avoid wrapping in subsequent subtraction
+  if (off > max)
+    return false;
+
+  // Asking for more than is left over in the buffer
+  if (max - off < len)
+    return false;
+
+  // Otherwise we're in bounds
+  return true;
+}
+
+}  // namespace Buffer
+}  // namespace node
+
+#endif  // SRC_NODE_BUFFER_H_

package/dist/node/include/node_builtins.h

@@ -0,0 +1,220 @@
+#ifndef SRC_NODE_BUILTINS_H_
+#define SRC_NODE_BUILTINS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <list>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include "node_external_reference.h"
+#include "node_mutex.h"
+#include "node_threadsafe_cow.h"
+#include "node_union_bytes.h"
+#include "v8.h"
+
+// Forward declare test fixture for `friend` declaration.
+class PerProcessTest;
+
+namespace node {
+class SnapshotBuilder;
+class ExternalReferenceRegistry;
+class Realm;
+
+namespace builtins {
+
+class BuiltinCodeCacheData {
+ public:
+  BuiltinCodeCacheData() : data(nullptr), length(0), owning_ptr(nullptr) {}
+
+  explicit BuiltinCodeCacheData(
+      std::shared_ptr<v8::ScriptCompiler::CachedData> cached_data)
+      : data(cached_data->data),
+        length(cached_data->length),
+        owning_ptr(cached_data) {}
+
+  explicit BuiltinCodeCacheData(
+      std::shared_ptr<std::vector<uint8_t>> cached_data)
+      : data(cached_data->data()),
+        length(cached_data->size()),
+        owning_ptr(cached_data) {}
+
+  BuiltinCodeCacheData(const uint8_t* data, size_t length)
+      : data(data), length(length), owning_ptr(nullptr) {}
+
+  const uint8_t* data;
+  size_t length;
+
+  // Returns a v8::ScriptCompiler::CachedData corresponding to this
+  // BuiltinCodeCacheData. The lifetime of the returned
+  // v8::ScriptCompiler::CachedData must not outlive that of the data.
+  std::unique_ptr<v8::ScriptCompiler::CachedData> AsCachedData() {
+    return std::make_unique<v8::ScriptCompiler::CachedData>(
+        data, length, v8::ScriptCompiler::CachedData::BufferNotOwned);
+  }
+
+ private:
+  // If not null, represents a pointer which owns data. Otherwise indicates
+  // that data has static lifetime.
+  std::shared_ptr<void> owning_ptr;
+};
+
+struct CodeCacheInfo {
+  std::string id;
+  BuiltinCodeCacheData data;
+};
+
+using BuiltinSourceMap = std::map<std::string, UnionBytes>;
+using BuiltinCodeCacheMap =
+    std::unordered_map<std::string, BuiltinCodeCacheData>;
+
+// Generated by tools/js2c.cc as node_javascript.cc
+void RegisterExternalReferencesForInternalizedBuiltinCode(
+    ExternalReferenceRegistry* registry);
+
+// Handles compilation and caching of built-in JavaScript modules and
+// bootstrap scripts, whose source are bundled into the binary as static data.
+class NODE_EXTERN_PRIVATE BuiltinLoader {
+ public:
+  BuiltinLoader();
+  BuiltinLoader(const BuiltinLoader&) = delete;
+  BuiltinLoader& operator=(const BuiltinLoader&) = delete;
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+
+  // The parameters used to compile the scripts are detected based on
+  // the pattern of the id.
+  v8::MaybeLocal<v8::Function> LookupAndCompile(v8::Local<v8::Context> context,
+                                                const char* id,
+                                                Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Function> LookupAndCompile(
+      v8::Local<v8::Context> context,
+      const char* id,
+      v8::LocalVector<v8::String>* parameters,
+      Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Value> CompileAndCall(v8::Local<v8::Context> context,
+                                           const char* id,
+                                           int argc,
+                                           v8::Local<v8::Value> argv[],
+                                           Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Value> CompileAndCall(v8::Local<v8::Context> context,
+                                           const char* id,
+                                           Realm* realm);
+
+  // Returns config.gypi as a JSON string
+  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
+  bool Exists(const char* id);
+  bool Add(const char* id, const UnionBytes& source);
+
+  bool CompileAllBuiltinsAndCopyCodeCache(
+      v8::Local<v8::Context> context,
+      const std::vector<std::string>& lazy_builtins,
+      std::vector<CodeCacheInfo>* out);
+  void RefreshCodeCache(const std::vector<CodeCacheInfo>& in);
+
+  void CopySourceAndCodeCacheReferenceFrom(const BuiltinLoader* other);
+
+  std::vector<std::string_view> GetBuiltinIds() const;
+
+  void SetEagerCompile() { should_eager_compile_ = true; }
+
+ private:
+  // Only allow access from friends.
+  friend class CodeCacheBuilder;
+
+  // Generated by tools/js2c.cc as node_javascript.cc
+  void LoadJavaScriptSource();  // Loads data into source_
+  UnionBytes GetConfig();       // Return data for config.gypi
+
+  struct BuiltinCategories {
+    std::set<std::string> can_be_required;
+    std::set<std::string> cannot_be_required;
+  };
+  // This method builds `BuiltinCategories` from scratch every time,
+  // and is therefore somewhat expensive, but also currently only being
+  // used for testing, so that should not be an issue.
+  BuiltinCategories GetBuiltinCategories() const;
+
+  const v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
+  enum class Result { kWithCache, kWithoutCache };
+  v8::MaybeLocal<v8::String> LoadBuiltinSource(v8::Isolate* isolate,
+                                               const char* id) const;
+  // If an exception is encountered (e.g. source code contains
+  // syntax error), the returned value is empty.
+  v8::MaybeLocal<v8::Function> LookupAndCompileInternal(
+      v8::Local<v8::Context> context,
+      const char* id,
+      v8::LocalVector<v8::String>* parameters,
+      Realm* optional_realm);
+  void SaveCodeCache(const char* id, v8::Local<v8::Function> fn);
+
+  static void RecordResult(const char* id,
+                           BuiltinLoader::Result result,
+                           Realm* realm);
+  static void GetBuiltinCategories(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Passing ids of built-in source code into JS land as
+  // internalBinding('builtins').builtinIds
+  static void BuiltinIdsGetter(v8::Local<v8::Name> property,
+                               const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Passing config.gypi into JS land as internalBinding('builtins').config
+  static void ConfigStringGetter(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Compile a specific built-in as a function
+  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasCachedBuiltins(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  // For legacy process.binding('natives')
+  static void GetNatives(v8::Local<v8::Name> property,
+                         const v8::PropertyCallbackInfo<v8::Value>& info);
+
+  void AddExternalizedBuiltin(const char* id, const char* filename);
+
+  ThreadsafeCopyOnWrite<BuiltinSourceMap> source_;
+
+  const UnionBytes config_;
+
+  // If any bulitins should be eagerly compiled i.e. with inner functions
+  // compiled too, either use should_eager_compile_ to compile all builtins
+  // eagerly, or use to_eager_compile_ to compile specific builtins eagerly.
+  // Currently we set should_eager_compile_ to true when compiling primordials,
+  // and use to_eager_compile_ to compile code cache that complements the
+  // snapshot, where builtins already loaded in the snapshot and a few extras
+  // are compiled eagerly (other less-essential built-ins are compiled lazily to
+  // avoid bloating the binary size). At runtime any additional compilation is
+  // done lazily.
+  bool should_eager_compile_ = false;
+  std::unordered_set<std::string> to_eager_compile_;
+
+  struct BuiltinCodeCache {
+    RwLock mutex;
+    BuiltinCodeCacheMap map;
+    bool has_code_cache = false;
+  };
+  std::shared_ptr<BuiltinCodeCache> code_cache_;
+
+  friend class ::PerProcessTest;
+};
+
+}  // namespace builtins
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_BUILTINS_H_

package/dist/node/include/node_config_file.h

@@ -0,0 +1,46 @@
+#ifndef SRC_NODE_CONFIG_FILE_H_
+#define SRC_NODE_CONFIG_FILE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <map>
+#include <string>
+#include <variant>
+#include "node_internals.h"
+#include "simdjson.h"
+#include "util-inl.h"
+
+namespace node {
+
+// When trying to parse the configuration file, we can have three possible
+// results:
+//  - Valid: The file was successfully parsed and the content is valid.
+//  - FileError: There was an error reading the file.
+//  - InvalidContent: The file was read, but the content is invalid.
+enum ParseResult { Valid, FileError, InvalidContent };
+
+// ConfigReader is the class that parses the configuration JSON file.
+// It reads the file provided by --experimental-config-file and
+// extracts the flags.
+class ConfigReader {
+ public:
+  ParseResult ParseConfig(const std::string_view& config_path);
+
+  std::optional<std::string_view> GetDataFromArgs(
+      const std::vector<std::string>& args);
+
+  std::string AssignNodeOptions();
+
+  size_t GetFlagsSize();
+
+ private:
+  ParseResult ParseNodeOptions(simdjson::ondemand::object* node_options_object);
+
+  std::vector<std::string> node_options_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONFIG_FILE_H_

package/dist/node/include/node_constants.h

@@ -0,0 +1,82 @@
+// 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_CONSTANTS_H_
+#define SRC_NODE_CONSTANTS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+#include "v8.h"
+
+#define EXTENSIONLESS_FORMAT_JAVASCRIPT (0)
+#define EXTENSIONLESS_FORMAT_WASM (1)
+
+#if HAVE_OPENSSL
+
+#ifndef RSA_PSS_SALTLEN_DIGEST
+#define RSA_PSS_SALTLEN_DIGEST -1
+#endif
+
+#ifndef RSA_PSS_SALTLEN_MAX_SIGN
+#define RSA_PSS_SALTLEN_MAX_SIGN -2
+#endif
+
+#ifndef RSA_PSS_SALTLEN_AUTO
+#define RSA_PSS_SALTLEN_AUTO -2
+#endif
+
+#if defined(NODE_OPENSSL_DEFAULT_CIPHER_LIST)
+#define DEFAULT_CIPHER_LIST_CORE NODE_OPENSSL_DEFAULT_CIPHER_LIST
+#else
+// TLSv1.3 suites start with TLS_, and are the OpenSSL defaults, see:
+//   https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_ciphersuites.html
+#define DEFAULT_CIPHER_LIST_CORE \
+                                 "TLS_AES_256_GCM_SHA384:"          \
+                                 "TLS_CHACHA20_POLY1305_SHA256:"    \
+                                 "TLS_AES_128_GCM_SHA256:"          \
+                                 "ECDHE-RSA-AES128-GCM-SHA256:"     \
+                                 "ECDHE-ECDSA-AES128-GCM-SHA256:"   \
+                                 "ECDHE-RSA-AES256-GCM-SHA384:"     \
+                                 "ECDHE-ECDSA-AES256-GCM-SHA384:"   \
+                                 "DHE-RSA-AES128-GCM-SHA256:"       \
+                                 "ECDHE-RSA-AES128-SHA256:"         \
+                                 "DHE-RSA-AES128-SHA256:"           \
+                                 "ECDHE-RSA-AES256-SHA384:"         \
+                                 "DHE-RSA-AES256-SHA384:"           \
+                                 "ECDHE-RSA-AES256-SHA256:"         \
+                                 "DHE-RSA-AES256-SHA256:"           \
+                                 "HIGH:"                            \
+                                 "!aNULL:"                          \
+                                 "!eNULL:"                          \
+                                 "!EXPORT:"                         \
+                                 "!DES:"                            \
+                                 "!RC4:"                            \
+                                 "!MD5:"                            \
+                                 "!PSK:"                            \
+                                 "!SRP:"                            \
+                                 "!CAMELLIA"
+#endif  // NODE_OPENSSL_DEFAULT_CIPHER_LIST
+#endif  // HAVE_OPENSSL
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONSTANTS_H_