Deleted vendor folder

14 files changed, 0 insertions, 3511 deletions

diff --git a/vendor/bytemuck/src/allocation.rs b/vendor/bytemuck/src/allocation.rs
deleted file mode 100644
index a2633b5..0000000
--- a/vendor/bytemuck/src/allocation.rs
+++ /dev/null
@@ -1,689 +0,0 @@
-#![cfg(feature = "extern_crate_alloc")]
-
-//! Stuff to boost things in the `alloc` crate.
-//!
-//! * You must enable the `extern_crate_alloc` feature of `bytemuck` or you will
-//!   not be able to use this module! This is generally done by adding the
-//!   feature to the dependency in Cargo.toml like so:
-//!
-//!   `bytemuck = { version = "VERSION_YOU_ARE_USING", features =
-//! ["extern_crate_alloc"]}`
-
-use super::*;
-#[cfg(target_has_atomic = "ptr")]
-use alloc::sync::Arc;
-use alloc::{
-  alloc::{alloc_zeroed, Layout},
-  boxed::Box,
-  rc::Rc,
-  vec,
-  vec::Vec,
-};
-
-/// As [`try_cast_box`](try_cast_box), but unwraps for you.
-#[inline]
-pub fn cast_box<A: NoUninit, B: AnyBitPattern>(input: Box<A>) -> Box<B> {
-  try_cast_box(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a [`Box`](alloc::boxed::Box).
-///
-/// On failure you get back an error along with the starting `Box`.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Box` must have the exact same
-///   alignment.
-/// * The start and end size of the `Box` must have the exact same size.
-#[inline]
-pub fn try_cast_box<A: NoUninit, B: AnyBitPattern>(
-  input: Box<A>,
-) -> Result<Box<B>, (PodCastError, Box<A>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    Err((PodCastError::SizeMismatch, input))
-  } else {
-    // Note(Lokathor): This is much simpler than with the Vec casting!
-    let ptr: *mut B = Box::into_raw(input) as *mut B;
-    Ok(unsafe { Box::from_raw(ptr) })
-  }
-}
-
-/// Allocates a `Box<T>` with all of the contents being zeroed out.
-///
-/// This uses the global allocator to create a zeroed allocation and _then_
-/// turns it into a Box. In other words, it's 100% assured that the zeroed data
-/// won't be put temporarily on the stack. You can make a box of any size
-/// without fear of a stack overflow.
-///
-/// ## Failure
-///
-/// This fails if the allocation fails.
-#[inline]
-pub fn try_zeroed_box<T: Zeroable>() -> Result<Box<T>, ()> {
-  if size_of::<T>() == 0 {
-    // This will not allocate but simply create a dangling pointer.
-    let dangling = core::ptr::NonNull::dangling().as_ptr();
-    return Ok(unsafe { Box::from_raw(dangling) });
-  }
-  let layout = Layout::new::<T>();
-  let ptr = unsafe { alloc_zeroed(layout) };
-  if ptr.is_null() {
-    // we don't know what the error is because `alloc_zeroed` is a dumb API
-    Err(())
-  } else {
-    Ok(unsafe { Box::<T>::from_raw(ptr as *mut T) })
-  }
-}
-
-/// As [`try_zeroed_box`], but unwraps for you.
-#[inline]
-pub fn zeroed_box<T: Zeroable>() -> Box<T> {
-  try_zeroed_box().unwrap()
-}
-
-/// Allocates a `Vec<T>` of length and capacity exactly equal to `length` and
-/// all elements zeroed.
-///
-/// ## Failure
-///
-/// This fails if the allocation fails, or if a layout cannot be calculated for
-/// the allocation.
-pub fn try_zeroed_vec<T: Zeroable>(length: usize) -> Result<Vec<T>, ()> {
-  if length == 0 {
-    Ok(Vec::new())
-  } else {
-    let boxed_slice = try_zeroed_slice_box(length)?;
-    Ok(boxed_slice.into_vec())
-  }
-}
-
-/// As [`try_zeroed_vec`] but unwraps for you
-pub fn zeroed_vec<T: Zeroable>(length: usize) -> Vec<T> {
-  try_zeroed_vec(length).unwrap()
-}
-
-/// Allocates a `Box<[T]>` with all contents being zeroed out.
-///
-/// This uses the global allocator to create a zeroed allocation and _then_
-/// turns it into a Box. In other words, it's 100% assured that the zeroed data
-/// won't be put temporarily on the stack. You can make a box of any size
-/// without fear of a stack overflow.
-///
-/// ## Failure
-///
-/// This fails if the allocation fails, or if a layout cannot be calculated for
-/// the allocation.
-#[inline]
-pub fn try_zeroed_slice_box<T: Zeroable>(
-  length: usize,
-) -> Result<Box<[T]>, ()> {
-  if size_of::<T>() == 0 || length == 0 {
-    // This will not allocate but simply create a dangling slice pointer.
-    let dangling = core::ptr::NonNull::dangling().as_ptr();
-    let dangling_slice = core::ptr::slice_from_raw_parts_mut(dangling, length);
-    return Ok(unsafe { Box::from_raw(dangling_slice) });
-  }
-  let layout = core::alloc::Layout::array::<T>(length).map_err(|_| ())?;
-  let ptr = unsafe { alloc_zeroed(layout) };
-  if ptr.is_null() {
-    // we don't know what the error is because `alloc_zeroed` is a dumb API
-    Err(())
-  } else {
-    let slice =
-      unsafe { core::slice::from_raw_parts_mut(ptr as *mut T, length) };
-    Ok(unsafe { Box::<[T]>::from_raw(slice) })
-  }
-}
-
-/// As [`try_zeroed_slice_box`](try_zeroed_slice_box), but unwraps for you.
-pub fn zeroed_slice_box<T: Zeroable>(length: usize) -> Box<[T]> {
-  try_zeroed_slice_box(length).unwrap()
-}
-
-/// As [`try_cast_slice_box`](try_cast_slice_box), but unwraps for you.
-#[inline]
-pub fn cast_slice_box<A: NoUninit, B: AnyBitPattern>(
-  input: Box<[A]>,
-) -> Box<[B]> {
-  try_cast_slice_box(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a `Box<[T]>`.
-///
-/// On failure you get back an error along with the starting `Box<[T]>`.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Box<[T]>` must have the exact same
-///   alignment.
-/// * The start and end content size in bytes of the `Box<[T]>` must be the
-///   exact same.
-#[inline]
-pub fn try_cast_slice_box<A: NoUninit, B: AnyBitPattern>(
-  input: Box<[A]>,
-) -> Result<Box<[B]>, (PodCastError, Box<[A]>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    if size_of::<A>() * input.len() % size_of::<B>() != 0 {
-      // If the size in bytes of the underlying buffer does not match an exact
-      // multiple of the size of B, we cannot cast between them.
-      Err((PodCastError::SizeMismatch, input))
-    } else {
-      // Because the size is an exact multiple, we can now change the length
-      // of the slice and recreate the Box
-      // NOTE: This is a valid operation because according to the docs of
-      // std::alloc::GlobalAlloc::dealloc(), the Layout that was used to alloc
-      // the block must be the same Layout that is used to dealloc the block.
-      // Luckily, Layout only stores two things, the alignment, and the size in
-      // bytes. So as long as both of those stay the same, the Layout will
-      // remain a valid input to dealloc.
-      let length = size_of::<A>() * input.len() / size_of::<B>();
-      let box_ptr: *mut A = Box::into_raw(input) as *mut A;
-      let ptr: *mut [B] =
-        unsafe { core::slice::from_raw_parts_mut(box_ptr as *mut B, length) };
-      Ok(unsafe { Box::<[B]>::from_raw(ptr) })
-    }
-  } else {
-    let box_ptr: *mut [A] = Box::into_raw(input);
-    let ptr: *mut [B] = box_ptr as *mut [B];
-    Ok(unsafe { Box::<[B]>::from_raw(ptr) })
-  }
-}
-
-/// As [`try_cast_vec`](try_cast_vec), but unwraps for you.
-#[inline]
-pub fn cast_vec<A: NoUninit, B: AnyBitPattern>(input: Vec<A>) -> Vec<B> {
-  try_cast_vec(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a [`Vec`](alloc::vec::Vec).
-///
-/// On failure you get back an error along with the starting `Vec`.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Vec` must have the exact same
-///   alignment.
-/// * The start and end content size in bytes of the `Vec` must be the exact
-///   same.
-/// * The start and end capacity in bytes of the `Vec` must be the exact same.
-#[inline]
-pub fn try_cast_vec<A: NoUninit, B: AnyBitPattern>(
-  input: Vec<A>,
-) -> Result<Vec<B>, (PodCastError, Vec<A>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    if size_of::<A>() * input.len() % size_of::<B>() != 0
-      || size_of::<A>() * input.capacity() % size_of::<B>() != 0
-    {
-      // If the size in bytes of the underlying buffer does not match an exact
-      // multiple of the size of B, we cannot cast between them.
-      // Note that we have to pay special attention to make sure that both
-      // length and capacity are valid under B, as we do not want to
-      // change which bytes are considered part of the initialized slice
-      // of the Vec
-      Err((PodCastError::SizeMismatch, input))
-    } else {
-      // Because the size is an exact multiple, we can now change the length and
-      // capacity and recreate the Vec
-      // NOTE: This is a valid operation because according to the docs of
-      // std::alloc::GlobalAlloc::dealloc(), the Layout that was used to alloc
-      // the block must be the same Layout that is used to dealloc the block.
-      // Luckily, Layout only stores two things, the alignment, and the size in
-      // bytes. So as long as both of those stay the same, the Layout will
-      // remain a valid input to dealloc.
-
-      // Note(Lokathor): First we record the length and capacity, which don't
-      // have any secret provenance metadata.
-      let length: usize = size_of::<A>() * input.len() / size_of::<B>();
-      let capacity: usize = size_of::<A>() * input.capacity() / size_of::<B>();
-      // Note(Lokathor): Next we "pre-forget" the old Vec by wrapping with
-      // ManuallyDrop, because if we used `core::mem::forget` after taking the
-      // pointer then that would invalidate our pointer. In nightly there's a
-      // "into raw parts" method, which we can switch this too eventually.
-      let mut manual_drop_vec = ManuallyDrop::new(input);
-      let vec_ptr: *mut A = manual_drop_vec.as_mut_ptr();
-      let ptr: *mut B = vec_ptr as *mut B;
-      Ok(unsafe { Vec::from_raw_parts(ptr, length, capacity) })
-    }
-  } else {
-    // Note(Lokathor): First we record the length and capacity, which don't have
-    // any secret provenance metadata.
-    let length: usize = input.len();
-    let capacity: usize = input.capacity();
-    // Note(Lokathor): Next we "pre-forget" the old Vec by wrapping with
-    // ManuallyDrop, because if we used `core::mem::forget` after taking the
-    // pointer then that would invalidate our pointer. In nightly there's a
-    // "into raw parts" method, which we can switch this too eventually.
-    let mut manual_drop_vec = ManuallyDrop::new(input);
-    let vec_ptr: *mut A = manual_drop_vec.as_mut_ptr();
-    let ptr: *mut B = vec_ptr as *mut B;
-    Ok(unsafe { Vec::from_raw_parts(ptr, length, capacity) })
-  }
-}
-
-/// This "collects" a slice of pod data into a vec of a different pod type.
-///
-/// Unlike with [`cast_slice`] and [`cast_slice_mut`], this will always work.
-///
-/// The output vec will be of a minimal size/capacity to hold the slice given.
-///
-/// ```rust
-/// # use bytemuck::*;
-/// let halfwords: [u16; 4] = [5, 6, 7, 8];
-/// let vec_of_words: Vec<u32> = pod_collect_to_vec(&halfwords);
-/// if cfg!(target_endian = "little") {
-///   assert_eq!(&vec_of_words[..], &[0x0006_0005, 0x0008_0007][..])
-/// } else {
-///   assert_eq!(&vec_of_words[..], &[0x0005_0006, 0x0007_0008][..])
-/// }
-/// ```
-pub fn pod_collect_to_vec<A: NoUninit, B: NoUninit + AnyBitPattern>(
-  src: &[A],
-) -> Vec<B> {
-  let src_size = size_of_val(src);
-  // Note(Lokathor): dst_count is rounded up so that the dest will always be at
-  // least as many bytes as the src.
-  let dst_count = src_size / size_of::<B>()
-    + if src_size % size_of::<B>() != 0 { 1 } else { 0 };
-  let mut dst = vec![B::zeroed(); dst_count];
-
-  let src_bytes: &[u8] = cast_slice(src);
-  let dst_bytes: &mut [u8] = cast_slice_mut(&mut dst[..]);
-  dst_bytes[..src_size].copy_from_slice(src_bytes);
-  dst
-}
-
-/// As [`try_cast_rc`](try_cast_rc), but unwraps for you.
-#[inline]
-pub fn cast_rc<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
-  input: Rc<A>,
-) -> Rc<B> {
-  try_cast_rc(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a [`Rc`](alloc::rc::Rc).
-///
-/// On failure you get back an error along with the starting `Rc`.
-///
-/// The bounds on this function are the same as [`cast_mut`], because a user
-/// could call `Rc::get_unchecked_mut` on the output, which could be observable
-/// in the input.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Rc` must have the exact same
-///   alignment.
-/// * The start and end size of the `Rc` must have the exact same size.
-#[inline]
-pub fn try_cast_rc<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
-  input: Rc<A>,
-) -> Result<Rc<B>, (PodCastError, Rc<A>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    Err((PodCastError::SizeMismatch, input))
-  } else {
-    // Safety: Rc::from_raw requires size and alignment match, which is met.
-    let ptr: *const B = Rc::into_raw(input) as *const B;
-    Ok(unsafe { Rc::from_raw(ptr) })
-  }
-}
-
-/// As [`try_cast_arc`](try_cast_arc), but unwraps for you.
-#[inline]
-#[cfg(target_has_atomic = "ptr")]
-pub fn cast_arc<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
-  input: Arc<A>,
-) -> Arc<B> {
-  try_cast_arc(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a [`Arc`](alloc::sync::Arc).
-///
-/// On failure you get back an error along with the starting `Arc`.
-///
-/// The bounds on this function are the same as [`cast_mut`], because a user
-/// could call `Rc::get_unchecked_mut` on the output, which could be observable
-/// in the input.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Arc` must have the exact same
-///   alignment.
-/// * The start and end size of the `Arc` must have the exact same size.
-#[inline]
-#[cfg(target_has_atomic = "ptr")]
-pub fn try_cast_arc<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  input: Arc<A>,
-) -> Result<Arc<B>, (PodCastError, Arc<A>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    Err((PodCastError::SizeMismatch, input))
-  } else {
-    // Safety: Arc::from_raw requires size and alignment match, which is met.
-    let ptr: *const B = Arc::into_raw(input) as *const B;
-    Ok(unsafe { Arc::from_raw(ptr) })
-  }
-}
-
-/// As [`try_cast_slice_rc`](try_cast_slice_rc), but unwraps for you.
-#[inline]
-pub fn cast_slice_rc<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  input: Rc<[A]>,
-) -> Rc<[B]> {
-  try_cast_slice_rc(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a `Rc<[T]>`.
-///
-/// On failure you get back an error along with the starting `Rc<[T]>`.
-///
-/// The bounds on this function are the same as [`cast_mut`], because a user
-/// could call `Rc::get_unchecked_mut` on the output, which could be observable
-/// in the input.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Rc<[T]>` must have the exact same
-///   alignment.
-/// * The start and end content size in bytes of the `Rc<[T]>` must be the exact
-///   same.
-#[inline]
-pub fn try_cast_slice_rc<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  input: Rc<[A]>,
-) -> Result<Rc<[B]>, (PodCastError, Rc<[A]>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    if size_of::<A>() * input.len() % size_of::<B>() != 0 {
-      // If the size in bytes of the underlying buffer does not match an exact
-      // multiple of the size of B, we cannot cast between them.
-      Err((PodCastError::SizeMismatch, input))
-    } else {
-      // Because the size is an exact multiple, we can now change the length
-      // of the slice and recreate the Rc
-      // NOTE: This is a valid operation because according to the docs of
-      // std::rc::Rc::from_raw(), the type U that was in the original Rc<U>
-      // acquired from Rc::into_raw() must have the same size alignment and
-      // size of the type T in the new Rc<T>. So as long as both the size
-      // and alignment stay the same, the Rc will remain a valid Rc.
-      let length = size_of::<A>() * input.len() / size_of::<B>();
-      let rc_ptr: *const A = Rc::into_raw(input) as *const A;
-      // Must use ptr::slice_from_raw_parts, because we cannot make an
-      // intermediate const reference, because it has mutable provenance,
-      // nor an intermediate mutable reference, because it could be aliased.
-      let ptr = core::ptr::slice_from_raw_parts(rc_ptr as *const B, length);
-      Ok(unsafe { Rc::<[B]>::from_raw(ptr) })
-    }
-  } else {
-    let rc_ptr: *const [A] = Rc::into_raw(input);
-    let ptr: *const [B] = rc_ptr as *const [B];
-    Ok(unsafe { Rc::<[B]>::from_raw(ptr) })
-  }
-}
-
-/// As [`try_cast_slice_arc`](try_cast_slice_arc), but unwraps for you.
-#[inline]
-#[cfg(target_has_atomic = "ptr")]
-pub fn cast_slice_arc<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  input: Arc<[A]>,
-) -> Arc<[B]> {
-  try_cast_slice_arc(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a `Arc<[T]>`.
-///
-/// On failure you get back an error along with the starting `Arc<[T]>`.
-///
-/// The bounds on this function are the same as [`cast_mut`], because a user
-/// could call `Rc::get_unchecked_mut` on the output, which could be observable
-/// in the input.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Arc<[T]>` must have the exact same
-///   alignment.
-/// * The start and end content size in bytes of the `Arc<[T]>` must be the
-///   exact same.
-#[inline]
-#[cfg(target_has_atomic = "ptr")]
-pub fn try_cast_slice_arc<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  input: Arc<[A]>,
-) -> Result<Arc<[B]>, (PodCastError, Arc<[A]>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    if size_of::<A>() * input.len() % size_of::<B>() != 0 {
-      // If the size in bytes of the underlying buffer does not match an exact
-      // multiple of the size of B, we cannot cast between them.
-      Err((PodCastError::SizeMismatch, input))
-    } else {
-      // Because the size is an exact multiple, we can now change the length
-      // of the slice and recreate the Arc
-      // NOTE: This is a valid operation because according to the docs of
-      // std::sync::Arc::from_raw(), the type U that was in the original Arc<U>
-      // acquired from Arc::into_raw() must have the same size alignment and
-      // size of the type T in the new Arc<T>. So as long as both the size
-      // and alignment stay the same, the Arc will remain a valid Arc.
-      let length = size_of::<A>() * input.len() / size_of::<B>();
-      let arc_ptr: *const A = Arc::into_raw(input) as *const A;
-      // Must use ptr::slice_from_raw_parts, because we cannot make an
-      // intermediate const reference, because it has mutable provenance,
-      // nor an intermediate mutable reference, because it could be aliased.
-      let ptr = core::ptr::slice_from_raw_parts(arc_ptr as *const B, length);
-      Ok(unsafe { Arc::<[B]>::from_raw(ptr) })
-    }
-  } else {
-    let arc_ptr: *const [A] = Arc::into_raw(input);
-    let ptr: *const [B] = arc_ptr as *const [B];
-    Ok(unsafe { Arc::<[B]>::from_raw(ptr) })
-  }
-}
-
-/// An extension trait for `TransparentWrapper` and alloc types.
-pub trait TransparentWrapperAlloc<Inner: ?Sized>:
-  TransparentWrapper<Inner>
-{
-  /// Convert a vec of the inner type into a vec of the wrapper type.
-  fn wrap_vec(s: Vec<Inner>) -> Vec<Self>
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    let mut s = core::mem::ManuallyDrop::new(s);
-
-    let length = s.len();
-    let capacity = s.capacity();
-    let ptr = s.as_mut_ptr();
-
-    unsafe {
-      // SAFETY:
-      // * ptr comes from Vec (and will not be double-dropped)
-      // * the two types have the identical representation
-      // * the len and capacity fields are valid
-      Vec::from_raw_parts(ptr as *mut Self, length, capacity)
-    }
-  }
-
-  /// Convert a box to the inner type into a box to the wrapper
-  /// type.
-  #[inline]
-  fn wrap_box(s: Box<Inner>) -> Box<Self> {
-    assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-
-    unsafe {
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY:
-      // * The unsafe contract requires that pointers to Inner and Self have
-      //   identical representations
-      // * Box is guaranteed to have representation identical to a (non-null)
-      //   pointer
-      // * The pointer comes from a box (and thus satisfies all safety
-      //   requirements of Box)
-      let inner_ptr: *mut Inner = Box::into_raw(s);
-      let wrapper_ptr: *mut Self = transmute!(inner_ptr);
-      Box::from_raw(wrapper_ptr)
-    }
-  }
-
-  /// Convert an [`Rc`](alloc::rc::Rc) to the inner type into an `Rc` to the
-  /// wrapper type.
-  #[inline]
-  fn wrap_rc(s: Rc<Inner>) -> Rc<Self> {
-    assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-
-    unsafe {
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the layout of Rc is unspecified.
-      //
-      // SAFETY:
-      // * The unsafe contract requires that pointers to Inner and Self have
-      //   identical representations, and that the size and alignment of Inner
-      //   and Self are the same, which meets the safety requirements of
-      //   Rc::from_raw
-      let inner_ptr: *const Inner = Rc::into_raw(s);
-      let wrapper_ptr: *const Self = transmute!(inner_ptr);
-      Rc::from_raw(wrapper_ptr)
-    }
-  }
-
-  /// Convert an [`Arc`](alloc::sync::Arc) to the inner type into an `Arc` to
-  /// the wrapper type.
-  #[inline]
-  #[cfg(target_has_atomic = "ptr")]
-  fn wrap_arc(s: Arc<Inner>) -> Arc<Self> {
-    assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-
-    unsafe {
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the layout of Arc is unspecified.
-      //
-      // SAFETY:
-      // * The unsafe contract requires that pointers to Inner and Self have
-      //   identical representations, and that the size and alignment of Inner
-      //   and Self are the same, which meets the safety requirements of
-      //   Arc::from_raw
-      let inner_ptr: *const Inner = Arc::into_raw(s);
-      let wrapper_ptr: *const Self = transmute!(inner_ptr);
-      Arc::from_raw(wrapper_ptr)
-    }
-  }
-
-  /// Convert a vec of the wrapper type into a vec of the inner type.
-  fn peel_vec(s: Vec<Self>) -> Vec<Inner>
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    let mut s = core::mem::ManuallyDrop::new(s);
-
-    let length = s.len();
-    let capacity = s.capacity();
-    let ptr = s.as_mut_ptr();
-
-    unsafe {
-      // SAFETY:
-      // * ptr comes from Vec (and will not be double-dropped)
-      // * the two types have the identical representation
-      // * the len and capacity fields are valid
-      Vec::from_raw_parts(ptr as *mut Inner, length, capacity)
-    }
-  }
-
-  /// Convert a box to the wrapper type into a box to the inner
-  /// type.
-  #[inline]
-  fn peel_box(s: Box<Self>) -> Box<Inner> {
-    assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-
-    unsafe {
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY:
-      // * The unsafe contract requires that pointers to Inner and Self have
-      //   identical representations
-      // * Box is guaranteed to have representation identical to a (non-null)
-      //   pointer
-      // * The pointer comes from a box (and thus satisfies all safety
-      //   requirements of Box)
-      let wrapper_ptr: *mut Self = Box::into_raw(s);
-      let inner_ptr: *mut Inner = transmute!(wrapper_ptr);
-      Box::from_raw(inner_ptr)
-    }
-  }
-
-  /// Convert an [`Rc`](alloc::rc::Rc) to the wrapper type into an `Rc` to the
-  /// inner type.
-  #[inline]
-  fn peel_rc(s: Rc<Self>) -> Rc<Inner> {
-    assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-
-    unsafe {
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the layout of Rc is unspecified.
-      //
-      // SAFETY:
-      // * The unsafe contract requires that pointers to Inner and Self have
-      //   identical representations, and that the size and alignment of Inner
-      //   and Self are the same, which meets the safety requirements of
-      //   Rc::from_raw
-      let wrapper_ptr: *const Self = Rc::into_raw(s);
-      let inner_ptr: *const Inner = transmute!(wrapper_ptr);
-      Rc::from_raw(inner_ptr)
-    }
-  }
-
-  /// Convert an [`Arc`](alloc::sync::Arc) to the wrapper type into an `Arc` to
-  /// the inner type.
-  #[inline]
-  #[cfg(target_has_atomic = "ptr")]
-  fn peel_arc(s: Arc<Self>) -> Arc<Inner> {
-    assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-
-    unsafe {
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the layout of Arc is unspecified.
-      //
-      // SAFETY:
-      // * The unsafe contract requires that pointers to Inner and Self have
-      //   identical representations, and that the size and alignment of Inner
-      //   and Self are the same, which meets the safety requirements of
-      //   Arc::from_raw
-      let wrapper_ptr: *const Self = Arc::into_raw(s);
-      let inner_ptr: *const Inner = transmute!(wrapper_ptr);
-      Arc::from_raw(inner_ptr)
-    }
-  }
-}
-
-impl<I: ?Sized, T: ?Sized + TransparentWrapper<I>> TransparentWrapperAlloc<I> for T {}
diff --git a/vendor/bytemuck/src/anybitpattern.rs b/vendor/bytemuck/src/anybitpattern.rs
deleted file mode 100644
index a759738..0000000
--- a/vendor/bytemuck/src/anybitpattern.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use crate::{Pod, Zeroable};
-
-/// Marker trait for "plain old data" types that are valid for any bit pattern.
-///
-/// The requirements for this is very similar to [`Pod`],
-/// except that the type can allow uninit (or padding) bytes.
-/// This limits what you can do with a type of this kind, but also broadens the
-/// included types to `repr(C)` `struct`s that contain padding as well as
-/// `union`s. Notably, you can only cast *immutable* references and *owned*
-/// values into [`AnyBitPattern`] types, not *mutable* references.
-///
-/// [`Pod`] is a subset of [`AnyBitPattern`], meaning that any `T: Pod` is also
-/// [`AnyBitPattern`] but any `T: AnyBitPattern` is not necessarily [`Pod`].
-///
-/// [`AnyBitPattern`] is a subset of [`Zeroable`], meaning that any `T:
-/// AnyBitPattern` is also [`Zeroable`], but any `T: Zeroable` is not
-/// necessarily [`AnyBitPattern  ]
-///
-/// # Derive
-///
-/// A `#[derive(AnyBitPattern)]` macro is provided under the `derive` feature
-/// flag which will automatically validate the requirements of this trait and
-/// implement the trait for you for both structs and enums. This is the
-/// recommended method for implementing the trait, however it's also possible to
-/// do manually. If you implement it manually, you *must* carefully follow the
-/// below safety rules.
-///
-/// * *NOTE: even `C-style`, fieldless enums are intentionally **excluded** from
-/// this trait, since it is **unsound** for an enum to have a discriminant value
-/// that is not one of its defined variants.
-///
-/// # Safety
-///
-/// Similar to [`Pod`] except we disregard the rule about it must not contain
-/// uninit bytes. Still, this is a quite strong guarantee about a type, so *be
-/// careful* when implementing it manually.
-///
-/// * The type must be inhabited (eg: no
-///   [Infallible](core::convert::Infallible)).
-/// * The type must be valid for any bit pattern of its backing memory.
-/// * Structs need to have all fields also be `AnyBitPattern`.
-/// * It is disallowed for types to contain pointer types, `Cell`, `UnsafeCell`,
-///   atomics, and any other forms of interior mutability.
-/// * More precisely: A shared reference to the type must allow reads, and
-///   *only* reads. RustBelt's separation logic is based on the notion that a
-///   type is allowed to define a sharing predicate, its own invariant that must
-///   hold for shared references, and this predicate is the reasoning that allow
-///   it to deal with atomic and cells etc. We require the sharing predicate to
-///   be trivial and permit only read-only access.
-/// * There's probably more, don't mess it up (I mean it).
-pub unsafe trait AnyBitPattern:
-  Zeroable + Sized + Copy + 'static
-{
-}
-
-unsafe impl<T: Pod> AnyBitPattern for T {}
-
-#[cfg(feature = "zeroable_maybe_uninit")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "zeroable_maybe_uninit")))]
-unsafe impl<T> AnyBitPattern for core::mem::MaybeUninit<T> where T: AnyBitPattern
-{}
diff --git a/vendor/bytemuck/src/checked.rs b/vendor/bytemuck/src/checked.rs
deleted file mode 100644
index 722c31d..0000000
--- a/vendor/bytemuck/src/checked.rs
+++ /dev/null
@@ -1,522 +0,0 @@
-//! Checked versions of the casting functions exposed in crate root
-//! that support [`CheckedBitPattern`] types.
-
-use crate::{
-  internal::{self, something_went_wrong},
-  AnyBitPattern, NoUninit,
-};
-
-/// A marker trait that allows types that have some invalid bit patterns to be
-/// used in places that otherwise require [`AnyBitPattern`] or [`Pod`] types by
-/// performing a runtime check on a perticular set of bits. This is particularly
-/// useful for types like fieldless ('C-style') enums, [`char`], bool, and
-/// structs containing them.
-///
-/// To do this, we define a `Bits` type which is a type with equivalent layout
-/// to `Self` other than the invalid bit patterns which disallow `Self` from
-/// being [`AnyBitPattern`]. This `Bits` type must itself implement
-/// [`AnyBitPattern`]. Then, we implement a function that checks whether a
-/// certain instance of the `Bits` is also a valid bit pattern of `Self`. If
-/// this check passes, then we can allow casting from the `Bits` to `Self` (and
-/// therefore, any type which is able to be cast to `Bits` is also able to be
-/// cast to `Self`).
-///
-/// [`AnyBitPattern`] is a subset of [`CheckedBitPattern`], meaning that any `T:
-/// AnyBitPattern` is also [`CheckedBitPattern`]. This means you can also use
-/// any [`AnyBitPattern`] type in the checked versions of casting functions in
-/// this module. If it's possible, prefer implementing [`AnyBitPattern`] for
-/// your type directly instead of [`CheckedBitPattern`] as it gives greater
-/// flexibility.
-///
-/// # Derive
-///
-/// A `#[derive(CheckedBitPattern)]` macro is provided under the `derive`
-/// feature flag which will automatically validate the requirements of this
-/// trait and implement the trait for you for both enums and structs. This is
-/// the recommended method for implementing the trait, however it's also
-/// possible to do manually.
-///
-/// # Example
-///
-/// If manually implementing the trait, we can do something like so:
-///
-/// ```rust
-/// use bytemuck::{CheckedBitPattern, NoUninit};
-///
-/// #[repr(u32)]
-/// #[derive(Copy, Clone)]
-/// enum MyEnum {
-///     Variant0 = 0,
-///     Variant1 = 1,
-///     Variant2 = 2,
-/// }
-///
-/// unsafe impl CheckedBitPattern for MyEnum {
-///     type Bits = u32;
-///
-///     fn is_valid_bit_pattern(bits: &u32) -> bool {
-///         match *bits {
-///             0 | 1 | 2 => true,
-///             _ => false,
-///         }
-///     }
-/// }
-///
-/// // It is often useful to also implement `NoUninit` on our `CheckedBitPattern` types.
-/// // This will allow us to do casting of mutable references (and mutable slices).
-/// // It is not always possible to do so, but in this case we have no padding so it is.
-/// unsafe impl NoUninit for MyEnum {}
-/// ```
-///
-/// We can now use relevant casting functions. For example,
-///
-/// ```rust
-/// # use bytemuck::{CheckedBitPattern, NoUninit};
-/// # #[repr(u32)]
-/// # #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-/// # enum MyEnum {
-/// #     Variant0 = 0,
-/// #     Variant1 = 1,
-/// #     Variant2 = 2,
-/// # }
-/// # unsafe impl NoUninit for MyEnum {}
-/// # unsafe impl CheckedBitPattern for MyEnum {
-/// #     type Bits = u32;
-/// #     fn is_valid_bit_pattern(bits: &u32) -> bool {
-/// #         match *bits {
-/// #             0 | 1 | 2 => true,
-/// #             _ => false,
-/// #         }
-/// #     }
-/// # }
-/// use bytemuck::{bytes_of, bytes_of_mut};
-/// use bytemuck::checked;
-///
-/// let bytes = bytes_of(&2u32);
-/// let result = checked::try_from_bytes::<MyEnum>(bytes);
-/// assert_eq!(result, Ok(&MyEnum::Variant2));
-///
-/// // Fails for invalid discriminant
-/// let bytes = bytes_of(&100u32);
-/// let result = checked::try_from_bytes::<MyEnum>(bytes);
-/// assert!(result.is_err());
-///
-/// // Since we implemented NoUninit, we can also cast mutably from an original type
-/// // that is `NoUninit + AnyBitPattern`:
-/// let mut my_u32 = 2u32;
-/// {
-///   let as_enum_mut = checked::cast_mut::<_, MyEnum>(&mut my_u32);
-///   assert_eq!(as_enum_mut, &mut MyEnum::Variant2);
-///   *as_enum_mut = MyEnum::Variant0;
-/// }
-/// assert_eq!(my_u32, 0u32);
-/// ```
-///
-/// # Safety
-///
-/// * `Self` *must* have the same layout as the specified `Bits` except for
-/// the possible invalid bit patterns being checked during
-/// [`is_valid_bit_pattern`].
-///   * This almost certainly means your type must be `#[repr(C)]` or a similar
-///   specified repr, but if you think you know better, you probably don't. If
-/// you   still think you know better, be careful and have fun. And don't mess
-/// it up   (I mean it).
-/// * If [`is_valid_bit_pattern`] returns true, then the bit pattern contained
-///   in `bits` must also be valid for an instance of `Self`.
-/// * Probably more, don't mess it up (I mean it 2.0)
-///
-/// [`is_valid_bit_pattern`]: CheckedBitPattern::is_valid_bit_pattern
-/// [`Pod`]: crate::Pod
-pub unsafe trait CheckedBitPattern: Copy {
-  /// `Self` *must* have the same layout as the specified `Bits` except for
-  /// the possible invalid bit patterns being checked during
-  /// [`is_valid_bit_pattern`].
-  ///
-  /// [`is_valid_bit_pattern`]: CheckedBitPattern::is_valid_bit_pattern
-  type Bits: AnyBitPattern;
-
-  /// If this function returns true, then it must be valid to reinterpret `bits`
-  /// as `&Self`.
-  fn is_valid_bit_pattern(bits: &Self::Bits) -> bool;
-}
-
-unsafe impl<T: AnyBitPattern> CheckedBitPattern for T {
-  type Bits = T;
-
-  #[inline(always)]
-  fn is_valid_bit_pattern(_bits: &T) -> bool {
-    true
-  }
-}
-
-unsafe impl CheckedBitPattern for char {
-  type Bits = u32;
-
-  #[inline]
-  fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
-    core::char::from_u32(*bits).is_some()
-  }
-}
-
-unsafe impl CheckedBitPattern for bool {
-  type Bits = u8;
-
-  #[inline]
-  fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
-    match *bits {
-      0 | 1 => true,
-      _ => false,
-    }
-  }
-}
-
-// Rust 1.70.0 documents that NonZero[int] has the same layout as [int].
-macro_rules! impl_checked_for_nonzero {
-  ($($nonzero:ty: $primitive:ty),* $(,)?) => {
-    $(
-      unsafe impl CheckedBitPattern for $nonzero {
-        type Bits = $primitive;
-
-        #[inline]
-        fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
-          *bits != 0
-        }
-      }
-    )*
-  };
-}
-impl_checked_for_nonzero! {
-  core::num::NonZeroU8: u8,
-  core::num::NonZeroI8: i8,
-  core::num::NonZeroU16: u16,
-  core::num::NonZeroI16: i16,
-  core::num::NonZeroU32: u32,
-  core::num::NonZeroI32: i32,
-  core::num::NonZeroU64: u64,
-  core::num::NonZeroI64: i64,
-  core::num::NonZeroI128: i128,
-  core::num::NonZeroU128: u128,
-  core::num::NonZeroUsize: usize,
-  core::num::NonZeroIsize: isize,
-}
-
-/// The things that can go wrong when casting between [`CheckedBitPattern`] data
-/// forms.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum CheckedCastError {
-  /// An error occurred during a true-[`Pod`] cast
-  ///
-  /// [`Pod`]: crate::Pod
-  PodCastError(crate::PodCastError),
-  /// When casting to a [`CheckedBitPattern`] type, it is possible that the
-  /// original data contains an invalid bit pattern. If so, the cast will
-  /// fail and this error will be returned. Will never happen on casts
-  /// between [`Pod`] types.
-  ///
-  /// [`Pod`]: crate::Pod
-  InvalidBitPattern,
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl core::fmt::Display for CheckedCastError {
-  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-    write!(f, "{:?}", self)
-  }
-}
-#[cfg(feature = "extern_crate_std")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "extern_crate_std")))]
-impl std::error::Error for CheckedCastError {}
-
-impl From<crate::PodCastError> for CheckedCastError {
-  fn from(err: crate::PodCastError) -> CheckedCastError {
-    CheckedCastError::PodCastError(err)
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-/// * If the slice contains an invalid bit pattern for `T`
-#[inline]
-pub fn try_from_bytes<T: CheckedBitPattern>(
-  s: &[u8],
-) -> Result<&T, CheckedCastError> {
-  let pod = crate::try_from_bytes(s)?;
-
-  if <T as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &*(pod as *const <T as CheckedBitPattern>::Bits as *const T) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-/// * If the slice contains an invalid bit pattern for `T`
-#[inline]
-pub fn try_from_bytes_mut<T: CheckedBitPattern + NoUninit>(
-  s: &mut [u8],
-) -> Result<&mut T, CheckedCastError> {
-  let pod = unsafe { internal::try_from_bytes_mut(s) }?;
-
-  if <T as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &mut *(pod as *mut <T as CheckedBitPattern>::Bits as *mut T) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Reads from the bytes as if they were a `T`.
-///
-/// ## Failure
-/// * If the `bytes` length is not equal to `size_of::<T>()`.
-/// * If the slice contains an invalid bit pattern for `T`
-#[inline]
-pub fn try_pod_read_unaligned<T: CheckedBitPattern>(
-  bytes: &[u8],
-) -> Result<T, CheckedCastError> {
-  let pod = crate::try_pod_read_unaligned(bytes)?;
-
-  if <T as CheckedBitPattern>::is_valid_bit_pattern(&pod) {
-    Ok(unsafe { transmute!(pod) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Try to cast `T` into `U`.
-///
-/// Note that for this particular type of cast, alignment isn't a factor. The
-/// input value is semantically copied into the function and then returned to a
-/// new memory location which will have whatever the required alignment of the
-/// output type is.
-///
-/// ## Failure
-///
-/// * If the types don't have the same size this fails.
-/// * If `a` contains an invalid bit pattern for `B` this fails.
-#[inline]
-pub fn try_cast<A: NoUninit, B: CheckedBitPattern>(
-  a: A,
-) -> Result<B, CheckedCastError> {
-  let pod = crate::try_cast(a)?;
-
-  if <B as CheckedBitPattern>::is_valid_bit_pattern(&pod) {
-    Ok(unsafe { transmute!(pod) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Try to convert a `&T` into `&U`.
-///
-/// ## Failure
-///
-/// * If the reference isn't aligned in the new type
-/// * If the source type and target type aren't the same size.
-/// * If `a` contains an invalid bit pattern for `B` this fails.
-#[inline]
-pub fn try_cast_ref<A: NoUninit, B: CheckedBitPattern>(
-  a: &A,
-) -> Result<&B, CheckedCastError> {
-  let pod = crate::try_cast_ref(a)?;
-
-  if <B as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &*(pod as *const <B as CheckedBitPattern>::Bits as *const B) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Try to convert a `&mut T` into `&mut U`.
-///
-/// As [`try_cast_ref`], but `mut`.
-#[inline]
-pub fn try_cast_mut<
-  A: NoUninit + AnyBitPattern,
-  B: CheckedBitPattern + NoUninit,
->(
-  a: &mut A,
-) -> Result<&mut B, CheckedCastError> {
-  let pod = unsafe { internal::try_cast_mut(a) }?;
-
-  if <B as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &mut *(pod as *mut <B as CheckedBitPattern>::Bits as *mut B) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Try to convert `&[A]` into `&[B]` (possibly with a change in length).
-///
-/// * `input.as_ptr() as usize == output.as_ptr() as usize`
-/// * `input.len() * size_of::<A>() == output.len() * size_of::<B>()`
-///
-/// ## Failure
-///
-/// * If the target type has a greater alignment requirement and the input slice
-///   isn't aligned.
-/// * If the target element type is a different size from the current element
-///   type, and the output slice wouldn't be a whole number of elements when
-///   accounting for the size change (eg: 3 `u16` values is 1.5 `u32` values, so
-///   that's a failure).
-/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts)
-///   and a non-ZST.
-/// * If any element of the converted slice would contain an invalid bit pattern
-///   for `B` this fails.
-#[inline]
-pub fn try_cast_slice<A: NoUninit, B: CheckedBitPattern>(
-  a: &[A],
-) -> Result<&[B], CheckedCastError> {
-  let pod = crate::try_cast_slice(a)?;
-
-  if pod.iter().all(|pod| <B as CheckedBitPattern>::is_valid_bit_pattern(pod)) {
-    Ok(unsafe {
-      core::slice::from_raw_parts(pod.as_ptr() as *const B, pod.len())
-    })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Try to convert `&mut [A]` into `&mut [B]` (possibly with a change in
-/// length).
-///
-/// As [`try_cast_slice`], but `&mut`.
-#[inline]
-pub fn try_cast_slice_mut<
-  A: NoUninit + AnyBitPattern,
-  B: CheckedBitPattern + NoUninit,
->(
-  a: &mut [A],
-) -> Result<&mut [B], CheckedCastError> {
-  let pod = unsafe { internal::try_cast_slice_mut(a) }?;
-
-  if pod.iter().all(|pod| <B as CheckedBitPattern>::is_valid_bit_pattern(pod)) {
-    Ok(unsafe {
-      core::slice::from_raw_parts_mut(pod.as_mut_ptr() as *mut B, pod.len())
-    })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes`] but will panic on error.
-#[inline]
-pub fn from_bytes<T: CheckedBitPattern>(s: &[u8]) -> &T {
-  match try_from_bytes(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes", e),
-  }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes_mut`] but will panic on error.
-#[inline]
-pub fn from_bytes_mut<T: NoUninit + CheckedBitPattern>(s: &mut [u8]) -> &mut T {
-  match try_from_bytes_mut(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes_mut", e),
-  }
-}
-
-/// Reads the slice into a `T` value.
-///
-/// ## Panics
-/// * This is like `try_pod_read_unaligned` but will panic on failure.
-#[inline]
-pub fn pod_read_unaligned<T: CheckedBitPattern>(bytes: &[u8]) -> T {
-  match try_pod_read_unaligned(bytes) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("pod_read_unaligned", e),
-  }
-}
-
-/// Cast `T` into `U`
-///
-/// ## Panics
-///
-/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch.
-#[inline]
-pub fn cast<A: NoUninit, B: CheckedBitPattern>(a: A) -> B {
-  match try_cast(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast", e),
-  }
-}
-
-/// Cast `&mut T` into `&mut U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_mut`] but will panic on error.
-#[inline]
-pub fn cast_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + CheckedBitPattern,
->(
-  a: &mut A,
-) -> &mut B {
-  match try_cast_mut(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_mut", e),
-  }
-}
-
-/// Cast `&T` into `&U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_ref`] but will panic on error.
-#[inline]
-pub fn cast_ref<A: NoUninit, B: CheckedBitPattern>(a: &A) -> &B {
-  match try_cast_ref(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_ref", e),
-  }
-}
-
-/// Cast `&[A]` into `&[B]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice`] but will panic on error.
-#[inline]
-pub fn cast_slice<A: NoUninit, B: CheckedBitPattern>(a: &[A]) -> &[B] {
-  match try_cast_slice(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_slice", e),
-  }
-}
-
-/// Cast `&mut [T]` into `&mut [U]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice_mut`] but will panic on error.
-#[inline]
-pub fn cast_slice_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + CheckedBitPattern,
->(
-  a: &mut [A],
-) -> &mut [B] {
-  match try_cast_slice_mut(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_slice_mut", e),
-  }
-}
diff --git a/vendor/bytemuck/src/contiguous.rs b/vendor/bytemuck/src/contiguous.rs
deleted file mode 100644
index 538514b..0000000
--- a/vendor/bytemuck/src/contiguous.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-use super::*;
-
-/// A trait indicating that:
-///
-/// 1. A type has an equivalent representation to some known integral type.
-/// 2. All instances of this type fall in a fixed range of values.
-/// 3. Within that range, there are no gaps.
-///
-/// This is generally useful for fieldless enums (aka "c-style" enums), however
-/// it's important that it only be used for those with an explicit `#[repr]`, as
-/// `#[repr(Rust)]` fieldess enums have an unspecified layout.
-///
-/// Additionally, you shouldn't assume that all implementations are enums. Any
-/// type which meets the requirements above while following the rules under
-/// "Safety" below is valid.
-///
-/// # Example
-///
-/// ```
-/// # use bytemuck::Contiguous;
-/// #[repr(u8)]
-/// #[derive(Debug, Copy, Clone, PartialEq)]
-/// enum Foo {
-///   A = 0,
-///   B = 1,
-///   C = 2,
-///   D = 3,
-///   E = 4,
-/// }
-/// unsafe impl Contiguous for Foo {
-///   type Int = u8;
-///   const MIN_VALUE: u8 = Foo::A as u8;
-///   const MAX_VALUE: u8 = Foo::E as u8;
-/// }
-/// assert_eq!(Foo::from_integer(3).unwrap(), Foo::D);
-/// assert_eq!(Foo::from_integer(8), None);
-/// assert_eq!(Foo::C.into_integer(), 2);
-/// ```
-/// # Safety
-///
-/// This is an unsafe trait, and incorrectly implementing it is undefined
-/// behavior.
-///
-/// Informally, by implementing it, you're asserting that `C` is identical to
-/// the integral type `C::Int`, and that every `C` falls between `C::MIN_VALUE`
-/// and `C::MAX_VALUE` exactly once, without any gaps.
-///
-/// Precisely, the guarantees you must uphold when implementing `Contiguous` for
-/// some type `C` are:
-///
-/// 1. The size of `C` and `C::Int` must be the same, and neither may be a ZST.
-///    (Note: alignment is explicitly allowed to differ)
-///
-/// 2. `C::Int` must be a primitive integer, and not a wrapper type. In the
-///    future, this may be lifted to include cases where the behavior is
-///    identical for a relevant set of traits (Ord, arithmetic, ...).
-///
-/// 3. All `C::Int`s which are in the *inclusive* range between `C::MIN_VALUE`
-///    and `C::MAX_VALUE` are bitwise identical to unique valid instances of
-///    `C`.
-///
-/// 4. There exist no instances of `C` such that their bitpatterns, when
-///    interpreted as instances of `C::Int`, fall outside of the `MAX_VALUE` /
-///    `MIN_VALUE` range -- It is legal for unsafe code to assume that if it
-///    gets a `C` that implements `Contiguous`, it is in the appropriate range.
-///
-/// 5. Finally, you promise not to provide overridden implementations of
-///    `Contiguous::from_integer` and `Contiguous::into_integer`.
-///
-/// For clarity, the following rules could be derived from the above, but are
-/// listed explicitly:
-///
-/// - `C::MAX_VALUE` must be greater or equal to `C::MIN_VALUE` (therefore, `C`
-///   must be an inhabited type).
-///
-/// - There exist no two values between `MIN_VALUE` and `MAX_VALUE` such that
-///   when interpreted as a `C` they are considered identical (by, say, match).
-pub unsafe trait Contiguous: Copy + 'static {
-  /// The primitive integer type with an identical representation to this
-  /// type.
-  ///
-  /// Contiguous is broadly intended for use with fieldless enums, and for
-  /// these the correct integer type is easy: The enum should have a
-  /// `#[repr(Int)]` or `#[repr(C)]` attribute, (if it does not, it is
-  /// *unsound* to implement `Contiguous`!).
-  ///
-  /// - For `#[repr(Int)]`, use the listed `Int`. e.g. `#[repr(u8)]` should use
-  ///   `type Int = u8`.
-  ///
-  /// - For `#[repr(C)]`, use whichever type the C compiler will use to
-  ///   represent the given enum. This is usually `c_int` (from `std::os::raw`
-  ///   or `libc`), but it's up to you to make the determination as the
-  ///   implementer of the unsafe trait.
-  ///
-  /// For precise rules, see the list under "Safety" above.
-  type Int: Copy + Ord;
-
-  /// The upper *inclusive* bound for valid instances of this type.
-  const MAX_VALUE: Self::Int;
-
-  /// The lower *inclusive* bound for valid instances of this type.
-  const MIN_VALUE: Self::Int;
-
-  /// If `value` is within the range for valid instances of this type,
-  /// returns `Some(converted_value)`, otherwise, returns `None`.
-  ///
-  /// This is a trait method so that you can write `value.into_integer()` in
-  /// your code. It is a contract of this trait that if you implement
-  /// `Contiguous` on your type you **must not** override this method.
-  ///
-  /// # Panics
-  ///
-  /// We will not panic for any correct implementation of `Contiguous`, but
-  /// *may* panic if we detect an incorrect one.
-  ///
-  /// This is undefined behavior regardless, so it could have been the nasal
-  /// demons at that point anyway ;).
-  #[inline]
-  fn from_integer(value: Self::Int) -> Option<Self> {
-    // Guard against an illegal implementation of Contiguous. Annoyingly we
-    // can't rely on `transmute` to do this for us (see below), but
-    // whatever, this gets compiled into nothing in release.
-    assert!(size_of::<Self>() == size_of::<Self::Int>());
-    if Self::MIN_VALUE <= value && value <= Self::MAX_VALUE {
-      // SAFETY: We've checked their bounds (and their size, even though
-      // they've sworn under the Oath Of Unsafe Rust that that already
-      // matched) so this is allowed by `Contiguous`'s unsafe contract.
-      //
-      // So, the `transmute!`. ideally we'd use transmute here, which
-      // is more obviously safe. Sadly, we can't, as these types still
-      // have unspecified sizes.
-      Some(unsafe { transmute!(value) })
-    } else {
-      None
-    }
-  }
-
-  /// Perform the conversion from `C` into the underlying integral type. This
-  /// mostly exists otherwise generic code would need unsafe for the `value as
-  /// integer`
-  ///
-  /// This is a trait method so that you can write `value.into_integer()` in
-  /// your code. It is a contract of this trait that if you implement
-  /// `Contiguous` on your type you **must not** override this method.
-  ///
-  /// # Panics
-  ///
-  /// We will not panic for any correct implementation of `Contiguous`, but
-  /// *may* panic if we detect an incorrect one.
-  ///
-  /// This is undefined behavior regardless, so it could have been the nasal
-  /// demons at that point anyway ;).
-  #[inline]
-  fn into_integer(self) -> Self::Int {
-    // Guard against an illegal implementation of Contiguous. Annoyingly we
-    // can't rely on `transmute` to do the size check for us (see
-    // `from_integer's comment`), but whatever, this gets compiled into
-    // nothing in release. Note that we don't check the result of cast
-    assert!(size_of::<Self>() == size_of::<Self::Int>());
-
-    // SAFETY: The unsafe contract requires that these have identical
-    // representations, and that the range be entirely valid. Using
-    // transmute! instead of transmute here is annoying, but is required
-    // as `Self` and `Self::Int` have unspecified sizes still.
-    unsafe { transmute!(self) }
-  }
-}
-
-macro_rules! impl_contiguous {
-  ($($src:ty as $repr:ident in [$min:expr, $max:expr];)*) => {$(
-    unsafe impl Contiguous for $src {
-      type Int = $repr;
-      const MAX_VALUE: $repr = $max;
-      const MIN_VALUE: $repr = $min;
-    }
-  )*};
-}
-
-impl_contiguous! {
-  bool as u8 in [0, 1];
-
-  u8 as u8 in [0, u8::max_value()];
-  u16 as u16 in [0, u16::max_value()];
-  u32 as u32 in [0, u32::max_value()];
-  u64 as u64 in [0, u64::max_value()];
-  u128 as u128 in [0, u128::max_value()];
-  usize as usize in [0, usize::max_value()];
-
-  i8 as i8 in [i8::min_value(), i8::max_value()];
-  i16 as i16 in [i16::min_value(), i16::max_value()];
-  i32 as i32 in [i32::min_value(), i32::max_value()];
-  i64 as i64 in [i64::min_value(), i64::max_value()];
-  i128 as i128 in [i128::min_value(), i128::max_value()];
-  isize as isize in [isize::min_value(), isize::max_value()];
-
-  NonZeroU8 as u8 in [1, u8::max_value()];
-  NonZeroU16 as u16 in [1, u16::max_value()];
-  NonZeroU32 as u32 in [1, u32::max_value()];
-  NonZeroU64 as u64 in [1, u64::max_value()];
-  NonZeroU128 as u128 in [1, u128::max_value()];
-  NonZeroUsize as usize in [1, usize::max_value()];
-}
diff --git a/vendor/bytemuck/src/internal.rs b/vendor/bytemuck/src/internal.rs
deleted file mode 100644
index 3ede50f..0000000
--- a/vendor/bytemuck/src/internal.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-//! Internal implementation of casting functions not bound by marker traits
-//! and therefore marked as unsafe. This is used so that we don't need to
-//! duplicate the business logic contained in these functions between the
-//! versions exported in the crate root, `checked`, and `relaxed` modules.
-#![allow(unused_unsafe)]
-
-use crate::PodCastError;
-use core::{marker::*, mem::*};
-
-/*
-
-Note(Lokathor): We've switched all of the `unwrap` to `match` because there is
-apparently a bug: https://github.com/rust-lang/rust/issues/68667
-and it doesn't seem to show up in simple godbolt examples but has been reported
-as having an impact when there's a cast mixed in with other more complicated
-code around it. Rustc/LLVM ends up missing that the `Err` can't ever happen for
-particular type combinations, and then it doesn't fully eliminated the panic
-possibility code branch.
-
-*/
-
-/// Immediately panics.
-#[cfg(not(target_arch = "spirv"))]
-#[cold]
-#[inline(never)]
-pub(crate) fn something_went_wrong<D: core::fmt::Display>(
-  _src: &str, _err: D,
-) -> ! {
-  // Note(Lokathor): Keeping the panic here makes the panic _formatting_ go
-  // here too, which helps assembly readability and also helps keep down
-  // the inline pressure.
-  panic!("{src}>{err}", src = _src, err = _err);
-}
-
-/// Immediately panics.
-#[cfg(target_arch = "spirv")]
-#[cold]
-#[inline(never)]
-pub(crate) fn something_went_wrong<D>(_src: &str, _err: D) -> ! {
-  // Note: On the spirv targets from [rust-gpu](https://github.com/EmbarkStudios/rust-gpu)
-  // panic formatting cannot be used. We we just give a generic error message
-  // The chance that the panicking version of these functions will ever get
-  // called on spir-v targets with invalid inputs is small, but giving a
-  // simple error message is better than no error message at all.
-  panic!("Called a panicing helper from bytemuck which paniced");
-}
-
-/// Re-interprets `&T` as `&[u8]`.
-///
-/// Any ZST becomes an empty slice, and in that case the pointer value of that
-/// empty slice might not match the pointer value of the input reference.
-#[inline(always)]
-pub(crate) unsafe fn bytes_of<T: Copy>(t: &T) -> &[u8] {
-  if size_of::<T>() == 0 {
-    &[]
-  } else {
-    match try_cast_slice::<T, u8>(core::slice::from_ref(t)) {
-      Ok(s) => s,
-      Err(_) => unreachable!(),
-    }
-  }
-}
-
-/// Re-interprets `&mut T` as `&mut [u8]`.
-///
-/// Any ZST becomes an empty slice, and in that case the pointer value of that
-/// empty slice might not match the pointer value of the input reference.
-#[inline]
-pub(crate) unsafe fn bytes_of_mut<T: Copy>(t: &mut T) -> &mut [u8] {
-  if size_of::<T>() == 0 {
-    &mut []
-  } else {
-    match try_cast_slice_mut::<T, u8>(core::slice::from_mut(t)) {
-      Ok(s) => s,
-      Err(_) => unreachable!(),
-    }
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes`] but will panic on error.
-#[inline]
-pub(crate) unsafe fn from_bytes<T: Copy>(s: &[u8]) -> &T {
-  match try_from_bytes(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes", e),
-  }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes_mut`] but will panic on error.
-#[inline]
-pub(crate) unsafe fn from_bytes_mut<T: Copy>(s: &mut [u8]) -> &mut T {
-  match try_from_bytes_mut(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes_mut", e),
-  }
-}
-
-/// Reads from the bytes as if they were a `T`.
-///
-/// ## Failure
-/// * If the `bytes` length is not equal to `size_of::<T>()`.
-#[inline]
-pub(crate) unsafe fn try_pod_read_unaligned<T: Copy>(
-  bytes: &[u8],
-) -> Result<T, PodCastError> {
-  if bytes.len() != size_of::<T>() {
-    Err(PodCastError::SizeMismatch)
-  } else {
-    Ok(unsafe { (bytes.as_ptr() as *const T).read_unaligned() })
-  }
-}
-
-/// Reads the slice into a `T` value.
-///
-/// ## Panics
-/// * This is like `try_pod_read_unaligned` but will panic on failure.
-#[inline]
-pub(crate) unsafe fn pod_read_unaligned<T: Copy>(bytes: &[u8]) -> T {
-  match try_pod_read_unaligned(bytes) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("pod_read_unaligned", e),
-  }
-}
-
-/// Checks if `ptr` is aligned to an `align` memory boundary.
-///
-/// ## Panics
-/// * If `align` is not a power of two. This includes when `align` is zero.
-#[inline]
-pub(crate) fn is_aligned_to(ptr: *const (), align: usize) -> bool {
-  #[cfg(feature = "align_offset")]
-  {
-    // This is in a way better than `ptr as usize % align == 0`,
-    // because casting a pointer to an integer has the side effect that it
-    // exposes the pointer's provenance, which may theoretically inhibit
-    // some compiler optimizations.
-    ptr.align_offset(align) == 0
-  }
-  #[cfg(not(feature = "align_offset"))]
-  {
-    ((ptr as usize) % align) == 0
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-#[inline]
-pub(crate) unsafe fn try_from_bytes<T: Copy>(
-  s: &[u8],
-) -> Result<&T, PodCastError> {
-  if s.len() != size_of::<T>() {
-    Err(PodCastError::SizeMismatch)
-  } else if !is_aligned_to(s.as_ptr() as *const (), align_of::<T>()) {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else {
-    Ok(unsafe { &*(s.as_ptr() as *const T) })
-  }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-#[inline]
-pub(crate) unsafe fn try_from_bytes_mut<T: Copy>(
-  s: &mut [u8],
-) -> Result<&mut T, PodCastError> {
-  if s.len() != size_of::<T>() {
-    Err(PodCastError::SizeMismatch)
-  } else if !is_aligned_to(s.as_ptr() as *const (), align_of::<T>()) {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else {
-    Ok(unsafe { &mut *(s.as_mut_ptr() as *mut T) })
-  }
-}
-
-/// Cast `T` into `U`
-///
-/// ## Panics
-///
-/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch.
-#[inline]
-pub(crate) unsafe fn cast<A: Copy, B: Copy>(a: A) -> B {
-  if size_of::<A>() == size_of::<B>() {
-    unsafe { transmute!(a) }
-  } else {
-    something_went_wrong("cast", PodCastError::SizeMismatch)
-  }
-}
-
-/// Cast `&mut T` into `&mut U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_mut`] but will panic on error.
-#[inline]
-pub(crate) unsafe fn cast_mut<A: Copy, B: Copy>(a: &mut A) -> &mut B {
-  if size_of::<A>() == size_of::<B>() && align_of::<A>() >= align_of::<B>() {
-    // Plz mr compiler, just notice that we can't ever hit Err in this case.
-    match try_cast_mut(a) {
-      Ok(b) => b,
-      Err(_) => unreachable!(),
-    }
-  } else {
-    match try_cast_mut(a) {
-      Ok(b) => b,
-      Err(e) => something_went_wrong("cast_mut", e),
-    }
-  }
-}
-
-/// Cast `&T` into `&U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_ref`] but will panic on error.
-#[inline]
-pub(crate) unsafe fn cast_ref<A: Copy, B: Copy>(a: &A) -> &B {
-  if size_of::<A>() == size_of::<B>() && align_of::<A>() >= align_of::<B>() {
-    // Plz mr compiler, just notice that we can't ever hit Err in this case.
-    match try_cast_ref(a) {
-      Ok(b) => b,
-      Err(_) => unreachable!(),
-    }
-  } else {
-    match try_cast_ref(a) {
-      Ok(b) => b,
-      Err(e) => something_went_wrong("cast_ref", e),
-    }
-  }
-}
-
-/// Cast `&[A]` into `&[B]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice`] but will panic on error.
-#[inline]
-pub(crate) unsafe fn cast_slice<A: Copy, B: Copy>(a: &[A]) -> &[B] {
-  match try_cast_slice(a) {
-    Ok(b) => b,
-    Err(e) => something_went_wrong("cast_slice", e),
-  }
-}
-
-/// Cast `&mut [T]` into `&mut [U]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice_mut`] but will panic on error.
-#[inline]
-pub(crate) unsafe fn cast_slice_mut<A: Copy, B: Copy>(a: &mut [A]) -> &mut [B] {
-  match try_cast_slice_mut(a) {
-    Ok(b) => b,
-    Err(e) => something_went_wrong("cast_slice_mut", e),
-  }
-}
-
-/// Try to cast `T` into `U`.
-///
-/// Note that for this particular type of cast, alignment isn't a factor. The
-/// input value is semantically copied into the function and then returned to a
-/// new memory location which will have whatever the required alignment of the
-/// output type is.
-///
-/// ## Failure
-///
-/// * If the types don't have the same size this fails.
-#[inline]
-pub(crate) unsafe fn try_cast<A: Copy, B: Copy>(
-  a: A,
-) -> Result<B, PodCastError> {
-  if size_of::<A>() == size_of::<B>() {
-    Ok(unsafe { transmute!(a) })
-  } else {
-    Err(PodCastError::SizeMismatch)
-  }
-}
-
-/// Try to convert a `&T` into `&U`.
-///
-/// ## Failure
-///
-/// * If the reference isn't aligned in the new type
-/// * If the source type and target type aren't the same size.
-#[inline]
-pub(crate) unsafe fn try_cast_ref<A: Copy, B: Copy>(
-  a: &A,
-) -> Result<&B, PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && !is_aligned_to(a as *const A as *const (), align_of::<B>())
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe { &*(a as *const A as *const B) })
-  } else {
-    Err(PodCastError::SizeMismatch)
-  }
-}
-
-/// Try to convert a `&mut T` into `&mut U`.
-///
-/// As [`try_cast_ref`], but `mut`.
-#[inline]
-pub(crate) unsafe fn try_cast_mut<A: Copy, B: Copy>(
-  a: &mut A,
-) -> Result<&mut B, PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && !is_aligned_to(a as *const A as *const (), align_of::<B>())
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe { &mut *(a as *mut A as *mut B) })
-  } else {
-    Err(PodCastError::SizeMismatch)
-  }
-}
-
-/// Try to convert `&[A]` into `&[B]` (possibly with a change in length).
-///
-/// * `input.as_ptr() as usize == output.as_ptr() as usize`
-/// * `input.len() * size_of::<A>() == output.len() * size_of::<B>()`
-///
-/// ## Failure
-///
-/// * If the target type has a greater alignment requirement and the input slice
-///   isn't aligned.
-/// * If the target element type is a different size from the current element
-///   type, and the output slice wouldn't be a whole number of elements when
-///   accounting for the size change (eg: 3 `u16` values is 1.5 `u32` values, so
-///   that's a failure).
-/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts)
-///   and a non-ZST.
-#[inline]
-pub(crate) unsafe fn try_cast_slice<A: Copy, B: Copy>(
-  a: &[A],
-) -> Result<&[B], PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && !is_aligned_to(a.as_ptr() as *const (), align_of::<B>())
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, a.len()) })
-  } else if size_of::<A>() == 0 || size_of::<B>() == 0 {
-    Err(PodCastError::SizeMismatch)
-  } else if core::mem::size_of_val(a) % size_of::<B>() == 0 {
-    let new_len = core::mem::size_of_val(a) / size_of::<B>();
-    Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, new_len) })
-  } else {
-    Err(PodCastError::OutputSliceWouldHaveSlop)
-  }
-}
-
-/// Try to convert `&mut [A]` into `&mut [B]` (possibly with a change in
-/// length).
-///
-/// As [`try_cast_slice`], but `&mut`.
-#[inline]
-pub(crate) unsafe fn try_cast_slice_mut<A: Copy, B: Copy>(
-  a: &mut [A],
-) -> Result<&mut [B], PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && !is_aligned_to(a.as_ptr() as *const (), align_of::<B>())
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe {
-      core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, a.len())
-    })
-  } else if size_of::<A>() == 0 || size_of::<B>() == 0 {
-    Err(PodCastError::SizeMismatch)
-  } else if core::mem::size_of_val(a) % size_of::<B>() == 0 {
-    let new_len = core::mem::size_of_val(a) / size_of::<B>();
-    Ok(unsafe {
-      core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, new_len)
-    })
-  } else {
-    Err(PodCastError::OutputSliceWouldHaveSlop)
-  }
-}
diff --git a/vendor/bytemuck/src/lib.rs b/vendor/bytemuck/src/lib.rs
deleted file mode 100644
index 000dacb..0000000
--- a/vendor/bytemuck/src/lib.rs
+++ /dev/null
@@ -1,457 +0,0 @@
-#![no_std]
-#![warn(missing_docs)]
-#![allow(clippy::match_like_matches_macro)]
-#![allow(clippy::uninlined_format_args)]
-#![cfg_attr(feature = "nightly_docs", feature(doc_cfg))]
-#![cfg_attr(feature = "nightly_portable_simd", feature(portable_simd))]
-#![cfg_attr(feature = "nightly_stdsimd", feature(stdsimd))]
-
-//! This crate gives small utilities for casting between plain data types.
-//!
-//! ## Basics
-//!
-//! Data comes in five basic forms in Rust, so we have five basic casting
-//! functions:
-//!
-//! * `T` uses [`cast`]
-//! * `&T` uses [`cast_ref`]
-//! * `&mut T` uses [`cast_mut`]
-//! * `&[T]` uses [`cast_slice`]
-//! * `&mut [T]` uses [`cast_slice_mut`]
-//!
-//! Some casts will never fail (eg: `cast::<u32, f32>` always works), other
-//! casts might fail (eg: `cast_ref::<[u8; 4], u32>` will fail if the reference
-//! isn't already aligned to 4). Each casting function has a "try" version which
-//! will return a `Result`, and the "normal" version which will simply panic on
-//! invalid input.
-//!
-//! ## Using Your Own Types
-//!
-//! All the functions here are guarded by the [`Pod`] trait, which is a
-//! sub-trait of the [`Zeroable`] trait.
-//!
-//! If you're very sure that your type is eligible, you can implement those
-//! traits for your type and then they'll have full casting support. However,
-//! these traits are `unsafe`, and you should carefully read the requirements
-//! before adding the them to your own types.
-//!
-//! ## Features
-//!
-//! * This crate is core only by default, but if you're using Rust 1.36 or later
-//!   you can enable the `extern_crate_alloc` cargo feature for some additional
-//!   methods related to `Box` and `Vec`. Note that the `docs.rs` documentation
-//!   is always built with `extern_crate_alloc` cargo feature enabled.
-
-#[cfg(all(target_arch = "aarch64", feature = "aarch64_simd"))]
-use core::arch::aarch64;
-#[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))]
-use core::arch::wasm32;
-#[cfg(target_arch = "x86")]
-use core::arch::x86;
-#[cfg(target_arch = "x86_64")]
-use core::arch::x86_64;
-//
-use core::{marker::*, mem::*, num::*, ptr::*};
-
-// Used from macros to ensure we aren't using some locally defined name and
-// actually are referencing libcore. This also would allow pre-2018 edition
-// crates to use our macros, but I'm not sure how important that is.
-#[doc(hidden)]
-pub use ::core as __core;
-
-#[cfg(not(feature = "min_const_generics"))]
-macro_rules! impl_unsafe_marker_for_array {
-  ( $marker:ident , $( $n:expr ),* ) => {
-    $(unsafe impl<T> $marker for [T; $n] where T: $marker {})*
-  }
-}
-
-/// A macro to transmute between two types without requiring knowing size
-/// statically.
-macro_rules! transmute {
-  ($val:expr) => {
-    ::core::mem::transmute_copy(&::core::mem::ManuallyDrop::new($val))
-  };
-}
-
-/// A macro to implement marker traits for various simd types.
-/// #[allow(unused)] because the impls are only compiled on relevant platforms
-/// with relevant cargo features enabled.
-#[allow(unused)]
-macro_rules! impl_unsafe_marker_for_simd {
-  ($(#[cfg($cfg_predicate:meta)])? unsafe impl $trait:ident for $platform:ident :: {}) => {};
-  ($(#[cfg($cfg_predicate:meta)])? unsafe impl $trait:ident for $platform:ident :: { $first_type:ident $(, $types:ident)* $(,)? }) => {
-    $( #[cfg($cfg_predicate)] )?
-    $( #[cfg_attr(feature = "nightly_docs", doc(cfg($cfg_predicate)))] )?
-    unsafe impl $trait for $platform::$first_type {}
-    $( #[cfg($cfg_predicate)] )? // To prevent recursion errors if nothing is going to be expanded anyway.
-    impl_unsafe_marker_for_simd!($( #[cfg($cfg_predicate)] )? unsafe impl $trait for $platform::{ $( $types ),* });
-  };
-}
-
-#[cfg(feature = "extern_crate_std")]
-extern crate std;
-
-#[cfg(feature = "extern_crate_alloc")]
-extern crate alloc;
-#[cfg(feature = "extern_crate_alloc")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "extern_crate_alloc")))]
-pub mod allocation;
-#[cfg(feature = "extern_crate_alloc")]
-pub use allocation::*;
-
-mod anybitpattern;
-pub use anybitpattern::*;
-
-pub mod checked;
-pub use checked::CheckedBitPattern;
-
-mod internal;
-
-mod zeroable;
-pub use zeroable::*;
-mod zeroable_in_option;
-pub use zeroable_in_option::*;
-
-mod pod;
-pub use pod::*;
-mod pod_in_option;
-pub use pod_in_option::*;
-
-#[cfg(feature = "must_cast")]
-mod must;
-#[cfg(feature = "must_cast")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "must_cast")))]
-pub use must::*;
-
-mod no_uninit;
-pub use no_uninit::*;
-
-mod contiguous;
-pub use contiguous::*;
-
-mod offset_of;
-pub use offset_of::*;
-
-mod transparent;
-pub use transparent::*;
-
-#[cfg(feature = "derive")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "derive")))]
-pub use bytemuck_derive::{
-  AnyBitPattern, ByteEq, ByteHash, CheckedBitPattern, Contiguous, NoUninit,
-  Pod, TransparentWrapper, Zeroable,
-};
-
-/// The things that can go wrong when casting between [`Pod`] data forms.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum PodCastError {
-  /// You tried to cast a slice to an element type with a higher alignment
-  /// requirement but the slice wasn't aligned.
-  TargetAlignmentGreaterAndInputNotAligned,
-  /// If the element size changes then the output slice changes length
-  /// accordingly. If the output slice wouldn't be a whole number of elements
-  /// then the conversion fails.
-  OutputSliceWouldHaveSlop,
-  /// When casting a slice you can't convert between ZST elements and non-ZST
-  /// elements. When casting an individual `T`, `&T`, or `&mut T` value the
-  /// source size and destination size must be an exact match.
-  SizeMismatch,
-  /// For this type of cast the alignments must be exactly the same and they
-  /// were not so now you're sad.
-  ///
-  /// This error is generated **only** by operations that cast allocated types
-  /// (such as `Box` and `Vec`), because in that case the alignment must stay
-  /// exact.
-  AlignmentMismatch,
-}
-#[cfg(not(target_arch = "spirv"))]
-impl core::fmt::Display for PodCastError {
-  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-    write!(f, "{:?}", self)
-  }
-}
-#[cfg(feature = "extern_crate_std")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "extern_crate_std")))]
-impl std::error::Error for PodCastError {}
-
-/// Re-interprets `&T` as `&[u8]`.
-///
-/// Any ZST becomes an empty slice, and in that case the pointer value of that
-/// empty slice might not match the pointer value of the input reference.
-#[inline]
-pub fn bytes_of<T: NoUninit>(t: &T) -> &[u8] {
-  unsafe { internal::bytes_of(t) }
-}
-
-/// Re-interprets `&mut T` as `&mut [u8]`.
-///
-/// Any ZST becomes an empty slice, and in that case the pointer value of that
-/// empty slice might not match the pointer value of the input reference.
-#[inline]
-pub fn bytes_of_mut<T: NoUninit + AnyBitPattern>(t: &mut T) -> &mut [u8] {
-  unsafe { internal::bytes_of_mut(t) }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes`] but will panic on error.
-#[inline]
-pub fn from_bytes<T: AnyBitPattern>(s: &[u8]) -> &T {
-  unsafe { internal::from_bytes(s) }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes_mut`] but will panic on error.
-#[inline]
-pub fn from_bytes_mut<T: NoUninit + AnyBitPattern>(s: &mut [u8]) -> &mut T {
-  unsafe { internal::from_bytes_mut(s) }
-}
-
-/// Reads from the bytes as if they were a `T`.
-///
-/// ## Failure
-/// * If the `bytes` length is not equal to `size_of::<T>()`.
-#[inline]
-pub fn try_pod_read_unaligned<T: AnyBitPattern>(
-  bytes: &[u8],
-) -> Result<T, PodCastError> {
-  unsafe { internal::try_pod_read_unaligned(bytes) }
-}
-
-/// Reads the slice into a `T` value.
-///
-/// ## Panics
-/// * This is like `try_pod_read_unaligned` but will panic on failure.
-#[inline]
-pub fn pod_read_unaligned<T: AnyBitPattern>(bytes: &[u8]) -> T {
-  unsafe { internal::pod_read_unaligned(bytes) }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-#[inline]
-pub fn try_from_bytes<T: AnyBitPattern>(s: &[u8]) -> Result<&T, PodCastError> {
-  unsafe { internal::try_from_bytes(s) }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-#[inline]
-pub fn try_from_bytes_mut<T: NoUninit + AnyBitPattern>(
-  s: &mut [u8],
-) -> Result<&mut T, PodCastError> {
-  unsafe { internal::try_from_bytes_mut(s) }
-}
-
-/// Cast `T` into `U`
-///
-/// ## Panics
-///
-/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch.
-#[inline]
-pub fn cast<A: NoUninit, B: AnyBitPattern>(a: A) -> B {
-  unsafe { internal::cast(a) }
-}
-
-/// Cast `&mut T` into `&mut U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_mut`] but will panic on error.
-#[inline]
-pub fn cast_mut<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
-  a: &mut A,
-) -> &mut B {
-  unsafe { internal::cast_mut(a) }
-}
-
-/// Cast `&T` into `&U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_ref`] but will panic on error.
-#[inline]
-pub fn cast_ref<A: NoUninit, B: AnyBitPattern>(a: &A) -> &B {
-  unsafe { internal::cast_ref(a) }
-}
-
-/// Cast `&[A]` into `&[B]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice`] but will panic on error.
-#[inline]
-pub fn cast_slice<A: NoUninit, B: AnyBitPattern>(a: &[A]) -> &[B] {
-  unsafe { internal::cast_slice(a) }
-}
-
-/// Cast `&mut [T]` into `&mut [U]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice_mut`] but will panic on error.
-#[inline]
-pub fn cast_slice_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  a: &mut [A],
-) -> &mut [B] {
-  unsafe { internal::cast_slice_mut(a) }
-}
-
-/// As `align_to`, but safe because of the [`Pod`] bound.
-#[inline]
-pub fn pod_align_to<T: NoUninit, U: AnyBitPattern>(
-  vals: &[T],
-) -> (&[T], &[U], &[T]) {
-  unsafe { vals.align_to::<U>() }
-}
-
-/// As `align_to_mut`, but safe because of the [`Pod`] bound.
-#[inline]
-pub fn pod_align_to_mut<
-  T: NoUninit + AnyBitPattern,
-  U: NoUninit + AnyBitPattern,
->(
-  vals: &mut [T],
-) -> (&mut [T], &mut [U], &mut [T]) {
-  unsafe { vals.align_to_mut::<U>() }
-}
-
-/// Try to cast `T` into `U`.
-///
-/// Note that for this particular type of cast, alignment isn't a factor. The
-/// input value is semantically copied into the function and then returned to a
-/// new memory location which will have whatever the required alignment of the
-/// output type is.
-///
-/// ## Failure
-///
-/// * If the types don't have the same size this fails.
-#[inline]
-pub fn try_cast<A: NoUninit, B: AnyBitPattern>(
-  a: A,
-) -> Result<B, PodCastError> {
-  unsafe { internal::try_cast(a) }
-}
-
-/// Try to convert a `&T` into `&U`.
-///
-/// ## Failure
-///
-/// * If the reference isn't aligned in the new type
-/// * If the source type and target type aren't the same size.
-#[inline]
-pub fn try_cast_ref<A: NoUninit, B: AnyBitPattern>(
-  a: &A,
-) -> Result<&B, PodCastError> {
-  unsafe { internal::try_cast_ref(a) }
-}
-
-/// Try to convert a `&mut T` into `&mut U`.
-///
-/// As [`try_cast_ref`], but `mut`.
-#[inline]
-pub fn try_cast_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  a: &mut A,
-) -> Result<&mut B, PodCastError> {
-  unsafe { internal::try_cast_mut(a) }
-}
-
-/// Try to convert `&[A]` into `&[B]` (possibly with a change in length).
-///
-/// * `input.as_ptr() as usize == output.as_ptr() as usize`
-/// * `input.len() * size_of::<A>() == output.len() * size_of::<B>()`
-///
-/// ## Failure
-///
-/// * If the target type has a greater alignment requirement and the input slice
-///   isn't aligned.
-/// * If the target element type is a different size from the current element
-///   type, and the output slice wouldn't be a whole number of elements when
-///   accounting for the size change (eg: 3 `u16` values is 1.5 `u32` values, so
-///   that's a failure).
-/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts)
-///   and a non-ZST.
-#[inline]
-pub fn try_cast_slice<A: NoUninit, B: AnyBitPattern>(
-  a: &[A],
-) -> Result<&[B], PodCastError> {
-  unsafe { internal::try_cast_slice(a) }
-}
-
-/// Try to convert `&mut [A]` into `&mut [B]` (possibly with a change in
-/// length).
-///
-/// As [`try_cast_slice`], but `&mut`.
-#[inline]
-pub fn try_cast_slice_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  a: &mut [A],
-) -> Result<&mut [B], PodCastError> {
-  unsafe { internal::try_cast_slice_mut(a) }
-}
-
-/// Fill all bytes of `target` with zeroes (see [`Zeroable`]).
-///
-/// This is similar to `*target = Zeroable::zeroed()`, but guarantees that any
-/// padding bytes in `target` are zeroed as well.
-///
-/// See also [`fill_zeroes`], if you have a slice rather than a single value.
-#[inline]
-pub fn write_zeroes<T: Zeroable>(target: &mut T) {
-  struct EnsureZeroWrite<T>(*mut T);
-  impl<T> Drop for EnsureZeroWrite<T> {
-    #[inline(always)]
-    fn drop(&mut self) {
-      unsafe {
-        core::ptr::write_bytes(self.0, 0u8, 1);
-      }
-    }
-  }
-  unsafe {
-    let guard = EnsureZeroWrite(target);
-    core::ptr::drop_in_place(guard.0);
-    drop(guard);
-  }
-}
-
-/// Fill all bytes of `slice` with zeroes (see [`Zeroable`]).
-///
-/// This is similar to `slice.fill(Zeroable::zeroed())`, but guarantees that any
-/// padding bytes in `slice` are zeroed as well.
-///
-/// See also [`write_zeroes`], which zeroes all bytes of a single value rather
-/// than a slice.
-#[inline]
-pub fn fill_zeroes<T: Zeroable>(slice: &mut [T]) {
-  if core::mem::needs_drop::<T>() {
-    // If `T` needs to be dropped then we have to do this one item at a time, in
-    // case one of the intermediate drops does a panic.
-    slice.iter_mut().for_each(write_zeroes);
-  } else {
-    // Otherwise we can be really fast and just fill everthing with zeros.
-    let len = core::mem::size_of_val::<[T]>(slice);
-    unsafe { core::ptr::write_bytes(slice.as_mut_ptr() as *mut u8, 0u8, len) }
-  }
-}
diff --git a/vendor/bytemuck/src/must.rs b/vendor/bytemuck/src/must.rs
deleted file mode 100644
index 8373e71..0000000
--- a/vendor/bytemuck/src/must.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-#![allow(clippy::module_name_repetitions)]
-#![allow(clippy::let_unit_value)]
-#![allow(clippy::let_underscore_untyped)]
-#![allow(clippy::ptr_as_ptr)]
-
-use crate::{AnyBitPattern, NoUninit};
-use core::mem::{align_of, size_of};
-
-struct Cast<A, B>((A, B));
-impl<A, B> Cast<A, B> {
-  const ASSERT_ALIGN_GREATER_THAN_EQUAL: () =
-    assert!(align_of::<A>() >= align_of::<B>());
-  const ASSERT_SIZE_EQUAL: () = assert!(size_of::<A>() == size_of::<B>());
-  const ASSERT_SIZE_MULTIPLE_OF: () = assert!(
-    (size_of::<A>() == 0) == (size_of::<B>() == 0)
-      && (size_of::<A>() % size_of::<B>() == 0)
-  );
-}
-
-// Workaround for https://github.com/rust-lang/miri/issues/2423.
-// Miri currently doesn't see post-monomorphization errors until runtime,
-// so `compile_fail` tests relying on post-monomorphization errors don't
-// actually fail. Instead use `should_panic` under miri as a workaround.
-#[cfg(miri)]
-macro_rules! post_mono_compile_fail_doctest {
-  () => {
-    "```should_panic"
-  };
-}
-#[cfg(not(miri))]
-macro_rules! post_mono_compile_fail_doctest {
-  () => {
-    "```compile_fail,E0080"
-  };
-}
-
-/// Cast `A` into `B` if infalliable, or fail to compile.
-///
-/// Note that for this particular type of cast, alignment isn't a factor. The
-/// input value is semantically copied into the function and then returned to a
-/// new memory location which will have whatever the required alignment of the
-/// output type is.
-///
-/// ## Failure
-///
-/// * If the types don't have the same size this fails to compile.
-///
-/// ## Examples
-/// ```
-/// // compiles:
-/// let bytes: [u8; 2] = bytemuck::must_cast(12_u16);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// // fails to compile (size mismatch):
-/// let bytes : [u8; 3] = bytemuck::must_cast(12_u16);
-/// ```
-#[inline]
-pub fn must_cast<A: NoUninit, B: AnyBitPattern>(a: A) -> B {
-  let _ = Cast::<A, B>::ASSERT_SIZE_EQUAL;
-  unsafe { transmute!(a) }
-}
-
-/// Convert `&A` into `&B` if infalliable, or fail to compile.
-///
-/// ## Failure
-///
-/// * If the target type has a greater alignment requirement.
-/// * If the source type and target type aren't the same size.
-///
-/// ## Examples
-/// ```
-/// // compiles:
-/// let bytes: &[u8; 2] = bytemuck::must_cast_ref(&12_u16);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// // fails to compile (size mismatch):
-/// let bytes : &[u8; 3] = bytemuck::must_cast_ref(&12_u16);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// // fails to compile (alignment requirements increased):
-/// let bytes : &u16 = bytemuck::must_cast_ref(&[1u8, 2u8]);
-/// ```
-#[inline]
-pub fn must_cast_ref<A: NoUninit, B: AnyBitPattern>(a: &A) -> &B {
-  let _ = Cast::<A, B>::ASSERT_SIZE_EQUAL;
-  let _ = Cast::<A, B>::ASSERT_ALIGN_GREATER_THAN_EQUAL;
-  unsafe { &*(a as *const A as *const B) }
-}
-
-/// Convert a `&mut A` into `&mut B` if infalliable, or fail to compile.
-///
-/// As [`must_cast_ref`], but `mut`.
-///
-/// ## Examples
-/// ```
-/// let mut i = 12_u16;
-/// // compiles:
-/// let bytes: &mut [u8; 2] = bytemuck::must_cast_mut(&mut i);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// # let mut bytes: &mut [u8; 2] = &mut [1, 2];
-/// // fails to compile (alignment requirements increased):
-/// let i : &mut u16 = bytemuck::must_cast_mut(bytes);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// # let mut i = 12_u16;
-/// // fails to compile (size mismatch):
-/// let bytes : &mut [u8; 3] = bytemuck::must_cast_mut(&mut i);
-/// ```
-#[inline]
-pub fn must_cast_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  a: &mut A,
-) -> &mut B {
-  let _ = Cast::<A, B>::ASSERT_SIZE_EQUAL;
-  let _ = Cast::<A, B>::ASSERT_ALIGN_GREATER_THAN_EQUAL;
-  unsafe { &mut *(a as *mut A as *mut B) }
-}
-
-/// Convert `&[A]` into `&[B]` (possibly with a change in length) if
-/// infalliable, or fail to compile.
-///
-/// * `input.as_ptr() as usize == output.as_ptr() as usize`
-/// * `input.len() * size_of::<A>() == output.len() * size_of::<B>()`
-///
-/// ## Failure
-///
-/// * If the target type has a greater alignment requirement.
-/// * If the target element type doesn't evenly fit into the the current element
-///   type (eg: 3 `u16` values is 1.5 `u32` values, so that's a failure).
-/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts)
-///   and a non-ZST.
-///
-/// ## Examples
-/// ```
-/// let indicies: &[u16] = &[1, 2, 3];
-/// // compiles:
-/// let bytes: &[u8] = bytemuck::must_cast_slice(indicies);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// # let bytes : &[u8] = &[1, 0, 2, 0, 3, 0];
-/// // fails to compile (bytes.len() might not be a multiple of 2):
-/// let byte_pairs : &[[u8; 2]] = bytemuck::must_cast_slice(bytes);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// # let byte_pairs : &[[u8; 2]] = &[[1, 0], [2, 0], [3, 0]];
-/// // fails to compile (alignment requirements increased):
-/// let indicies : &[u16] = bytemuck::must_cast_slice(byte_pairs);
-/// ```
-#[inline]
-pub fn must_cast_slice<A: NoUninit, B: AnyBitPattern>(a: &[A]) -> &[B] {
-  let _ = Cast::<A, B>::ASSERT_SIZE_MULTIPLE_OF;
-  let _ = Cast::<A, B>::ASSERT_ALIGN_GREATER_THAN_EQUAL;
-  let new_len = if size_of::<A>() == size_of::<B>() {
-    a.len()
-  } else {
-    a.len() * (size_of::<A>() / size_of::<B>())
-  };
-  unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, new_len) }
-}
-
-/// Convert `&mut [A]` into `&mut [B]` (possibly with a change in length) if
-/// infalliable, or fail to compile.
-///
-/// As [`must_cast_slice`], but `&mut`.
-///
-/// ## Examples
-/// ```
-/// let mut indicies = [1, 2, 3];
-/// let indicies: &mut [u16] = &mut indicies;
-/// // compiles:
-/// let bytes: &mut [u8] = bytemuck::must_cast_slice_mut(indicies);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// # let mut bytes = [1, 0, 2, 0, 3, 0];
-/// # let bytes : &mut [u8] = &mut bytes[..];
-/// // fails to compile (bytes.len() might not be a multiple of 2):
-/// let byte_pairs : &mut [[u8; 2]] = bytemuck::must_cast_slice_mut(bytes);
-/// ```
-#[doc = post_mono_compile_fail_doctest!()]
-/// # let mut byte_pairs = [[1, 0], [2, 0], [3, 0]];
-/// # let byte_pairs : &mut [[u8; 2]] = &mut byte_pairs[..];
-/// // fails to compile (alignment requirements increased):
-/// let indicies : &mut [u16] = bytemuck::must_cast_slice_mut(byte_pairs);
-/// ```
-#[inline]
-pub fn must_cast_slice_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + AnyBitPattern,
->(
-  a: &mut [A],
-) -> &mut [B] {
-  let _ = Cast::<A, B>::ASSERT_SIZE_MULTIPLE_OF;
-  let _ = Cast::<A, B>::ASSERT_ALIGN_GREATER_THAN_EQUAL;
-  let new_len = if size_of::<A>() == size_of::<B>() {
-    a.len()
-  } else {
-    a.len() * (size_of::<A>() / size_of::<B>())
-  };
-  unsafe { core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, new_len) }
-}
diff --git a/vendor/bytemuck/src/no_uninit.rs b/vendor/bytemuck/src/no_uninit.rs
deleted file mode 100644
index 5fda0c9..0000000
--- a/vendor/bytemuck/src/no_uninit.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use crate::Pod;
-use core::num::{
-  NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize,
-  NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
-};
-
-/// Marker trait for "plain old data" types with no uninit (or padding) bytes.
-///
-/// The requirements for this is very similar to [`Pod`],
-/// except that it doesn't require that all bit patterns of the type are valid,
-/// i.e. it does not require the type to be [`Zeroable`][crate::Zeroable].
-/// This limits what you can do with a type of this kind, but also broadens the
-/// included types to things like C-style enums. Notably, you can only cast from
-/// *immutable* references to a [`NoUninit`] type into *immutable* references of
-/// any other type, no casting of mutable references or mutable references to
-/// slices etc.
-///
-/// [`Pod`] is a subset of [`NoUninit`], meaning that any `T: Pod` is also
-/// [`NoUninit`] but any `T: NoUninit` is not necessarily [`Pod`]. If possible,
-/// prefer implementing [`Pod`] directly. To get more [`Pod`]-like functionality
-/// for a type that is only [`NoUninit`], consider also implementing
-/// [`CheckedBitPattern`][crate::CheckedBitPattern].
-///
-/// # Derive
-///
-/// A `#[derive(NoUninit)]` macro is provided under the `derive` feature flag
-/// which will automatically validate the requirements of this trait and
-/// implement the trait for you for both enums and structs. This is the
-/// recommended method for implementing the trait, however it's also possible to
-/// do manually. If you implement it manually, you *must* carefully follow the
-/// below safety rules.
-///
-/// # Safety
-///
-/// The same as [`Pod`] except we disregard the rule about it must
-/// allow any bit pattern (i.e. it does not need to be
-/// [`Zeroable`][crate::Zeroable]). Still, this is a quite strong guarantee
-/// about a type, so *be careful* whem implementing it manually.
-///
-/// * The type must be inhabited (eg: no
-///   [Infallible](core::convert::Infallible)).
-/// * The type must not contain any uninit (or padding) bytes, either in the
-///   middle or on the end (eg: no `#[repr(C)] struct Foo(u8, u16)`, which has
-///   padding in the middle, and also no `#[repr(C)] struct Foo(u16, u8)`, which
-///   has padding on the end).
-/// * Structs need to have all fields also be `NoUninit`.
-/// * Structs need to be `repr(C)` or `repr(transparent)`. In the case of
-///   `repr(C)`, the `packed` and `align` repr modifiers can be used as long as
-///   all other rules end up being followed.
-/// * Enums need to have an explicit `#[repr(Int)]`
-/// * Enums must have only fieldless variants
-/// * It is disallowed for types to contain pointer types, `Cell`, `UnsafeCell`,
-///   atomics, and any other forms of interior mutability.
-/// * More precisely: A shared reference to the type must allow reads, and
-///   *only* reads. RustBelt's separation logic is based on the notion that a
-///   type is allowed to define a sharing predicate, its own invariant that must
-///   hold for shared references, and this predicate is the reasoning that allow
-///   it to deal with atomic and cells etc. We require the sharing predicate to
-///   be trivial and permit only read-only access.
-/// * There's probably more, don't mess it up (I mean it).
-pub unsafe trait NoUninit: Sized + Copy + 'static {}
-
-unsafe impl<T: Pod> NoUninit for T {}
-
-unsafe impl NoUninit for char {}
-
-unsafe impl NoUninit for bool {}
-
-unsafe impl NoUninit for NonZeroU8 {}
-unsafe impl NoUninit for NonZeroI8 {}
-unsafe impl NoUninit for NonZeroU16 {}
-unsafe impl NoUninit for NonZeroI16 {}
-unsafe impl NoUninit for NonZeroU32 {}
-unsafe impl NoUninit for NonZeroI32 {}
-unsafe impl NoUninit for NonZeroU64 {}
-unsafe impl NoUninit for NonZeroI64 {}
-unsafe impl NoUninit for NonZeroU128 {}
-unsafe impl NoUninit for NonZeroI128 {}
-unsafe impl NoUninit for NonZeroUsize {}
-unsafe impl NoUninit for NonZeroIsize {}
diff --git a/vendor/bytemuck/src/offset_of.rs b/vendor/bytemuck/src/offset_of.rs
deleted file mode 100644
index 7e8aedf..0000000
--- a/vendor/bytemuck/src/offset_of.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-#![forbid(unsafe_code)]
-
-/// Find the offset in bytes of the given `$field` of `$Type`. Requires an
-/// already initialized `$instance` value to work with.
-///
-/// This is similar to the macro from [`memoffset`](https://docs.rs/memoffset),
-/// however it uses no `unsafe` code.
-///
-/// This macro has a 3-argument and 2-argument version.
-/// * In the 3-arg version you specify an instance of the type, the type itself,
-///   and the field name.
-/// * In the 2-arg version the macro will call the [`default`](Default::default)
-///   method to make a temporary instance of the type for you.
-///
-/// The output of this macro is the byte offset of the field (as a `usize`). The
-/// calculations of the macro are fixed across the entire program, but if the
-/// type used is `repr(Rust)` then they're *not* fixed across compilations or
-/// compilers.
-///
-/// ## Examples
-///
-/// ### 3-arg Usage
-///
-/// ```rust
-/// # use bytemuck::offset_of;
-/// // enums can't derive default, and for this example we don't pick one
-/// enum MyExampleEnum {
-///   A,
-///   B,
-///   C,
-/// }
-///
-/// // so now our struct here doesn't have Default
-/// #[repr(C)]
-/// struct MyNotDefaultType {
-///   pub counter: i32,
-///   pub some_field: MyExampleEnum,
-/// }
-///
-/// // but we provide an instance of the type and it's all good.
-/// let val = MyNotDefaultType { counter: 5, some_field: MyExampleEnum::A };
-/// assert_eq!(offset_of!(val, MyNotDefaultType, some_field), 4);
-/// ```
-///
-/// ### 2-arg Usage
-///
-/// ```rust
-/// # use bytemuck::offset_of;
-/// #[derive(Default)]
-/// #[repr(C)]
-/// struct Vertex {
-///   pub loc: [f32; 3],
-///   pub color: [f32; 3],
-/// }
-/// // if the type impls Default the macro can make its own default instance.
-/// assert_eq!(offset_of!(Vertex, loc), 0);
-/// assert_eq!(offset_of!(Vertex, color), 12);
-/// ```
-///
-/// # Usage with `#[repr(packed)]` structs
-///
-/// Attempting to compute the offset of a `#[repr(packed)]` struct with
-/// `bytemuck::offset_of!` requires an `unsafe` block. We hope to relax this in
-/// the future, but currently it is required to work around a soundness hole in
-/// Rust (See [rust-lang/rust#27060]).
-///
-/// [rust-lang/rust#27060]: https://github.com/rust-lang/rust/issues/27060
-///
-/// <p style="background:rgba(255,181,77,0.16);padding:0.75em;">
-/// <strong>Warning:</strong> This is only true for versions of bytemuck >
-/// 1.4.0. Previous versions of
-/// <code style="background:rgba(41,24,0,0.1);">bytemuck::offset_of!</code>
-/// will only emit a warning when used on the field of a packed struct in safe
-/// code, which can lead to unsoundness.
-/// </p>
-///
-/// For example, the following will fail to compile:
-///
-/// ```compile_fail
-/// #[repr(C, packed)]
-/// #[derive(Default)]
-/// struct Example {
-///   field: u32,
-/// }
-/// // Doesn't compile:
-/// let _offset = bytemuck::offset_of!(Example, field);
-/// ```
-///
-/// While the error message this generates will mention the
-/// `safe_packed_borrows` lint, the macro will still fail to compile even if
-/// that lint is `#[allow]`ed:
-///
-/// ```compile_fail
-/// # #[repr(C, packed)] #[derive(Default)] struct Example { field: u32 }
-/// // Still doesn't compile:
-/// #[allow(safe_packed_borrows)]
-/// {
-///   let _offset = bytemuck::offset_of!(Example, field);
-/// }
-/// ```
-///
-/// This *can* be worked around by using `unsafe`, but it is only sound to do so
-/// if you can guarantee that taking a reference to the field is sound.
-///
-/// In practice, this means it only works for fields of align(1) types, or if
-/// you know the field's offset in advance (defeating the point of `offset_of`)
-/// and can prove that the struct's alignment and the field's offset are enough
-/// to prove the field's alignment.
-///
-/// Once the `raw_ref` macros are available, a future version of this crate will
-/// use them to lift the limitations of packed structs. For the duration of the
-/// `1.x` version of this crate that will be behind an on-by-default cargo
-/// feature (to maintain minimum rust version support).
-#[macro_export]
-macro_rules! offset_of {
-  ($instance:expr, $Type:path, $field:tt) => {{
-    #[forbid(safe_packed_borrows)]
-    {
-      // This helps us guard against field access going through a Deref impl.
-      #[allow(clippy::unneeded_field_pattern)]
-      let $Type { $field: _, .. };
-      let reference: &$Type = &$instance;
-      let address = reference as *const _ as usize;
-      let field_pointer = &reference.$field as *const _ as usize;
-      // These asserts/unwraps are compiled away at release, and defend against
-      // the case where somehow a deref impl is still invoked.
-      let result = field_pointer.checked_sub(address).unwrap();
-      assert!(result <= $crate::__core::mem::size_of::<$Type>());
-      result
-    }
-  }};
-  ($Type:path, $field:tt) => {{
-    $crate::offset_of!(<$Type as Default>::default(), $Type, $field)
-  }};
-}
diff --git a/vendor/bytemuck/src/pod.rs b/vendor/bytemuck/src/pod.rs
deleted file mode 100644
index 2cec1c2..0000000
--- a/vendor/bytemuck/src/pod.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use super::*;
-
-/// Marker trait for "plain old data".
-///
-/// The point of this trait is that once something is marked "plain old data"
-/// you can really go to town with the bit fiddling and bit casting. Therefore,
-/// it's a relatively strong claim to make about a type. Do not add this to your
-/// type casually.
-///
-/// **Reminder:** The results of casting around bytes between data types are
-/// _endian dependant_. Little-endian machines are the most common, but
-/// big-endian machines do exist (and big-endian is also used for "network
-/// order" bytes).
-///
-/// ## Safety
-///
-/// * The type must be inhabited (eg: no
-///   [Infallible](core::convert::Infallible)).
-/// * The type must allow any bit pattern (eg: no `bool` or `char`, which have
-///   illegal bit patterns).
-/// * The type must not contain any uninit (or padding) bytes, either in the
-///   middle or on the end (eg: no `#[repr(C)] struct Foo(u8, u16)`, which has
-///   padding in the middle, and also no `#[repr(C)] struct Foo(u16, u8)`, which
-///   has padding on the end).
-/// * The type needs to have all fields also be `Pod`.
-/// * The type needs to be `repr(C)` or `repr(transparent)`. In the case of
-///   `repr(C)`, the `packed` and `align` repr modifiers can be used as long as
-///   all other rules end up being followed.
-/// * It is disallowed for types to contain pointer types, `Cell`, `UnsafeCell`,
-///   atomics, and any other forms of interior mutability.
-/// * More precisely: A shared reference to the type must allow reads, and
-///   *only* reads. RustBelt's separation logic is based on the notion that a
-///   type is allowed to define a sharing predicate, its own invariant that must
-///   hold for shared references, and this predicate is the reasoning that allow
-///   it to deal with atomic and cells etc. We require the sharing predicate to
-///   be trivial and permit only read-only access.
-pub unsafe trait Pod: Zeroable + Copy + 'static {}
-
-unsafe impl Pod for () {}
-unsafe impl Pod for u8 {}
-unsafe impl Pod for i8 {}
-unsafe impl Pod for u16 {}
-unsafe impl Pod for i16 {}
-unsafe impl Pod for u32 {}
-unsafe impl Pod for i32 {}
-unsafe impl Pod for u64 {}
-unsafe impl Pod for i64 {}
-unsafe impl Pod for usize {}
-unsafe impl Pod for isize {}
-unsafe impl Pod for u128 {}
-unsafe impl Pod for i128 {}
-unsafe impl Pod for f32 {}
-unsafe impl Pod for f64 {}
-unsafe impl<T: Pod> Pod for Wrapping<T> {}
-
-#[cfg(feature = "unsound_ptr_pod_impl")]
-#[cfg_attr(
-  feature = "nightly_docs",
-  doc(cfg(feature = "unsound_ptr_pod_impl"))
-)]
-unsafe impl<T: 'static> Pod for *mut T {}
-#[cfg(feature = "unsound_ptr_pod_impl")]
-#[cfg_attr(
-  feature = "nightly_docs",
-  doc(cfg(feature = "unsound_ptr_pod_impl"))
-)]
-unsafe impl<T: 'static> Pod for *const T {}
-#[cfg(feature = "unsound_ptr_pod_impl")]
-#[cfg_attr(
-  feature = "nightly_docs",
-  doc(cfg(feature = "unsound_ptr_pod_impl"))
-)]
-unsafe impl<T: 'static> PodInOption for NonNull<T> {}
-
-unsafe impl<T: ?Sized + 'static> Pod for PhantomData<T> {}
-unsafe impl Pod for PhantomPinned {}
-unsafe impl<T: Pod> Pod for ManuallyDrop<T> {}
-
-// Note(Lokathor): MaybeUninit can NEVER be Pod.
-
-#[cfg(feature = "min_const_generics")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "min_const_generics")))]
-unsafe impl<T, const N: usize> Pod for [T; N] where T: Pod {}
-
-#[cfg(not(feature = "min_const_generics"))]
-impl_unsafe_marker_for_array!(
-  Pod, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-  20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 48, 64, 96, 128, 256,
-  512, 1024, 2048, 4096
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))]
-  unsafe impl Pod for wasm32::{v128}
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "aarch64", feature = "aarch64_simd"))]
-  unsafe impl Pod for aarch64::{
-    float32x2_t, float32x2x2_t, float32x2x3_t, float32x2x4_t, float32x4_t,
-    float32x4x2_t, float32x4x3_t, float32x4x4_t, float64x1_t, float64x1x2_t,
-    float64x1x3_t, float64x1x4_t, float64x2_t, float64x2x2_t, float64x2x3_t,
-    float64x2x4_t, int16x4_t, int16x4x2_t, int16x4x3_t, int16x4x4_t, int16x8_t,
-    int16x8x2_t, int16x8x3_t, int16x8x4_t, int32x2_t, int32x2x2_t, int32x2x3_t,
-    int32x2x4_t, int32x4_t, int32x4x2_t, int32x4x3_t, int32x4x4_t, int64x1_t,
-    int64x1x2_t, int64x1x3_t, int64x1x4_t, int64x2_t, int64x2x2_t, int64x2x3_t,
-    int64x2x4_t, int8x16_t, int8x16x2_t, int8x16x3_t, int8x16x4_t, int8x8_t,
-    int8x8x2_t, int8x8x3_t, int8x8x4_t, poly16x4_t, poly16x4x2_t, poly16x4x3_t,
-    poly16x4x4_t, poly16x8_t, poly16x8x2_t, poly16x8x3_t, poly16x8x4_t,
-    poly64x1_t, poly64x1x2_t, poly64x1x3_t, poly64x1x4_t, poly64x2_t,
-    poly64x2x2_t, poly64x2x3_t, poly64x2x4_t, poly8x16_t, poly8x16x2_t,
-    poly8x16x3_t, poly8x16x4_t, poly8x8_t, poly8x8x2_t, poly8x8x3_t, poly8x8x4_t,
-    uint16x4_t, uint16x4x2_t, uint16x4x3_t, uint16x4x4_t, uint16x8_t,
-    uint16x8x2_t, uint16x8x3_t, uint16x8x4_t, uint32x2_t, uint32x2x2_t,
-    uint32x2x3_t, uint32x2x4_t, uint32x4_t, uint32x4x2_t, uint32x4x3_t,
-    uint32x4x4_t, uint64x1_t, uint64x1x2_t, uint64x1x3_t, uint64x1x4_t,
-    uint64x2_t, uint64x2x2_t, uint64x2x3_t, uint64x2x4_t, uint8x16_t,
-    uint8x16x2_t, uint8x16x3_t, uint8x16x4_t, uint8x8_t, uint8x8x2_t,
-    uint8x8x3_t, uint8x8x4_t,
-  }
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(target_arch = "x86")]
-  unsafe impl Pod for x86::{
-    __m128i, __m128, __m128d,
-    __m256i, __m256, __m256d,
-  }
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(target_arch = "x86_64")]
-  unsafe impl Pod for x86_64::{
-    __m128i, __m128, __m128d,
-    __m256i, __m256, __m256d,
-  }
-);
-
-#[cfg(feature = "nightly_portable_simd")]
-#[cfg_attr(
-  feature = "nightly_docs",
-  doc(cfg(feature = "nightly_portable_simd"))
-)]
-unsafe impl<T, const N: usize> Pod for core::simd::Simd<T, N>
-where
-  T: core::simd::SimdElement + Pod,
-  core::simd::LaneCount<N>: core::simd::SupportedLaneCount,
-{
-}
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "x86", feature = "nightly_stdsimd"))]
-  unsafe impl Pod for x86::{
-    __m128bh, __m256bh, __m512,
-    __m512bh, __m512d, __m512i,
-  }
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "x86_64", feature = "nightly_stdsimd"))]
-  unsafe impl Pod for x86_64::{
-    __m128bh, __m256bh, __m512,
-    __m512bh, __m512d, __m512i,
-  }
-);
diff --git a/vendor/bytemuck/src/pod_in_option.rs b/vendor/bytemuck/src/pod_in_option.rs
deleted file mode 100644
index 3327e99..0000000
--- a/vendor/bytemuck/src/pod_in_option.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use super::*;
-
-// Note(Lokathor): This is the neat part!!
-unsafe impl<T: PodInOption> Pod for Option<T> {}
-
-/// Trait for types which are [Pod](Pod) when wrapped in
-/// [Option](core::option::Option).
-///
-/// ## Safety
-///
-/// * `Option<T>` must uphold the same invariants as [Pod](Pod).
-/// * **Reminder:** pointers are **not** pod! **Do not** mix this trait with a
-///   newtype over [NonNull](core::ptr::NonNull).
-pub unsafe trait PodInOption: ZeroableInOption + Copy + 'static {}
-
-unsafe impl PodInOption for NonZeroI8 {}
-unsafe impl PodInOption for NonZeroI16 {}
-unsafe impl PodInOption for NonZeroI32 {}
-unsafe impl PodInOption for NonZeroI64 {}
-unsafe impl PodInOption for NonZeroI128 {}
-unsafe impl PodInOption for NonZeroIsize {}
-unsafe impl PodInOption for NonZeroU8 {}
-unsafe impl PodInOption for NonZeroU16 {}
-unsafe impl PodInOption for NonZeroU32 {}
-unsafe impl PodInOption for NonZeroU64 {}
-unsafe impl PodInOption for NonZeroU128 {}
-unsafe impl PodInOption for NonZeroUsize {}
diff --git a/vendor/bytemuck/src/transparent.rs b/vendor/bytemuck/src/transparent.rs
deleted file mode 100644
index 5b9fe0e..0000000
--- a/vendor/bytemuck/src/transparent.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-use super::*;
-
-/// A trait which indicates that a type is a `#[repr(transparent)]` wrapper
-/// around the `Inner` value.
-///
-/// This allows safely copy transmuting between the `Inner` type and the
-/// `TransparentWrapper` type. Functions like `wrap_{}` convert from the inner
-/// type to the wrapper type and `peel_{}` functions do the inverse conversion
-/// from the wrapper type to the inner type. We deliberately do not call the
-/// wrapper-removing methods "unwrap" because at this point that word is too
-/// strongly tied to the Option/ Result methods.
-///
-/// # Safety
-///
-/// The safety contract of `TransparentWrapper` is relatively simple:
-///
-/// For a given `Wrapper` which implements `TransparentWrapper<Inner>`:
-///
-/// 1. `Wrapper` must be a wrapper around `Inner` with an identical data
-///    representations. This    either means that it must be a
-///    `#[repr(transparent)]` struct which    contains a either a field of type
-///    `Inner` (or a field of some other    transparent wrapper for `Inner`) as
-///    the only non-ZST field.
-///
-/// 2. Any fields *other* than the `Inner` field must be trivially constructable
-///    ZSTs, for example `PhantomData`, `PhantomPinned`, etc. (When deriving
-///    `TransparentWrapper` on a type with ZST fields, the ZST fields must be
-///    [`Zeroable`]).
-///
-/// 3. The `Wrapper` may not impose additional alignment requirements over
-///    `Inner`.
-///     - Note: this is currently guaranteed by `repr(transparent)`, but there
-///       have been discussions of lifting it, so it's stated here explicitly.
-///
-/// 4. All functions on `TransparentWrapper` **may not** be overridden.
-///
-/// ## Caveats
-///
-/// If the wrapper imposes additional constraints upon the inner type which are
-/// required for safety, it's responsible for ensuring those still hold -- this
-/// generally requires preventing access to instances of the inner type, as
-/// implementing `TransparentWrapper<U> for T` means anybody can call
-/// `T::cast_ref(any_instance_of_u)`.
-///
-/// For example, it would be invalid to implement TransparentWrapper for `str`
-/// to implement `TransparentWrapper` around `[u8]` because of this.
-///
-/// # Examples
-///
-/// ## Basic
-///
-/// ```
-/// use bytemuck::TransparentWrapper;
-/// # #[derive(Default)]
-/// # struct SomeStruct(u32);
-///
-/// #[repr(transparent)]
-/// struct MyWrapper(SomeStruct);
-///
-/// unsafe impl TransparentWrapper<SomeStruct> for MyWrapper {}
-///
-/// // interpret a reference to &SomeStruct as a &MyWrapper
-/// let thing = SomeStruct::default();
-/// let inner_ref: &MyWrapper = MyWrapper::wrap_ref(&thing);
-///
-/// // Works with &mut too.
-/// let mut mut_thing = SomeStruct::default();
-/// let inner_mut: &mut MyWrapper = MyWrapper::wrap_mut(&mut mut_thing);
-///
-/// # let _ = (inner_ref, inner_mut); // silence warnings
-/// ```
-///
-/// ## Use with dynamically sized types
-///
-/// ```
-/// use bytemuck::TransparentWrapper;
-///
-/// #[repr(transparent)]
-/// struct Slice<T>([T]);
-///
-/// unsafe impl<T> TransparentWrapper<[T]> for Slice<T> {}
-///
-/// let s = Slice::wrap_ref(&[1u32, 2, 3]);
-/// assert_eq!(&s.0, &[1, 2, 3]);
-///
-/// let mut buf = [1, 2, 3u8];
-/// let sm = Slice::wrap_mut(&mut buf);
-/// ```
-///
-/// ## Deriving
-///
-/// When deriving, the non-wrapped fields must uphold all the normal requirements,
-/// and must also be `Zeroable`.
-///
-#[cfg_attr(feature = "derive", doc = "```")]
-#[cfg_attr(
-  not(feature = "derive"),
-  doc = "```ignore
-// This example requires the `derive` feature."
-)]
-/// use bytemuck::TransparentWrapper;
-/// use std::marker::PhantomData;
-///
-/// #[derive(TransparentWrapper)]
-/// #[repr(transparent)]
-/// #[transparent(usize)]
-/// struct Wrapper<T: ?Sized>(usize, PhantomData<T>); // PhantomData<T> implements Zeroable for all T
-/// ```
-///
-/// Here, an error will occur, because `MyZst` does not implement `Zeroable`.
-///
-#[cfg_attr(feature = "derive", doc = "```compile_fail")]
-#[cfg_attr(
-  not(feature = "derive"),
-  doc = "```ignore
-// This example requires the `derive` feature."
-)]
-/// use bytemuck::TransparentWrapper;
-/// struct MyZst;
-///
-/// #[derive(TransparentWrapper)]
-/// #[repr(transparent)]
-/// #[transparent(usize)]
-/// struct Wrapper(usize, MyZst); // MyZst does not implement Zeroable
-/// ```
-pub unsafe trait TransparentWrapper<Inner: ?Sized> {
-  /// Convert the inner type into the wrapper type.
-  #[inline]
-  fn wrap(s: Inner) -> Self
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    // SAFETY: The unsafe contract requires that `Self` and `Inner` have
-    // identical representations.
-    unsafe { transmute!(s) }
-  }
-
-  /// Convert a reference to the inner type into a reference to the wrapper
-  /// type.
-  #[inline]
-  fn wrap_ref(s: &Inner) -> &Self {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let inner_ptr = s as *const Inner;
-      let wrapper_ptr: *const Self = transmute!(inner_ptr);
-      &*wrapper_ptr
-    }
-  }
-
-  /// Convert a mutable reference to the inner type into a mutable reference to
-  /// the wrapper type.
-  #[inline]
-  fn wrap_mut(s: &mut Inner) -> &mut Self {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let inner_ptr = s as *mut Inner;
-      let wrapper_ptr: *mut Self = transmute!(inner_ptr);
-      &mut *wrapper_ptr
-    }
-  }
-
-  /// Convert a slice to the inner type into a slice to the wrapper type.
-  #[inline]
-  fn wrap_slice(s: &[Inner]) -> &[Self]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      assert!(align_of::<*const Inner>() == align_of::<*const Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts(s.as_ptr() as *const Self, s.len())
-    }
-  }
-
-  /// Convert a mutable slice to the inner type into a mutable slice to the
-  /// wrapper type.
-  #[inline]
-  fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      assert!(align_of::<*mut Inner>() == align_of::<*mut Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts_mut(s.as_mut_ptr() as *mut Self, s.len())
-    }
-  }
-
-  /// Convert the wrapper type into the inner type.
-  #[inline]
-  fn peel(s: Self) -> Inner
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe { transmute!(s) }
-  }
-
-  /// Convert a reference to the wrapper type into a reference to the inner
-  /// type.
-  #[inline]
-  fn peel_ref(s: &Self) -> &Inner {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let wrapper_ptr = s as *const Self;
-      let inner_ptr: *const Inner = transmute!(wrapper_ptr);
-      &*inner_ptr
-    }
-  }
-
-  /// Convert a mutable reference to the wrapper type into a mutable reference
-  /// to the inner type.
-  #[inline]
-  fn peel_mut(s: &mut Self) -> &mut Inner {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let wrapper_ptr = s as *mut Self;
-      let inner_ptr: *mut Inner = transmute!(wrapper_ptr);
-      &mut *inner_ptr
-    }
-  }
-
-  /// Convert a slice to the wrapped type into a slice to the inner type.
-  #[inline]
-  fn peel_slice(s: &[Self]) -> &[Inner]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      assert!(align_of::<*const Inner>() == align_of::<*const Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts(s.as_ptr() as *const Inner, s.len())
-    }
-  }
-
-  /// Convert a mutable slice to the wrapped type into a mutable slice to the
-  /// inner type.
-  #[inline]
-  fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      assert!(align_of::<*mut Inner>() == align_of::<*mut Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts_mut(s.as_mut_ptr() as *mut Inner, s.len())
-    }
-  }
-}
-
-unsafe impl<T> TransparentWrapper<T> for core::num::Wrapping<T> {}
diff --git a/vendor/bytemuck/src/zeroable.rs b/vendor/bytemuck/src/zeroable.rs
deleted file mode 100644
index b64a9bf..0000000
--- a/vendor/bytemuck/src/zeroable.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use super::*;
-
-/// Trait for types that can be safely created with
-/// [`zeroed`](core::mem::zeroed).
-///
-/// An all-zeroes value may or may not be the same value as the
-/// [Default](core::default::Default) value of the type.
-///
-/// ## Safety
-///
-/// * Your type must be inhabited (eg: no
-///   [Infallible](core::convert::Infallible)).
-/// * Your type must be allowed to be an "all zeroes" bit pattern (eg: no
-///   [`NonNull<T>`](core::ptr::NonNull)).
-///
-/// ## Features
-///
-/// Some `impl`s are feature gated due to the MSRV policy:
-///
-/// * `MaybeUninit<T>` was not available in 1.34.0, but is available under the
-///   `zeroable_maybe_uninit` feature flag.
-/// * `Atomic*` types require Rust 1.60.0 or later to work on certain platforms,
-///   but is available under the `zeroable_atomics` feature flag.
-/// * `[T; N]` for arbitrary `N` requires the `min_const_generics` feature flag.
-pub unsafe trait Zeroable: Sized {
-  /// Calls [`zeroed`](core::mem::zeroed).
-  ///
-  /// This is a trait method so that you can write `MyType::zeroed()` in your
-  /// code. It is a contract of this trait that if you implement it on your type
-  /// you **must not** override this method.
-  #[inline]
-  fn zeroed() -> Self {
-    unsafe { core::mem::zeroed() }
-  }
-}
-unsafe impl Zeroable for () {}
-unsafe impl Zeroable for bool {}
-unsafe impl Zeroable for char {}
-unsafe impl Zeroable for u8 {}
-unsafe impl Zeroable for i8 {}
-unsafe impl Zeroable for u16 {}
-unsafe impl Zeroable for i16 {}
-unsafe impl Zeroable for u32 {}
-unsafe impl Zeroable for i32 {}
-unsafe impl Zeroable for u64 {}
-unsafe impl Zeroable for i64 {}
-unsafe impl Zeroable for usize {}
-unsafe impl Zeroable for isize {}
-unsafe impl Zeroable for u128 {}
-unsafe impl Zeroable for i128 {}
-unsafe impl Zeroable for f32 {}
-unsafe impl Zeroable for f64 {}
-unsafe impl<T: Zeroable> Zeroable for Wrapping<T> {}
-unsafe impl<T: Zeroable> Zeroable for core::cmp::Reverse<T> {}
-
-// Note: we can't implement this for all `T: ?Sized` types because it would
-// create NULL pointers for vtables.
-// Maybe one day this could be changed to be implemented for
-// `T: ?Sized where <T as core::ptr::Pointee>::Metadata: Zeroable`.
-unsafe impl<T> Zeroable for *mut T {}
-unsafe impl<T> Zeroable for *const T {}
-unsafe impl<T> Zeroable for *mut [T] {}
-unsafe impl<T> Zeroable for *const [T] {}
-unsafe impl Zeroable for *mut str {}
-unsafe impl Zeroable for *const str {}
-
-unsafe impl<T: ?Sized> Zeroable for PhantomData<T> {}
-unsafe impl Zeroable for PhantomPinned {}
-unsafe impl<T: Zeroable> Zeroable for ManuallyDrop<T> {}
-unsafe impl<T: Zeroable> Zeroable for core::cell::UnsafeCell<T> {}
-unsafe impl<T: Zeroable> Zeroable for core::cell::Cell<T> {}
-
-#[cfg(feature = "zeroable_atomics")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "zeroable_atomics")))]
-mod atomic_impls {
-  use super::Zeroable;
-
-  #[cfg(target_has_atomic = "8")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicBool {}
-  #[cfg(target_has_atomic = "8")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicU8 {}
-  #[cfg(target_has_atomic = "8")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicI8 {}
-
-  #[cfg(target_has_atomic = "16")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicU16 {}
-  #[cfg(target_has_atomic = "16")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicI16 {}
-
-  #[cfg(target_has_atomic = "32")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicU32 {}
-  #[cfg(target_has_atomic = "32")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicI32 {}
-
-  #[cfg(target_has_atomic = "64")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicU64 {}
-  #[cfg(target_has_atomic = "64")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicI64 {}
-
-  #[cfg(target_has_atomic = "ptr")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicUsize {}
-  #[cfg(target_has_atomic = "ptr")]
-  unsafe impl Zeroable for core::sync::atomic::AtomicIsize {}
-
-  #[cfg(target_has_atomic = "ptr")]
-  unsafe impl<T> Zeroable for core::sync::atomic::AtomicPtr<T> {}
-}
-
-#[cfg(feature = "zeroable_maybe_uninit")]
-#[cfg_attr(
-  feature = "nightly_docs",
-  doc(cfg(feature = "zeroable_maybe_uninit"))
-)]
-unsafe impl<T> Zeroable for core::mem::MaybeUninit<T> {}
-
-unsafe impl<A: Zeroable> Zeroable for (A,) {}
-unsafe impl<A: Zeroable, B: Zeroable> Zeroable for (A, B) {}
-unsafe impl<A: Zeroable, B: Zeroable, C: Zeroable> Zeroable for (A, B, C) {}
-unsafe impl<A: Zeroable, B: Zeroable, C: Zeroable, D: Zeroable> Zeroable
-  for (A, B, C, D)
-{
-}
-unsafe impl<A: Zeroable, B: Zeroable, C: Zeroable, D: Zeroable, E: Zeroable>
-  Zeroable for (A, B, C, D, E)
-{
-}
-unsafe impl<
-    A: Zeroable,
-    B: Zeroable,
-    C: Zeroable,
-    D: Zeroable,
-    E: Zeroable,
-    F: Zeroable,
-  > Zeroable for (A, B, C, D, E, F)
-{
-}
-unsafe impl<
-    A: Zeroable,
-    B: Zeroable,
-    C: Zeroable,
-    D: Zeroable,
-    E: Zeroable,
-    F: Zeroable,
-    G: Zeroable,
-  > Zeroable for (A, B, C, D, E, F, G)
-{
-}
-unsafe impl<
-    A: Zeroable,
-    B: Zeroable,
-    C: Zeroable,
-    D: Zeroable,
-    E: Zeroable,
-    F: Zeroable,
-    G: Zeroable,
-    H: Zeroable,
-  > Zeroable for (A, B, C, D, E, F, G, H)
-{
-}
-
-#[cfg(feature = "min_const_generics")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "min_const_generics")))]
-unsafe impl<T, const N: usize> Zeroable for [T; N] where T: Zeroable {}
-
-#[cfg(not(feature = "min_const_generics"))]
-impl_unsafe_marker_for_array!(
-  Zeroable, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
-  19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 48, 64, 96, 128, 256,
-  512, 1024, 2048, 4096
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))]
-  unsafe impl Zeroable for wasm32::{v128}
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "aarch64", feature = "aarch64_simd"))]
-  unsafe impl Zeroable for aarch64::{
-    float32x2_t, float32x2x2_t, float32x2x3_t, float32x2x4_t, float32x4_t,
-    float32x4x2_t, float32x4x3_t, float32x4x4_t, float64x1_t, float64x1x2_t,
-    float64x1x3_t, float64x1x4_t, float64x2_t, float64x2x2_t, float64x2x3_t,
-    float64x2x4_t, int16x4_t, int16x4x2_t, int16x4x3_t, int16x4x4_t, int16x8_t,
-    int16x8x2_t, int16x8x3_t, int16x8x4_t, int32x2_t, int32x2x2_t, int32x2x3_t,
-    int32x2x4_t, int32x4_t, int32x4x2_t, int32x4x3_t, int32x4x4_t, int64x1_t,
-    int64x1x2_t, int64x1x3_t, int64x1x4_t, int64x2_t, int64x2x2_t, int64x2x3_t,
-    int64x2x4_t, int8x16_t, int8x16x2_t, int8x16x3_t, int8x16x4_t, int8x8_t,
-    int8x8x2_t, int8x8x3_t, int8x8x4_t, poly16x4_t, poly16x4x2_t, poly16x4x3_t,
-    poly16x4x4_t, poly16x8_t, poly16x8x2_t, poly16x8x3_t, poly16x8x4_t,
-    poly64x1_t, poly64x1x2_t, poly64x1x3_t, poly64x1x4_t, poly64x2_t,
-    poly64x2x2_t, poly64x2x3_t, poly64x2x4_t, poly8x16_t, poly8x16x2_t,
-    poly8x16x3_t, poly8x16x4_t, poly8x8_t, poly8x8x2_t, poly8x8x3_t, poly8x8x4_t,
-    uint16x4_t, uint16x4x2_t, uint16x4x3_t, uint16x4x4_t, uint16x8_t,
-    uint16x8x2_t, uint16x8x3_t, uint16x8x4_t, uint32x2_t, uint32x2x2_t,
-    uint32x2x3_t, uint32x2x4_t, uint32x4_t, uint32x4x2_t, uint32x4x3_t,
-    uint32x4x4_t, uint64x1_t, uint64x1x2_t, uint64x1x3_t, uint64x1x4_t,
-    uint64x2_t, uint64x2x2_t, uint64x2x3_t, uint64x2x4_t, uint8x16_t,
-    uint8x16x2_t, uint8x16x3_t, uint8x16x4_t, uint8x8_t, uint8x8x2_t,
-    uint8x8x3_t, uint8x8x4_t,
-  }
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(target_arch = "x86")]
-  unsafe impl Zeroable for x86::{
-    __m128i, __m128, __m128d,
-    __m256i, __m256, __m256d,
-  }
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(target_arch = "x86_64")]
-    unsafe impl Zeroable for x86_64::{
-        __m128i, __m128, __m128d,
-        __m256i, __m256, __m256d,
-    }
-);
-
-#[cfg(feature = "nightly_portable_simd")]
-#[cfg_attr(
-  feature = "nightly_docs",
-  doc(cfg(feature = "nightly_portable_simd"))
-)]
-unsafe impl<T, const N: usize> Zeroable for core::simd::Simd<T, N>
-where
-  T: core::simd::SimdElement + Zeroable,
-  core::simd::LaneCount<N>: core::simd::SupportedLaneCount,
-{
-}
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "x86", feature = "nightly_stdsimd"))]
-  unsafe impl Zeroable for x86::{
-    __m128bh, __m256bh, __m512,
-    __m512bh, __m512d, __m512i,
-  }
-);
-
-impl_unsafe_marker_for_simd!(
-  #[cfg(all(target_arch = "x86_64", feature = "nightly_stdsimd"))]
-  unsafe impl Zeroable for x86_64::{
-    __m128bh, __m256bh, __m512,
-    __m512bh, __m512d, __m512i,
-  }
-);
diff --git a/vendor/bytemuck/src/zeroable_in_option.rs b/vendor/bytemuck/src/zeroable_in_option.rs
deleted file mode 100644
index c4cf158..0000000
--- a/vendor/bytemuck/src/zeroable_in_option.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use super::*;
-
-// Note(Lokathor): This is the neat part!!
-unsafe impl<T: ZeroableInOption> Zeroable for Option<T> {}
-
-/// Trait for types which are [Zeroable](Zeroable) when wrapped in
-/// [Option](core::option::Option).
-///
-/// ## Safety
-///
-/// * `Option<YourType>` must uphold the same invariants as
-///   [Zeroable](Zeroable).
-pub unsafe trait ZeroableInOption: Sized {}
-
-unsafe impl ZeroableInOption for NonZeroI8 {}
-unsafe impl ZeroableInOption for NonZeroI16 {}
-unsafe impl ZeroableInOption for NonZeroI32 {}
-unsafe impl ZeroableInOption for NonZeroI64 {}
-unsafe impl ZeroableInOption for NonZeroI128 {}
-unsafe impl ZeroableInOption for NonZeroIsize {}
-unsafe impl ZeroableInOption for NonZeroU8 {}
-unsafe impl ZeroableInOption for NonZeroU16 {}
-unsafe impl ZeroableInOption for NonZeroU32 {}
-unsafe impl ZeroableInOption for NonZeroU64 {}
-unsafe impl ZeroableInOption for NonZeroU128 {}
-unsafe impl ZeroableInOption for NonZeroUsize {}
-
-// Note: this does not create NULL vtable because we get `None` anyway.
-unsafe impl<T: ?Sized> ZeroableInOption for NonNull<T> {}
-unsafe impl<T: ?Sized> ZeroableInOption for &'_ T {}
-unsafe impl<T: ?Sized> ZeroableInOption for &'_ mut T {}
-
-#[cfg(feature = "extern_crate_alloc")]
-#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "extern_crate_alloc")))]
-unsafe impl<T: ?Sized> ZeroableInOption for alloc::boxed::Box<T> {}