hunk.code_window: }
   function App() {
     const colorScheme = useColorScheme();
     const themeStatusBarStyle =
       colorScheme === 'light' ? 'dark-content' : 'light-content';
     const themeTextStyle =
       colorScheme === 'light' ? styles.lightThemeText : styles.darkThemeText;
     const themeContainerStyle =
       colorScheme === 'light' ? styles.lightContainer : styles.darkContainer;
     return (
       <SafeAreaView style={[styles.container, themeContainerStyle]}>
  
hunk.labels: keep keep keep keep keep replace replace replace replace keep keep keep keep keep
hunk.after_edit:   const themeStatusBarStyle = colorScheme === 'light' ? 'dark-content' : 'light-content';
     const themeTextStyle = colorScheme === 'light' ? styles.lightThemeText : styles.darkThemeText;
  
hunk.file_path: docs/pages/versions/unversioned/sdk/appearance.md
hunk.type: replace
file: 
  //  (C) Copyright Rani Sharoni 2003.
  //  Use, modification and distribution are subject to the Boost Software License,
  //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  //  http://www.boost.org/LICENSE_1_0.txt).
  //
  //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
   
  #ifndef BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
  #define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
  
  #include <boost/type_traits/intrinsics.hpp>
  #include <boost/type_traits/integral_constant.hpp>
  #ifndef BOOST_IS_BASE_OF
  #include <boost/type_traits/is_class.hpp>
  #include <boost/type_traits/is_same.hpp>
  #include <boost/type_traits/is_convertible.hpp>
  #include <boost/config.hpp>
  #include <boost/static_assert.hpp>
  #endif
  #include <boost/type_traits/remove_cv.hpp>
  #include <boost/type_traits/is_same.hpp>
  
  namespace boost {
  
  namespace detail {
  
  #ifndef BOOST_IS_BASE_OF
  #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) \
   && !BOOST_WORKAROUND(__SUNPRO_CC , <= 0x540) \
   && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \
   && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
  
                               // The EDG version number is a lower estimate.
                               // It is not currently known which EDG version
                               // exactly fixes the problem.
  
  /*************************************************************************
  
  This version detects ambiguous base classes and private base classes
  correctly, and was devised by Rani Sharoni.
  
  Explanation by Terje Slettebo and Rani Sharoni.
  
  Let's take the multiple base class below as an example, and the following
  will also show why there's not a problem with private or ambiguous base
  class:
  
  struct B {};
  struct B1 : B {};
  struct B2 : B {};
  struct D : private B1, private B2 {};
  
  is_base_and_derived<B, D>::value;
  
  First, some terminology:
  
  SC  - Standard conversion
  UDC - User-defined conversion
  
  A user-defined conversion sequence consists of an SC, followed by an UDC,
  followed by another SC. Either SC may be the identity conversion.
  
  When passing the default-constructed Host object to the overloaded check_sig()
  functions (initialization 8.5/14/4/3), we have several viable implicit
  conversion sequences:
  
  For "static no_type check_sig(B const volatile *, int)" we have the conversion
  sequences:
  
  C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC)
  C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
       B const volatile* (SC - Conversion)
  
  For "static yes_type check_sig(D const volatile *, T)" we have the conversion
  sequence:
  
  C -> D const volatile* (UDC)
  
  According to 13.3.3.1/4, in context of user-defined conversion only the
  standard conversion sequence is considered when selecting the best viable
  function, so it only considers up to the user-defined conversion. For the
  first function this means choosing between C -> C const and C -> C, and it
  chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the
  former. Therefore, we have:
  
  C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
       B const volatile* (SC - Conversion)
  C -> D const volatile* (UDC)
  
  Here, the principle of the "shortest subsequence" applies again, and it
  chooses C -> D const volatile*. This shows that it doesn't even need to
  consider the multiple paths to B, or accessibility, as that possibility is
  eliminated before it could possibly cause ambiguity or access violation.
  
  If D is not derived from B, it has to choose between C -> C const -> B const
  volatile* for the first function, and C -> D const volatile* for the second
  function, which are just as good (both requires a UDC, 13.3.3.2), had it not
  been for the fact that "static no_type check_sig(B const volatile *, int)" is
  not templated, which makes C -> C const -> B const volatile* the best choice
  (13.3.3/1/4), resulting in "no".
  
  Also, if Host::operator B const volatile* hadn't been const, the two
  conversion sequences for "static no_type check_sig(B const volatile *, int)", in
  the case where D is derived from B, would have been ambiguous.
  
  See also
  http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting.
  google.com and links therein.
  
  *************************************************************************/
  
  template <typename B, typename D>
  struct bd_helper
  {
     //
     // This VC7.1 specific workaround stops the compiler from generating
     // an internal compiler error when compiling with /vmg (thanks to
     // Aleksey Gurtovoy for figuring out the workaround).
     //
  #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
      template <typename T>
      static type_traits::yes_type check_sig(D const volatile *, T);
      static type_traits::no_type  check_sig(B const volatile *, int);
  #else
      static type_traits::yes_type check_sig(D const volatile *, long);
      static type_traits::no_type  check_sig(B const volatile * const&, int);
  #endif
  };
  
  template<typename B, typename D>
  struct is_base_and_derived_impl2
  {
  #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
  #pragma warning(push)
  #pragma warning(disable:6334)
  #endif
      //
      // May silently do the wrong thing with incomplete types
      // unless we trap them here:
      //
      BOOST_STATIC_ASSERT(sizeof(B) != 0);
      BOOST_STATIC_ASSERT(sizeof(D) != 0);
  
      struct Host
      {
  #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
          operator B const volatile *() const;
  #else
          operator B const volatile * const&() const;
  #endif
          operator D const volatile *();
      };
  
      BOOST_STATIC_CONSTANT(bool, value =
          sizeof(bd_helper<B,D>::check_sig(Host(), 0)) == sizeof(type_traits::yes_type));
  #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
  #pragma warning(pop)
  #endif
  };
  
  #else
  
  //
  // broken version:
  //
  template<typename B, typename D>
  struct is_base_and_derived_impl2
  {
      BOOST_STATIC_CONSTANT(bool, value =
          (::boost::is_convertible<D*,B*>::value));
  };
  
  #define BOOST_BROKEN_IS_BASE_AND_DERIVED
  
  #endif
  
  template <typename B, typename D>
  struct is_base_and_derived_impl3
  {
      BOOST_STATIC_CONSTANT(bool, value = false);
  };
  
  template <bool ic1, bool ic2, bool iss>
  struct is_base_and_derived_select
  {
     template <class T, class U>
     struct rebind
     {
        typedef is_base_and_derived_impl3<T,U> type;
     };
  };
  
  template <>
  struct is_base_and_derived_select<true,true,false>
  {
     template <class T, class U>
     struct rebind
     {
        typedef is_base_and_derived_impl2<T,U> type;
     };
  };
  
  template <typename B, typename D>
  struct is_base_and_derived_impl
  {
      typedef typename remove_cv<B>::type ncvB;
      typedef typename remove_cv<D>::type ncvD;
  
      typedef is_base_and_derived_select<
         ::boost::is_class<B>::value,
         ::boost::is_class<D>::value,
         ::boost::is_same<ncvB,ncvD>::value> selector;
      typedef typename selector::template rebind<ncvB,ncvD> binder;
      typedef typename binder::type bound_type;
  
      BOOST_STATIC_CONSTANT(bool, value = bound_type::value);
  };
  #else
  template <typename B, typename D>
  struct is_base_and_derived_impl
  {
      typedef typename remove_cv<B>::type ncvB;
      typedef typename remove_cv<D>::type ncvD;
  
      BOOST_STATIC_CONSTANT(bool, value = (BOOST_IS_BASE_OF(B,D) && ! ::boost::is_same<ncvB,ncvD>::value));
  };
  #endif
  } // namespace detail
  
  template <class Base, class Derived> struct is_base_and_derived
     : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};
  
  template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
  template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
  template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
  
  #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
  template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
  #endif
  
  } // namespace boost
  
  #endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
  