react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

package/common/cpp/audioapi/dsp/VectorMath.cpp

@@ -25,6 +25,7 @@
 
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <algorithm>
 
 #if defined(HAVE_ACCELERATE)
 #include <Accelerate/Accelerate.h>
@@ -47,8 +48,7 @@ void multiplyByScalar(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsmul(
-      inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
+  vDSP_vsmul(inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
 }
 
 void addScalar(
@@ -56,8 +56,7 @@ void addScalar(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsadd(
-      inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
+  vDSP_vsadd(inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
 }
 
 void add(
@@ -65,14 +64,7 @@ void add(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vadd(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vadd(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 void subtract(
@@ -80,14 +72,7 @@ void subtract(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsub(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vsub(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 void multiply(
@@ -95,19 +80,10 @@ void multiply(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vmul(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vmul(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess) {
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess) {
   float maximumValue = 0;
   vDSP_maxmgv(inputVector, 1, &maximumValue, numberOfElementsToProcess);
   return maximumValue;
@@ -118,15 +94,7 @@ void multiplyByScalarThenAddToOutput(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsma(
-      inputVector,
-      1,
-      &scalar,
-      outputVector,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vsma(inputVector, 1, &scalar, outputVector, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 #else
@@ -552,9 +520,7 @@ void multiply(
   }
 }
 
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess) {
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess) {
   size_t n = numberOfElementsToProcess;
   float max = 0;
 

package/common/cpp/audioapi/dsp/VectorMath.h

@@ -28,23 +28,50 @@
 // Defines the interface for several vector math functions whose implementation
 // will ideally be optimized.
 
-#include <cstddef>
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 
 namespace audioapi::dsp {
 
-void multiplyByScalarThenAddToOutput(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
-void multiplyByScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
-void addScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
-void add(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
-void subtract(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
-void multiply(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
+void multiplyByScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void addScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void add(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void subtract(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void multiply(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
 // Finds the maximum magnitude of a float vector.
 float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess);
 
-void linearToDecibels(const float *inputVector, float *outputVector, size_t numberOfElementsToProcess);
+void linearToDecibels(
+    const float *inputVector,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
 } // namespace audioapi::dsp

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,12 +1,10 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/Windows.h>
+#include <algorithm>
 
 namespace audioapi::dsp {
 
-void WindowFunction::forcePerfectReconstruction(
-    float *data,
-    int windowLength,
-    int interval) {
+void WindowFunction::forcePerfectReconstruction(float *data, int windowLength, int interval) {
   for (int i = 0; i < interval; ++i) {
     float sum2 = 0;
 
@@ -58,14 +56,11 @@ float Kaiser::bandwidthToBeta(float bandwidth, bool heuristicOptimal) {
 }
 
 void ApproximateConfinedGaussian::apply(float *data, int size) const {
-  auto offsetScale =
-      getGaussian(1.0f) / (getGaussian(3.0f) + getGaussian(-1.0f));
+  auto offsetScale = getGaussian(1.0f) / (getGaussian(3.0f) + getGaussian(-1.0f));
   auto norm = 1 / (getGaussian(1.0f) - 2 * offsetScale * getGaussian(2.0f));
   for (int i = 0; i < size; ++i) {
     auto r = static_cast<float>(2 * i + 1) / static_cast<float>(size) - 1.0f;
-    data[i] = norm *
-        (getGaussian(r) -
-         offsetScale * (getGaussian(r - 2) + getGaussian(r + 2)));
+    data[i] = norm * (getGaussian(r) - offsetScale * (getGaussian(r - 2) + getGaussian(r + 2)));
   }
 }
 

package/common/cpp/audioapi/dsp/Windows.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cmath>
-#include <algorithm>
 
 namespace audioapi::dsp {
 
@@ -9,7 +8,7 @@ namespace audioapi::dsp {
 // https://personalpages.hs-kempten.de/~vollratj/InEl/pdf/Window%20function%20-%20Wikipedia.pdf
 class WindowFunction {
  public:
-  explicit WindowFunction(float amplitude = 1.0f): amplitude_(amplitude) {}
+  explicit WindowFunction(float amplitude = 1.0f) : amplitude_(amplitude) {}
 
   virtual void apply(float *data, int size) const = 0;
   // forces STFT perfect-reconstruction (WOLA) on an existing window, for a given STFT interval.
@@ -23,29 +22,30 @@ class WindowFunction {
 //https://en.wikipedia.org/wiki/Hann_function
 // https://www.sciencedirect.com/topics/engineering/hanning-window
 // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.hann.html#scipy.signal.windows.hann
-class Hann: public WindowFunction {
+class Hann : public WindowFunction {
  public:
-  explicit Hann(float amplitude = 1.0f): WindowFunction(amplitude) {}
+  explicit Hann(float amplitude = 1.0f) : WindowFunction(amplitude) {}
 
   void apply(float *data, int size) const override;
 };
 
 // https://www.sciencedirect.com/topics/engineering/blackman-window
 // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.blackman.html#scipy.signal.windows.blackman
-class Blackman: public WindowFunction {
+class Blackman : public WindowFunction {
  public:
-  explicit Blackman(float amplitude = 1.0f): WindowFunction(amplitude) {}
+  explicit Blackman(float amplitude = 1.0f) : WindowFunction(amplitude) {}
 
   void apply(float *data, int size) const override;
 };
 
-
 // https://en.wikipedia.org/wiki/Kaiser_window
-class Kaiser: public WindowFunction {
+class Kaiser : public WindowFunction {
  public:
-  explicit Kaiser(float beta, float amplitude = 1.0f): WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
+  explicit Kaiser(float beta, float amplitude = 1.0f)
+      : WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
 
-  static Kaiser withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
+  static Kaiser
+  withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
     return Kaiser(bandwidthToBeta(bandwidth, heuristicOptimal), amplitude);
   }
 
@@ -59,25 +59,26 @@ class Kaiser: public WindowFunction {
 
   // https://en.wikipedia.org/wiki/Bessel_function#Modified_Bessel_functions:_I%CE%B1,_K%CE%B1
   static inline float bessel0(float x) {
-      const double significanceLimit = 1e-4;
-      auto result = 0.0f;
-      auto term = 1.0f;
-      auto m = 1.0f;
-      while (term > significanceLimit) {
-          result += term;
-          ++m;
-          term *= (x * x) / (4 * m * m);
-      }
-
-      return result;
+    const double significanceLimit = 1e-4;
+    auto result = 0.0f;
+    auto term = 1.0f;
+    auto m = 1.0f;
+    while (term > significanceLimit) {
+      result += term;
+      ++m;
+      term *= (x * x) / (4 * m * m);
+    }
+
+    return result;
   }
   static float bandwidthToBeta(float bandwidth, bool heuristicOptimal = false);
 };
 
 // https://www.recordingblogs.com/wiki/gaussian-window
-class ApproximateConfinedGaussian: public WindowFunction {
+class ApproximateConfinedGaussian : public WindowFunction {
  public:
-  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f): WindowFunction(amplitude), gaussianFactor_(0.0625f/(sigma*sigma)) {}
+  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f)
+      : WindowFunction(amplitude), gaussianFactor_(0.0625f / (sigma * sigma)) {}
 
   static ApproximateConfinedGaussian withBandwidth(float bandwidth, float amplitude = 1.0f) {
     return ApproximateConfinedGaussian(bandwidthToSigma(bandwidth), amplitude);

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -1,5 +1,8 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -100,12 +103,9 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         if (eventName.compare("audioReady") == 0) {
           auto bufferIt = body.find("buffer");
           if (bufferIt != body.end()) {
-            auto bufferHostObject =
-                std::static_pointer_cast<AudioBufferHostObject>(
-                    std::get<std::shared_ptr<jsi::HostObject>>(
-                        bufferIt->second));
-            eventObject =
-                createEventObject(body, bufferHostObject->getSizeInBytes());
+            auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
+                std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
+            eventObject = createEventObject(body, bufferHostObject->getSizeInBytes());
           }
         } else {
           eventObject = createEventObject(body);
@@ -117,8 +117,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         throw;
       } catch (...) {
         printf(
-            "Unknown exception occurred while invoking handler for event: %s\n",
-            eventName.c_str());
+            "Unknown exception occurred while invoking handler for event: %s\n", eventName.c_str());
       }
     }
   });
@@ -168,11 +167,9 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       if (eventName.compare("audioReady") == 0) {
         auto bufferIt = body.find("buffer");
         if (bufferIt != body.end()) {
-          auto bufferHostObject =
-              std::static_pointer_cast<AudioBufferHostObject>(
-                  std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
-          eventObject =
-              createEventObject(body, bufferHostObject->getSizeInBytes());
+          auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
+              std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
+          eventObject = createEventObject(body, bufferHostObject->getSizeInBytes());
         }
       } else {
         eventObject = createEventObject(body);
@@ -184,8 +181,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       throw;
     } catch (...) {
       printf(
-          "Unknown exception occurred while invoking handler for event: %s\n",
-          eventName.c_str());
+          "Unknown exception occurred while invoking handler for event: %s\n", eventName.c_str());
     }
   });
 }
@@ -208,8 +204,7 @@ jsi::Object AudioEventHandlerRegistry::createEventObject(
       eventObject.setProperty(*runtime_, name, std::get<bool>(value));
     } else if (std::holds_alternative<std::string>(value)) {
       eventObject.setProperty(*runtime_, name, std::get<std::string>(value));
-    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(
-                   value)) {
+    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
       auto hostObject = jsi::Object::createFromHostObject(
           *runtime_, std::get<std::shared_ptr<jsi::HostObject>>(value));
       eventObject.setProperty(*runtime_, name, hostObject);

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -1,19 +1,20 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
-#include <memory>
-#include <unordered_map>
+#include <jsi/jsi.h>
 #include <array>
+#include <atomic>
+#include <memory>
 #include <string>
+#include <unordered_map>
 #include <variant>
-#include <atomic>
 
 namespace audioapi {
 using namespace facebook;
 
-using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
+using EventValue =
+    std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
 
 class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
@@ -22,48 +23,52 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
       const std::shared_ptr<react::CallInvoker> &callInvoker);
   ~AudioEventHandlerRegistry() override;
 
-  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler) override;
+  uint64_t registerHandler(
+      const std::string &eventName,
+      const std::shared_ptr<jsi::Function> &handler) override;
   void unregisterHandler(const std::string &eventName, uint64_t listenerId) override;
 
-  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) override;
-  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) override;
+  void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      const std::unordered_map<std::string, EventValue> &body) override;
+  void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      uint64_t listenerId,
+      const std::unordered_map<std::string, EventValue> &body) override;
 
  private:
-    std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs
+  std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs
 
-    std::shared_ptr<react::CallInvoker> callInvoker_;
-    jsi::Runtime *runtime_;
-    std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>> eventHandlers_;
+  std::shared_ptr<react::CallInvoker> callInvoker_;
+  jsi::Runtime *runtime_;
+  std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>>
+      eventHandlers_;
 
-    static constexpr std::array<std::string_view, 15> SYSTEM_EVENT_NAMES = {
-        "remotePlay",
-        "remotePause",
-        "remoteStop",
-        "remoteTogglePlayPause",
-        "remoteChangePlaybackRate",
-        "remoteNextTrack",
-        "remotePreviousTrack",
-        "remoteSkipForward",
-        "remoteSkipBackward",
-        "remoteSeekForward",
-        "remoteSeekBackward",
-        "remoteChangePlaybackPosition",
-        "routeChange",
-        "interruption",
-        "volumeChange",
-    };
+  static constexpr std::array<std::string_view, 15> SYSTEM_EVENT_NAMES = {
+      "remotePlay",
+      "remotePause",
+      "remoteStop",
+      "remoteTogglePlayPause",
+      "remoteChangePlaybackRate",
+      "remoteNextTrack",
+      "remotePreviousTrack",
+      "remoteSkipForward",
+      "remoteSkipBackward",
+      "remoteSeekForward",
+      "remoteSeekBackward",
+      "remoteChangePlaybackPosition",
+      "routeChange",
+      "interruption",
+      "volumeChange",
+  };
 
-    static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES = {
-      "ended",
-      "loopEnded",
-      "audioReady",
-      "positionChanged",
-      "audioError",
-      "systemStateChanged"
-    };
+  static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES =
+      {"ended", "loopEnded", "audioReady", "positionChanged", "audioError", "systemStateChanged"};
 
-    jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
-    jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body, size_t memoryPressure);
+  jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
+  jsi::Object createEventObject(
+      const std::unordered_map<std::string, EventValue> &body,
+      size_t memoryPressure);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/events/IAudioEventHandlerRegistry.h

@@ -1,25 +1,33 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
 #include <unordered_map>
 #include <variant>
-#include <string>
-#include <memory>
 
 namespace audioapi {
 
-using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<facebook::jsi::HostObject>>;
+using EventValue =
+    std::variant<int, float, double, std::string, bool, std::shared_ptr<facebook::jsi::HostObject>>;
 
 class IAudioEventHandlerRegistry {
  public:
   virtual ~IAudioEventHandlerRegistry() = default;
 
-  virtual uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
+  virtual uint64_t registerHandler(
+      const std::string &eventName,
+      const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
   virtual void unregisterHandler(const std::string &eventName, uint64_t listenerId) = 0;
 
-  virtual void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) = 0;
-  virtual void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) = 0;
+  virtual void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      const std::unordered_map<std::string, EventValue> &body) = 0;
+  virtual void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      uint64_t listenerId,
+      const std::unordered_map<std::string, EventValue> &body) = 0;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/jsi/AudioArrayBuffer.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <audioapi/utils/AudioArray.h>
+#include <jsi/jsi.h>
 
 #include <memory>
 #include <utility>
@@ -12,11 +12,11 @@ using namespace facebook;
 
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
-  explicit AudioArrayBuffer(const std::shared_ptr<AudioArray> &audioArray): audioArray_(audioArray) {}
+  explicit AudioArrayBuffer(const std::shared_ptr<AudioArray> &audioArray)
+      : audioArray_(audioArray) {}
   ~AudioArrayBuffer() override = default;
 
-  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
-      : audioArray_(std::move(other.audioArray_)) {
+  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept : audioArray_(std::move(other.audioArray_)) {
     other.audioArray_ = nullptr;
   }
 
@@ -32,4 +32,3 @@ class AudioArrayBuffer : public jsi::MutableBuffer {
 };
 
 } // namespace audioapi
-

package/common/cpp/audioapi/jsi/JsiHostObject.cpp

@@ -1,4 +1,9 @@
 #include <audioapi/jsi/JsiHostObject.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 
 //  set this value to 1 in order to debug the construction/destruction
 #define JSI_DEBUG_ALLOCATIONS 0
@@ -11,9 +16,8 @@ std::vector<JsiHostObject *> objects;
 #endif
 
 JsiHostObject::JsiHostObject() {
-  getters_ = std::make_unique<std::unordered_map<
-      std::string,
-      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
+  getters_ = std::make_unique<
+      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
   functions_ = std::make_unique<std::unordered_map<
       std::string,
       jsi::Value (JsiHostObject::*)(
@@ -70,8 +74,7 @@ JsiHostObject::~JsiHostObject() {
 
 std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> propertyNames;
-  propertyNames.reserve(
-      getters_->size() + functions_->size() + setters_->size());
+  propertyNames.reserve(getters_->size() + functions_->size() + setters_->size());
 
   for (const auto &it : *getters_) {
     propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
@@ -88,9 +91,7 @@ std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
   return propertyNames;
 }
 
-jsi::Value JsiHostObject::get(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &name) {
+jsi::Value JsiHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
   auto nameAsString = name.utf8(runtime);
   auto &hostFunctionCache = hostFunctionCache_.get(runtime);
 
@@ -117,9 +118,7 @@ jsi::Value JsiHostObject::get(
         std::placeholders::_4);
 
     return hostFunctionCache
-        .emplace(
-            nameAsString,
-            jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher))
+        .emplace(nameAsString, jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher))
         .first->second.asFunction(runtime);
   }
 
@@ -135,8 +134,7 @@ void JsiHostObject::set(
   auto setter = setters_->find(nameAsString);
 
   if (setter != setters_->end()) {
-    auto dispatcher = std::bind(
-        setter->second, this, std::placeholders::_1, std::placeholders::_2);
+    auto dispatcher = std::bind(setter->second, this, std::placeholders::_1, std::placeholders::_2);
 
     return dispatcher(runtime, value);
   }