@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/Public/CtorConfig.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_CTORCONFIG_H
+#define HERMES_PUBLIC_CTORCONFIG_H
+
+#include <utility>
+
+/// Defines a new class, called \p NAME representing a constructor config, and
+/// an associated builder class.
+///
+/// The fields of the class (along with their types and default values) are
+/// encoded in the \p FIELDS parameter, and any logic to be run whilst building
+/// the config can be passed as a code block in \p BUILD_BODY.
+///
+/// Example:
+///
+///   Suppose we wish to define a configuration class called Foo, with the
+///   following fields and default values:
+///
+///       int A = 0;
+///       int B = 42;
+///       std::string C = "hello";
+///
+///   Such that the value in A is at most the length of \c C.
+///
+///   We can do so with the following declaration:
+///
+///   "    #define FIELDS(F)                     \  "
+///   "      F(int, A)                           \  "
+///   "      F(int, B, 42)                       \  "
+///   "      F(std::string, C, "hello")             "
+///   "                                             "
+///   "    _HERMES_CTORCONFIG_STRUCT(Foo, FIELDS, { "
+///   "        A_ = std::min(A_, C_.length());      "
+///   "      });                                    "
+///
+///   N.B.
+///     - The definition of A does not mention any value -- meaning it is
+///       default initialised.
+///     - References to the fields in the validation logic have a trailling
+///       underscore.
+///
+#define _HERMES_CTORCONFIG_STRUCT(NAME, FIELDS, BUILD_BODY)             \
+  class NAME {                                                          \
+    FIELDS(_HERMES_CTORCONFIG_FIELD_DECL)                               \
+                                                                        \
+   public:                                                              \
+    class Builder;                                                      \
+    friend Builder;                                                     \
+    FIELDS(_HERMES_CTORCONFIG_GETTER)                                   \
+                                                                        \
+    /* returns a Builder that starts with the current config. */        \
+    inline Builder rebuild() const;                                     \
+                                                                        \
+   private:                                                             \
+    inline void doBuild(const Builder &builder);                        \
+  };                                                                    \
+                                                                        \
+  class NAME::Builder {                                                 \
+    NAME config_;                                                       \
+                                                                        \
+    FIELDS(_HERMES_CTORCONFIG_FIELD_EXPLICIT_BOOL_DECL)                 \
+                                                                        \
+   public:                                                              \
+    Builder() = default;                                                \
+                                                                        \
+    explicit Builder(const NAME &config) : config_(config) {}           \
+                                                                        \
+    inline const NAME build() {                                         \
+      config_.doBuild(*this);                                           \
+      return config_;                                                   \
+    }                                                                   \
+                                                                        \
+    /* The explicitly set fields of \p newconfig update                 \
+     * the corresponding fields of \p this. */                          \
+    inline Builder update(const NAME::Builder &newConfig);              \
+                                                                        \
+    FIELDS(_HERMES_CTORCONFIG_SETTER)                                   \
+    FIELDS(_HERMES_CTORCONFIG_FIELD_EXPLICIT_BOOL_ACCESSOR)             \
+  };                                                                    \
+                                                                        \
+  NAME::Builder NAME::rebuild() const {                                 \
+    return Builder(*this);                                              \
+  }                                                                     \
+                                                                        \
+  NAME::Builder NAME::Builder::update(const NAME::Builder &newConfig) { \
+    FIELDS(_HERMES_CTORCONFIG_UPDATE)                                   \
+    return *this;                                                       \
+  }                                                                     \
+                                                                        \
+  void NAME::doBuild(const NAME::Builder &builder) {                    \
+    (void)builder;                                                      \
+    BUILD_BODY                                                          \
+  }
+
+/// Helper Macros
+
+#define _HERMES_CTORCONFIG_FIELD_DECL(CX, TYPE, NAME, ...) \
+  TYPE NAME##_{__VA_ARGS__};
+
+/// This ignores the first and trailing arguments, and defines a member
+/// indicating whether field NAME was set explicitly.
+#define _HERMES_CTORCONFIG_FIELD_EXPLICIT_BOOL_DECL(CX, TYPE, NAME, ...) \
+  bool NAME##Explicit_{false};
+
+/// This defines an accessor for the "Explicit_" fields defined above.
+#define _HERMES_CTORCONFIG_FIELD_EXPLICIT_BOOL_ACCESSOR(CX, TYPE, NAME, ...) \
+  bool has##NAME() const {                                                   \
+    return NAME##Explicit_;                                                  \
+  }
+
+/// Placeholder token for fields whose defaults are not constexpr, to make the
+/// listings more readable.
+#define HERMES_NON_CONSTEXPR
+
+#define _HERMES_CTORCONFIG_GETTER(CX, TYPE, NAME, ...) \
+  inline TYPE get##NAME() const {                      \
+    return NAME##_;                                    \
+  }                                                    \
+  static CX TYPE getDefault##NAME() {                  \
+    /* Instead of parens around TYPE (non-standard) */ \
+    using TypeAsSingleToken = TYPE;                    \
+    return TypeAsSingleToken{__VA_ARGS__};             \
+  }
+
+#define _HERMES_CTORCONFIG_SETTER(CX, TYPE, NAME, ...)   \
+  inline auto with##NAME(TYPE NAME) -> decltype(*this) { \
+    config_.NAME##_ = std::move(NAME);                   \
+    NAME##Explicit_ = true;                              \
+    return *this;                                        \
+  }
+
+#define _HERMES_CTORCONFIG_BUILDER_GETTER(CX, TYPE, NAME, ...) \
+  TYPE get##NAME() const {                                     \
+    return config_.NAME##_;                                    \
+  }
+
+#define _HERMES_CTORCONFIG_UPDATE(CX, TYPE, NAME, ...) \
+  if (newConfig.has##NAME()) {                         \
+    with##NAME(newConfig.config_.get##NAME());         \
+  }
+
+#endif //  HERMES_PUBLIC_CTORCONFIG_H

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/Public/DebuggerTypes.h

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_DEBUGGERTYPES_H
+#define HERMES_PUBLIC_DEBUGGERTYPES_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#pragma GCC diagnostic push
+
+#ifdef HERMES_COMPILER_SUPPORTS_WSHORTEN_64_TO_32
+#pragma GCC diagnostic ignored "-Wshorten-64-to-32"
+#endif
+namespace hermes {
+namespace vm {
+class Debugger;
+}
+} // namespace hermes
+
+namespace facebook {
+namespace hermes {
+namespace debugger {
+
+class ProgramState;
+
+/// Strings in the Debugger are UTF-8 encoded. When converting from a JavaScript
+/// string, valid UTF-16 surrogate pairs are decoded. Surrogate halves are
+/// converted into the Unicode replacement character.
+using String = std::string;
+
+/// Debugging entities like breakpoints are identified by a unique ID. The
+/// Debugger will not re-use IDs even across different entity types. 0 is an
+/// invalid ID.
+using BreakpointID = uint64_t;
+// NOTE: Can't be kInvalidID due to a clash with MacTypes.h's define kInvalidID.
+constexpr uint64_t kInvalidBreakpoint = 0;
+
+/// Scripts when loaded are identified by a script ID.
+/// These are not reused within one invocation of the VM.
+using ScriptID = uint32_t;
+
+/// A SourceLocation is a small value-type representing a location in a source
+/// file.
+constexpr uint32_t kInvalidLocation = ~0u;
+struct SourceLocation {
+  /// Line in the source. 1 based.
+  uint32_t line = kInvalidLocation;
+
+  /// Column in the source. 1 based.
+  uint32_t column = kInvalidLocation;
+
+  /// Identifier of the source file.
+  ScriptID fileId = kInvalidLocation;
+
+  /// Name of the source file.
+  String fileName;
+};
+
+/// CallFrameInfo is a value type representing an entry in a call stack.
+struct CallFrameInfo {
+  /// Name of the function executing in this frame.
+  String functionName;
+
+  /// Source location of the program counter for this frame.
+  SourceLocation location;
+};
+
+/// StackTrace represents a list of call frames, either in the current execution
+/// or captured in an exception.
+struct StackTrace {
+  /// \return the number of call frames.
+  uint32_t callFrameCount() const {
+    return frames_.size();
+  }
+
+  /// \return call frame info at a given index. 0 represents the topmost
+  /// (current) frame on the call stack.
+  CallFrameInfo callFrameForIndex(uint32_t index) const {
+    return frames_.at(index);
+  }
+
+  StackTrace() {}
+
+ private:
+  explicit StackTrace(std::vector<CallFrameInfo> frames)
+      : frames_(std::move(frames)) {}
+  friend ProgramState;
+  friend ::hermes::vm::Debugger;
+  std::vector<CallFrameInfo> frames_;
+};
+
+/// ExceptionDetails is a value type describing an exception.
+struct ExceptionDetails {
+  /// Textual description of the exception.
+  String text;
+
+  /// Location where the exception was thrown.
+  SourceLocation location;
+
+  /// Get the stack trace associated with the exception.
+  const StackTrace &getStackTrace() const {
+    return stackTrace_;
+  }
+
+ private:
+  friend ::hermes::vm::Debugger;
+  StackTrace stackTrace_;
+};
+
+/// A list of possible reasons for a Pause.
+enum class PauseReason {
+  ScriptLoaded, /// A script file was loaded, and the debugger has requested
+                /// pausing after script load.
+  DebuggerStatement, /// A debugger; statement was hit.
+  Breakpoint, /// A breakpoint was hit.
+  StepFinish, /// A Step operation completed.
+  Exception, /// An Exception was thrown.
+  AsyncTriggerImplicit, /// The Pause is the result of
+                        /// triggerAsyncPause(Implicit).
+  AsyncTriggerExplicit, /// The Pause is the result of
+                        /// triggerAsyncPause(Explicit).
+  EvalComplete, /// An eval() function finished.
+};
+
+/// When stepping, the mode with which to step.
+enum class StepMode {
+  Into, /// Enter into any function calls.
+  Over, /// Skip over any function calls.
+  Out, /// Step until the current function exits.
+};
+
+/// When setting pause on throw, this specifies when to pause.
+enum class PauseOnThrowMode {
+  None, /// Never pause on exceptions.
+  Uncaught, /// Only pause on uncaught exceptions.
+  All, /// Pause any time an exception is thrown.
+};
+
+/// When requesting an async break, this specifies whether it was an implicit
+/// break from the inspector or a user-requested explicit break.
+enum class AsyncPauseKind {
+  /// Implicit pause to allow movement of jsi::Value types between threads.
+  /// The user will not be running commands and the inspector will immediately
+  /// request a Continue.
+  Implicit,
+
+  /// Explicit pause requested by the user.
+  /// Clears any stepping state and allows the user to run their own commands.
+  Explicit,
+};
+
+/// A type representing depth in a lexical scope chain.
+using ScopeDepth = uint32_t;
+
+/// Information about lexical entities (for now, just variable names).
+struct LexicalInfo {
+  /// \return the number of scopes.
+  ScopeDepth getScopesCount() const {
+    return variableCountsByScope_.size();
+  }
+
+  /// \return the number of variables in a given scope.
+  uint32_t getVariablesCountInScope(ScopeDepth depth) const {
+    return variableCountsByScope_.at(depth);
+  }
+
+ private:
+  friend ::hermes::vm::Debugger;
+  std::vector<uint32_t> variableCountsByScope_;
+};
+
+/// Information about a breakpoint.
+struct BreakpointInfo {
+  /// ID of the breakpoint.
+  /// kInvalidBreakpoint if the info is not valid.
+  BreakpointID id;
+
+  /// Whether the breakpoint is enabled.
+  bool enabled;
+
+  /// Whether the breakpoint has been resolved.
+  bool resolved;
+
+  /// The originally requested location of the breakpoint.
+  SourceLocation requestedLocation;
+
+  /// The resolved location of the breakpoint if resolved is true.
+  SourceLocation resolvedLocation;
+};
+
+} // namespace debugger
+} // namespace hermes
+} // namespace facebook
+
+#endif

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/Public/GCConfig.h

@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_GCCONFIG_H
+#define HERMES_PUBLIC_GCCONFIG_H
+
+#include "hermes/Public/CtorConfig.h"
+#include "hermes/Public/GCTripwireContext.h"
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace hermes {
+namespace vm {
+
+/// A type big enough to accomodate the entire allocated address space.
+/// Individual allocations are always 'uint32_t', but on a 64-bit machine we
+/// might want to accommodate a larger total heap (or not, in which case we keep
+/// it 32-bit).
+using gcheapsize_t = uint32_t;
+
+/// Represents a value before and after an event.
+/// NOTE: Not a std::pair because using the names are more readable than first
+/// and second.
+struct BeforeAndAfter {
+  uint64_t before;
+  uint64_t after;
+};
+
+struct GCAnalyticsEvent {
+  /// The same value as \p Name from GCConfig. Stored here for simplicity of
+  /// the API since this is passed in callbacks that might not be able to store
+  /// the name. For a given Runtime, this will be the same value every time.
+  std::string runtimeDescription;
+
+  /// The kind of GC this was. For a given Runtime, this will be the same value
+  /// every time.
+  std::string gcKind;
+
+  /// The type of collection that ran, typically differentiating a "young"
+  /// generation GC and an "old" generation GC. When other values say they're
+  /// "scoped to the collectionType", it means that for a generation GC
+  /// they're only reporting the numbers for that generation.
+  std::string collectionType;
+
+  /// The cause of this GC. Can be an arbitrary string describing the cause.
+  /// Typically "natural" is used to mean that the GC decided it was time, and
+  /// other causes mean it was forced by some other condition.
+  std::string cause;
+
+  /// The wall time a collection took from start to end.
+  std::chrono::milliseconds duration;
+
+  /// The CPU time a collection took from start to end. This time measure will
+  /// exclude time waiting on disk, mutexes, or time spent not scheduled to run.
+  std::chrono::milliseconds cpuDuration;
+
+  /// The number of bytes allocated in the heap before and after the collection.
+  /// measurement does not include fragmentation, and is the same as the sum of
+  /// all sizes in calls to \p GC::makeA into that generation (including any
+  /// rounding up the GC does).
+  /// The value is scoped to the \p collectionType.
+  BeforeAndAfter allocated;
+
+  /// The number of bytes in use by the heap before and after the collection.
+  /// This measurement can include fragmentation if the \p gcKind has that
+  /// concept.
+  /// The value is scoped to the \p collectionType.
+  BeforeAndAfter size;
+
+  /// The number of bytes external to the JS heap before and after the
+  /// collection.
+  /// The value is scoped to the \p collectionType.
+  BeforeAndAfter external;
+
+  /// The ratio of cells that survived the collection to all cells before
+  /// the collection. Note that this is in term of sizes of cells, not the
+  /// numbers of cells. Excludes any cells not in direct use by the JS program,
+  /// such as FillerCell or FreelistCell.
+  /// The value is scoped to the \p collectionType.
+  double survivalRatio;
+
+  /// A list of metadata tags to annotate this event with.
+  std::vector<std::string> tags;
+};
+
+/// Parameters to control a tripwire function called when the live set size
+/// surpasses a given threshold after collections.  Check documentation in
+/// README.md
+#define GC_TRIPWIRE_FIELDS(F)                                                  \
+  /* If the heap size is above this threshold after a collection, the tripwire \
+   * is triggered. */                                                          \
+  F(constexpr, gcheapsize_t, Limit, std::numeric_limits<gcheapsize_t>::max())  \
+                                                                               \
+  /* The callback to call when the tripwire is considered triggered. */        \
+  F(HERMES_NON_CONSTEXPR,                                                      \
+    std::function<void(GCTripwireContext &)>,                                  \
+    Callback,                                                                  \
+    nullptr)                                                                   \
+  /* GC_TRIPWIRE_FIELDS END */
+
+_HERMES_CTORCONFIG_STRUCT(GCTripwireConfig, GC_TRIPWIRE_FIELDS, {})
+
+#undef HEAP_TRIPWIRE_FIELDS
+
+#define GC_HANDLESAN_FIELDS(F)                                        \
+  /* The probability with which the GC should keep moving the heap */ \
+  /* to detect stale GC handles. */                                   \
+  F(constexpr, double, SanitizeRate, 0.0)                             \
+  /* Random seed to use for basis of decisions whether or not to */   \
+  /* sanitize. A negative value will mean a seed will be chosen at */ \
+  /* random. */                                                       \
+  F(constexpr, int64_t, RandomSeed, -1)                               \
+  /* GC_HANDLESAN_FIELDS END */
+
+_HERMES_CTORCONFIG_STRUCT(GCSanitizeConfig, GC_HANDLESAN_FIELDS, {})
+
+#undef GC_HANDLESAN_FIELDS
+
+/// How aggressively to return unused memory to the OS.
+enum ReleaseUnused {
+  kReleaseUnusedNone = 0, /// Don't try to release unused memory.
+  kReleaseUnusedOld, /// Only old gen, on full collections.
+  kReleaseUnusedYoungOnFull, /// Also young gen, but only on full collections.
+  kReleaseUnusedYoungAlways /// Also young gen, also on young gen collections.
+};
+
+enum class GCEventKind {
+  CollectionStart,
+  CollectionEnd,
+};
+
+/// Parameters for GC Initialisation.  Check documentation in README.md
+/// constexpr indicates that the default value is constexpr.
+#define GC_FIELDS(F)                                                     \
+  /* Minimum heap size hint. */                                          \
+  F(constexpr, gcheapsize_t, MinHeapSize, 0)                             \
+                                                                         \
+  /* Initial heap size hint. */                                          \
+  F(constexpr, gcheapsize_t, InitHeapSize, 32 << 20)                     \
+                                                                         \
+  /* Maximum heap size hint. */                                          \
+  F(constexpr, gcheapsize_t, MaxHeapSize, 3u << 30)                      \
+                                                                         \
+  /* Sizing heuristic: fraction of heap to be occupied by live data. */  \
+  F(constexpr, double, OccupancyTarget, 0.5)                             \
+                                                                         \
+  /* Number of consecutive full collections considered to be an OOM. */  \
+  F(constexpr,                                                           \
+    unsigned,                                                            \
+    EffectiveOOMThreshold,                                               \
+    std::numeric_limits<unsigned>::max())                                \
+                                                                         \
+  /* Sanitizer configuration for the GC. */                              \
+  F(constexpr, GCSanitizeConfig, SanitizeConfig)                         \
+                                                                         \
+  /* Whether to Keep track of GC Statistics. */                          \
+  F(constexpr, bool, ShouldRecordStats, false)                           \
+                                                                         \
+  /* How aggressively to return unused memory to the OS. */              \
+  F(constexpr, ReleaseUnused, ShouldReleaseUnused, kReleaseUnusedOld)    \
+                                                                         \
+  /* Name for this heap in logs. */                                      \
+  F(HERMES_NON_CONSTEXPR, std::string, Name, "")                         \
+                                                                         \
+  /* Configuration for the Heap Tripwire. */                             \
+  F(HERMES_NON_CONSTEXPR, GCTripwireConfig, TripwireConfig)              \
+                                                                         \
+  /* Whether to (initially) allocate from the young gen (true) or the */ \
+  /* old gen (false). */                                                 \
+  F(constexpr, bool, AllocInYoung, true)                                 \
+                                                                         \
+  /* Whether to fill the YG with invalid data after each collection. */  \
+  F(constexpr, bool, OverwriteDeadYGObjects, false)                      \
+                                                                         \
+  /* Whether to revert, if necessary, to young-gen allocation at TTI. */ \
+  F(constexpr, bool, RevertToYGAtTTI, false)                             \
+                                                                         \
+  /* Whether to use mprotect on GC metadata between GCs. */              \
+  F(constexpr, bool, ProtectMetadata, false)                             \
+                                                                         \
+  /* Callout for an analytics event. */                                  \
+  F(HERMES_NON_CONSTEXPR,                                                \
+    std::function<void(const GCAnalyticsEvent &)>,                       \
+    AnalyticsCallback,                                                   \
+    nullptr)                                                             \
+                                                                         \
+  /* Called at GC events (see GCEventKind enum for the list). The */     \
+  /* second argument contains human-readable details about the event. */ \
+  /* NOTE: The function MUST NOT invoke any methods on the Runtime. */   \
+  F(HERMES_NON_CONSTEXPR,                                                \
+    std::function<void(GCEventKind, const char *)>,                      \
+    Callback,                                                            \
+    nullptr)                                                             \
+  /* GC_FIELDS END */
+
+_HERMES_CTORCONFIG_STRUCT(GCConfig, GC_FIELDS, {
+  if (builder.hasMinHeapSize()) {
+    if (builder.hasInitHeapSize()) {
+      // If both are specified, normalize the initial size up to the minimum,
+      // if necessary.
+      InitHeapSize_ = std::max(MinHeapSize_, InitHeapSize_);
+    } else {
+      // If the minimum is set explicitly, but the initial heap size is not,
+      // use the minimum as the initial size.
+      InitHeapSize_ = MinHeapSize_;
+    }
+  }
+  assert(InitHeapSize_ >= MinHeapSize_);
+
+  // Make sure the max is at least the Init.
+  MaxHeapSize_ = std::max(InitHeapSize_, MaxHeapSize_);
+})
+
+#undef GC_FIELDS
+
+} // namespace vm
+} // namespace hermes
+
+#endif // HERMES_PUBLIC_GCCONFIG_H

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/Public/GCTripwireContext.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_GCTRIPWIRECONTEXT_H
+#define HERMES_PUBLIC_GCTRIPWIRECONTEXT_H
+
+#include <hermes/Public/HermesExport.h>
+
+#include <iosfwd>
+#include <string>
+#include <system_error>
+
+namespace hermes {
+namespace vm {
+
+/// Interface passed to the GC tripwire callback when it fires.
+class HERMES_EXPORT GCTripwireContext {
+ public:
+  virtual ~GCTripwireContext();
+
+  /// Captures the heap to a file.
+  /// \param path to save the heap capture.
+  /// \return Empty error code if the heap capture succeeded, else a real error
+  ///   code.
+  virtual std::error_code createSnapshotToFile(const std::string &path) = 0;
+
+  /// Captures the heap to a stream.
+  /// \param os stream to save the heap capture to.
+  /// \return Empty error code if the heap capture succeeded, else a real error
+  ///   code.
+  virtual std::error_code createSnapshot(
+      std::ostream &os,
+      bool captureNumericValue) = 0;
+};
+
+} // namespace vm
+} // namespace hermes
+
+#endif // HERMES_PUBLIC_GCTRIPWIRECONTEXT_H

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/Public/HermesExport.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_EXPORT
+#ifdef _MSC_VER
+#define HERMES_EXPORT __declspec(dllexport)
+#else // _MSC_VER
+#define HERMES_EXPORT __attribute__((visibility("default")))
+#endif // _MSC_VER
+#endif // !defined(HERMES_EXPORT)

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/Public/JSOutOfMemoryError.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_JSOUTOFMEMORYERROR_H
+#define HERMES_PUBLIC_JSOUTOFMEMORYERROR_H
+
+#include <hermes/Public/HermesExport.h>
+
+#include <stdexcept>
+#include <string>
+
+namespace hermes {
+namespace vm {
+
+/// A std::runtime_error class for out-of-memory.
+class HERMES_EXPORT JSOutOfMemoryError : public std::runtime_error {
+  friend class GCBase;
+  JSOutOfMemoryError(const std::string &what_arg)
+      : std::runtime_error(what_arg) {}
+  ~JSOutOfMemoryError() override;
+};
+
+} // namespace vm
+} // namespace hermes
+
+#endif // HERMES_PUBLIC_JSOUTOFMEMORYERROR_H