react-native-windows 0.81.34 → 0.81.35

package/external/folly/folly/UTF8String.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <boost/regex/pending/unicode_iterator.hpp>
+
+#include <folly/Range.h>
+
+namespace folly {
+
+class UTF8StringPiece {
+ public:
+  using iterator = boost::u8_to_u32_iterator<const char*>;
+  using size_type = std::size_t;
+
+  /* implicit */ UTF8StringPiece(const folly::StringPiece piece)
+      : begin_{piece.begin(), piece.begin(), piece.end()},
+        end_{piece.end(), piece.begin(), piece.end()} {}
+  template <
+      typename T,
+      std::enable_if_t<std::is_convertible_v<T, folly::StringPiece>, int> = 0>
+  /* implicit */ UTF8StringPiece(const T& t)
+      : UTF8StringPiece(folly::StringPiece(t)) {}
+
+  iterator begin() const noexcept { return begin_; }
+  iterator cbegin() const noexcept { return begin_; }
+  iterator end() const noexcept { return end_; }
+  iterator cend() const noexcept { return end_; }
+
+  bool empty() const noexcept { return begin_ == end_; }
+  size_type walk_size() const {
+    return static_cast<size_type>(std::distance(begin_, end_));
+  }
+
+ private:
+  iterator begin_;
+  iterator end_;
+};
+
+} // namespace folly

package/external/folly/folly/Unicode.cpp

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Unicode.h>
+
+#include <initializer_list>
+
+#include <folly/Conv.h>
+
+namespace folly {
+
+namespace {
+
+template <class F>
+void codePointToUtf8Impl(char32_t cp, F&& f) {
+  // Based on description from http://en.wikipedia.org/wiki/UTF-8.
+
+  if (cp <= 0x7f) {
+    f({
+        static_cast<char>(cp),
+    });
+  } else if (cp <= 0x7FF) {
+    f({
+        static_cast<char>(0xC0 | (cp >> 6)),
+        static_cast<char>(0x80 | (0x3f & cp)),
+    });
+  } else if (cp <= 0xFFFF) {
+    f({
+        static_cast<char>(0xE0 | (cp >> 12)),
+        static_cast<char>(0x80 | (0x3f & (cp >> 6))),
+        static_cast<char>(0x80 | (0x3f & cp)),
+    });
+  } else if (cp <= 0x10FFFF) {
+    f({
+        static_cast<char>(0xF0 | (cp >> 18)),
+        static_cast<char>(0x80 | (0x3f & (cp >> 12))),
+        static_cast<char>(0x80 | (0x3f & (cp >> 6))),
+        static_cast<char>(0x80 | (0x3f & cp)),
+    });
+  }
+}
+
+} // namespace
+
+std::string codePointToUtf8(char32_t cp) {
+  std::string result;
+  codePointToUtf8Impl(cp, [&](std::initializer_list<char> data) {
+    result.assign(data.begin(), data.end());
+  });
+  return result;
+}
+
+void appendCodePointToUtf8(char32_t cp, std::string& out) {
+  codePointToUtf8Impl(cp, [&](std::initializer_list<char> data) {
+    out.append(data.begin(), data.end());
+  });
+}
+
+char32_t utf8ToCodePoint(
+    const unsigned char*& p, const unsigned char* const e, bool skipOnError) {
+  // clang-format off
+  /** UTF encodings
+  *  | # of B | First CP |  Last CP  | Bit Pattern
+  *  |   1    |   0x0000 |   0x007F  | 0xxxxxxx
+  *  |   2    |   0x0080 |   0x07FF  | 110xxxxx 10xxxxxx
+  *  |   3    |   0x0800 |   0xFFFF  | 1110xxxx 10xxxxxx 10xxxxxx
+  *  |   4    |  0x10000 | 0x10FFFF  | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+  *  |   5    |       -  |        -  | 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+  *  |   6    |       -  |        -  | 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+  *
+  *
+  * NOTE:
+  * - the 4B encoding can encode values up to 0x1FFFFF,
+  *   but Unicode defines 0x10FFFF to be the largest code point
+  * - the 5B & 6B encodings will all encode values larger than 0x1FFFFF
+  *   (so larger than the largest code point value 0x10FFFF) so they form invalid
+  *   Unicode code points
+  *
+  * On invalid input (invalid encoding or code points larger than 0x10FFFF):
+  * - When skipOnError is true, this function will skip the first byte and return
+  *   U'\ufffd'. Potential optimization: skip the whole invalid range.
+  * - When skipOnError is false, throws.
+  */
+  // clang-format on
+
+  const auto skip = [&] {
+    ++p;
+    return U'\ufffd';
+  };
+
+  if (p >= e) {
+    if (skipOnError) {
+      return skip();
+    }
+    throw std::runtime_error("folly::utf8ToCodePoint empty/invalid string");
+  }
+
+  unsigned char fst = *p;
+  if (!(fst & 0x80)) {
+    // trivial case, 1 byte encoding
+    return *p++;
+  }
+
+  static const uint32_t bitMask[] = {
+      (1 << 7) - 1,
+      (1 << 11) - 1,
+      (1 << 16) - 1,
+      (1 << 21) - 1,
+  };
+
+  // upper control bits are masked out later
+  uint32_t d = fst;
+
+  // multi-byte encoded values must start with bits 0b11. 0xC0 is 0b11000000
+  if ((fst & 0xC0) != 0xC0) {
+    if (skipOnError) {
+      return skip();
+    }
+    throw std::runtime_error(
+        to<std::string>("folly::utf8ToCodePoint i=0 d=", d));
+  }
+
+  fst <<= 1;
+
+  for (unsigned int i = 1; i != 4 && p + i < e; ++i) {
+    const unsigned char tmp = p[i];
+
+    // from the second byte on, format should be 10xxxxxx
+    if ((tmp & 0xC0) != 0x80) {
+      if (skipOnError) {
+        return skip();
+      }
+      throw std::runtime_error(to<std::string>(
+          "folly::utf8ToCodePoint i=", i, " tmp=", (uint32_t)tmp));
+    }
+
+    // gradually fill a 32 bit integer d with non control bits in tmp
+    // 0x3F is 0b00111111 which clears out the first 2 control bits
+    d = (d << 6) | (tmp & 0x3F);
+    fst <<= 1;
+
+    if (!(fst & 0x80)) {
+      // We know the length of encoding now, since we encounter the first "0" in
+      // fst (the first byte). This branch processes the last byte of encoding.
+      d &= bitMask[i]; // d is now the code point
+
+      // overlong, could have been encoded with i bytes
+      if ((d & ~bitMask[i - 1]) == 0) {
+        if (skipOnError) {
+          return skip();
+        }
+        throw std::runtime_error(
+            to<std::string>("folly::utf8ToCodePoint i=", i, " d=", d));
+      }
+
+      // check for surrogates only needed for 3 bytes
+      if (i == 2) {
+        if (d >= 0xD800 && d <= 0xDFFF) {
+          if (skipOnError) {
+            return skip();
+          }
+          throw std::runtime_error(
+              to<std::string>("folly::utf8ToCodePoint i=", i, " d=", d));
+        }
+      }
+
+      // While UTF-8 encoding can encode arbitrary numbers, 0x10FFFF is the
+      // largest defined Unicode code point.
+      // Only >=4 bytes can UTF-8 encode such values, so i=3 here.
+      if (d > 0x10FFFF) {
+        if (skipOnError) {
+          return skip();
+        }
+        throw std::runtime_error(
+            "folly::utf8ToCodePoint encoding exceeds max unicode code point");
+      }
+      p += i + 1;
+      return d;
+    }
+  }
+
+  if (skipOnError) {
+    return skip();
+  }
+  throw std::runtime_error("folly::utf8ToCodePoint encoding length maxed out");
+}
+
+} // namespace folly

package/external/folly/folly/Unicode.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Some utility routines relating to Unicode.
+
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+#include <folly/lang/Exception.h>
+
+namespace folly {
+
+class FOLLY_EXPORT unicode_error : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+//  Unicode code points are split into 17 planes.
+//
+//  The Basic Multilingual Plane covers code points in [0-0xFFFF] but reserves
+//  two invalid ranges:
+//  - High surrogates: [0xD800-0xDBFF].
+//  - Low surrogates: [0xDC00-0xDFFF].
+//
+//  UTF-16 code units are 2 bytes wide and are represented here with char16_t.
+//  Unicode code points are represented in UTF-16 across either 1-2 code units:
+//  - Valid BMP code points [0x0000-0xD7FF] + [0xE000-0xFFFF] are encoded
+//    directly as 1 code unit.
+//  - Code points larger than BMP (>0xFFFF) are encoded as 2 code units, with
+//    values respectively in the high surrogates and low surrogates ranges.
+//
+//  JSON text permits the inclusion of Unicode escape sequences within quoted
+//  strings:
+//  - Valid BMP code points are encoded as \xXXXX, where XXXX are the base-16
+//    digits of the code point.
+//  - Code points larger than BMP are encoded as \uHHHH\uLLLL, where HHHH and
+//    LLLL are respectively the base-16 digits of the high and low surrogates of
+//    the UTF-16 encoding of the code point.
+
+inline bool utf16_code_unit_is_bmp(char16_t const c) {
+  return c < 0xd800 || c >= 0xe000;
+}
+inline bool utf16_code_unit_is_high_surrogate(char16_t const c) {
+  return c >= 0xd800 && c < 0xdc00;
+}
+inline bool utf16_code_unit_is_low_surrogate(char16_t const c) {
+  return c >= 0xdc00 && c < 0xe000;
+}
+inline char32_t unicode_code_point_from_utf16_surrogate_pair(
+    char16_t const high, char16_t const low) {
+  if (!utf16_code_unit_is_high_surrogate(high)) {
+    throw_exception<unicode_error>("invalid high surrogate");
+  }
+  if (!utf16_code_unit_is_low_surrogate(low)) {
+    throw_exception<unicode_error>("invalid low surrogate");
+  }
+  return 0x10000 + ((char32_t(high) & 0x3ff) << 10) + (char32_t(low) & 0x3ff);
+}
+
+//////////////////////////////////////////////////////////////////////
+
+/*
+ * Encode a single Unicode code point into a UTF-8 byte sequence.
+ *
+ * Result is undefined if `cp' is an invalid code point.
+ */
+std::string codePointToUtf8(char32_t cp);
+void appendCodePointToUtf8(char32_t cp, std::string& out);
+
+/*
+ * Decode a single Unicode code point from UTF-8 byte sequence.
+ */
+char32_t utf8ToCodePoint(
+    const unsigned char*& p, const unsigned char* const e, bool skipOnError);
+
+//////////////////////////////////////////////////////////////////////
+
+} // namespace folly

package/external/folly/folly/Unit.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace folly {
+
+/// In functional programming, the degenerate case is often called "unit". In
+/// C++, "void" is often the best analogue. However, because of the syntactic
+/// special-casing required for void, it is frequently a liability for template
+/// metaprogramming. So, instead of writing specializations to handle cases like
+/// SomeContainer<void>, a library author may instead rule that out and simply
+/// have library users use SomeContainer<Unit>. Contained values may be ignored.
+/// Much easier.
+///
+/// "void" is the type that admits of no values at all. It is not possible to
+/// construct a value of this type.
+/// "unit" is the type that admits of precisely one unique value. It is
+/// possible to construct a value of this type, but it is always the same value
+/// every time, so it is uninteresting.
+struct Unit {
+  constexpr bool operator==(const Unit& /*other*/) const { return true; }
+  constexpr bool operator!=(const Unit& /*other*/) const { return false; }
+};
+
+constexpr Unit unit{};
+
+template <typename T>
+struct lift_unit {
+  using type = T;
+};
+template <>
+struct lift_unit<void> {
+  using type = Unit;
+};
+template <typename T>
+using lift_unit_t = typename lift_unit<T>::type;
+
+template <typename T>
+struct drop_unit {
+  using type = T;
+};
+template <>
+struct drop_unit<Unit> {
+  using type = void;
+};
+template <typename T>
+using drop_unit_t = typename drop_unit<T>::type;
+
+} // namespace folly

package/external/folly/folly/Uri-inl.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FOLLY_URI_H_
+#error This file may only be included from folly/Uri.h
+#endif
+
+#include <functional>
+#include <tuple>
+
+#include <folly/Conv.h>
+#include <folly/hash/Hash.h>
+
+namespace folly {
+
+namespace uri_detail {
+
+using UriTuple = std::tuple<
+    const std::string&,
+    const std::string&,
+    const std::string&,
+    const std::string&,
+    uint16_t,
+    const std::string&,
+    const std::string&,
+    const std::string&>;
+
+inline UriTuple as_tuple(const folly::Uri& k) {
+  return UriTuple(
+      k.scheme(),
+      k.username(),
+      k.password(),
+      k.host(),
+      k.port(),
+      k.path(),
+      k.query(),
+      k.fragment());
+}
+
+} // namespace uri_detail
+
+template <class String>
+String Uri::toString() const {
+  String str;
+  if (hasAuthority_) {
+    toAppend(scheme_, "://", &str);
+    if (!password_.empty()) {
+      toAppend(username_, ":", password_, "@", &str);
+    } else if (!username_.empty()) {
+      toAppend(username_, "@", &str);
+    }
+    toAppend(host_, &str);
+    if (port_ != 0) {
+      toAppend(":", port_, &str);
+    }
+  } else {
+    toAppend(scheme_, ":", &str);
+  }
+  toAppend(path_, &str);
+  if (!query_.empty()) {
+    toAppend("?", query_, &str);
+  }
+  if (!fragment_.empty()) {
+    toAppend("#", fragment_, &str);
+  }
+  return str;
+}
+
+} // namespace folly
+
+namespace std {
+
+template <>
+struct hash<folly::Uri> {
+  std::size_t operator()(const folly::Uri& k) const {
+    return std::hash<folly::uri_detail::UriTuple>{}(
+        folly::uri_detail::as_tuple(k));
+  }
+};
+
+template <>
+struct equal_to<folly::Uri> {
+  bool operator()(const folly::Uri& a, const folly::Uri& b) const {
+    return folly::uri_detail::as_tuple(a) == folly::uri_detail::as_tuple(b);
+  }
+};
+
+} // namespace std