@crossbind/bridge-tools 0.0.0-stage → 2.0.0-beta.72

package/dist/emscripten/include/c++/v1/__iterator/insert_iterator.h

@@ -0,0 +1,89 @@
+// -*- 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___ITERATOR_INSERT_ITERATOR_H
+#define _LIBCPP___ITERATOR_INSERT_ITERATOR_H
+
+#include <__config>
+#include <__cstddef/ptrdiff_t.h>
+#include <__iterator/iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.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
+template <class _Container>
+using __insert_iterator_iter_t _LIBCPP_NODEBUG = ranges::iterator_t<_Container>;
+#else
+template <class _Container>
+using __insert_iterator_iter_t _LIBCPP_NODEBUG = typename _Container::iterator;
+#endif
+
+template <class _Container>
+class insert_iterator
+    : public __iterator_base<insert_iterator<_Container>, output_iterator_tag, void, void, void, void> {
+protected:
+  _Container* container;
+  __insert_iterator_iter_t<_Container> iter;
+
+public:
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
+#if _LIBCPP_STD_VER >= 20
+  typedef ptrdiff_t difference_type;
+#else
+  typedef void difference_type;
+#endif
+  typedef void pointer;
+  typedef void reference;
+  typedef _Container container_type;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
+      : container(std::addressof(__x)), iter(__i) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator&
+  operator=(const typename _Container::value_type& __value) {
+    iter = container->insert(iter, __value);
+    ++iter;
+    return *this;
+  }
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator&
+  operator=(typename _Container::value_type&& __value) {
+    iter = container->insert(iter, std::move(__value));
+    ++iter;
+    return *this;
+  }
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator++() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator++(int) { return *this; }
+};
+
+template <class _Container>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator<_Container>
+inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i) {
+  return insert_iterator<_Container>(__x, __i);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ITERATOR_INSERT_ITERATOR_H

package/dist/emscripten/include/c++/v1/__iterator/istream_iterator.h

@@ -0,0 +1,103 @@
+// -*- 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___ITERATOR_ISTREAM_ITERATOR_H
+#define _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H
+
+#include <__config>
+#include <__cstddef/ptrdiff_t.h>
+#include <__fwd/istream.h>
+#include <__fwd/string.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
+class istream_iterator
+    : public __iterator_base<istream_iterator<_Tp, _CharT, _Traits, _Distance>,
+                             input_iterator_tag,
+                             _Tp,
+                             _Distance,
+                             const _Tp*,
+                             const _Tp&> {
+public:
+  typedef input_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef _Distance difference_type;
+  typedef const _Tp* pointer;
+  typedef const _Tp& reference;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef basic_istream<_CharT, _Traits> istream_type;
+
+private:
+  istream_type* __in_stream_;
+  _Tp __value_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {}
+#endif // _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI istream_iterator(istream_type& __s) : __in_stream_(std::addressof(__s)) {
+    if (!(*__in_stream_ >> __value_))
+      __in_stream_ = nullptr;
+  }
+
+  // LWG3600 Changed the wording of the copy constructor. In libc++ this constructor
+  // can still be trivial after this change.
+
+  _LIBCPP_HIDE_FROM_ABI const _Tp& operator*() const { return __value_; }
+  _LIBCPP_HIDE_FROM_ABI const _Tp* operator->() const { return std::addressof((operator*())); }
+  _LIBCPP_HIDE_FROM_ABI istream_iterator& operator++() {
+    if (!(*__in_stream_ >> __value_))
+      __in_stream_ = nullptr;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI istream_iterator operator++(int) {
+    istream_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
+
+  template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
+                                               const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
+
+#if _LIBCPP_STD_VER >= 20
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) {
+    return __i.__in_stream_ == nullptr;
+  }
+#endif // _LIBCPP_STD_VER >= 20
+};
+
+template <class _Tp, class _CharT, class _Traits, class _Distance>
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
+                                             const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y) {
+  return __x.__in_stream_ == __y.__in_stream_;
+}
+
+#if _LIBCPP_STD_VER <= 17
+template <class _Tp, class _CharT, class _Traits, class _Distance>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
+                                             const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y) {
+  return !(__x == __y);
+}
+#endif // _LIBCPP_STD_VER <= 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H

package/dist/emscripten/include/c++/v1/__iterator/istreambuf_iterator.h

@@ -0,0 +1,110 @@
+// -*- 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___ITERATOR_ISTREAMBUF_ITERATOR_H
+#define _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H
+
+#include <__config>
+#include <__fwd/istream.h>
+#include <__fwd/streambuf.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__string/char_traits.h>
+#include <iosfwd>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _CharT, class _Traits>
+class istreambuf_iterator
+    : public __iterator_base<istreambuf_iterator<_CharT, _Traits>,
+                             input_iterator_tag,
+                             _CharT,
+                             typename _Traits::off_type,
+                             _CharT*,
+                             _CharT> {
+public:
+  typedef input_iterator_tag iterator_category;
+  typedef _CharT value_type;
+  typedef typename _Traits::off_type difference_type;
+  typedef _CharT* pointer;
+  typedef _CharT reference;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename _Traits::int_type int_type;
+  typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+  typedef basic_istream<_CharT, _Traits> istream_type;
+
+private:
+  mutable streambuf_type* __sbuf_;
+
+  class __proxy {
+    char_type __keep_;
+    streambuf_type* __sbuf_;
+    _LIBCPP_HIDE_FROM_ABI explicit __proxy(char_type __c, streambuf_type* __s) : __keep_(__c), __sbuf_(__s) {}
+    friend class istreambuf_iterator;
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI char_type operator*() const { return __keep_; }
+  };
+
+  _LIBCPP_HIDE_FROM_ABI bool __test_for_eof() const {
+    if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
+      __sbuf_ = nullptr;
+    return __sbuf_ == nullptr;
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI constexpr istreambuf_iterator(default_sentinel_t) noexcept : istreambuf_iterator() {}
+#endif // _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator(istream_type& __s) _NOEXCEPT : __sbuf_(__s.rdbuf()) {}
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator(streambuf_type* __s) _NOEXCEPT : __sbuf_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator(const __proxy& __p) _NOEXCEPT : __sbuf_(__p.__sbuf_) {}
+
+  _LIBCPP_HIDE_FROM_ABI char_type operator*() const { return static_cast<char_type>(__sbuf_->sgetc()); }
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator& operator++() {
+    __sbuf_->sbumpc();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __proxy operator++(int) { return __proxy(__sbuf_->sbumpc(), __sbuf_); }
+
+  _LIBCPP_HIDE_FROM_ABI bool equal(const istreambuf_iterator& __b) const {
+    return __test_for_eof() == __b.__test_for_eof();
+  }
+
+#if _LIBCPP_STD_VER >= 20
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t) {
+    return __i.__test_for_eof();
+  }
+#endif // _LIBCPP_STD_VER >= 20
+};
+
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) {
+  return __a.equal(__b);
+}
+
+#if _LIBCPP_STD_VER <= 17
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) {
+  return !__a.equal(__b);
+}
+#endif // _LIBCPP_STD_VER <= 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H

package/dist/emscripten/include/c++/v1/__iterator/iter_move.h

@@ -0,0 +1,104 @@
+// -*- 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___ITERATOR_ITER_MOVE_H
+#define _LIBCPP___ITERATOR_ITER_MOVE_H
+
+#include <__concepts/class_or_enum.h>
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_referenceable.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/declval.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
+
+// [iterator.cust.move]
+
+namespace ranges {
+namespace __iter_move {
+
+void iter_move() = delete;
+
+template <class _Tp>
+concept __unqualified_iter_move = __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+  // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_move ADL calls should only be made through ranges::iter_move
+  iter_move(std::forward<_Tp>(__t));
+};
+
+template <class _Tp>
+concept __move_deref = !__unqualified_iter_move<_Tp> && requires(_Tp&& __t) {
+  *__t;
+  requires is_lvalue_reference_v<decltype(*__t)>;
+};
+
+template <class _Tp>
+concept __just_deref = !__unqualified_iter_move<_Tp> && !__move_deref<_Tp> && requires(_Tp&& __t) {
+  *__t;
+  requires(!is_lvalue_reference_v<decltype(*__t)>);
+};
+
+// [iterator.cust.move]
+
+struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) iter_move ADL calls should only be made through ranges::iter_move
+  template <class _Ip>
+    requires __unqualified_iter_move<_Ip>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
+      noexcept(noexcept(iter_move(std::forward<_Ip>(__i)))) {
+    return iter_move(std::forward<_Ip>(__i));
+  }
+  // NOLINTEND(libcpp-robust-against-adl)
+
+  template <class _Ip>
+    requires __move_deref<_Ip>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
+      noexcept(noexcept(std::move(*std::forward<_Ip>(__i)))) -> decltype(std::move(*std::forward<_Ip>(__i))) {
+    return std::move(*std::forward<_Ip>(__i));
+  }
+
+  template <class _Ip>
+    requires __just_deref<_Ip>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
+      noexcept(noexcept(*std::forward<_Ip>(__i))) -> decltype(*std::forward<_Ip>(__i)) {
+    return *std::forward<_Ip>(__i);
+  }
+};
+} // namespace __iter_move
+
+inline namespace __cpo {
+inline constexpr auto iter_move = __iter_move::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+template <__dereferenceable _Tp>
+  requires requires(_Tp& __t) {
+    { ranges::iter_move(__t) } -> __referenceable;
+  }
+using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<_Tp&>()));
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ITERATOR_ITER_MOVE_H

package/dist/emscripten/include/c++/v1/__iterator/iter_swap.h

@@ -0,0 +1,108 @@
+// -*- 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___ITERATOR_ITER_SWAP_H
+#define _LIBCPP___ITERATOR_ITER_SWAP_H
+
+#include <__concepts/class_or_enum.h>
+#include <__concepts/swappable.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/readable_traits.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/declval.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
+
+// [iter.cust.swap]
+
+namespace ranges {
+namespace __iter_swap {
+template <class _I1, class _I2>
+void iter_swap(_I1, _I2) = delete;
+
+template <class _T1, class _T2>
+concept __unqualified_iter_swap =
+    (__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>) && requires(_T1&& __x, _T2&& __y) {
+      // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
+      iter_swap(std::forward<_T1>(__x), std::forward<_T2>(__y));
+    };
+
+template <class _T1, class _T2>
+concept __readable_swappable =
+    indirectly_readable<_T1> && indirectly_readable<_T2> &&
+    swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
+
+struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
+  template <class _T1, class _T2>
+    requires __unqualified_iter_swap<_T1, _T2>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_T1&& __x, _T2&& __y) const
+      noexcept(noexcept(iter_swap(std::forward<_T1>(__x), std::forward<_T2>(__y)))) {
+    (void)iter_swap(std::forward<_T1>(__x), std::forward<_T2>(__y));
+  }
+  // NOLINTEND(libcpp-robust-against-adl)
+
+  template <class _T1, class _T2>
+    requires(!__unqualified_iter_swap<_T1, _T2>) && __readable_swappable<_T1, _T2>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_T1&& __x, _T2&& __y) const
+      noexcept(noexcept(ranges::swap(*std::forward<_T1>(__x), *std::forward<_T2>(__y)))) {
+    ranges::swap(*std::forward<_T1>(__x), *std::forward<_T2>(__y));
+  }
+
+  template <class _T1, class _T2>
+    requires(!__unqualified_iter_swap<_T1, _T2> &&   //
+             !__readable_swappable<_T1, _T2>) &&     //
+            indirectly_movable_storable<_T1, _T2> && //
+            indirectly_movable_storable<_T2, _T1>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_T1&& __x, _T2&& __y) const
+      noexcept(noexcept(iter_value_t<_T2>(ranges::iter_move(__y))) && //
+               noexcept(*__y = ranges::iter_move(__x)) &&             //
+               noexcept(*std::forward<_T1>(__x) = std::declval<iter_value_t<_T2>>())) {
+    iter_value_t<_T2> __old(ranges::iter_move(__y));
+    *__y                    = ranges::iter_move(__x);
+    *std::forward<_T1>(__x) = std::move(__old);
+  }
+};
+} // namespace __iter_swap
+
+inline namespace __cpo {
+inline constexpr auto iter_swap = __iter_swap::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+template <class _I1, class _I2 = _I1>
+concept indirectly_swappable =
+    indirectly_readable<_I1> && indirectly_readable<_I2> && requires(const _I1 __i1, const _I2 __i2) {
+      ranges::iter_swap(__i1, __i1);
+      ranges::iter_swap(__i2, __i2);
+      ranges::iter_swap(__i1, __i2);
+      ranges::iter_swap(__i2, __i1);
+    };
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ITERATOR_ITER_SWAP_H

package/dist/emscripten/include/c++/v1/__iterator/iterator.h

@@ -0,0 +1,46 @@
+// -*- 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___ITERATOR_ITERATOR_H
+#define _LIBCPP___ITERATOR_ITERATOR_H
+
+#include <__config>
+#include <__cstddef/ptrdiff_t.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Category, class _Tp, class _Distance = ptrdiff_t, class _Pointer = _Tp*, class _Reference = _Tp&>
+struct _LIBCPP_DEPRECATED_IN_CXX17 iterator {
+  typedef _Tp value_type;
+  typedef _Distance difference_type;
+  typedef _Pointer pointer;
+  typedef _Reference reference;
+  typedef _Category iterator_category;
+};
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+#ifdef _LIBCPP_ABI_NO_ITERATOR_BASES
+template <class _Derived>
+struct __no_iterator_base {};
+
+template <class _Derived, class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
+using __iterator_base _LIBCPP_NODEBUG = __no_iterator_base<_Derived>;
+#else
+template <class _Derived, class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
+using __iterator_base _LIBCPP_NODEBUG = iterator<_Category, _Tp, _Distance, _Pointer, _Reference>;
+#endif
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_ITERATOR_H