react-native-tvos 0.82.1-0 → 0.83.0-0

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.h

@@ -14,40 +14,43 @@
 namespace facebook::react {
 
 struct DynamicColor {
-  uint32_t lightColor = 0;
-  uint32_t darkColor = 0;
-  uint32_t highContrastLightColor = 0;
-  uint32_t highContrastDarkColor = 0;
+  int32_t lightColor = 0;
+  int32_t darkColor = 0;
+  int32_t highContrastLightColor = 0;
+  int32_t highContrastDarkColor = 0;
 };
 
 struct Color {
-  Color(uint32_t color);
-  Color(const DynamicColor& dynamicColor);
-  Color(const ColorComponents& components);
-  Color() : uiColor_(nullptr){};
-  uint32_t getColor() const;
+  Color(int32_t color);
+  Color(const DynamicColor &dynamicColor);
+  Color(const ColorComponents &components);
+  Color() : uiColor_(nullptr) {};
+  int32_t getColor() const;
   std::size_t getUIColorHash() const;
 
-  static Color createSemanticColor(std::vector<std::string>& semanticItems);
+  static Color createSemanticColor(std::vector<std::string> &semanticItems);
 
-  std::shared_ptr<void> getUIColor() const {
+  std::shared_ptr<void> getUIColor() const
+  {
     return uiColor_;
   }
 
   float getChannel(int channelId) const;
 
-  ColorComponents getColorComponents() const {
+  ColorComponents getColorComponents() const
+  {
     float ratio = 255;
-    uint32_t primitiveColor = getColor();
+    int32_t primitiveColor = getColor();
     return ColorComponents{
         .red = (float)((primitiveColor >> 16) & 0xff) / ratio,
         .green = (float)((primitiveColor >> 8) & 0xff) / ratio,
         .blue = (float)((primitiveColor >> 0) & 0xff) / ratio,
         .alpha = (float)((primitiveColor >> 24) & 0xff) / ratio};
   }
-  bool operator==(const Color& other) const;
-  bool operator!=(const Color& other) const;
-  operator uint32_t() const {
+  bool operator==(const Color &other) const;
+  bool operator!=(const Color &other) const;
+  operator int32_t() const
+  {
     return getColor();
   }
 
@@ -68,8 +71,8 @@ namespace HostPlatformColor {
 NO_DESTROY static const facebook::react::Color UndefinedColor = Color();
 } // namespace HostPlatformColor
 
-inline Color
-hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+inline Color hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+{
   float ratio = 255;
   const auto colorComponents = ColorComponents{
       .red = r / ratio,
@@ -80,31 +83,38 @@ hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
   return Color(colorComponents);
 }
 
-inline Color hostPlatformColorFromComponents(ColorComponents components) {
+inline Color hostPlatformColorFromComponents(ColorComponents components)
+{
   return Color(components);
 }
 
-inline ColorComponents colorComponentsFromHostPlatformColor(Color color) {
+inline ColorComponents colorComponentsFromHostPlatformColor(Color color)
+{
   return color.getColorComponents();
 }
 
-inline float alphaFromHostPlatformColor(Color color) {
+inline float alphaFromHostPlatformColor(Color color)
+{
   return color.getChannel(3) * 255;
 }
 
-inline float redFromHostPlatformColor(Color color) {
+inline float redFromHostPlatformColor(Color color)
+{
   return color.getChannel(0) * 255;
 }
 
-inline float greenFromHostPlatformColor(Color color) {
+inline float greenFromHostPlatformColor(Color color)
+{
   return color.getChannel(1) * 255;
 }
 
-inline float blueFromHostPlatformColor(Color color) {
+inline float blueFromHostPlatformColor(Color color)
+{
   return color.getChannel(2) * 255;
 }
 
-inline bool hostPlatformColorIsColorMeaningful(Color color) noexcept {
+inline bool hostPlatformColorIsColorMeaningful(Color color) noexcept
+{
   return alphaFromHostPlatformColor(color) > 0;
 }
 
@@ -112,7 +122,8 @@ inline bool hostPlatformColorIsColorMeaningful(Color color) noexcept {
 
 template <>
 struct std::hash<facebook::react::Color> {
-  size_t operator()(const facebook::react::Color& color) const {
+  size_t operator()(const facebook::react::Color &color) const
+  {
     return color.getUIColorHash();
   }
 };

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.mm

@@ -29,14 +29,14 @@ bool UIColorIsP3ColorSpace(const std::shared_ptr<void> &uiColor)
 
   if (CGColorSpaceGetModel(colorSpace) == kCGColorSpaceModelRGB) {
     CFStringRef name = CGColorSpaceGetName(colorSpace);
-    if (name != NULL && CFEqual(name, kCGColorSpaceDisplayP3)) {
+    if (name != NULL && (CFEqual(name, kCGColorSpaceDisplayP3) != 0u)) {
       return true;
     }
   }
   return false;
 }
 
-UIColor *_Nullable UIColorFromInt32(uint32_t intColor)
+UIColor *_Nullable UIColorFromInt32(int32_t intColor)
 {
   CGFloat a = CGFloat((intColor >> 24) & 0xFF) / 255.0;
   CGFloat r = CGFloat((intColor >> 16) & 0xFF) / 255.0;
@@ -49,10 +49,10 @@ UIColor *_Nullable UIColorFromInt32(uint32_t intColor)
 
 UIColor *_Nullable UIColorFromDynamicColor(const facebook::react::DynamicColor &dynamicColor)
 {
-  uint32_t light = dynamicColor.lightColor;
-  uint32_t dark = dynamicColor.darkColor;
-  uint32_t highContrastLight = dynamicColor.highContrastLightColor;
-  uint32_t highContrastDark = dynamicColor.highContrastDarkColor;
+  int32_t light = dynamicColor.lightColor;
+  int32_t dark = dynamicColor.darkColor;
+  int32_t highContrastLight = dynamicColor.highContrastLightColor;
+  int32_t highContrastDark = dynamicColor.highContrastDarkColor;
 
   UIColor *lightColor = UIColorFromInt32(light);
   UIColor *darkColor = UIColorFromInt32(dark);
@@ -83,7 +83,7 @@ UIColor *_Nullable UIColorFromDynamicColor(const facebook::react::DynamicColor &
   return nil;
 }
 
-uint32_t ColorFromColorComponents(const facebook::react::ColorComponents &components)
+int32_t ColorFromColorComponents(const facebook::react::ColorComponents &components)
 {
   float ratio = 255;
   auto color = ((int32_t)round((float)components.alpha * ratio) & 0xff) << 24 |
@@ -92,7 +92,7 @@ uint32_t ColorFromColorComponents(const facebook::react::ColorComponents &compon
   return color;
 }
 
-uint32_t ColorFromUIColor(UIColor *color)
+int32_t ColorFromUIColor(UIColor *color)
 {
   CGFloat rgba[4];
   [color getRed:&rgba[0] green:&rgba[1] blue:&rgba[2] alpha:&rgba[3]];
@@ -100,12 +100,12 @@ uint32_t ColorFromUIColor(UIColor *color)
       {.red = (float)rgba[0], .green = (float)rgba[1], .blue = (float)rgba[2], .alpha = (float)rgba[3]});
 }
 
-uint32_t ColorFromUIColorForSpecificTraitCollection(
+int32_t ColorFromUIColorForSpecificTraitCollection(
     const std::shared_ptr<void> &uiColor,
     UITraitCollection *traitCollection)
 {
   UIColor *color = (UIColor *)unwrapManagedObject(uiColor);
-  if (color) {
+  if (color != nullptr) {
     color = [color resolvedColorWithTraitCollection:traitCollection];
     return ColorFromUIColor(color);
   }
@@ -113,7 +113,7 @@ uint32_t ColorFromUIColorForSpecificTraitCollection(
   return 0;
 }
 
-uint32_t ColorFromUIColor(const std::shared_ptr<void> &uiColor)
+int32_t ColorFromUIColor(const std::shared_ptr<void> &uiColor)
 {
   return ColorFromUIColorForSpecificTraitCollection(uiColor, [UITraitCollection currentTraitCollection]);
 }
@@ -172,7 +172,7 @@ std::size_t hashFromUIColor(const std::shared_ptr<void> &uiColor)
 
 } // anonymous namespace
 
-Color::Color(uint32_t color)
+Color::Color(int32_t color)
 {
   uiColor_ = wrapManagedObject(UIColorFromInt32(color));
   uiColorHashValue_ = facebook::react::hash_combine(color, 0);
@@ -199,7 +199,7 @@ Color::Color(const ColorComponents &components)
 Color::Color(std::shared_ptr<void> uiColor)
 {
   UIColor *color = ((UIColor *)unwrapManagedObject(uiColor));
-  if (color) {
+  if (color != nullptr) {
     auto colorHash = hashFromUIColor(uiColor);
     uiColorHashValue_ = colorHash;
   }
@@ -217,7 +217,7 @@ bool Color::operator!=(const Color &other) const
   return !(*this == other);
 }
 
-uint32_t Color::getColor() const
+int32_t Color::getColor() const
 {
   return ColorFromUIColor(uiColor_);
 }

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/PlatformColorParser.h

@@ -15,18 +15,12 @@
 
 namespace facebook::react {
 
-SharedColor parsePlatformColor(
-    const ContextContainer& contextContainer,
-    int32_t surfaceId,
-    const RawValue& value);
+SharedColor parsePlatformColor(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value);
 
-inline void fromRawValue(
-    const ContextContainer& contextContainer,
-    int32_t surfaceId,
-    const RawValue& value,
-    SharedColor& result) {
-  fromRawValueShared(
-      contextContainer, surfaceId, value, result, parsePlatformColor);
+inline void
+fromRawValue(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value, SharedColor &result)
+{
+  fromRawValueShared(contextContainer, surfaceId, value, result, parsePlatformColor);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/PlatformColorParser.mm

@@ -29,24 +29,25 @@ inline facebook::react::SharedColor RCTPlatformColorComponentsFromDynamicItems(
   SharedColor darkSharedColor{};
   SharedColor highContrastLightSharedColor{};
   SharedColor highContrastDarkSharedColor{};
-  if (dynamicItems.count("light")) {
+  if (dynamicItems.count("light") != 0u) {
     fromRawValue(contextContainer, surfaceId, dynamicItems.at("light"), lightSharedColor);
   }
-  if (dynamicItems.count("dark")) {
+  if (dynamicItems.count("dark") != 0u) {
     fromRawValue(contextContainer, surfaceId, dynamicItems.at("dark"), darkSharedColor);
   }
-  if (dynamicItems.count("highContrastLight")) {
+  if (dynamicItems.count("highContrastLight") != 0u) {
     fromRawValue(contextContainer, surfaceId, dynamicItems.at("highContrastLight"), highContrastLightSharedColor);
   }
-  if (dynamicItems.count("highContrastDark")) {
+  if (dynamicItems.count("highContrastDark") != 0u) {
     fromRawValue(contextContainer, surfaceId, dynamicItems.at("highContrastDark"), highContrastDarkSharedColor);
   }
 
-  Color color = Color(DynamicColor{
-      .lightColor = (*lightSharedColor).getColor(),
-      .darkColor = (*darkSharedColor).getColor(),
-      .highContrastLightColor = (*highContrastLightSharedColor).getColor(),
-      .highContrastDarkColor = (*highContrastDarkSharedColor).getColor()});
+  Color color = Color(
+      DynamicColor{
+          .lightColor = (*lightSharedColor).getColor(),
+          .darkColor = (*darkSharedColor).getColor(),
+          .highContrastLightColor = (*highContrastLightSharedColor).getColor(),
+          .highContrastDarkColor = (*highContrastDarkSharedColor).getColor()});
   return SharedColor(color);
 }
 

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/RCTPlatformColorUtils.h

@@ -15,8 +15,6 @@ struct ColorComponents;
 struct Color;
 } // namespace facebook::react
 
-facebook::react::ColorComponents RCTPlatformColorComponentsFromSemanticItems(
-    std::vector<std::string>& semanticItems);
-UIColor* RCTPlatformColorFromSemanticItems(
-    std::vector<std::string>& semanticItems);
-UIColor* RCTPlatformColorFromColor(const facebook::react::Color& color);
+facebook::react::ColorComponents RCTPlatformColorComponentsFromSemanticItems(std::vector<std::string> &semanticItems);
+UIColor *RCTPlatformColorFromSemanticItems(std::vector<std::string> &semanticItems);
+UIColor *RCTPlatformColorFromColor(const facebook::react::Color &color);

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/RCTPlatformColorUtils.mm

@@ -153,17 +153,17 @@ static UIColor *_Nullable _UIColorFromSemanticString(NSString *semanticString)
       : semanticString;
   NSDictionary<NSString *, NSDictionary *> *platformColorSelectorsDict = _PlatformColorSelectorsDict();
   NSDictionary<NSString *, id> *colorInfo = platformColorSelectorsDict[platformColorString];
-  if (colorInfo) {
+  if (colorInfo != nullptr) {
     SEL objcColorSelector = NSSelectorFromString([platformColorString stringByAppendingString:kColorSuffix]);
     if (![UIColor respondsToSelector:objcColorSelector]) {
       NSNumber *fallbackRGB = colorInfo[kFallbackARGBKey];
-      if (fallbackRGB) {
+      if (fallbackRGB != nullptr) {
         return _UIColorFromHexValue(fallbackRGB);
       }
     } else {
       Class uiColorClass = [UIColor class];
       IMP imp = [uiColorClass methodForSelector:objcColorSelector];
-      id (*getUIColor)(id, SEL) = ((id(*)(id, SEL))imp);
+      id (*getUIColor)(id, SEL) = ((id (*)(id, SEL))imp);
       id colorObject = getUIColor(uiColorClass, objcColorSelector);
       if ([colorObject isKindOfClass:[UIColor class]]) {
         return colorObject;

package/ReactCommon/react/renderer/graphics/rounding.h

@@ -23,60 +23,70 @@ namespace facebook::react {
  *   auto crispSize = roundToPixel<&std::ceil>(size, scaleFactor);
  */
 template <Float (*RoundingFunction)(Float)>
-Float roundToPixel(Float value, Float scaleFactor) {
+Float roundToPixel(Float value, Float scaleFactor)
+{
   return RoundingFunction(value * scaleFactor) / scaleFactor;
 }
 
 template <Float (*RoundingFunction)(Float)>
-Point roundToPixel(Point value, Float scaleFactor) {
+Point roundToPixel(Point value, Float scaleFactor)
+{
   return Point{
-      roundToPixel<RoundingFunction>(value.x, scaleFactor),
-      roundToPixel<RoundingFunction>(value.y, scaleFactor)};
+      roundToPixel<RoundingFunction>(value.x, scaleFactor), roundToPixel<RoundingFunction>(value.y, scaleFactor)};
 }
 
 template <Float (*RoundingFunction)(Float)>
-Size roundToPixel(Size value, Float scaleFactor) {
+Size roundToPixel(Size value, Float scaleFactor)
+{
   return Size{
       roundToPixel<RoundingFunction>(value.width, scaleFactor),
       roundToPixel<RoundingFunction>(value.height, scaleFactor)};
 }
 
 template <Float (*RoundingFunction)(Float)>
-Rect roundToPixel(Rect value, Float scaleFactor) {
-  return Rect{
-      roundToPixel<RoundingFunction>(value.origin),
-      roundToPixel<RoundingFunction>(value.size)};
+Rect roundToPixel(Rect value, Float scaleFactor)
+{
+  return Rect{roundToPixel<RoundingFunction>(value.origin), roundToPixel<RoundingFunction>(value.size)};
 }
 
 /*
  * GCC-based Android NDK does not have rounding functions as part of STL.
  */
 
-inline float round(float value) noexcept {
+inline float round(float value) noexcept
+{
   return ::roundf(value);
 }
-inline double round(double value) noexcept {
+inline double round(double value) noexcept
+{
   return ::round(value);
 }
-inline long double round(long double value) noexcept {
+inline long double round(long double value) noexcept
+{
   return ::roundl(value);
 }
-inline float ceil(float value) noexcept {
+inline float ceil(float value) noexcept
+{
   return ::ceilf(value);
 }
-inline double ceil(double value) noexcept {
+inline double ceil(double value) noexcept
+{
   return ::ceil(value);
 }
-inline long double ceil(long double value) noexcept {
+inline long double ceil(long double value) noexcept
+{
   return ::ceill(value);
 }
-inline float floor(float value) noexcept {
+inline float floor(float value) noexcept
+{
   return ::floorf(value);
 }
-inline double floor(double value) noexcept {
+inline double floor(double value) noexcept
+{
   return ::floor(value);
 }
-inline long double floor(long double value) noexcept {
+inline long double floor(long double value) noexcept
+{
   return ::floorl(value);
 }
 

package/ReactCommon/react/renderer/imagemanager/ImageManager.h

@@ -19,9 +19,7 @@ namespace facebook::react {
 
 class ImageManager;
 
-using SharedImageManager
-    [[deprecated("Use std::shared_ptr<ImageManager> instead.")]] =
-        std::shared_ptr<ImageManager>;
+using SharedImageManager [[deprecated("Use std::shared_ptr<ImageManager> instead.")]] = std::shared_ptr<ImageManager>;
 
 /*
  * Cross platform facade for image management (e.g. iOS-specific
@@ -29,17 +27,17 @@ using SharedImageManager
  */
 class ImageManager {
  public:
-  ImageManager(const std::shared_ptr<const ContextContainer>& contextContainer);
+  ImageManager(const std::shared_ptr<const ContextContainer> &contextContainer);
   virtual ~ImageManager();
 
   virtual ImageRequest requestImage(
-      const ImageSource& imageSource,
+      const ImageSource &imageSource,
       SurfaceId surfaceId,
-      const ImageRequestParams& imageRequestParams = {},
+      const ImageRequestParams &imageRequestParams = {},
       Tag tag = {}) const;
 
  private:
-  void* self_{};
+  void *self_{};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/imagemanager/ImageRequest.h

@@ -37,18 +37,18 @@ class ImageRequest final {
   /*
    * The move constructor.
    */
-  ImageRequest(ImageRequest&& other) noexcept = default;
+  ImageRequest(ImageRequest &&other) noexcept = default;
 
   /*
    * Move assignment operator.
    */
-  ImageRequest& operator=(ImageRequest&& other) noexcept = default;
+  ImageRequest &operator=(ImageRequest &&other) noexcept = default;
 
   /*
    * `ImageRequest` does not support copying by design.
    */
-  ImageRequest(const ImageRequest& other) = delete;
-  ImageRequest& operator=(const ImageRequest& other) = delete;
+  ImageRequest(const ImageRequest &other) = delete;
+  ImageRequest &operator=(const ImageRequest &other) = delete;
 
   /*
    * Destructor
@@ -58,27 +58,26 @@ class ImageRequest final {
   /*
    * Returns the Image Source associated with the request.
    */
-  const ImageSource& getImageSource() const;
+  const ImageSource &getImageSource() const;
 
   /*
    * Returns stored observer coordinator as a shared pointer.
    * Retain this *or* `ImageRequest` to ensure a correct lifetime of the object.
    */
-  const std::shared_ptr<const ImageResponseObserverCoordinator>&
-  getSharedObserverCoordinator() const;
+  const std::shared_ptr<const ImageResponseObserverCoordinator> &getSharedObserverCoordinator() const;
 
   /*
    * Returns stored observer coordinator as a reference.
    * Use this if a correct lifetime of the object is ensured in some other way
    * (e.g. by retaining an `ImageRequest`).
    */
-  const ImageResponseObserverCoordinator& getObserverCoordinator() const;
+  const ImageResponseObserverCoordinator &getObserverCoordinator() const;
 
   /*
    * Returns stored image telemetry object as a shared pointer.
    * Retain this *or* `ImageRequest` to ensure a correct lifetime of the object.
    */
-  const std::shared_ptr<const ImageTelemetry>& getSharedTelemetry() const;
+  const std::shared_ptr<const ImageTelemetry> &getSharedTelemetry() const;
 
  private:
   /*

package/ReactCommon/react/renderer/imagemanager/ImageResponseObserver.h

@@ -19,10 +19,9 @@ class ImageResponseObserver {
  public:
   virtual ~ImageResponseObserver() noexcept = default;
 
-  virtual void didReceiveProgress(float progress, int64_t loaded, int64_t total)
-      const = 0;
-  virtual void didReceiveImage(const ImageResponse& imageResponse) const = 0;
-  virtual void didReceiveFailure(const ImageLoadError& error) const = 0;
+  virtual void didReceiveProgress(float progress, int64_t loaded, int64_t total) const = 0;
+  virtual void didReceiveImage(const ImageResponse &imageResponse) const = 0;
+  virtual void didReceiveFailure(const ImageLoadError &error) const = 0;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/imagemanager/ImageResponseObserverCoordinator.cpp

@@ -123,11 +123,9 @@ void ImageResponseObserverCoordinator::nativeImageResponseFailed(
 }
 
 void ImageResponseObserverCoordinator::consumeResponse() const {
-  if (ReactNativeFeatureFlags::releaseImageDataWhenConsumed()) {
-    status_ = ImageResponse::Status::Consumed;
-    imageData_.reset();
-    imageMetadata_.reset();
-  }
+  status_ = ImageResponse::Status::Consumed;
+  imageData_.reset();
+  imageMetadata_.reset();
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/imagemanager/ImageResponseObserverCoordinator.h

@@ -24,41 +24,36 @@ namespace facebook::react {
  */
 class ImageResponseObserverCoordinator {
  public:
-  ImageResponseObserverCoordinator(
-      SharedFunction<> resumeFunction,
-      SharedFunction<> cancelationFunction);
+  ImageResponseObserverCoordinator(SharedFunction<> resumeFunction, SharedFunction<> cancelationFunction);
 
   /*
    * Interested parties may observe the image response.
    * If the current image request status is not equal to `Loading`, the observer
    * will be called immediately.
    */
-  void addObserver(const ImageResponseObserver& observer) const;
+  void addObserver(const ImageResponseObserver &observer) const;
 
   /*
    * Interested parties may stop observing the image response.
    */
-  void removeObserver(const ImageResponseObserver& observer) const;
+  void removeObserver(const ImageResponseObserver &observer) const;
 
   /*
    * Platform-specific image loader will call this method with progress updates.
    */
-  void nativeImageResponseProgress(
-      float progress,
-      int64_t loaded,
-      int64_t total) const;
+  void nativeImageResponseProgress(float progress, int64_t loaded, int64_t total) const;
 
   /*
    * Platform-specific image loader will call this method with a completed image
    * response.
    */
-  void nativeImageResponseComplete(const ImageResponse& imageResponse) const;
+  void nativeImageResponseComplete(const ImageResponse &imageResponse) const;
 
   /*
    * Platform-specific image loader will call this method in case of any
    * failures.
    */
-  void nativeImageResponseFailed(const ImageLoadError& loadError) const;
+  void nativeImageResponseFailed(const ImageLoadError &loadError) const;
 
  private:
   /*
@@ -70,7 +65,7 @@ class ImageResponseObserverCoordinator {
    * List of observers.
    * Mutable: protected by mutex_.
    */
-  mutable std::vector<const ImageResponseObserver*> observers_;
+  mutable std::vector<const ImageResponseObserver *> observers_;
 
   /*
    * Current status of image loading.

package/ReactCommon/react/renderer/imagemanager/ImageTelemetry.h

@@ -18,7 +18,8 @@ namespace facebook::react {
  */
 class ImageTelemetry final {
  public:
-  ImageTelemetry(const SurfaceId surfaceId) : surfaceId_(surfaceId) {
+  ImageTelemetry(const SurfaceId surfaceId) : surfaceId_(surfaceId)
+  {
     willRequestUrlTime_ = telemetryTimePointNow();
   }