chore: add vendor directory

23 files changed, 11897 insertions, 0 deletions

diff --git a/vendor/indexmap/src/arbitrary.rs b/vendor/indexmap/src/arbitrary.rs
new file mode 100644
index 00000000..7798438c
--- /dev/null
+++ b/vendor/indexmap/src/arbitrary.rs
@@ -0,0 +1,77 @@
+#[cfg(feature = "arbitrary")]
+#[cfg_attr(docsrs, doc(cfg(feature = "arbitrary")))]
+mod impl_arbitrary {
+    use crate::{IndexMap, IndexSet};
+    use arbitrary::{Arbitrary, Result, Unstructured};
+    use core::hash::{BuildHasher, Hash};
+
+    impl<'a, K, V, S> Arbitrary<'a> for IndexMap<K, V, S>
+    where
+        K: Arbitrary<'a> + Hash + Eq,
+        V: Arbitrary<'a>,
+        S: BuildHasher + Default,
+    {
+        fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+            u.arbitrary_iter()?.collect()
+        }
+
+        fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+            u.arbitrary_take_rest_iter()?.collect()
+        }
+    }
+
+    impl<'a, T, S> Arbitrary<'a> for IndexSet<T, S>
+    where
+        T: Arbitrary<'a> + Hash + Eq,
+        S: BuildHasher + Default,
+    {
+        fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+            u.arbitrary_iter()?.collect()
+        }
+
+        fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+            u.arbitrary_take_rest_iter()?.collect()
+        }
+    }
+}
+
+#[cfg(feature = "quickcheck")]
+#[cfg_attr(docsrs, doc(cfg(feature = "quickcheck")))]
+mod impl_quickcheck {
+    use crate::{IndexMap, IndexSet};
+    use alloc::boxed::Box;
+    use alloc::vec::Vec;
+    use core::hash::{BuildHasher, Hash};
+    use quickcheck::{Arbitrary, Gen};
+
+    impl<K, V, S> Arbitrary for IndexMap<K, V, S>
+    where
+        K: Arbitrary + Hash + Eq,
+        V: Arbitrary,
+        S: BuildHasher + Default + Clone + 'static,
+    {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self::from_iter(Vec::arbitrary(g))
+        }
+
+        fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+            let vec = Vec::from_iter(self.clone());
+            Box::new(vec.shrink().map(Self::from_iter))
+        }
+    }
+
+    impl<T, S> Arbitrary for IndexSet<T, S>
+    where
+        T: Arbitrary + Hash + Eq,
+        S: BuildHasher + Default + Clone + 'static,
+    {
+        fn arbitrary(g: &mut Gen) -> Self {
+            Self::from_iter(Vec::arbitrary(g))
+        }
+
+        fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+            let vec = Vec::from_iter(self.clone());
+            Box::new(vec.shrink().map(Self::from_iter))
+        }
+    }
+}
diff --git a/vendor/indexmap/src/borsh.rs b/vendor/indexmap/src/borsh.rs
new file mode 100644
index 00000000..dfa45e73
--- /dev/null
+++ b/vendor/indexmap/src/borsh.rs
@@ -0,0 +1,128 @@
+#![cfg_attr(docsrs, doc(cfg(feature = "borsh")))]
+
+use alloc::vec::Vec;
+use core::hash::BuildHasher;
+use core::hash::Hash;
+use core::mem::size_of;
+
+use borsh::error::ERROR_ZST_FORBIDDEN;
+use borsh::io::{Error, ErrorKind, Read, Result, Write};
+use borsh::{BorshDeserialize, BorshSerialize};
+
+use crate::map::IndexMap;
+use crate::set::IndexSet;
+
+// NOTE: the real `#[deprecated]` attribute doesn't work for trait implementations,
+// but we can get close by mimicking the message style for documentation.
+/// <div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated: use borsh's <code>indexmap</code> feature instead.</span></div>
+impl<K, V, S> BorshSerialize for IndexMap<K, V, S>
+where
+    K: BorshSerialize,
+    V: BorshSerialize,
+{
+    #[inline]
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        check_zst::<K>()?;
+
+        let iterator = self.iter();
+
+        u32::try_from(iterator.len())
+            .map_err(|_| ErrorKind::InvalidData)?
+            .serialize(writer)?;
+
+        for (key, value) in iterator {
+            key.serialize(writer)?;
+            value.serialize(writer)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// <div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated: use borsh's <code>indexmap</code> feature instead.</span></div>
+impl<K, V, S> BorshDeserialize for IndexMap<K, V, S>
+where
+    K: BorshDeserialize + Eq + Hash,
+    V: BorshDeserialize,
+    S: BuildHasher + Default,
+{
+    #[inline]
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        check_zst::<K>()?;
+        let vec = <Vec<(K, V)>>::deserialize_reader(reader)?;
+        Ok(vec.into_iter().collect::<IndexMap<K, V, S>>())
+    }
+}
+
+/// <div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated: use borsh's <code>indexmap</code> feature instead.</span></div>
+impl<T, S> BorshSerialize for IndexSet<T, S>
+where
+    T: BorshSerialize,
+{
+    #[inline]
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        check_zst::<T>()?;
+
+        let iterator = self.iter();
+
+        u32::try_from(iterator.len())
+            .map_err(|_| ErrorKind::InvalidData)?
+            .serialize(writer)?;
+
+        for item in iterator {
+            item.serialize(writer)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// <div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated: use borsh's <code>indexmap</code> feature instead.</span></div>
+impl<T, S> BorshDeserialize for IndexSet<T, S>
+where
+    T: BorshDeserialize + Eq + Hash,
+    S: BuildHasher + Default,
+{
+    #[inline]
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        check_zst::<T>()?;
+        let vec = <Vec<T>>::deserialize_reader(reader)?;
+        Ok(vec.into_iter().collect::<IndexSet<T, S>>())
+    }
+}
+
+fn check_zst<T>() -> Result<()> {
+    if size_of::<T>() == 0 {
+        return Err(Error::new(ErrorKind::InvalidData, ERROR_ZST_FORBIDDEN));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod borsh_tests {
+    use super::*;
+
+    #[test]
+    fn map_borsh_roundtrip() {
+        let original_map: IndexMap<i32, i32> = {
+            let mut map = IndexMap::new();
+            map.insert(1, 2);
+            map.insert(3, 4);
+            map.insert(5, 6);
+            map
+        };
+        let serialized_map = borsh::to_vec(&original_map).unwrap();
+        let deserialized_map: IndexMap<i32, i32> =
+            BorshDeserialize::try_from_slice(&serialized_map).unwrap();
+        assert_eq!(original_map, deserialized_map);
+    }
+
+    #[test]
+    fn set_borsh_roundtrip() {
+        let original_map: IndexSet<i32> = [1, 2, 3, 4, 5, 6].into_iter().collect();
+        let serialized_map = borsh::to_vec(&original_map).unwrap();
+        let deserialized_map: IndexSet<i32> =
+            BorshDeserialize::try_from_slice(&serialized_map).unwrap();
+        assert_eq!(original_map, deserialized_map);
+    }
+}
diff --git a/vendor/indexmap/src/lib.rs b/vendor/indexmap/src/lib.rs
new file mode 100644
index 00000000..0458239c
--- /dev/null
+++ b/vendor/indexmap/src/lib.rs
@@ -0,0 +1,300 @@
+// We *mostly* avoid unsafe code, but `Slice` allows it for DST casting.
+#![deny(unsafe_code)]
+#![warn(rust_2018_idioms)]
+#![no_std]
+
+//! [`IndexMap`] is a hash table where the iteration order of the key-value
+//! pairs is independent of the hash values of the keys.
+//!
+//! [`IndexSet`] is a corresponding hash set using the same implementation and
+//! with similar properties.
+//!
+//! ### Highlights
+//!
+//! [`IndexMap`] and [`IndexSet`] are drop-in compatible with the std `HashMap`
+//! and `HashSet`, but they also have some features of note:
+//!
+//! - The ordering semantics (see their documentation for details)
+//! - Sorting methods and the [`.pop()`][IndexMap::pop] methods.
+//! - The [`Equivalent`] trait, which offers more flexible equality definitions
+//!   between borrowed and owned versions of keys.
+//! - The [`MutableKeys`][map::MutableKeys] trait, which gives opt-in mutable
+//!   access to map keys, and [`MutableValues`][set::MutableValues] for sets.
+//!
+//! ### Feature Flags
+//!
+//! To reduce the amount of compiled code in the crate by default, certain
+//! features are gated behind [feature flags]. These allow you to opt in to (or
+//! out of) functionality. Below is a list of the features available in this
+//! crate.
+//!
+//! * `std`: Enables features which require the Rust standard library. For more
+//!   information see the section on [`no_std`].
+//! * `rayon`: Enables parallel iteration and other parallel methods.
+//! * `serde`: Adds implementations for [`Serialize`] and [`Deserialize`]
+//!   to [`IndexMap`] and [`IndexSet`]. Alternative implementations for
+//!   (de)serializing [`IndexMap`] as an ordered sequence are available in the
+//!   [`map::serde_seq`] module.
+//! * `arbitrary`: Adds implementations for the [`arbitrary::Arbitrary`] trait
+//!   to [`IndexMap`] and [`IndexSet`].
+//! * `quickcheck`: Adds implementations for the [`quickcheck::Arbitrary`] trait
+//!   to [`IndexMap`] and [`IndexSet`].
+//! * `borsh` (**deprecated**): Adds implementations for [`BorshSerialize`] and
+//!   [`BorshDeserialize`] to [`IndexMap`] and [`IndexSet`]. Due to a cyclic
+//!   dependency that arose between [`borsh`] and `indexmap`, `borsh v1.5.6`
+//!   added an `indexmap` feature that should be used instead of enabling the
+//!   feature here.
+//!
+//! _Note: only the `std` feature is enabled by default._
+//!
+//! [feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section
+//! [`no_std`]: #no-standard-library-targets
+//! [`Serialize`]: `::serde::Serialize`
+//! [`Deserialize`]: `::serde::Deserialize`
+//! [`BorshSerialize`]: `::borsh::BorshSerialize`
+//! [`BorshDeserialize`]: `::borsh::BorshDeserialize`
+//! [`borsh`]: `::borsh`
+//! [`arbitrary::Arbitrary`]: `::arbitrary::Arbitrary`
+//! [`quickcheck::Arbitrary`]: `::quickcheck::Arbitrary`
+//!
+//! ### Alternate Hashers
+//!
+//! [`IndexMap`] and [`IndexSet`] have a default hasher type
+//! [`S = RandomState`][std::collections::hash_map::RandomState],
+//! just like the standard `HashMap` and `HashSet`, which is resistant to
+//! HashDoS attacks but not the most performant. Type aliases can make it easier
+//! to use alternate hashers:
+//!
+//! ```
+//! use fnv::FnvBuildHasher;
+//! use indexmap::{IndexMap, IndexSet};
+//!
+//! type FnvIndexMap<K, V> = IndexMap<K, V, FnvBuildHasher>;
+//! type FnvIndexSet<T> = IndexSet<T, FnvBuildHasher>;
+//!
+//! let std: IndexSet<i32> = (0..100).collect();
+//! let fnv: FnvIndexSet<i32> = (0..100).collect();
+//! assert_eq!(std, fnv);
+//! ```
+//!
+//! ### Rust Version
+//!
+//! This version of indexmap requires Rust 1.63 or later.
+//!
+//! The indexmap 2.x release series will use a carefully considered version
+//! upgrade policy, where in a later 2.x version, we will raise the minimum
+//! required Rust version.
+//!
+//! ## No Standard Library Targets
+//!
+//! This crate supports being built without `std`, requiring `alloc` instead.
+//! This is chosen by disabling the default "std" cargo feature, by adding
+//! `default-features = false` to your dependency specification.
+//!
+//! - Creating maps and sets using [`new`][IndexMap::new] and
+//!   [`with_capacity`][IndexMap::with_capacity] is unavailable without `std`.
+//!   Use methods [`IndexMap::default`], [`with_hasher`][IndexMap::with_hasher],
+//!   [`with_capacity_and_hasher`][IndexMap::with_capacity_and_hasher] instead.
+//!   A no-std compatible hasher will be needed as well, for example
+//!   from the crate `twox-hash`.
+//! - Macros [`indexmap!`] and [`indexset!`] are unavailable without `std`. Use
+//!   the macros [`indexmap_with_default!`] and [`indexset_with_default!`] instead.
+
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+
+use alloc::vec::{self, Vec};
+
+mod arbitrary;
+#[macro_use]
+mod macros;
+#[cfg(feature = "borsh")]
+mod borsh;
+#[cfg(feature = "serde")]
+mod serde;
+mod util;
+
+pub mod map;
+pub mod set;
+
+// Placed after `map` and `set` so new `rayon` methods on the types
+// are documented after the "normal" methods.
+#[cfg(feature = "rayon")]
+mod rayon;
+
+pub use crate::map::IndexMap;
+pub use crate::set::IndexSet;
+pub use equivalent::Equivalent;
+
+// shared private items
+
+/// Hash value newtype. Not larger than usize, since anything larger
+/// isn't used for selecting position anyway.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct HashValue(usize);
+
+impl HashValue {
+    #[inline(always)]
+    fn get(self) -> u64 {
+        self.0 as u64
+    }
+}
+
+#[derive(Copy, Debug)]
+struct Bucket<K, V> {
+    hash: HashValue,
+    key: K,
+    value: V,
+}
+
+impl<K, V> Clone for Bucket<K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    fn clone(&self) -> Self {
+        Bucket {
+            hash: self.hash,
+            key: self.key.clone(),
+            value: self.value.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.hash = other.hash;
+        self.key.clone_from(&other.key);
+        self.value.clone_from(&other.value);
+    }
+}
+
+impl<K, V> Bucket<K, V> {
+    // field accessors -- used for `f` instead of closures in `.map(f)`
+    fn key_ref(&self) -> &K {
+        &self.key
+    }
+    fn value_ref(&self) -> &V {
+        &self.value
+    }
+    fn value_mut(&mut self) -> &mut V {
+        &mut self.value
+    }
+    fn key(self) -> K {
+        self.key
+    }
+    fn value(self) -> V {
+        self.value
+    }
+    fn key_value(self) -> (K, V) {
+        (self.key, self.value)
+    }
+    fn refs(&self) -> (&K, &V) {
+        (&self.key, &self.value)
+    }
+    fn ref_mut(&mut self) -> (&K, &mut V) {
+        (&self.key, &mut self.value)
+    }
+    fn muts(&mut self) -> (&mut K, &mut V) {
+        (&mut self.key, &mut self.value)
+    }
+}
+
+trait Entries {
+    type Entry;
+    fn into_entries(self) -> Vec<Self::Entry>;
+    fn as_entries(&self) -> &[Self::Entry];
+    fn as_entries_mut(&mut self) -> &mut [Self::Entry];
+    fn with_entries<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut [Self::Entry]);
+}
+
+/// The error type for [`try_reserve`][IndexMap::try_reserve] methods.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TryReserveError {
+    kind: TryReserveErrorKind,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum TryReserveErrorKind {
+    // The standard library's kind is currently opaque to us, otherwise we could unify this.
+    Std(alloc::collections::TryReserveError),
+    CapacityOverflow,
+    AllocError { layout: alloc::alloc::Layout },
+}
+
+// These are not `From` so we don't expose them in our public API.
+impl TryReserveError {
+    fn from_alloc(error: alloc::collections::TryReserveError) -> Self {
+        Self {
+            kind: TryReserveErrorKind::Std(error),
+        }
+    }
+
+    fn from_hashbrown(error: hashbrown::TryReserveError) -> Self {
+        Self {
+            kind: match error {
+                hashbrown::TryReserveError::CapacityOverflow => {
+                    TryReserveErrorKind::CapacityOverflow
+                }
+                hashbrown::TryReserveError::AllocError { layout } => {
+                    TryReserveErrorKind::AllocError { layout }
+                }
+            },
+        }
+    }
+}
+
+impl core::fmt::Display for TryReserveError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let reason = match &self.kind {
+            TryReserveErrorKind::Std(e) => return core::fmt::Display::fmt(e, f),
+            TryReserveErrorKind::CapacityOverflow => {
+                " because the computed capacity exceeded the collection's maximum"
+            }
+            TryReserveErrorKind::AllocError { .. } => {
+                " because the memory allocator returned an error"
+            }
+        };
+        f.write_str("memory allocation failed")?;
+        f.write_str(reason)
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl std::error::Error for TryReserveError {}
+
+// NOTE: This is copied from the slice module in the std lib.
+/// The error type returned by [`get_disjoint_indices_mut`][`IndexMap::get_disjoint_indices_mut`].
+///
+/// It indicates one of two possible errors:
+/// - An index is out-of-bounds.
+/// - The same index appeared multiple times in the array.
+//    (or different but overlapping indices when ranges are provided)
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum GetDisjointMutError {
+    /// An index provided was out-of-bounds for the slice.
+    IndexOutOfBounds,
+    /// Two indices provided were overlapping.
+    OverlappingIndices,
+}
+
+impl core::fmt::Display for GetDisjointMutError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let msg = match self {
+            GetDisjointMutError::IndexOutOfBounds => "an index is out of bounds",
+            GetDisjointMutError::OverlappingIndices => "there were overlapping indices",
+        };
+
+        core::fmt::Display::fmt(msg, f)
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl std::error::Error for GetDisjointMutError {}
diff --git a/vendor/indexmap/src/macros.rs b/vendor/indexmap/src/macros.rs
new file mode 100644
index 00000000..8f545083
--- /dev/null
+++ b/vendor/indexmap/src/macros.rs
@@ -0,0 +1,252 @@
+/// Create an [`IndexMap`][crate::IndexMap] from a list of key-value pairs
+/// and a [`BuildHasherDefault`][core::hash::BuildHasherDefault]-wrapped custom hasher.
+///
+/// ## Example
+///
+/// ```
+/// use indexmap::indexmap_with_default;
+/// use fnv::FnvHasher;
+///
+/// let map = indexmap_with_default!{
+///     FnvHasher;
+///     "a" => 1,
+///     "b" => 2,
+/// };
+/// assert_eq!(map["a"], 1);
+/// assert_eq!(map["b"], 2);
+/// assert_eq!(map.get("c"), None);
+///
+/// // "a" is the first key
+/// assert_eq!(map.keys().next(), Some(&"a"));
+/// ```
+#[macro_export]
+macro_rules! indexmap_with_default {
+    ($H:ty; $($key:expr => $value:expr,)+) => { $crate::indexmap_with_default!($H; $($key => $value),+) };
+    ($H:ty; $($key:expr => $value:expr),*) => {{
+        let builder = ::core::hash::BuildHasherDefault::<$H>::default();
+        const CAP: usize = <[()]>::len(&[$({ stringify!($key); }),*]);
+        #[allow(unused_mut)]
+        // Specify your custom `H` (must implement Default + Hasher) as the hasher:
+        let mut map = $crate::IndexMap::with_capacity_and_hasher(CAP, builder);
+        $(
+            map.insert($key, $value);
+        )*
+        map
+    }};
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+#[macro_export]
+/// Create an [`IndexMap`][crate::IndexMap] from a list of key-value pairs
+///
+/// ## Example
+///
+/// ```
+/// use indexmap::indexmap;
+///
+/// let map = indexmap!{
+///     "a" => 1,
+///     "b" => 2,
+/// };
+/// assert_eq!(map["a"], 1);
+/// assert_eq!(map["b"], 2);
+/// assert_eq!(map.get("c"), None);
+///
+/// // "a" is the first key
+/// assert_eq!(map.keys().next(), Some(&"a"));
+/// ```
+macro_rules! indexmap {
+    ($($key:expr => $value:expr,)+) => { $crate::indexmap!($($key => $value),+) };
+    ($($key:expr => $value:expr),*) => {
+        {
+            // Note: `stringify!($key)` is just here to consume the repetition,
+            // but we throw away that string literal during constant evaluation.
+            const CAP: usize = <[()]>::len(&[$({ stringify!($key); }),*]);
+            let mut map = $crate::IndexMap::with_capacity(CAP);
+            $(
+                map.insert($key, $value);
+            )*
+            map
+        }
+    };
+}
+
+/// Create an [`IndexSet`][crate::IndexSet] from a list of values
+/// and a [`BuildHasherDefault`][core::hash::BuildHasherDefault]-wrapped custom hasher.
+///
+/// ## Example
+///
+/// ```
+/// use indexmap::indexset_with_default;
+/// use fnv::FnvHasher;
+///
+/// let set = indexset_with_default!{
+///     FnvHasher;
+///     "a",
+///     "b",
+/// };
+/// assert!(set.contains("a"));
+/// assert!(set.contains("b"));
+/// assert!(!set.contains("c"));
+///
+/// // "a" is the first value
+/// assert_eq!(set.iter().next(), Some(&"a"));
+/// ```
+#[macro_export]
+macro_rules! indexset_with_default {
+    ($H:ty; $($value:expr,)+) => { $crate::indexset_with_default!($H; $($value),+) };
+    ($H:ty; $($value:expr),*) => {{
+        let builder = ::core::hash::BuildHasherDefault::<$H>::default();
+        const CAP: usize = <[()]>::len(&[$({ stringify!($value); }),*]);
+        #[allow(unused_mut)]
+        // Specify your custom `H` (must implement Default + Hash) as the hasher:
+        let mut set = $crate::IndexSet::with_capacity_and_hasher(CAP, builder);
+        $(
+            set.insert($value);
+        )*
+        set
+    }};
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+#[macro_export]
+/// Create an [`IndexSet`][crate::IndexSet] from a list of values
+///
+/// ## Example
+///
+/// ```
+/// use indexmap::indexset;
+///
+/// let set = indexset!{
+///     "a",
+///     "b",
+/// };
+/// assert!(set.contains("a"));
+/// assert!(set.contains("b"));
+/// assert!(!set.contains("c"));
+///
+/// // "a" is the first value
+/// assert_eq!(set.iter().next(), Some(&"a"));
+/// ```
+macro_rules! indexset {
+    ($($value:expr,)+) => { $crate::indexset!($($value),+) };
+    ($($value:expr),*) => {
+        {
+            // Note: `stringify!($value)` is just here to consume the repetition,
+            // but we throw away that string literal during constant evaluation.
+            const CAP: usize = <[()]>::len(&[$({ stringify!($value); }),*]);
+            let mut set = $crate::IndexSet::with_capacity(CAP);
+            $(
+                set.insert($value);
+            )*
+            set
+        }
+    };
+}
+
+// generate all the Iterator methods by just forwarding to the underlying
+// self.iter and mapping its element.
+macro_rules! iterator_methods {
+    // $map_elt is the mapping function from the underlying iterator's element
+    // same mapping function for both options and iterators
+    ($map_elt:expr) => {
+        fn next(&mut self) -> Option<Self::Item> {
+            self.iter.next().map($map_elt)
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.iter.size_hint()
+        }
+
+        fn count(self) -> usize {
+            self.iter.len()
+        }
+
+        fn nth(&mut self, n: usize) -> Option<Self::Item> {
+            self.iter.nth(n).map($map_elt)
+        }
+
+        fn last(mut self) -> Option<Self::Item> {
+            self.next_back()
+        }
+
+        fn collect<C>(self) -> C
+        where
+            C: FromIterator<Self::Item>,
+        {
+            // NB: forwarding this directly to standard iterators will
+            // allow it to leverage unstable traits like `TrustedLen`.
+            self.iter.map($map_elt).collect()
+        }
+    };
+}
+
+macro_rules! double_ended_iterator_methods {
+    // $map_elt is the mapping function from the underlying iterator's element
+    // same mapping function for both options and iterators
+    ($map_elt:expr) => {
+        fn next_back(&mut self) -> Option<Self::Item> {
+            self.iter.next_back().map($map_elt)
+        }
+
+        fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+            self.iter.nth_back(n).map($map_elt)
+        }
+    };
+}
+
+// generate `ParallelIterator` methods by just forwarding to the underlying
+// self.entries and mapping its elements.
+#[cfg(feature = "rayon")]
+macro_rules! parallel_iterator_methods {
+    // $map_elt is the mapping function from the underlying iterator's element
+    ($map_elt:expr) => {
+        fn drive_unindexed<C>(self, consumer: C) -> C::Result
+        where
+            C: UnindexedConsumer<Self::Item>,
+        {
+            self.entries
+                .into_par_iter()
+                .map($map_elt)
+                .drive_unindexed(consumer)
+        }
+
+        // NB: This allows indexed collection, e.g. directly into a `Vec`, but the
+        // underlying iterator must really be indexed.  We should remove this if we
+        // start having tombstones that must be filtered out.
+        fn opt_len(&self) -> Option<usize> {
+            Some(self.entries.len())
+        }
+    };
+}
+
+// generate `IndexedParallelIterator` methods by just forwarding to the underlying
+// self.entries and mapping its elements.
+#[cfg(feature = "rayon")]
+macro_rules! indexed_parallel_iterator_methods {
+    // $map_elt is the mapping function from the underlying iterator's element
+    ($map_elt:expr) => {
+        fn drive<C>(self, consumer: C) -> C::Result
+        where
+            C: Consumer<Self::Item>,
+        {
+            self.entries.into_par_iter().map($map_elt).drive(consumer)
+        }
+
+        fn len(&self) -> usize {
+            self.entries.len()
+        }
+
+        fn with_producer<CB>(self, callback: CB) -> CB::Output
+        where
+            CB: ProducerCallback<Self::Item>,
+        {
+            self.entries
+                .into_par_iter()
+                .map($map_elt)
+                .with_producer(callback)
+        }
+    };
+}
diff --git a/vendor/indexmap/src/map.rs b/vendor/indexmap/src/map.rs
new file mode 100644
index 00000000..79a45527
--- /dev/null
+++ b/vendor/indexmap/src/map.rs
@@ -0,0 +1,1651 @@
+//! [`IndexMap`] is a hash table where the iteration order of the key-value
+//! pairs is independent of the hash values of the keys.
+
+mod core;
+mod iter;
+mod mutable;
+mod slice;
+
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+pub mod serde_seq;
+
+#[cfg(test)]
+mod tests;
+
+pub use self::core::raw_entry_v1::{self, RawEntryApiV1};
+pub use self::core::{Entry, IndexedEntry, OccupiedEntry, VacantEntry};
+pub use self::iter::{
+    Drain, IntoIter, IntoKeys, IntoValues, Iter, IterMut, IterMut2, Keys, Splice, Values, ValuesMut,
+};
+pub use self::mutable::MutableEntryKey;
+pub use self::mutable::MutableKeys;
+pub use self::slice::Slice;
+
+#[cfg(feature = "rayon")]
+pub use crate::rayon::map as rayon;
+
+use ::core::cmp::Ordering;
+use ::core::fmt;
+use ::core::hash::{BuildHasher, Hash, Hasher};
+use ::core::mem;
+use ::core::ops::{Index, IndexMut, RangeBounds};
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+
+#[cfg(feature = "std")]
+use std::collections::hash_map::RandomState;
+
+use self::core::IndexMapCore;
+use crate::util::{third, try_simplify_range};
+use crate::{Bucket, Entries, Equivalent, GetDisjointMutError, HashValue, TryReserveError};
+
+/// A hash table where the iteration order of the key-value pairs is independent
+/// of the hash values of the keys.
+///
+/// The interface is closely compatible with the standard
+/// [`HashMap`][std::collections::HashMap],
+/// but also has additional features.
+///
+/// # Order
+///
+/// The key-value pairs have a consistent order that is determined by
+/// the sequence of insertion and removal calls on the map. The order does
+/// not depend on the keys or the hash function at all.
+///
+/// All iterators traverse the map in *the order*.
+///
+/// The insertion order is preserved, with **notable exceptions** like the
+/// [`.remove()`][Self::remove] or [`.swap_remove()`][Self::swap_remove] methods.
+/// Methods such as [`.sort_by()`][Self::sort_by] of
+/// course result in a new order, depending on the sorting order.
+///
+/// # Indices
+///
+/// The key-value pairs are indexed in a compact range without holes in the
+/// range `0..self.len()`. For example, the method `.get_full` looks up the
+/// index for a key, and the method `.get_index` looks up the key-value pair by
+/// index.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// // count the frequency of each letter in a sentence.
+/// let mut letters = IndexMap::new();
+/// for ch in "a short treatise on fungi".chars() {
+///     *letters.entry(ch).or_insert(0) += 1;
+/// }
+///
+/// assert_eq!(letters[&'s'], 2);
+/// assert_eq!(letters[&'t'], 3);
+/// assert_eq!(letters[&'u'], 1);
+/// assert_eq!(letters.get(&'y'), None);
+/// ```
+#[cfg(feature = "std")]
+pub struct IndexMap<K, V, S = RandomState> {
+    pub(crate) core: IndexMapCore<K, V>,
+    hash_builder: S,
+}
+#[cfg(not(feature = "std"))]
+pub struct IndexMap<K, V, S> {
+    pub(crate) core: IndexMapCore<K, V>,
+    hash_builder: S,
+}
+
+impl<K, V, S> Clone for IndexMap<K, V, S>
+where
+    K: Clone,
+    V: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        IndexMap {
+            core: self.core.clone(),
+            hash_builder: self.hash_builder.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.core.clone_from(&other.core);
+        self.hash_builder.clone_from(&other.hash_builder);
+    }
+}
+
+impl<K, V, S> Entries for IndexMap<K, V, S> {
+    type Entry = Bucket<K, V>;
+
+    #[inline]
+    fn into_entries(self) -> Vec<Self::Entry> {
+        self.core.into_entries()
+    }
+
+    #[inline]
+    fn as_entries(&self) -> &[Self::Entry] {
+        self.core.as_entries()
+    }
+
+    #[inline]
+    fn as_entries_mut(&mut self) -> &mut [Self::Entry] {
+        self.core.as_entries_mut()
+    }
+
+    fn with_entries<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut [Self::Entry]),
+    {
+        self.core.with_entries(f);
+    }
+}
+
+impl<K, V, S> fmt::Debug for IndexMap<K, V, S>
+where
+    K: fmt::Debug,
+    V: fmt::Debug,
+{
+    #[cfg(not(feature = "test_debug"))]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_map().entries(self.iter()).finish()
+    }
+
+    #[cfg(feature = "test_debug")]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Let the inner `IndexMapCore` print all of its details
+        f.debug_struct("IndexMap")
+            .field("core", &self.core)
+            .finish()
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl<K, V> IndexMap<K, V> {
+    /// Create a new map. (Does not allocate.)
+    #[inline]
+    pub fn new() -> Self {
+        Self::with_capacity(0)
+    }
+
+    /// Create a new map with capacity for `n` key-value pairs. (Does not
+    /// allocate if `n` is zero.)
+    ///
+    /// Computes in **O(n)** time.
+    #[inline]
+    pub fn with_capacity(n: usize) -> Self {
+        Self::with_capacity_and_hasher(n, <_>::default())
+    }
+}
+
+impl<K, V, S> IndexMap<K, V, S> {
+    /// Create a new map with capacity for `n` key-value pairs. (Does not
+    /// allocate if `n` is zero.)
+    ///
+    /// Computes in **O(n)** time.
+    #[inline]
+    pub fn with_capacity_and_hasher(n: usize, hash_builder: S) -> Self {
+        if n == 0 {
+            Self::with_hasher(hash_builder)
+        } else {
+            IndexMap {
+                core: IndexMapCore::with_capacity(n),
+                hash_builder,
+            }
+        }
+    }
+
+    /// Create a new map with `hash_builder`.
+    ///
+    /// This function is `const`, so it
+    /// can be called in `static` contexts.
+    pub const fn with_hasher(hash_builder: S) -> Self {
+        IndexMap {
+            core: IndexMapCore::new(),
+            hash_builder,
+        }
+    }
+
+    /// Return the number of elements the map can hold without reallocating.
+    ///
+    /// This number is a lower bound; the map might be able to hold more,
+    /// but is guaranteed to be able to hold at least this many.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn capacity(&self) -> usize {
+        self.core.capacity()
+    }
+
+    /// Return a reference to the map's `BuildHasher`.
+    pub fn hasher(&self) -> &S {
+        &self.hash_builder
+    }
+
+    /// Return the number of key-value pairs in the map.
+    ///
+    /// Computes in **O(1)** time.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.core.len()
+    }
+
+    /// Returns true if the map contains no elements.
+    ///
+    /// Computes in **O(1)** time.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Return an iterator over the key-value pairs of the map, in their order
+    pub fn iter(&self) -> Iter<'_, K, V> {
+        Iter::new(self.as_entries())
+    }
+
+    /// Return an iterator over the key-value pairs of the map, in their order
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
+        IterMut::new(self.as_entries_mut())
+    }
+
+    /// Return an iterator over the keys of the map, in their order
+    pub fn keys(&self) -> Keys<'_, K, V> {
+        Keys::new(self.as_entries())
+    }
+
+    /// Return an owning iterator over the keys of the map, in their order
+    pub fn into_keys(self) -> IntoKeys<K, V> {
+        IntoKeys::new(self.into_entries())
+    }
+
+    /// Return an iterator over the values of the map, in their order
+    pub fn values(&self) -> Values<'_, K, V> {
+        Values::new(self.as_entries())
+    }
+
+    /// Return an iterator over mutable references to the values of the map,
+    /// in their order
+    pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
+        ValuesMut::new(self.as_entries_mut())
+    }
+
+    /// Return an owning iterator over the values of the map, in their order
+    pub fn into_values(self) -> IntoValues<K, V> {
+        IntoValues::new(self.into_entries())
+    }
+
+    /// Remove all key-value pairs in the map, while preserving its capacity.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn clear(&mut self) {
+        self.core.clear();
+    }
+
+    /// Shortens the map, keeping the first `len` elements and dropping the rest.
+    ///
+    /// If `len` is greater than the map's current length, this has no effect.
+    pub fn truncate(&mut self, len: usize) {
+        self.core.truncate(len);
+    }
+
+    /// Clears the `IndexMap` in the given index range, returning those
+    /// key-value pairs as a drain iterator.
+    ///
+    /// The range may be any type that implements [`RangeBounds<usize>`],
+    /// including all of the `std::ops::Range*` types, or even a tuple pair of
+    /// `Bound` start and end values. To drain the map entirely, use `RangeFull`
+    /// like `map.drain(..)`.
+    ///
+    /// This shifts down all entries following the drained range to fill the
+    /// gap, and keeps the allocated memory for reuse.
+    ///
+    /// ***Panics*** if the starting point is greater than the end point or if
+    /// the end point is greater than the length of the map.
+    #[track_caller]
+    pub fn drain<R>(&mut self, range: R) -> Drain<'_, K, V>
+    where
+        R: RangeBounds<usize>,
+    {
+        Drain::new(self.core.drain(range))
+    }
+
+    /// Splits the collection into two at the given index.
+    ///
+    /// Returns a newly allocated map containing the elements in the range
+    /// `[at, len)`. After the call, the original map will be left containing
+    /// the elements `[0, at)` with its previous capacity unchanged.
+    ///
+    /// ***Panics*** if `at > len`.
+    #[track_caller]
+    pub fn split_off(&mut self, at: usize) -> Self
+    where
+        S: Clone,
+    {
+        Self {
+            core: self.core.split_off(at),
+            hash_builder: self.hash_builder.clone(),
+        }
+    }
+
+    /// Reserve capacity for `additional` more key-value pairs.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn reserve(&mut self, additional: usize) {
+        self.core.reserve(additional);
+    }
+
+    /// Reserve capacity for `additional` more key-value pairs, without over-allocating.
+    ///
+    /// Unlike `reserve`, this does not deliberately over-allocate the entry capacity to avoid
+    /// frequent re-allocations. However, the underlying data structures may still have internal
+    /// capacity requirements, and the allocator itself may give more space than requested, so this
+    /// cannot be relied upon to be precisely minimal.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn reserve_exact(&mut self, additional: usize) {
+        self.core.reserve_exact(additional);
+    }
+
+    /// Try to reserve capacity for `additional` more key-value pairs.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.core.try_reserve(additional)
+    }
+
+    /// Try to reserve capacity for `additional` more key-value pairs, without over-allocating.
+    ///
+    /// Unlike `try_reserve`, this does not deliberately over-allocate the entry capacity to avoid
+    /// frequent re-allocations. However, the underlying data structures may still have internal
+    /// capacity requirements, and the allocator itself may give more space than requested, so this
+    /// cannot be relied upon to be precisely minimal.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.core.try_reserve_exact(additional)
+    }
+
+    /// Shrink the capacity of the map as much as possible.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn shrink_to_fit(&mut self) {
+        self.core.shrink_to(0);
+    }
+
+    /// Shrink the capacity of the map with a lower limit.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn shrink_to(&mut self, min_capacity: usize) {
+        self.core.shrink_to(min_capacity);
+    }
+}
+
+impl<K, V, S> IndexMap<K, V, S>
+where
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    /// Insert a key-value pair in the map.
+    ///
+    /// If an equivalent key already exists in the map: the key remains and
+    /// retains in its place in the order, its corresponding value is updated
+    /// with `value`, and the older value is returned inside `Some(_)`.
+    ///
+    /// If no equivalent key existed in the map: the new key-value pair is
+    /// inserted, last in order, and `None` is returned.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    ///
+    /// See also [`entry`][Self::entry] if you want to insert *or* modify,
+    /// or [`insert_full`][Self::insert_full] if you need to get the index of
+    /// the corresponding key-value pair.
+    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
+        self.insert_full(key, value).1
+    }
+
+    /// Insert a key-value pair in the map, and get their index.
+    ///
+    /// If an equivalent key already exists in the map: the key remains and
+    /// retains in its place in the order, its corresponding value is updated
+    /// with `value`, and the older value is returned inside `(index, Some(_))`.
+    ///
+    /// If no equivalent key existed in the map: the new key-value pair is
+    /// inserted, last in order, and `(index, None)` is returned.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    ///
+    /// See also [`entry`][Self::entry] if you want to insert *or* modify.
+    pub fn insert_full(&mut self, key: K, value: V) -> (usize, Option<V>) {
+        let hash = self.hash(&key);
+        self.core.insert_full(hash, key, value)
+    }
+
+    /// Insert a key-value pair in the map at its ordered position among sorted keys.
+    ///
+    /// This is equivalent to finding the position with
+    /// [`binary_search_keys`][Self::binary_search_keys], then either updating
+    /// it or calling [`insert_before`][Self::insert_before] for a new key.
+    ///
+    /// If the sorted key is found in the map, its corresponding value is
+    /// updated with `value`, and the older value is returned inside
+    /// `(index, Some(_))`. Otherwise, the new key-value pair is inserted at
+    /// the sorted position, and `(index, None)` is returned.
+    ///
+    /// If the existing keys are **not** already sorted, then the insertion
+    /// index is unspecified (like [`slice::binary_search`]), but the key-value
+    /// pair is moved to or inserted at that position regardless.
+    ///
+    /// Computes in **O(n)** time (average). Instead of repeating calls to
+    /// `insert_sorted`, it may be faster to call batched [`insert`][Self::insert]
+    /// or [`extend`][Self::extend] and only call [`sort_keys`][Self::sort_keys]
+    /// or [`sort_unstable_keys`][Self::sort_unstable_keys] once.
+    pub fn insert_sorted(&mut self, key: K, value: V) -> (usize, Option<V>)
+    where
+        K: Ord,
+    {
+        match self.binary_search_keys(&key) {
+            Ok(i) => (i, Some(mem::replace(&mut self[i], value))),
+            Err(i) => self.insert_before(i, key, value),
+        }
+    }
+
+    /// Insert a key-value pair in the map before the entry at the given index, or at the end.
+    ///
+    /// If an equivalent key already exists in the map: the key remains and
+    /// is moved to the new position in the map, its corresponding value is updated
+    /// with `value`, and the older value is returned inside `Some(_)`. The returned index
+    /// will either be the given index or one less, depending on how the entry moved.
+    /// (See [`shift_insert`](Self::shift_insert) for different behavior here.)
+    ///
+    /// If no equivalent key existed in the map: the new key-value pair is
+    /// inserted exactly at the given index, and `None` is returned.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    /// Valid indices are `0..=map.len()` (inclusive).
+    ///
+    /// Computes in **O(n)** time (average).
+    ///
+    /// See also [`entry`][Self::entry] if you want to insert *or* modify,
+    /// perhaps only using the index for new entries with [`VacantEntry::shift_insert`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexMap;
+    /// let mut map: IndexMap<char, ()> = ('a'..='z').map(|c| (c, ())).collect();
+    ///
+    /// // The new key '*' goes exactly at the given index.
+    /// assert_eq!(map.get_index_of(&'*'), None);
+    /// assert_eq!(map.insert_before(10, '*', ()), (10, None));
+    /// assert_eq!(map.get_index_of(&'*'), Some(10));
+    ///
+    /// // Moving the key 'a' up will shift others down, so this moves *before* 10 to index 9.
+    /// assert_eq!(map.insert_before(10, 'a', ()), (9, Some(())));
+    /// assert_eq!(map.get_index_of(&'a'), Some(9));
+    /// assert_eq!(map.get_index_of(&'*'), Some(10));
+    ///
+    /// // Moving the key 'z' down will shift others up, so this moves to exactly 10.
+    /// assert_eq!(map.insert_before(10, 'z', ()), (10, Some(())));
+    /// assert_eq!(map.get_index_of(&'z'), Some(10));
+    /// assert_eq!(map.get_index_of(&'*'), Some(11));
+    ///
+    /// // Moving or inserting before the endpoint is also valid.
+    /// assert_eq!(map.len(), 27);
+    /// assert_eq!(map.insert_before(map.len(), '*', ()), (26, Some(())));
+    /// assert_eq!(map.get_index_of(&'*'), Some(26));
+    /// assert_eq!(map.insert_before(map.len(), '+', ()), (27, None));
+    /// assert_eq!(map.get_index_of(&'+'), Some(27));
+    /// assert_eq!(map.len(), 28);
+    /// ```
+    #[track_caller]
+    pub fn insert_before(&mut self, mut index: usize, key: K, value: V) -> (usize, Option<V>) {
+        let len = self.len();
+
+        assert!(
+            index <= len,
+            "index out of bounds: the len is {len} but the index is {index}. Expected index <= len"
+        );
+
+        match self.entry(key) {
+            Entry::Occupied(mut entry) => {
+                if index > entry.index() {
+                    // Some entries will shift down when this one moves up,
+                    // so "insert before index" becomes "move to index - 1",
+                    // keeping the entry at the original index unmoved.
+                    index -= 1;
+                }
+                let old = mem::replace(entry.get_mut(), value);
+                entry.move_index(index);
+                (index, Some(old))
+            }
+            Entry::Vacant(entry) => {
+                entry.shift_insert(index, value);
+                (index, None)
+            }
+        }
+    }
+
+    /// Insert a key-value pair in the map at the given index.
+    ///
+    /// If an equivalent key already exists in the map: the key remains and
+    /// is moved to the given index in the map, its corresponding value is updated
+    /// with `value`, and the older value is returned inside `Some(_)`.
+    /// Note that existing entries **cannot** be moved to `index == map.len()`!
+    /// (See [`insert_before`](Self::insert_before) for different behavior here.)
+    ///
+    /// If no equivalent key existed in the map: the new key-value pair is
+    /// inserted at the given index, and `None` is returned.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    /// Valid indices are `0..map.len()` (exclusive) when moving an existing entry, or
+    /// `0..=map.len()` (inclusive) when inserting a new key.
+    ///
+    /// Computes in **O(n)** time (average).
+    ///
+    /// See also [`entry`][Self::entry] if you want to insert *or* modify,
+    /// perhaps only using the index for new entries with [`VacantEntry::shift_insert`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexMap;
+    /// let mut map: IndexMap<char, ()> = ('a'..='z').map(|c| (c, ())).collect();
+    ///
+    /// // The new key '*' goes exactly at the given index.
+    /// assert_eq!(map.get_index_of(&'*'), None);
+    /// assert_eq!(map.shift_insert(10, '*', ()), None);
+    /// assert_eq!(map.get_index_of(&'*'), Some(10));
+    ///
+    /// // Moving the key 'a' up to 10 will shift others down, including the '*' that was at 10.
+    /// assert_eq!(map.shift_insert(10, 'a', ()), Some(()));
+    /// assert_eq!(map.get_index_of(&'a'), Some(10));
+    /// assert_eq!(map.get_index_of(&'*'), Some(9));
+    ///
+    /// // Moving the key 'z' down to 9 will shift others up, including the '*' that was at 9.
+    /// assert_eq!(map.shift_insert(9, 'z', ()), Some(()));
+    /// assert_eq!(map.get_index_of(&'z'), Some(9));
+    /// assert_eq!(map.get_index_of(&'*'), Some(10));
+    ///
+    /// // Existing keys can move to len-1 at most, but new keys can insert at the endpoint.
+    /// assert_eq!(map.len(), 27);
+    /// assert_eq!(map.shift_insert(map.len() - 1, '*', ()), Some(()));
+    /// assert_eq!(map.get_index_of(&'*'), Some(26));
+    /// assert_eq!(map.shift_insert(map.len(), '+', ()), None);
+    /// assert_eq!(map.get_index_of(&'+'), Some(27));
+    /// assert_eq!(map.len(), 28);
+    /// ```
+    ///
+    /// ```should_panic
+    /// use indexmap::IndexMap;
+    /// let mut map: IndexMap<char, ()> = ('a'..='z').map(|c| (c, ())).collect();
+    ///
+    /// // This is an invalid index for moving an existing key!
+    /// map.shift_insert(map.len(), 'a', ());
+    /// ```
+    #[track_caller]
+    pub fn shift_insert(&mut self, index: usize, key: K, value: V) -> Option<V> {
+        let len = self.len();
+        match self.entry(key) {
+            Entry::Occupied(mut entry) => {
+                assert!(
+                    index < len,
+                    "index out of bounds: the len is {len} but the index is {index}"
+                );
+
+                let old = mem::replace(entry.get_mut(), value);
+                entry.move_index(index);
+                Some(old)
+            }
+            Entry::Vacant(entry) => {
+                assert!(
+                    index <= len,
+                    "index out of bounds: the len is {len} but the index is {index}. Expected index <= len"
+                );
+
+                entry.shift_insert(index, value);
+                None
+            }
+        }
+    }
+
+    /// Get the given key’s corresponding entry in the map for insertion and/or
+    /// in-place manipulation.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+        let hash = self.hash(&key);
+        self.core.entry(hash, key)
+    }
+
+    /// Creates a splicing iterator that replaces the specified range in the map
+    /// with the given `replace_with` key-value iterator and yields the removed
+    /// items. `replace_with` does not need to be the same length as `range`.
+    ///
+    /// The `range` is removed even if the iterator is not consumed until the
+    /// end. It is unspecified how many elements are removed from the map if the
+    /// `Splice` value is leaked.
+    ///
+    /// The input iterator `replace_with` is only consumed when the `Splice`
+    /// value is dropped. If a key from the iterator matches an existing entry
+    /// in the map (outside of `range`), then the value will be updated in that
+    /// position. Otherwise, the new key-value pair will be inserted in the
+    /// replaced `range`.
+    ///
+    /// ***Panics*** if the starting point is greater than the end point or if
+    /// the end point is greater than the length of the map.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexMap;
+    ///
+    /// let mut map = IndexMap::from([(0, '_'), (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);
+    /// let new = [(5, 'E'), (4, 'D'), (3, 'C'), (2, 'B'), (1, 'A')];
+    /// let removed: Vec<_> = map.splice(2..4, new).collect();
+    ///
+    /// // 1 and 4 got new values, while 5, 3, and 2 were newly inserted.
+    /// assert!(map.into_iter().eq([(0, '_'), (1, 'A'), (5, 'E'), (3, 'C'), (2, 'B'), (4, 'D')]));
+    /// assert_eq!(removed, &[(2, 'b'), (3, 'c')]);
+    /// ```
+    #[track_caller]
+    pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, K, V, S>
+    where
+        R: RangeBounds<usize>,
+        I: IntoIterator<Item = (K, V)>,
+    {
+        Splice::new(self, range, replace_with.into_iter())
+    }
+
+    /// Moves all key-value pairs from `other` into `self`, leaving `other` empty.
+    ///
+    /// This is equivalent to calling [`insert`][Self::insert] for each
+    /// key-value pair from `other` in order, which means that for keys that
+    /// already exist in `self`, their value is updated in the current position.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexMap;
+    ///
+    /// // Note: Key (3) is present in both maps.
+    /// let mut a = IndexMap::from([(3, "c"), (2, "b"), (1, "a")]);
+    /// let mut b = IndexMap::from([(3, "d"), (4, "e"), (5, "f")]);
+    /// let old_capacity = b.capacity();
+    ///
+    /// a.append(&mut b);
+    ///
+    /// assert_eq!(a.len(), 5);
+    /// assert_eq!(b.len(), 0);
+    /// assert_eq!(b.capacity(), old_capacity);
+    ///
+    /// assert!(a.keys().eq(&[3, 2, 1, 4, 5]));
+    /// assert_eq!(a[&3], "d"); // "c" was overwritten.
+    /// ```
+    pub fn append<S2>(&mut self, other: &mut IndexMap<K, V, S2>) {
+        self.extend(other.drain(..));
+    }
+}
+
+impl<K, V, S> IndexMap<K, V, S>
+where
+    S: BuildHasher,
+{
+    pub(crate) fn hash<Q: ?Sized + Hash>(&self, key: &Q) -> HashValue {
+        let mut h = self.hash_builder.build_hasher();
+        key.hash(&mut h);
+        HashValue(h.finish() as usize)
+    }
+
+    /// Return `true` if an equivalent to `key` exists in the map.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn contains_key<Q>(&self, key: &Q) -> bool
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        self.get_index_of(key).is_some()
+    }
+
+    /// Return a reference to the value stored for `key`, if it is present,
+    /// else `None`.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn get<Q>(&self, key: &Q) -> Option<&V>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &self.as_entries()[i];
+            Some(&entry.value)
+        } else {
+            None
+        }
+    }
+
+    /// Return references to the key-value pair stored for `key`,
+    /// if it is present, else `None`.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &self.as_entries()[i];
+            Some((&entry.key, &entry.value))
+        } else {
+            None
+        }
+    }
+
+    /// Return item index, key and value
+    pub fn get_full<Q>(&self, key: &Q) -> Option<(usize, &K, &V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &self.as_entries()[i];
+            Some((i, &entry.key, &entry.value))
+        } else {
+            None
+        }
+    }
+
+    /// Return item index, if it exists in the map
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        match self.as_entries() {
+            [] => None,
+            [x] => key.equivalent(&x.key).then_some(0),
+            _ => {
+                let hash = self.hash(key);
+                self.core.get_index_of(hash, key)
+            }
+        }
+    }
+
+    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &mut self.as_entries_mut()[i];
+            Some(&mut entry.value)
+        } else {
+            None
+        }
+    }
+
+    pub fn get_full_mut<Q>(&mut self, key: &Q) -> Option<(usize, &K, &mut V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &mut self.as_entries_mut()[i];
+            Some((i, &entry.key, &mut entry.value))
+        } else {
+            None
+        }
+    }
+
+    /// Return the values for `N` keys. If any key is duplicated, this function will panic.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut map = indexmap::IndexMap::from([(1, 'a'), (3, 'b'), (2, 'c')]);
+    /// assert_eq!(map.get_disjoint_mut([&2, &1]), [Some(&mut 'c'), Some(&mut 'a')]);
+    /// ```
+    pub fn get_disjoint_mut<Q, const N: usize>(&mut self, keys: [&Q; N]) -> [Option<&mut V>; N]
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        let indices = keys.map(|key| self.get_index_of(key));
+        match self.as_mut_slice().get_disjoint_opt_mut(indices) {
+            Err(GetDisjointMutError::IndexOutOfBounds) => {
+                unreachable!(
+                    "Internal error: indices should never be OOB as we got them from get_index_of"
+                );
+            }
+            Err(GetDisjointMutError::OverlappingIndices) => {
+                panic!("duplicate keys found");
+            }
+            Ok(key_values) => key_values.map(|kv_opt| kv_opt.map(|kv| kv.1)),
+        }
+    }
+
+    /// Remove the key-value pair equivalent to `key` and return
+    /// its value.
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove(key)`][Self::swap_remove], replacing this
+    /// entry's position with the last element, and it is deprecated in favor of calling that
+    /// explicitly. If you need to preserve the relative order of the keys in the map, use
+    /// [`.shift_remove(key)`][Self::shift_remove] instead.
+    #[deprecated(note = "`remove` disrupts the map order -- \
+        use `swap_remove` or `shift_remove` for explicit behavior.")]
+    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        self.swap_remove(key)
+    }
+
+    /// Remove and return the key-value pair equivalent to `key`.
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove_entry(key)`][Self::swap_remove_entry],
+    /// replacing this entry's position with the last element, and it is deprecated in favor of
+    /// calling that explicitly. If you need to preserve the relative order of the keys in the map,
+    /// use [`.shift_remove_entry(key)`][Self::shift_remove_entry] instead.
+    #[deprecated(note = "`remove_entry` disrupts the map order -- \
+        use `swap_remove_entry` or `shift_remove_entry` for explicit behavior.")]
+    pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        self.swap_remove_entry(key)
+    }
+
+    /// Remove the key-value pair equivalent to `key` and return
+    /// its value.
+    ///
+    /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
+    /// last element of the map and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Return `None` if `key` is not in map.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove<Q>(&mut self, key: &Q) -> Option<V>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        self.swap_remove_full(key).map(third)
+    }
+
+    /// Remove and return the key-value pair equivalent to `key`.
+    ///
+    /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
+    /// last element of the map and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Return `None` if `key` is not in map.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        match self.swap_remove_full(key) {
+            Some((_, key, value)) => Some((key, value)),
+            None => None,
+        }
+    }
+
+    /// Remove the key-value pair equivalent to `key` and return it and
+    /// the index it had.
+    ///
+    /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
+    /// last element of the map and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Return `None` if `key` is not in map.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_full<Q>(&mut self, key: &Q) -> Option<(usize, K, V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        match self.as_entries() {
+            [x] if key.equivalent(&x.key) => {
+                let (k, v) = self.core.pop()?;
+                Some((0, k, v))
+            }
+            [_] | [] => None,
+            _ => {
+                let hash = self.hash(key);
+                self.core.swap_remove_full(hash, key)
+            }
+        }
+    }
+
+    /// Remove the key-value pair equivalent to `key` and return
+    /// its value.
+    ///
+    /// Like [`Vec::remove`], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Return `None` if `key` is not in map.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove<Q>(&mut self, key: &Q) -> Option<V>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        self.shift_remove_full(key).map(third)
+    }
+
+    /// Remove and return the key-value pair equivalent to `key`.
+    ///
+    /// Like [`Vec::remove`], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Return `None` if `key` is not in map.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        match self.shift_remove_full(key) {
+            Some((_, key, value)) => Some((key, value)),
+            None => None,
+        }
+    }
+
+    /// Remove the key-value pair equivalent to `key` and return it and
+    /// the index it had.
+    ///
+    /// Like [`Vec::remove`], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Return `None` if `key` is not in map.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_full<Q>(&mut self, key: &Q) -> Option<(usize, K, V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        match self.as_entries() {
+            [x] if key.equivalent(&x.key) => {
+                let (k, v) = self.core.pop()?;
+                Some((0, k, v))
+            }
+            [_] | [] => None,
+            _ => {
+                let hash = self.hash(key);
+                self.core.shift_remove_full(hash, key)
+            }
+        }
+    }
+}
+
+impl<K, V, S> IndexMap<K, V, S> {
+    /// Remove the last key-value pair
+    ///
+    /// This preserves the order of the remaining elements.
+    ///
+    /// Computes in **O(1)** time (average).
+    #[doc(alias = "pop_last")] // like `BTreeMap`
+    pub fn pop(&mut self) -> Option<(K, V)> {
+        self.core.pop()
+    }
+
+    /// Scan through each key-value pair in the map and keep those where the
+    /// closure `keep` returns `true`.
+    ///
+    /// The elements are visited in order, and remaining elements keep their
+    /// order.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn retain<F>(&mut self, mut keep: F)
+    where
+        F: FnMut(&K, &mut V) -> bool,
+    {
+        self.core.retain_in_order(move |k, v| keep(k, v));
+    }
+
+    /// Sort the map’s key-value pairs by the default ordering of the keys.
+    ///
+    /// This is a stable sort -- but equivalent keys should not normally coexist in
+    /// a map at all, so [`sort_unstable_keys`][Self::sort_unstable_keys] is preferred
+    /// because it is generally faster and doesn't allocate auxiliary memory.
+    ///
+    /// See [`sort_by`](Self::sort_by) for details.
+    pub fn sort_keys(&mut self)
+    where
+        K: Ord,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_by(move |a, b| K::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the map’s key-value pairs in place using the comparison
+    /// function `cmp`.
+    ///
+    /// The comparison function receives two key and value pairs to compare (you
+    /// can sort by keys or values or their combination as needed).
+    ///
+    /// Computes in **O(n log n + c)** time and **O(n)** space where *n* is
+    /// the length of the map and *c* the capacity. The sort is stable.
+    pub fn sort_by<F>(&mut self, mut cmp: F)
+    where
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        });
+    }
+
+    /// Sort the key-value pairs of the map and return a by-value iterator of
+    /// the key-value pairs with the result.
+    ///
+    /// The sort is stable.
+    pub fn sorted_by<F>(self, mut cmp: F) -> IntoIter<K, V>
+    where
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        let mut entries = self.into_entries();
+        entries.sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        IntoIter::new(entries)
+    }
+
+    /// Sort the map's key-value pairs by the default ordering of the keys, but
+    /// may not preserve the order of equal elements.
+    ///
+    /// See [`sort_unstable_by`](Self::sort_unstable_by) for details.
+    pub fn sort_unstable_keys(&mut self)
+    where
+        K: Ord,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_unstable_by(move |a, b| K::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the map's key-value pairs in place using the comparison function `cmp`, but
+    /// may not preserve the order of equal elements.
+    ///
+    /// The comparison function receives two key and value pairs to compare (you
+    /// can sort by keys or values or their combination as needed).
+    ///
+    /// Computes in **O(n log n + c)** time where *n* is
+    /// the length of the map and *c* is the capacity. The sort is unstable.
+    pub fn sort_unstable_by<F>(&mut self, mut cmp: F)
+    where
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        });
+    }
+
+    /// Sort the key-value pairs of the map and return a by-value iterator of
+    /// the key-value pairs with the result.
+    ///
+    /// The sort is unstable.
+    #[inline]
+    pub fn sorted_unstable_by<F>(self, mut cmp: F) -> IntoIter<K, V>
+    where
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        let mut entries = self.into_entries();
+        entries.sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        IntoIter::new(entries)
+    }
+
+    /// Sort the map’s key-value pairs in place using a sort-key extraction function.
+    ///
+    /// During sorting, the function is called at most once per entry, by using temporary storage
+    /// to remember the results of its evaluation. The order of calls to the function is
+    /// unspecified and may change between versions of `indexmap` or the standard library.
+    ///
+    /// Computes in **O(m n + n log n + c)** time () and **O(n)** space, where the function is
+    /// **O(m)**, *n* is the length of the map, and *c* the capacity. The sort is stable.
+    pub fn sort_by_cached_key<T, F>(&mut self, mut sort_key: F)
+    where
+        T: Ord,
+        F: FnMut(&K, &V) -> T,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_by_cached_key(move |a| sort_key(&a.key, &a.value));
+        });
+    }
+
+    /// Search over a sorted map for a key.
+    ///
+    /// Returns the position where that key is present, or the position where it can be inserted to
+    /// maintain the sort. See [`slice::binary_search`] for more details.
+    ///
+    /// Computes in **O(log(n))** time, which is notably less scalable than looking the key up
+    /// using [`get_index_of`][IndexMap::get_index_of], but this can also position missing keys.
+    pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
+    where
+        K: Ord,
+    {
+        self.as_slice().binary_search_keys(x)
+    }
+
+    /// Search over a sorted map with a comparator function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a K, &'a V) -> Ordering,
+    {
+        self.as_slice().binary_search_by(f)
+    }
+
+    /// Search over a sorted map with an extraction function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a K, &'a V) -> B,
+        B: Ord,
+    {
+        self.as_slice().binary_search_by_key(b, f)
+    }
+
+    /// Returns the index of the partition point of a sorted map according to the given predicate
+    /// (the index of the first element of the second partition).
+    ///
+    /// See [`slice::partition_point`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[must_use]
+    pub fn partition_point<P>(&self, pred: P) -> usize
+    where
+        P: FnMut(&K, &V) -> bool,
+    {
+        self.as_slice().partition_point(pred)
+    }
+
+    /// Reverses the order of the map’s key-value pairs in place.
+    ///
+    /// Computes in **O(n)** time and **O(1)** space.
+    pub fn reverse(&mut self) {
+        self.core.reverse()
+    }
+
+    /// Returns a slice of all the key-value pairs in the map.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn as_slice(&self) -> &Slice<K, V> {
+        Slice::from_slice(self.as_entries())
+    }
+
+    /// Returns a mutable slice of all the key-value pairs in the map.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn as_mut_slice(&mut self) -> &mut Slice<K, V> {
+        Slice::from_mut_slice(self.as_entries_mut())
+    }
+
+    /// Converts into a boxed slice of all the key-value pairs in the map.
+    ///
+    /// Note that this will drop the inner hash table and any excess capacity.
+    pub fn into_boxed_slice(self) -> Box<Slice<K, V>> {
+        Slice::from_boxed(self.into_entries().into_boxed_slice())
+    }
+
+    /// Get a key-value pair by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_index(&self, index: usize) -> Option<(&K, &V)> {
+        self.as_entries().get(index).map(Bucket::refs)
+    }
+
+    /// Get a key-value pair by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)> {
+        self.as_entries_mut().get_mut(index).map(Bucket::ref_mut)
+    }
+
+    /// Get an entry in the map by index for in-place manipulation.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_index_entry(&mut self, index: usize) -> Option<IndexedEntry<'_, K, V>> {
+        if index >= self.len() {
+            return None;
+        }
+        Some(IndexedEntry::new(&mut self.core, index))
+    }
+
+    /// Get an array of `N` key-value pairs by `N` indices
+    ///
+    /// Valid indices are *0 <= index < self.len()* and each index needs to be unique.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut map = indexmap::IndexMap::from([(1, 'a'), (3, 'b'), (2, 'c')]);
+    /// assert_eq!(map.get_disjoint_indices_mut([2, 0]), Ok([(&2, &mut 'c'), (&1, &mut 'a')]));
+    /// ```
+    pub fn get_disjoint_indices_mut<const N: usize>(
+        &mut self,
+        indices: [usize; N],
+    ) -> Result<[(&K, &mut V); N], GetDisjointMutError> {
+        self.as_mut_slice().get_disjoint_mut(indices)
+    }
+
+    /// Returns a slice of key-value pairs in the given range of indices.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Slice<K, V>> {
+        let entries = self.as_entries();
+        let range = try_simplify_range(range, entries.len())?;
+        entries.get(range).map(Slice::from_slice)
+    }
+
+    /// Returns a mutable slice of key-value pairs in the given range of indices.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_range_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Option<&mut Slice<K, V>> {
+        let entries = self.as_entries_mut();
+        let range = try_simplify_range(range, entries.len())?;
+        entries.get_mut(range).map(Slice::from_mut_slice)
+    }
+
+    /// Get the first key-value pair
+    ///
+    /// Computes in **O(1)** time.
+    #[doc(alias = "first_key_value")] // like `BTreeMap`
+    pub fn first(&self) -> Option<(&K, &V)> {
+        self.as_entries().first().map(Bucket::refs)
+    }
+
+    /// Get the first key-value pair, with mutable access to the value
+    ///
+    /// Computes in **O(1)** time.
+    pub fn first_mut(&mut self) -> Option<(&K, &mut V)> {
+        self.as_entries_mut().first_mut().map(Bucket::ref_mut)
+    }
+
+    /// Get the first entry in the map for in-place manipulation.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn first_entry(&mut self) -> Option<IndexedEntry<'_, K, V>> {
+        self.get_index_entry(0)
+    }
+
+    /// Get the last key-value pair
+    ///
+    /// Computes in **O(1)** time.
+    #[doc(alias = "last_key_value")] // like `BTreeMap`
+    pub fn last(&self) -> Option<(&K, &V)> {
+        self.as_entries().last().map(Bucket::refs)
+    }
+
+    /// Get the last key-value pair, with mutable access to the value
+    ///
+    /// Computes in **O(1)** time.
+    pub fn last_mut(&mut self) -> Option<(&K, &mut V)> {
+        self.as_entries_mut().last_mut().map(Bucket::ref_mut)
+    }
+
+    /// Get the last entry in the map for in-place manipulation.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn last_entry(&mut self) -> Option<IndexedEntry<'_, K, V>> {
+        self.get_index_entry(self.len().checked_sub(1)?)
+    }
+
+    /// Remove the key-value pair by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
+    /// last element of the map and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_index(&mut self, index: usize) -> Option<(K, V)> {
+        self.core.swap_remove_index(index)
+    }
+
+    /// Remove the key-value pair by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Like [`Vec::remove`], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_index(&mut self, index: usize) -> Option<(K, V)> {
+        self.core.shift_remove_index(index)
+    }
+
+    /// Moves the position of a key-value pair from one index to another
+    /// by shifting all other pairs in-between.
+    ///
+    /// * If `from < to`, the other pairs will shift down while the targeted pair moves up.
+    /// * If `from > to`, the other pairs will shift up while the targeted pair moves down.
+    ///
+    /// ***Panics*** if `from` or `to` are out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    #[track_caller]
+    pub fn move_index(&mut self, from: usize, to: usize) {
+        self.core.move_index(from, to)
+    }
+
+    /// Swaps the position of two key-value pairs in the map.
+    ///
+    /// ***Panics*** if `a` or `b` are out of bounds.
+    ///
+    /// Computes in **O(1)** time (average).
+    #[track_caller]
+    pub fn swap_indices(&mut self, a: usize, b: usize) {
+        self.core.swap_indices(a, b)
+    }
+}
+
+/// Access [`IndexMap`] values corresponding to a key.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+///     map.insert(word.to_lowercase(), word.to_uppercase());
+/// }
+/// assert_eq!(map["lorem"], "LOREM");
+/// assert_eq!(map["ipsum"], "IPSUM");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// map.insert("foo", 1);
+/// println!("{:?}", map["bar"]); // panics!
+/// ```
+impl<K, V, Q: ?Sized, S> Index<&Q> for IndexMap<K, V, S>
+where
+    Q: Hash + Equivalent<K>,
+    S: BuildHasher,
+{
+    type Output = V;
+
+    /// Returns a reference to the value corresponding to the supplied `key`.
+    ///
+    /// ***Panics*** if `key` is not present in the map.
+    fn index(&self, key: &Q) -> &V {
+        self.get(key).expect("no entry found for key")
+    }
+}
+
+/// Access [`IndexMap`] values corresponding to a key.
+///
+/// Mutable indexing allows changing / updating values of key-value
+/// pairs that are already present.
+///
+/// You can **not** insert new pairs with index syntax, use `.insert()`.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+///     map.insert(word.to_lowercase(), word.to_string());
+/// }
+/// let lorem = &mut map["lorem"];
+/// assert_eq!(lorem, "Lorem");
+/// lorem.retain(char::is_lowercase);
+/// assert_eq!(map["lorem"], "orem");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// map.insert("foo", 1);
+/// map["bar"] = 1; // panics!
+/// ```
+impl<K, V, Q: ?Sized, S> IndexMut<&Q> for IndexMap<K, V, S>
+where
+    Q: Hash + Equivalent<K>,
+    S: BuildHasher,
+{
+    /// Returns a mutable reference to the value corresponding to the supplied `key`.
+    ///
+    /// ***Panics*** if `key` is not present in the map.
+    fn index_mut(&mut self, key: &Q) -> &mut V {
+        self.get_mut(key).expect("no entry found for key")
+    }
+}
+
+/// Access [`IndexMap`] values at indexed positions.
+///
+/// See [`Index<usize> for Keys`][keys] to access a map's keys instead.
+///
+/// [keys]: Keys#impl-Index<usize>-for-Keys<'a,+K,+V>
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+///     map.insert(word.to_lowercase(), word.to_uppercase());
+/// }
+/// assert_eq!(map[0], "LOREM");
+/// assert_eq!(map[1], "IPSUM");
+/// map.reverse();
+/// assert_eq!(map[0], "AMET");
+/// assert_eq!(map[1], "SIT");
+/// map.sort_keys();
+/// assert_eq!(map[0], "AMET");
+/// assert_eq!(map[1], "DOLOR");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// map.insert("foo", 1);
+/// println!("{:?}", map[10]); // panics!
+/// ```
+impl<K, V, S> Index<usize> for IndexMap<K, V, S> {
+    type Output = V;
+
+    /// Returns a reference to the value at the supplied `index`.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    fn index(&self, index: usize) -> &V {
+        self.get_index(index)
+            .unwrap_or_else(|| {
+                panic!(
+                    "index out of bounds: the len is {len} but the index is {index}",
+                    len = self.len()
+                );
+            })
+            .1
+    }
+}
+
+/// Access [`IndexMap`] values at indexed positions.
+///
+/// Mutable indexing allows changing / updating indexed values
+/// that are already present.
+///
+/// You can **not** insert new values with index syntax -- use [`.insert()`][IndexMap::insert].
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+///     map.insert(word.to_lowercase(), word.to_string());
+/// }
+/// let lorem = &mut map[0];
+/// assert_eq!(lorem, "Lorem");
+/// lorem.retain(char::is_lowercase);
+/// assert_eq!(map["lorem"], "orem");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// map.insert("foo", 1);
+/// map[10] = 1; // panics!
+/// ```
+impl<K, V, S> IndexMut<usize> for IndexMap<K, V, S> {
+    /// Returns a mutable reference to the value at the supplied `index`.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    fn index_mut(&mut self, index: usize) -> &mut V {
+        let len: usize = self.len();
+
+        self.get_index_mut(index)
+            .unwrap_or_else(|| {
+                panic!("index out of bounds: the len is {len} but the index is {index}");
+            })
+            .1
+    }
+}
+
+impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S>
+where
+    K: Hash + Eq,
+    S: BuildHasher + Default,
+{
+    /// Create an `IndexMap` from the sequence of key-value pairs in the
+    /// iterable.
+    ///
+    /// `from_iter` uses the same logic as `extend`. See
+    /// [`extend`][IndexMap::extend] for more details.
+    fn from_iter<I: IntoIterator<Item = (K, V)>>(iterable: I) -> Self {
+        let iter = iterable.into_iter();
+        let (low, _) = iter.size_hint();
+        let mut map = Self::with_capacity_and_hasher(low, <_>::default());
+        map.extend(iter);
+        map
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl<K, V, const N: usize> From<[(K, V); N]> for IndexMap<K, V, RandomState>
+where
+    K: Hash + Eq,
+{
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexMap;
+    ///
+    /// let map1 = IndexMap::from([(1, 2), (3, 4)]);
+    /// let map2: IndexMap<_, _> = [(1, 2), (3, 4)].into();
+    /// assert_eq!(map1, map2);
+    /// ```
+    fn from(arr: [(K, V); N]) -> Self {
+        Self::from_iter(arr)
+    }
+}
+
+impl<K, V, S> Extend<(K, V)> for IndexMap<K, V, S>
+where
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    /// Extend the map with all key-value pairs in the iterable.
+    ///
+    /// This is equivalent to calling [`insert`][IndexMap::insert] for each of
+    /// them in order, which means that for keys that already existed
+    /// in the map, their value is updated but it keeps the existing order.
+    ///
+    /// New keys are inserted in the order they appear in the sequence. If
+    /// equivalents of a key occur more than once, the last corresponding value
+    /// prevails.
+    fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iterable: I) {
+        // (Note: this is a copy of `std`/`hashbrown`'s reservation logic.)
+        // Keys may be already present or show multiple times in the iterator.
+        // Reserve the entire hint lower bound if the map is empty.
+        // Otherwise reserve half the hint (rounded up), so the map
+        // will only resize twice in the worst case.
+        let iter = iterable.into_iter();
+        let reserve = if self.is_empty() {
+            iter.size_hint().0
+        } else {
+            (iter.size_hint().0 + 1) / 2
+        };
+        self.reserve(reserve);
+        iter.for_each(move |(k, v)| {
+            self.insert(k, v);
+        });
+    }
+}
+
+impl<'a, K, V, S> Extend<(&'a K, &'a V)> for IndexMap<K, V, S>
+where
+    K: Hash + Eq + Copy,
+    V: Copy,
+    S: BuildHasher,
+{
+    /// Extend the map with all key-value pairs in the iterable.
+    ///
+    /// See the first extend method for more details.
+    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iterable: I) {
+        self.extend(iterable.into_iter().map(|(&key, &value)| (key, value)));
+    }
+}
+
+impl<K, V, S> Default for IndexMap<K, V, S>
+where
+    S: Default,
+{
+    /// Return an empty [`IndexMap`]
+    fn default() -> Self {
+        Self::with_capacity_and_hasher(0, S::default())
+    }
+}
+
+impl<K, V1, S1, V2, S2> PartialEq<IndexMap<K, V2, S2>> for IndexMap<K, V1, S1>
+where
+    K: Hash + Eq,
+    V1: PartialEq<V2>,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn eq(&self, other: &IndexMap<K, V2, S2>) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+
+        self.iter()
+            .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
+    }
+}
+
+impl<K, V, S> Eq for IndexMap<K, V, S>
+where
+    K: Eq + Hash,
+    V: Eq,
+    S: BuildHasher,
+{
+}
diff --git a/vendor/indexmap/src/map/core.rs b/vendor/indexmap/src/map/core.rs
new file mode 100644
index 00000000..9022c8ee
--- /dev/null
+++ b/vendor/indexmap/src/map/core.rs
@@ -0,0 +1,738 @@
+//! This is the core implementation that doesn't depend on the hasher at all.
+//!
+//! The methods of `IndexMapCore` don't use any Hash properties of K.
+//!
+//! It's cleaner to separate them out, then the compiler checks that we are not
+//! using Hash at all in these methods.
+//!
+//! However, we should probably not let this show in the public API or docs.
+
+mod entry;
+
+pub mod raw_entry_v1;
+
+use hashbrown::hash_table;
+
+use crate::vec::{self, Vec};
+use crate::TryReserveError;
+use core::mem;
+use core::ops::RangeBounds;
+
+use crate::util::simplify_range;
+use crate::{Bucket, Equivalent, HashValue};
+
+type Indices = hash_table::HashTable<usize>;
+type Entries<K, V> = Vec<Bucket<K, V>>;
+
+pub use entry::{Entry, IndexedEntry, OccupiedEntry, VacantEntry};
+
+/// Core of the map that does not depend on S
+#[derive(Debug)]
+pub(crate) struct IndexMapCore<K, V> {
+    /// indices mapping from the entry hash to its index.
+    indices: Indices,
+    /// entries is a dense vec maintaining entry order.
+    entries: Entries<K, V>,
+}
+
+/// Mutable references to the parts of an `IndexMapCore`.
+///
+/// When using `HashTable::find_entry`, that takes hold of `&mut indices`, so we have to borrow our
+/// `&mut entries` separately, and there's no way to go back to a `&mut IndexMapCore`. So this type
+/// is used to implement methods on the split references, and `IndexMapCore` can also call those to
+/// avoid duplication.
+struct RefMut<'a, K, V> {
+    indices: &'a mut Indices,
+    entries: &'a mut Entries<K, V>,
+}
+
+#[inline(always)]
+fn get_hash<K, V>(entries: &[Bucket<K, V>]) -> impl Fn(&usize) -> u64 + '_ {
+    move |&i| entries[i].hash.get()
+}
+
+#[inline]
+fn equivalent<'a, K, V, Q: ?Sized + Equivalent<K>>(
+    key: &'a Q,
+    entries: &'a [Bucket<K, V>],
+) -> impl Fn(&usize) -> bool + 'a {
+    move |&i| Q::equivalent(key, &entries[i].key)
+}
+
+#[inline]
+fn erase_index(table: &mut Indices, hash: HashValue, index: usize) {
+    if let Ok(entry) = table.find_entry(hash.get(), move |&i| i == index) {
+        entry.remove();
+    } else if cfg!(debug_assertions) {
+        panic!("index not found");
+    }
+}
+
+#[inline]
+fn update_index(table: &mut Indices, hash: HashValue, old: usize, new: usize) {
+    let index = table
+        .find_mut(hash.get(), move |&i| i == old)
+        .expect("index not found");
+    *index = new;
+}
+
+/// Inserts many entries into the indices table without reallocating,
+/// and without regard for duplication.
+///
+/// ***Panics*** if there is not sufficient capacity already.
+fn insert_bulk_no_grow<K, V>(indices: &mut Indices, entries: &[Bucket<K, V>]) {
+    assert!(indices.capacity() - indices.len() >= entries.len());
+    for entry in entries {
+        indices.insert_unique(entry.hash.get(), indices.len(), |_| unreachable!());
+    }
+}
+
+impl<K, V> Clone for IndexMapCore<K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    fn clone(&self) -> Self {
+        let mut new = Self::new();
+        new.clone_from(self);
+        new
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.indices.clone_from(&other.indices);
+        if self.entries.capacity() < other.entries.len() {
+            // If we must resize, match the indices capacity.
+            let additional = other.entries.len() - self.entries.len();
+            self.borrow_mut().reserve_entries(additional);
+        }
+        self.entries.clone_from(&other.entries);
+    }
+}
+
+impl<K, V> crate::Entries for IndexMapCore<K, V> {
+    type Entry = Bucket<K, V>;
+
+    #[inline]
+    fn into_entries(self) -> Vec<Self::Entry> {
+        self.entries
+    }
+
+    #[inline]
+    fn as_entries(&self) -> &[Self::Entry] {
+        &self.entries
+    }
+
+    #[inline]
+    fn as_entries_mut(&mut self) -> &mut [Self::Entry] {
+        &mut self.entries
+    }
+
+    fn with_entries<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut [Self::Entry]),
+    {
+        f(&mut self.entries);
+        self.rebuild_hash_table();
+    }
+}
+
+impl<K, V> IndexMapCore<K, V> {
+    /// The maximum capacity before the `entries` allocation would exceed `isize::MAX`.
+    const MAX_ENTRIES_CAPACITY: usize = (isize::MAX as usize) / mem::size_of::<Bucket<K, V>>();
+
+    #[inline]
+    pub(crate) const fn new() -> Self {
+        IndexMapCore {
+            indices: Indices::new(),
+            entries: Vec::new(),
+        }
+    }
+
+    #[inline]
+    fn borrow_mut(&mut self) -> RefMut<'_, K, V> {
+        RefMut::new(&mut self.indices, &mut self.entries)
+    }
+
+    #[inline]
+    pub(crate) fn with_capacity(n: usize) -> Self {
+        IndexMapCore {
+            indices: Indices::with_capacity(n),
+            entries: Vec::with_capacity(n),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn len(&self) -> usize {
+        self.indices.len()
+    }
+
+    #[inline]
+    pub(crate) fn capacity(&self) -> usize {
+        Ord::min(self.indices.capacity(), self.entries.capacity())
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.indices.clear();
+        self.entries.clear();
+    }
+
+    pub(crate) fn truncate(&mut self, len: usize) {
+        if len < self.len() {
+            self.erase_indices(len, self.entries.len());
+            self.entries.truncate(len);
+        }
+    }
+
+    #[track_caller]
+    pub(crate) fn drain<R>(&mut self, range: R) -> vec::Drain<'_, Bucket<K, V>>
+    where
+        R: RangeBounds<usize>,
+    {
+        let range = simplify_range(range, self.entries.len());
+        self.erase_indices(range.start, range.end);
+        self.entries.drain(range)
+    }
+
+    #[cfg(feature = "rayon")]
+    pub(crate) fn par_drain<R>(&mut self, range: R) -> rayon::vec::Drain<'_, Bucket<K, V>>
+    where
+        K: Send,
+        V: Send,
+        R: RangeBounds<usize>,
+    {
+        use rayon::iter::ParallelDrainRange;
+        let range = simplify_range(range, self.entries.len());
+        self.erase_indices(range.start, range.end);
+        self.entries.par_drain(range)
+    }
+
+    #[track_caller]
+    pub(crate) fn split_off(&mut self, at: usize) -> Self {
+        let len = self.entries.len();
+        assert!(
+            at <= len,
+            "index out of bounds: the len is {len} but the index is {at}. Expected index <= len"
+        );
+
+        self.erase_indices(at, self.entries.len());
+        let entries = self.entries.split_off(at);
+
+        let mut indices = Indices::with_capacity(entries.len());
+        insert_bulk_no_grow(&mut indices, &entries);
+        Self { indices, entries }
+    }
+
+    #[track_caller]
+    pub(crate) fn split_splice<R>(&mut self, range: R) -> (Self, vec::IntoIter<Bucket<K, V>>)
+    where
+        R: RangeBounds<usize>,
+    {
+        let range = simplify_range(range, self.len());
+        self.erase_indices(range.start, self.entries.len());
+        let entries = self.entries.split_off(range.end);
+        let drained = self.entries.split_off(range.start);
+
+        let mut indices = Indices::with_capacity(entries.len());
+        insert_bulk_no_grow(&mut indices, &entries);
+        (Self { indices, entries }, drained.into_iter())
+    }
+
+    /// Append from another map without checking whether items already exist.
+    pub(crate) fn append_unchecked(&mut self, other: &mut Self) {
+        self.reserve(other.len());
+        insert_bulk_no_grow(&mut self.indices, &other.entries);
+        self.entries.append(&mut other.entries);
+        other.indices.clear();
+    }
+
+    /// Reserve capacity for `additional` more key-value pairs.
+    pub(crate) fn reserve(&mut self, additional: usize) {
+        self.indices.reserve(additional, get_hash(&self.entries));
+        // Only grow entries if necessary, since we also round up capacity.
+        if additional > self.entries.capacity() - self.entries.len() {
+            self.borrow_mut().reserve_entries(additional);
+        }
+    }
+
+    /// Reserve capacity for `additional` more key-value pairs, without over-allocating.
+    pub(crate) fn reserve_exact(&mut self, additional: usize) {
+        self.indices.reserve(additional, get_hash(&self.entries));
+        self.entries.reserve_exact(additional);
+    }
+
+    /// Try to reserve capacity for `additional` more key-value pairs.
+    pub(crate) fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.indices
+            .try_reserve(additional, get_hash(&self.entries))
+            .map_err(TryReserveError::from_hashbrown)?;
+        // Only grow entries if necessary, since we also round up capacity.
+        if additional > self.entries.capacity() - self.entries.len() {
+            self.try_reserve_entries(additional)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Try to reserve entries capacity, rounded up to match the indices
+    fn try_reserve_entries(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        // Use a soft-limit on the maximum capacity, but if the caller explicitly
+        // requested more, do it and let them have the resulting error.
+        let new_capacity = Ord::min(self.indices.capacity(), Self::MAX_ENTRIES_CAPACITY);
+        let try_add = new_capacity - self.entries.len();
+        if try_add > additional && self.entries.try_reserve_exact(try_add).is_ok() {
+            return Ok(());
+        }
+        self.entries
+            .try_reserve_exact(additional)
+            .map_err(TryReserveError::from_alloc)
+    }
+
+    /// Try to reserve capacity for `additional` more key-value pairs, without over-allocating.
+    pub(crate) fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.indices
+            .try_reserve(additional, get_hash(&self.entries))
+            .map_err(TryReserveError::from_hashbrown)?;
+        self.entries
+            .try_reserve_exact(additional)
+            .map_err(TryReserveError::from_alloc)
+    }
+
+    /// Shrink the capacity of the map with a lower bound
+    pub(crate) fn shrink_to(&mut self, min_capacity: usize) {
+        self.indices
+            .shrink_to(min_capacity, get_hash(&self.entries));
+        self.entries.shrink_to(min_capacity);
+    }
+
+    /// Remove the last key-value pair
+    pub(crate) fn pop(&mut self) -> Option<(K, V)> {
+        if let Some(entry) = self.entries.pop() {
+            let last = self.entries.len();
+            erase_index(&mut self.indices, entry.hash, last);
+            Some((entry.key, entry.value))
+        } else {
+            None
+        }
+    }
+
+    /// Return the index in `entries` where an equivalent key can be found
+    pub(crate) fn get_index_of<Q>(&self, hash: HashValue, key: &Q) -> Option<usize>
+    where
+        Q: ?Sized + Equivalent<K>,
+    {
+        let eq = equivalent(key, &self.entries);
+        self.indices.find(hash.get(), eq).copied()
+    }
+
+    /// Append a key-value pair to `entries`,
+    /// *without* checking whether it already exists.
+    fn push_entry(&mut self, hash: HashValue, key: K, value: V) {
+        if self.entries.len() == self.entries.capacity() {
+            // Reserve our own capacity synced to the indices,
+            // rather than letting `Vec::push` just double it.
+            self.borrow_mut().reserve_entries(1);
+        }
+        self.entries.push(Bucket { hash, key, value });
+    }
+
+    pub(crate) fn insert_full(&mut self, hash: HashValue, key: K, value: V) -> (usize, Option<V>)
+    where
+        K: Eq,
+    {
+        let eq = equivalent(&key, &self.entries);
+        let hasher = get_hash(&self.entries);
+        match self.indices.entry(hash.get(), eq, hasher) {
+            hash_table::Entry::Occupied(entry) => {
+                let i = *entry.get();
+                (i, Some(mem::replace(&mut self.entries[i].value, value)))
+            }
+            hash_table::Entry::Vacant(entry) => {
+                let i = self.entries.len();
+                entry.insert(i);
+                self.push_entry(hash, key, value);
+                debug_assert_eq!(self.indices.len(), self.entries.len());
+                (i, None)
+            }
+        }
+    }
+
+    /// Same as `insert_full`, except it also replaces the key
+    pub(crate) fn replace_full(
+        &mut self,
+        hash: HashValue,
+        key: K,
+        value: V,
+    ) -> (usize, Option<(K, V)>)
+    where
+        K: Eq,
+    {
+        let eq = equivalent(&key, &self.entries);
+        let hasher = get_hash(&self.entries);
+        match self.indices.entry(hash.get(), eq, hasher) {
+            hash_table::Entry::Occupied(entry) => {
+                let i = *entry.get();
+                let entry = &mut self.entries[i];
+                let kv = (
+                    mem::replace(&mut entry.key, key),
+                    mem::replace(&mut entry.value, value),
+                );
+                (i, Some(kv))
+            }
+            hash_table::Entry::Vacant(entry) => {
+                let i = self.entries.len();
+                entry.insert(i);
+                self.push_entry(hash, key, value);
+                debug_assert_eq!(self.indices.len(), self.entries.len());
+                (i, None)
+            }
+        }
+    }
+
+    /// Remove an entry by shifting all entries that follow it
+    pub(crate) fn shift_remove_full<Q>(&mut self, hash: HashValue, key: &Q) -> Option<(usize, K, V)>
+    where
+        Q: ?Sized + Equivalent<K>,
+    {
+        let eq = equivalent(key, &self.entries);
+        match self.indices.find_entry(hash.get(), eq) {
+            Ok(entry) => {
+                let (index, _) = entry.remove();
+                let (key, value) = self.borrow_mut().shift_remove_finish(index);
+                Some((index, key, value))
+            }
+            Err(_) => None,
+        }
+    }
+
+    /// Remove an entry by shifting all entries that follow it
+    #[inline]
+    pub(crate) fn shift_remove_index(&mut self, index: usize) -> Option<(K, V)> {
+        self.borrow_mut().shift_remove_index(index)
+    }
+
+    #[inline]
+    #[track_caller]
+    pub(super) fn move_index(&mut self, from: usize, to: usize) {
+        self.borrow_mut().move_index(from, to);
+    }
+
+    #[inline]
+    #[track_caller]
+    pub(crate) fn swap_indices(&mut self, a: usize, b: usize) {
+        self.borrow_mut().swap_indices(a, b);
+    }
+
+    /// Remove an entry by swapping it with the last
+    pub(crate) fn swap_remove_full<Q>(&mut self, hash: HashValue, key: &Q) -> Option<(usize, K, V)>
+    where
+        Q: ?Sized + Equivalent<K>,
+    {
+        let eq = equivalent(key, &self.entries);
+        match self.indices.find_entry(hash.get(), eq) {
+            Ok(entry) => {
+                let (index, _) = entry.remove();
+                let (key, value) = self.borrow_mut().swap_remove_finish(index);
+                Some((index, key, value))
+            }
+            Err(_) => None,
+        }
+    }
+
+    /// Remove an entry by swapping it with the last
+    #[inline]
+    pub(crate) fn swap_remove_index(&mut self, index: usize) -> Option<(K, V)> {
+        self.borrow_mut().swap_remove_index(index)
+    }
+
+    /// Erase `start..end` from `indices`, and shift `end..` indices down to `start..`
+    ///
+    /// All of these items should still be at their original location in `entries`.
+    /// This is used by `drain`, which will let `Vec::drain` do the work on `entries`.
+    fn erase_indices(&mut self, start: usize, end: usize) {
+        let (init, shifted_entries) = self.entries.split_at(end);
+        let (start_entries, erased_entries) = init.split_at(start);
+
+        let erased = erased_entries.len();
+        let shifted = shifted_entries.len();
+        let half_capacity = self.indices.capacity() / 2;
+
+        // Use a heuristic between different strategies
+        if erased == 0 {
+            // Degenerate case, nothing to do
+        } else if start + shifted < half_capacity && start < erased {
+            // Reinsert everything, as there are few kept indices
+            self.indices.clear();
+
+            // Reinsert stable indices, then shifted indices
+            insert_bulk_no_grow(&mut self.indices, start_entries);
+            insert_bulk_no_grow(&mut self.indices, shifted_entries);
+        } else if erased + shifted < half_capacity {
+            // Find each affected index, as there are few to adjust
+
+            // Find erased indices
+            for (i, entry) in (start..).zip(erased_entries) {
+                erase_index(&mut self.indices, entry.hash, i);
+            }
+
+            // Find shifted indices
+            for ((new, old), entry) in (start..).zip(end..).zip(shifted_entries) {
+                update_index(&mut self.indices, entry.hash, old, new);
+            }
+        } else {
+            // Sweep the whole table for adjustments
+            let offset = end - start;
+            self.indices.retain(move |i| {
+                if *i >= end {
+                    *i -= offset;
+                    true
+                } else {
+                    *i < start
+                }
+            });
+        }
+
+        debug_assert_eq!(self.indices.len(), start + shifted);
+    }
+
+    pub(crate) fn retain_in_order<F>(&mut self, mut keep: F)
+    where
+        F: FnMut(&mut K, &mut V) -> bool,
+    {
+        self.entries
+            .retain_mut(|entry| keep(&mut entry.key, &mut entry.value));
+        if self.entries.len() < self.indices.len() {
+            self.rebuild_hash_table();
+        }
+    }
+
+    fn rebuild_hash_table(&mut self) {
+        self.indices.clear();
+        insert_bulk_no_grow(&mut self.indices, &self.entries);
+    }
+
+    pub(crate) fn reverse(&mut self) {
+        self.entries.reverse();
+
+        // No need to save hash indices, can easily calculate what they should
+        // be, given that this is an in-place reversal.
+        let len = self.entries.len();
+        for i in &mut self.indices {
+            *i = len - *i - 1;
+        }
+    }
+}
+
+/// Reserve entries capacity, rounded up to match the indices (via `try_capacity`).
+fn reserve_entries<K, V>(entries: &mut Entries<K, V>, additional: usize, try_capacity: usize) {
+    // Use a soft-limit on the maximum capacity, but if the caller explicitly
+    // requested more, do it and let them have the resulting panic.
+    let try_capacity = try_capacity.min(IndexMapCore::<K, V>::MAX_ENTRIES_CAPACITY);
+    let try_add = try_capacity - entries.len();
+    if try_add > additional && entries.try_reserve_exact(try_add).is_ok() {
+        return;
+    }
+    entries.reserve_exact(additional);
+}
+
+impl<'a, K, V> RefMut<'a, K, V> {
+    #[inline]
+    fn new(indices: &'a mut Indices, entries: &'a mut Entries<K, V>) -> Self {
+        Self { indices, entries }
+    }
+
+    /// Reserve entries capacity, rounded up to match the indices
+    #[inline]
+    fn reserve_entries(&mut self, additional: usize) {
+        reserve_entries(self.entries, additional, self.indices.capacity());
+    }
+
+    /// Insert a key-value pair in `entries`,
+    /// *without* checking whether it already exists.
+    fn insert_unique(self, hash: HashValue, key: K, value: V) -> OccupiedEntry<'a, K, V> {
+        let i = self.indices.len();
+        debug_assert_eq!(i, self.entries.len());
+        let entry = self
+            .indices
+            .insert_unique(hash.get(), i, get_hash(self.entries));
+        if self.entries.len() == self.entries.capacity() {
+            // We can't call `indices.capacity()` while this `entry` has borrowed it, so we'll have
+            // to amortize growth on our own. It's still an improvement over the basic `Vec::push`
+            // doubling though, since we also consider `MAX_ENTRIES_CAPACITY`.
+            reserve_entries(self.entries, 1, 2 * self.entries.capacity());
+        }
+        self.entries.push(Bucket { hash, key, value });
+        OccupiedEntry::new(self.entries, entry)
+    }
+
+    /// Insert a key-value pair in `entries` at a particular index,
+    /// *without* checking whether it already exists.
+    fn shift_insert_unique(&mut self, index: usize, hash: HashValue, key: K, value: V) {
+        let end = self.indices.len();
+        assert!(index <= end);
+        // Increment others first so we don't have duplicate indices.
+        self.increment_indices(index, end);
+        let entries = &*self.entries;
+        self.indices.insert_unique(hash.get(), index, move |&i| {
+            // Adjust for the incremented indices to find hashes.
+            debug_assert_ne!(i, index);
+            let i = if i < index { i } else { i - 1 };
+            entries[i].hash.get()
+        });
+        if self.entries.len() == self.entries.capacity() {
+            // Reserve our own capacity synced to the indices,
+            // rather than letting `Vec::insert` just double it.
+            self.reserve_entries(1);
+        }
+        self.entries.insert(index, Bucket { hash, key, value });
+    }
+
+    /// Remove an entry by shifting all entries that follow it
+    fn shift_remove_index(&mut self, index: usize) -> Option<(K, V)> {
+        match self.entries.get(index) {
+            Some(entry) => {
+                erase_index(self.indices, entry.hash, index);
+                Some(self.shift_remove_finish(index))
+            }
+            None => None,
+        }
+    }
+
+    /// Remove an entry by shifting all entries that follow it
+    ///
+    /// The index should already be removed from `self.indices`.
+    fn shift_remove_finish(&mut self, index: usize) -> (K, V) {
+        // Correct indices that point to the entries that followed the removed entry.
+        self.decrement_indices(index + 1, self.entries.len());
+
+        // Use Vec::remove to actually remove the entry.
+        let entry = self.entries.remove(index);
+        (entry.key, entry.value)
+    }
+
+    /// Remove an entry by swapping it with the last
+    fn swap_remove_index(&mut self, index: usize) -> Option<(K, V)> {
+        match self.entries.get(index) {
+            Some(entry) => {
+                erase_index(self.indices, entry.hash, index);
+                Some(self.swap_remove_finish(index))
+            }
+            None => None,
+        }
+    }
+
+    /// Finish removing an entry by swapping it with the last
+    ///
+    /// The index should already be removed from `self.indices`.
+    fn swap_remove_finish(&mut self, index: usize) -> (K, V) {
+        // use swap_remove, but then we need to update the index that points
+        // to the other entry that has to move
+        let entry = self.entries.swap_remove(index);
+
+        // correct index that points to the entry that had to swap places
+        if let Some(entry) = self.entries.get(index) {
+            // was not last element
+            // examine new element in `index` and find it in indices
+            let last = self.entries.len();
+            update_index(self.indices, entry.hash, last, index);
+        }
+
+        (entry.key, entry.value)
+    }
+
+    /// Decrement all indices in the range `start..end`.
+    ///
+    /// The index `start - 1` should not exist in `self.indices`.
+    /// All entries should still be in their original positions.
+    fn decrement_indices(&mut self, start: usize, end: usize) {
+        // Use a heuristic between a full sweep vs. a `find()` for every shifted item.
+        let shifted_entries = &self.entries[start..end];
+        if shifted_entries.len() > self.indices.capacity() / 2 {
+            // Shift all indices in range.
+            for i in &mut *self.indices {
+                if start <= *i && *i < end {
+                    *i -= 1;
+                }
+            }
+        } else {
+            // Find each entry in range to shift its index.
+            for (i, entry) in (start..end).zip(shifted_entries) {
+                update_index(self.indices, entry.hash, i, i - 1);
+            }
+        }
+    }
+
+    /// Increment all indices in the range `start..end`.
+    ///
+    /// The index `end` should not exist in `self.indices`.
+    /// All entries should still be in their original positions.
+    fn increment_indices(&mut self, start: usize, end: usize) {
+        // Use a heuristic between a full sweep vs. a `find()` for every shifted item.
+        let shifted_entries = &self.entries[start..end];
+        if shifted_entries.len() > self.indices.capacity() / 2 {
+            // Shift all indices in range.
+            for i in &mut *self.indices {
+                if start <= *i && *i < end {
+                    *i += 1;
+                }
+            }
+        } else {
+            // Find each entry in range to shift its index, updated in reverse so
+            // we never have duplicated indices that might have a hash collision.
+            for (i, entry) in (start..end).zip(shifted_entries).rev() {
+                update_index(self.indices, entry.hash, i, i + 1);
+            }
+        }
+    }
+
+    #[track_caller]
+    fn move_index(&mut self, from: usize, to: usize) {
+        let from_hash = self.entries[from].hash;
+        let _ = self.entries[to]; // explicit bounds check
+        if from != to {
+            // Use a sentinel index so other indices don't collide.
+            update_index(self.indices, from_hash, from, usize::MAX);
+
+            // Update all other indices and rotate the entry positions.
+            if from < to {
+                self.decrement_indices(from + 1, to + 1);
+                self.entries[from..=to].rotate_left(1);
+            } else if to < from {
+                self.increment_indices(to, from);
+                self.entries[to..=from].rotate_right(1);
+            }
+
+            // Change the sentinel index to its final position.
+            update_index(self.indices, from_hash, usize::MAX, to);
+        }
+    }
+
+    #[track_caller]
+    fn swap_indices(&mut self, a: usize, b: usize) {
+        // If they're equal and in-bounds, there's nothing to do.
+        if a == b && a < self.entries.len() {
+            return;
+        }
+
+        // We'll get a "nice" bounds-check from indexing `entries`,
+        // and then we expect to find it in the table as well.
+        match self.indices.get_many_mut(
+            [self.entries[a].hash.get(), self.entries[b].hash.get()],
+            move |i, &x| if i == 0 { x == a } else { x == b },
+        ) {
+            [Some(ref_a), Some(ref_b)] => {
+                mem::swap(ref_a, ref_b);
+                self.entries.swap(a, b);
+            }
+            _ => panic!("indices not found"),
+        }
+    }
+}
+
+#[test]
+fn assert_send_sync() {
+    fn assert_send_sync<T: Send + Sync>() {}
+    assert_send_sync::<IndexMapCore<i32, i32>>();
+    assert_send_sync::<Entry<'_, i32, i32>>();
+    assert_send_sync::<IndexedEntry<'_, i32, i32>>();
+    assert_send_sync::<raw_entry_v1::RawEntryMut<'_, i32, i32, ()>>();
+}
diff --git a/vendor/indexmap/src/map/core/entry.rs b/vendor/indexmap/src/map/core/entry.rs
new file mode 100644
index 00000000..6ab29ca5
--- /dev/null
+++ b/vendor/indexmap/src/map/core/entry.rs
@@ -0,0 +1,571 @@
+use super::{equivalent, Entries, IndexMapCore, RefMut};
+use crate::HashValue;
+use core::{fmt, mem};
+use hashbrown::hash_table;
+
+impl<K, V> IndexMapCore<K, V> {
+    pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<'_, K, V>
+    where
+        K: Eq,
+    {
+        let entries = &mut self.entries;
+        let eq = equivalent(&key, entries);
+        match self.indices.find_entry(hash.get(), eq) {
+            Ok(index) => Entry::Occupied(OccupiedEntry { entries, index }),
+            Err(absent) => Entry::Vacant(VacantEntry {
+                map: RefMut::new(absent.into_table(), entries),
+                hash,
+                key,
+            }),
+        }
+    }
+}
+
+/// Entry for an existing key-value pair in an [`IndexMap`][crate::IndexMap]
+/// or a vacant location to insert one.
+pub enum Entry<'a, K, V> {
+    /// Existing slot with equivalent key.
+    Occupied(OccupiedEntry<'a, K, V>),
+    /// Vacant slot (no equivalent key in the map).
+    Vacant(VacantEntry<'a, K, V>),
+}
+
+impl<'a, K, V> Entry<'a, K, V> {
+    /// Return the index where the key-value pair exists or will be inserted.
+    pub fn index(&self) -> usize {
+        match *self {
+            Entry::Occupied(ref entry) => entry.index(),
+            Entry::Vacant(ref entry) => entry.index(),
+        }
+    }
+
+    /// Sets the value of the entry (after inserting if vacant), and returns an `OccupiedEntry`.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+        match self {
+            Entry::Occupied(mut entry) => {
+                entry.insert(value);
+                entry
+            }
+            Entry::Vacant(entry) => entry.insert_entry(value),
+        }
+    }
+
+    /// Inserts the given default value in the entry if it is vacant and returns a mutable
+    /// reference to it. Otherwise a mutable reference to an already existent value is returned.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn or_insert(self, default: V) -> &'a mut V {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(default),
+        }
+    }
+
+    /// Inserts the result of the `call` function in the entry if it is vacant and returns a mutable
+    /// reference to it. Otherwise a mutable reference to an already existent value is returned.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn or_insert_with<F>(self, call: F) -> &'a mut V
+    where
+        F: FnOnce() -> V,
+    {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(call()),
+        }
+    }
+
+    /// Inserts the result of the `call` function with a reference to the entry's key if it is
+    /// vacant, and returns a mutable reference to the new value. Otherwise a mutable reference to
+    /// an already existent value is returned.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn or_insert_with_key<F>(self, call: F) -> &'a mut V
+    where
+        F: FnOnce(&K) -> V,
+    {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => {
+                let value = call(&entry.key);
+                entry.insert(value)
+            }
+        }
+    }
+
+    /// Gets a reference to the entry's key, either within the map if occupied,
+    /// or else the new key that was used to find the entry.
+    pub fn key(&self) -> &K {
+        match *self {
+            Entry::Occupied(ref entry) => entry.key(),
+            Entry::Vacant(ref entry) => entry.key(),
+        }
+    }
+
+    /// Modifies the entry if it is occupied.
+    pub fn and_modify<F>(mut self, f: F) -> Self
+    where
+        F: FnOnce(&mut V),
+    {
+        if let Entry::Occupied(entry) = &mut self {
+            f(entry.get_mut());
+        }
+        self
+    }
+
+    /// Inserts a default-constructed value in the entry if it is vacant and returns a mutable
+    /// reference to it. Otherwise a mutable reference to an already existent value is returned.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn or_default(self) -> &'a mut V
+    where
+        V: Default,
+    {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(V::default()),
+        }
+    }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Entry<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut tuple = f.debug_tuple("Entry");
+        match self {
+            Entry::Vacant(v) => tuple.field(v),
+            Entry::Occupied(o) => tuple.field(o),
+        };
+        tuple.finish()
+    }
+}
+
+/// A view into an occupied entry in an [`IndexMap`][crate::IndexMap].
+/// It is part of the [`Entry`] enum.
+pub struct OccupiedEntry<'a, K, V> {
+    entries: &'a mut Entries<K, V>,
+    index: hash_table::OccupiedEntry<'a, usize>,
+}
+
+impl<'a, K, V> OccupiedEntry<'a, K, V> {
+    pub(crate) fn new(
+        entries: &'a mut Entries<K, V>,
+        index: hash_table::OccupiedEntry<'a, usize>,
+    ) -> Self {
+        Self { entries, index }
+    }
+
+    /// Return the index of the key-value pair
+    #[inline]
+    pub fn index(&self) -> usize {
+        *self.index.get()
+    }
+
+    #[inline]
+    fn into_ref_mut(self) -> RefMut<'a, K, V> {
+        RefMut::new(self.index.into_table(), self.entries)
+    }
+
+    /// Gets a reference to the entry's key in the map.
+    ///
+    /// Note that this is not the key that was used to find the entry. There may be an observable
+    /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+    /// extra fields or the memory address of an allocation.
+    pub fn key(&self) -> &K {
+        &self.entries[self.index()].key
+    }
+
+    pub(crate) fn key_mut(&mut self) -> &mut K {
+        let index = self.index();
+        &mut self.entries[index].key
+    }
+
+    /// Gets a reference to the entry's value in the map.
+    pub fn get(&self) -> &V {
+        &self.entries[self.index()].value
+    }
+
+    /// Gets a mutable reference to the entry's value in the map.
+    ///
+    /// If you need a reference which may outlive the destruction of the
+    /// [`Entry`] value, see [`into_mut`][Self::into_mut].
+    pub fn get_mut(&mut self) -> &mut V {
+        let index = self.index();
+        &mut self.entries[index].value
+    }
+
+    /// Converts into a mutable reference to the entry's value in the map,
+    /// with a lifetime bound to the map itself.
+    pub fn into_mut(self) -> &'a mut V {
+        let index = self.index();
+        &mut self.entries[index].value
+    }
+
+    pub(super) fn into_muts(self) -> (&'a mut K, &'a mut V) {
+        let index = self.index();
+        self.entries[index].muts()
+    }
+
+    /// Sets the value of the entry to `value`, and returns the entry's old value.
+    pub fn insert(&mut self, value: V) -> V {
+        mem::replace(self.get_mut(), value)
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove()`][Self::swap_remove], replacing this
+    /// entry's position with the last element, and it is deprecated in favor of calling that
+    /// explicitly. If you need to preserve the relative order of the keys in the map, use
+    /// [`.shift_remove()`][Self::shift_remove] instead.
+    #[deprecated(note = "`remove` disrupts the map order -- \
+        use `swap_remove` or `shift_remove` for explicit behavior.")]
+    pub fn remove(self) -> V {
+        self.swap_remove()
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+    /// the last element of the map and popping it off.
+    /// **This perturbs the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove(self) -> V {
+        self.swap_remove_entry().1
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove(self) -> V {
+        self.shift_remove_entry().1
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove_entry()`][Self::swap_remove_entry],
+    /// replacing this entry's position with the last element, and it is deprecated in favor of
+    /// calling that explicitly. If you need to preserve the relative order of the keys in the map,
+    /// use [`.shift_remove_entry()`][Self::shift_remove_entry] instead.
+    #[deprecated(note = "`remove_entry` disrupts the map order -- \
+        use `swap_remove_entry` or `shift_remove_entry` for explicit behavior.")]
+    pub fn remove_entry(self) -> (K, V) {
+        self.swap_remove_entry()
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+    /// the last element of the map and popping it off.
+    /// **This perturbs the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_entry(self) -> (K, V) {
+        let (index, entry) = self.index.remove();
+        RefMut::new(entry.into_table(), self.entries).swap_remove_finish(index)
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_entry(self) -> (K, V) {
+        let (index, entry) = self.index.remove();
+        RefMut::new(entry.into_table(), self.entries).shift_remove_finish(index)
+    }
+
+    /// Moves the position of the entry to a new index
+    /// by shifting all other entries in-between.
+    ///
+    /// This is equivalent to [`IndexMap::move_index`][`crate::IndexMap::move_index`]
+    /// coming `from` the current [`.index()`][Self::index].
+    ///
+    /// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up.
+    /// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down.
+    ///
+    /// ***Panics*** if `to` is out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    #[track_caller]
+    pub fn move_index(self, to: usize) {
+        let index = self.index();
+        self.into_ref_mut().move_index(index, to);
+    }
+
+    /// Swaps the position of entry with another.
+    ///
+    /// This is equivalent to [`IndexMap::swap_indices`][`crate::IndexMap::swap_indices`]
+    /// with the current [`.index()`][Self::index] as one of the two being swapped.
+    ///
+    /// ***Panics*** if the `other` index is out of bounds.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_indices(self, other: usize) {
+        let index = self.index();
+        self.into_ref_mut().swap_indices(index, other);
+    }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for OccupiedEntry<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OccupiedEntry")
+            .field("key", self.key())
+            .field("value", self.get())
+            .finish()
+    }
+}
+
+impl<'a, K, V> From<IndexedEntry<'a, K, V>> for OccupiedEntry<'a, K, V> {
+    fn from(other: IndexedEntry<'a, K, V>) -> Self {
+        let IndexedEntry {
+            map: RefMut { indices, entries },
+            index,
+        } = other;
+        let hash = entries[index].hash;
+        Self {
+            entries,
+            index: indices
+                .find_entry(hash.get(), move |&i| i == index)
+                .expect("index not found"),
+        }
+    }
+}
+
+/// A view into a vacant entry in an [`IndexMap`][crate::IndexMap].
+/// It is part of the [`Entry`] enum.
+pub struct VacantEntry<'a, K, V> {
+    map: RefMut<'a, K, V>,
+    hash: HashValue,
+    key: K,
+}
+
+impl<'a, K, V> VacantEntry<'a, K, V> {
+    /// Return the index where a key-value pair may be inserted.
+    pub fn index(&self) -> usize {
+        self.map.indices.len()
+    }
+
+    /// Gets a reference to the key that was used to find the entry.
+    pub fn key(&self) -> &K {
+        &self.key
+    }
+
+    pub(crate) fn key_mut(&mut self) -> &mut K {
+        &mut self.key
+    }
+
+    /// Takes ownership of the key, leaving the entry vacant.
+    pub fn into_key(self) -> K {
+        self.key
+    }
+
+    /// Inserts the entry's key and the given value into the map, and returns a mutable reference
+    /// to the value.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert(self, value: V) -> &'a mut V {
+        self.insert_entry(value).into_mut()
+    }
+
+    /// Inserts the entry's key and the given value into the map, and returns an `OccupiedEntry`.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+        let Self { map, hash, key } = self;
+        map.insert_unique(hash, key, value)
+    }
+
+    /// Inserts the entry's key and the given value into the map at its ordered
+    /// position among sorted keys, and returns the new index and a mutable
+    /// reference to the value.
+    ///
+    /// If the existing keys are **not** already sorted, then the insertion
+    /// index is unspecified (like [`slice::binary_search`]), but the key-value
+    /// pair is inserted at that position regardless.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn insert_sorted(self, value: V) -> (usize, &'a mut V)
+    where
+        K: Ord,
+    {
+        let slice = crate::map::Slice::from_slice(self.map.entries);
+        let i = slice.binary_search_keys(&self.key).unwrap_err();
+        (i, self.shift_insert(i, value))
+    }
+
+    /// Inserts the entry's key and the given value into the map at the given index,
+    /// shifting others to the right, and returns a mutable reference to the value.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_insert(mut self, index: usize, value: V) -> &'a mut V {
+        self.map
+            .shift_insert_unique(index, self.hash, self.key, value);
+        &mut self.map.entries[index].value
+    }
+}
+
+impl<K: fmt::Debug, V> fmt::Debug for VacantEntry<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("VacantEntry").field(self.key()).finish()
+    }
+}
+
+/// A view into an occupied entry in an [`IndexMap`][crate::IndexMap] obtained by index.
+///
+/// This `struct` is created from the [`get_index_entry`][crate::IndexMap::get_index_entry] method.
+pub struct IndexedEntry<'a, K, V> {
+    map: RefMut<'a, K, V>,
+    // We have a mutable reference to the map, which keeps the index
+    // valid and pointing to the correct entry.
+    index: usize,
+}
+
+impl<'a, K, V> IndexedEntry<'a, K, V> {
+    pub(crate) fn new(map: &'a mut IndexMapCore<K, V>, index: usize) -> Self {
+        Self {
+            map: map.borrow_mut(),
+            index,
+        }
+    }
+
+    /// Return the index of the key-value pair
+    #[inline]
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Gets a reference to the entry's key in the map.
+    pub fn key(&self) -> &K {
+        &self.map.entries[self.index].key
+    }
+
+    pub(crate) fn key_mut(&mut self) -> &mut K {
+        &mut self.map.entries[self.index].key
+    }
+
+    /// Gets a reference to the entry's value in the map.
+    pub fn get(&self) -> &V {
+        &self.map.entries[self.index].value
+    }
+
+    /// Gets a mutable reference to the entry's value in the map.
+    ///
+    /// If you need a reference which may outlive the destruction of the
+    /// `IndexedEntry` value, see [`into_mut`][Self::into_mut].
+    pub fn get_mut(&mut self) -> &mut V {
+        &mut self.map.entries[self.index].value
+    }
+
+    /// Sets the value of the entry to `value`, and returns the entry's old value.
+    pub fn insert(&mut self, value: V) -> V {
+        mem::replace(self.get_mut(), value)
+    }
+
+    /// Converts into a mutable reference to the entry's value in the map,
+    /// with a lifetime bound to the map itself.
+    pub fn into_mut(self) -> &'a mut V {
+        &mut self.map.entries[self.index].value
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+    /// the last element of the map and popping it off.
+    /// **This perturbs the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_entry(mut self) -> (K, V) {
+        self.map.swap_remove_index(self.index).unwrap()
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_entry(mut self) -> (K, V) {
+        self.map.shift_remove_index(self.index).unwrap()
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+    /// the last element of the map and popping it off.
+    /// **This perturbs the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove(self) -> V {
+        self.swap_remove_entry().1
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove(self) -> V {
+        self.shift_remove_entry().1
+    }
+
+    /// Moves the position of the entry to a new index
+    /// by shifting all other entries in-between.
+    ///
+    /// This is equivalent to [`IndexMap::move_index`][`crate::IndexMap::move_index`]
+    /// coming `from` the current [`.index()`][Self::index].
+    ///
+    /// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up.
+    /// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down.
+    ///
+    /// ***Panics*** if `to` is out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    #[track_caller]
+    pub fn move_index(mut self, to: usize) {
+        self.map.move_index(self.index, to);
+    }
+
+    /// Swaps the position of entry with another.
+    ///
+    /// This is equivalent to [`IndexMap::swap_indices`][`crate::IndexMap::swap_indices`]
+    /// with the current [`.index()`][Self::index] as one of the two being swapped.
+    ///
+    /// ***Panics*** if the `other` index is out of bounds.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_indices(mut self, other: usize) {
+        self.map.swap_indices(self.index, other);
+    }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IndexedEntry<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("IndexedEntry")
+            .field("index", &self.index)
+            .field("key", self.key())
+            .field("value", self.get())
+            .finish()
+    }
+}
+
+impl<'a, K, V> From<OccupiedEntry<'a, K, V>> for IndexedEntry<'a, K, V> {
+    fn from(other: OccupiedEntry<'a, K, V>) -> Self {
+        Self {
+            index: other.index(),
+            map: other.into_ref_mut(),
+        }
+    }
+}
diff --git a/vendor/indexmap/src/map/core/raw_entry_v1.rs b/vendor/indexmap/src/map/core/raw_entry_v1.rs
new file mode 100644
index 00000000..757a3cee
--- /dev/null
+++ b/vendor/indexmap/src/map/core/raw_entry_v1.rs
@@ -0,0 +1,665 @@
+//! Opt-in access to the experimental raw entry API.
+//!
+//! This module is designed to mimic the raw entry API of [`HashMap`][std::collections::hash_map],
+//! matching its unstable state as of Rust 1.75. See the tracking issue
+//! [rust#56167](https://github.com/rust-lang/rust/issues/56167) for more details.
+//!
+//! The trait [`RawEntryApiV1`] and the `_v1` suffix on its methods are meant to insulate this for
+//! the future, in case later breaking changes are needed. If the standard library stabilizes its
+//! `hash_raw_entry` feature (or some replacement), matching *inherent* methods will be added to
+//! `IndexMap` without such an opt-in trait.
+
+use super::{Entries, RefMut};
+use crate::{Equivalent, HashValue, IndexMap};
+use core::fmt;
+use core::hash::{BuildHasher, Hash, Hasher};
+use core::marker::PhantomData;
+use core::mem;
+use hashbrown::hash_table;
+
+/// Opt-in access to the experimental raw entry API.
+///
+/// See the [`raw_entry_v1`][self] module documentation for more information.
+pub trait RawEntryApiV1<K, V, S>: private::Sealed {
+    /// Creates a raw immutable entry builder for the [`IndexMap`].
+    ///
+    /// Raw entries provide the lowest level of control for searching and
+    /// manipulating a map. They must be manually initialized with a hash and
+    /// then manually searched.
+    ///
+    /// This is useful for
+    /// * Hash memoization
+    /// * Using a search key that doesn't work with the [`Equivalent`] trait
+    /// * Using custom comparison logic without newtype wrappers
+    ///
+    /// Unless you are in such a situation, higher-level and more foolproof APIs like
+    /// [`get`][IndexMap::get] should be preferred.
+    ///
+    /// Immutable raw entries have very limited use; you might instead want
+    /// [`raw_entry_mut_v1`][Self::raw_entry_mut_v1].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use core::hash::{BuildHasher, Hash};
+    /// use indexmap::map::{IndexMap, RawEntryApiV1};
+    ///
+    /// let mut map = IndexMap::new();
+    /// map.extend([("a", 100), ("b", 200), ("c", 300)]);
+    ///
+    /// fn compute_hash<K: Hash + ?Sized, S: BuildHasher>(hash_builder: &S, key: &K) -> u64 {
+    ///     use core::hash::Hasher;
+    ///     let mut state = hash_builder.build_hasher();
+    ///     key.hash(&mut state);
+    ///     state.finish()
+    /// }
+    ///
+    /// for k in ["a", "b", "c", "d", "e", "f"] {
+    ///     let hash = compute_hash(map.hasher(), k);
+    ///     let i = map.get_index_of(k);
+    ///     let v = map.get(k);
+    ///     let kv = map.get_key_value(k);
+    ///     let ikv = map.get_full(k);
+    ///
+    ///     println!("Key: {} and value: {:?}", k, v);
+    ///
+    ///     assert_eq!(map.raw_entry_v1().from_key(k), kv);
+    ///     assert_eq!(map.raw_entry_v1().from_hash(hash, |q| *q == k), kv);
+    ///     assert_eq!(map.raw_entry_v1().from_key_hashed_nocheck(hash, k), kv);
+    ///     assert_eq!(map.raw_entry_v1().from_hash_full(hash, |q| *q == k), ikv);
+    ///     assert_eq!(map.raw_entry_v1().index_from_hash(hash, |q| *q == k), i);
+    /// }
+    /// ```
+    fn raw_entry_v1(&self) -> RawEntryBuilder<'_, K, V, S>;
+
+    /// Creates a raw entry builder for the [`IndexMap`].
+    ///
+    /// Raw entries provide the lowest level of control for searching and
+    /// manipulating a map. They must be manually initialized with a hash and
+    /// then manually searched. After this, insertions into a vacant entry
+    /// still require an owned key to be provided.
+    ///
+    /// Raw entries are useful for such exotic situations as:
+    ///
+    /// * Hash memoization
+    /// * Deferring the creation of an owned key until it is known to be required
+    /// * Using a search key that doesn't work with the [`Equivalent`] trait
+    /// * Using custom comparison logic without newtype wrappers
+    ///
+    /// Because raw entries provide much more low-level control, it's much easier
+    /// to put the `IndexMap` into an inconsistent state which, while memory-safe,
+    /// will cause the map to produce seemingly random results. Higher-level and more
+    /// foolproof APIs like [`entry`][IndexMap::entry] should be preferred when possible.
+    ///
+    /// Raw entries give mutable access to the keys. This must not be used
+    /// to modify how the key would compare or hash, as the map will not re-evaluate
+    /// where the key should go, meaning the keys may become "lost" if their
+    /// location does not reflect their state. For instance, if you change a key
+    /// so that the map now contains keys which compare equal, search may start
+    /// acting erratically, with two keys randomly masking each other. Implementations
+    /// are free to assume this doesn't happen (within the limits of memory-safety).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use core::hash::{BuildHasher, Hash};
+    /// use indexmap::map::{IndexMap, RawEntryApiV1};
+    /// use indexmap::map::raw_entry_v1::RawEntryMut;
+    ///
+    /// let mut map = IndexMap::new();
+    /// map.extend([("a", 100), ("b", 200), ("c", 300)]);
+    ///
+    /// fn compute_hash<K: Hash + ?Sized, S: BuildHasher>(hash_builder: &S, key: &K) -> u64 {
+    ///     use core::hash::Hasher;
+    ///     let mut state = hash_builder.build_hasher();
+    ///     key.hash(&mut state);
+    ///     state.finish()
+    /// }
+    ///
+    /// // Existing key (insert and update)
+    /// match map.raw_entry_mut_v1().from_key("a") {
+    ///     RawEntryMut::Vacant(_) => unreachable!(),
+    ///     RawEntryMut::Occupied(mut view) => {
+    ///         assert_eq!(view.index(), 0);
+    ///         assert_eq!(view.get(), &100);
+    ///         let v = view.get_mut();
+    ///         let new_v = (*v) * 10;
+    ///         *v = new_v;
+    ///         assert_eq!(view.insert(1111), 1000);
+    ///     }
+    /// }
+    ///
+    /// assert_eq!(map["a"], 1111);
+    /// assert_eq!(map.len(), 3);
+    ///
+    /// // Existing key (take)
+    /// let hash = compute_hash(map.hasher(), "c");
+    /// match map.raw_entry_mut_v1().from_key_hashed_nocheck(hash, "c") {
+    ///     RawEntryMut::Vacant(_) => unreachable!(),
+    ///     RawEntryMut::Occupied(view) => {
+    ///         assert_eq!(view.index(), 2);
+    ///         assert_eq!(view.shift_remove_entry(), ("c", 300));
+    ///     }
+    /// }
+    /// assert_eq!(map.raw_entry_v1().from_key("c"), None);
+    /// assert_eq!(map.len(), 2);
+    ///
+    /// // Nonexistent key (insert and update)
+    /// let key = "d";
+    /// let hash = compute_hash(map.hasher(), key);
+    /// match map.raw_entry_mut_v1().from_hash(hash, |q| *q == key) {
+    ///     RawEntryMut::Occupied(_) => unreachable!(),
+    ///     RawEntryMut::Vacant(view) => {
+    ///         assert_eq!(view.index(), 2);
+    ///         let (k, value) = view.insert("d", 4000);
+    ///         assert_eq!((*k, *value), ("d", 4000));
+    ///         *value = 40000;
+    ///     }
+    /// }
+    /// assert_eq!(map["d"], 40000);
+    /// assert_eq!(map.len(), 3);
+    ///
+    /// match map.raw_entry_mut_v1().from_hash(hash, |q| *q == key) {
+    ///     RawEntryMut::Vacant(_) => unreachable!(),
+    ///     RawEntryMut::Occupied(view) => {
+    ///         assert_eq!(view.index(), 2);
+    ///         assert_eq!(view.swap_remove_entry(), ("d", 40000));
+    ///     }
+    /// }
+    /// assert_eq!(map.get("d"), None);
+    /// assert_eq!(map.len(), 2);
+    /// ```
+    fn raw_entry_mut_v1(&mut self) -> RawEntryBuilderMut<'_, K, V, S>;
+}
+
+impl<K, V, S> RawEntryApiV1<K, V, S> for IndexMap<K, V, S> {
+    fn raw_entry_v1(&self) -> RawEntryBuilder<'_, K, V, S> {
+        RawEntryBuilder { map: self }
+    }
+
+    fn raw_entry_mut_v1(&mut self) -> RawEntryBuilderMut<'_, K, V, S> {
+        RawEntryBuilderMut { map: self }
+    }
+}
+
+/// A builder for computing where in an [`IndexMap`] a key-value pair would be stored.
+///
+/// This `struct` is created by the [`IndexMap::raw_entry_v1`] method, provided by the
+/// [`RawEntryApiV1`] trait. See its documentation for more.
+pub struct RawEntryBuilder<'a, K, V, S> {
+    map: &'a IndexMap<K, V, S>,
+}
+
+impl<K, V, S> fmt::Debug for RawEntryBuilder<'_, K, V, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RawEntryBuilder").finish_non_exhaustive()
+    }
+}
+
+impl<'a, K, V, S> RawEntryBuilder<'a, K, V, S> {
+    /// Access an entry by key.
+    pub fn from_key<Q>(self, key: &Q) -> Option<(&'a K, &'a V)>
+    where
+        S: BuildHasher,
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        self.map.get_key_value(key)
+    }
+
+    /// Access an entry by a key and its hash.
+    pub fn from_key_hashed_nocheck<Q>(self, hash: u64, key: &Q) -> Option<(&'a K, &'a V)>
+    where
+        Q: ?Sized + Equivalent<K>,
+    {
+        let hash = HashValue(hash as usize);
+        let i = self.map.core.get_index_of(hash, key)?;
+        self.map.get_index(i)
+    }
+
+    /// Access an entry by hash.
+    pub fn from_hash<F>(self, hash: u64, is_match: F) -> Option<(&'a K, &'a V)>
+    where
+        F: FnMut(&K) -> bool,
+    {
+        let map = self.map;
+        let i = self.index_from_hash(hash, is_match)?;
+        map.get_index(i)
+    }
+
+    /// Access an entry by hash, including its index.
+    pub fn from_hash_full<F>(self, hash: u64, is_match: F) -> Option<(usize, &'a K, &'a V)>
+    where
+        F: FnMut(&K) -> bool,
+    {
+        let map = self.map;
+        let i = self.index_from_hash(hash, is_match)?;
+        let (key, value) = map.get_index(i)?;
+        Some((i, key, value))
+    }
+
+    /// Access the index of an entry by hash.
+    pub fn index_from_hash<F>(self, hash: u64, mut is_match: F) -> Option<usize>
+    where
+        F: FnMut(&K) -> bool,
+    {
+        let hash = HashValue(hash as usize);
+        let entries = &*self.map.core.entries;
+        let eq = move |&i: &usize| is_match(&entries[i].key);
+        self.map.core.indices.find(hash.get(), eq).copied()
+    }
+}
+
+/// A builder for computing where in an [`IndexMap`] a key-value pair would be stored.
+///
+/// This `struct` is created by the [`IndexMap::raw_entry_mut_v1`] method, provided by the
+/// [`RawEntryApiV1`] trait. See its documentation for more.
+pub struct RawEntryBuilderMut<'a, K, V, S> {
+    map: &'a mut IndexMap<K, V, S>,
+}
+
+impl<K, V, S> fmt::Debug for RawEntryBuilderMut<'_, K, V, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RawEntryBuilderMut").finish_non_exhaustive()
+    }
+}
+
+impl<'a, K, V, S> RawEntryBuilderMut<'a, K, V, S> {
+    /// Access an entry by key.
+    pub fn from_key<Q>(self, key: &Q) -> RawEntryMut<'a, K, V, S>
+    where
+        S: BuildHasher,
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        let hash = self.map.hash(key);
+        self.from_key_hashed_nocheck(hash.get(), key)
+    }
+
+    /// Access an entry by a key and its hash.
+    pub fn from_key_hashed_nocheck<Q>(self, hash: u64, key: &Q) -> RawEntryMut<'a, K, V, S>
+    where
+        Q: ?Sized + Equivalent<K>,
+    {
+        self.from_hash(hash, |k| Q::equivalent(key, k))
+    }
+
+    /// Access an entry by hash.
+    pub fn from_hash<F>(self, hash: u64, mut is_match: F) -> RawEntryMut<'a, K, V, S>
+    where
+        F: FnMut(&K) -> bool,
+    {
+        let ref_entries = &*self.map.core.entries;
+        let eq = move |&i: &usize| is_match(&ref_entries[i].key);
+        match self.map.core.indices.find_entry(hash, eq) {
+            Ok(index) => RawEntryMut::Occupied(RawOccupiedEntryMut {
+                entries: &mut self.map.core.entries,
+                index,
+                hash_builder: PhantomData,
+            }),
+            Err(absent) => RawEntryMut::Vacant(RawVacantEntryMut {
+                map: RefMut::new(absent.into_table(), &mut self.map.core.entries),
+                hash_builder: &self.map.hash_builder,
+            }),
+        }
+    }
+}
+
+/// Raw entry for an existing key-value pair or a vacant location to
+/// insert one.
+pub enum RawEntryMut<'a, K, V, S> {
+    /// Existing slot with equivalent key.
+    Occupied(RawOccupiedEntryMut<'a, K, V, S>),
+    /// Vacant slot (no equivalent key in the map).
+    Vacant(RawVacantEntryMut<'a, K, V, S>),
+}
+
+impl<K: fmt::Debug, V: fmt::Debug, S> fmt::Debug for RawEntryMut<'_, K, V, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut tuple = f.debug_tuple("RawEntryMut");
+        match self {
+            Self::Vacant(v) => tuple.field(v),
+            Self::Occupied(o) => tuple.field(o),
+        };
+        tuple.finish()
+    }
+}
+
+impl<'a, K, V, S> RawEntryMut<'a, K, V, S> {
+    /// Return the index where the key-value pair exists or may be inserted.
+    #[inline]
+    pub fn index(&self) -> usize {
+        match self {
+            Self::Occupied(entry) => entry.index(),
+            Self::Vacant(entry) => entry.index(),
+        }
+    }
+
+    /// Inserts the given default key and value in the entry if it is vacant and returns mutable
+    /// references to them. Otherwise mutable references to an already existent pair are returned.
+    pub fn or_insert(self, default_key: K, default_value: V) -> (&'a mut K, &'a mut V)
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
+        match self {
+            Self::Occupied(entry) => entry.into_key_value_mut(),
+            Self::Vacant(entry) => entry.insert(default_key, default_value),
+        }
+    }
+
+    /// Inserts the result of the `call` function in the entry if it is vacant and returns mutable
+    /// references to them. Otherwise mutable references to an already existent pair are returned.
+    pub fn or_insert_with<F>(self, call: F) -> (&'a mut K, &'a mut V)
+    where
+        F: FnOnce() -> (K, V),
+        K: Hash,
+        S: BuildHasher,
+    {
+        match self {
+            Self::Occupied(entry) => entry.into_key_value_mut(),
+            Self::Vacant(entry) => {
+                let (key, value) = call();
+                entry.insert(key, value)
+            }
+        }
+    }
+
+    /// Modifies the entry if it is occupied.
+    pub fn and_modify<F>(mut self, f: F) -> Self
+    where
+        F: FnOnce(&mut K, &mut V),
+    {
+        if let Self::Occupied(entry) = &mut self {
+            let (k, v) = entry.get_key_value_mut();
+            f(k, v);
+        }
+        self
+    }
+}
+
+/// A raw view into an occupied entry in an [`IndexMap`].
+/// It is part of the [`RawEntryMut`] enum.
+pub struct RawOccupiedEntryMut<'a, K, V, S> {
+    entries: &'a mut Entries<K, V>,
+    index: hash_table::OccupiedEntry<'a, usize>,
+    hash_builder: PhantomData<&'a S>,
+}
+
+impl<K: fmt::Debug, V: fmt::Debug, S> fmt::Debug for RawOccupiedEntryMut<'_, K, V, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RawOccupiedEntryMut")
+            .field("key", self.key())
+            .field("value", self.get())
+            .finish_non_exhaustive()
+    }
+}
+
+impl<'a, K, V, S> RawOccupiedEntryMut<'a, K, V, S> {
+    /// Return the index of the key-value pair
+    #[inline]
+    pub fn index(&self) -> usize {
+        *self.index.get()
+    }
+
+    #[inline]
+    fn into_ref_mut(self) -> RefMut<'a, K, V> {
+        RefMut::new(self.index.into_table(), self.entries)
+    }
+
+    /// Gets a reference to the entry's key in the map.
+    ///
+    /// Note that this is not the key that was used to find the entry. There may be an observable
+    /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+    /// extra fields or the memory address of an allocation.
+    pub fn key(&self) -> &K {
+        &self.entries[self.index()].key
+    }
+
+    /// Gets a mutable reference to the entry's key in the map.
+    ///
+    /// Note that this is not the key that was used to find the entry. There may be an observable
+    /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+    /// extra fields or the memory address of an allocation.
+    pub fn key_mut(&mut self) -> &mut K {
+        let index = self.index();
+        &mut self.entries[index].key
+    }
+
+    /// Converts into a mutable reference to the entry's key in the map,
+    /// with a lifetime bound to the map itself.
+    ///
+    /// Note that this is not the key that was used to find the entry. There may be an observable
+    /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+    /// extra fields or the memory address of an allocation.
+    pub fn into_key(self) -> &'a mut K {
+        let index = self.index();
+        &mut self.entries[index].key
+    }
+
+    /// Gets a reference to the entry's value in the map.
+    pub fn get(&self) -> &V {
+        &self.entries[self.index()].value
+    }
+
+    /// Gets a mutable reference to the entry's value in the map.
+    ///
+    /// If you need a reference which may outlive the destruction of the
+    /// [`RawEntryMut`] value, see [`into_mut`][Self::into_mut].
+    pub fn get_mut(&mut self) -> &mut V {
+        let index = self.index();
+        &mut self.entries[index].value
+    }
+
+    /// Converts into a mutable reference to the entry's value in the map,
+    /// with a lifetime bound to the map itself.
+    pub fn into_mut(self) -> &'a mut V {
+        let index = self.index();
+        &mut self.entries[index].value
+    }
+
+    /// Gets a reference to the entry's key and value in the map.
+    pub fn get_key_value(&self) -> (&K, &V) {
+        self.entries[self.index()].refs()
+    }
+
+    /// Gets a reference to the entry's key and value in the map.
+    pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V) {
+        let index = self.index();
+        self.entries[index].muts()
+    }
+
+    /// Converts into a mutable reference to the entry's key and value in the map,
+    /// with a lifetime bound to the map itself.
+    pub fn into_key_value_mut(self) -> (&'a mut K, &'a mut V) {
+        let index = self.index();
+        self.entries[index].muts()
+    }
+
+    /// Sets the value of the entry, and returns the entry's old value.
+    pub fn insert(&mut self, value: V) -> V {
+        mem::replace(self.get_mut(), value)
+    }
+
+    /// Sets the key of the entry, and returns the entry's old key.
+    pub fn insert_key(&mut self, key: K) -> K {
+        mem::replace(self.key_mut(), key)
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove()`][Self::swap_remove], replacing this
+    /// entry's position with the last element, and it is deprecated in favor of calling that
+    /// explicitly. If you need to preserve the relative order of the keys in the map, use
+    /// [`.shift_remove()`][Self::shift_remove] instead.
+    #[deprecated(note = "`remove` disrupts the map order -- \
+        use `swap_remove` or `shift_remove` for explicit behavior.")]
+    pub fn remove(self) -> V {
+        self.swap_remove()
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+    /// the last element of the map and popping it off.
+    /// **This perturbs the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove(self) -> V {
+        self.swap_remove_entry().1
+    }
+
+    /// Remove the key, value pair stored in the map for this entry, and return the value.
+    ///
+    /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove(self) -> V {
+        self.shift_remove_entry().1
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove_entry()`][Self::swap_remove_entry],
+    /// replacing this entry's position with the last element, and it is deprecated in favor of
+    /// calling that explicitly. If you need to preserve the relative order of the keys in the map,
+    /// use [`.shift_remove_entry()`][Self::shift_remove_entry] instead.
+    #[deprecated(note = "`remove_entry` disrupts the map order -- \
+        use `swap_remove_entry` or `shift_remove_entry` for explicit behavior.")]
+    pub fn remove_entry(self) -> (K, V) {
+        self.swap_remove_entry()
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+    /// the last element of the map and popping it off.
+    /// **This perturbs the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_entry(self) -> (K, V) {
+        let (index, entry) = self.index.remove();
+        RefMut::new(entry.into_table(), self.entries).swap_remove_finish(index)
+    }
+
+    /// Remove and return the key, value pair stored in the map for this entry
+    ///
+    /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_entry(self) -> (K, V) {
+        let (index, entry) = self.index.remove();
+        RefMut::new(entry.into_table(), self.entries).shift_remove_finish(index)
+    }
+
+    /// Moves the position of the entry to a new index
+    /// by shifting all other entries in-between.
+    ///
+    /// This is equivalent to [`IndexMap::move_index`]
+    /// coming `from` the current [`.index()`][Self::index].
+    ///
+    /// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up.
+    /// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down.
+    ///
+    /// ***Panics*** if `to` is out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn move_index(self, to: usize) {
+        let index = self.index();
+        self.into_ref_mut().move_index(index, to);
+    }
+
+    /// Swaps the position of entry with another.
+    ///
+    /// This is equivalent to [`IndexMap::swap_indices`]
+    /// with the current [`.index()`][Self::index] as one of the two being swapped.
+    ///
+    /// ***Panics*** if the `other` index is out of bounds.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_indices(self, other: usize) {
+        let index = self.index();
+        self.into_ref_mut().swap_indices(index, other);
+    }
+}
+
+/// A view into a vacant raw entry in an [`IndexMap`].
+/// It is part of the [`RawEntryMut`] enum.
+pub struct RawVacantEntryMut<'a, K, V, S> {
+    map: RefMut<'a, K, V>,
+    hash_builder: &'a S,
+}
+
+impl<K, V, S> fmt::Debug for RawVacantEntryMut<'_, K, V, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RawVacantEntryMut").finish_non_exhaustive()
+    }
+}
+
+impl<'a, K, V, S> RawVacantEntryMut<'a, K, V, S> {
+    /// Return the index where a key-value pair may be inserted.
+    pub fn index(&self) -> usize {
+        self.map.indices.len()
+    }
+
+    /// Inserts the given key and value into the map,
+    /// and returns mutable references to them.
+    pub fn insert(self, key: K, value: V) -> (&'a mut K, &'a mut V)
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
+        let mut h = self.hash_builder.build_hasher();
+        key.hash(&mut h);
+        self.insert_hashed_nocheck(h.finish(), key, value)
+    }
+
+    /// Inserts the given key and value into the map with the provided hash,
+    /// and returns mutable references to them.
+    pub fn insert_hashed_nocheck(self, hash: u64, key: K, value: V) -> (&'a mut K, &'a mut V) {
+        let hash = HashValue(hash as usize);
+        self.map.insert_unique(hash, key, value).into_muts()
+    }
+
+    /// Inserts the given key and value into the map at the given index,
+    /// shifting others to the right, and returns mutable references to them.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_insert(self, index: usize, key: K, value: V) -> (&'a mut K, &'a mut V)
+    where
+        K: Hash,
+        S: BuildHasher,
+    {
+        let mut h = self.hash_builder.build_hasher();
+        key.hash(&mut h);
+        self.shift_insert_hashed_nocheck(index, h.finish(), key, value)
+    }
+
+    /// Inserts the given key and value into the map with the provided hash
+    /// at the given index, and returns mutable references to them.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_insert_hashed_nocheck(
+        mut self,
+        index: usize,
+        hash: u64,
+        key: K,
+        value: V,
+    ) -> (&'a mut K, &'a mut V) {
+        let hash = HashValue(hash as usize);
+        self.map.shift_insert_unique(index, hash, key, value);
+        self.map.entries[index].muts()
+    }
+}
+
+mod private {
+    pub trait Sealed {}
+
+    impl<K, V, S> Sealed for super::IndexMap<K, V, S> {}
+}
diff --git a/vendor/indexmap/src/map/iter.rs b/vendor/indexmap/src/map/iter.rs
new file mode 100644
index 00000000..cce9abed
--- /dev/null
+++ b/vendor/indexmap/src/map/iter.rs
@@ -0,0 +1,776 @@
+use super::core::IndexMapCore;
+use super::{Bucket, Entries, IndexMap, Slice};
+
+use alloc::vec::{self, Vec};
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::iter::FusedIterator;
+use core::ops::{Index, RangeBounds};
+use core::slice;
+
+impl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S> {
+    type Item = (&'a K, &'a V);
+    type IntoIter = Iter<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S> {
+    type Item = (&'a K, &'a mut V);
+    type IntoIter = IterMut<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter_mut()
+    }
+}
+
+impl<K, V, S> IntoIterator for IndexMap<K, V, S> {
+    type Item = (K, V);
+    type IntoIter = IntoIter<K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.into_entries())
+    }
+}
+
+/// An iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::iter`] method.
+/// See its documentation for more.
+pub struct Iter<'a, K, V> {
+    iter: slice::Iter<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Iter<'a, K, V> {
+    pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
+        Self {
+            iter: entries.iter(),
+        }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &'a Slice<K, V> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+}
+
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+    type Item = (&'a K, &'a V);
+
+    iterator_methods!(Bucket::refs);
+}
+
+impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::refs);
+}
+
+impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for Iter<'_, K, V> {}
+
+// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
+impl<K, V> Clone for Iter<'_, K, V> {
+    fn clone(&self) -> Self {
+        Iter {
+            iter: self.iter.clone(),
+        }
+    }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl<K, V> Default for Iter<'_, K, V> {
+    fn default() -> Self {
+        Self { iter: [].iter() }
+    }
+}
+
+/// A mutable iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::iter_mut`] method.
+/// See its documentation for more.
+pub struct IterMut<'a, K, V> {
+    iter: slice::IterMut<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> IterMut<'a, K, V> {
+    pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
+        Self {
+            iter: entries.iter_mut(),
+        }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &Slice<K, V> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+
+    /// Returns a mutable slice of the remaining entries in the iterator.
+    ///
+    /// To avoid creating `&mut` references that alias, this is forced to consume the iterator.
+    pub fn into_slice(self) -> &'a mut Slice<K, V> {
+        Slice::from_mut_slice(self.iter.into_slice())
+    }
+}
+
+impl<'a, K, V> Iterator for IterMut<'a, K, V> {
+    type Item = (&'a K, &'a mut V);
+
+    iterator_methods!(Bucket::ref_mut);
+}
+
+impl<K, V> DoubleEndedIterator for IterMut<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::ref_mut);
+}
+
+impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for IterMut<'_, K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K, V> Default for IterMut<'_, K, V> {
+    fn default() -> Self {
+        Self {
+            iter: [].iter_mut(),
+        }
+    }
+}
+
+/// A mutable iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`MutableKeys::iter_mut2`][super::MutableKeys::iter_mut2] method.
+/// See its documentation for more.
+pub struct IterMut2<'a, K, V> {
+    iter: slice::IterMut<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> IterMut2<'a, K, V> {
+    pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
+        Self {
+            iter: entries.iter_mut(),
+        }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &Slice<K, V> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+
+    /// Returns a mutable slice of the remaining entries in the iterator.
+    ///
+    /// To avoid creating `&mut` references that alias, this is forced to consume the iterator.
+    pub fn into_slice(self) -> &'a mut Slice<K, V> {
+        Slice::from_mut_slice(self.iter.into_slice())
+    }
+}
+
+impl<'a, K, V> Iterator for IterMut2<'a, K, V> {
+    type Item = (&'a mut K, &'a mut V);
+
+    iterator_methods!(Bucket::muts);
+}
+
+impl<K, V> DoubleEndedIterator for IterMut2<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::muts);
+}
+
+impl<K, V> ExactSizeIterator for IterMut2<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for IterMut2<'_, K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut2<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K, V> Default for IterMut2<'_, K, V> {
+    fn default() -> Self {
+        Self {
+            iter: [].iter_mut(),
+        }
+    }
+}
+
+/// An owning iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_iter`] method
+/// (provided by the [`IntoIterator`] trait). See its documentation for more.
+#[derive(Clone)]
+pub struct IntoIter<K, V> {
+    iter: vec::IntoIter<Bucket<K, V>>,
+}
+
+impl<K, V> IntoIter<K, V> {
+    pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
+        Self {
+            iter: entries.into_iter(),
+        }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &Slice<K, V> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+
+    /// Returns a mutable slice of the remaining entries in the iterator.
+    pub fn as_mut_slice(&mut self) -> &mut Slice<K, V> {
+        Slice::from_mut_slice(self.iter.as_mut_slice())
+    }
+}
+
+impl<K, V> Iterator for IntoIter<K, V> {
+    type Item = (K, V);
+
+    iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
+    double_ended_iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for IntoIter<K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K, V> Default for IntoIter<K, V> {
+    fn default() -> Self {
+        Self {
+            iter: Vec::new().into_iter(),
+        }
+    }
+}
+
+/// A draining iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::drain`] method.
+/// See its documentation for more.
+pub struct Drain<'a, K, V> {
+    iter: vec::Drain<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Drain<'a, K, V> {
+    pub(super) fn new(iter: vec::Drain<'a, Bucket<K, V>>) -> Self {
+        Self { iter }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &Slice<K, V> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+}
+
+impl<K, V> Iterator for Drain<'_, K, V> {
+    type Item = (K, V);
+
+    iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> DoubleEndedIterator for Drain<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> ExactSizeIterator for Drain<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for Drain<'_, K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Drain<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+/// An iterator over the keys of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::keys`] method.
+/// See its documentation for more.
+pub struct Keys<'a, K, V> {
+    iter: slice::Iter<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Keys<'a, K, V> {
+    pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
+        Self {
+            iter: entries.iter(),
+        }
+    }
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+    type Item = &'a K;
+
+    iterator_methods!(Bucket::key_ref);
+}
+
+impl<K, V> DoubleEndedIterator for Keys<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::key_ref);
+}
+
+impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for Keys<'_, K, V> {}
+
+// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
+impl<K, V> Clone for Keys<'_, K, V> {
+    fn clone(&self) -> Self {
+        Keys {
+            iter: self.iter.clone(),
+        }
+    }
+}
+
+impl<K: fmt::Debug, V> fmt::Debug for Keys<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl<K, V> Default for Keys<'_, K, V> {
+    fn default() -> Self {
+        Self { iter: [].iter() }
+    }
+}
+
+/// Access [`IndexMap`] keys at indexed positions.
+///
+/// While [`Index<usize> for IndexMap`][values] accesses a map's values,
+/// indexing through [`IndexMap::keys`] offers an alternative to access a map's
+/// keys instead.
+///
+/// [values]: IndexMap#impl-Index<usize>-for-IndexMap<K,+V,+S>
+///
+/// Since `Keys` is also an iterator, consuming items from the iterator will
+/// offset the effective indices. Similarly, if `Keys` is obtained from
+/// [`Slice::keys`], indices will be interpreted relative to the position of
+/// that slice.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+///     map.insert(word.to_lowercase(), word.to_uppercase());
+/// }
+///
+/// assert_eq!(map[0], "LOREM");
+/// assert_eq!(map.keys()[0], "lorem");
+/// assert_eq!(map[1], "IPSUM");
+/// assert_eq!(map.keys()[1], "ipsum");
+///
+/// map.reverse();
+/// assert_eq!(map.keys()[0], "amet");
+/// assert_eq!(map.keys()[1], "sit");
+///
+/// map.sort_keys();
+/// assert_eq!(map.keys()[0], "amet");
+/// assert_eq!(map.keys()[1], "dolor");
+///
+/// // Advancing the iterator will offset the indexing
+/// let mut keys = map.keys();
+/// assert_eq!(keys[0], "amet");
+/// assert_eq!(keys.next().map(|s| &**s), Some("amet"));
+/// assert_eq!(keys[0], "dolor");
+/// assert_eq!(keys[1], "ipsum");
+///
+/// // Slices may have an offset as well
+/// let slice = &map[2..];
+/// assert_eq!(slice[0], "IPSUM");
+/// assert_eq!(slice.keys()[0], "ipsum");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// map.insert("foo", 1);
+/// println!("{:?}", map.keys()[10]); // panics!
+/// ```
+impl<K, V> Index<usize> for Keys<'_, K, V> {
+    type Output = K;
+
+    /// Returns a reference to the key at the supplied `index`.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    fn index(&self, index: usize) -> &K {
+        &self.iter.as_slice()[index].key
+    }
+}
+
+/// An owning iterator over the keys of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_keys`] method.
+/// See its documentation for more.
+pub struct IntoKeys<K, V> {
+    iter: vec::IntoIter<Bucket<K, V>>,
+}
+
+impl<K, V> IntoKeys<K, V> {
+    pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
+        Self {
+            iter: entries.into_iter(),
+        }
+    }
+}
+
+impl<K, V> Iterator for IntoKeys<K, V> {
+    type Item = K;
+
+    iterator_methods!(Bucket::key);
+}
+
+impl<K, V> DoubleEndedIterator for IntoKeys<K, V> {
+    double_ended_iterator_methods!(Bucket::key);
+}
+
+impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for IntoKeys<K, V> {}
+
+impl<K: fmt::Debug, V> fmt::Debug for IntoKeys<K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K, V> Default for IntoKeys<K, V> {
+    fn default() -> Self {
+        Self {
+            iter: Vec::new().into_iter(),
+        }
+    }
+}
+
+/// An iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::values`] method.
+/// See its documentation for more.
+pub struct Values<'a, K, V> {
+    iter: slice::Iter<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Values<'a, K, V> {
+    pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
+        Self {
+            iter: entries.iter(),
+        }
+    }
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+    type Item = &'a V;
+
+    iterator_methods!(Bucket::value_ref);
+}
+
+impl<K, V> DoubleEndedIterator for Values<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::value_ref);
+}
+
+impl<K, V> ExactSizeIterator for Values<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for Values<'_, K, V> {}
+
+// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
+impl<K, V> Clone for Values<'_, K, V> {
+    fn clone(&self) -> Self {
+        Values {
+            iter: self.iter.clone(),
+        }
+    }
+}
+
+impl<K, V: fmt::Debug> fmt::Debug for Values<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl<K, V> Default for Values<'_, K, V> {
+    fn default() -> Self {
+        Self { iter: [].iter() }
+    }
+}
+
+/// A mutable iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::values_mut`] method.
+/// See its documentation for more.
+pub struct ValuesMut<'a, K, V> {
+    iter: slice::IterMut<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> ValuesMut<'a, K, V> {
+    pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
+        Self {
+            iter: entries.iter_mut(),
+        }
+    }
+}
+
+impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
+    type Item = &'a mut V;
+
+    iterator_methods!(Bucket::value_mut);
+}
+
+impl<K, V> DoubleEndedIterator for ValuesMut<'_, K, V> {
+    double_ended_iterator_methods!(Bucket::value_mut);
+}
+
+impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
+
+impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::value_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K, V> Default for ValuesMut<'_, K, V> {
+    fn default() -> Self {
+        Self {
+            iter: [].iter_mut(),
+        }
+    }
+}
+
+/// An owning iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_values`] method.
+/// See its documentation for more.
+pub struct IntoValues<K, V> {
+    iter: vec::IntoIter<Bucket<K, V>>,
+}
+
+impl<K, V> IntoValues<K, V> {
+    pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
+        Self {
+            iter: entries.into_iter(),
+        }
+    }
+}
+
+impl<K, V> Iterator for IntoValues<K, V> {
+    type Item = V;
+
+    iterator_methods!(Bucket::value);
+}
+
+impl<K, V> DoubleEndedIterator for IntoValues<K, V> {
+    double_ended_iterator_methods!(Bucket::value);
+}
+
+impl<K, V> ExactSizeIterator for IntoValues<K, V> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<K, V> FusedIterator for IntoValues<K, V> {}
+
+impl<K, V: fmt::Debug> fmt::Debug for IntoValues<K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::value_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K, V> Default for IntoValues<K, V> {
+    fn default() -> Self {
+        Self {
+            iter: Vec::new().into_iter(),
+        }
+    }
+}
+
+/// A splicing iterator for `IndexMap`.
+///
+/// This `struct` is created by [`IndexMap::splice()`].
+/// See its documentation for more.
+pub struct Splice<'a, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    map: &'a mut IndexMap<K, V, S>,
+    tail: IndexMapCore<K, V>,
+    drain: vec::IntoIter<Bucket<K, V>>,
+    replace_with: I,
+}
+
+impl<'a, I, K, V, S> Splice<'a, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    #[track_caller]
+    pub(super) fn new<R>(map: &'a mut IndexMap<K, V, S>, range: R, replace_with: I) -> Self
+    where
+        R: RangeBounds<usize>,
+    {
+        let (tail, drain) = map.core.split_splice(range);
+        Self {
+            map,
+            tail,
+            drain,
+            replace_with,
+        }
+    }
+}
+
+impl<I, K, V, S> Drop for Splice<'_, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    fn drop(&mut self) {
+        // Finish draining unconsumed items. We don't strictly *have* to do this
+        // manually, since we already split it into separate memory, but it will
+        // match the drop order of `vec::Splice` items this way.
+        let _ = self.drain.nth(usize::MAX);
+
+        // Now insert all the new items. If a key matches an existing entry, it
+        // keeps the original position and only replaces the value, like `insert`.
+        while let Some((key, value)) = self.replace_with.next() {
+            // Since the tail is disjoint, we can try to update it first,
+            // or else insert (update or append) the primary map.
+            let hash = self.map.hash(&key);
+            if let Some(i) = self.tail.get_index_of(hash, &key) {
+                self.tail.as_entries_mut()[i].value = value;
+            } else {
+                self.map.core.insert_full(hash, key, value);
+            }
+        }
+
+        // Finally, re-append the tail
+        self.map.core.append_unchecked(&mut self.tail);
+    }
+}
+
+impl<I, K, V, S> Iterator for Splice<'_, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    type Item = (K, V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.drain.next().map(Bucket::key_value)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.drain.size_hint()
+    }
+}
+
+impl<I, K, V, S> DoubleEndedIterator for Splice<'_, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.drain.next_back().map(Bucket::key_value)
+    }
+}
+
+impl<I, K, V, S> ExactSizeIterator for Splice<'_, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    fn len(&self) -> usize {
+        self.drain.len()
+    }
+}
+
+impl<I, K, V, S> FusedIterator for Splice<'_, I, K, V, S>
+where
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+}
+
+impl<I, K, V, S> fmt::Debug for Splice<'_, I, K, V, S>
+where
+    I: fmt::Debug + Iterator<Item = (K, V)>,
+    K: fmt::Debug + Hash + Eq,
+    V: fmt::Debug,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Follow `vec::Splice` in only printing the drain and replacement
+        f.debug_struct("Splice")
+            .field("drain", &self.drain)
+            .field("replace_with", &self.replace_with)
+            .finish()
+    }
+}
diff --git a/vendor/indexmap/src/map/mutable.rs b/vendor/indexmap/src/map/mutable.rs
new file mode 100644
index 00000000..e429c8be
--- /dev/null
+++ b/vendor/indexmap/src/map/mutable.rs
@@ -0,0 +1,166 @@
+use core::hash::{BuildHasher, Hash};
+
+use super::{
+    Bucket, Entries, Entry, Equivalent, IndexMap, IndexedEntry, IterMut2, OccupiedEntry,
+    VacantEntry,
+};
+
+/// Opt-in mutable access to [`IndexMap`] keys.
+///
+/// These methods expose `&mut K`, mutable references to the key as it is stored
+/// in the map.
+/// You are allowed to modify the keys in the map **if the modification
+/// does not change the key’s hash and equality**.
+///
+/// If keys are modified erroneously, you can no longer look them up.
+/// This is sound (memory safe) but a logical error hazard (just like
+/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
+///
+/// `use` this trait to enable its methods for `IndexMap`.
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait MutableKeys: private::Sealed {
+    type Key;
+    type Value;
+
+    /// Return item index, mutable reference to key and value
+    ///
+    /// Computes in **O(1)** time (average).
+    fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut Self::Key, &mut Self::Value)>
+    where
+        Q: ?Sized + Hash + Equivalent<Self::Key>;
+
+    /// Return mutable reference to key and value at an index.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    fn get_index_mut2(&mut self, index: usize) -> Option<(&mut Self::Key, &mut Self::Value)>;
+
+    /// Return an iterator over the key-value pairs of the map, in their order
+    fn iter_mut2(&mut self) -> IterMut2<'_, Self::Key, Self::Value>;
+
+    /// Scan through each key-value pair in the map and keep those where the
+    /// closure `keep` returns `true`.
+    ///
+    /// The elements are visited in order, and remaining elements keep their
+    /// order.
+    ///
+    /// Computes in **O(n)** time (average).
+    fn retain2<F>(&mut self, keep: F)
+    where
+        F: FnMut(&mut Self::Key, &mut Self::Value) -> bool;
+}
+
+/// Opt-in mutable access to [`IndexMap`] keys.
+///
+/// See [`MutableKeys`] for more information.
+impl<K, V, S> MutableKeys for IndexMap<K, V, S>
+where
+    S: BuildHasher,
+{
+    type Key = K;
+    type Value = V;
+
+    fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
+    where
+        Q: ?Sized + Hash + Equivalent<K>,
+    {
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &mut self.as_entries_mut()[i];
+            Some((i, &mut entry.key, &mut entry.value))
+        } else {
+            None
+        }
+    }
+
+    fn get_index_mut2(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
+        self.as_entries_mut().get_mut(index).map(Bucket::muts)
+    }
+
+    fn iter_mut2(&mut self) -> IterMut2<'_, Self::Key, Self::Value> {
+        IterMut2::new(self.as_entries_mut())
+    }
+
+    fn retain2<F>(&mut self, keep: F)
+    where
+        F: FnMut(&mut K, &mut V) -> bool,
+    {
+        self.core.retain_in_order(keep);
+    }
+}
+
+/// Opt-in mutable access to [`Entry`] keys.
+///
+/// These methods expose `&mut K`, mutable references to the key as it is stored
+/// in the map.
+/// You are allowed to modify the keys in the map **if the modification
+/// does not change the key’s hash and equality**.
+///
+/// If keys are modified erroneously, you can no longer look them up.
+/// This is sound (memory safe) but a logical error hazard (just like
+/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
+///
+/// `use` this trait to enable its methods for `Entry`.
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait MutableEntryKey: private::Sealed {
+    type Key;
+
+    /// Gets a mutable reference to the entry's key, either within the map if occupied,
+    /// or else the new key that was used to find the entry.
+    fn key_mut(&mut self) -> &mut Self::Key;
+}
+
+/// Opt-in mutable access to [`Entry`] keys.
+///
+/// See [`MutableEntryKey`] for more information.
+impl<K, V> MutableEntryKey for Entry<'_, K, V> {
+    type Key = K;
+    fn key_mut(&mut self) -> &mut Self::Key {
+        match self {
+            Entry::Occupied(e) => e.key_mut(),
+            Entry::Vacant(e) => e.key_mut(),
+        }
+    }
+}
+
+/// Opt-in mutable access to [`OccupiedEntry`] keys.
+///
+/// See [`MutableEntryKey`] for more information.
+impl<K, V> MutableEntryKey for OccupiedEntry<'_, K, V> {
+    type Key = K;
+    fn key_mut(&mut self) -> &mut Self::Key {
+        self.key_mut()
+    }
+}
+
+/// Opt-in mutable access to [`VacantEntry`] keys.
+///
+/// See [`MutableEntryKey`] for more information.
+impl<K, V> MutableEntryKey for VacantEntry<'_, K, V> {
+    type Key = K;
+    fn key_mut(&mut self) -> &mut Self::Key {
+        self.key_mut()
+    }
+}
+
+/// Opt-in mutable access to [`IndexedEntry`] keys.
+///
+/// See [`MutableEntryKey`] for more information.
+impl<K, V> MutableEntryKey for IndexedEntry<'_, K, V> {
+    type Key = K;
+    fn key_mut(&mut self) -> &mut Self::Key {
+        self.key_mut()
+    }
+}
+
+mod private {
+    pub trait Sealed {}
+
+    impl<K, V, S> Sealed for super::IndexMap<K, V, S> {}
+    impl<K, V> Sealed for super::Entry<'_, K, V> {}
+    impl<K, V> Sealed for super::OccupiedEntry<'_, K, V> {}
+    impl<K, V> Sealed for super::VacantEntry<'_, K, V> {}
+    impl<K, V> Sealed for super::IndexedEntry<'_, K, V> {}
+}
diff --git a/vendor/indexmap/src/map/serde_seq.rs b/vendor/indexmap/src/map/serde_seq.rs
new file mode 100644
index 00000000..602ae7dc
--- /dev/null
+++ b/vendor/indexmap/src/map/serde_seq.rs
@@ -0,0 +1,138 @@
+//! Functions to serialize and deserialize an [`IndexMap`] as an ordered sequence.
+//!
+//! The default `serde` implementation serializes `IndexMap` as a normal map,
+//! but there is no guarantee that serialization formats will preserve the order
+//! of the key-value pairs. This module serializes `IndexMap` as a sequence of
+//! `(key, value)` elements instead, in order.
+//!
+//! This module may be used in a field attribute for derived implementations:
+//!
+//! ```
+//! # use indexmap::IndexMap;
+//! # use serde_derive::{Deserialize, Serialize};
+//! #[derive(Deserialize, Serialize)]
+//! struct Data {
+//!     #[serde(with = "indexmap::map::serde_seq")]
+//!     map: IndexMap<i32, u64>,
+//!     // ...
+//! }
+//! ```
+
+use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
+use serde::ser::{Serialize, Serializer};
+
+use core::fmt::{self, Formatter};
+use core::hash::{BuildHasher, Hash};
+use core::marker::PhantomData;
+
+use crate::map::Slice as MapSlice;
+use crate::serde::cautious_capacity;
+use crate::set::Slice as SetSlice;
+use crate::IndexMap;
+
+/// Serializes a [`map::Slice`][MapSlice] as an ordered sequence.
+///
+/// This behaves like [`crate::map::serde_seq`] for `IndexMap`, serializing a sequence
+/// of `(key, value)` pairs, rather than as a map that might not preserve order.
+impl<K, V> Serialize for MapSlice<K, V>
+where
+    K: Serialize,
+    V: Serialize,
+{
+    fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
+    where
+        T: Serializer,
+    {
+        serializer.collect_seq(self)
+    }
+}
+
+/// Serializes a [`set::Slice`][SetSlice] as an ordered sequence.
+impl<T> Serialize for SetSlice<T>
+where
+    T: Serialize,
+{
+    fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
+    where
+        Se: Serializer,
+    {
+        serializer.collect_seq(self)
+    }
+}
+
+/// Serializes an [`IndexMap`] as an ordered sequence.
+///
+/// This function may be used in a field attribute for deriving [`Serialize`]:
+///
+/// ```
+/// # use indexmap::IndexMap;
+/// # use serde_derive::Serialize;
+/// #[derive(Serialize)]
+/// struct Data {
+///     #[serde(serialize_with = "indexmap::map::serde_seq::serialize")]
+///     map: IndexMap<i32, u64>,
+///     // ...
+/// }
+/// ```
+pub fn serialize<K, V, S, T>(map: &IndexMap<K, V, S>, serializer: T) -> Result<T::Ok, T::Error>
+where
+    K: Serialize,
+    V: Serialize,
+    T: Serializer,
+{
+    serializer.collect_seq(map)
+}
+
+/// Visitor to deserialize a *sequenced* `IndexMap`
+struct SeqVisitor<K, V, S>(PhantomData<(K, V, S)>);
+
+impl<'de, K, V, S> Visitor<'de> for SeqVisitor<K, V, S>
+where
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+    S: Default + BuildHasher,
+{
+    type Value = IndexMap<K, V, S>;
+
+    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+        write!(formatter, "a sequenced map")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let capacity = cautious_capacity::<K, V>(seq.size_hint());
+        let mut map = IndexMap::with_capacity_and_hasher(capacity, S::default());
+
+        while let Some((key, value)) = seq.next_element()? {
+            map.insert(key, value);
+        }
+
+        Ok(map)
+    }
+}
+
+/// Deserializes an [`IndexMap`] from an ordered sequence.
+///
+/// This function may be used in a field attribute for deriving [`Deserialize`]:
+///
+/// ```
+/// # use indexmap::IndexMap;
+/// # use serde_derive::Deserialize;
+/// #[derive(Deserialize)]
+/// struct Data {
+///     #[serde(deserialize_with = "indexmap::map::serde_seq::deserialize")]
+///     map: IndexMap<i32, u64>,
+///     // ...
+/// }
+/// ```
+pub fn deserialize<'de, D, K, V, S>(deserializer: D) -> Result<IndexMap<K, V, S>, D::Error>
+where
+    D: Deserializer<'de>,
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+    S: Default + BuildHasher,
+{
+    deserializer.deserialize_seq(SeqVisitor(PhantomData))
+}
diff --git a/vendor/indexmap/src/map/slice.rs b/vendor/indexmap/src/map/slice.rs
new file mode 100644
index 00000000..035744ef
--- /dev/null
+++ b/vendor/indexmap/src/map/slice.rs
@@ -0,0 +1,631 @@
+use super::{
+    Bucket, Entries, IndexMap, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, Values,
+    ValuesMut,
+};
+use crate::util::{slice_eq, try_simplify_range};
+use crate::GetDisjointMutError;
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::{self, Bound, Index, IndexMut, RangeBounds};
+
+/// A dynamically-sized slice of key-value pairs in an [`IndexMap`].
+///
+/// This supports indexed operations much like a `[(K, V)]` slice,
+/// but not any hashed operations on the map keys.
+///
+/// Unlike `IndexMap`, `Slice` does consider the order for [`PartialEq`]
+/// and [`Eq`], and it also implements [`PartialOrd`], [`Ord`], and [`Hash`].
+#[repr(transparent)]
+pub struct Slice<K, V> {
+    pub(crate) entries: [Bucket<K, V>],
+}
+
+// SAFETY: `Slice<K, V>` is a transparent wrapper around `[Bucket<K, V>]`,
+// and reference lifetimes are bound together in function signatures.
+#[allow(unsafe_code)]
+impl<K, V> Slice<K, V> {
+    pub(super) const fn from_slice(entries: &[Bucket<K, V>]) -> &Self {
+        unsafe { &*(entries as *const [Bucket<K, V>] as *const Self) }
+    }
+
+    pub(super) fn from_mut_slice(entries: &mut [Bucket<K, V>]) -> &mut Self {
+        unsafe { &mut *(entries as *mut [Bucket<K, V>] as *mut Self) }
+    }
+
+    pub(super) fn from_boxed(entries: Box<[Bucket<K, V>]>) -> Box<Self> {
+        unsafe { Box::from_raw(Box::into_raw(entries) as *mut Self) }
+    }
+
+    fn into_boxed(self: Box<Self>) -> Box<[Bucket<K, V>]> {
+        unsafe { Box::from_raw(Box::into_raw(self) as *mut [Bucket<K, V>]) }
+    }
+}
+
+impl<K, V> Slice<K, V> {
+    pub(crate) fn into_entries(self: Box<Self>) -> Vec<Bucket<K, V>> {
+        self.into_boxed().into_vec()
+    }
+
+    /// Returns an empty slice.
+    pub const fn new<'a>() -> &'a Self {
+        Self::from_slice(&[])
+    }
+
+    /// Returns an empty mutable slice.
+    pub fn new_mut<'a>() -> &'a mut Self {
+        Self::from_mut_slice(&mut [])
+    }
+
+    /// Return the number of key-value pairs in the map slice.
+    #[inline]
+    pub const fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    /// Returns true if the map slice contains no elements.
+    #[inline]
+    pub const fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Get a key-value pair by index.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    pub fn get_index(&self, index: usize) -> Option<(&K, &V)> {
+        self.entries.get(index).map(Bucket::refs)
+    }
+
+    /// Get a key-value pair by index, with mutable access to the value.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)> {
+        self.entries.get_mut(index).map(Bucket::ref_mut)
+    }
+
+    /// Returns a slice of key-value pairs in the given range of indices.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Self> {
+        let range = try_simplify_range(range, self.entries.len())?;
+        self.entries.get(range).map(Slice::from_slice)
+    }
+
+    /// Returns a mutable slice of key-value pairs in the given range of indices.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    pub fn get_range_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Option<&mut Self> {
+        let range = try_simplify_range(range, self.entries.len())?;
+        self.entries.get_mut(range).map(Slice::from_mut_slice)
+    }
+
+    /// Get the first key-value pair.
+    pub fn first(&self) -> Option<(&K, &V)> {
+        self.entries.first().map(Bucket::refs)
+    }
+
+    /// Get the first key-value pair, with mutable access to the value.
+    pub fn first_mut(&mut self) -> Option<(&K, &mut V)> {
+        self.entries.first_mut().map(Bucket::ref_mut)
+    }
+
+    /// Get the last key-value pair.
+    pub fn last(&self) -> Option<(&K, &V)> {
+        self.entries.last().map(Bucket::refs)
+    }
+
+    /// Get the last key-value pair, with mutable access to the value.
+    pub fn last_mut(&mut self) -> Option<(&K, &mut V)> {
+        self.entries.last_mut().map(Bucket::ref_mut)
+    }
+
+    /// Divides one slice into two at an index.
+    ///
+    /// ***Panics*** if `index > len`.
+    pub fn split_at(&self, index: usize) -> (&Self, &Self) {
+        let (first, second) = self.entries.split_at(index);
+        (Self::from_slice(first), Self::from_slice(second))
+    }
+
+    /// Divides one mutable slice into two at an index.
+    ///
+    /// ***Panics*** if `index > len`.
+    pub fn split_at_mut(&mut self, index: usize) -> (&mut Self, &mut Self) {
+        let (first, second) = self.entries.split_at_mut(index);
+        (Self::from_mut_slice(first), Self::from_mut_slice(second))
+    }
+
+    /// Returns the first key-value pair and the rest of the slice,
+    /// or `None` if it is empty.
+    pub fn split_first(&self) -> Option<((&K, &V), &Self)> {
+        if let [first, rest @ ..] = &self.entries {
+            Some((first.refs(), Self::from_slice(rest)))
+        } else {
+            None
+        }
+    }
+
+    /// Returns the first key-value pair and the rest of the slice,
+    /// with mutable access to the value, or `None` if it is empty.
+    pub fn split_first_mut(&mut self) -> Option<((&K, &mut V), &mut Self)> {
+        if let [first, rest @ ..] = &mut self.entries {
+            Some((first.ref_mut(), Self::from_mut_slice(rest)))
+        } else {
+            None
+        }
+    }
+
+    /// Returns the last key-value pair and the rest of the slice,
+    /// or `None` if it is empty.
+    pub fn split_last(&self) -> Option<((&K, &V), &Self)> {
+        if let [rest @ .., last] = &self.entries {
+            Some((last.refs(), Self::from_slice(rest)))
+        } else {
+            None
+        }
+    }
+
+    /// Returns the last key-value pair and the rest of the slice,
+    /// with mutable access to the value, or `None` if it is empty.
+    pub fn split_last_mut(&mut self) -> Option<((&K, &mut V), &mut Self)> {
+        if let [rest @ .., last] = &mut self.entries {
+            Some((last.ref_mut(), Self::from_mut_slice(rest)))
+        } else {
+            None
+        }
+    }
+
+    /// Return an iterator over the key-value pairs of the map slice.
+    pub fn iter(&self) -> Iter<'_, K, V> {
+        Iter::new(&self.entries)
+    }
+
+    /// Return an iterator over the key-value pairs of the map slice.
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
+        IterMut::new(&mut self.entries)
+    }
+
+    /// Return an iterator over the keys of the map slice.
+    pub fn keys(&self) -> Keys<'_, K, V> {
+        Keys::new(&self.entries)
+    }
+
+    /// Return an owning iterator over the keys of the map slice.
+    pub fn into_keys(self: Box<Self>) -> IntoKeys<K, V> {
+        IntoKeys::new(self.into_entries())
+    }
+
+    /// Return an iterator over the values of the map slice.
+    pub fn values(&self) -> Values<'_, K, V> {
+        Values::new(&self.entries)
+    }
+
+    /// Return an iterator over mutable references to the the values of the map slice.
+    pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
+        ValuesMut::new(&mut self.entries)
+    }
+
+    /// Return an owning iterator over the values of the map slice.
+    pub fn into_values(self: Box<Self>) -> IntoValues<K, V> {
+        IntoValues::new(self.into_entries())
+    }
+
+    /// Search over a sorted map for a key.
+    ///
+    /// Returns the position where that key is present, or the position where it can be inserted to
+    /// maintain the sort. See [`slice::binary_search`] for more details.
+    ///
+    /// Computes in **O(log(n))** time, which is notably less scalable than looking the key up in
+    /// the map this is a slice from using [`IndexMap::get_index_of`], but this can also position
+    /// missing keys.
+    pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
+    where
+        K: Ord,
+    {
+        self.binary_search_by(|p, _| p.cmp(x))
+    }
+
+    /// Search over a sorted map with a comparator function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a K, &'a V) -> Ordering,
+    {
+        self.entries.binary_search_by(move |a| f(&a.key, &a.value))
+    }
+
+    /// Search over a sorted map with an extraction function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a K, &'a V) -> B,
+        B: Ord,
+    {
+        self.binary_search_by(|k, v| f(k, v).cmp(b))
+    }
+
+    /// Returns the index of the partition point of a sorted map according to the given predicate
+    /// (the index of the first element of the second partition).
+    ///
+    /// See [`slice::partition_point`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[must_use]
+    pub fn partition_point<P>(&self, mut pred: P) -> usize
+    where
+        P: FnMut(&K, &V) -> bool,
+    {
+        self.entries
+            .partition_point(move |a| pred(&a.key, &a.value))
+    }
+
+    /// Get an array of `N` key-value pairs by `N` indices
+    ///
+    /// Valid indices are *0 <= index < self.len()* and each index needs to be unique.
+    pub fn get_disjoint_mut<const N: usize>(
+        &mut self,
+        indices: [usize; N],
+    ) -> Result<[(&K, &mut V); N], GetDisjointMutError> {
+        let indices = indices.map(Some);
+        let key_values = self.get_disjoint_opt_mut(indices)?;
+        Ok(key_values.map(Option::unwrap))
+    }
+
+    #[allow(unsafe_code)]
+    pub(crate) fn get_disjoint_opt_mut<const N: usize>(
+        &mut self,
+        indices: [Option<usize>; N],
+    ) -> Result<[Option<(&K, &mut V)>; N], GetDisjointMutError> {
+        // SAFETY: Can't allow duplicate indices as we would return several mutable refs to the same data.
+        let len = self.len();
+        for i in 0..N {
+            if let Some(idx) = indices[i] {
+                if idx >= len {
+                    return Err(GetDisjointMutError::IndexOutOfBounds);
+                } else if indices[..i].contains(&Some(idx)) {
+                    return Err(GetDisjointMutError::OverlappingIndices);
+                }
+            }
+        }
+
+        let entries_ptr = self.entries.as_mut_ptr();
+        let out = indices.map(|idx_opt| {
+            match idx_opt {
+                Some(idx) => {
+                    // SAFETY: The base pointer is valid as it comes from a slice and the reference is always
+                    // in-bounds & unique as we've already checked the indices above.
+                    let kv = unsafe { (*(entries_ptr.add(idx))).ref_mut() };
+                    Some(kv)
+                }
+                None => None,
+            }
+        });
+
+        Ok(out)
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a Slice<K, V> {
+    type IntoIter = Iter<'a, K, V>;
+    type Item = (&'a K, &'a V);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a mut Slice<K, V> {
+    type IntoIter = IterMut<'a, K, V>;
+    type Item = (&'a K, &'a mut V);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter_mut()
+    }
+}
+
+impl<K, V> IntoIterator for Box<Slice<K, V>> {
+    type IntoIter = IntoIter<K, V>;
+    type Item = (K, V);
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.into_entries())
+    }
+}
+
+impl<K, V> Default for &'_ Slice<K, V> {
+    fn default() -> Self {
+        Slice::from_slice(&[])
+    }
+}
+
+impl<K, V> Default for &'_ mut Slice<K, V> {
+    fn default() -> Self {
+        Slice::from_mut_slice(&mut [])
+    }
+}
+
+impl<K, V> Default for Box<Slice<K, V>> {
+    fn default() -> Self {
+        Slice::from_boxed(Box::default())
+    }
+}
+
+impl<K: Clone, V: Clone> Clone for Box<Slice<K, V>> {
+    fn clone(&self) -> Self {
+        Slice::from_boxed(self.entries.to_vec().into_boxed_slice())
+    }
+}
+
+impl<K: Copy, V: Copy> From<&Slice<K, V>> for Box<Slice<K, V>> {
+    fn from(slice: &Slice<K, V>) -> Self {
+        Slice::from_boxed(Box::from(&slice.entries))
+    }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Slice<K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self).finish()
+    }
+}
+
+impl<K, V, K2, V2> PartialEq<Slice<K2, V2>> for Slice<K, V>
+where
+    K: PartialEq<K2>,
+    V: PartialEq<V2>,
+{
+    fn eq(&self, other: &Slice<K2, V2>) -> bool {
+        slice_eq(&self.entries, &other.entries, |b1, b2| {
+            b1.key == b2.key && b1.value == b2.value
+        })
+    }
+}
+
+impl<K, V, K2, V2> PartialEq<[(K2, V2)]> for Slice<K, V>
+where
+    K: PartialEq<K2>,
+    V: PartialEq<V2>,
+{
+    fn eq(&self, other: &[(K2, V2)]) -> bool {
+        slice_eq(&self.entries, other, |b, t| b.key == t.0 && b.value == t.1)
+    }
+}
+
+impl<K, V, K2, V2> PartialEq<Slice<K2, V2>> for [(K, V)]
+where
+    K: PartialEq<K2>,
+    V: PartialEq<V2>,
+{
+    fn eq(&self, other: &Slice<K2, V2>) -> bool {
+        slice_eq(self, &other.entries, |t, b| t.0 == b.key && t.1 == b.value)
+    }
+}
+
+impl<K, V, K2, V2, const N: usize> PartialEq<[(K2, V2); N]> for Slice<K, V>
+where
+    K: PartialEq<K2>,
+    V: PartialEq<V2>,
+{
+    fn eq(&self, other: &[(K2, V2); N]) -> bool {
+        <Self as PartialEq<[_]>>::eq(self, other)
+    }
+}
+
+impl<K, V, const N: usize, K2, V2> PartialEq<Slice<K2, V2>> for [(K, V); N]
+where
+    K: PartialEq<K2>,
+    V: PartialEq<V2>,
+{
+    fn eq(&self, other: &Slice<K2, V2>) -> bool {
+        <[_] as PartialEq<_>>::eq(self, other)
+    }
+}
+
+impl<K: Eq, V: Eq> Eq for Slice<K, V> {}
+
+impl<K: PartialOrd, V: PartialOrd> PartialOrd for Slice<K, V> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.iter().partial_cmp(other)
+    }
+}
+
+impl<K: Ord, V: Ord> Ord for Slice<K, V> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.iter().cmp(other)
+    }
+}
+
+impl<K: Hash, V: Hash> Hash for Slice<K, V> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.len().hash(state);
+        for (key, value) in self {
+            key.hash(state);
+            value.hash(state);
+        }
+    }
+}
+
+impl<K, V> Index<usize> for Slice<K, V> {
+    type Output = V;
+
+    fn index(&self, index: usize) -> &V {
+        &self.entries[index].value
+    }
+}
+
+impl<K, V> IndexMut<usize> for Slice<K, V> {
+    fn index_mut(&mut self, index: usize) -> &mut V {
+        &mut self.entries[index].value
+    }
+}
+
+// We can't have `impl<I: RangeBounds<usize>> Index<I>` because that conflicts
+// both upstream with `Index<usize>` and downstream with `Index<&Q>`.
+// Instead, we repeat the implementations for all the core range types.
+macro_rules! impl_index {
+    ($($range:ty),*) => {$(
+        impl<K, V, S> Index<$range> for IndexMap<K, V, S> {
+            type Output = Slice<K, V>;
+
+            fn index(&self, range: $range) -> &Self::Output {
+                Slice::from_slice(&self.as_entries()[range])
+            }
+        }
+
+        impl<K, V, S> IndexMut<$range> for IndexMap<K, V, S> {
+            fn index_mut(&mut self, range: $range) -> &mut Self::Output {
+                Slice::from_mut_slice(&mut self.as_entries_mut()[range])
+            }
+        }
+
+        impl<K, V> Index<$range> for Slice<K, V> {
+            type Output = Slice<K, V>;
+
+            fn index(&self, range: $range) -> &Self {
+                Self::from_slice(&self.entries[range])
+            }
+        }
+
+        impl<K, V> IndexMut<$range> for Slice<K, V> {
+            fn index_mut(&mut self, range: $range) -> &mut Self {
+                Self::from_mut_slice(&mut self.entries[range])
+            }
+        }
+    )*}
+}
+impl_index!(
+    ops::Range<usize>,
+    ops::RangeFrom<usize>,
+    ops::RangeFull,
+    ops::RangeInclusive<usize>,
+    ops::RangeTo<usize>,
+    ops::RangeToInclusive<usize>,
+    (Bound<usize>, Bound<usize>)
+);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn slice_index() {
+        fn check(
+            vec_slice: &[(i32, i32)],
+            map_slice: &Slice<i32, i32>,
+            sub_slice: &Slice<i32, i32>,
+        ) {
+            assert_eq!(map_slice as *const _, sub_slice as *const _);
+            itertools::assert_equal(
+                vec_slice.iter().copied(),
+                map_slice.iter().map(|(&k, &v)| (k, v)),
+            );
+            itertools::assert_equal(vec_slice.iter().map(|(k, _)| k), map_slice.keys());
+            itertools::assert_equal(vec_slice.iter().map(|(_, v)| v), map_slice.values());
+        }
+
+        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
+        let map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let slice = map.as_slice();
+
+        // RangeFull
+        check(&vec[..], &map[..], &slice[..]);
+
+        for i in 0usize..10 {
+            // Index
+            assert_eq!(vec[i].1, map[i]);
+            assert_eq!(vec[i].1, slice[i]);
+            assert_eq!(map[&(i as i32)], map[i]);
+            assert_eq!(map[&(i as i32)], slice[i]);
+
+            // RangeFrom
+            check(&vec[i..], &map[i..], &slice[i..]);
+
+            // RangeTo
+            check(&vec[..i], &map[..i], &slice[..i]);
+
+            // RangeToInclusive
+            check(&vec[..=i], &map[..=i], &slice[..=i]);
+
+            // (Bound<usize>, Bound<usize>)
+            let bounds = (Bound::Excluded(i), Bound::Unbounded);
+            check(&vec[i + 1..], &map[bounds], &slice[bounds]);
+
+            for j in i..=10 {
+                // Range
+                check(&vec[i..j], &map[i..j], &slice[i..j]);
+            }
+
+            for j in i..10 {
+                // RangeInclusive
+                check(&vec[i..=j], &map[i..=j], &slice[i..=j]);
+            }
+        }
+    }
+
+    #[test]
+    fn slice_index_mut() {
+        fn check_mut(
+            vec_slice: &[(i32, i32)],
+            map_slice: &mut Slice<i32, i32>,
+            sub_slice: &mut Slice<i32, i32>,
+        ) {
+            assert_eq!(map_slice, sub_slice);
+            itertools::assert_equal(
+                vec_slice.iter().copied(),
+                map_slice.iter_mut().map(|(&k, &mut v)| (k, v)),
+            );
+            itertools::assert_equal(
+                vec_slice.iter().map(|&(_, v)| v),
+                map_slice.values_mut().map(|&mut v| v),
+            );
+        }
+
+        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
+        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map2 = map.clone();
+        let slice = map2.as_mut_slice();
+
+        // RangeFull
+        check_mut(&vec[..], &mut map[..], &mut slice[..]);
+
+        for i in 0usize..10 {
+            // IndexMut
+            assert_eq!(&mut map[i], &mut slice[i]);
+
+            // RangeFrom
+            check_mut(&vec[i..], &mut map[i..], &mut slice[i..]);
+
+            // RangeTo
+            check_mut(&vec[..i], &mut map[..i], &mut slice[..i]);
+
+            // RangeToInclusive
+            check_mut(&vec[..=i], &mut map[..=i], &mut slice[..=i]);
+
+            // (Bound<usize>, Bound<usize>)
+            let bounds = (Bound::Excluded(i), Bound::Unbounded);
+            check_mut(&vec[i + 1..], &mut map[bounds], &mut slice[bounds]);
+
+            for j in i..=10 {
+                // Range
+                check_mut(&vec[i..j], &mut map[i..j], &mut slice[i..j]);
+            }
+
+            for j in i..10 {
+                // RangeInclusive
+                check_mut(&vec[i..=j], &mut map[i..=j], &mut slice[i..=j]);
+            }
+        }
+    }
+}
diff --git a/vendor/indexmap/src/map/tests.rs b/vendor/indexmap/src/map/tests.rs
new file mode 100644
index 00000000..f97f2f14
--- /dev/null
+++ b/vendor/indexmap/src/map/tests.rs
@@ -0,0 +1,1008 @@
+use super::*;
+use std::string::String;
+
+#[test]
+fn it_works() {
+    let mut map = IndexMap::new();
+    assert_eq!(map.is_empty(), true);
+    map.insert(1, ());
+    map.insert(1, ());
+    assert_eq!(map.len(), 1);
+    assert!(map.get(&1).is_some());
+    assert_eq!(map.is_empty(), false);
+}
+
+#[test]
+fn new() {
+    let map = IndexMap::<String, String>::new();
+    println!("{:?}", map);
+    assert_eq!(map.capacity(), 0);
+    assert_eq!(map.len(), 0);
+    assert_eq!(map.is_empty(), true);
+}
+
+#[test]
+fn insert() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5];
+    let not_present = [1, 3, 6, 9, 10];
+    let mut map = IndexMap::with_capacity(insert.len());
+
+    for (i, &elt) in insert.iter().enumerate() {
+        assert_eq!(map.len(), i);
+        map.insert(elt, elt);
+        assert_eq!(map.len(), i + 1);
+        assert_eq!(map.get(&elt), Some(&elt));
+        assert_eq!(map[&elt], elt);
+    }
+    println!("{:?}", map);
+
+    for &elt in &not_present {
+        assert!(map.get(&elt).is_none());
+    }
+}
+
+#[test]
+fn insert_full() {
+    let insert = vec![9, 2, 7, 1, 4, 6, 13];
+    let present = vec![1, 6, 2];
+    let mut map = IndexMap::with_capacity(insert.len());
+
+    for (i, &elt) in insert.iter().enumerate() {
+        assert_eq!(map.len(), i);
+        let (index, existing) = map.insert_full(elt, elt);
+        assert_eq!(existing, None);
+        assert_eq!(Some(index), map.get_full(&elt).map(|x| x.0));
+        assert_eq!(map.len(), i + 1);
+    }
+
+    let len = map.len();
+    for &elt in &present {
+        let (index, existing) = map.insert_full(elt, elt);
+        assert_eq!(existing, Some(elt));
+        assert_eq!(Some(index), map.get_full(&elt).map(|x| x.0));
+        assert_eq!(map.len(), len);
+    }
+}
+
+#[test]
+fn insert_2() {
+    let mut map = IndexMap::with_capacity(16);
+
+    let mut keys = vec![];
+    keys.extend(0..16);
+    keys.extend(if cfg!(miri) { 32..64 } else { 128..267 });
+
+    for &i in &keys {
+        let old_map = map.clone();
+        map.insert(i, ());
+        for key in old_map.keys() {
+            if map.get(key).is_none() {
+                println!("old_map: {:?}", old_map);
+                println!("map: {:?}", map);
+                panic!("did not find {} in map", key);
+            }
+        }
+    }
+
+    for &i in &keys {
+        assert!(map.get(&i).is_some(), "did not find {}", i);
+    }
+}
+
+#[test]
+fn insert_order() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut map = IndexMap::new();
+
+    for &elt in &insert {
+        map.insert(elt, ());
+    }
+
+    assert_eq!(map.keys().count(), map.len());
+    assert_eq!(map.keys().count(), insert.len());
+    for (a, b) in insert.iter().zip(map.keys()) {
+        assert_eq!(a, b);
+    }
+    for (i, k) in (0..insert.len()).zip(map.keys()) {
+        assert_eq!(map.get_index(i).unwrap().0, k);
+    }
+}
+
+#[test]
+fn shift_insert() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut map = IndexMap::new();
+
+    for &elt in &insert {
+        map.shift_insert(0, elt, ());
+    }
+
+    assert_eq!(map.keys().count(), map.len());
+    assert_eq!(map.keys().count(), insert.len());
+    for (a, b) in insert.iter().rev().zip(map.keys()) {
+        assert_eq!(a, b);
+    }
+    for (i, k) in (0..insert.len()).zip(map.keys()) {
+        assert_eq!(map.get_index(i).unwrap().0, k);
+    }
+
+    // "insert" that moves an existing entry
+    map.shift_insert(0, insert[0], ());
+    assert_eq!(map.keys().count(), insert.len());
+    assert_eq!(insert[0], map.keys()[0]);
+    for (a, b) in insert[1..].iter().rev().zip(map.keys().skip(1)) {
+        assert_eq!(a, b);
+    }
+}
+
+#[test]
+fn insert_sorted_bad() {
+    let mut map = IndexMap::new();
+    map.insert(10, ());
+    for i in 0..10 {
+        map.insert(i, ());
+    }
+
+    // The binary search will want to insert this at the end (index == len()),
+    // but that's only possible for *new* inserts. It should still be handled
+    // without panicking though, and in this case it's simple enough that we
+    // know the exact result. (But don't read this as an API guarantee!)
+    assert_eq!(map.first(), Some((&10, &())));
+    map.insert_sorted(10, ());
+    assert_eq!(map.last(), Some((&10, &())));
+    assert!(map.keys().copied().eq(0..=10));
+
+    // Other out-of-order entries can also "insert" to a binary-searched
+    // position, moving in either direction.
+    map.move_index(5, 0);
+    map.move_index(6, 10);
+    assert_eq!(map.first(), Some((&5, &())));
+    assert_eq!(map.last(), Some((&6, &())));
+    map.insert_sorted(5, ()); // moves back up
+    map.insert_sorted(6, ()); // moves back down
+    assert!(map.keys().copied().eq(0..=10));
+}
+
+#[test]
+fn grow() {
+    let insert = [0, 4, 2, 12, 8, 7, 11];
+    let not_present = [1, 3, 6, 9, 10];
+    let mut map = IndexMap::with_capacity(insert.len());
+
+    for (i, &elt) in insert.iter().enumerate() {
+        assert_eq!(map.len(), i);
+        map.insert(elt, elt);
+        assert_eq!(map.len(), i + 1);
+        assert_eq!(map.get(&elt), Some(&elt));
+        assert_eq!(map[&elt], elt);
+    }
+
+    println!("{:?}", map);
+    for &elt in &insert {
+        map.insert(elt * 10, elt);
+    }
+    for &elt in &insert {
+        map.insert(elt * 100, elt);
+    }
+    for (i, &elt) in insert.iter().cycle().enumerate().take(100) {
+        map.insert(elt * 100 + i as i32, elt);
+    }
+    println!("{:?}", map);
+    for &elt in &not_present {
+        assert!(map.get(&elt).is_none());
+    }
+}
+
+#[test]
+fn reserve() {
+    let mut map = IndexMap::<usize, usize>::new();
+    assert_eq!(map.capacity(), 0);
+    map.reserve(100);
+    let capacity = map.capacity();
+    assert!(capacity >= 100);
+    for i in 0..capacity {
+        assert_eq!(map.len(), i);
+        map.insert(i, i * i);
+        assert_eq!(map.len(), i + 1);
+        assert_eq!(map.capacity(), capacity);
+        assert_eq!(map.get(&i), Some(&(i * i)));
+    }
+    map.insert(capacity, std::usize::MAX);
+    assert_eq!(map.len(), capacity + 1);
+    assert!(map.capacity() > capacity);
+    assert_eq!(map.get(&capacity), Some(&std::usize::MAX));
+}
+
+#[test]
+fn try_reserve() {
+    let mut map = IndexMap::<usize, usize>::new();
+    assert_eq!(map.capacity(), 0);
+    assert_eq!(map.try_reserve(100), Ok(()));
+    assert!(map.capacity() >= 100);
+    assert!(map.try_reserve(usize::MAX).is_err());
+}
+
+#[test]
+fn shrink_to_fit() {
+    let mut map = IndexMap::<usize, usize>::new();
+    assert_eq!(map.capacity(), 0);
+    for i in 0..100 {
+        assert_eq!(map.len(), i);
+        map.insert(i, i * i);
+        assert_eq!(map.len(), i + 1);
+        assert!(map.capacity() >= i + 1);
+        assert_eq!(map.get(&i), Some(&(i * i)));
+        map.shrink_to_fit();
+        assert_eq!(map.len(), i + 1);
+        assert_eq!(map.capacity(), i + 1);
+        assert_eq!(map.get(&i), Some(&(i * i)));
+    }
+}
+
+#[test]
+fn remove() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut map = IndexMap::new();
+
+    for &elt in &insert {
+        map.insert(elt, elt);
+    }
+
+    assert_eq!(map.keys().count(), map.len());
+    assert_eq!(map.keys().count(), insert.len());
+    for (a, b) in insert.iter().zip(map.keys()) {
+        assert_eq!(a, b);
+    }
+
+    let remove_fail = [99, 77];
+    let remove = [4, 12, 8, 7];
+
+    for &key in &remove_fail {
+        assert!(map.swap_remove_full(&key).is_none());
+    }
+    println!("{:?}", map);
+    for &key in &remove {
+        //println!("{:?}", map);
+        let index = map.get_full(&key).unwrap().0;
+        assert_eq!(map.swap_remove_full(&key), Some((index, key, key)));
+    }
+    println!("{:?}", map);
+
+    for key in &insert {
+        assert_eq!(map.get(key).is_some(), !remove.contains(key));
+    }
+    assert_eq!(map.len(), insert.len() - remove.len());
+    assert_eq!(map.keys().count(), insert.len() - remove.len());
+}
+
+#[test]
+fn remove_to_empty() {
+    let mut map = indexmap! { 0 => 0, 4 => 4, 5 => 5 };
+    map.swap_remove(&5).unwrap();
+    map.swap_remove(&4).unwrap();
+    map.swap_remove(&0).unwrap();
+    assert!(map.is_empty());
+}
+
+#[test]
+fn swap_remove_index() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut map = IndexMap::new();
+
+    for &elt in &insert {
+        map.insert(elt, elt * 2);
+    }
+
+    let mut vector = insert.to_vec();
+    let remove_sequence = &[3, 3, 10, 4, 5, 4, 3, 0, 1];
+
+    // check that the same swap remove sequence on vec and map
+    // have the same result.
+    for &rm in remove_sequence {
+        let out_vec = vector.swap_remove(rm);
+        let (out_map, _) = map.swap_remove_index(rm).unwrap();
+        assert_eq!(out_vec, out_map);
+    }
+    assert_eq!(vector.len(), map.len());
+    for (a, b) in vector.iter().zip(map.keys()) {
+        assert_eq!(a, b);
+    }
+}
+
+#[test]
+fn partial_eq_and_eq() {
+    let mut map_a = IndexMap::new();
+    map_a.insert(1, "1");
+    map_a.insert(2, "2");
+    let mut map_b = map_a.clone();
+    assert_eq!(map_a, map_b);
+    map_b.swap_remove(&1);
+    assert_ne!(map_a, map_b);
+
+    let map_c: IndexMap<_, String> = map_b.into_iter().map(|(k, v)| (k, v.into())).collect();
+    assert_ne!(map_a, map_c);
+    assert_ne!(map_c, map_a);
+}
+
+#[test]
+fn extend() {
+    let mut map = IndexMap::new();
+    map.extend(vec![(&1, &2), (&3, &4)]);
+    map.extend(vec![(5, 6)]);
+    assert_eq!(
+        map.into_iter().collect::<Vec<_>>(),
+        vec![(1, 2), (3, 4), (5, 6)]
+    );
+}
+
+#[test]
+fn entry() {
+    let mut map = IndexMap::new();
+
+    map.insert(1, "1");
+    map.insert(2, "2");
+    {
+        let e = map.entry(3);
+        assert_eq!(e.index(), 2);
+        let e = e.or_insert("3");
+        assert_eq!(e, &"3");
+    }
+
+    let e = map.entry(2);
+    assert_eq!(e.index(), 1);
+    assert_eq!(e.key(), &2);
+    match e {
+        Entry::Occupied(ref e) => assert_eq!(e.get(), &"2"),
+        Entry::Vacant(_) => panic!(),
+    }
+    assert_eq!(e.or_insert("4"), &"2");
+}
+
+#[test]
+fn entry_and_modify() {
+    let mut map = IndexMap::new();
+
+    map.insert(1, "1");
+    map.entry(1).and_modify(|x| *x = "2");
+    assert_eq!(Some(&"2"), map.get(&1));
+
+    map.entry(2).and_modify(|x| *x = "doesn't exist");
+    assert_eq!(None, map.get(&2));
+}
+
+#[test]
+fn entry_or_default() {
+    let mut map = IndexMap::new();
+
+    #[derive(Debug, PartialEq)]
+    enum TestEnum {
+        DefaultValue,
+        NonDefaultValue,
+    }
+
+    impl Default for TestEnum {
+        fn default() -> Self {
+            TestEnum::DefaultValue
+        }
+    }
+
+    map.insert(1, TestEnum::NonDefaultValue);
+    assert_eq!(&mut TestEnum::NonDefaultValue, map.entry(1).or_default());
+
+    assert_eq!(&mut TestEnum::DefaultValue, map.entry(2).or_default());
+}
+
+#[test]
+fn occupied_entry_key() {
+    // These keys match hash and equality, but their addresses are distinct.
+    let (k1, k2) = (&mut 1, &mut 1);
+    let k1_ptr = k1 as *const i32;
+    let k2_ptr = k2 as *const i32;
+    assert_ne!(k1_ptr, k2_ptr);
+
+    let mut map = IndexMap::new();
+    map.insert(k1, "value");
+    match map.entry(k2) {
+        Entry::Occupied(ref e) => {
+            // `OccupiedEntry::key` should reference the key in the map,
+            // not the key that was used to find the entry.
+            let ptr = *e.key() as *const i32;
+            assert_eq!(ptr, k1_ptr);
+            assert_ne!(ptr, k2_ptr);
+        }
+        Entry::Vacant(_) => panic!(),
+    }
+}
+
+#[test]
+fn get_index_entry() {
+    let mut map = IndexMap::new();
+
+    assert!(map.get_index_entry(0).is_none());
+    assert!(map.first_entry().is_none());
+    assert!(map.last_entry().is_none());
+
+    map.insert(0, "0");
+    map.insert(1, "1");
+    map.insert(2, "2");
+    map.insert(3, "3");
+
+    assert!(map.get_index_entry(4).is_none());
+
+    {
+        let e = map.get_index_entry(1).unwrap();
+        assert_eq!(*e.key(), 1);
+        assert_eq!(*e.get(), "1");
+        assert_eq!(e.swap_remove(), "1");
+    }
+
+    {
+        let mut e = map.get_index_entry(1).unwrap();
+        assert_eq!(*e.key(), 3);
+        assert_eq!(*e.get(), "3");
+        assert_eq!(e.insert("4"), "3");
+    }
+
+    assert_eq!(*map.get(&3).unwrap(), "4");
+
+    {
+        let e = map.first_entry().unwrap();
+        assert_eq!(*e.key(), 0);
+        assert_eq!(*e.get(), "0");
+    }
+
+    {
+        let e = map.last_entry().unwrap();
+        assert_eq!(*e.key(), 2);
+        assert_eq!(*e.get(), "2");
+    }
+}
+
+#[test]
+fn from_entries() {
+    let mut map = IndexMap::from([(1, "1"), (2, "2"), (3, "3")]);
+
+    {
+        let e = match map.entry(1) {
+            Entry::Occupied(e) => IndexedEntry::from(e),
+            Entry::Vacant(_) => panic!(),
+        };
+        assert_eq!(e.index(), 0);
+        assert_eq!(*e.key(), 1);
+        assert_eq!(*e.get(), "1");
+    }
+
+    {
+        let e = match map.get_index_entry(1) {
+            Some(e) => OccupiedEntry::from(e),
+            None => panic!(),
+        };
+        assert_eq!(e.index(), 1);
+        assert_eq!(*e.key(), 2);
+        assert_eq!(*e.get(), "2");
+    }
+}
+
+#[test]
+fn keys() {
+    let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+    let map: IndexMap<_, _> = vec.into_iter().collect();
+    let keys: Vec<_> = map.keys().copied().collect();
+    assert_eq!(keys.len(), 3);
+    assert!(keys.contains(&1));
+    assert!(keys.contains(&2));
+    assert!(keys.contains(&3));
+}
+
+#[test]
+fn into_keys() {
+    let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+    let map: IndexMap<_, _> = vec.into_iter().collect();
+    let keys: Vec<i32> = map.into_keys().collect();
+    assert_eq!(keys.len(), 3);
+    assert!(keys.contains(&1));
+    assert!(keys.contains(&2));
+    assert!(keys.contains(&3));
+}
+
+#[test]
+fn values() {
+    let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+    let map: IndexMap<_, _> = vec.into_iter().collect();
+    let values: Vec<_> = map.values().copied().collect();
+    assert_eq!(values.len(), 3);
+    assert!(values.contains(&'a'));
+    assert!(values.contains(&'b'));
+    assert!(values.contains(&'c'));
+}
+
+#[test]
+fn values_mut() {
+    let vec = vec![(1, 1), (2, 2), (3, 3)];
+    let mut map: IndexMap<_, _> = vec.into_iter().collect();
+    for value in map.values_mut() {
+        *value *= 2
+    }
+    let values: Vec<_> = map.values().copied().collect();
+    assert_eq!(values.len(), 3);
+    assert!(values.contains(&2));
+    assert!(values.contains(&4));
+    assert!(values.contains(&6));
+}
+
+#[test]
+fn into_values() {
+    let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+    let map: IndexMap<_, _> = vec.into_iter().collect();
+    let values: Vec<char> = map.into_values().collect();
+    assert_eq!(values.len(), 3);
+    assert!(values.contains(&'a'));
+    assert!(values.contains(&'b'));
+    assert!(values.contains(&'c'));
+}
+
+#[test]
+fn drain_range() {
+    // Test the various heuristics of `erase_indices`
+    for range in [
+        0..0,   // nothing erased
+        10..90, // reinsert the few kept (..10 and 90..)
+        80..90, // update the few to adjust (80..)
+        20..30, // sweep everything
+    ] {
+        let mut vec = Vec::from_iter(0..100);
+        let mut map: IndexMap<i32, ()> = (0..100).map(|i| (i, ())).collect();
+        drop(vec.drain(range.clone()));
+        drop(map.drain(range));
+        assert!(vec.iter().eq(map.keys()));
+        for (i, x) in vec.iter().enumerate() {
+            assert_eq!(map.get_index_of(x), Some(i));
+        }
+    }
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn from_array() {
+    let map = IndexMap::from([(1, 2), (3, 4)]);
+    let mut expected = IndexMap::new();
+    expected.insert(1, 2);
+    expected.insert(3, 4);
+
+    assert_eq!(map, expected)
+}
+
+#[test]
+fn iter_default() {
+    struct K;
+    struct V;
+    fn assert_default<T>()
+    where
+        T: Default + Iterator,
+    {
+        assert!(T::default().next().is_none());
+    }
+    assert_default::<Iter<'static, K, V>>();
+    assert_default::<IterMut<'static, K, V>>();
+    assert_default::<IterMut2<'static, K, V>>();
+    assert_default::<IntoIter<K, V>>();
+    assert_default::<Keys<'static, K, V>>();
+    assert_default::<IntoKeys<K, V>>();
+    assert_default::<Values<'static, K, V>>();
+    assert_default::<ValuesMut<'static, K, V>>();
+    assert_default::<IntoValues<K, V>>();
+}
+
+#[test]
+fn test_binary_search_by() {
+    // adapted from std's test for binary_search
+    let b: IndexMap<_, i32> = []
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(0));
+
+    let b: IndexMap<_, i32> = [4]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&3)), Err(0));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&4)), Ok(0));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(1));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 6, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(3));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&6)), Ok(3));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&7)), Err(4));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&8)), Ok(4));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&9)), Err(6));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 6, 7, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&6)), Ok(3));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(3));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&8)), Ok(5));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&7)), Err(5));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&0)), Err(0));
+
+    let b: IndexMap<_, i32> = [1, 3, 3, 3, 7]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&0)), Err(0));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&1)), Ok(0));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&2)), Err(1));
+    assert!(match b.binary_search_by(|_, x| x.cmp(&3)) {
+        Ok(1..=3) => true,
+        _ => false,
+    });
+    assert!(match b.binary_search_by(|_, x| x.cmp(&3)) {
+        Ok(1..=3) => true,
+        _ => false,
+    });
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&4)), Err(4));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(4));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&6)), Err(4));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&7)), Ok(4));
+    assert_eq!(b.binary_search_by(|_, x| x.cmp(&8)), Err(5));
+}
+
+#[test]
+fn test_binary_search_by_key() {
+    // adapted from std's test for binary_search
+    let b: IndexMap<_, i32> = []
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(0));
+
+    let b: IndexMap<_, i32> = [4]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&3, |_, &x| x), Err(0));
+    assert_eq!(b.binary_search_by_key(&4, |_, &x| x), Ok(0));
+    assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(1));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 6, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(3));
+    assert_eq!(b.binary_search_by_key(&6, |_, &x| x), Ok(3));
+    assert_eq!(b.binary_search_by_key(&7, |_, &x| x), Err(4));
+    assert_eq!(b.binary_search_by_key(&8, |_, &x| x), Ok(4));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&9, |_, &x| x), Err(6));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 6, 7, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&6, |_, &x| x), Ok(3));
+    assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(3));
+    assert_eq!(b.binary_search_by_key(&8, |_, &x| x), Ok(5));
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&7, |_, &x| x), Err(5));
+    assert_eq!(b.binary_search_by_key(&0, |_, &x| x), Err(0));
+
+    let b: IndexMap<_, i32> = [1, 3, 3, 3, 7]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.binary_search_by_key(&0, |_, &x| x), Err(0));
+    assert_eq!(b.binary_search_by_key(&1, |_, &x| x), Ok(0));
+    assert_eq!(b.binary_search_by_key(&2, |_, &x| x), Err(1));
+    assert!(match b.binary_search_by_key(&3, |_, &x| x) {
+        Ok(1..=3) => true,
+        _ => false,
+    });
+    assert!(match b.binary_search_by_key(&3, |_, &x| x) {
+        Ok(1..=3) => true,
+        _ => false,
+    });
+    assert_eq!(b.binary_search_by_key(&4, |_, &x| x), Err(4));
+    assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(4));
+    assert_eq!(b.binary_search_by_key(&6, |_, &x| x), Err(4));
+    assert_eq!(b.binary_search_by_key(&7, |_, &x| x), Ok(4));
+    assert_eq!(b.binary_search_by_key(&8, |_, &x| x), Err(5));
+}
+
+#[test]
+fn test_partition_point() {
+    // adapted from std's test for partition_point
+    let b: IndexMap<_, i32> = []
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 5), 0);
+
+    let b: IndexMap<_, i32> = [4]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 3), 0);
+    assert_eq!(b.partition_point(|_, &x| x < 4), 0);
+    assert_eq!(b.partition_point(|_, &x| x < 5), 1);
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 6, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 5), 3);
+    assert_eq!(b.partition_point(|_, &x| x < 6), 3);
+    assert_eq!(b.partition_point(|_, &x| x < 7), 4);
+    assert_eq!(b.partition_point(|_, &x| x < 8), 4);
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 9), 6);
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 6, 7, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 6), 3);
+    assert_eq!(b.partition_point(|_, &x| x < 5), 3);
+    assert_eq!(b.partition_point(|_, &x| x < 8), 5);
+
+    let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8, 9]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 7), 5);
+    assert_eq!(b.partition_point(|_, &x| x < 0), 0);
+
+    let b: IndexMap<_, i32> = [1, 3, 3, 3, 7]
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (i + 100, x))
+        .collect();
+    assert_eq!(b.partition_point(|_, &x| x < 0), 0);
+    assert_eq!(b.partition_point(|_, &x| x < 1), 0);
+    assert_eq!(b.partition_point(|_, &x| x < 2), 1);
+    assert_eq!(b.partition_point(|_, &x| x < 3), 1);
+    assert_eq!(b.partition_point(|_, &x| x < 4), 4);
+    assert_eq!(b.partition_point(|_, &x| x < 5), 4);
+    assert_eq!(b.partition_point(|_, &x| x < 6), 4);
+    assert_eq!(b.partition_point(|_, &x| x < 7), 4);
+    assert_eq!(b.partition_point(|_, &x| x < 8), 5);
+}
+
+macro_rules! move_index_oob {
+    ($test:ident, $from:expr, $to:expr) => {
+        #[test]
+        #[should_panic(expected = "index out of bounds")]
+        fn $test() {
+            let mut map: IndexMap<i32, ()> = (0..10).map(|k| (k, ())).collect();
+            map.move_index($from, $to);
+        }
+    };
+}
+move_index_oob!(test_move_index_out_of_bounds_0_10, 0, 10);
+move_index_oob!(test_move_index_out_of_bounds_0_max, 0, usize::MAX);
+move_index_oob!(test_move_index_out_of_bounds_10_0, 10, 0);
+move_index_oob!(test_move_index_out_of_bounds_max_0, usize::MAX, 0);
+
+#[test]
+fn disjoint_mut_empty_map() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    assert_eq!(
+        map.get_disjoint_mut([&0, &1, &2, &3]),
+        [None, None, None, None]
+    );
+}
+
+#[test]
+fn disjoint_mut_empty_param() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    assert_eq!(map.get_disjoint_mut([] as [&u32; 0]), []);
+}
+
+#[test]
+fn disjoint_mut_single_fail() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    assert_eq!(map.get_disjoint_mut([&0]), [None]);
+}
+
+#[test]
+fn disjoint_mut_single_success() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    assert_eq!(map.get_disjoint_mut([&1]), [Some(&mut 10)]);
+}
+
+#[test]
+fn disjoint_mut_multi_success() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 100);
+    map.insert(2, 200);
+    map.insert(3, 300);
+    map.insert(4, 400);
+    assert_eq!(
+        map.get_disjoint_mut([&1, &2]),
+        [Some(&mut 100), Some(&mut 200)]
+    );
+    assert_eq!(
+        map.get_disjoint_mut([&1, &3]),
+        [Some(&mut 100), Some(&mut 300)]
+    );
+    assert_eq!(
+        map.get_disjoint_mut([&3, &1, &4, &2]),
+        [
+            Some(&mut 300),
+            Some(&mut 100),
+            Some(&mut 400),
+            Some(&mut 200)
+        ]
+    );
+}
+
+#[test]
+fn disjoint_mut_multi_success_unsized_key() {
+    let mut map: IndexMap<&'static str, u32> = IndexMap::default();
+    map.insert("1", 100);
+    map.insert("2", 200);
+    map.insert("3", 300);
+    map.insert("4", 400);
+
+    assert_eq!(
+        map.get_disjoint_mut(["1", "2"]),
+        [Some(&mut 100), Some(&mut 200)]
+    );
+    assert_eq!(
+        map.get_disjoint_mut(["1", "3"]),
+        [Some(&mut 100), Some(&mut 300)]
+    );
+    assert_eq!(
+        map.get_disjoint_mut(["3", "1", "4", "2"]),
+        [
+            Some(&mut 300),
+            Some(&mut 100),
+            Some(&mut 400),
+            Some(&mut 200)
+        ]
+    );
+}
+
+#[test]
+fn disjoint_mut_multi_success_borrow_key() {
+    let mut map: IndexMap<String, u32> = IndexMap::default();
+    map.insert("1".into(), 100);
+    map.insert("2".into(), 200);
+    map.insert("3".into(), 300);
+    map.insert("4".into(), 400);
+
+    assert_eq!(
+        map.get_disjoint_mut(["1", "2"]),
+        [Some(&mut 100), Some(&mut 200)]
+    );
+    assert_eq!(
+        map.get_disjoint_mut(["1", "3"]),
+        [Some(&mut 100), Some(&mut 300)]
+    );
+    assert_eq!(
+        map.get_disjoint_mut(["3", "1", "4", "2"]),
+        [
+            Some(&mut 300),
+            Some(&mut 100),
+            Some(&mut 400),
+            Some(&mut 200)
+        ]
+    );
+}
+
+#[test]
+fn disjoint_mut_multi_fail_missing() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 100);
+    map.insert(2, 200);
+    map.insert(3, 300);
+    map.insert(4, 400);
+
+    assert_eq!(map.get_disjoint_mut([&1, &5]), [Some(&mut 100), None]);
+    assert_eq!(map.get_disjoint_mut([&5, &6]), [None, None]);
+    assert_eq!(
+        map.get_disjoint_mut([&1, &5, &4]),
+        [Some(&mut 100), None, Some(&mut 400)]
+    );
+}
+
+#[test]
+#[should_panic]
+fn disjoint_mut_multi_fail_duplicate_panic() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 100);
+    map.get_disjoint_mut([&1, &2, &1]);
+}
+
+#[test]
+fn disjoint_indices_mut_fail_oob() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    map.insert(321, 20);
+    assert_eq!(
+        map.get_disjoint_indices_mut([1, 3]),
+        Err(crate::GetDisjointMutError::IndexOutOfBounds)
+    );
+}
+
+#[test]
+fn disjoint_indices_mut_empty() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    map.insert(321, 20);
+    assert_eq!(map.get_disjoint_indices_mut([]), Ok([]));
+}
+
+#[test]
+fn disjoint_indices_mut_success() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    map.insert(321, 20);
+    assert_eq!(map.get_disjoint_indices_mut([0]), Ok([(&1, &mut 10)]));
+
+    assert_eq!(map.get_disjoint_indices_mut([1]), Ok([(&321, &mut 20)]));
+    assert_eq!(
+        map.get_disjoint_indices_mut([0, 1]),
+        Ok([(&1, &mut 10), (&321, &mut 20)])
+    );
+}
+
+#[test]
+fn disjoint_indices_mut_fail_duplicate() {
+    let mut map: IndexMap<u32, u32> = IndexMap::default();
+    map.insert(1, 10);
+    map.insert(321, 20);
+    assert_eq!(
+        map.get_disjoint_indices_mut([1, 0, 1]),
+        Err(crate::GetDisjointMutError::OverlappingIndices)
+    );
+}
diff --git a/vendor/indexmap/src/rayon/map.rs b/vendor/indexmap/src/rayon/map.rs
new file mode 100644
index 00000000..8236cf70
--- /dev/null
+++ b/vendor/indexmap/src/rayon/map.rs
@@ -0,0 +1,663 @@
+//! Parallel iterator types for [`IndexMap`] with [`rayon`][::rayon].
+//!
+//! You will rarely need to interact with this module directly unless you need to name one of the
+//! iterator types.
+
+use super::collect;
+use rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
+use rayon::prelude::*;
+
+use crate::vec::Vec;
+use alloc::boxed::Box;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::ops::RangeBounds;
+
+use crate::map::Slice;
+use crate::Bucket;
+use crate::Entries;
+use crate::IndexMap;
+
+impl<K, V, S> IntoParallelIterator for IndexMap<K, V, S>
+where
+    K: Send,
+    V: Send,
+{
+    type Item = (K, V);
+    type Iter = IntoParIter<K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoParIter {
+            entries: self.into_entries(),
+        }
+    }
+}
+
+impl<K, V> IntoParallelIterator for Box<Slice<K, V>>
+where
+    K: Send,
+    V: Send,
+{
+    type Item = (K, V);
+    type Iter = IntoParIter<K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoParIter {
+            entries: self.into_entries(),
+        }
+    }
+}
+
+/// A parallel owning iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_par_iter`] method
+/// (provided by rayon's [`IntoParallelIterator`] trait). See its documentation for more.
+pub struct IntoParIter<K, V> {
+    entries: Vec<Bucket<K, V>>,
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoParIter<K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<K: Send, V: Send> ParallelIterator for IntoParIter<K, V> {
+    type Item = (K, V);
+
+    parallel_iterator_methods!(Bucket::key_value);
+}
+
+impl<K: Send, V: Send> IndexedParallelIterator for IntoParIter<K, V> {
+    indexed_parallel_iterator_methods!(Bucket::key_value);
+}
+
+impl<'a, K, V, S> IntoParallelIterator for &'a IndexMap<K, V, S>
+where
+    K: Sync,
+    V: Sync,
+{
+    type Item = (&'a K, &'a V);
+    type Iter = ParIter<'a, K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        ParIter {
+            entries: self.as_entries(),
+        }
+    }
+}
+
+impl<'a, K, V> IntoParallelIterator for &'a Slice<K, V>
+where
+    K: Sync,
+    V: Sync,
+{
+    type Item = (&'a K, &'a V);
+    type Iter = ParIter<'a, K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        ParIter {
+            entries: &self.entries,
+        }
+    }
+}
+
+/// A parallel iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::par_iter`] method
+/// (provided by rayon's [`IntoParallelRefIterator`] trait). See its documentation for more.
+///
+/// [`IndexMap::par_iter`]: ../struct.IndexMap.html#method.par_iter
+pub struct ParIter<'a, K, V> {
+    entries: &'a [Bucket<K, V>],
+}
+
+impl<K, V> Clone for ParIter<'_, K, V> {
+    fn clone(&self) -> Self {
+        ParIter { ..*self }
+    }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for ParIter<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<'a, K: Sync, V: Sync> ParallelIterator for ParIter<'a, K, V> {
+    type Item = (&'a K, &'a V);
+
+    parallel_iterator_methods!(Bucket::refs);
+}
+
+impl<K: Sync, V: Sync> IndexedParallelIterator for ParIter<'_, K, V> {
+    indexed_parallel_iterator_methods!(Bucket::refs);
+}
+
+impl<'a, K, V, S> IntoParallelIterator for &'a mut IndexMap<K, V, S>
+where
+    K: Sync + Send,
+    V: Send,
+{
+    type Item = (&'a K, &'a mut V);
+    type Iter = ParIterMut<'a, K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        ParIterMut {
+            entries: self.as_entries_mut(),
+        }
+    }
+}
+
+impl<'a, K, V> IntoParallelIterator for &'a mut Slice<K, V>
+where
+    K: Sync + Send,
+    V: Send,
+{
+    type Item = (&'a K, &'a mut V);
+    type Iter = ParIterMut<'a, K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        ParIterMut {
+            entries: &mut self.entries,
+        }
+    }
+}
+
+/// A parallel mutable iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::par_iter_mut`] method
+/// (provided by rayon's [`IntoParallelRefMutIterator`] trait). See its documentation for more.
+///
+/// [`IndexMap::par_iter_mut`]: ../struct.IndexMap.html#method.par_iter_mut
+pub struct ParIterMut<'a, K, V> {
+    entries: &'a mut [Bucket<K, V>],
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for ParIterMut<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::refs);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<'a, K: Sync + Send, V: Send> ParallelIterator for ParIterMut<'a, K, V> {
+    type Item = (&'a K, &'a mut V);
+
+    parallel_iterator_methods!(Bucket::ref_mut);
+}
+
+impl<K: Sync + Send, V: Send> IndexedParallelIterator for ParIterMut<'_, K, V> {
+    indexed_parallel_iterator_methods!(Bucket::ref_mut);
+}
+
+impl<'a, K, V, S> ParallelDrainRange<usize> for &'a mut IndexMap<K, V, S>
+where
+    K: Send,
+    V: Send,
+{
+    type Item = (K, V);
+    type Iter = ParDrain<'a, K, V>;
+
+    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
+        ParDrain {
+            entries: self.core.par_drain(range),
+        }
+    }
+}
+
+/// A parallel draining iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::par_drain`] method
+/// (provided by rayon's [`ParallelDrainRange`] trait). See its documentation for more.
+///
+/// [`IndexMap::par_drain`]: ../struct.IndexMap.html#method.par_drain
+pub struct ParDrain<'a, K: Send, V: Send> {
+    entries: rayon::vec::Drain<'a, Bucket<K, V>>,
+}
+
+impl<K: Send, V: Send> ParallelIterator for ParDrain<'_, K, V> {
+    type Item = (K, V);
+
+    parallel_iterator_methods!(Bucket::key_value);
+}
+
+impl<K: Send, V: Send> IndexedParallelIterator for ParDrain<'_, K, V> {
+    indexed_parallel_iterator_methods!(Bucket::key_value);
+}
+
+/// Parallel iterator methods and other parallel methods.
+///
+/// The following methods **require crate feature `"rayon"`**.
+///
+/// See also the `IntoParallelIterator` implementations.
+impl<K, V, S> IndexMap<K, V, S>
+where
+    K: Sync,
+    V: Sync,
+{
+    /// Return a parallel iterator over the keys of the map.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the map is still preserved for operations like `reduce` and `collect`.
+    pub fn par_keys(&self) -> ParKeys<'_, K, V> {
+        ParKeys {
+            entries: self.as_entries(),
+        }
+    }
+
+    /// Return a parallel iterator over the values of the map.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the map is still preserved for operations like `reduce` and `collect`.
+    pub fn par_values(&self) -> ParValues<'_, K, V> {
+        ParValues {
+            entries: self.as_entries(),
+        }
+    }
+}
+
+/// Parallel iterator methods and other parallel methods.
+///
+/// The following methods **require crate feature `"rayon"`**.
+///
+/// See also the `IntoParallelIterator` implementations.
+impl<K, V> Slice<K, V>
+where
+    K: Sync,
+    V: Sync,
+{
+    /// Return a parallel iterator over the keys of the map slice.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the slice is still preserved for operations like `reduce` and `collect`.
+    pub fn par_keys(&self) -> ParKeys<'_, K, V> {
+        ParKeys {
+            entries: &self.entries,
+        }
+    }
+
+    /// Return a parallel iterator over the values of the map slice.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the slice is still preserved for operations like `reduce` and `collect`.
+    pub fn par_values(&self) -> ParValues<'_, K, V> {
+        ParValues {
+            entries: &self.entries,
+        }
+    }
+}
+
+impl<K, V, S> IndexMap<K, V, S>
+where
+    K: Hash + Eq + Sync,
+    V: Sync,
+    S: BuildHasher,
+{
+    /// Returns `true` if `self` contains all of the same key-value pairs as `other`,
+    /// regardless of each map's indexed order, determined in parallel.
+    pub fn par_eq<V2, S2>(&self, other: &IndexMap<K, V2, S2>) -> bool
+    where
+        V: PartialEq<V2>,
+        V2: Sync,
+        S2: BuildHasher + Sync,
+    {
+        self.len() == other.len()
+            && self
+                .par_iter()
+                .all(move |(key, value)| other.get(key).map_or(false, |v| *value == *v))
+    }
+}
+
+/// A parallel iterator over the keys of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::par_keys`] method.
+/// See its documentation for more.
+pub struct ParKeys<'a, K, V> {
+    entries: &'a [Bucket<K, V>],
+}
+
+impl<K, V> Clone for ParKeys<'_, K, V> {
+    fn clone(&self) -> Self {
+        ParKeys { ..*self }
+    }
+}
+
+impl<K: fmt::Debug, V> fmt::Debug for ParKeys<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::key_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<'a, K: Sync, V: Sync> ParallelIterator for ParKeys<'a, K, V> {
+    type Item = &'a K;
+
+    parallel_iterator_methods!(Bucket::key_ref);
+}
+
+impl<K: Sync, V: Sync> IndexedParallelIterator for ParKeys<'_, K, V> {
+    indexed_parallel_iterator_methods!(Bucket::key_ref);
+}
+
+/// A parallel iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::par_values`] method.
+/// See its documentation for more.
+pub struct ParValues<'a, K, V> {
+    entries: &'a [Bucket<K, V>],
+}
+
+impl<K, V> Clone for ParValues<'_, K, V> {
+    fn clone(&self) -> Self {
+        ParValues { ..*self }
+    }
+}
+
+impl<K, V: fmt::Debug> fmt::Debug for ParValues<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::value_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<'a, K: Sync, V: Sync> ParallelIterator for ParValues<'a, K, V> {
+    type Item = &'a V;
+
+    parallel_iterator_methods!(Bucket::value_ref);
+}
+
+impl<K: Sync, V: Sync> IndexedParallelIterator for ParValues<'_, K, V> {
+    indexed_parallel_iterator_methods!(Bucket::value_ref);
+}
+
+impl<K, V, S> IndexMap<K, V, S>
+where
+    K: Send,
+    V: Send,
+{
+    /// Return a parallel iterator over mutable references to the values of the map
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the map is still preserved for operations like `reduce` and `collect`.
+    pub fn par_values_mut(&mut self) -> ParValuesMut<'_, K, V> {
+        ParValuesMut {
+            entries: self.as_entries_mut(),
+        }
+    }
+}
+
+impl<K, V> Slice<K, V>
+where
+    K: Send,
+    V: Send,
+{
+    /// Return a parallel iterator over mutable references to the the values of the map slice.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the slice is still preserved for operations like `reduce` and `collect`.
+    pub fn par_values_mut(&mut self) -> ParValuesMut<'_, K, V> {
+        ParValuesMut {
+            entries: &mut self.entries,
+        }
+    }
+}
+
+impl<K, V, S> IndexMap<K, V, S>
+where
+    K: Send,
+    V: Send,
+{
+    /// Sort the map’s key-value pairs in parallel, by the default ordering of the keys.
+    pub fn par_sort_keys(&mut self)
+    where
+        K: Ord,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_by(|a, b| K::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the map’s key-value pairs in place and in parallel, using the comparison
+    /// function `cmp`.
+    ///
+    /// The comparison function receives two key and value pairs to compare (you
+    /// can sort by keys or values or their combination as needed).
+    pub fn par_sort_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&K, &V, &K, &V) -> Ordering + Sync,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        });
+    }
+
+    /// Sort the key-value pairs of the map in parallel and return a by-value parallel
+    /// iterator of the key-value pairs with the result.
+    pub fn par_sorted_by<F>(self, cmp: F) -> IntoParIter<K, V>
+    where
+        F: Fn(&K, &V, &K, &V) -> Ordering + Sync,
+    {
+        let mut entries = self.into_entries();
+        entries.par_sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        IntoParIter { entries }
+    }
+
+    /// Sort the map's key-value pairs in parallel, by the default ordering of the keys.
+    pub fn par_sort_unstable_keys(&mut self)
+    where
+        K: Ord,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(|a, b| K::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the map's key-value pairs in place and in parallel, using the comparison
+    /// function `cmp`.
+    ///
+    /// The comparison function receives two key and value pairs to compare (you
+    /// can sort by keys or values or their combination as needed).
+    pub fn par_sort_unstable_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&K, &V, &K, &V) -> Ordering + Sync,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        });
+    }
+
+    /// Sort the key-value pairs of the map in parallel and return a by-value parallel
+    /// iterator of the key-value pairs with the result.
+    pub fn par_sorted_unstable_by<F>(self, cmp: F) -> IntoParIter<K, V>
+    where
+        F: Fn(&K, &V, &K, &V) -> Ordering + Sync,
+    {
+        let mut entries = self.into_entries();
+        entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        IntoParIter { entries }
+    }
+
+    /// Sort the map’s key-value pairs in place and in parallel, using a sort-key extraction
+    /// function.
+    pub fn par_sort_by_cached_key<T, F>(&mut self, sort_key: F)
+    where
+        T: Ord + Send,
+        F: Fn(&K, &V) -> T + Sync,
+    {
+        self.with_entries(move |entries| {
+            entries.par_sort_by_cached_key(move |a| sort_key(&a.key, &a.value));
+        });
+    }
+}
+
+/// A parallel mutable iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::par_values_mut`] method.
+/// See its documentation for more.
+pub struct ParValuesMut<'a, K, V> {
+    entries: &'a mut [Bucket<K, V>],
+}
+
+impl<K, V: fmt::Debug> fmt::Debug for ParValuesMut<'_, K, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::value_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<'a, K: Send, V: Send> ParallelIterator for ParValuesMut<'a, K, V> {
+    type Item = &'a mut V;
+
+    parallel_iterator_methods!(Bucket::value_mut);
+}
+
+impl<K: Send, V: Send> IndexedParallelIterator for ParValuesMut<'_, K, V> {
+    indexed_parallel_iterator_methods!(Bucket::value_mut);
+}
+
+impl<K, V, S> FromParallelIterator<(K, V)> for IndexMap<K, V, S>
+where
+    K: Eq + Hash + Send,
+    V: Send,
+    S: BuildHasher + Default + Send,
+{
+    fn from_par_iter<I>(iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
+    {
+        let list = collect(iter);
+        let len = list.iter().map(Vec::len).sum();
+        let mut map = Self::with_capacity_and_hasher(len, S::default());
+        for vec in list {
+            map.extend(vec);
+        }
+        map
+    }
+}
+
+impl<K, V, S> ParallelExtend<(K, V)> for IndexMap<K, V, S>
+where
+    K: Eq + Hash + Send,
+    V: Send,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, iter: I)
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
+    {
+        for vec in collect(iter) {
+            self.extend(vec);
+        }
+    }
+}
+
+impl<'a, K: 'a, V: 'a, S> ParallelExtend<(&'a K, &'a V)> for IndexMap<K, V, S>
+where
+    K: Copy + Eq + Hash + Send + Sync,
+    V: Copy + Send + Sync,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, iter: I)
+    where
+        I: IntoParallelIterator<Item = (&'a K, &'a V)>,
+    {
+        for vec in collect(iter) {
+            self.extend(vec);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::string::String;
+
+    #[test]
+    fn insert_order() {
+        let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+        let mut map = IndexMap::new();
+
+        for &elt in &insert {
+            map.insert(elt, ());
+        }
+
+        assert_eq!(map.par_keys().count(), map.len());
+        assert_eq!(map.par_keys().count(), insert.len());
+        insert.par_iter().zip(map.par_keys()).for_each(|(a, b)| {
+            assert_eq!(a, b);
+        });
+        (0..insert.len())
+            .into_par_iter()
+            .zip(map.par_keys())
+            .for_each(|(i, k)| {
+                assert_eq!(map.get_index(i).unwrap().0, k);
+            });
+    }
+
+    #[test]
+    fn partial_eq_and_eq() {
+        let mut map_a = IndexMap::new();
+        map_a.insert(1, "1");
+        map_a.insert(2, "2");
+        let mut map_b = map_a.clone();
+        assert!(map_a.par_eq(&map_b));
+        map_b.swap_remove(&1);
+        assert!(!map_a.par_eq(&map_b));
+        map_b.insert(3, "3");
+        assert!(!map_a.par_eq(&map_b));
+
+        let map_c: IndexMap<_, String> =
+            map_b.into_par_iter().map(|(k, v)| (k, v.into())).collect();
+        assert!(!map_a.par_eq(&map_c));
+        assert!(!map_c.par_eq(&map_a));
+    }
+
+    #[test]
+    fn extend() {
+        let mut map = IndexMap::new();
+        map.par_extend(vec![(&1, &2), (&3, &4)]);
+        map.par_extend(vec![(5, 6)]);
+        assert_eq!(
+            map.into_par_iter().collect::<Vec<_>>(),
+            vec![(1, 2), (3, 4), (5, 6)]
+        );
+    }
+
+    #[test]
+    fn keys() {
+        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+        let map: IndexMap<_, _> = vec.into_par_iter().collect();
+        let keys: Vec<_> = map.par_keys().copied().collect();
+        assert_eq!(keys.len(), 3);
+        assert!(keys.contains(&1));
+        assert!(keys.contains(&2));
+        assert!(keys.contains(&3));
+    }
+
+    #[test]
+    fn values() {
+        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+        let map: IndexMap<_, _> = vec.into_par_iter().collect();
+        let values: Vec<_> = map.par_values().copied().collect();
+        assert_eq!(values.len(), 3);
+        assert!(values.contains(&'a'));
+        assert!(values.contains(&'b'));
+        assert!(values.contains(&'c'));
+    }
+
+    #[test]
+    fn values_mut() {
+        let vec = vec![(1, 1), (2, 2), (3, 3)];
+        let mut map: IndexMap<_, _> = vec.into_par_iter().collect();
+        map.par_values_mut().for_each(|value| *value *= 2);
+        let values: Vec<_> = map.par_values().copied().collect();
+        assert_eq!(values.len(), 3);
+        assert!(values.contains(&2));
+        assert!(values.contains(&4));
+        assert!(values.contains(&6));
+    }
+}
diff --git a/vendor/indexmap/src/rayon/mod.rs b/vendor/indexmap/src/rayon/mod.rs
new file mode 100644
index 00000000..84ce02db
--- /dev/null
+++ b/vendor/indexmap/src/rayon/mod.rs
@@ -0,0 +1,16 @@
+#![cfg_attr(docsrs, doc(cfg(feature = "rayon")))]
+
+use rayon::prelude::*;
+
+use alloc::collections::LinkedList;
+
+use crate::vec::Vec;
+
+pub mod map;
+pub mod set;
+
+// This form of intermediate collection is also how Rayon collects `HashMap`.
+// Note that the order will also be preserved!
+fn collect<I: IntoParallelIterator>(iter: I) -> LinkedList<Vec<I::Item>> {
+    iter.into_par_iter().collect_vec_list()
+}
diff --git a/vendor/indexmap/src/rayon/set.rs b/vendor/indexmap/src/rayon/set.rs
new file mode 100644
index 00000000..3904234b
--- /dev/null
+++ b/vendor/indexmap/src/rayon/set.rs
@@ -0,0 +1,756 @@
+//! Parallel iterator types for [`IndexSet`] with [rayon][::rayon].
+//!
+//! You will rarely need to interact with this module directly unless you need to name one of the
+//! iterator types.
+
+use super::collect;
+use rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
+use rayon::prelude::*;
+
+use crate::vec::Vec;
+use alloc::boxed::Box;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::ops::RangeBounds;
+
+use crate::set::Slice;
+use crate::Entries;
+use crate::IndexSet;
+
+type Bucket<T> = crate::Bucket<T, ()>;
+
+impl<T, S> IntoParallelIterator for IndexSet<T, S>
+where
+    T: Send,
+{
+    type Item = T;
+    type Iter = IntoParIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoParIter {
+            entries: self.into_entries(),
+        }
+    }
+}
+
+impl<T> IntoParallelIterator for Box<Slice<T>>
+where
+    T: Send,
+{
+    type Item = T;
+    type Iter = IntoParIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoParIter {
+            entries: self.into_entries(),
+        }
+    }
+}
+
+/// A parallel owning iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::into_par_iter`] method
+/// (provided by rayon's [`IntoParallelIterator`] trait). See its documentation for more.
+pub struct IntoParIter<T> {
+    entries: Vec<Bucket<T>>,
+}
+
+impl<T: fmt::Debug> fmt::Debug for IntoParIter<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::key_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<T: Send> ParallelIterator for IntoParIter<T> {
+    type Item = T;
+
+    parallel_iterator_methods!(Bucket::key);
+}
+
+impl<T: Send> IndexedParallelIterator for IntoParIter<T> {
+    indexed_parallel_iterator_methods!(Bucket::key);
+}
+
+impl<'a, T, S> IntoParallelIterator for &'a IndexSet<T, S>
+where
+    T: Sync,
+{
+    type Item = &'a T;
+    type Iter = ParIter<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        ParIter {
+            entries: self.as_entries(),
+        }
+    }
+}
+
+impl<'a, T> IntoParallelIterator for &'a Slice<T>
+where
+    T: Sync,
+{
+    type Item = &'a T;
+    type Iter = ParIter<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        ParIter {
+            entries: &self.entries,
+        }
+    }
+}
+
+/// A parallel iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::par_iter`] method
+/// (provided by rayon's [`IntoParallelRefIterator`] trait). See its documentation for more.
+///
+/// [`IndexSet::par_iter`]: ../struct.IndexSet.html#method.par_iter
+pub struct ParIter<'a, T> {
+    entries: &'a [Bucket<T>],
+}
+
+impl<T> Clone for ParIter<'_, T> {
+    fn clone(&self) -> Self {
+        ParIter { ..*self }
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for ParIter<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.entries.iter().map(Bucket::key_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<'a, T: Sync> ParallelIterator for ParIter<'a, T> {
+    type Item = &'a T;
+
+    parallel_iterator_methods!(Bucket::key_ref);
+}
+
+impl<T: Sync> IndexedParallelIterator for ParIter<'_, T> {
+    indexed_parallel_iterator_methods!(Bucket::key_ref);
+}
+
+impl<'a, T, S> ParallelDrainRange<usize> for &'a mut IndexSet<T, S>
+where
+    T: Send,
+{
+    type Item = T;
+    type Iter = ParDrain<'a, T>;
+
+    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
+        ParDrain {
+            entries: self.map.core.par_drain(range),
+        }
+    }
+}
+
+/// A parallel draining iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::par_drain`] method
+/// (provided by rayon's [`ParallelDrainRange`] trait). See its documentation for more.
+///
+/// [`IndexSet::par_drain`]: ../struct.IndexSet.html#method.par_drain
+pub struct ParDrain<'a, T: Send> {
+    entries: rayon::vec::Drain<'a, Bucket<T>>,
+}
+
+impl<T: Send> ParallelIterator for ParDrain<'_, T> {
+    type Item = T;
+
+    parallel_iterator_methods!(Bucket::key);
+}
+
+impl<T: Send> IndexedParallelIterator for ParDrain<'_, T> {
+    indexed_parallel_iterator_methods!(Bucket::key);
+}
+
+/// Parallel iterator methods and other parallel methods.
+///
+/// The following methods **require crate feature `"rayon"`**.
+///
+/// See also the `IntoParallelIterator` implementations.
+impl<T, S> IndexSet<T, S>
+where
+    T: Hash + Eq + Sync,
+    S: BuildHasher + Sync,
+{
+    /// Return a parallel iterator over the values that are in `self` but not `other`.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the `self` set is still preserved for operations like `reduce` and `collect`.
+    pub fn par_difference<'a, S2>(
+        &'a self,
+        other: &'a IndexSet<T, S2>,
+    ) -> ParDifference<'a, T, S, S2>
+    where
+        S2: BuildHasher + Sync,
+    {
+        ParDifference {
+            set1: self,
+            set2: other,
+        }
+    }
+
+    /// Return a parallel iterator over the values that are in `self` or `other`,
+    /// but not in both.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the sets is still preserved for operations like `reduce` and `collect`.
+    /// Values from `self` are produced in their original order, followed by
+    /// values from `other` in their original order.
+    pub fn par_symmetric_difference<'a, S2>(
+        &'a self,
+        other: &'a IndexSet<T, S2>,
+    ) -> ParSymmetricDifference<'a, T, S, S2>
+    where
+        S2: BuildHasher + Sync,
+    {
+        ParSymmetricDifference {
+            set1: self,
+            set2: other,
+        }
+    }
+
+    /// Return a parallel iterator over the values that are in both `self` and `other`.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the `self` set is still preserved for operations like `reduce` and `collect`.
+    pub fn par_intersection<'a, S2>(
+        &'a self,
+        other: &'a IndexSet<T, S2>,
+    ) -> ParIntersection<'a, T, S, S2>
+    where
+        S2: BuildHasher + Sync,
+    {
+        ParIntersection {
+            set1: self,
+            set2: other,
+        }
+    }
+
+    /// Return a parallel iterator over all values that are in `self` or `other`.
+    ///
+    /// While parallel iterators can process items in any order, their relative order
+    /// in the sets is still preserved for operations like `reduce` and `collect`.
+    /// Values from `self` are produced in their original order, followed by
+    /// values that are unique to `other` in their original order.
+    pub fn par_union<'a, S2>(&'a self, other: &'a IndexSet<T, S2>) -> ParUnion<'a, T, S, S2>
+    where
+        S2: BuildHasher + Sync,
+    {
+        ParUnion {
+            set1: self,
+            set2: other,
+        }
+    }
+
+    /// Returns `true` if `self` contains all of the same values as `other`,
+    /// regardless of each set's indexed order, determined in parallel.
+    pub fn par_eq<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher + Sync,
+    {
+        self.len() == other.len() && self.par_is_subset(other)
+    }
+
+    /// Returns `true` if `self` has no elements in common with `other`,
+    /// determined in parallel.
+    pub fn par_is_disjoint<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher + Sync,
+    {
+        if self.len() <= other.len() {
+            self.par_iter().all(move |value| !other.contains(value))
+        } else {
+            other.par_iter().all(move |value| !self.contains(value))
+        }
+    }
+
+    /// Returns `true` if all elements of `other` are contained in `self`,
+    /// determined in parallel.
+    pub fn par_is_superset<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher + Sync,
+    {
+        other.par_is_subset(self)
+    }
+
+    /// Returns `true` if all elements of `self` are contained in `other`,
+    /// determined in parallel.
+    pub fn par_is_subset<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher + Sync,
+    {
+        self.len() <= other.len() && self.par_iter().all(move |value| other.contains(value))
+    }
+}
+
+/// A parallel iterator producing elements in the difference of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::par_difference`] method.
+/// See its documentation for more.
+pub struct ParDifference<'a, T, S1, S2> {
+    set1: &'a IndexSet<T, S1>,
+    set2: &'a IndexSet<T, S2>,
+}
+
+impl<T, S1, S2> Clone for ParDifference<'_, T, S1, S2> {
+    fn clone(&self) -> Self {
+        ParDifference { ..*self }
+    }
+}
+
+impl<T, S1, S2> fmt::Debug for ParDifference<'_, T, S1, S2>
+where
+    T: fmt::Debug + Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(self.set1.difference(self.set2))
+            .finish()
+    }
+}
+
+impl<'a, T, S1, S2> ParallelIterator for ParDifference<'a, T, S1, S2>
+where
+    T: Hash + Eq + Sync,
+    S1: BuildHasher + Sync,
+    S2: BuildHasher + Sync,
+{
+    type Item = &'a T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let Self { set1, set2 } = self;
+
+        set1.par_iter()
+            .filter(move |&item| !set2.contains(item))
+            .drive_unindexed(consumer)
+    }
+}
+
+/// A parallel iterator producing elements in the intersection of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::par_intersection`] method.
+/// See its documentation for more.
+pub struct ParIntersection<'a, T, S1, S2> {
+    set1: &'a IndexSet<T, S1>,
+    set2: &'a IndexSet<T, S2>,
+}
+
+impl<T, S1, S2> Clone for ParIntersection<'_, T, S1, S2> {
+    fn clone(&self) -> Self {
+        ParIntersection { ..*self }
+    }
+}
+
+impl<T, S1, S2> fmt::Debug for ParIntersection<'_, T, S1, S2>
+where
+    T: fmt::Debug + Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(self.set1.intersection(self.set2))
+            .finish()
+    }
+}
+
+impl<'a, T, S1, S2> ParallelIterator for ParIntersection<'a, T, S1, S2>
+where
+    T: Hash + Eq + Sync,
+    S1: BuildHasher + Sync,
+    S2: BuildHasher + Sync,
+{
+    type Item = &'a T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let Self { set1, set2 } = self;
+
+        set1.par_iter()
+            .filter(move |&item| set2.contains(item))
+            .drive_unindexed(consumer)
+    }
+}
+
+/// A parallel iterator producing elements in the symmetric difference of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::par_symmetric_difference`] method.
+/// See its documentation for more.
+pub struct ParSymmetricDifference<'a, T, S1, S2> {
+    set1: &'a IndexSet<T, S1>,
+    set2: &'a IndexSet<T, S2>,
+}
+
+impl<T, S1, S2> Clone for ParSymmetricDifference<'_, T, S1, S2> {
+    fn clone(&self) -> Self {
+        ParSymmetricDifference { ..*self }
+    }
+}
+
+impl<T, S1, S2> fmt::Debug for ParSymmetricDifference<'_, T, S1, S2>
+where
+    T: fmt::Debug + Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(self.set1.symmetric_difference(self.set2))
+            .finish()
+    }
+}
+
+impl<'a, T, S1, S2> ParallelIterator for ParSymmetricDifference<'a, T, S1, S2>
+where
+    T: Hash + Eq + Sync,
+    S1: BuildHasher + Sync,
+    S2: BuildHasher + Sync,
+{
+    type Item = &'a T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let Self { set1, set2 } = self;
+
+        set1.par_difference(set2)
+            .chain(set2.par_difference(set1))
+            .drive_unindexed(consumer)
+    }
+}
+
+/// A parallel iterator producing elements in the union of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::par_union`] method.
+/// See its documentation for more.
+pub struct ParUnion<'a, T, S1, S2> {
+    set1: &'a IndexSet<T, S1>,
+    set2: &'a IndexSet<T, S2>,
+}
+
+impl<T, S1, S2> Clone for ParUnion<'_, T, S1, S2> {
+    fn clone(&self) -> Self {
+        ParUnion { ..*self }
+    }
+}
+
+impl<T, S1, S2> fmt::Debug for ParUnion<'_, T, S1, S2>
+where
+    T: fmt::Debug + Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.set1.union(self.set2)).finish()
+    }
+}
+
+impl<'a, T, S1, S2> ParallelIterator for ParUnion<'a, T, S1, S2>
+where
+    T: Hash + Eq + Sync,
+    S1: BuildHasher + Sync,
+    S2: BuildHasher + Sync,
+{
+    type Item = &'a T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let Self { set1, set2 } = self;
+
+        set1.par_iter()
+            .chain(set2.par_difference(set1))
+            .drive_unindexed(consumer)
+    }
+}
+
+/// Parallel sorting methods.
+///
+/// The following methods **require crate feature `"rayon"`**.
+impl<T, S> IndexSet<T, S>
+where
+    T: Send,
+{
+    /// Sort the set’s values in parallel by their default ordering.
+    pub fn par_sort(&mut self)
+    where
+        T: Ord,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_by(|a, b| T::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the set’s values in place and in parallel, using the comparison function `cmp`.
+    pub fn par_sort_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_by(move |a, b| cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the values of the set in parallel and return a by-value parallel iterator of
+    /// the values with the result.
+    pub fn par_sorted_by<F>(self, cmp: F) -> IntoParIter<T>
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        let mut entries = self.into_entries();
+        entries.par_sort_by(move |a, b| cmp(&a.key, &b.key));
+        IntoParIter { entries }
+    }
+
+    /// Sort the set's values in parallel by their default ordering.
+    pub fn par_sort_unstable(&mut self)
+    where
+        T: Ord,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(|a, b| T::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the set’s values in place and in parallel, using the comparison function `cmp`.
+    pub fn par_sort_unstable_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the values of the set in parallel and return a by-value parallel iterator of
+    /// the values with the result.
+    pub fn par_sorted_unstable_by<F>(self, cmp: F) -> IntoParIter<T>
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        let mut entries = self.into_entries();
+        entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
+        IntoParIter { entries }
+    }
+
+    /// Sort the set’s values in place and in parallel, using a key extraction function.
+    pub fn par_sort_by_cached_key<K, F>(&mut self, sort_key: F)
+    where
+        K: Ord + Send,
+        F: Fn(&T) -> K + Sync,
+    {
+        self.with_entries(move |entries| {
+            entries.par_sort_by_cached_key(move |a| sort_key(&a.key));
+        });
+    }
+}
+
+impl<T, S> FromParallelIterator<T> for IndexSet<T, S>
+where
+    T: Eq + Hash + Send,
+    S: BuildHasher + Default + Send,
+{
+    fn from_par_iter<I>(iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        let list = collect(iter);
+        let len = list.iter().map(Vec::len).sum();
+        let mut set = Self::with_capacity_and_hasher(len, S::default());
+        for vec in list {
+            set.extend(vec);
+        }
+        set
+    }
+}
+
+impl<T, S> ParallelExtend<T> for IndexSet<T, S>
+where
+    T: Eq + Hash + Send,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        for vec in collect(iter) {
+            self.extend(vec);
+        }
+    }
+}
+
+impl<'a, T: 'a, S> ParallelExtend<&'a T> for IndexSet<T, S>
+where
+    T: Copy + Eq + Hash + Send + Sync,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        for vec in collect(iter) {
+            self.extend(vec);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn insert_order() {
+        let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+        let mut set = IndexSet::new();
+
+        for &elt in &insert {
+            set.insert(elt);
+        }
+
+        assert_eq!(set.par_iter().count(), set.len());
+        assert_eq!(set.par_iter().count(), insert.len());
+        insert.par_iter().zip(&set).for_each(|(a, b)| {
+            assert_eq!(a, b);
+        });
+        (0..insert.len())
+            .into_par_iter()
+            .zip(&set)
+            .for_each(|(i, v)| {
+                assert_eq!(set.get_index(i).unwrap(), v);
+            });
+    }
+
+    #[test]
+    fn partial_eq_and_eq() {
+        let mut set_a = IndexSet::new();
+        set_a.insert(1);
+        set_a.insert(2);
+        let mut set_b = set_a.clone();
+        assert!(set_a.par_eq(&set_b));
+        set_b.swap_remove(&1);
+        assert!(!set_a.par_eq(&set_b));
+        set_b.insert(3);
+        assert!(!set_a.par_eq(&set_b));
+
+        let set_c: IndexSet<_> = set_b.into_par_iter().collect();
+        assert!(!set_a.par_eq(&set_c));
+        assert!(!set_c.par_eq(&set_a));
+    }
+
+    #[test]
+    fn extend() {
+        let mut set = IndexSet::new();
+        set.par_extend(vec![&1, &2, &3, &4]);
+        set.par_extend(vec![5, 6]);
+        assert_eq!(
+            set.into_par_iter().collect::<Vec<_>>(),
+            vec![1, 2, 3, 4, 5, 6]
+        );
+    }
+
+    #[test]
+    fn comparisons() {
+        let set_a: IndexSet<_> = (0..3).collect();
+        let set_b: IndexSet<_> = (3..6).collect();
+        let set_c: IndexSet<_> = (0..6).collect();
+        let set_d: IndexSet<_> = (3..9).collect();
+
+        assert!(!set_a.par_is_disjoint(&set_a));
+        assert!(set_a.par_is_subset(&set_a));
+        assert!(set_a.par_is_superset(&set_a));
+
+        assert!(set_a.par_is_disjoint(&set_b));
+        assert!(set_b.par_is_disjoint(&set_a));
+        assert!(!set_a.par_is_subset(&set_b));
+        assert!(!set_b.par_is_subset(&set_a));
+        assert!(!set_a.par_is_superset(&set_b));
+        assert!(!set_b.par_is_superset(&set_a));
+
+        assert!(!set_a.par_is_disjoint(&set_c));
+        assert!(!set_c.par_is_disjoint(&set_a));
+        assert!(set_a.par_is_subset(&set_c));
+        assert!(!set_c.par_is_subset(&set_a));
+        assert!(!set_a.par_is_superset(&set_c));
+        assert!(set_c.par_is_superset(&set_a));
+
+        assert!(!set_c.par_is_disjoint(&set_d));
+        assert!(!set_d.par_is_disjoint(&set_c));
+        assert!(!set_c.par_is_subset(&set_d));
+        assert!(!set_d.par_is_subset(&set_c));
+        assert!(!set_c.par_is_superset(&set_d));
+        assert!(!set_d.par_is_superset(&set_c));
+    }
+
+    #[test]
+    fn iter_comparisons() {
+        use std::iter::empty;
+
+        fn check<'a, I1, I2>(iter1: I1, iter2: I2)
+        where
+            I1: ParallelIterator<Item = &'a i32>,
+            I2: Iterator<Item = i32>,
+        {
+            let v1: Vec<_> = iter1.copied().collect();
+            let v2: Vec<_> = iter2.collect();
+            assert_eq!(v1, v2);
+        }
+
+        let set_a: IndexSet<_> = (0..3).collect();
+        let set_b: IndexSet<_> = (3..6).collect();
+        let set_c: IndexSet<_> = (0..6).collect();
+        let set_d: IndexSet<_> = (3..9).rev().collect();
+
+        check(set_a.par_difference(&set_a), empty());
+        check(set_a.par_symmetric_difference(&set_a), empty());
+        check(set_a.par_intersection(&set_a), 0..3);
+        check(set_a.par_union(&set_a), 0..3);
+
+        check(set_a.par_difference(&set_b), 0..3);
+        check(set_b.par_difference(&set_a), 3..6);
+        check(set_a.par_symmetric_difference(&set_b), 0..6);
+        check(set_b.par_symmetric_difference(&set_a), (3..6).chain(0..3));
+        check(set_a.par_intersection(&set_b), empty());
+        check(set_b.par_intersection(&set_a), empty());
+        check(set_a.par_union(&set_b), 0..6);
+        check(set_b.par_union(&set_a), (3..6).chain(0..3));
+
+        check(set_a.par_difference(&set_c), empty());
+        check(set_c.par_difference(&set_a), 3..6);
+        check(set_a.par_symmetric_difference(&set_c), 3..6);
+        check(set_c.par_symmetric_difference(&set_a), 3..6);
+        check(set_a.par_intersection(&set_c), 0..3);
+        check(set_c.par_intersection(&set_a), 0..3);
+        check(set_a.par_union(&set_c), 0..6);
+        check(set_c.par_union(&set_a), 0..6);
+
+        check(set_c.par_difference(&set_d), 0..3);
+        check(set_d.par_difference(&set_c), (6..9).rev());
+        check(
+            set_c.par_symmetric_difference(&set_d),
+            (0..3).chain((6..9).rev()),
+        );
+        check(
+            set_d.par_symmetric_difference(&set_c),
+            (6..9).rev().chain(0..3),
+        );
+        check(set_c.par_intersection(&set_d), 3..6);
+        check(set_d.par_intersection(&set_c), (3..6).rev());
+        check(set_c.par_union(&set_d), (0..6).chain((6..9).rev()));
+        check(set_d.par_union(&set_c), (3..9).rev().chain(0..3));
+    }
+}
diff --git a/vendor/indexmap/src/serde.rs b/vendor/indexmap/src/serde.rs
new file mode 100644
index 00000000..25546d53
--- /dev/null
+++ b/vendor/indexmap/src/serde.rs
@@ -0,0 +1,166 @@
+#![cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+
+use serde::de::value::{MapDeserializer, SeqDeserializer};
+use serde::de::{
+    Deserialize, Deserializer, Error, IntoDeserializer, MapAccess, SeqAccess, Visitor,
+};
+use serde::ser::{Serialize, Serializer};
+
+use core::fmt::{self, Formatter};
+use core::hash::{BuildHasher, Hash};
+use core::marker::PhantomData;
+use core::{cmp, mem};
+
+use crate::{Bucket, IndexMap, IndexSet};
+
+/// Limit our preallocated capacity from a deserializer `size_hint()`.
+///
+/// We do account for the `Bucket` overhead from its saved `hash` field, but we don't count the
+/// `RawTable` allocation or the fact that its raw capacity will be rounded up to a power of two.
+/// The "max" is an arbitrary choice anyway, not something that needs precise adherence.
+///
+/// This is based on the internal `serde::de::size_hint::cautious(hint)` function.
+pub(crate) fn cautious_capacity<K, V>(hint: Option<usize>) -> usize {
+    const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
+
+    cmp::min(
+        hint.unwrap_or(0),
+        MAX_PREALLOC_BYTES / mem::size_of::<Bucket<K, V>>(),
+    )
+}
+
+impl<K, V, S> Serialize for IndexMap<K, V, S>
+where
+    K: Serialize,
+    V: Serialize,
+{
+    fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
+    where
+        T: Serializer,
+    {
+        serializer.collect_map(self)
+    }
+}
+
+struct IndexMapVisitor<K, V, S>(PhantomData<(K, V, S)>);
+
+impl<'de, K, V, S> Visitor<'de> for IndexMapVisitor<K, V, S>
+where
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+    S: Default + BuildHasher,
+{
+    type Value = IndexMap<K, V, S>;
+
+    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+        write!(formatter, "a map")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        let capacity = cautious_capacity::<K, V>(map.size_hint());
+        let mut values = IndexMap::with_capacity_and_hasher(capacity, S::default());
+
+        while let Some((key, value)) = map.next_entry()? {
+            values.insert(key, value);
+        }
+
+        Ok(values)
+    }
+}
+
+impl<'de, K, V, S> Deserialize<'de> for IndexMap<K, V, S>
+where
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+    S: Default + BuildHasher,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(IndexMapVisitor(PhantomData))
+    }
+}
+
+impl<'de, K, V, S, E> IntoDeserializer<'de, E> for IndexMap<K, V, S>
+where
+    K: IntoDeserializer<'de, E> + Eq + Hash,
+    V: IntoDeserializer<'de, E>,
+    S: BuildHasher,
+    E: Error,
+{
+    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        MapDeserializer::new(self.into_iter())
+    }
+}
+
+impl<T, S> Serialize for IndexSet<T, S>
+where
+    T: Serialize,
+{
+    fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
+    where
+        Se: Serializer,
+    {
+        serializer.collect_seq(self)
+    }
+}
+
+struct IndexSetVisitor<T, S>(PhantomData<(T, S)>);
+
+impl<'de, T, S> Visitor<'de> for IndexSetVisitor<T, S>
+where
+    T: Deserialize<'de> + Eq + Hash,
+    S: Default + BuildHasher,
+{
+    type Value = IndexSet<T, S>;
+
+    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+        write!(formatter, "a set")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let capacity = cautious_capacity::<T, ()>(seq.size_hint());
+        let mut values = IndexSet::with_capacity_and_hasher(capacity, S::default());
+
+        while let Some(value) = seq.next_element()? {
+            values.insert(value);
+        }
+
+        Ok(values)
+    }
+}
+
+impl<'de, T, S> Deserialize<'de> for IndexSet<T, S>
+where
+    T: Deserialize<'de> + Eq + Hash,
+    S: Default + BuildHasher,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(IndexSetVisitor(PhantomData))
+    }
+}
+
+impl<'de, T, S, E> IntoDeserializer<'de, E> for IndexSet<T, S>
+where
+    T: IntoDeserializer<'de, E> + Eq + Hash,
+    S: BuildHasher,
+    E: Error,
+{
+    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        SeqDeserializer::new(self.into_iter())
+    }
+}
diff --git a/vendor/indexmap/src/set.rs b/vendor/indexmap/src/set.rs
new file mode 100644
index 00000000..1be248eb
--- /dev/null
+++ b/vendor/indexmap/src/set.rs
@@ -0,0 +1,1301 @@
+//! A hash set implemented using [`IndexMap`]
+
+mod iter;
+mod mutable;
+mod slice;
+
+#[cfg(test)]
+mod tests;
+
+pub use self::iter::{
+    Difference, Drain, Intersection, IntoIter, Iter, Splice, SymmetricDifference, Union,
+};
+pub use self::mutable::MutableValues;
+pub use self::slice::Slice;
+
+#[cfg(feature = "rayon")]
+pub use crate::rayon::set as rayon;
+use crate::TryReserveError;
+
+#[cfg(feature = "std")]
+use std::collections::hash_map::RandomState;
+
+use crate::util::try_simplify_range;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::ops::{BitAnd, BitOr, BitXor, Index, RangeBounds, Sub};
+
+use super::{Entries, Equivalent, IndexMap};
+
+type Bucket<T> = super::Bucket<T, ()>;
+
+/// A hash set where the iteration order of the values is independent of their
+/// hash values.
+///
+/// The interface is closely compatible with the standard
+/// [`HashSet`][std::collections::HashSet],
+/// but also has additional features.
+///
+/// # Order
+///
+/// The values have a consistent order that is determined by the sequence of
+/// insertion and removal calls on the set. The order does not depend on the
+/// values or the hash function at all. Note that insertion order and value
+/// are not affected if a re-insertion is attempted once an element is
+/// already present.
+///
+/// All iterators traverse the set *in order*.  Set operation iterators like
+/// [`IndexSet::union`] produce a concatenated order, as do their matching "bitwise"
+/// operators.  See their documentation for specifics.
+///
+/// The insertion order is preserved, with **notable exceptions** like the
+/// [`.remove()`][Self::remove] or [`.swap_remove()`][Self::swap_remove] methods.
+/// Methods such as [`.sort_by()`][Self::sort_by] of
+/// course result in a new order, depending on the sorting order.
+///
+/// # Indices
+///
+/// The values are indexed in a compact range without holes in the range
+/// `0..self.len()`. For example, the method `.get_full` looks up the index for
+/// a value, and the method `.get_index` looks up the value by index.
+///
+/// # Complexity
+///
+/// Internally, `IndexSet<T, S>` just holds an [`IndexMap<T, (), S>`](IndexMap). Thus the complexity
+/// of the two are the same for most methods.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexSet;
+///
+/// // Collects which letters appear in a sentence.
+/// let letters: IndexSet<_> = "a short treatise on fungi".chars().collect();
+///
+/// assert!(letters.contains(&'s'));
+/// assert!(letters.contains(&'t'));
+/// assert!(letters.contains(&'u'));
+/// assert!(!letters.contains(&'y'));
+/// ```
+#[cfg(feature = "std")]
+pub struct IndexSet<T, S = RandomState> {
+    pub(crate) map: IndexMap<T, (), S>,
+}
+#[cfg(not(feature = "std"))]
+pub struct IndexSet<T, S> {
+    pub(crate) map: IndexMap<T, (), S>,
+}
+
+impl<T, S> Clone for IndexSet<T, S>
+where
+    T: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        IndexSet {
+            map: self.map.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.map.clone_from(&other.map);
+    }
+}
+
+impl<T, S> Entries for IndexSet<T, S> {
+    type Entry = Bucket<T>;
+
+    #[inline]
+    fn into_entries(self) -> Vec<Self::Entry> {
+        self.map.into_entries()
+    }
+
+    #[inline]
+    fn as_entries(&self) -> &[Self::Entry] {
+        self.map.as_entries()
+    }
+
+    #[inline]
+    fn as_entries_mut(&mut self) -> &mut [Self::Entry] {
+        self.map.as_entries_mut()
+    }
+
+    fn with_entries<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut [Self::Entry]),
+    {
+        self.map.with_entries(f);
+    }
+}
+
+impl<T, S> fmt::Debug for IndexSet<T, S>
+where
+    T: fmt::Debug,
+{
+    #[cfg(not(feature = "test_debug"))]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_set().entries(self.iter()).finish()
+    }
+
+    #[cfg(feature = "test_debug")]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Let the inner `IndexMap` print all of its details
+        f.debug_struct("IndexSet").field("map", &self.map).finish()
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl<T> IndexSet<T> {
+    /// Create a new set. (Does not allocate.)
+    pub fn new() -> Self {
+        IndexSet {
+            map: IndexMap::new(),
+        }
+    }
+
+    /// Create a new set with capacity for `n` elements.
+    /// (Does not allocate if `n` is zero.)
+    ///
+    /// Computes in **O(n)** time.
+    pub fn with_capacity(n: usize) -> Self {
+        IndexSet {
+            map: IndexMap::with_capacity(n),
+        }
+    }
+}
+
+impl<T, S> IndexSet<T, S> {
+    /// Create a new set with capacity for `n` elements.
+    /// (Does not allocate if `n` is zero.)
+    ///
+    /// Computes in **O(n)** time.
+    pub fn with_capacity_and_hasher(n: usize, hash_builder: S) -> Self {
+        IndexSet {
+            map: IndexMap::with_capacity_and_hasher(n, hash_builder),
+        }
+    }
+
+    /// Create a new set with `hash_builder`.
+    ///
+    /// This function is `const`, so it
+    /// can be called in `static` contexts.
+    pub const fn with_hasher(hash_builder: S) -> Self {
+        IndexSet {
+            map: IndexMap::with_hasher(hash_builder),
+        }
+    }
+
+    /// Return the number of elements the set can hold without reallocating.
+    ///
+    /// This number is a lower bound; the set might be able to hold more,
+    /// but is guaranteed to be able to hold at least this many.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn capacity(&self) -> usize {
+        self.map.capacity()
+    }
+
+    /// Return a reference to the set's `BuildHasher`.
+    pub fn hasher(&self) -> &S {
+        self.map.hasher()
+    }
+
+    /// Return the number of elements in the set.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Returns true if the set contains no elements.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+
+    /// Return an iterator over the values of the set, in their order
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter::new(self.as_entries())
+    }
+
+    /// Remove all elements in the set, while preserving its capacity.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn clear(&mut self) {
+        self.map.clear();
+    }
+
+    /// Shortens the set, keeping the first `len` elements and dropping the rest.
+    ///
+    /// If `len` is greater than the set's current length, this has no effect.
+    pub fn truncate(&mut self, len: usize) {
+        self.map.truncate(len);
+    }
+
+    /// Clears the `IndexSet` in the given index range, returning those values
+    /// as a drain iterator.
+    ///
+    /// The range may be any type that implements [`RangeBounds<usize>`],
+    /// including all of the `std::ops::Range*` types, or even a tuple pair of
+    /// `Bound` start and end values. To drain the set entirely, use `RangeFull`
+    /// like `set.drain(..)`.
+    ///
+    /// This shifts down all entries following the drained range to fill the
+    /// gap, and keeps the allocated memory for reuse.
+    ///
+    /// ***Panics*** if the starting point is greater than the end point or if
+    /// the end point is greater than the length of the set.
+    #[track_caller]
+    pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
+    where
+        R: RangeBounds<usize>,
+    {
+        Drain::new(self.map.core.drain(range))
+    }
+
+    /// Splits the collection into two at the given index.
+    ///
+    /// Returns a newly allocated set containing the elements in the range
+    /// `[at, len)`. After the call, the original set will be left containing
+    /// the elements `[0, at)` with its previous capacity unchanged.
+    ///
+    /// ***Panics*** if `at > len`.
+    #[track_caller]
+    pub fn split_off(&mut self, at: usize) -> Self
+    where
+        S: Clone,
+    {
+        Self {
+            map: self.map.split_off(at),
+        }
+    }
+
+    /// Reserve capacity for `additional` more values.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn reserve(&mut self, additional: usize) {
+        self.map.reserve(additional);
+    }
+
+    /// Reserve capacity for `additional` more values, without over-allocating.
+    ///
+    /// Unlike `reserve`, this does not deliberately over-allocate the entry capacity to avoid
+    /// frequent re-allocations. However, the underlying data structures may still have internal
+    /// capacity requirements, and the allocator itself may give more space than requested, so this
+    /// cannot be relied upon to be precisely minimal.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn reserve_exact(&mut self, additional: usize) {
+        self.map.reserve_exact(additional);
+    }
+
+    /// Try to reserve capacity for `additional` more values.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.map.try_reserve(additional)
+    }
+
+    /// Try to reserve capacity for `additional` more values, without over-allocating.
+    ///
+    /// Unlike `try_reserve`, this does not deliberately over-allocate the entry capacity to avoid
+    /// frequent re-allocations. However, the underlying data structures may still have internal
+    /// capacity requirements, and the allocator itself may give more space than requested, so this
+    /// cannot be relied upon to be precisely minimal.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.map.try_reserve_exact(additional)
+    }
+
+    /// Shrink the capacity of the set as much as possible.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn shrink_to_fit(&mut self) {
+        self.map.shrink_to_fit();
+    }
+
+    /// Shrink the capacity of the set with a lower limit.
+    ///
+    /// Computes in **O(n)** time.
+    pub fn shrink_to(&mut self, min_capacity: usize) {
+        self.map.shrink_to(min_capacity);
+    }
+}
+
+impl<T, S> IndexSet<T, S>
+where
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    /// Insert the value into the set.
+    ///
+    /// If an equivalent item already exists in the set, it returns
+    /// `false` leaving the original value in the set and without
+    /// altering its insertion order. Otherwise, it inserts the new
+    /// item and returns `true`.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert(&mut self, value: T) -> bool {
+        self.map.insert(value, ()).is_none()
+    }
+
+    /// Insert the value into the set, and get its index.
+    ///
+    /// If an equivalent item already exists in the set, it returns
+    /// the index of the existing item and `false`, leaving the
+    /// original value in the set and without altering its insertion
+    /// order. Otherwise, it inserts the new item and returns the index
+    /// of the inserted item and `true`.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert_full(&mut self, value: T) -> (usize, bool) {
+        let (index, existing) = self.map.insert_full(value, ());
+        (index, existing.is_none())
+    }
+
+    /// Insert the value into the set at its ordered position among sorted values.
+    ///
+    /// This is equivalent to finding the position with
+    /// [`binary_search`][Self::binary_search], and if needed calling
+    /// [`insert_before`][Self::insert_before] for a new value.
+    ///
+    /// If the sorted item is found in the set, it returns the index of that
+    /// existing item and `false`, without any change. Otherwise, it inserts the
+    /// new item and returns its sorted index and `true`.
+    ///
+    /// If the existing items are **not** already sorted, then the insertion
+    /// index is unspecified (like [`slice::binary_search`]), but the value
+    /// is moved to or inserted at that position regardless.
+    ///
+    /// Computes in **O(n)** time (average). Instead of repeating calls to
+    /// `insert_sorted`, it may be faster to call batched [`insert`][Self::insert]
+    /// or [`extend`][Self::extend] and only call [`sort`][Self::sort] or
+    /// [`sort_unstable`][Self::sort_unstable] once.
+    pub fn insert_sorted(&mut self, value: T) -> (usize, bool)
+    where
+        T: Ord,
+    {
+        let (index, existing) = self.map.insert_sorted(value, ());
+        (index, existing.is_none())
+    }
+
+    /// Insert the value into the set before the value at the given index, or at the end.
+    ///
+    /// If an equivalent item already exists in the set, it returns `false` leaving the
+    /// original value in the set, but moved to the new position. The returned index
+    /// will either be the given index or one less, depending on how the value moved.
+    /// (See [`shift_insert`](Self::shift_insert) for different behavior here.)
+    ///
+    /// Otherwise, it inserts the new value exactly at the given index and returns `true`.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    /// Valid indices are `0..=set.len()` (inclusive).
+    ///
+    /// Computes in **O(n)** time (average).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexSet;
+    /// let mut set: IndexSet<char> = ('a'..='z').collect();
+    ///
+    /// // The new value '*' goes exactly at the given index.
+    /// assert_eq!(set.get_index_of(&'*'), None);
+    /// assert_eq!(set.insert_before(10, '*'), (10, true));
+    /// assert_eq!(set.get_index_of(&'*'), Some(10));
+    ///
+    /// // Moving the value 'a' up will shift others down, so this moves *before* 10 to index 9.
+    /// assert_eq!(set.insert_before(10, 'a'), (9, false));
+    /// assert_eq!(set.get_index_of(&'a'), Some(9));
+    /// assert_eq!(set.get_index_of(&'*'), Some(10));
+    ///
+    /// // Moving the value 'z' down will shift others up, so this moves to exactly 10.
+    /// assert_eq!(set.insert_before(10, 'z'), (10, false));
+    /// assert_eq!(set.get_index_of(&'z'), Some(10));
+    /// assert_eq!(set.get_index_of(&'*'), Some(11));
+    ///
+    /// // Moving or inserting before the endpoint is also valid.
+    /// assert_eq!(set.len(), 27);
+    /// assert_eq!(set.insert_before(set.len(), '*'), (26, false));
+    /// assert_eq!(set.get_index_of(&'*'), Some(26));
+    /// assert_eq!(set.insert_before(set.len(), '+'), (27, true));
+    /// assert_eq!(set.get_index_of(&'+'), Some(27));
+    /// assert_eq!(set.len(), 28);
+    /// ```
+    #[track_caller]
+    pub fn insert_before(&mut self, index: usize, value: T) -> (usize, bool) {
+        let (index, existing) = self.map.insert_before(index, value, ());
+        (index, existing.is_none())
+    }
+
+    /// Insert the value into the set at the given index.
+    ///
+    /// If an equivalent item already exists in the set, it returns `false` leaving
+    /// the original value in the set, but moved to the given index.
+    /// Note that existing values **cannot** be moved to `index == set.len()`!
+    /// (See [`insert_before`](Self::insert_before) for different behavior here.)
+    ///
+    /// Otherwise, it inserts the new value at the given index and returns `true`.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    /// Valid indices are `0..set.len()` (exclusive) when moving an existing value, or
+    /// `0..=set.len()` (inclusive) when inserting a new value.
+    ///
+    /// Computes in **O(n)** time (average).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexSet;
+    /// let mut set: IndexSet<char> = ('a'..='z').collect();
+    ///
+    /// // The new value '*' goes exactly at the given index.
+    /// assert_eq!(set.get_index_of(&'*'), None);
+    /// assert_eq!(set.shift_insert(10, '*'), true);
+    /// assert_eq!(set.get_index_of(&'*'), Some(10));
+    ///
+    /// // Moving the value 'a' up to 10 will shift others down, including the '*' that was at 10.
+    /// assert_eq!(set.shift_insert(10, 'a'), false);
+    /// assert_eq!(set.get_index_of(&'a'), Some(10));
+    /// assert_eq!(set.get_index_of(&'*'), Some(9));
+    ///
+    /// // Moving the value 'z' down to 9 will shift others up, including the '*' that was at 9.
+    /// assert_eq!(set.shift_insert(9, 'z'), false);
+    /// assert_eq!(set.get_index_of(&'z'), Some(9));
+    /// assert_eq!(set.get_index_of(&'*'), Some(10));
+    ///
+    /// // Existing values can move to len-1 at most, but new values can insert at the endpoint.
+    /// assert_eq!(set.len(), 27);
+    /// assert_eq!(set.shift_insert(set.len() - 1, '*'), false);
+    /// assert_eq!(set.get_index_of(&'*'), Some(26));
+    /// assert_eq!(set.shift_insert(set.len(), '+'), true);
+    /// assert_eq!(set.get_index_of(&'+'), Some(27));
+    /// assert_eq!(set.len(), 28);
+    /// ```
+    ///
+    /// ```should_panic
+    /// use indexmap::IndexSet;
+    /// let mut set: IndexSet<char> = ('a'..='z').collect();
+    ///
+    /// // This is an invalid index for moving an existing value!
+    /// set.shift_insert(set.len(), 'a');
+    /// ```
+    #[track_caller]
+    pub fn shift_insert(&mut self, index: usize, value: T) -> bool {
+        self.map.shift_insert(index, value, ()).is_none()
+    }
+
+    /// Adds a value to the set, replacing the existing value, if any, that is
+    /// equal to the given one, without altering its insertion order. Returns
+    /// the replaced value.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn replace(&mut self, value: T) -> Option<T> {
+        self.replace_full(value).1
+    }
+
+    /// Adds a value to the set, replacing the existing value, if any, that is
+    /// equal to the given one, without altering its insertion order. Returns
+    /// the index of the item and its replaced value.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn replace_full(&mut self, value: T) -> (usize, Option<T>) {
+        let hash = self.map.hash(&value);
+        match self.map.core.replace_full(hash, value, ()) {
+            (i, Some((replaced, ()))) => (i, Some(replaced)),
+            (i, None) => (i, None),
+        }
+    }
+
+    /// Return an iterator over the values that are in `self` but not `other`.
+    ///
+    /// Values are produced in the same order that they appear in `self`.
+    pub fn difference<'a, S2>(&'a self, other: &'a IndexSet<T, S2>) -> Difference<'a, T, S2>
+    where
+        S2: BuildHasher,
+    {
+        Difference::new(self, other)
+    }
+
+    /// Return an iterator over the values that are in `self` or `other`,
+    /// but not in both.
+    ///
+    /// Values from `self` are produced in their original order, followed by
+    /// values from `other` in their original order.
+    pub fn symmetric_difference<'a, S2>(
+        &'a self,
+        other: &'a IndexSet<T, S2>,
+    ) -> SymmetricDifference<'a, T, S, S2>
+    where
+        S2: BuildHasher,
+    {
+        SymmetricDifference::new(self, other)
+    }
+
+    /// Return an iterator over the values that are in both `self` and `other`.
+    ///
+    /// Values are produced in the same order that they appear in `self`.
+    pub fn intersection<'a, S2>(&'a self, other: &'a IndexSet<T, S2>) -> Intersection<'a, T, S2>
+    where
+        S2: BuildHasher,
+    {
+        Intersection::new(self, other)
+    }
+
+    /// Return an iterator over all values that are in `self` or `other`.
+    ///
+    /// Values from `self` are produced in their original order, followed by
+    /// values that are unique to `other` in their original order.
+    pub fn union<'a, S2>(&'a self, other: &'a IndexSet<T, S2>) -> Union<'a, T, S>
+    where
+        S2: BuildHasher,
+    {
+        Union::new(self, other)
+    }
+
+    /// Creates a splicing iterator that replaces the specified range in the set
+    /// with the given `replace_with` iterator and yields the removed items.
+    /// `replace_with` does not need to be the same length as `range`.
+    ///
+    /// The `range` is removed even if the iterator is not consumed until the
+    /// end. It is unspecified how many elements are removed from the set if the
+    /// `Splice` value is leaked.
+    ///
+    /// The input iterator `replace_with` is only consumed when the `Splice`
+    /// value is dropped. If a value from the iterator matches an existing entry
+    /// in the set (outside of `range`), then the original will be unchanged.
+    /// Otherwise, the new value will be inserted in the replaced `range`.
+    ///
+    /// ***Panics*** if the starting point is greater than the end point or if
+    /// the end point is greater than the length of the set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexSet;
+    ///
+    /// let mut set = IndexSet::from([0, 1, 2, 3, 4]);
+    /// let new = [5, 4, 3, 2, 1];
+    /// let removed: Vec<_> = set.splice(2..4, new).collect();
+    ///
+    /// // 1 and 4 kept their positions, while 5, 3, and 2 were newly inserted.
+    /// assert!(set.into_iter().eq([0, 1, 5, 3, 2, 4]));
+    /// assert_eq!(removed, &[2, 3]);
+    /// ```
+    #[track_caller]
+    pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, T, S>
+    where
+        R: RangeBounds<usize>,
+        I: IntoIterator<Item = T>,
+    {
+        Splice::new(self, range, replace_with.into_iter())
+    }
+
+    /// Moves all values from `other` into `self`, leaving `other` empty.
+    ///
+    /// This is equivalent to calling [`insert`][Self::insert] for each value
+    /// from `other` in order, which means that values that already exist
+    /// in `self` are unchanged in their current position.
+    ///
+    /// See also [`union`][Self::union] to iterate the combined values by
+    /// reference, without modifying `self` or `other`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexSet;
+    ///
+    /// let mut a = IndexSet::from([3, 2, 1]);
+    /// let mut b = IndexSet::from([3, 4, 5]);
+    /// let old_capacity = b.capacity();
+    ///
+    /// a.append(&mut b);
+    ///
+    /// assert_eq!(a.len(), 5);
+    /// assert_eq!(b.len(), 0);
+    /// assert_eq!(b.capacity(), old_capacity);
+    ///
+    /// assert!(a.iter().eq(&[3, 2, 1, 4, 5]));
+    /// ```
+    pub fn append<S2>(&mut self, other: &mut IndexSet<T, S2>) {
+        self.map.append(&mut other.map);
+    }
+}
+
+impl<T, S> IndexSet<T, S>
+where
+    S: BuildHasher,
+{
+    /// Return `true` if an equivalent to `value` exists in the set.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn contains<Q>(&self, value: &Q) -> bool
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.contains_key(value)
+    }
+
+    /// Return a reference to the value stored in the set, if it is present,
+    /// else `None`.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn get<Q>(&self, value: &Q) -> Option<&T>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.get_key_value(value).map(|(x, &())| x)
+    }
+
+    /// Return item index and value
+    pub fn get_full<Q>(&self, value: &Q) -> Option<(usize, &T)>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.get_full(value).map(|(i, x, &())| (i, x))
+    }
+
+    /// Return item index, if it exists in the set
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn get_index_of<Q>(&self, value: &Q) -> Option<usize>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.get_index_of(value)
+    }
+
+    /// Remove the value from the set, and return `true` if it was present.
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_remove(value)`][Self::swap_remove], replacing this
+    /// value's position with the last element, and it is deprecated in favor of calling that
+    /// explicitly. If you need to preserve the relative order of the values in the set, use
+    /// [`.shift_remove(value)`][Self::shift_remove] instead.
+    #[deprecated(note = "`remove` disrupts the set order -- \
+        use `swap_remove` or `shift_remove` for explicit behavior.")]
+    pub fn remove<Q>(&mut self, value: &Q) -> bool
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.swap_remove(value)
+    }
+
+    /// Remove the value from the set, and return `true` if it was present.
+    ///
+    /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
+    /// last element of the set and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Return `false` if `value` was not in the set.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove<Q>(&mut self, value: &Q) -> bool
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.swap_remove(value).is_some()
+    }
+
+    /// Remove the value from the set, and return `true` if it was present.
+    ///
+    /// Like [`Vec::remove`], the value is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Return `false` if `value` was not in the set.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove<Q>(&mut self, value: &Q) -> bool
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.shift_remove(value).is_some()
+    }
+
+    /// Removes and returns the value in the set, if any, that is equal to the
+    /// given one.
+    ///
+    /// **NOTE:** This is equivalent to [`.swap_take(value)`][Self::swap_take], replacing this
+    /// value's position with the last element, and it is deprecated in favor of calling that
+    /// explicitly. If you need to preserve the relative order of the values in the set, use
+    /// [`.shift_take(value)`][Self::shift_take] instead.
+    #[deprecated(note = "`take` disrupts the set order -- \
+        use `swap_take` or `shift_take` for explicit behavior.")]
+    pub fn take<Q>(&mut self, value: &Q) -> Option<T>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.swap_take(value)
+    }
+
+    /// Removes and returns the value in the set, if any, that is equal to the
+    /// given one.
+    ///
+    /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
+    /// last element of the set and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Return `None` if `value` was not in the set.
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_take<Q>(&mut self, value: &Q) -> Option<T>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.swap_remove_entry(value).map(|(x, ())| x)
+    }
+
+    /// Removes and returns the value in the set, if any, that is equal to the
+    /// given one.
+    ///
+    /// Like [`Vec::remove`], the value is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Return `None` if `value` was not in the set.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_take<Q>(&mut self, value: &Q) -> Option<T>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.shift_remove_entry(value).map(|(x, ())| x)
+    }
+
+    /// Remove the value from the set return it and the index it had.
+    ///
+    /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
+    /// last element of the set and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Return `None` if `value` was not in the set.
+    pub fn swap_remove_full<Q>(&mut self, value: &Q) -> Option<(usize, T)>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.swap_remove_full(value).map(|(i, x, ())| (i, x))
+    }
+
+    /// Remove the value from the set return it and the index it had.
+    ///
+    /// Like [`Vec::remove`], the value is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Return `None` if `value` was not in the set.
+    pub fn shift_remove_full<Q>(&mut self, value: &Q) -> Option<(usize, T)>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        self.map.shift_remove_full(value).map(|(i, x, ())| (i, x))
+    }
+}
+
+impl<T, S> IndexSet<T, S> {
+    /// Remove the last value
+    ///
+    /// This preserves the order of the remaining elements.
+    ///
+    /// Computes in **O(1)** time (average).
+    #[doc(alias = "pop_last")] // like `BTreeSet`
+    pub fn pop(&mut self) -> Option<T> {
+        self.map.pop().map(|(x, ())| x)
+    }
+
+    /// Scan through each value in the set and keep those where the
+    /// closure `keep` returns `true`.
+    ///
+    /// The elements are visited in order, and remaining elements keep their
+    /// order.
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn retain<F>(&mut self, mut keep: F)
+    where
+        F: FnMut(&T) -> bool,
+    {
+        self.map.retain(move |x, &mut ()| keep(x))
+    }
+
+    /// Sort the set’s values by their default ordering.
+    ///
+    /// This is a stable sort -- but equivalent values should not normally coexist in
+    /// a set at all, so [`sort_unstable`][Self::sort_unstable] is preferred
+    /// because it is generally faster and doesn't allocate auxiliary memory.
+    ///
+    /// See [`sort_by`](Self::sort_by) for details.
+    pub fn sort(&mut self)
+    where
+        T: Ord,
+    {
+        self.map.sort_keys()
+    }
+
+    /// Sort the set’s values in place using the comparison function `cmp`.
+    ///
+    /// Computes in **O(n log n)** time and **O(n)** space. The sort is stable.
+    pub fn sort_by<F>(&mut self, mut cmp: F)
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        self.map.sort_by(move |a, _, b, _| cmp(a, b));
+    }
+
+    /// Sort the values of the set and return a by-value iterator of
+    /// the values with the result.
+    ///
+    /// The sort is stable.
+    pub fn sorted_by<F>(self, mut cmp: F) -> IntoIter<T>
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        let mut entries = self.into_entries();
+        entries.sort_by(move |a, b| cmp(&a.key, &b.key));
+        IntoIter::new(entries)
+    }
+
+    /// Sort the set's values by their default ordering.
+    ///
+    /// See [`sort_unstable_by`](Self::sort_unstable_by) for details.
+    pub fn sort_unstable(&mut self)
+    where
+        T: Ord,
+    {
+        self.map.sort_unstable_keys()
+    }
+
+    /// Sort the set's values in place using the comparison function `cmp`.
+    ///
+    /// Computes in **O(n log n)** time. The sort is unstable.
+    pub fn sort_unstable_by<F>(&mut self, mut cmp: F)
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        self.map.sort_unstable_by(move |a, _, b, _| cmp(a, b))
+    }
+
+    /// Sort the values of the set and return a by-value iterator of
+    /// the values with the result.
+    pub fn sorted_unstable_by<F>(self, mut cmp: F) -> IntoIter<T>
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        let mut entries = self.into_entries();
+        entries.sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
+        IntoIter::new(entries)
+    }
+
+    /// Sort the set’s values in place using a key extraction function.
+    ///
+    /// During sorting, the function is called at most once per entry, by using temporary storage
+    /// to remember the results of its evaluation. The order of calls to the function is
+    /// unspecified and may change between versions of `indexmap` or the standard library.
+    ///
+    /// Computes in **O(m n + n log n + c)** time () and **O(n)** space, where the function is
+    /// **O(m)**, *n* is the length of the map, and *c* the capacity. The sort is stable.
+    pub fn sort_by_cached_key<K, F>(&mut self, mut sort_key: F)
+    where
+        K: Ord,
+        F: FnMut(&T) -> K,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_by_cached_key(move |a| sort_key(&a.key));
+        });
+    }
+
+    /// Search over a sorted set for a value.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search`] for more details.
+    ///
+    /// Computes in **O(log(n))** time, which is notably less scalable than looking the value up
+    /// using [`get_index_of`][IndexSet::get_index_of], but this can also position missing values.
+    pub fn binary_search(&self, x: &T) -> Result<usize, usize>
+    where
+        T: Ord,
+    {
+        self.as_slice().binary_search(x)
+    }
+
+    /// Search over a sorted set with a comparator function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a T) -> Ordering,
+    {
+        self.as_slice().binary_search_by(f)
+    }
+
+    /// Search over a sorted set with an extraction function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a T) -> B,
+        B: Ord,
+    {
+        self.as_slice().binary_search_by_key(b, f)
+    }
+
+    /// Returns the index of the partition point of a sorted set according to the given predicate
+    /// (the index of the first element of the second partition).
+    ///
+    /// See [`slice::partition_point`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[must_use]
+    pub fn partition_point<P>(&self, pred: P) -> usize
+    where
+        P: FnMut(&T) -> bool,
+    {
+        self.as_slice().partition_point(pred)
+    }
+
+    /// Reverses the order of the set’s values in place.
+    ///
+    /// Computes in **O(n)** time and **O(1)** space.
+    pub fn reverse(&mut self) {
+        self.map.reverse()
+    }
+
+    /// Returns a slice of all the values in the set.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn as_slice(&self) -> &Slice<T> {
+        Slice::from_slice(self.as_entries())
+    }
+
+    /// Converts into a boxed slice of all the values in the set.
+    ///
+    /// Note that this will drop the inner hash table and any excess capacity.
+    pub fn into_boxed_slice(self) -> Box<Slice<T>> {
+        Slice::from_boxed(self.into_entries().into_boxed_slice())
+    }
+
+    /// Get a value by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_index(&self, index: usize) -> Option<&T> {
+        self.as_entries().get(index).map(Bucket::key_ref)
+    }
+
+    /// Returns a slice of values in the given range of indices.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Slice<T>> {
+        let entries = self.as_entries();
+        let range = try_simplify_range(range, entries.len())?;
+        entries.get(range).map(Slice::from_slice)
+    }
+
+    /// Get the first value
+    ///
+    /// Computes in **O(1)** time.
+    pub fn first(&self) -> Option<&T> {
+        self.as_entries().first().map(Bucket::key_ref)
+    }
+
+    /// Get the last value
+    ///
+    /// Computes in **O(1)** time.
+    pub fn last(&self) -> Option<&T> {
+        self.as_entries().last().map(Bucket::key_ref)
+    }
+
+    /// Remove the value by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
+    /// last element of the set and popping it off. **This perturbs
+    /// the position of what used to be the last element!**
+    ///
+    /// Computes in **O(1)** time (average).
+    pub fn swap_remove_index(&mut self, index: usize) -> Option<T> {
+        self.map.swap_remove_index(index).map(|(x, ())| x)
+    }
+
+    /// Remove the value by index
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Like [`Vec::remove`], the value is removed by shifting all of the
+    /// elements that follow it, preserving their relative order.
+    /// **This perturbs the index of all of those elements!**
+    ///
+    /// Computes in **O(n)** time (average).
+    pub fn shift_remove_index(&mut self, index: usize) -> Option<T> {
+        self.map.shift_remove_index(index).map(|(x, ())| x)
+    }
+
+    /// Moves the position of a value from one index to another
+    /// by shifting all other values in-between.
+    ///
+    /// * If `from < to`, the other values will shift down while the targeted value moves up.
+    /// * If `from > to`, the other values will shift up while the targeted value moves down.
+    ///
+    /// ***Panics*** if `from` or `to` are out of bounds.
+    ///
+    /// Computes in **O(n)** time (average).
+    #[track_caller]
+    pub fn move_index(&mut self, from: usize, to: usize) {
+        self.map.move_index(from, to)
+    }
+
+    /// Swaps the position of two values in the set.
+    ///
+    /// ***Panics*** if `a` or `b` are out of bounds.
+    ///
+    /// Computes in **O(1)** time (average).
+    #[track_caller]
+    pub fn swap_indices(&mut self, a: usize, b: usize) {
+        self.map.swap_indices(a, b)
+    }
+}
+
+/// Access [`IndexSet`] values at indexed positions.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexSet;
+///
+/// let mut set = IndexSet::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+///     set.insert(word.to_string());
+/// }
+/// assert_eq!(set[0], "Lorem");
+/// assert_eq!(set[1], "ipsum");
+/// set.reverse();
+/// assert_eq!(set[0], "amet");
+/// assert_eq!(set[1], "sit");
+/// set.sort();
+/// assert_eq!(set[0], "Lorem");
+/// assert_eq!(set[1], "amet");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexSet;
+///
+/// let mut set = IndexSet::new();
+/// set.insert("foo");
+/// println!("{:?}", set[10]); // panics!
+/// ```
+impl<T, S> Index<usize> for IndexSet<T, S> {
+    type Output = T;
+
+    /// Returns a reference to the value at the supplied `index`.
+    ///
+    /// ***Panics*** if `index` is out of bounds.
+    fn index(&self, index: usize) -> &T {
+        self.get_index(index).unwrap_or_else(|| {
+            panic!(
+                "index out of bounds: the len is {len} but the index is {index}",
+                len = self.len()
+            );
+        })
+    }
+}
+
+impl<T, S> FromIterator<T> for IndexSet<T, S>
+where
+    T: Hash + Eq,
+    S: BuildHasher + Default,
+{
+    fn from_iter<I: IntoIterator<Item = T>>(iterable: I) -> Self {
+        let iter = iterable.into_iter().map(|x| (x, ()));
+        IndexSet {
+            map: IndexMap::from_iter(iter),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl<T, const N: usize> From<[T; N]> for IndexSet<T, RandomState>
+where
+    T: Eq + Hash,
+{
+    /// # Examples
+    ///
+    /// ```
+    /// use indexmap::IndexSet;
+    ///
+    /// let set1 = IndexSet::from([1, 2, 3, 4]);
+    /// let set2: IndexSet<_> = [1, 2, 3, 4].into();
+    /// assert_eq!(set1, set2);
+    /// ```
+    fn from(arr: [T; N]) -> Self {
+        Self::from_iter(arr)
+    }
+}
+
+impl<T, S> Extend<T> for IndexSet<T, S>
+where
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iterable: I) {
+        let iter = iterable.into_iter().map(|x| (x, ()));
+        self.map.extend(iter);
+    }
+}
+
+impl<'a, T, S> Extend<&'a T> for IndexSet<T, S>
+where
+    T: Hash + Eq + Copy + 'a,
+    S: BuildHasher,
+{
+    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iterable: I) {
+        let iter = iterable.into_iter().copied();
+        self.extend(iter);
+    }
+}
+
+impl<T, S> Default for IndexSet<T, S>
+where
+    S: Default,
+{
+    /// Return an empty [`IndexSet`]
+    fn default() -> Self {
+        IndexSet {
+            map: IndexMap::default(),
+        }
+    }
+}
+
+impl<T, S1, S2> PartialEq<IndexSet<T, S2>> for IndexSet<T, S1>
+where
+    T: Hash + Eq,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn eq(&self, other: &IndexSet<T, S2>) -> bool {
+        self.len() == other.len() && self.is_subset(other)
+    }
+}
+
+impl<T, S> Eq for IndexSet<T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+}
+
+impl<T, S> IndexSet<T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    /// Returns `true` if `self` has no elements in common with `other`.
+    pub fn is_disjoint<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher,
+    {
+        if self.len() <= other.len() {
+            self.iter().all(move |value| !other.contains(value))
+        } else {
+            other.iter().all(move |value| !self.contains(value))
+        }
+    }
+
+    /// Returns `true` if all elements of `self` are contained in `other`.
+    pub fn is_subset<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher,
+    {
+        self.len() <= other.len() && self.iter().all(move |value| other.contains(value))
+    }
+
+    /// Returns `true` if all elements of `other` are contained in `self`.
+    pub fn is_superset<S2>(&self, other: &IndexSet<T, S2>) -> bool
+    where
+        S2: BuildHasher,
+    {
+        other.is_subset(self)
+    }
+}
+
+impl<T, S1, S2> BitAnd<&IndexSet<T, S2>> for &IndexSet<T, S1>
+where
+    T: Eq + Hash + Clone,
+    S1: BuildHasher + Default,
+    S2: BuildHasher,
+{
+    type Output = IndexSet<T, S1>;
+
+    /// Returns the set intersection, cloned into a new set.
+    ///
+    /// Values are collected in the same order that they appear in `self`.
+    fn bitand(self, other: &IndexSet<T, S2>) -> Self::Output {
+        self.intersection(other).cloned().collect()
+    }
+}
+
+impl<T, S1, S2> BitOr<&IndexSet<T, S2>> for &IndexSet<T, S1>
+where
+    T: Eq + Hash + Clone,
+    S1: BuildHasher + Default,
+    S2: BuildHasher,
+{
+    type Output = IndexSet<T, S1>;
+
+    /// Returns the set union, cloned into a new set.
+    ///
+    /// Values from `self` are collected in their original order, followed by
+    /// values that are unique to `other` in their original order.
+    fn bitor(self, other: &IndexSet<T, S2>) -> Self::Output {
+        self.union(other).cloned().collect()
+    }
+}
+
+impl<T, S1, S2> BitXor<&IndexSet<T, S2>> for &IndexSet<T, S1>
+where
+    T: Eq + Hash + Clone,
+    S1: BuildHasher + Default,
+    S2: BuildHasher,
+{
+    type Output = IndexSet<T, S1>;
+
+    /// Returns the set symmetric-difference, cloned into a new set.
+    ///
+    /// Values from `self` are collected in their original order, followed by
+    /// values from `other` in their original order.
+    fn bitxor(self, other: &IndexSet<T, S2>) -> Self::Output {
+        self.symmetric_difference(other).cloned().collect()
+    }
+}
+
+impl<T, S1, S2> Sub<&IndexSet<T, S2>> for &IndexSet<T, S1>
+where
+    T: Eq + Hash + Clone,
+    S1: BuildHasher + Default,
+    S2: BuildHasher,
+{
+    type Output = IndexSet<T, S1>;
+
+    /// Returns the set difference, cloned into a new set.
+    ///
+    /// Values are collected in the same order that they appear in `self`.
+    fn sub(self, other: &IndexSet<T, S2>) -> Self::Output {
+        self.difference(other).cloned().collect()
+    }
+}
diff --git a/vendor/indexmap/src/set/iter.rs b/vendor/indexmap/src/set/iter.rs
new file mode 100644
index 00000000..34433164
--- /dev/null
+++ b/vendor/indexmap/src/set/iter.rs
@@ -0,0 +1,628 @@
+use super::{Bucket, Entries, IndexSet, Slice};
+
+use alloc::vec::{self, Vec};
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::iter::{Chain, FusedIterator};
+use core::ops::RangeBounds;
+use core::slice::Iter as SliceIter;
+
+impl<'a, T, S> IntoIterator for &'a IndexSet<T, S> {
+    type Item = &'a T;
+    type IntoIter = Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<T, S> IntoIterator for IndexSet<T, S> {
+    type Item = T;
+    type IntoIter = IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.into_entries())
+    }
+}
+
+/// An iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::iter`] method.
+/// See its documentation for more.
+pub struct Iter<'a, T> {
+    iter: SliceIter<'a, Bucket<T>>,
+}
+
+impl<'a, T> Iter<'a, T> {
+    pub(super) fn new(entries: &'a [Bucket<T>]) -> Self {
+        Self {
+            iter: entries.iter(),
+        }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &'a Slice<T> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
+    iterator_methods!(Bucket::key_ref);
+}
+
+impl<T> DoubleEndedIterator for Iter<'_, T> {
+    double_ended_iterator_methods!(Bucket::key_ref);
+}
+
+impl<T> ExactSizeIterator for Iter<'_, T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<T> FusedIterator for Iter<'_, T> {}
+
+impl<T> Clone for Iter<'_, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            iter: self.iter.clone(),
+        }
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl<T> Default for Iter<'_, T> {
+    fn default() -> Self {
+        Self { iter: [].iter() }
+    }
+}
+
+/// An owning iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::into_iter`] method
+/// (provided by the [`IntoIterator`] trait). See its documentation for more.
+#[derive(Clone)]
+pub struct IntoIter<T> {
+    iter: vec::IntoIter<Bucket<T>>,
+}
+
+impl<T> IntoIter<T> {
+    pub(super) fn new(entries: Vec<Bucket<T>>) -> Self {
+        Self {
+            iter: entries.into_iter(),
+        }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &Slice<T> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+}
+
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
+    iterator_methods!(Bucket::key);
+}
+
+impl<T> DoubleEndedIterator for IntoIter<T> {
+    double_ended_iterator_methods!(Bucket::key);
+}
+
+impl<T> ExactSizeIterator for IntoIter<T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<T> FusedIterator for IntoIter<T> {}
+
+impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+impl<T> Default for IntoIter<T> {
+    fn default() -> Self {
+        Self {
+            iter: Vec::new().into_iter(),
+        }
+    }
+}
+
+/// A draining iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::drain`] method.
+/// See its documentation for more.
+pub struct Drain<'a, T> {
+    iter: vec::Drain<'a, Bucket<T>>,
+}
+
+impl<'a, T> Drain<'a, T> {
+    pub(super) fn new(iter: vec::Drain<'a, Bucket<T>>) -> Self {
+        Self { iter }
+    }
+
+    /// Returns a slice of the remaining entries in the iterator.
+    pub fn as_slice(&self) -> &Slice<T> {
+        Slice::from_slice(self.iter.as_slice())
+    }
+}
+
+impl<T> Iterator for Drain<'_, T> {
+    type Item = T;
+
+    iterator_methods!(Bucket::key);
+}
+
+impl<T> DoubleEndedIterator for Drain<'_, T> {
+    double_ended_iterator_methods!(Bucket::key);
+}
+
+impl<T> ExactSizeIterator for Drain<'_, T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<T> FusedIterator for Drain<'_, T> {}
+
+impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
+        f.debug_list().entries(iter).finish()
+    }
+}
+
+/// A lazy iterator producing elements in the difference of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::difference`] method.
+/// See its documentation for more.
+pub struct Difference<'a, T, S> {
+    iter: Iter<'a, T>,
+    other: &'a IndexSet<T, S>,
+}
+
+impl<'a, T, S> Difference<'a, T, S> {
+    pub(super) fn new<S1>(set: &'a IndexSet<T, S1>, other: &'a IndexSet<T, S>) -> Self {
+        Self {
+            iter: set.iter(),
+            other,
+        }
+    }
+}
+
+impl<'a, T, S> Iterator for Difference<'a, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(item) = self.iter.next() {
+            if !self.other.contains(item) {
+                return Some(item);
+            }
+        }
+        None
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, self.iter.size_hint().1)
+    }
+}
+
+impl<T, S> DoubleEndedIterator for Difference<'_, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        while let Some(item) = self.iter.next_back() {
+            if !self.other.contains(item) {
+                return Some(item);
+            }
+        }
+        None
+    }
+}
+
+impl<T, S> FusedIterator for Difference<'_, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+}
+
+impl<T, S> Clone for Difference<'_, T, S> {
+    fn clone(&self) -> Self {
+        Difference {
+            iter: self.iter.clone(),
+            ..*self
+        }
+    }
+}
+
+impl<T, S> fmt::Debug for Difference<'_, T, S>
+where
+    T: fmt::Debug + Eq + Hash,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+/// A lazy iterator producing elements in the intersection of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::intersection`] method.
+/// See its documentation for more.
+pub struct Intersection<'a, T, S> {
+    iter: Iter<'a, T>,
+    other: &'a IndexSet<T, S>,
+}
+
+impl<'a, T, S> Intersection<'a, T, S> {
+    pub(super) fn new<S1>(set: &'a IndexSet<T, S1>, other: &'a IndexSet<T, S>) -> Self {
+        Self {
+            iter: set.iter(),
+            other,
+        }
+    }
+}
+
+impl<'a, T, S> Iterator for Intersection<'a, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(item) = self.iter.next() {
+            if self.other.contains(item) {
+                return Some(item);
+            }
+        }
+        None
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, self.iter.size_hint().1)
+    }
+}
+
+impl<T, S> DoubleEndedIterator for Intersection<'_, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        while let Some(item) = self.iter.next_back() {
+            if self.other.contains(item) {
+                return Some(item);
+            }
+        }
+        None
+    }
+}
+
+impl<T, S> FusedIterator for Intersection<'_, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+}
+
+impl<T, S> Clone for Intersection<'_, T, S> {
+    fn clone(&self) -> Self {
+        Intersection {
+            iter: self.iter.clone(),
+            ..*self
+        }
+    }
+}
+
+impl<T, S> fmt::Debug for Intersection<'_, T, S>
+where
+    T: fmt::Debug + Eq + Hash,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+/// A lazy iterator producing elements in the symmetric difference of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::symmetric_difference`] method.
+/// See its documentation for more.
+pub struct SymmetricDifference<'a, T, S1, S2> {
+    iter: Chain<Difference<'a, T, S2>, Difference<'a, T, S1>>,
+}
+
+impl<'a, T, S1, S2> SymmetricDifference<'a, T, S1, S2>
+where
+    T: Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    pub(super) fn new(set1: &'a IndexSet<T, S1>, set2: &'a IndexSet<T, S2>) -> Self {
+        let diff1 = set1.difference(set2);
+        let diff2 = set2.difference(set1);
+        Self {
+            iter: diff1.chain(diff2),
+        }
+    }
+}
+
+impl<'a, T, S1, S2> Iterator for SymmetricDifference<'a, T, S1, S2>
+where
+    T: Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.fold(init, f)
+    }
+}
+
+impl<T, S1, S2> DoubleEndedIterator for SymmetricDifference<'_, T, S1, S2>
+where
+    T: Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.iter.next_back()
+    }
+
+    fn rfold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.rfold(init, f)
+    }
+}
+
+impl<T, S1, S2> FusedIterator for SymmetricDifference<'_, T, S1, S2>
+where
+    T: Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+}
+
+impl<T, S1, S2> Clone for SymmetricDifference<'_, T, S1, S2> {
+    fn clone(&self) -> Self {
+        SymmetricDifference {
+            iter: self.iter.clone(),
+        }
+    }
+}
+
+impl<T, S1, S2> fmt::Debug for SymmetricDifference<'_, T, S1, S2>
+where
+    T: fmt::Debug + Eq + Hash,
+    S1: BuildHasher,
+    S2: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+/// A lazy iterator producing elements in the union of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::union`] method.
+/// See its documentation for more.
+pub struct Union<'a, T, S> {
+    iter: Chain<Iter<'a, T>, Difference<'a, T, S>>,
+}
+
+impl<'a, T, S> Union<'a, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    pub(super) fn new<S2>(set1: &'a IndexSet<T, S>, set2: &'a IndexSet<T, S2>) -> Self
+    where
+        S2: BuildHasher,
+    {
+        Self {
+            iter: set1.iter().chain(set2.difference(set1)),
+        }
+    }
+}
+
+impl<'a, T, S> Iterator for Union<'a, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.fold(init, f)
+    }
+}
+
+impl<T, S> DoubleEndedIterator for Union<'_, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.iter.next_back()
+    }
+
+    fn rfold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.rfold(init, f)
+    }
+}
+
+impl<T, S> FusedIterator for Union<'_, T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+}
+
+impl<T, S> Clone for Union<'_, T, S> {
+    fn clone(&self) -> Self {
+        Union {
+            iter: self.iter.clone(),
+        }
+    }
+}
+
+impl<T, S> fmt::Debug for Union<'_, T, S>
+where
+    T: fmt::Debug + Eq + Hash,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+/// A splicing iterator for `IndexSet`.
+///
+/// This `struct` is created by [`IndexSet::splice()`].
+/// See its documentation for more.
+pub struct Splice<'a, I, T, S>
+where
+    I: Iterator<Item = T>,
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    iter: crate::map::Splice<'a, UnitValue<I>, T, (), S>,
+}
+
+impl<'a, I, T, S> Splice<'a, I, T, S>
+where
+    I: Iterator<Item = T>,
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    #[track_caller]
+    pub(super) fn new<R>(set: &'a mut IndexSet<T, S>, range: R, replace_with: I) -> Self
+    where
+        R: RangeBounds<usize>,
+    {
+        Self {
+            iter: set.map.splice(range, UnitValue(replace_with)),
+        }
+    }
+}
+
+impl<I, T, S> Iterator for Splice<'_, I, T, S>
+where
+    I: Iterator<Item = T>,
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(self.iter.next()?.0)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<I, T, S> DoubleEndedIterator for Splice<'_, I, T, S>
+where
+    I: Iterator<Item = T>,
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        Some(self.iter.next_back()?.0)
+    }
+}
+
+impl<I, T, S> ExactSizeIterator for Splice<'_, I, T, S>
+where
+    I: Iterator<Item = T>,
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<I, T, S> FusedIterator for Splice<'_, I, T, S>
+where
+    I: Iterator<Item = T>,
+    T: Hash + Eq,
+    S: BuildHasher,
+{
+}
+
+struct UnitValue<I>(I);
+
+impl<I: Iterator> Iterator for UnitValue<I> {
+    type Item = (I::Item, ());
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next().map(|x| (x, ()))
+    }
+}
+
+impl<I, T, S> fmt::Debug for Splice<'_, I, T, S>
+where
+    I: fmt::Debug + Iterator<Item = T>,
+    T: fmt::Debug + Hash + Eq,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.iter, f)
+    }
+}
+
+impl<I: fmt::Debug> fmt::Debug for UnitValue<I> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
diff --git a/vendor/indexmap/src/set/mutable.rs b/vendor/indexmap/src/set/mutable.rs
new file mode 100644
index 00000000..21615f34
--- /dev/null
+++ b/vendor/indexmap/src/set/mutable.rs
@@ -0,0 +1,86 @@
+use core::hash::{BuildHasher, Hash};
+
+use super::{Equivalent, IndexSet};
+use crate::map::MutableKeys;
+
+/// Opt-in mutable access to [`IndexSet`] values.
+///
+/// These methods expose `&mut T`, mutable references to the value as it is stored
+/// in the set.
+/// You are allowed to modify the values in the set **if the modification
+/// does not change the value’s hash and equality**.
+///
+/// If values are modified erroneously, you can no longer look them up.
+/// This is sound (memory safe) but a logical error hazard (just like
+/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
+///
+/// `use` this trait to enable its methods for `IndexSet`.
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait MutableValues: private::Sealed {
+    type Value;
+
+    /// Return item index and mutable reference to the value
+    ///
+    /// Computes in **O(1)** time (average).
+    fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut Self::Value)>
+    where
+        Q: ?Sized + Hash + Equivalent<Self::Value>;
+
+    /// Return mutable reference to the value at an index.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    ///
+    /// Computes in **O(1)** time.
+    fn get_index_mut2(&mut self, index: usize) -> Option<&mut Self::Value>;
+
+    /// Scan through each value in the set and keep those where the
+    /// closure `keep` returns `true`.
+    ///
+    /// The values are visited in order, and remaining values keep their order.
+    ///
+    /// Computes in **O(n)** time (average).
+    fn retain2<F>(&mut self, keep: F)
+    where
+        F: FnMut(&mut Self::Value) -> bool;
+}
+
+/// Opt-in mutable access to [`IndexSet`] values.
+///
+/// See [`MutableValues`] for more information.
+impl<T, S> MutableValues for IndexSet<T, S>
+where
+    S: BuildHasher,
+{
+    type Value = T;
+
+    fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut T)>
+    where
+        Q: ?Sized + Hash + Equivalent<T>,
+    {
+        match self.map.get_full_mut2(value) {
+            Some((index, value, ())) => Some((index, value)),
+            None => None,
+        }
+    }
+
+    fn get_index_mut2(&mut self, index: usize) -> Option<&mut T> {
+        match self.map.get_index_mut2(index) {
+            Some((value, ())) => Some(value),
+            None => None,
+        }
+    }
+
+    fn retain2<F>(&mut self, mut keep: F)
+    where
+        F: FnMut(&mut T) -> bool,
+    {
+        self.map.retain2(move |value, ()| keep(value));
+    }
+}
+
+mod private {
+    pub trait Sealed {}
+
+    impl<T, S> Sealed for super::IndexSet<T, S> {}
+}
diff --git a/vendor/indexmap/src/set/slice.rs b/vendor/indexmap/src/set/slice.rs
new file mode 100644
index 00000000..faa9041a
--- /dev/null
+++ b/vendor/indexmap/src/set/slice.rs
@@ -0,0 +1,379 @@
+use super::{Bucket, Entries, IndexSet, IntoIter, Iter};
+use crate::util::{slice_eq, try_simplify_range};
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::{self, Bound, Index, RangeBounds};
+
+/// A dynamically-sized slice of values in an [`IndexSet`].
+///
+/// This supports indexed operations much like a `[T]` slice,
+/// but not any hashed operations on the values.
+///
+/// Unlike `IndexSet`, `Slice` does consider the order for [`PartialEq`]
+/// and [`Eq`], and it also implements [`PartialOrd`], [`Ord`], and [`Hash`].
+#[repr(transparent)]
+pub struct Slice<T> {
+    pub(crate) entries: [Bucket<T>],
+}
+
+// SAFETY: `Slice<T>` is a transparent wrapper around `[Bucket<T>]`,
+// and reference lifetimes are bound together in function signatures.
+#[allow(unsafe_code)]
+impl<T> Slice<T> {
+    pub(super) const fn from_slice(entries: &[Bucket<T>]) -> &Self {
+        unsafe { &*(entries as *const [Bucket<T>] as *const Self) }
+    }
+
+    pub(super) fn from_boxed(entries: Box<[Bucket<T>]>) -> Box<Self> {
+        unsafe { Box::from_raw(Box::into_raw(entries) as *mut Self) }
+    }
+
+    fn into_boxed(self: Box<Self>) -> Box<[Bucket<T>]> {
+        unsafe { Box::from_raw(Box::into_raw(self) as *mut [Bucket<T>]) }
+    }
+}
+
+impl<T> Slice<T> {
+    pub(crate) fn into_entries(self: Box<Self>) -> Vec<Bucket<T>> {
+        self.into_boxed().into_vec()
+    }
+
+    /// Returns an empty slice.
+    pub const fn new<'a>() -> &'a Self {
+        Self::from_slice(&[])
+    }
+
+    /// Return the number of elements in the set slice.
+    pub const fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    /// Returns true if the set slice contains no elements.
+    pub const fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Get a value by index.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    pub fn get_index(&self, index: usize) -> Option<&T> {
+        self.entries.get(index).map(Bucket::key_ref)
+    }
+
+    /// Returns a slice of values in the given range of indices.
+    ///
+    /// Valid indices are `0 <= index < self.len()`.
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Self> {
+        let range = try_simplify_range(range, self.entries.len())?;
+        self.entries.get(range).map(Self::from_slice)
+    }
+
+    /// Get the first value.
+    pub fn first(&self) -> Option<&T> {
+        self.entries.first().map(Bucket::key_ref)
+    }
+
+    /// Get the last value.
+    pub fn last(&self) -> Option<&T> {
+        self.entries.last().map(Bucket::key_ref)
+    }
+
+    /// Divides one slice into two at an index.
+    ///
+    /// ***Panics*** if `index > len`.
+    pub fn split_at(&self, index: usize) -> (&Self, &Self) {
+        let (first, second) = self.entries.split_at(index);
+        (Self::from_slice(first), Self::from_slice(second))
+    }
+
+    /// Returns the first value and the rest of the slice,
+    /// or `None` if it is empty.
+    pub fn split_first(&self) -> Option<(&T, &Self)> {
+        if let [first, rest @ ..] = &self.entries {
+            Some((&first.key, Self::from_slice(rest)))
+        } else {
+            None
+        }
+    }
+
+    /// Returns the last value and the rest of the slice,
+    /// or `None` if it is empty.
+    pub fn split_last(&self) -> Option<(&T, &Self)> {
+        if let [rest @ .., last] = &self.entries {
+            Some((&last.key, Self::from_slice(rest)))
+        } else {
+            None
+        }
+    }
+
+    /// Return an iterator over the values of the set slice.
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter::new(&self.entries)
+    }
+
+    /// Search over a sorted set for a value.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search`] for more details.
+    ///
+    /// Computes in **O(log(n))** time, which is notably less scalable than looking the value up in
+    /// the set this is a slice from using [`IndexSet::get_index_of`], but this can also position
+    /// missing values.
+    pub fn binary_search(&self, x: &T) -> Result<usize, usize>
+    where
+        T: Ord,
+    {
+        self.binary_search_by(|p| p.cmp(x))
+    }
+
+    /// Search over a sorted set with a comparator function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a T) -> Ordering,
+    {
+        self.entries.binary_search_by(move |a| f(&a.key))
+    }
+
+    /// Search over a sorted set with an extraction function.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted
+    /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[inline]
+    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&'a T) -> B,
+        B: Ord,
+    {
+        self.binary_search_by(|k| f(k).cmp(b))
+    }
+
+    /// Returns the index of the partition point of a sorted set according to the given predicate
+    /// (the index of the first element of the second partition).
+    ///
+    /// See [`slice::partition_point`] for more details.
+    ///
+    /// Computes in **O(log(n))** time.
+    #[must_use]
+    pub fn partition_point<P>(&self, mut pred: P) -> usize
+    where
+        P: FnMut(&T) -> bool,
+    {
+        self.entries.partition_point(move |a| pred(&a.key))
+    }
+}
+
+impl<'a, T> IntoIterator for &'a Slice<T> {
+    type IntoIter = Iter<'a, T>;
+    type Item = &'a T;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<T> IntoIterator for Box<Slice<T>> {
+    type IntoIter = IntoIter<T>;
+    type Item = T;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.into_entries())
+    }
+}
+
+impl<T> Default for &'_ Slice<T> {
+    fn default() -> Self {
+        Slice::from_slice(&[])
+    }
+}
+
+impl<T> Default for Box<Slice<T>> {
+    fn default() -> Self {
+        Slice::from_boxed(Box::default())
+    }
+}
+
+impl<T: Clone> Clone for Box<Slice<T>> {
+    fn clone(&self) -> Self {
+        Slice::from_boxed(self.entries.to_vec().into_boxed_slice())
+    }
+}
+
+impl<T: Copy> From<&Slice<T>> for Box<Slice<T>> {
+    fn from(slice: &Slice<T>) -> Self {
+        Slice::from_boxed(Box::from(&slice.entries))
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Slice<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self).finish()
+    }
+}
+
+impl<T, U> PartialEq<Slice<U>> for Slice<T>
+where
+    T: PartialEq<U>,
+{
+    fn eq(&self, other: &Slice<U>) -> bool {
+        slice_eq(&self.entries, &other.entries, |b1, b2| b1.key == b2.key)
+    }
+}
+
+impl<T, U> PartialEq<[U]> for Slice<T>
+where
+    T: PartialEq<U>,
+{
+    fn eq(&self, other: &[U]) -> bool {
+        slice_eq(&self.entries, other, |b, o| b.key == *o)
+    }
+}
+
+impl<T, U> PartialEq<Slice<U>> for [T]
+where
+    T: PartialEq<U>,
+{
+    fn eq(&self, other: &Slice<U>) -> bool {
+        slice_eq(self, &other.entries, |o, b| *o == b.key)
+    }
+}
+
+impl<T, U, const N: usize> PartialEq<[U; N]> for Slice<T>
+where
+    T: PartialEq<U>,
+{
+    fn eq(&self, other: &[U; N]) -> bool {
+        <Self as PartialEq<[U]>>::eq(self, other)
+    }
+}
+
+impl<T, const N: usize, U> PartialEq<Slice<U>> for [T; N]
+where
+    T: PartialEq<U>,
+{
+    fn eq(&self, other: &Slice<U>) -> bool {
+        <[T] as PartialEq<Slice<U>>>::eq(self, other)
+    }
+}
+
+impl<T: Eq> Eq for Slice<T> {}
+
+impl<T: PartialOrd> PartialOrd for Slice<T> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.iter().partial_cmp(other)
+    }
+}
+
+impl<T: Ord> Ord for Slice<T> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.iter().cmp(other)
+    }
+}
+
+impl<T: Hash> Hash for Slice<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.len().hash(state);
+        for value in self {
+            value.hash(state);
+        }
+    }
+}
+
+impl<T> Index<usize> for Slice<T> {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.entries[index].key
+    }
+}
+
+// We can't have `impl<I: RangeBounds<usize>> Index<I>` because that conflicts with `Index<usize>`.
+// Instead, we repeat the implementations for all the core range types.
+macro_rules! impl_index {
+    ($($range:ty),*) => {$(
+        impl<T, S> Index<$range> for IndexSet<T, S> {
+            type Output = Slice<T>;
+
+            fn index(&self, range: $range) -> &Self::Output {
+                Slice::from_slice(&self.as_entries()[range])
+            }
+        }
+
+        impl<T> Index<$range> for Slice<T> {
+            type Output = Self;
+
+            fn index(&self, range: $range) -> &Self::Output {
+                Slice::from_slice(&self.entries[range])
+            }
+        }
+    )*}
+}
+impl_index!(
+    ops::Range<usize>,
+    ops::RangeFrom<usize>,
+    ops::RangeFull,
+    ops::RangeInclusive<usize>,
+    ops::RangeTo<usize>,
+    ops::RangeToInclusive<usize>,
+    (Bound<usize>, Bound<usize>)
+);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn slice_index() {
+        fn check(vec_slice: &[i32], set_slice: &Slice<i32>, sub_slice: &Slice<i32>) {
+            assert_eq!(set_slice as *const _, sub_slice as *const _);
+            itertools::assert_equal(vec_slice, set_slice);
+        }
+
+        let vec: Vec<i32> = (0..10).map(|i| i * i).collect();
+        let set: IndexSet<i32> = vec.iter().cloned().collect();
+        let slice = set.as_slice();
+
+        // RangeFull
+        check(&vec[..], &set[..], &slice[..]);
+
+        for i in 0usize..10 {
+            // Index
+            assert_eq!(vec[i], set[i]);
+            assert_eq!(vec[i], slice[i]);
+
+            // RangeFrom
+            check(&vec[i..], &set[i..], &slice[i..]);
+
+            // RangeTo
+            check(&vec[..i], &set[..i], &slice[..i]);
+
+            // RangeToInclusive
+            check(&vec[..=i], &set[..=i], &slice[..=i]);
+
+            // (Bound<usize>, Bound<usize>)
+            let bounds = (Bound::Excluded(i), Bound::Unbounded);
+            check(&vec[i + 1..], &set[bounds], &slice[bounds]);
+
+            for j in i..=10 {
+                // Range
+                check(&vec[i..j], &set[i..j], &slice[i..j]);
+            }
+
+            for j in i..10 {
+                // RangeInclusive
+                check(&vec[i..=j], &set[i..=j], &slice[i..=j]);
+            }
+        }
+    }
+}
diff --git a/vendor/indexmap/src/set/tests.rs b/vendor/indexmap/src/set/tests.rs
new file mode 100644
index 00000000..35a076e8
--- /dev/null
+++ b/vendor/indexmap/src/set/tests.rs
@@ -0,0 +1,723 @@
+use super::*;
+use std::string::String;
+
+#[test]
+fn it_works() {
+    let mut set = IndexSet::new();
+    assert_eq!(set.is_empty(), true);
+    set.insert(1);
+    set.insert(1);
+    assert_eq!(set.len(), 1);
+    assert!(set.get(&1).is_some());
+    assert_eq!(set.is_empty(), false);
+}
+
+#[test]
+fn new() {
+    let set = IndexSet::<String>::new();
+    println!("{:?}", set);
+    assert_eq!(set.capacity(), 0);
+    assert_eq!(set.len(), 0);
+    assert_eq!(set.is_empty(), true);
+}
+
+#[test]
+fn insert() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5];
+    let not_present = [1, 3, 6, 9, 10];
+    let mut set = IndexSet::with_capacity(insert.len());
+
+    for (i, &elt) in insert.iter().enumerate() {
+        assert_eq!(set.len(), i);
+        set.insert(elt);
+        assert_eq!(set.len(), i + 1);
+        assert_eq!(set.get(&elt), Some(&elt));
+    }
+    println!("{:?}", set);
+
+    for &elt in &not_present {
+        assert!(set.get(&elt).is_none());
+    }
+}
+
+#[test]
+fn insert_full() {
+    let insert = vec![9, 2, 7, 1, 4, 6, 13];
+    let present = vec![1, 6, 2];
+    let mut set = IndexSet::with_capacity(insert.len());
+
+    for (i, &elt) in insert.iter().enumerate() {
+        assert_eq!(set.len(), i);
+        let (index, success) = set.insert_full(elt);
+        assert!(success);
+        assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+        assert_eq!(set.len(), i + 1);
+    }
+
+    let len = set.len();
+    for &elt in &present {
+        let (index, success) = set.insert_full(elt);
+        assert!(!success);
+        assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+        assert_eq!(set.len(), len);
+    }
+}
+
+#[test]
+fn insert_2() {
+    let mut set = IndexSet::with_capacity(16);
+
+    let mut values = vec![];
+    values.extend(0..16);
+    values.extend(if cfg!(miri) { 32..64 } else { 128..267 });
+
+    for &i in &values {
+        let old_set = set.clone();
+        set.insert(i);
+        for value in old_set.iter() {
+            if set.get(value).is_none() {
+                println!("old_set: {:?}", old_set);
+                println!("set: {:?}", set);
+                panic!("did not find {} in set", value);
+            }
+        }
+    }
+
+    for &i in &values {
+        assert!(set.get(&i).is_some(), "did not find {}", i);
+    }
+}
+
+#[test]
+fn insert_dup() {
+    let mut elements = vec![0, 2, 4, 6, 8];
+    let mut set: IndexSet<u8> = elements.drain(..).collect();
+    {
+        let (i, v) = set.get_full(&0).unwrap();
+        assert_eq!(set.len(), 5);
+        assert_eq!(i, 0);
+        assert_eq!(*v, 0);
+    }
+    {
+        let inserted = set.insert(0);
+        let (i, v) = set.get_full(&0).unwrap();
+        assert_eq!(set.len(), 5);
+        assert_eq!(inserted, false);
+        assert_eq!(i, 0);
+        assert_eq!(*v, 0);
+    }
+}
+
+#[test]
+fn insert_order() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut set = IndexSet::new();
+
+    for &elt in &insert {
+        set.insert(elt);
+    }
+
+    assert_eq!(set.iter().count(), set.len());
+    assert_eq!(set.iter().count(), insert.len());
+    for (a, b) in insert.iter().zip(set.iter()) {
+        assert_eq!(a, b);
+    }
+    for (i, v) in (0..insert.len()).zip(set.iter()) {
+        assert_eq!(set.get_index(i).unwrap(), v);
+    }
+}
+
+#[test]
+fn shift_insert() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut set = IndexSet::new();
+
+    for &elt in &insert {
+        set.shift_insert(0, elt);
+    }
+
+    assert_eq!(set.iter().count(), set.len());
+    assert_eq!(set.iter().count(), insert.len());
+    for (a, b) in insert.iter().rev().zip(set.iter()) {
+        assert_eq!(a, b);
+    }
+    for (i, v) in (0..insert.len()).zip(set.iter()) {
+        assert_eq!(set.get_index(i).unwrap(), v);
+    }
+
+    // "insert" that moves an existing entry
+    set.shift_insert(0, insert[0]);
+    assert_eq!(set.iter().count(), insert.len());
+    assert_eq!(insert[0], set[0]);
+    for (a, b) in insert[1..].iter().rev().zip(set.iter().skip(1)) {
+        assert_eq!(a, b);
+    }
+}
+
+#[test]
+fn replace() {
+    let replace = [0, 4, 2, 12, 8, 7, 11, 5];
+    let not_present = [1, 3, 6, 9, 10];
+    let mut set = IndexSet::with_capacity(replace.len());
+
+    for (i, &elt) in replace.iter().enumerate() {
+        assert_eq!(set.len(), i);
+        set.replace(elt);
+        assert_eq!(set.len(), i + 1);
+        assert_eq!(set.get(&elt), Some(&elt));
+    }
+    println!("{:?}", set);
+
+    for &elt in &not_present {
+        assert!(set.get(&elt).is_none());
+    }
+}
+
+#[test]
+fn replace_full() {
+    let replace = vec![9, 2, 7, 1, 4, 6, 13];
+    let present = vec![1, 6, 2];
+    let mut set = IndexSet::with_capacity(replace.len());
+
+    for (i, &elt) in replace.iter().enumerate() {
+        assert_eq!(set.len(), i);
+        let (index, replaced) = set.replace_full(elt);
+        assert!(replaced.is_none());
+        assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+        assert_eq!(set.len(), i + 1);
+    }
+
+    let len = set.len();
+    for &elt in &present {
+        let (index, replaced) = set.replace_full(elt);
+        assert_eq!(Some(elt), replaced);
+        assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+        assert_eq!(set.len(), len);
+    }
+}
+
+#[test]
+fn replace_2() {
+    let mut set = IndexSet::with_capacity(16);
+
+    let mut values = vec![];
+    values.extend(0..16);
+    values.extend(if cfg!(miri) { 32..64 } else { 128..267 });
+
+    for &i in &values {
+        let old_set = set.clone();
+        set.replace(i);
+        for value in old_set.iter() {
+            if set.get(value).is_none() {
+                println!("old_set: {:?}", old_set);
+                println!("set: {:?}", set);
+                panic!("did not find {} in set", value);
+            }
+        }
+    }
+
+    for &i in &values {
+        assert!(set.get(&i).is_some(), "did not find {}", i);
+    }
+}
+
+#[test]
+fn replace_dup() {
+    let mut elements = vec![0, 2, 4, 6, 8];
+    let mut set: IndexSet<u8> = elements.drain(..).collect();
+    {
+        let (i, v) = set.get_full(&0).unwrap();
+        assert_eq!(set.len(), 5);
+        assert_eq!(i, 0);
+        assert_eq!(*v, 0);
+    }
+    {
+        let replaced = set.replace(0);
+        let (i, v) = set.get_full(&0).unwrap();
+        assert_eq!(set.len(), 5);
+        assert_eq!(replaced, Some(0));
+        assert_eq!(i, 0);
+        assert_eq!(*v, 0);
+    }
+}
+
+#[test]
+fn replace_order() {
+    let replace = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut set = IndexSet::new();
+
+    for &elt in &replace {
+        set.replace(elt);
+    }
+
+    assert_eq!(set.iter().count(), set.len());
+    assert_eq!(set.iter().count(), replace.len());
+    for (a, b) in replace.iter().zip(set.iter()) {
+        assert_eq!(a, b);
+    }
+    for (i, v) in (0..replace.len()).zip(set.iter()) {
+        assert_eq!(set.get_index(i).unwrap(), v);
+    }
+}
+
+#[test]
+fn replace_change() {
+    // Check pointers to make sure it really changes
+    let mut set = indexset!(vec![42]);
+    let old_ptr = set[0].as_ptr();
+    let new = set[0].clone();
+    let new_ptr = new.as_ptr();
+    assert_ne!(old_ptr, new_ptr);
+    let replaced = set.replace(new).unwrap();
+    assert_eq!(replaced.as_ptr(), old_ptr);
+}
+
+#[test]
+fn grow() {
+    let insert = [0, 4, 2, 12, 8, 7, 11];
+    let not_present = [1, 3, 6, 9, 10];
+    let mut set = IndexSet::with_capacity(insert.len());
+
+    for (i, &elt) in insert.iter().enumerate() {
+        assert_eq!(set.len(), i);
+        set.insert(elt);
+        assert_eq!(set.len(), i + 1);
+        assert_eq!(set.get(&elt), Some(&elt));
+    }
+
+    println!("{:?}", set);
+    for &elt in &insert {
+        set.insert(elt * 10);
+    }
+    for &elt in &insert {
+        set.insert(elt * 100);
+    }
+    for (i, &elt) in insert.iter().cycle().enumerate().take(100) {
+        set.insert(elt * 100 + i as i32);
+    }
+    println!("{:?}", set);
+    for &elt in &not_present {
+        assert!(set.get(&elt).is_none());
+    }
+}
+
+#[test]
+fn reserve() {
+    let mut set = IndexSet::<usize>::new();
+    assert_eq!(set.capacity(), 0);
+    set.reserve(100);
+    let capacity = set.capacity();
+    assert!(capacity >= 100);
+    for i in 0..capacity {
+        assert_eq!(set.len(), i);
+        set.insert(i);
+        assert_eq!(set.len(), i + 1);
+        assert_eq!(set.capacity(), capacity);
+        assert_eq!(set.get(&i), Some(&i));
+    }
+    set.insert(capacity);
+    assert_eq!(set.len(), capacity + 1);
+    assert!(set.capacity() > capacity);
+    assert_eq!(set.get(&capacity), Some(&capacity));
+}
+
+#[test]
+fn try_reserve() {
+    let mut set = IndexSet::<usize>::new();
+    assert_eq!(set.capacity(), 0);
+    assert_eq!(set.try_reserve(100), Ok(()));
+    assert!(set.capacity() >= 100);
+    assert!(set.try_reserve(usize::MAX).is_err());
+}
+
+#[test]
+fn shrink_to_fit() {
+    let mut set = IndexSet::<usize>::new();
+    assert_eq!(set.capacity(), 0);
+    for i in 0..100 {
+        assert_eq!(set.len(), i);
+        set.insert(i);
+        assert_eq!(set.len(), i + 1);
+        assert!(set.capacity() >= i + 1);
+        assert_eq!(set.get(&i), Some(&i));
+        set.shrink_to_fit();
+        assert_eq!(set.len(), i + 1);
+        assert_eq!(set.capacity(), i + 1);
+        assert_eq!(set.get(&i), Some(&i));
+    }
+}
+
+#[test]
+fn remove() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut set = IndexSet::new();
+
+    for &elt in &insert {
+        set.insert(elt);
+    }
+
+    assert_eq!(set.iter().count(), set.len());
+    assert_eq!(set.iter().count(), insert.len());
+    for (a, b) in insert.iter().zip(set.iter()) {
+        assert_eq!(a, b);
+    }
+
+    let remove_fail = [99, 77];
+    let remove = [4, 12, 8, 7];
+
+    for &value in &remove_fail {
+        assert!(set.swap_remove_full(&value).is_none());
+    }
+    println!("{:?}", set);
+    for &value in &remove {
+        //println!("{:?}", set);
+        let index = set.get_full(&value).unwrap().0;
+        assert_eq!(set.swap_remove_full(&value), Some((index, value)));
+    }
+    println!("{:?}", set);
+
+    for value in &insert {
+        assert_eq!(set.get(value).is_some(), !remove.contains(value));
+    }
+    assert_eq!(set.len(), insert.len() - remove.len());
+    assert_eq!(set.iter().count(), insert.len() - remove.len());
+}
+
+#[test]
+fn swap_remove_index() {
+    let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+    let mut set = IndexSet::new();
+
+    for &elt in &insert {
+        set.insert(elt);
+    }
+
+    let mut vector = insert.to_vec();
+    let remove_sequence = &[3, 3, 10, 4, 5, 4, 3, 0, 1];
+
+    // check that the same swap remove sequence on vec and set
+    // have the same result.
+    for &rm in remove_sequence {
+        let out_vec = vector.swap_remove(rm);
+        let out_set = set.swap_remove_index(rm).unwrap();
+        assert_eq!(out_vec, out_set);
+    }
+    assert_eq!(vector.len(), set.len());
+    for (a, b) in vector.iter().zip(set.iter()) {
+        assert_eq!(a, b);
+    }
+}
+
+#[test]
+fn partial_eq_and_eq() {
+    let mut set_a = IndexSet::new();
+    set_a.insert(1);
+    set_a.insert(2);
+    let mut set_b = set_a.clone();
+    assert_eq!(set_a, set_b);
+    set_b.swap_remove(&1);
+    assert_ne!(set_a, set_b);
+
+    let set_c: IndexSet<_> = set_b.into_iter().collect();
+    assert_ne!(set_a, set_c);
+    assert_ne!(set_c, set_a);
+}
+
+#[test]
+fn extend() {
+    let mut set = IndexSet::new();
+    set.extend(vec![&1, &2, &3, &4]);
+    set.extend(vec![5, 6]);
+    assert_eq!(set.into_iter().collect::<Vec<_>>(), vec![1, 2, 3, 4, 5, 6]);
+}
+
+#[test]
+fn comparisons() {
+    let set_a: IndexSet<_> = (0..3).collect();
+    let set_b: IndexSet<_> = (3..6).collect();
+    let set_c: IndexSet<_> = (0..6).collect();
+    let set_d: IndexSet<_> = (3..9).collect();
+
+    assert!(!set_a.is_disjoint(&set_a));
+    assert!(set_a.is_subset(&set_a));
+    assert!(set_a.is_superset(&set_a));
+
+    assert!(set_a.is_disjoint(&set_b));
+    assert!(set_b.is_disjoint(&set_a));
+    assert!(!set_a.is_subset(&set_b));
+    assert!(!set_b.is_subset(&set_a));
+    assert!(!set_a.is_superset(&set_b));
+    assert!(!set_b.is_superset(&set_a));
+
+    assert!(!set_a.is_disjoint(&set_c));
+    assert!(!set_c.is_disjoint(&set_a));
+    assert!(set_a.is_subset(&set_c));
+    assert!(!set_c.is_subset(&set_a));
+    assert!(!set_a.is_superset(&set_c));
+    assert!(set_c.is_superset(&set_a));
+
+    assert!(!set_c.is_disjoint(&set_d));
+    assert!(!set_d.is_disjoint(&set_c));
+    assert!(!set_c.is_subset(&set_d));
+    assert!(!set_d.is_subset(&set_c));
+    assert!(!set_c.is_superset(&set_d));
+    assert!(!set_d.is_superset(&set_c));
+}
+
+#[test]
+fn iter_comparisons() {
+    use std::iter::empty;
+
+    fn check<'a, I1, I2>(iter1: I1, iter2: I2)
+    where
+        I1: Iterator<Item = &'a i32>,
+        I2: Iterator<Item = i32>,
+    {
+        assert!(iter1.copied().eq(iter2));
+    }
+
+    let set_a: IndexSet<_> = (0..3).collect();
+    let set_b: IndexSet<_> = (3..6).collect();
+    let set_c: IndexSet<_> = (0..6).collect();
+    let set_d: IndexSet<_> = (3..9).rev().collect();
+
+    check(set_a.difference(&set_a), empty());
+    check(set_a.symmetric_difference(&set_a), empty());
+    check(set_a.intersection(&set_a), 0..3);
+    check(set_a.union(&set_a), 0..3);
+
+    check(set_a.difference(&set_b), 0..3);
+    check(set_b.difference(&set_a), 3..6);
+    check(set_a.symmetric_difference(&set_b), 0..6);
+    check(set_b.symmetric_difference(&set_a), (3..6).chain(0..3));
+    check(set_a.intersection(&set_b), empty());
+    check(set_b.intersection(&set_a), empty());
+    check(set_a.union(&set_b), 0..6);
+    check(set_b.union(&set_a), (3..6).chain(0..3));
+
+    check(set_a.difference(&set_c), empty());
+    check(set_c.difference(&set_a), 3..6);
+    check(set_a.symmetric_difference(&set_c), 3..6);
+    check(set_c.symmetric_difference(&set_a), 3..6);
+    check(set_a.intersection(&set_c), 0..3);
+    check(set_c.intersection(&set_a), 0..3);
+    check(set_a.union(&set_c), 0..6);
+    check(set_c.union(&set_a), 0..6);
+
+    check(set_c.difference(&set_d), 0..3);
+    check(set_d.difference(&set_c), (6..9).rev());
+    check(
+        set_c.symmetric_difference(&set_d),
+        (0..3).chain((6..9).rev()),
+    );
+    check(set_d.symmetric_difference(&set_c), (6..9).rev().chain(0..3));
+    check(set_c.intersection(&set_d), 3..6);
+    check(set_d.intersection(&set_c), (3..6).rev());
+    check(set_c.union(&set_d), (0..6).chain((6..9).rev()));
+    check(set_d.union(&set_c), (3..9).rev().chain(0..3));
+}
+
+#[test]
+fn ops() {
+    let empty = IndexSet::<i32>::new();
+    let set_a: IndexSet<_> = (0..3).collect();
+    let set_b: IndexSet<_> = (3..6).collect();
+    let set_c: IndexSet<_> = (0..6).collect();
+    let set_d: IndexSet<_> = (3..9).rev().collect();
+
+    #[allow(clippy::eq_op)]
+    {
+        assert_eq!(&set_a & &set_a, set_a);
+        assert_eq!(&set_a | &set_a, set_a);
+        assert_eq!(&set_a ^ &set_a, empty);
+        assert_eq!(&set_a - &set_a, empty);
+    }
+
+    assert_eq!(&set_a & &set_b, empty);
+    assert_eq!(&set_b & &set_a, empty);
+    assert_eq!(&set_a | &set_b, set_c);
+    assert_eq!(&set_b | &set_a, set_c);
+    assert_eq!(&set_a ^ &set_b, set_c);
+    assert_eq!(&set_b ^ &set_a, set_c);
+    assert_eq!(&set_a - &set_b, set_a);
+    assert_eq!(&set_b - &set_a, set_b);
+
+    assert_eq!(&set_a & &set_c, set_a);
+    assert_eq!(&set_c & &set_a, set_a);
+    assert_eq!(&set_a | &set_c, set_c);
+    assert_eq!(&set_c | &set_a, set_c);
+    assert_eq!(&set_a ^ &set_c, set_b);
+    assert_eq!(&set_c ^ &set_a, set_b);
+    assert_eq!(&set_a - &set_c, empty);
+    assert_eq!(&set_c - &set_a, set_b);
+
+    assert_eq!(&set_c & &set_d, set_b);
+    assert_eq!(&set_d & &set_c, set_b);
+    assert_eq!(&set_c | &set_d, &set_a | &set_d);
+    assert_eq!(&set_d | &set_c, &set_a | &set_d);
+    assert_eq!(&set_c ^ &set_d, &set_a | &(&set_d - &set_b));
+    assert_eq!(&set_d ^ &set_c, &set_a | &(&set_d - &set_b));
+    assert_eq!(&set_c - &set_d, set_a);
+    assert_eq!(&set_d - &set_c, &set_d - &set_b);
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn from_array() {
+    let set1 = IndexSet::from([1, 2, 3, 4]);
+    let set2: IndexSet<_> = [1, 2, 3, 4].into();
+
+    assert_eq!(set1, set2);
+}
+
+#[test]
+fn iter_default() {
+    struct Item;
+    fn assert_default<T>()
+    where
+        T: Default + Iterator,
+    {
+        assert!(T::default().next().is_none());
+    }
+    assert_default::<Iter<'static, Item>>();
+    assert_default::<IntoIter<Item>>();
+}
+
+#[test]
+fn test_binary_search_by() {
+    // adapted from std's test for binary_search
+    let b: IndexSet<i32> = [].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(0));
+
+    let b: IndexSet<i32> = [4].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&3)), Err(0));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&4)), Ok(0));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(1));
+
+    let b: IndexSet<i32> = [1, 2, 4, 6, 8, 9].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(3));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&6)), Ok(3));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&7)), Err(4));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&8)), Ok(4));
+
+    let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&9)), Err(6));
+
+    let b: IndexSet<i32> = [1, 2, 4, 6, 7, 8, 9].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&6)), Ok(3));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(3));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&8)), Ok(5));
+
+    let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8, 9].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&7)), Err(5));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&0)), Err(0));
+
+    let b: IndexSet<i32> = [1, 3, 3, 3, 7].into();
+    assert_eq!(b.binary_search_by(|x| x.cmp(&0)), Err(0));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&1)), Ok(0));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&2)), Err(1));
+    // diff from std as set merges the duplicate keys
+    assert!(match b.binary_search_by(|x| x.cmp(&3)) {
+        Ok(1..=2) => true,
+        _ => false,
+    });
+    assert!(match b.binary_search_by(|x| x.cmp(&3)) {
+        Ok(1..=2) => true,
+        _ => false,
+    });
+    assert_eq!(b.binary_search_by(|x| x.cmp(&4)), Err(2));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(2));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&6)), Err(2));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&7)), Ok(2));
+    assert_eq!(b.binary_search_by(|x| x.cmp(&8)), Err(3));
+}
+
+#[test]
+fn test_binary_search_by_key() {
+    // adapted from std's test for binary_search
+    let b: IndexSet<i32> = [].into();
+    assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(0));
+
+    let b: IndexSet<i32> = [4].into();
+    assert_eq!(b.binary_search_by_key(&3, |&x| x), Err(0));
+    assert_eq!(b.binary_search_by_key(&4, |&x| x), Ok(0));
+    assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(1));
+
+    let b: IndexSet<i32> = [1, 2, 4, 6, 8, 9].into();
+    assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(3));
+    assert_eq!(b.binary_search_by_key(&6, |&x| x), Ok(3));
+    assert_eq!(b.binary_search_by_key(&7, |&x| x), Err(4));
+    assert_eq!(b.binary_search_by_key(&8, |&x| x), Ok(4));
+
+    let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8].into();
+    assert_eq!(b.binary_search_by_key(&9, |&x| x), Err(6));
+
+    let b: IndexSet<i32> = [1, 2, 4, 6, 7, 8, 9].into();
+    assert_eq!(b.binary_search_by_key(&6, |&x| x), Ok(3));
+    assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(3));
+    assert_eq!(b.binary_search_by_key(&8, |&x| x), Ok(5));
+
+    let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8, 9].into();
+    assert_eq!(b.binary_search_by_key(&7, |&x| x), Err(5));
+    assert_eq!(b.binary_search_by_key(&0, |&x| x), Err(0));
+
+    let b: IndexSet<i32> = [1, 3, 3, 3, 7].into();
+    assert_eq!(b.binary_search_by_key(&0, |&x| x), Err(0));
+    assert_eq!(b.binary_search_by_key(&1, |&x| x), Ok(0));
+    assert_eq!(b.binary_search_by_key(&2, |&x| x), Err(1));
+    // diff from std as set merges the duplicate keys
+    assert!(match b.binary_search_by_key(&3, |&x| x) {
+        Ok(1..=2) => true,
+        _ => false,
+    });
+    assert!(match b.binary_search_by_key(&3, |&x| x) {
+        Ok(1..=2) => true,
+        _ => false,
+    });
+    assert_eq!(b.binary_search_by_key(&4, |&x| x), Err(2));
+    assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(2));
+    assert_eq!(b.binary_search_by_key(&6, |&x| x), Err(2));
+    assert_eq!(b.binary_search_by_key(&7, |&x| x), Ok(2));
+    assert_eq!(b.binary_search_by_key(&8, |&x| x), Err(3));
+}
+
+#[test]
+fn test_partition_point() {
+    // adapted from std's test for partition_point
+    let b: IndexSet<i32> = [].into();
+    assert_eq!(b.partition_point(|&x| x < 5), 0);
+
+    let b: IndexSet<_> = [4].into();
+    assert_eq!(b.partition_point(|&x| x < 3), 0);
+    assert_eq!(b.partition_point(|&x| x < 4), 0);
+    assert_eq!(b.partition_point(|&x| x < 5), 1);
+
+    let b: IndexSet<_> = [1, 2, 4, 6, 8, 9].into();
+    assert_eq!(b.partition_point(|&x| x < 5), 3);
+    assert_eq!(b.partition_point(|&x| x < 6), 3);
+    assert_eq!(b.partition_point(|&x| x < 7), 4);
+    assert_eq!(b.partition_point(|&x| x < 8), 4);
+
+    let b: IndexSet<_> = [1, 2, 4, 5, 6, 8].into();
+    assert_eq!(b.partition_point(|&x| x < 9), 6);
+
+    let b: IndexSet<_> = [1, 2, 4, 6, 7, 8, 9].into();
+    assert_eq!(b.partition_point(|&x| x < 6), 3);
+    assert_eq!(b.partition_point(|&x| x < 5), 3);
+    assert_eq!(b.partition_point(|&x| x < 8), 5);
+
+    let b: IndexSet<_> = [1, 2, 4, 5, 6, 8, 9].into();
+    assert_eq!(b.partition_point(|&x| x < 7), 5);
+    assert_eq!(b.partition_point(|&x| x < 0), 0);
+
+    let b: IndexSet<_> = [1, 3, 3, 3, 7].into();
+    assert_eq!(b.partition_point(|&x| x < 0), 0);
+    assert_eq!(b.partition_point(|&x| x < 1), 0);
+    assert_eq!(b.partition_point(|&x| x < 2), 1);
+    assert_eq!(b.partition_point(|&x| x < 3), 1);
+    assert_eq!(b.partition_point(|&x| x < 4), 2); // diff from std as set merges the duplicate keys
+    assert_eq!(b.partition_point(|&x| x < 5), 2);
+    assert_eq!(b.partition_point(|&x| x < 6), 2);
+    assert_eq!(b.partition_point(|&x| x < 7), 2);
+    assert_eq!(b.partition_point(|&x| x < 8), 3);
+}
diff --git a/vendor/indexmap/src/util.rs b/vendor/indexmap/src/util.rs
new file mode 100644
index 00000000..8b3b2b48
--- /dev/null
+++ b/vendor/indexmap/src/util.rs
@@ -0,0 +1,78 @@
+use core::ops::{Bound, Range, RangeBounds};
+
+pub(crate) fn third<A, B, C>(t: (A, B, C)) -> C {
+    t.2
+}
+
+#[track_caller]
+pub(crate) fn simplify_range<R>(range: R, len: usize) -> Range<usize>
+where
+    R: RangeBounds<usize>,
+{
+    let start = match range.start_bound() {
+        Bound::Unbounded => 0,
+        Bound::Included(&i) if i <= len => i,
+        Bound::Excluded(&i) if i < len => i + 1,
+        Bound::Included(i) | Bound::Excluded(i) => {
+            panic!("range start index {i} out of range for slice of length {len}")
+        }
+    };
+    let end = match range.end_bound() {
+        Bound::Unbounded => len,
+        Bound::Excluded(&i) if i <= len => i,
+        Bound::Included(&i) if i < len => i + 1,
+        Bound::Included(i) | Bound::Excluded(i) => {
+            panic!("range end index {i} out of range for slice of length {len}")
+        }
+    };
+    if start > end {
+        panic!(
+            "range start index {:?} should be <= range end index {:?}",
+            range.start_bound(),
+            range.end_bound()
+        );
+    }
+    start..end
+}
+
+pub(crate) fn try_simplify_range<R>(range: R, len: usize) -> Option<Range<usize>>
+where
+    R: RangeBounds<usize>,
+{
+    let start = match range.start_bound() {
+        Bound::Unbounded => 0,
+        Bound::Included(&i) if i <= len => i,
+        Bound::Excluded(&i) if i < len => i + 1,
+        _ => return None,
+    };
+    let end = match range.end_bound() {
+        Bound::Unbounded => len,
+        Bound::Excluded(&i) if i <= len => i,
+        Bound::Included(&i) if i < len => i + 1,
+        _ => return None,
+    };
+    if start > end {
+        return None;
+    }
+    Some(start..end)
+}
+
+// Generic slice equality -- copied from the standard library but adding a custom comparator,
+// allowing for our `Bucket` wrapper on either or both sides.
+pub(crate) fn slice_eq<T, U>(left: &[T], right: &[U], eq: impl Fn(&T, &U) -> bool) -> bool {
+    if left.len() != right.len() {
+        return false;
+    }
+
+    // Implemented as explicit indexing rather
+    // than zipped iterators for performance reasons.
+    // See PR https://github.com/rust-lang/rust/pull/116846
+    for i in 0..left.len() {
+        // bound checks are optimized away
+        if !eq(&left[i], &right[i]) {
+            return false;
+        }
+    }
+
+    true
+}