diff --git a/examples/hello.rs b/examples/hello.rs
index ad26e60..715d50d 100644
--- a/examples/hello.rs
+++ b/examples/hello.rs
@@ -76,7 +76,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     // │   ├── rust •3
     // │   └── ** •1
     // └── POST/login •4
-    let mut tree = PathTree::<'static, Box<dyn Handler>>::new();
+    let mut tree = PathTree::<Box<dyn Handler>>::new();
     tree.insert("/GET/", Box::new(index));
     tree.insert("/GET/*", Box::new(hello_world));
     tree.insert("/GET/hello/:name", Box::new(hello_user));
diff --git a/src/lib.rs b/src/lib.rs
index 7798235..3432952 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -135,9 +135,10 @@
 #![forbid(unsafe_code)]
 #![warn(rust_2018_idioms, unreachable_pub)]
 
-use smallvec::SmallVec;
 use std::str::from_utf8;
 
+use smallvec::SmallVec;
+
 mod node;
 mod parser;
 
@@ -145,28 +146,28 @@ pub use node::{Node, NodeKind};
 pub use parser::{Kind, Parser, Piece, Position};
 
 #[derive(Debug)]
-pub struct PathTree<'a, T> {
+pub struct PathTree<T> {
     id: usize,
-    routes: Vec<(T, Vec<Piece<'a>>)>,
-    pub node: Node<'a, usize>,
+    routes: Vec<(T, Vec<Piece>)>,
+    pub node: Node<usize>,
 }
 
-impl<'a, T> Default for PathTree<'a, T> {
+impl<T> Default for PathTree<T> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<'a, T> PathTree<'a, T> {
+impl<T> PathTree<T> {
     pub fn new() -> Self {
         Self {
             id: 0,
             routes: Vec::new(),
-            node: Node::new(NodeKind::String("".as_bytes()), None),
+            node: Node::new(NodeKind::String("".as_bytes().to_vec()), None),
         }
     }
 
-    pub fn insert(&mut self, path: &'a str, value: T) -> usize {
+    pub fn insert(&mut self, path: &str, value: T) -> usize {
         if path.is_empty() {
             return self.id;
         }
@@ -177,7 +178,7 @@ impl<'a, T> PathTree<'a, T> {
         for piece in &pieces {
             match piece {
                 Piece::String(s) => {
-                    node = node.insert_bytes(s);
+                    node = node.insert_bytes(&s[..]);
                 }
                 Piece::Parameter(_, k) => {
                     node = node.insert_parameter(*k);
@@ -196,7 +197,7 @@ impl<'a, T> PathTree<'a, T> {
         }
     }
 
-    pub fn find<'b>(&'a self, path: &'b str) -> Option<Path<'a, 'b, T>> {
+    pub fn find<'b>(&self, path: &'b str) -> Option<Path<'_, 'b, T>> {
         let bytes = path.as_bytes();
         self.node.find(bytes).and_then(|(id, ranges)| {
             self.get_route(*id).map(|(value, pieces)| {
@@ -206,8 +207,8 @@ impl<'a, T> PathTree<'a, T> {
                     pieces,
                     // opt!
                     raws: ranges
-                        .chunks(2)
-                        .map(|r| from_utf8(&bytes[r[0]..r[1]]).unwrap())
+                        .into_iter()
+                        .map(|r| from_utf8(&bytes[r]).unwrap())
                         .rev()
                         .collect(),
                 }
@@ -216,7 +217,7 @@ impl<'a, T> PathTree<'a, T> {
     }
 
     #[inline]
-    pub fn get_route(&self, index: usize) -> Option<&(T, Vec<Piece<'a>>)> {
+    pub fn get_route(&self, index: usize) -> Option<&(T, Vec<Piece>)> {
         self.routes.get(index)
     }
 
@@ -246,7 +247,7 @@ impl<'a, T> PathTree<'a, T> {
 pub struct Path<'a, 'b, T> {
     pub id: &'a usize,
     pub value: &'a T,
-    pub pieces: &'a [Piece<'a>],
+    pub pieces: &'a [Piece],
     pub raws: SmallVec<[&'b str; 4]>,
 }
 
diff --git a/src/node.rs b/src/node.rs
index 024615d..8ff71dc 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -1,28 +1,30 @@
-use smallvec::SmallVec;
 use std::{
     cmp::Ordering,
     fmt::{self, Write},
+    ops::Range,
 };
 
+use smallvec::SmallVec;
+
 use crate::Kind;
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum NodeKind<'a> {
-    String(&'a [u8]),
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum NodeKind {
+    String(Vec<u8>),
     Parameter(Kind),
 }
 
-pub struct Node<'a, T> {
+pub struct Node<T> {
     pub value: Option<T>,
-    pub kind: NodeKind<'a>,
+    pub kind: NodeKind,
     /// Stores string node
     pub nodes0: Option<Vec<Self>>,
     /// Stores parameter node
     pub nodes1: Option<Vec<Self>>,
 }
 
-impl<'a, T: fmt::Debug> Node<'a, T> {
-    pub fn new(kind: NodeKind<'a>, value: Option<T>) -> Self {
+impl<T: fmt::Debug> Node<T> {
+    pub fn new(kind: NodeKind, value: Option<T>) -> Self {
         Self {
             kind,
             value,
@@ -31,11 +33,11 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
         }
     }
 
-    pub fn insert_bytes(&mut self, mut bytes: &'a [u8]) -> &mut Self {
+    pub fn insert_bytes(&mut self, mut bytes: &[u8]) -> &mut Self {
         let (cursor, diff) = match &mut self.kind {
             NodeKind::String(p) => {
                 if p.is_empty() {
-                    *p = bytes;
+                    *p = bytes.to_vec();
                     return self;
                 }
 
@@ -53,8 +55,8 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                         // split node
                         if cursor < p.len() {
                             let (prefix, suffix) = p.split_at(cursor);
-                            let mut node = Node::new(NodeKind::String(prefix), None);
-                            *p = suffix;
+                            let mut node = Node::new(NodeKind::String(prefix.to_vec()), None);
+                            *p = suffix.to_vec();
                             ::std::mem::swap(self, &mut node);
                             self.nodes0.get_or_insert_with(Vec::new).push(node);
                         }
@@ -69,7 +71,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
         if diff {
             bytes = &bytes[cursor..];
             let nodes = self.nodes0.get_or_insert_with(Vec::new);
-            return match nodes.binary_search_by(|node| match node.kind {
+            return match nodes.binary_search_by(|node| match &node.kind {
                 NodeKind::String(s) => {
                     // s[0].cmp(&bytes[0])
                     // opt!
@@ -80,7 +82,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
             }) {
                 Ok(i) => nodes[i].insert_bytes(bytes),
                 Err(i) => {
-                    nodes.insert(i, Node::new(NodeKind::String(bytes), None));
+                    nodes.insert(i, Node::new(NodeKind::String(bytes.to_vec()), None));
                     &mut nodes[i]
                 }
             };
@@ -108,10 +110,10 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
         &self,
         mut start: usize,
         mut bytes: &[u8],
-        ranges: &mut SmallVec<[usize; 8]>,
+        ranges: &mut SmallVec<[Range<usize>; 8]>,
     ) -> Option<&T> {
         let mut m = bytes.len();
-        match self.kind {
+        match &self.kind {
             NodeKind::String(s) => {
                 let n = s.len();
                 let mut flag = m >= n;
@@ -139,7 +141,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                         // static
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
                             nodes
-                                .binary_search_by(|node| match node.kind {
+                                .binary_search_by(|node| match &node.kind {
                                     NodeKind::String(s) => {
                                         // s[0].cmp(&bytes[0])
                                         // opt!
@@ -262,14 +264,13 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                 // }
                 Kind::Normal | Kind::Optional | Kind::OptionalSegment => {
                     if m == 0 {
-                        if k == Kind::Normal {
+                        if k == &Kind::Normal {
                             return None;
                         } else {
                             // last
                             if self.nodes0.is_none() && self.nodes1.is_none() {
                                 return self.value.as_ref().map(|id| {
-                                    ranges.push(start);
-                                    ranges.push(start);
+                                    ranges.push(start..start);
                                     id
                                 });
                             }
@@ -277,12 +278,11 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                     } else {
                         // static
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
-                            nodes.iter().find_map(|node| match node.kind {
+                            nodes.iter().find_map(|node| match &node.kind {
                                 NodeKind::String(s) => {
                                     bytes.iter().position(|b| s[0] == *b).and_then(|n| {
                                         node._find(start + n, &bytes[n..], ranges).map(|id| {
-                                            ranges.push(start);
-                                            ranges.push(start + n);
+                                            ranges.push(start..start + n);
                                             id
                                         })
                                     })
@@ -308,21 +308,20 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                                 })
                                 .find_map(|node| node._find(start + 1, &bytes[1..], ranges))
                         }) {
-                            ranges.push(start);
-                            ranges.push(start + 1);
+                            ranges.push(start..start + 1);
                             return Some(id);
                         }
                     }
 
                     // parameter => `:a:b?:c?`
-                    if k == Kind::Optional || k == Kind::OptionalSegment {
+                    if k == &Kind::Optional || k == &Kind::OptionalSegment {
                         if let Some(id) = self.nodes1.as_ref().and_then(|nodes| {
                             let b = m > 0;
                             nodes
                                 .iter()
-                                .filter(|node| match node.kind {
+                                .filter(|node| match &node.kind {
                                     NodeKind::Parameter(pk)
-                                        if pk == Kind::Normal || pk == Kind::OneOrMore =>
+                                        if pk == &Kind::Normal || pk == &Kind::OneOrMore =>
                                     {
                                         b
                                     }
@@ -331,8 +330,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                                 .find_map(|node| node._find(start, bytes, ranges))
                         }) {
                             // param should be empty
-                            ranges.push(start + m);
-                            ranges.push(start + m);
+                            ranges.push(start + m..start + m);
                             return Some(id);
                         }
                     }
@@ -341,31 +339,29 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                         bytes = &bytes[n..];
                     } else {
                         if let Some(id) = &self.value {
-                            ranges.push(start);
-                            ranges.push(start + m);
+                            ranges.push(start..start + m);
                             return Some(id);
                         }
                         bytes = &bytes[m..];
                     }
 
-                    if k == Kind::OptionalSegment {
+                    if k == &Kind::OptionalSegment {
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
                             nodes
                                 .last()
-                                .filter(|node| match node.kind {
+                                .filter(|node| match &node.kind {
                                     NodeKind::String(s) => s[0] == b'/',
                                     _ => unreachable!(),
                                 })
                                 .and_then(|node| node._find(start, bytes, ranges))
                         }) {
-                            ranges.push(start);
-                            ranges.push(start + m);
+                            ranges.push(start..start + m);
                             return Some(id);
                         }
                     }
                 }
                 Kind::OneOrMore | Kind::ZeroOrMore | Kind::ZeroOrMoreSegment => {
-                    let is_one_or_more = k == Kind::OneOrMore;
+                    let is_one_or_more = k == &Kind::OneOrMore;
                     if m == 0 {
                         if is_one_or_more {
                             return None;
@@ -373,8 +369,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                             // last
                             if self.nodes0.is_none() && self.nodes1.is_none() {
                                 return self.value.as_ref().map(|id| {
-                                    ranges.push(start);
-                                    ranges.push(start);
+                                    ranges.push(start..start);
                                     id
                                 });
                             }
@@ -382,8 +377,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                     } else {
                         if self.nodes0.is_none() && self.nodes1.is_none() {
                             if let Some(id) = &self.value {
-                                ranges.push(start);
-                                ranges.push(start + m);
+                                ranges.push(start..start + m);
                                 return Some(id);
                             }
                         }
@@ -391,7 +385,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                         // static
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
                             nodes.iter().find_map(|node| {
-                                if let NodeKind::String(s) = node.kind {
+                                if let NodeKind::String(s) = &node.kind {
                                     let right_length = if is_one_or_more {
                                         m > s.len()
                                     } else {
@@ -407,8 +401,7 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                                             .find_map(|n| {
                                                 node._find(start + n, &bytes[n..], ranges).map(
                                                     |id| {
-                                                        ranges.push(start);
-                                                        ranges.push(start + n);
+                                                        ranges.push(start..start + n);
                                                         id
                                                     },
                                                 )
@@ -422,19 +415,18 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
                         }
                     }
 
-                    if k == Kind::ZeroOrMoreSegment {
+                    if k == &Kind::ZeroOrMoreSegment {
                         if let Some(id) = self.nodes0.as_ref().and_then(|nodes| {
                             nodes
                                 .last()
-                                .filter(|node| match node.kind {
+                                .filter(|node| match &node.kind {
                                     NodeKind::String(s) => s[0] == b'/',
                                     _ => unreachable!(),
                                 })
                                 .and_then(|node| node._find(start, bytes, ranges))
                         }) {
                             // param should be empty
-                            ranges.push(start + m);
-                            ranges.push(start + m);
+                            ranges.push(start + m..start + m);
                             return Some(id);
                         }
                     }
@@ -444,22 +436,22 @@ impl<'a, T: fmt::Debug> Node<'a, T> {
         None
     }
 
-    pub fn find<'b>(&self, bytes: &'b [u8]) -> Option<(&T, SmallVec<[usize; 8]>)> {
-        let mut ranges = SmallVec::<[usize; 8]>::new(); // opt!
+    pub fn find<'b>(&self, bytes: &'b [u8]) -> Option<(&T, SmallVec<[Range<usize>; 8]>)> {
+        let mut ranges = SmallVec::<[Range<usize>; 8]>::new(); // opt!
         return self._find(0, bytes, &mut ranges).map(|t| (t, ranges));
     }
 }
 
-impl<'a, T: fmt::Debug> fmt::Debug for Node<'a, T> {
+impl<T: fmt::Debug> fmt::Debug for Node<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         const EDGE: &str = "├──";
         const LINE: &str = "│  ";
         const CORNER: &str = "└──";
         const BLANK: &str = "   ";
 
-        fn print_nodes<'a, T: fmt::Debug>(
+        fn print_nodes<T: fmt::Debug>(
             f: &mut fmt::Formatter<'_>,
-            nodes: &Vec<Node<'a, T>>,
+            nodes: &Vec<Node<T>>,
             check: bool,
             pad: &str,
             space: &str,
@@ -478,9 +470,9 @@ impl<'a, T: fmt::Debug> fmt::Debug for Node<'a, T> {
             Ok(())
         }
 
-        fn print_tree<'a, T: fmt::Debug>(
+        fn print_tree<T: fmt::Debug>(
             f: &mut fmt::Formatter<'_>,
-            node: &Node<'a, T>,
+            node: &Node<T>,
             root: bool,
             pad: &str,
         ) -> fmt::Result {
diff --git a/src/parser.rs b/src/parser.rs
index 5dea3dd..c51c792 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, iter::Peekable, str::CharIndices};
+use std::{iter::Peekable, str::CharIndices};
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Kind {
@@ -22,15 +22,15 @@ pub enum Kind {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Piece<'a> {
-    String(&'a [u8]),
-    Parameter(Position<'a>, Kind),
+pub enum Piece {
+    String(Vec<u8>),
+    Parameter(Position, Kind),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Position<'a> {
-    Index(usize, Cow<'a, [u8]>),
-    Named(Cow<'a, [u8]>),
+pub enum Position {
+    Index(usize, Vec<u8>),
+    Named(Vec<u8>),
 }
 
 pub struct Parser<'a> {
@@ -85,14 +85,14 @@ impl<'a> Parser<'a> {
         self.input[start..].as_bytes()
     }
 
-    fn parameter(&mut self) -> (Position<'a>, Kind) {
+    fn parameter(&mut self) -> (Position, Kind) {
         let start = self.pos;
         while let Some(&(i, c)) = self.cursor.peek() {
             match c {
                 '-' | '.' | '~' | '/' | '\\' | ':' => {
                     self.pos = i;
                     return (
-                        Position::Named(Cow::Borrowed(self.input[start..i].as_bytes())),
+                        Position::Named(self.input[start..i].as_bytes().to_vec()),
                         Kind::Normal,
                     );
                 }
@@ -100,7 +100,7 @@ impl<'a> Parser<'a> {
                     self.cursor.next();
                     self.pos = i + 1;
                     return (
-                        Position::Named(Cow::Borrowed(self.input[start..i].as_bytes())),
+                        Position::Named(self.input[start..i].as_bytes().to_vec()),
                         if c == '+' {
                             Kind::OneOrMore
                         } else {
@@ -138,14 +138,14 @@ impl<'a> Parser<'a> {
         }
 
         (
-            Position::Named(Cow::Borrowed(self.input[start..].as_bytes())),
+            Position::Named(self.input[start..].as_bytes().to_vec()),
             Kind::Normal,
         )
     }
 }
 
 impl<'a> Iterator for Parser<'a> {
-    type Item = Piece<'a>;
+    type Item = Piece;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.cursor.peek() {
@@ -163,7 +163,7 @@ impl<'a> Iterator for Parser<'a> {
                     Some(Piece::Parameter(
                         Position::Index(
                             self.count,
-                            Cow::Owned(format!("{}{}", c, self.count).as_bytes().to_owned()),
+                            format!("{}{}", c, self.count).as_bytes().to_owned(),
                         ),
                         if c == '+' {
                             Kind::OneOrMore
@@ -186,7 +186,7 @@ impl<'a> Iterator for Parser<'a> {
                         },
                     ))
                 }
-                _ => Some(Piece::String(self.string())),
+                _ => Some(Piece::String(self.string().to_vec())),
             },
             None => None,
         }
diff --git a/tests/node.rs b/tests/node.rs
index e557214..ade7298 100644
--- a/tests/node.rs
+++ b/tests/node.rs
@@ -2,7 +2,7 @@ use path_tree::*;
 
 #[test]
 fn github_nodes() {
-    let mut node = Node::<'static, usize>::new(NodeKind::String(b"/"), None);
+    let mut node = Node::<usize>::new(NodeKind::String(b"/".to_vec()), None);
 
     let mut n = node.insert_bytes(b"/");
     n = n.insert_parameter(Kind::Normal);
diff --git a/tests/parser.rs b/tests/parser.rs
index 03731a3..d00c334 100644
--- a/tests/parser.rs
+++ b/tests/parser.rs
@@ -1,352 +1,327 @@
 use path_tree::*;
-use std::borrow::Cow;
 
 #[test]
 fn parses() {
     assert_eq!(
         Parser::new(r"/shop/product/\::filter/color\::color/size\::size").collect::<Vec<_>>(),
         [
-            Piece::String(b"/shop/product/"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"filter")), Kind::Normal),
-            Piece::String(b"/color"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"color")), Kind::Normal),
-            Piece::String(b"/size"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"size")), Kind::Normal),
+            Piece::String(b"/shop/product/".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"filter".to_vec()), Kind::Normal),
+            Piece::String(b"/color".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"color".to_vec()), Kind::Normal),
+            Piece::String(b"/size".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"size".to_vec()), Kind::Normal),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:param/abc/*").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/abc/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/abc/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:param/+").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"+1")), Kind::OneOrMore),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"+1".to_vec()), Kind::OneOrMore),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:param?").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"param")),
-                Kind::OptionalSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::OptionalSegment),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:param?").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"param")),
-                Kind::OptionalSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::OptionalSegment),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:param").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/*").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:param-:param2").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"-"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param2")), Kind::Normal),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"-".to_vec()),
+            Piece::Parameter(Position::Named(b"param2".to_vec()), Kind::Normal),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/:filename.:extension").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"filename")), Kind::Normal),
-            Piece::String(b"."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"extension")), Kind::Normal),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"filename".to_vec()), Kind::Normal),
+            Piece::String(b".".to_vec()),
+            Piece::Parameter(Position::Named(b"extension".to_vec()), Kind::Normal),
         ],
     );
 
     assert_eq!(
         Parser::new("/api/v1/string").collect::<Vec<_>>(),
-        [Piece::String(b"/api/v1/string"),],
+        [Piece::String(b"/api/v1/string".to_vec()),],
     );
 
     assert_eq!(
         Parser::new(r"/\::param?").collect::<Vec<_>>(),
         [
-            Piece::String(b"/"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Optional),
+            Piece::String(b"/".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Optional),
         ],
     );
 
     assert_eq!(
         Parser::new("/:param1:param2?:param3").collect::<Vec<_>>(),
         [
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param1")), Kind::Normal),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param2")), Kind::Optional),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param3")), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param1".to_vec()), Kind::Normal),
+            Piece::Parameter(Position::Named(b"param2".to_vec()), Kind::Optional),
+            Piece::Parameter(Position::Named(b"param3".to_vec()), Kind::Normal),
         ],
     );
 
     assert_eq!(
         Parser::new("/test:sign:param").collect::<Vec<_>>(),
         [
-            Piece::String(b"/test"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"sign")), Kind::Normal),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
+            Piece::String(b"/test".to_vec()),
+            Piece::Parameter(Position::Named(b"sign".to_vec()), Kind::Normal),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
         ],
     );
 
     assert_eq!(
         Parser::new("/foo:param?bar").collect::<Vec<_>>(),
         [
-            Piece::String(b"/foo"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Optional),
-            Piece::String(b"bar"),
+            Piece::String(b"/foo".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Optional),
+            Piece::String(b"bar".to_vec()),
         ],
     );
 
     assert_eq!(
         Parser::new("/foo*bar").collect::<Vec<_>>(),
         [
-            Piece::String(b"/foo"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b"bar"),
+            Piece::String(b"/foo".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"bar".to_vec()),
         ],
     );
 
     assert_eq!(
         Parser::new("/foo+bar").collect::<Vec<_>>(),
         [
-            Piece::String(b"/foo"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"+1")), Kind::OneOrMore),
-            Piece::String(b"bar"),
+            Piece::String(b"/foo".to_vec()),
+            Piece::Parameter(Position::Index(1, b"+1".to_vec()), Kind::OneOrMore),
+            Piece::String(b"bar".to_vec()),
         ],
     );
 
     assert_eq!(
         Parser::new("/a*cde*g/").collect::<Vec<_>>(),
         [
-            Piece::String(b"/a"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b"cde"),
-            Piece::Parameter(Position::Index(2, Cow::Borrowed(b"*2")), Kind::ZeroOrMore),
-            Piece::String(b"g/"),
+            Piece::String(b"/a".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"cde".to_vec()),
+            Piece::Parameter(Position::Index(2, b"*2".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"g/".to_vec()),
         ],
     );
 
     assert_eq!(
         Parser::new(r"/name\::name").collect::<Vec<_>>(),
         [
-            Piece::String(b"/name"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/name".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
 
     assert_eq!(
         Parser::new("/@:name").collect::<Vec<_>>(),
         [
-            Piece::String(b"/@"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/@".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
 
     assert_eq!(
         Parser::new("/-:name").collect::<Vec<_>>(),
         [
-            Piece::String(b"/-"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/-".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
 
     assert_eq!(
         Parser::new("/.:name").collect::<Vec<_>>(),
         [
-            Piece::String(b"/."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/.".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
 
     assert_eq!(
         Parser::new("/_:name").collect::<Vec<_>>(),
         [
-            Piece::String(b"/_"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/_".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
 
     assert_eq!(
         Parser::new("/~:name").collect::<Vec<_>>(),
         [
-            Piece::String(b"/~"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/~".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
 
     assert_eq!(
         Parser::new("/v1/some/resource/name\\:customVerb").collect::<Vec<_>>(),
         [
-            Piece::String(b"/v1/some/resource/name"),
-            Piece::String(b":"),
-            Piece::String(b"customVerb"),
+            Piece::String(b"/v1/some/resource/name".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::String(b"customVerb".to_vec()),
         ],
     );
 
     assert_eq!(
         Parser::new("/v1/some/resource/:name\\:customVerb").collect::<Vec<_>>(),
         [
-            Piece::String(b"/v1/some/resource/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
-            Piece::String(b":"),
-            Piece::String(b"customVerb"),
+            Piece::String(b"/v1/some/resource/".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
+            Piece::String(b":".to_vec()),
+            Piece::String(b"customVerb".to_vec()),
         ],
     );
 
     assert_eq!(
         Parser::new("/v1/some/resource/name\\:customVerb??/:param/*").collect::<Vec<_>>(),
         [
-            Piece::String(b"/v1/some/resource/name"),
-            Piece::String(b":"),
-            Piece::String(b"customVerb??/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            )
+            Piece::String(b"/v1/some/resource/name".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::String(b"customVerb??/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment)
         ],
     );
 
     assert_eq!(
         Parser::new("/api/*/:param/:param2").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param2")), Kind::Normal)
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param2".to_vec()), Kind::Normal)
         ],
     );
 
     assert_eq!(
         Parser::new("/test:optional?:optional2?").collect::<Vec<_>>(),
         [
-            Piece::String(b"/test"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"optional")), Kind::Optional),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"optional2")), Kind::Optional)
+            Piece::String(b"/test".to_vec()),
+            Piece::Parameter(Position::Named(b"optional".to_vec()), Kind::Optional),
+            Piece::Parameter(Position::Named(b"optional2".to_vec()), Kind::Optional)
         ],
     );
 
     assert_eq!(
         Parser::new("/config/+.json").collect::<Vec<_>>(),
         [
-            Piece::String(b"/config/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"+1")), Kind::OneOrMore),
-            Piece::String(b".json")
+            Piece::String(b"/config/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"+1".to_vec()), Kind::OneOrMore),
+            Piece::String(b".json".to_vec()),
         ]
     );
 
     assert_eq!(
         Parser::new("/config/*.json").collect::<Vec<_>>(),
         [
-            Piece::String(b"/config/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b".json")
+            Piece::String(b"/config/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b".json".to_vec()),
         ]
     );
 
     assert_eq!(
         Parser::new("/api/:day.:month?.:year?").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"day")), Kind::Normal),
-            Piece::String(b"."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"month")), Kind::Optional),
-            Piece::String(b"."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"year")), Kind::Optional),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Named(b"day".to_vec()), Kind::Normal),
+            Piece::String(b".".to_vec()),
+            Piece::Parameter(Position::Named(b"month".to_vec()), Kind::Optional),
+            Piece::String(b".".to_vec()),
+            Piece::Parameter(Position::Named(b"year".to_vec()), Kind::Optional),
         ]
     );
 
     assert_eq!(
         Parser::new("/api/:day/:month?/:year?").collect::<Vec<_>>(),
         [
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"day")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"month")),
-                Kind::OptionalSegment
-            ),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"year")),
-                Kind::OptionalSegment
-            ),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Named(b"day".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"month".to_vec()), Kind::OptionalSegment),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"year".to_vec()), Kind::OptionalSegment),
         ]
     );
 
     assert_eq!(
         Parser::new("/*v1*/proxy").collect::<Vec<_>>(),
         [
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b"v1"),
-            Piece::Parameter(Position::Index(2, Cow::Borrowed(b"*2")), Kind::ZeroOrMore),
-            Piece::String(b"/proxy")
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"v1".to_vec()),
+            Piece::Parameter(Position::Index(2, b"*2".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"/proxy".to_vec()),
         ]
     );
 
     assert_eq!(
         Parser::new("/:a*v1:b+/proxy").collect::<Vec<_>>(),
         [
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"a")), Kind::ZeroOrMore),
-            Piece::String(b"v1"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"b")), Kind::OneOrMore),
-            Piece::String(b"/proxy")
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"a".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"v1".to_vec()),
+            Piece::Parameter(Position::Named(b"b".to_vec()), Kind::OneOrMore),
+            Piece::String(b"/proxy".to_vec()),
         ]
     );
 }
diff --git a/tests/tree.rs b/tests/tree.rs
index 68db9ae..8e0e55c 100644
--- a/tests/tree.rs
+++ b/tests/tree.rs
@@ -1,5 +1,3 @@
-use std::borrow::Cow;
-
 use path_tree::*;
 use rand::seq::SliceRandom;
 
@@ -23,7 +21,7 @@ fn statics() {
 
     routes.shuffle(&mut rand::thread_rng());
 
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     for (i, u) in routes.iter().enumerate() {
         tree.insert(u, i);
@@ -474,7 +472,7 @@ fn match_params() {
     //     └── :
     //         └── /
     //             └── ** •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/:param/*", 1);
 
@@ -487,13 +485,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
         ]
     );
 
@@ -514,7 +509,7 @@ fn match_params() {
     //     └── :
     //         └── /
     //             └── + •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/:param/+", 1);
 
@@ -536,7 +531,7 @@ fn match_params() {
     // /
     // └── api/v1/
     //     └── ?? •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/:param?", 1);
 
@@ -548,11 +543,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"param")),
-                Kind::OptionalSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::OptionalSegment),
         ]
     );
 
@@ -565,7 +557,7 @@ fn match_params() {
     // └── v1/some/resource/name
     //     └── \:
     //         └── customVerb •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/v1/some/resource/name\\:customVerb", 1);
 
@@ -577,9 +569,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/v1/some/resource/name"),
-            Piece::String(b":"),
-            Piece::String(b"customVerb"),
+            Piece::String(b"/v1/some/resource/name".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::String(b"customVerb".to_vec()),
         ]
     );
     assert_eq!(tree.find("/v1/some/resource/name:test"), None);
@@ -589,7 +581,7 @@ fn match_params() {
     //     └── :
     //         └── \:
     //             └── customVerb •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert(r"/v1/some/resource/:name\:customVerb", 1);
 
@@ -600,10 +592,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/v1/some/resource/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
-            Piece::String(b":"),
-            Piece::String(b"customVerb"),
+            Piece::String(b"/v1/some/resource/".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
+            Piece::String(b":".to_vec()),
+            Piece::String(b"customVerb".to_vec()),
         ]
     );
     assert_eq!(tree.find("/v1/some/resource/test:test"), None);
@@ -617,7 +609,7 @@ fn match_params() {
     //                     └── :
     //                         └── /
     //                             └── ** •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert(r"/v1/some/resource/name\\\\:customVerb?\?/:param/*", 1);
 
@@ -641,7 +633,7 @@ fn match_params() {
     // /
     // └── api/v1/
     //     └── ** •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/*", 1);
 
@@ -666,7 +658,7 @@ fn match_params() {
     // /
     // └── api/v1/
     //     └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/:param", 1);
 
@@ -695,7 +687,7 @@ fn match_params() {
     //         │   └── : •2
     //         └── /
     //             └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/:param/:param2", 3);
     tree.insert("/api/v1/:param-:param2", 1);
@@ -737,7 +729,7 @@ fn match_params() {
 
     // /
     // └── api/v1/const •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/const", 1);
 
@@ -746,7 +738,7 @@ fn match_params() {
     assert_eq!(*p.value, 1);
     assert!(p.params().is_empty());
     assert_eq!(p.pattern(), "/api/v1/const");
-    assert_eq!(p.pieces, vec![Piece::String(b"/api/v1/const")]);
+    assert_eq!(p.pieces, vec![Piece::String(b"/api/v1/const".to_vec())]);
 
     assert_eq!(tree.find("/api/v1/cons"), None);
     assert_eq!(tree.find("/api/v1/conststatic"), None);
@@ -758,7 +750,7 @@ fn match_params() {
     // └── api/
     //     └── :
     //         └── /fixedEnd •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/:param/fixedEnd", 1);
 
@@ -768,9 +760,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/fixedEnd"),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/fixedEnd".to_vec()),
         ]
     );
     assert_eq!(p.params(), vec![("param", "abc")]);
@@ -788,7 +780,7 @@ fn match_params() {
     //                         └── /size
     //                             └── \:
     //                                 └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert(r"/shop/product/\::filter/color\::color/size\::size", 1);
 
@@ -798,15 +790,15 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/shop/product/"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"filter")), Kind::Normal),
-            Piece::String(b"/color"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"color")), Kind::Normal),
-            Piece::String(b"/size"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"size")), Kind::Normal),
+            Piece::String(b"/shop/product/".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"filter".to_vec()), Kind::Normal),
+            Piece::String(b"/color".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"color".to_vec()), Kind::Normal),
+            Piece::String(b"/size".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"size".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(
@@ -823,7 +815,7 @@ fn match_params() {
     // /
     // └── \:
     //     └── ? •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/\\::param?", 1);
 
@@ -835,9 +827,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Optional),
+            Piece::String(b"/".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Optional),
         ]
     );
 
@@ -851,7 +843,7 @@ fn match_params() {
     // └── test
     //     └── :
     //         └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/test:sign:param", 1);
 
@@ -863,9 +855,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/test"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"sign")), Kind::Normal),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
+            Piece::String(b"/test".to_vec()),
+            Piece::Parameter(Position::Named(b"sign".to_vec()), Kind::Normal),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
         ]
     );
 
@@ -880,7 +872,7 @@ fn match_params() {
     // └── :
     //     └── ?
     //         └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/:param1:param2?:param3", 1);
 
@@ -895,10 +887,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param1")), Kind::Normal),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param2")), Kind::Optional),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param3")), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param1".to_vec()), Kind::Normal),
+            Piece::Parameter(Position::Named(b"param2".to_vec()), Kind::Optional),
+            Piece::Parameter(Position::Named(b"param3".to_vec()), Kind::Normal),
         ]
     );
 
@@ -915,7 +907,7 @@ fn match_params() {
     // └── test
     //     └── ?
     //         └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/test:optional?:mandatory", 1);
 
@@ -927,9 +919,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/test"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"optional")), Kind::Optional),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"mandatory")), Kind::Normal),
+            Piece::String(b"/test".to_vec()),
+            Piece::Parameter(Position::Named(b"optional".to_vec()), Kind::Optional),
+            Piece::Parameter(Position::Named(b"mandatory".to_vec()), Kind::Normal),
         ]
     );
 
@@ -944,7 +936,7 @@ fn match_params() {
     // └── test
     //     └── ?
     //         └── ? •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/test:optional?:optional2?", 1);
 
@@ -956,9 +948,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/test"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"optional")), Kind::Optional),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"optional2")), Kind::Optional),
+            Piece::String(b"/test".to_vec()),
+            Piece::Parameter(Position::Named(b"optional".to_vec()), Kind::Optional),
+            Piece::Parameter(Position::Named(b"optional2".to_vec()), Kind::Optional),
         ]
     );
 
@@ -976,7 +968,7 @@ fn match_params() {
     // └── foo
     //     └── ?
     //         └── bar •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/foo:param?bar", 1);
 
@@ -988,9 +980,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/foo"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Optional),
-            Piece::String(b"bar"),
+            Piece::String(b"/foo".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Optional),
+            Piece::String(b"bar".to_vec()),
         ]
     );
 
@@ -1005,7 +997,7 @@ fn match_params() {
     // └── foo
     //     └── *
     //         └── bar •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/foo*bar", 1);
 
@@ -1017,9 +1009,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/foo"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b"bar"),
+            Piece::String(b"/foo".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"bar".to_vec()),
         ]
     );
 
@@ -1042,7 +1034,7 @@ fn match_params() {
     // └── foo
     //     └── +
     //         └── bar •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/foo+bar", 1);
 
@@ -1054,9 +1046,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/foo"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"+1")), Kind::OneOrMore),
-            Piece::String(b"bar"),
+            Piece::String(b"/foo".to_vec()),
+            Piece::Parameter(Position::Index(1, b"+1".to_vec()), Kind::OneOrMore),
+            Piece::String(b"bar".to_vec()),
         ]
     );
 
@@ -1079,7 +1071,7 @@ fn match_params() {
     //         └── cde
     //             └── *
     //                 └── g/ •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/a*cde*g/", 1);
 
@@ -1090,11 +1082,11 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/a"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b"cde"),
-            Piece::Parameter(Position::Index(2, Cow::Borrowed(b"*2")), Kind::ZeroOrMore),
-            Piece::String(b"g/"),
+            Piece::String(b"/a".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"cde".to_vec()),
+            Piece::Parameter(Position::Index(2, b"*2".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"g/".to_vec()),
         ]
     );
     assert_eq!(p.pattern(), "/a*cde*g/");
@@ -1123,7 +1115,7 @@ fn match_params() {
     //     └── v1
     //         └── *
     //             └── proxy/ •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/*v1*/proxy", 1);
 
@@ -1132,11 +1124,11 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b"v1"),
-            Piece::Parameter(Position::Index(2, Cow::Borrowed(b"*2")), Kind::ZeroOrMore),
-            Piece::String(b"/proxy"),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"v1".to_vec()),
+            Piece::Parameter(Position::Index(2, b"*2".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b"/proxy".to_vec()),
         ]
     );
     assert_eq!(p.pattern(), "/*v1*/proxy");
@@ -1162,7 +1154,7 @@ fn match_params() {
     // ├── ~
     // │   └── : •4
     // └── : •6
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/name\\::name", 1);
     tree.insert("/@:name", 2);
@@ -1177,9 +1169,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/name"),
-            Piece::String(b":"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/name".to_vec()),
+            Piece::String(b":".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/name\\::name");
@@ -1190,8 +1182,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/@"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/@".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/@:name");
@@ -1202,8 +1194,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/-"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/-".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/-:name");
@@ -1214,8 +1206,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/.".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/.:name");
@@ -1226,8 +1218,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/~"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/~".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/~:name");
@@ -1238,8 +1230,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/_"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/_".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/_:name");
@@ -1250,8 +1242,8 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"name")), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"name".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/:name");
@@ -1262,7 +1254,7 @@ fn match_params() {
     //     └── :
     //         └── /abc/
     //             └── ** •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/v1/:param/abc/*", 1);
 
@@ -1271,13 +1263,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/v1/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/abc/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
+            Piece::String(b"/api/v1/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/abc/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
         ]
     );
     assert_eq!(p.pattern(), "/api/v1/:param/abc/*");
@@ -1296,7 +1285,7 @@ fn match_params() {
     //             └── ??
     //                 └── /
     //                     └── ?? •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/:day/:month?/:year?", 1);
 
@@ -1307,18 +1296,12 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"day")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"month")),
-                Kind::OptionalSegment
-            ),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"year")),
-                Kind::OptionalSegment
-            ),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Named(b"day".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"month".to_vec()), Kind::OptionalSegment),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"year".to_vec()), Kind::OptionalSegment),
         ]
     );
     assert_eq!(p.pattern(), "/api/:day/:month?/:year?");
@@ -1351,7 +1334,7 @@ fn match_params() {
     //             └── ?
     //                 └── .
     //                     └── ? •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/:day.:month?.:year?", 1);
     tree.insert("/api/:day-:month?-:year?", 2);
@@ -1365,12 +1348,12 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"day")), Kind::Normal),
-            Piece::String(b"."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"month")), Kind::Optional),
-            Piece::String(b"."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"year")), Kind::Optional),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Named(b"day".to_vec()), Kind::Normal),
+            Piece::String(b".".to_vec()),
+            Piece::Parameter(Position::Named(b"month".to_vec()), Kind::Optional),
+            Piece::String(b".".to_vec()),
+            Piece::Parameter(Position::Named(b"year".to_vec()), Kind::Optional),
         ]
     );
     assert_eq!(p.pattern(), "/api/:day.:month?.:year?");
@@ -1392,12 +1375,12 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"day")), Kind::Normal),
-            Piece::String(b"-"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"month")), Kind::Optional),
-            Piece::String(b"-"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"year")), Kind::Optional),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Named(b"day".to_vec()), Kind::Normal),
+            Piece::String(b"-".to_vec()),
+            Piece::Parameter(Position::Named(b"month".to_vec()), Kind::Optional),
+            Piece::String(b"-".to_vec()),
+            Piece::Parameter(Position::Named(b"year".to_vec()), Kind::Optional),
         ]
     );
     assert_eq!(p.pattern(), "/api/:day-:month?-:year?");
@@ -1423,7 +1406,7 @@ fn match_params() {
     //     │   └── .json •1
     //     └── *
     //         └── .json •2
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/config/abc.json", 1);
     tree.insert("/config/+.json", 2);
@@ -1431,7 +1414,7 @@ fn match_params() {
 
     let p = tree.find("/config/abc.json").unwrap();
     assert_eq!(p.value, &1);
-    assert_eq!(p.pieces, vec![Piece::String(b"/config/abc.json")]);
+    assert_eq!(p.pieces, vec![Piece::String(b"/config/abc.json".to_vec())]);
     assert_eq!(p.pattern(), "/config/abc.json");
     assert_eq!(p.params(), vec![]);
 
@@ -1440,9 +1423,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/config/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"+1")), Kind::OneOrMore),
-            Piece::String(b".json"),
+            Piece::String(b"/config/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"+1".to_vec()), Kind::OneOrMore),
+            Piece::String(b".json".to_vec()),
         ]
     );
     assert_eq!(p.pattern(), "/config/+.json");
@@ -1465,9 +1448,9 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/config/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"*1")), Kind::ZeroOrMore),
-            Piece::String(b".json"),
+            Piece::String(b"/config/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMore),
+            Piece::String(b".json".to_vec()),
         ]
     );
     assert_eq!(p.pattern(), "/config/*.json");
@@ -1478,7 +1461,7 @@ fn match_params() {
     //     └── **
     //         └── /
     //             └── ?? •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/*/:param?", 1);
 
@@ -1487,16 +1470,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
-            Piece::String(b"/"),
-            Piece::Parameter(
-                Position::Named(Cow::Borrowed(b"param")),
-                Kind::OptionalSegment
-            ),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::OptionalSegment),
         ]
     );
     assert_eq!(p.pattern(), "/api/*/:param?");
@@ -1525,7 +1502,7 @@ fn match_params() {
     //     └── **
     //         └── /
     //             └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/*/:param", 1);
 
@@ -1534,13 +1511,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/api/*/:param");
@@ -1563,7 +1537,7 @@ fn match_params() {
     //     └── +
     //         └── /
     //             └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/+/:param", 1);
 
@@ -1572,10 +1546,10 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(Position::Index(1, Cow::Borrowed(b"+1")), Kind::OneOrMore),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"+1".to_vec()), Kind::OneOrMore),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/api/+/:param");
@@ -1597,7 +1571,7 @@ fn match_params() {
     //             └── :
     //                 └── /
     //                     └── : •0
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/api/*/:param/:param2", 1);
 
@@ -1606,15 +1580,12 @@ fn match_params() {
     assert_eq!(
         p.pieces,
         vec![
-            Piece::String(b"/api/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"param2")), Kind::Normal),
+            Piece::String(b"/api/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"param2".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(p.pattern(), "/api/*/:param/:param2");
@@ -1662,7 +1633,7 @@ fn match_params() {
 
 #[test]
 fn basic() {
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/", 0);
     tree.insert("/login", 1);
@@ -1815,7 +1786,7 @@ fn basic() {
 
 #[test]
 fn github_tree() {
-    let mut tree = PathTree::<'static, usize>::new();
+    let mut tree = PathTree::<usize>::new();
 
     tree.insert("/", 0);
     tree.insert("/api", 1);
@@ -2168,15 +2139,12 @@ fn github_tree() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"org")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"repo")), Kind::Normal),
-            Piece::String(b"/releases/"),
-            Piece::Parameter(
-                Position::Index(1, Cow::Borrowed(b"*1")),
-                Kind::ZeroOrMoreSegment
-            ),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"org".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"repo".to_vec()), Kind::Normal),
+            Piece::String(b"/releases/".to_vec()),
+            Piece::Parameter(Position::Index(1, b"*1".to_vec()), Kind::ZeroOrMoreSegment),
         ]
     );
 
@@ -2195,16 +2163,16 @@ fn github_tree() {
     assert_eq!(
         p.pieces,
         &vec![
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"org")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"repo")), Kind::Normal),
-            Piece::String(b"/releases/download/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"tag")), Kind::Normal),
-            Piece::String(b"/"),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"filename")), Kind::Normal),
-            Piece::String(b"."),
-            Piece::Parameter(Position::Named(Cow::Borrowed(b"ext")), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"org".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"repo".to_vec()), Kind::Normal),
+            Piece::String(b"/releases/download/".to_vec()),
+            Piece::Parameter(Position::Named(b"tag".to_vec()), Kind::Normal),
+            Piece::String(b"/".to_vec()),
+            Piece::Parameter(Position::Named(b"filename".to_vec()), Kind::Normal),
+            Piece::String(b".".to_vec()),
+            Piece::Parameter(Position::Named(b"ext".to_vec()), Kind::Normal),
         ]
     );
     assert_eq!(