1 files changed, 0 insertions, 184 deletions
diff --git a/vendor/matchit/src/escape.rs b/vendor/matchit/src/escape.rs
deleted file mode 100644
index ef8ddbfb..00000000
--- a/vendor/matchit/src/escape.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use std::{fmt, ops::Range};
-
-/// An unescaped route that keeps track of the position of escaped characters ('{{' or '}}').
-///
-/// Note that this type dereferences to `&[u8]`.
-#[derive(Clone, Default)]
-pub struct UnescapedRoute {
-    // The raw unescaped route.
-    inner: Vec<u8>,
-    escaped: Vec<usize>,
-}
-
-impl UnescapedRoute {
-    /// Unescapes escaped brackets ('{{' or '}}') in a route.
-    pub fn new(mut inner: Vec<u8>) -> UnescapedRoute {
-        let mut escaped = Vec::new();
-        let mut i = 0;
-
-        while let Some(&c) = inner.get(i) {
-            if (c == b'{' && inner.get(i + 1) == Some(&b'{'))
-                || (c == b'}' && inner.get(i + 1) == Some(&b'}'))
-            {
-                inner.remove(i);
-                escaped.push(i);
-            }
-
-            i += 1;
-        }
-
-        UnescapedRoute { inner, escaped }
-    }
-
-    /// Returns true if the character at the given index was escaped.
-    pub fn is_escaped(&self, i: usize) -> bool {
-        self.escaped.contains(&i)
-    }
-
-    /// Replaces the characters in the given range.
-    pub fn splice(
-        &mut self,
-        range: Range<usize>,
-        replace: Vec<u8>,
-    ) -> impl Iterator<Item = u8> + '_ {
-        // Ignore any escaped characters in the range being replaced.
-        self.escaped.retain(|x| !range.contains(x));
-
-        // Update the escaped indices.
-        let offset = (replace.len() as isize) - (range.len() as isize);
-        for i in &mut self.escaped {
-            if *i > range.end {
-                *i = i.checked_add_signed(offset).unwrap();
-            }
-        }
-
-        self.inner.splice(range, replace)
-    }
-
-    /// Appends another route to the end of this one.
-    pub fn append(&mut self, other: &UnescapedRoute) {
-        for i in &other.escaped {
-            self.escaped.push(self.inner.len() + i);
-        }
-
-        self.inner.extend_from_slice(&other.inner);
-    }
-
-    /// Truncates the route to the given length.
-    pub fn truncate(&mut self, to: usize) {
-        self.escaped.retain(|&x| x < to);
-        self.inner.truncate(to);
-    }
-
-    /// Returns a reference to this route.
-    pub fn as_ref(&self) -> UnescapedRef<'_> {
-        UnescapedRef {
-            inner: &self.inner,
-            escaped: &self.escaped,
-            offset: 0,
-        }
-    }
-
-    /// Returns a reference to the unescaped slice.
-    pub fn unescaped(&self) -> &[u8] {
-        &self.inner
-    }
-
-    /// Returns the unescaped route.
-    pub fn into_unescaped(self) -> Vec<u8> {
-        self.inner
-    }
-}
-
-impl std::ops::Deref for UnescapedRoute {
-    type Target = [u8];
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl fmt::Debug for UnescapedRoute {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(std::str::from_utf8(&self.inner).unwrap(), f)
-    }
-}
-
-/// A reference to an `UnescapedRoute`.
-#[derive(Copy, Clone)]
-pub struct UnescapedRef<'a> {
-    pub inner: &'a [u8],
-    escaped: &'a [usize],
-    // An offset applied to each escaped index.
-    offset: isize,
-}
-
-impl<'a> UnescapedRef<'a> {
-    /// Converts this reference into an owned route.
-    pub fn to_owned(self) -> UnescapedRoute {
-        let mut escaped = Vec::new();
-        for &i in self.escaped {
-            let i = i.checked_add_signed(self.offset);
-
-            match i {
-                Some(i) if i < self.inner.len() => escaped.push(i),
-                _ => {}
-            }
-        }
-
-        UnescapedRoute {
-            escaped,
-            inner: self.inner.to_owned(),
-        }
-    }
-
-    /// Returns `true` if the character at the given index was escaped.
-    pub fn is_escaped(&self, i: usize) -> bool {
-        if let Some(i) = i.checked_add_signed(-self.offset) {
-            return self.escaped.contains(&i);
-        }
-
-        false
-    }
-
-    /// Slices the route with `start..`.
-    pub fn slice_off(&self, start: usize) -> UnescapedRef<'a> {
-        UnescapedRef {
-            inner: &self.inner[start..],
-            escaped: self.escaped,
-            offset: self.offset - (start as isize),
-        }
-    }
-
-    /// Slices the route with `..end`.
-    pub fn slice_until(&self, end: usize) -> UnescapedRef<'a> {
-        UnescapedRef {
-            inner: &self.inner[..end],
-            escaped: self.escaped,
-            offset: self.offset,
-        }
-    }
-
-    /// Returns a reference to the unescaped slice.
-    pub fn unescaped(&self) -> &[u8] {
-        self.inner
-    }
-}
-
-impl<'a> std::ops::Deref for UnescapedRef<'a> {
-    type Target = &'a [u8];
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<'a> fmt::Debug for UnescapedRef<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("UnescapedRef")
-            .field("inner", &std::str::from_utf8(self.inner))
-            .field("escaped", &self.escaped)
-            .field("offset", &self.offset)
-            .finish()
-    }
-}