@swiftbrowser/wasm-sdk-cxx 0.0.0-stage → 0.9.1

package/wasm32-unknown-wasip1/WASI.sdk/include/c++/v1/__ranges/size.h

@@ -0,0 +1,138 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_SIZE_H
+#define _LIBCPP___RANGES_SIZE_H
+
+#include <__concepts/arithmetic.h>
+#include <__concepts/class_or_enum.h>
+#include <__config>
+#include <__cstddef/ptrdiff_t.h>
+#include <__cstddef/size_t.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/make_signed.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/auto_cast.h>
+#include <__utility/declval.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+template <class>
+inline constexpr bool disable_sized_range = false;
+} // namespace ranges
+
+// [range.prim.size]
+
+namespace ranges {
+namespace __size {
+void size() = delete;
+
+template <class _Tp>
+concept __size_enabled = !disable_sized_range<remove_cvref_t<_Tp>>;
+
+template <class _Tp>
+concept __member_size = __size_enabled<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
+};
+
+template <class _Tp>
+concept __unqualified_size =
+    __size_enabled<_Tp> && !__member_size<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
+    };
+
+template <class _Tp>
+concept __difference =
+    !__member_size<_Tp> && !__unqualified_size<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { ranges::begin(__t) } -> forward_iterator;
+      { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(std::declval<_Tp>()))>;
+    };
+
+struct __fn {
+  // `[range.prim.size]`: the array case (for rvalues).
+  template <class _Tp, size_t _Sz>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
+    return _Sz;
+  }
+
+  // `[range.prim.size]`: the array case (for lvalues).
+  template <class _Tp, size_t _Sz>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
+    return _Sz;
+  }
+
+  // `[range.prim.size]`: `auto(t.size())` is a valid expression.
+  template <__member_size _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.size()))) {
+    return _LIBCPP_AUTO_CAST(__t.size());
+  }
+
+  // `[range.prim.size]`: `auto(size(t))` is a valid expression.
+  template <__unqualified_size _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(size(__t)))) {
+    return _LIBCPP_AUTO_CAST(size(__t));
+  }
+
+  // [range.prim.size]: the `to-unsigned-like` case.
+  template <__difference _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
+          -> decltype(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))) {
+    return std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
+  }
+};
+
+} // namespace __size
+
+inline namespace __cpo {
+inline constexpr auto size = __size::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+// [range.prim.ssize]
+
+namespace ranges {
+namespace __ssize {
+struct __fn {
+  template <class _Tp>
+    requires requires(_Tp&& __t) { ranges::size(__t); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::size(__t))) {
+    using _Signed = make_signed_t<decltype(ranges::size(__t))>;
+    if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
+      return static_cast<ptrdiff_t>(ranges::size(__t));
+    else
+      return static_cast<_Signed>(ranges::size(__t));
+  }
+};
+} // namespace __ssize
+
+inline namespace __cpo {
+inline constexpr auto ssize = __ssize::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_SIZE_H

package/wasm32-unknown-wasip1/WASI.sdk/include/c++/v1/__ranges/split_view.h

@@ -0,0 +1,232 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_SPLIT_VIEW_H
+#define _LIBCPP___RANGES_SPLIT_VIEW_H
+
+#include <__algorithm/ranges_search.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/empty.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/single_view.h>
+#include <__ranges/subrange.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <forward_range _View, forward_range _Pattern>
+  requires view<_View> && view<_Pattern> &&
+           indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to>
+class split_view : public view_interface<split_view<_View, _Pattern>> {
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_       = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Pattern __pattern_ = _Pattern();
+  using _Cache _LIBCPP_NODEBUG                  = __non_propagating_cache<subrange<iterator_t<_View>>>;
+  _Cache __cached_begin_                        = _Cache();
+
+  template <class, class>
+  friend struct __iterator;
+
+  template <class, class>
+  friend struct __sentinel;
+
+  struct __iterator;
+  struct __sentinel;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange<iterator_t<_View>> __find_next(iterator_t<_View> __it) {
+    auto [__begin, __end] = ranges::search(subrange(__it, ranges::end(__base_)), __pattern_);
+    if (__begin != ranges::end(__base_) && ranges::empty(__pattern_)) {
+      ++__begin;
+      ++__end;
+    }
+    return {__begin, __end};
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI split_view()
+    requires default_initializable<_View> && default_initializable<_Pattern>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 split_view(_View __base, _Pattern __pattern)
+      : __base_(std::move(__base)), __pattern_(std::move((__pattern))) {}
+
+  template <forward_range _Range>
+    requires constructible_from<_View, views::all_t<_Range>> &&
+                 constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  split_view(_Range&& __range, range_value_t<_Range> __elem)
+      : __base_(views::all(std::forward<_Range>(__range))), __pattern_(views::single(std::move(__elem))) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
+    if (!__cached_begin_.__has_value()) {
+      __cached_begin_.__emplace(__find_next(ranges::begin(__base_)));
+    }
+    return {*this, ranges::begin(__base_), *__cached_begin_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (common_range<_View>) {
+      return __iterator{*this, ranges::end(__base_), {}};
+    } else {
+      return __sentinel{*this};
+    }
+  }
+};
+
+template <class _Range, class _Pattern>
+split_view(_Range&&, _Pattern&&) -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
+
+template <forward_range _Range>
+split_view(_Range&&, range_value_t<_Range>) -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
+
+template <forward_range _View, forward_range _Pattern>
+  requires view<_View> && view<_Pattern> &&
+           indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to>
+struct split_view<_View, _Pattern>::__iterator {
+private:
+  split_view* __parent_                                         = nullptr;
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __cur_            = iterator_t<_View>();
+  _LIBCPP_NO_UNIQUE_ADDRESS subrange<iterator_t<_View>> __next_ = subrange<iterator_t<_View>>();
+  bool __trailing_empty_                                        = false;
+
+  friend struct __sentinel;
+
+public:
+  using iterator_concept  = forward_iterator_tag;
+  using iterator_category = input_iterator_tag;
+  using value_type        = subrange<iterator_t<_View>>;
+  using difference_type   = range_difference_t<_View>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(
+      split_view<_View, _Pattern>& __parent, iterator_t<_View> __current, subrange<iterator_t<_View>> __next)
+      : __parent_(std::addressof(__parent)), __cur_(std::move(__current)), __next_(std::move(__next)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> base() const { return __cur_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const { return {__cur_, __next_.begin()}; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    __cur_ = __next_.begin();
+    if (__cur_ != ranges::end(__parent_->__base_)) {
+      __cur_ = __next_.end();
+      if (__cur_ == ranges::end(__parent_->__base_)) {
+        __trailing_empty_ = true;
+        __next_           = {__cur_, __cur_};
+      } else {
+        __next_ = __parent_->__find_next(__cur_);
+      }
+    } else {
+      __trailing_empty_ = false;
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+    return __x.__cur_ == __y.__cur_ && __x.__trailing_empty_ == __y.__trailing_empty_;
+  }
+};
+
+template <forward_range _View, forward_range _Pattern>
+  requires view<_View> && view<_Pattern> &&
+           indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to>
+struct split_view<_View, _Pattern>::__sentinel {
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_View> __end_ = sentinel_t<_View>();
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __equals(const __iterator& __x, const __sentinel& __y) {
+    return __x.__cur_ == __y.__end_ && !__x.__trailing_empty_;
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(split_view<_View, _Pattern>& __parent)
+      : __end_(ranges::end(__parent.__base_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
+    return __equals(__x, __y);
+  }
+};
+
+namespace views {
+namespace __split_view {
+struct __fn {
+  // clang-format off
+  template <class _Range, class _Pattern>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
+    noexcept(noexcept(split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
+    -> decltype(      split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
+    { return          split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)); }
+  // clang-format on
+
+  template <class _Pattern>
+    requires constructible_from<decay_t<_Pattern>, _Pattern>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
+    return __pipeable(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
+  }
+};
+} // namespace __split_view
+
+inline namespace __cpo {
+inline constexpr auto split = __split_view::__fn{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_SPLIT_VIEW_H

package/wasm32-unknown-wasip1/WASI.sdk/include/c++/v1/__ranges/subrange.h

@@ -0,0 +1,274 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_SUBRANGE_H
+#define _LIBCPP___RANGES_SUBRANGE_H
+
+#include <__assert>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/copyable.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/different_from.h>
+#include <__config>
+#include <__cstddef/size_t.h>
+#include <__fwd/subrange.h>
+#include <__iterator/advance.h>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__tuple/tuple_element.h>
+#include <__tuple/tuple_like_no_subrange.h>
+#include <__tuple/tuple_size.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/remove_pointer.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+template <class _From, class _To>
+concept __uses_nonqualification_pointer_conversion =
+    is_pointer_v<_From> && is_pointer_v<_To> &&
+    !convertible_to<remove_pointer_t<_From> (*)[], remove_pointer_t<_To> (*)[]>;
+
+template <class _From, class _To>
+concept __convertible_to_non_slicing =
+    convertible_to<_From, _To> && !__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
+
+template <class _Pair, class _Iter, class _Sent>
+concept __pair_like_convertible_from =
+    !range<_Pair> && __pair_like_no_subrange<_Pair> && constructible_from<_Pair, _Iter, _Sent> &&
+    __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> && convertible_to<_Sent, tuple_element_t<1, _Pair>>;
+
+template <input_or_output_iterator _Iter,
+          sentinel_for<_Iter> _Sent = _Iter,
+          subrange_kind _Kind       = sized_sentinel_for<_Sent, _Iter> ? subrange_kind::sized : subrange_kind::unsized>
+  requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+class subrange : public view_interface<subrange<_Iter, _Sent, _Kind>> {
+public:
+  // Note: this is an internal implementation detail that is public only for internal usage.
+  static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
+
+private:
+  static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
+  struct _Empty {
+    _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept {}
+  };
+  using _Size _LIBCPP_NODEBUG = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_   = _Sent();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Size __size_  = 0;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI subrange()
+    requires default_initializable<_Iter>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
+    requires _MustProvideSizeAtConstruction
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange(
+      __convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent, make_unsigned_t<iter_difference_t<_Iter>> __n)
+    requires(_Kind == subrange_kind::sized)
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)), __size_(__n) {
+    if constexpr (sized_sentinel_for<_Sent, _Iter>)
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS((__end_ - __begin_) == static_cast<iter_difference_t<_Iter>>(__n),
+                                          "std::ranges::subrange was passed an invalid size hint");
+  }
+
+  template <__different_from<subrange> _Range>
+    requires borrowed_range<_Range> && __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range)
+               requires(!_StoreSize)
+      : subrange(ranges::begin(__range), ranges::end(__range)) {}
+
+  template <__different_from<subrange> _Range>
+    requires borrowed_range<_Range> && __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range)
+               requires _StoreSize && sized_range<_Range>
+      : subrange(__range, ranges::size(__range)) {}
+
+  template <borrowed_range _Range>
+    requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
+               requires(_Kind == subrange_kind::sized)
+      : subrange(ranges::begin(__range), ranges::end(__range), __n) {}
+
+  template <__pair_like_convertible_from<const _Iter&, const _Sent&> _Pair>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator _Pair() const {
+    return _Pair(__begin_, __end_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() const
+    requires copyable<_Iter>
+  {
+    return __begin_;
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin()
+    requires(!copyable<_Iter>)
+  {
+    return std::move(__begin_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Sent end() const { return __end_; }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return __begin_ == __end_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
+    requires(_Kind == subrange_kind::sized)
+  {
+    if constexpr (_StoreSize)
+      return __size_;
+    else
+      return std::__to_unsigned_like(__end_ - __begin_);
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
+    requires forward_iterator<_Iter>
+  {
+    auto __tmp = *this;
+    __tmp.advance(__n);
+    return __tmp;
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
+    advance(__n);
+    return std::move(*this);
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
+    requires bidirectional_iterator<_Iter>
+  {
+    auto __tmp = *this;
+    __tmp.advance(-__n);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange& advance(iter_difference_t<_Iter> __n) {
+    if constexpr (bidirectional_iterator<_Iter>) {
+      if (__n < 0) {
+        ranges::advance(__begin_, __n);
+        if constexpr (_StoreSize)
+          __size_ += std::__to_unsigned_like(-__n);
+        return *this;
+      }
+    }
+
+    auto __d = __n - ranges::advance(__begin_, __n, __end_);
+    if constexpr (_StoreSize)
+      __size_ -= std::__to_unsigned_like(__d);
+    return *this;
+  }
+};
+
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
+
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>) -> subrange<_Iter, _Sent, subrange_kind::sized>;
+
+template <borrowed_range _Range>
+subrange(_Range&&) -> subrange<iterator_t<_Range>,
+                               sentinel_t<_Range>,
+                               (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
+                                   ? subrange_kind::sized
+                                   : subrange_kind::unsized>;
+
+template <borrowed_range _Range>
+subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>)
+    -> subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
+  if constexpr (_Index == 0)
+    return __subrange.begin();
+  else
+    return __subrange.end();
+}
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires(_Index < 2)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
+  if constexpr (_Index == 0)
+    return __subrange.begin();
+  else
+    return __subrange.end();
+}
+
+template <class _Ip, class _Sp, subrange_kind _Kp>
+inline constexpr bool enable_borrowed_range<subrange<_Ip, _Sp, _Kp>> = true;
+
+template <range _Rp>
+using borrowed_subrange_t = _If<borrowed_range<_Rp>, subrange<iterator_t<_Rp>>, dangling>;
+} // namespace ranges
+
+// [range.subrange.general]
+
+using ranges::get;
+
+// [ranges.syn]
+
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct tuple_size<ranges::subrange<_Ip, _Sp, _Kp>> : integral_constant<size_t, 2> {};
+
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct tuple_element<0, ranges::subrange<_Ip, _Sp, _Kp>> {
+  using type _LIBCPP_NODEBUG = _Ip;
+};
+
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct tuple_element<1, ranges::subrange<_Ip, _Sp, _Kp>> {
+  using type _LIBCPP_NODEBUG = _Sp;
+};
+
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct tuple_element<0, const ranges::subrange<_Ip, _Sp, _Kp>> {
+  using type _LIBCPP_NODEBUG = _Ip;
+};
+
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct tuple_element<1, const ranges::subrange<_Ip, _Sp, _Kp>> {
+  using type _LIBCPP_NODEBUG = _Sp;
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_SUBRANGE_H