diff --git a/Cargo.toml b/Cargo.toml
index 253c6c37..a3071942 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,3 +15,4 @@ license = "MPL-2.0"
 [dependencies]
 encoding = "0.2"
 text_writer = "0.1.1"
+matches = "0.1"
diff --git a/src/ast.rs b/src/ast.rs
deleted file mode 100644
index 4c32fb0e..00000000
--- a/src/ast.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use std::fmt;
-use std::slice;
-use std::vec;
-
-
-#[deriving(PartialEq, Show)]
-pub struct NumericValue {
-    pub representation: String,
-    pub value: f64,
-    pub int_value: Option<i64>,
-}
-
-
-#[deriving(PartialEq, Show, Copy)]
-pub struct SourceLocation {
-    pub line: uint,  // First line is 1
-    pub column: uint,  // First character of a line is at column 1
-}
-
-
-pub type Node = (ComponentValue, SourceLocation);  // TODO this is not a good name
-
-
-#[deriving(PartialEq, Show)]
-pub enum ComponentValue {
-    // Preserved tokens.
-    Ident(String),
-    AtKeyword(String),
-    Hash(String),
-    IDHash(String),  // Hash that is a valid ID selector.
-    QuotedString(String),
-    URL(String),
-    Delim(char),
-    Number(NumericValue),
-    Percentage(NumericValue),
-    Dimension(NumericValue, String),
-    UnicodeRange(u32, u32),  // (start, end) of range
-    WhiteSpace,
-    Colon,  // :
-    Semicolon,  // ;
-    Comma,  // ,
-    IncludeMatch, // ~=
-    DashMatch, // |=
-    PrefixMatch, // ^=
-    SuffixMatch, // $=
-    SubstringMatch, // *=
-    Column, // ||
-    CDO,  // <!--
-    CDC,  // -->
-
-    // Function
-    Function(String, Vec<ComponentValue>),  // name, arguments
-
-    // Simple block
-    ParenthesisBlock(Vec<ComponentValue>),  // (…)
-    SquareBracketBlock(Vec<ComponentValue>),  // […]
-    CurlyBracketBlock(Vec<Node>),  // {…}
-
-    // These are always invalid
-    BadURL,
-    BadString,
-    CloseParenthesis, // )
-    CloseSquareBracket, // ]
-    CloseCurlyBracket, // }
-}
-
-
-#[deriving(PartialEq)]
-pub struct Declaration {
-    pub location: SourceLocation,
-    pub name: String,
-    pub value: Vec<ComponentValue>,
-    pub important: bool,
-}
-
-#[deriving(PartialEq)]
-pub struct QualifiedRule {
-    pub location: SourceLocation,
-    pub prelude: Vec<ComponentValue>,
-    pub block: Vec<Node>,
-}
-
-#[deriving(PartialEq)]
-pub struct AtRule {
-    pub location: SourceLocation,
-    pub name: String,
-    pub prelude: Vec<ComponentValue>,
-    pub block: Option<Vec<Node>>,
-}
-
-#[deriving(PartialEq)]
-pub enum DeclarationListItem {
-    Declaration(Declaration),
-    AtRule(AtRule),
-}
-
-#[deriving(PartialEq)]
-pub enum Rule {
-    QualifiedRule(QualifiedRule),
-    AtRule(AtRule),
-}
-
-#[deriving(PartialEq, Copy)]
-pub struct SyntaxError {
-    pub location: SourceLocation,
-    pub reason: ErrorReason,
-}
-
-#[deriving(PartialEq, Show, Copy)]
-pub enum ErrorReason {
-    EmptyInput,  // Parsing a single "thing", found only whitespace.
-    ExtraInput,  // Found more non-whitespace after parsing a single "thing".
-    MissingQualifiedRuleBlock,  // EOF in a qualified rule prelude, before '{'
-    InvalidDeclarationSyntax,
-    InvalidBangImportantSyntax,
-    // This is meant to be extended
-}
-
-impl fmt::Show for SyntaxError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{} {}", self.location.line, self.location.column, self.reason)
-    }
-}
-
-
-pub trait SkipWhitespaceIterable<'a> {
-    fn skip_whitespace(self) -> SkipWhitespaceIterator<'a>;
-}
-
-impl<'a> SkipWhitespaceIterable<'a> for &'a [ComponentValue] {
-    fn skip_whitespace(self) -> SkipWhitespaceIterator<'a> {
-        SkipWhitespaceIterator{ iter_with_whitespace: self.iter() }
-    }
-}
-
-#[deriving(Clone)]
-pub struct SkipWhitespaceIterator<'a> {
-    pub iter_with_whitespace: slice::Items<'a, ComponentValue>,
-}
-
-impl<'a> Iterator<&'a ComponentValue> for SkipWhitespaceIterator<'a> {
-    fn next(&mut self) -> Option<&'a ComponentValue> {
-        for component_value in self.iter_with_whitespace {
-            if component_value != &ComponentValue::WhiteSpace { return Some(component_value) }
-        }
-        None
-    }
-}
-
-
-pub trait MoveSkipWhitespaceIterable {
-    fn move_skip_whitespace(self) -> MoveSkipWhitespaceIterator;
-}
-
-impl MoveSkipWhitespaceIterable for Vec<ComponentValue> {
-    fn move_skip_whitespace(self) -> MoveSkipWhitespaceIterator {
-        MoveSkipWhitespaceIterator{ iter_with_whitespace: self.into_iter() }
-    }
-}
-
-pub struct MoveSkipWhitespaceIterator {
-    iter_with_whitespace: vec::MoveItems<ComponentValue>,
-}
-
-impl Iterator<ComponentValue> for MoveSkipWhitespaceIterator {
-    fn next(&mut self) -> Option<ComponentValue> {
-        for component_value in self.iter_with_whitespace {
-            if component_value != ComponentValue::WhiteSpace { return Some(component_value) }
-        }
-        None
-    }
-}
diff --git a/src/color.rs b/src/color.rs
index 5872269f..553c3bca 100644
--- a/src/color.rs
+++ b/src/color.rs
@@ -8,9 +8,7 @@ use std::num::{Float, FloatMath};
 
 use text_writer::{mod, TextWriter};
 
-use ast::{ComponentValue, SkipWhitespaceIterable};
-use ast::ComponentValue::{Number, Percentage, Function, Ident, Hash, IDHash, Comma};
-use serializer::ToCss;
+use super::{Token, Parser, ToCss};
 
 
 #[deriving(Clone, Copy, PartialEq)]
@@ -65,12 +63,17 @@ impl fmt::Show for Color {
 
 /// Return `Err(())` on invalid or unsupported value (not a color).
 impl Color {
-    pub fn parse(component_value: &ComponentValue) -> Result<Color, ()> {
-        match *component_value {
-            Hash(ref value) | IDHash(ref value) => parse_color_hash(value.as_slice()),
-            Ident(ref value) => parse_color_keyword(value.as_slice()),
-            Function(ref name, ref arguments)
-                => parse_color_function(name.as_slice(), arguments.as_slice()),
+    pub fn parse(input: &mut Parser) -> Result<Color, ()> {
+        match try!(input.next()) {
+            Token::Hash(ref value) | Token::IDHash(ref value) => {
+                parse_color_hash(value.as_slice())
+            }
+            Token::Ident(ref value) => parse_color_keyword(value.as_slice()),
+            Token::Function(ref name) => {
+                input.parse_nested_block(|arguments| {
+                    parse_color_function(name.as_slice(), arguments)
+                })
+            }
             _ => Err(())
         }
     }
@@ -78,164 +81,173 @@ impl Color {
 
 
 #[inline]
-pub fn parse_color_keyword(value: &str) -> Result<Color, ()> {
-    let lower_value = value.to_ascii_lower();
-    let (r, g, b) = match lower_value.as_slice() {
-        "black" => (0., 0., 0.),
-        "silver" => (192., 192., 192.),
-        "gray" => (128., 128., 128.),
-        "white" => (255., 255., 255.),
-        "maroon" => (128., 0., 0.),
-        "red" => (255., 0., 0.),
-        "purple" => (128., 0., 128.),
-        "fuchsia" => (255., 0., 255.),
-        "green" => (0., 128., 0.),
-        "lime" => (0., 255., 0.),
-        "olive" => (128., 128., 0.),
-        "yellow" => (255., 255., 0.),
-        "navy" => (0., 0., 128.),
-        "blue" => (0., 0., 255.),
-        "teal" => (0., 128., 128.),
-        "aqua" => (0., 255., 255.),
+pub fn parse_color_keyword(ident: &str) -> Result<Color, ()> {
+    macro_rules! rgba {
+        ($red: expr, $green: expr, $blue: expr) => {
+            Ok(Color::RGBA(RGBA {
+                red: $red / 255.,
+                green: $green / 255.,
+                blue: $blue / 255.,
+                alpha: 1.,
+            }))
+        }
+    }
 
-        "aliceblue" => (240., 248., 255.),
-        "antiquewhite" => (250., 235., 215.),
-        "aquamarine" => (127., 255., 212.),
-        "azure" => (240., 255., 255.),
-        "beige" => (245., 245., 220.),
-        "bisque" => (255., 228., 196.),
-        "blanchedalmond" => (255., 235., 205.),
-        "blueviolet" => (138., 43., 226.),
-        "brown" => (165., 42., 42.),
-        "burlywood" => (222., 184., 135.),
-        "cadetblue" => (95., 158., 160.),
-        "chartreuse" => (127., 255., 0.),
-        "chocolate" => (210., 105., 30.),
-        "coral" => (255., 127., 80.),
-        "cornflowerblue" => (100., 149., 237.),
-        "cornsilk" => (255., 248., 220.),
-        "crimson" => (220., 20., 60.),
-        "cyan" => (0., 255., 255.),
-        "darkblue" => (0., 0., 139.),
-        "darkcyan" => (0., 139., 139.),
-        "darkgoldenrod" => (184., 134., 11.),
-        "darkgray" => (169., 169., 169.),
-        "darkgreen" => (0., 100., 0.),
-        "darkgrey" => (169., 169., 169.),
-        "darkkhaki" => (189., 183., 107.),
-        "darkmagenta" => (139., 0., 139.),
-        "darkolivegreen" => (85., 107., 47.),
-        "darkorange" => (255., 140., 0.),
-        "darkorchid" => (153., 50., 204.),
-        "darkred" => (139., 0., 0.),
-        "darksalmon" => (233., 150., 122.),
-        "darkseagreen" => (143., 188., 143.),
-        "darkslateblue" => (72., 61., 139.),
-        "darkslategray" => (47., 79., 79.),
-        "darkslategrey" => (47., 79., 79.),
-        "darkturquoise" => (0., 206., 209.),
-        "darkviolet" => (148., 0., 211.),
-        "deeppink" => (255., 20., 147.),
-        "deepskyblue" => (0., 191., 255.),
-        "dimgray" => (105., 105., 105.),
-        "dimgrey" => (105., 105., 105.),
-        "dodgerblue" => (30., 144., 255.),
-        "firebrick" => (178., 34., 34.),
-        "floralwhite" => (255., 250., 240.),
-        "forestgreen" => (34., 139., 34.),
-        "gainsboro" => (220., 220., 220.),
-        "ghostwhite" => (248., 248., 255.),
-        "gold" => (255., 215., 0.),
-        "goldenrod" => (218., 165., 32.),
-        "greenyellow" => (173., 255., 47.),
-        "grey" => (128., 128., 128.),
-        "honeydew" => (240., 255., 240.),
-        "hotpink" => (255., 105., 180.),
-        "indianred" => (205., 92., 92.),
-        "indigo" => (75., 0., 130.),
-        "ivory" => (255., 255., 240.),
-        "khaki" => (240., 230., 140.),
-        "lavender" => (230., 230., 250.),
-        "lavenderblush" => (255., 240., 245.),
-        "lawngreen" => (124., 252., 0.),
-        "lemonchiffon" => (255., 250., 205.),
-        "lightblue" => (173., 216., 230.),
-        "lightcoral" => (240., 128., 128.),
-        "lightcyan" => (224., 255., 255.),
-        "lightgoldenrodyellow" => (250., 250., 210.),
-        "lightgray" => (211., 211., 211.),
-        "lightgreen" => (144., 238., 144.),
-        "lightgrey" => (211., 211., 211.),
-        "lightpink" => (255., 182., 193.),
-        "lightsalmon" => (255., 160., 122.),
-        "lightseagreen" => (32., 178., 170.),
-        "lightskyblue" => (135., 206., 250.),
-        "lightslategray" => (119., 136., 153.),
-        "lightslategrey" => (119., 136., 153.),
-        "lightsteelblue" => (176., 196., 222.),
-        "lightyellow" => (255., 255., 224.),
-        "limegreen" => (50., 205., 50.),
-        "linen" => (250., 240., 230.),
-        "magenta" => (255., 0., 255.),
-        "mediumaquamarine" => (102., 205., 170.),
-        "mediumblue" => (0., 0., 205.),
-        "mediumorchid" => (186., 85., 211.),
-        "mediumpurple" => (147., 112., 219.),
-        "mediumseagreen" => (60., 179., 113.),
-        "mediumslateblue" => (123., 104., 238.),
-        "mediumspringgreen" => (0., 250., 154.),
-        "mediumturquoise" => (72., 209., 204.),
-        "mediumvioletred" => (199., 21., 133.),
-        "midnightblue" => (25., 25., 112.),
-        "mintcream" => (245., 255., 250.),
-        "mistyrose" => (255., 228., 225.),
-        "moccasin" => (255., 228., 181.),
-        "navajowhite" => (255., 222., 173.),
-        "oldlace" => (253., 245., 230.),
-        "olivedrab" => (107., 142., 35.),
-        "orange" => (255., 165., 0.),
-        "orangered" => (255., 69., 0.),
-        "orchid" => (218., 112., 214.),
-        "palegoldenrod" => (238., 232., 170.),
-        "palegreen" => (152., 251., 152.),
-        "paleturquoise" => (175., 238., 238.),
-        "palevioletred" => (219., 112., 147.),
-        "papayawhip" => (255., 239., 213.),
-        "peachpuff" => (255., 218., 185.),
-        "peru" => (205., 133., 63.),
-        "pink" => (255., 192., 203.),
-        "plum" => (221., 160., 221.),
-        "powderblue" => (176., 224., 230.),
-        "rebeccapurple" => (102., 51., 153.),
-        "rosybrown" => (188., 143., 143.),
-        "royalblue" => (65., 105., 225.),
-        "saddlebrown" => (139., 69., 19.),
-        "salmon" => (250., 128., 114.),
-        "sandybrown" => (244., 164., 96.),
-        "seagreen" => (46., 139., 87.),
-        "seashell" => (255., 245., 238.),
-        "sienna" => (160., 82., 45.),
-        "skyblue" => (135., 206., 235.),
-        "slateblue" => (106., 90., 205.),
-        "slategray" => (112., 128., 144.),
-        "slategrey" => (112., 128., 144.),
-        "snow" => (255., 250., 250.),
-        "springgreen" => (0., 255., 127.),
-        "steelblue" => (70., 130., 180.),
-        "tan" => (210., 180., 140.),
-        "thistle" => (216., 191., 216.),
-        "tomato" => (255., 99., 71.),
-        "turquoise" => (64., 224., 208.),
-        "violet" => (238., 130., 238.),
-        "wheat" => (245., 222., 179.),
-        "whitesmoke" => (245., 245., 245.),
-        "yellowgreen" => (154., 205., 50.),
+    match_ignore_ascii_case! { ident:
+        "black" => rgba!(0., 0., 0.),
+        "silver" => rgba!(192., 192., 192.),
+        "gray" => rgba!(128., 128., 128.),
+        "white" => rgba!(255., 255., 255.),
+        "maroon" => rgba!(128., 0., 0.),
+        "red" => rgba!(255., 0., 0.),
+        "purple" => rgba!(128., 0., 128.),
+        "fuchsia" => rgba!(255., 0., 255.),
+        "green" => rgba!(0., 128., 0.),
+        "lime" => rgba!(0., 255., 0.),
+        "olive" => rgba!(128., 128., 0.),
+        "yellow" => rgba!(255., 255., 0.),
+        "navy" => rgba!(0., 0., 128.),
+        "blue" => rgba!(0., 0., 255.),
+        "teal" => rgba!(0., 128., 128.),
+        "aqua" => rgba!(0., 255., 255.),
 
-        "transparent" => return Ok(Color::RGBA(RGBA { red: 0., green: 0., blue: 0., alpha: 0. })),
-        "currentcolor" => return Ok(Color::CurrentColor),
-        _ => return Err(()),
-    };
-    Ok(Color::RGBA(RGBA { red: r / 255., green: g / 255., blue: b / 255., alpha: 1. }))
+        "aliceblue" => rgba!(240., 248., 255.),
+        "antiquewhite" => rgba!(250., 235., 215.),
+        "aquamarine" => rgba!(127., 255., 212.),
+        "azure" => rgba!(240., 255., 255.),
+        "beige" => rgba!(245., 245., 220.),
+        "bisque" => rgba!(255., 228., 196.),
+        "blanchedalmond" => rgba!(255., 235., 205.),
+        "blueviolet" => rgba!(138., 43., 226.),
+        "brown" => rgba!(165., 42., 42.),
+        "burlywood" => rgba!(222., 184., 135.),
+        "cadetblue" => rgba!(95., 158., 160.),
+        "chartreuse" => rgba!(127., 255., 0.),
+        "chocolate" => rgba!(210., 105., 30.),
+        "coral" => rgba!(255., 127., 80.),
+        "cornflowerblue" => rgba!(100., 149., 237.),
+        "cornsilk" => rgba!(255., 248., 220.),
+        "crimson" => rgba!(220., 20., 60.),
+        "cyan" => rgba!(0., 255., 255.),
+        "darkblue" => rgba!(0., 0., 139.),
+        "darkcyan" => rgba!(0., 139., 139.),
+        "darkgoldenrod" => rgba!(184., 134., 11.),
+        "darkgray" => rgba!(169., 169., 169.),
+        "darkgreen" => rgba!(0., 100., 0.),
+        "darkgrey" => rgba!(169., 169., 169.),
+        "darkkhaki" => rgba!(189., 183., 107.),
+        "darkmagenta" => rgba!(139., 0., 139.),
+        "darkolivegreen" => rgba!(85., 107., 47.),
+        "darkorange" => rgba!(255., 140., 0.),
+        "darkorchid" => rgba!(153., 50., 204.),
+        "darkred" => rgba!(139., 0., 0.),
+        "darksalmon" => rgba!(233., 150., 122.),
+        "darkseagreen" => rgba!(143., 188., 143.),
+        "darkslateblue" => rgba!(72., 61., 139.),
+        "darkslategray" => rgba!(47., 79., 79.),
+        "darkslategrey" => rgba!(47., 79., 79.),
+        "darkturquoise" => rgba!(0., 206., 209.),
+        "darkviolet" => rgba!(148., 0., 211.),
+        "deeppink" => rgba!(255., 20., 147.),
+        "deepskyblue" => rgba!(0., 191., 255.),
+        "dimgray" => rgba!(105., 105., 105.),
+        "dimgrey" => rgba!(105., 105., 105.),
+        "dodgerblue" => rgba!(30., 144., 255.),
+        "firebrick" => rgba!(178., 34., 34.),
+        "floralwhite" => rgba!(255., 250., 240.),
+        "forestgreen" => rgba!(34., 139., 34.),
+        "gainsboro" => rgba!(220., 220., 220.),
+        "ghostwhite" => rgba!(248., 248., 255.),
+        "gold" => rgba!(255., 215., 0.),
+        "goldenrod" => rgba!(218., 165., 32.),
+        "greenyellow" => rgba!(173., 255., 47.),
+        "grey" => rgba!(128., 128., 128.),
+        "honeydew" => rgba!(240., 255., 240.),
+        "hotpink" => rgba!(255., 105., 180.),
+        "indianred" => rgba!(205., 92., 92.),
+        "indigo" => rgba!(75., 0., 130.),
+        "ivory" => rgba!(255., 255., 240.),
+        "khaki" => rgba!(240., 230., 140.),
+        "lavender" => rgba!(230., 230., 250.),
+        "lavenderblush" => rgba!(255., 240., 245.),
+        "lawngreen" => rgba!(124., 252., 0.),
+        "lemonchiffon" => rgba!(255., 250., 205.),
+        "lightblue" => rgba!(173., 216., 230.),
+        "lightcoral" => rgba!(240., 128., 128.),
+        "lightcyan" => rgba!(224., 255., 255.),
+        "lightgoldenrodyellow" => rgba!(250., 250., 210.),
+        "lightgray" => rgba!(211., 211., 211.),
+        "lightgreen" => rgba!(144., 238., 144.),
+        "lightgrey" => rgba!(211., 211., 211.),
+        "lightpink" => rgba!(255., 182., 193.),
+        "lightsalmon" => rgba!(255., 160., 122.),
+        "lightseagreen" => rgba!(32., 178., 170.),
+        "lightskyblue" => rgba!(135., 206., 250.),
+        "lightslategray" => rgba!(119., 136., 153.),
+        "lightslategrey" => rgba!(119., 136., 153.),
+        "lightsteelblue" => rgba!(176., 196., 222.),
+        "lightyellow" => rgba!(255., 255., 224.),
+        "limegreen" => rgba!(50., 205., 50.),
+        "linen" => rgba!(250., 240., 230.),
+        "magenta" => rgba!(255., 0., 255.),
+        "mediumaquamarine" => rgba!(102., 205., 170.),
+        "mediumblue" => rgba!(0., 0., 205.),
+        "mediumorchid" => rgba!(186., 85., 211.),
+        "mediumpurple" => rgba!(147., 112., 219.),
+        "mediumseagreen" => rgba!(60., 179., 113.),
+        "mediumslateblue" => rgba!(123., 104., 238.),
+        "mediumspringgreen" => rgba!(0., 250., 154.),
+        "mediumturquoise" => rgba!(72., 209., 204.),
+        "mediumvioletred" => rgba!(199., 21., 133.),
+        "midnightblue" => rgba!(25., 25., 112.),
+        "mintcream" => rgba!(245., 255., 250.),
+        "mistyrose" => rgba!(255., 228., 225.),
+        "moccasin" => rgba!(255., 228., 181.),
+        "navajowhite" => rgba!(255., 222., 173.),
+        "oldlace" => rgba!(253., 245., 230.),
+        "olivedrab" => rgba!(107., 142., 35.),
+        "orange" => rgba!(255., 165., 0.),
+        "orangered" => rgba!(255., 69., 0.),
+        "orchid" => rgba!(218., 112., 214.),
+        "palegoldenrod" => rgba!(238., 232., 170.),
+        "palegreen" => rgba!(152., 251., 152.),
+        "paleturquoise" => rgba!(175., 238., 238.),
+        "palevioletred" => rgba!(219., 112., 147.),
+        "papayawhip" => rgba!(255., 239., 213.),
+        "peachpuff" => rgba!(255., 218., 185.),
+        "peru" => rgba!(205., 133., 63.),
+        "pink" => rgba!(255., 192., 203.),
+        "plum" => rgba!(221., 160., 221.),
+        "powderblue" => rgba!(176., 224., 230.),
+        "rebeccapurple" => rgba!(102., 51., 153.),
+        "rosybrown" => rgba!(188., 143., 143.),
+        "royalblue" => rgba!(65., 105., 225.),
+        "saddlebrown" => rgba!(139., 69., 19.),
+        "salmon" => rgba!(250., 128., 114.),
+        "sandybrown" => rgba!(244., 164., 96.),
+        "seagreen" => rgba!(46., 139., 87.),
+        "seashell" => rgba!(255., 245., 238.),
+        "sienna" => rgba!(160., 82., 45.),
+        "skyblue" => rgba!(135., 206., 235.),
+        "slateblue" => rgba!(106., 90., 205.),
+        "slategray" => rgba!(112., 128., 144.),
+        "slategrey" => rgba!(112., 128., 144.),
+        "snow" => rgba!(255., 250., 250.),
+        "springgreen" => rgba!(0., 255., 127.),
+        "steelblue" => rgba!(70., 130., 180.),
+        "tan" => rgba!(210., 180., 140.),
+        "thistle" => rgba!(216., 191., 216.),
+        "tomato" => rgba!(255., 99., 71.),
+        "turquoise" => rgba!(64., 224., 208.),
+        "violet" => rgba!(238., 130., 238.),
+        "wheat" => rgba!(245., 222., 179.),
+        "whitesmoke" => rgba!(245., 245., 245.),
+        "yellowgreen" => rgba!(154., 205., 50.),
+
+        "transparent" => Ok(Color::RGBA(RGBA { red: 0., green: 0., blue: 0., alpha: 0. })),
+        "currentcolor" => Ok(Color::CurrentColor)
+        _ => Err(())
+    }
 }
 
 
@@ -278,70 +290,44 @@ fn parse_color_hash(value: &str) -> Result<Color, ()> {
 
 
 #[inline]
-fn parse_color_function(name: &str, arguments: &[ComponentValue])
-                        -> Result<Color, ()> {
-    let lower_name = name.to_ascii_lower();
-    let lower_name = lower_name.as_slice();
-
-    let (is_rgb, has_alpha) =
-        if "rgba" == lower_name { (true, true) }
-        else if "rgb" == lower_name { (true, false) }
-        else if "hsl" == lower_name { (false, false) }
-        else if "hsla" == lower_name { (false, true) }
-        else { return Err(()) };
-
-    let mut iter = arguments.skip_whitespace();
-    macro_rules! expect_comma(
-        () => ( match iter.next() { Some(&Comma) => {}, _ => { return Err(()) } } );
-    );
-    macro_rules! expect_percentage(
-        () => ( match iter.next() {
-            Some(&Percentage(ref v)) => v.value,
-            _ => return Err(()),
-        });
-    );
-    macro_rules! expect_integer(
-        () => ( match iter.next() {
-            Some(&Number(ref v)) if v.int_value.is_some() => v.value,
-            _ => return Err(()),
-        });
-    );
-    macro_rules! expect_number(
-        () => ( match iter.next() {
-            Some(&Number(ref v)) => v.value,
-            _ => return Err(()),
-        });
-    );
+fn parse_color_function(name: &str, arguments: &mut Parser) -> Result<Color, ()> {
+    let (is_rgb, has_alpha) = match_ignore_ascii_case! { name:
+        "rgba" => (true, true),
+        "rgb" => (true, false),
+        "hsl" => (false, false),
+        "hsla" => (false, true)
+        _ => return Err(())
+    };
 
     let red: f32;
     let green: f32;
     let blue: f32;
     if is_rgb {
         // Either integers or percentages, but all the same type.
-        match iter.next() {
-            Some(&Number(ref v)) if v.int_value.is_some() => {
+        match try!(arguments.next()) {
+            Token::Number(ref v) if v.int_value.is_some() => {
                 red = (v.value / 255.) as f32;
-                expect_comma!();
-                green = (expect_integer!() / 255.) as f32;
-                expect_comma!();
-                blue = (expect_integer!() / 255.) as f32;
+                try!(arguments.expect_comma());
+                green = try!(arguments.expect_integer()) as f32 / 255.;
+                try!(arguments.expect_comma());
+                blue = try!(arguments.expect_integer()) as f32 / 255.;
             }
-            Some(&Percentage(ref v)) => {
-                red = (v.value / 100.) as f32;
-                expect_comma!();
-                green = (expect_percentage!() / 100.) as f32;
-                expect_comma!();
-                blue = (expect_percentage!() / 100.) as f32;
+            Token::Percentage(ref v) => {
+                red = v.unit_value as f32;
+                try!(arguments.expect_comma());
+                green = try!(arguments.expect_percentage()) as f32;
+                try!(arguments.expect_comma());
+                blue = try!(arguments.expect_percentage()) as f32;
             }
             _ => return Err(())
         };
     } else {
-        let hue = expect_number!() / 360.;
+        let hue = try!(arguments.expect_number()) / 360.;
         let hue = hue - hue.floor();
-        expect_comma!();
-        let saturation = (expect_percentage!() / 100.).max(0.).min(1.);
-        expect_comma!();
-        let lightness = (expect_percentage!() / 100.).max(0.).min(1.);
+        try!(arguments.expect_comma());
+        let saturation = (try!(arguments.expect_percentage())).max(0.).min(1.);
+        try!(arguments.expect_comma());
+        let lightness = (try!(arguments.expect_percentage())).max(0.).min(1.);
 
         // http://www.w3.org/TR/css3-color/#hsl-color
         fn hue_to_rgb(m1: f64, m2: f64, mut h: f64) -> f64 {
@@ -362,14 +348,11 @@ fn parse_color_function(name: &str, arguments: &[ComponentValue])
     }
 
     let alpha = if has_alpha {
-        expect_comma!();
-        (expect_number!()).max(0.).min(1.) as f32
+        try!(arguments.expect_comma());
+        (try!(arguments.expect_number())).max(0.).min(1.) as f32
     } else {
         1.
     };
-    if iter.next().is_none() {
-        Ok(Color::RGBA(RGBA { red: red, green: green, blue: blue, alpha: alpha }))
-    } else {
-        Err(())
-    }
+    try!(arguments.expect_exhausted());
+    Ok(Color::RGBA(RGBA { red: red, green: green, blue: blue, alpha: alpha }))
 }
diff --git a/src/css-parsing-tests/An+B.json b/src/css-parsing-tests/An+B.json
index 3f4e89b2..f17849ea 100644
--- a/src/css-parsing-tests/An+B.json
+++ b/src/css-parsing-tests/An+B.json
@@ -54,12 +54,15 @@
 "- 14N-1 ", null,
 "3.1n-1", null,
 "3 n-1", null,
+"3n-1foo", null,
 
 "  n-1", [1, -1],
 " +n-1", [1, -1],
 " -n-1", [-1, -1],
 "+ n-1", null,
 "- n-1", null,
+" +n-1foo", null,
+" -n-1foo", null,
 
 
 "3N +1", [3, 1],
@@ -69,6 +72,8 @@
 "- 14n +1 ", null,
 "3.1N +1", null,
 "3 n +1", null,
+"3n foo", null,
+"3n + foo", null,
 
 "  n +1", [1, 1],
 " +N +1", [1, 1],
diff --git a/src/css-parsing-tests/component_value_list.json b/src/css-parsing-tests/component_value_list.json
index 01c9cbb1..70dc06d9 100644
--- a/src/css-parsing-tests/component_value_list.json
+++ b/src/css-parsing-tests/component_value_list.json
@@ -22,14 +22,15 @@
 	["ident", "red--"], ">"
 ],
 
-"red0 -red --red -\\-red\\ blue 0red -0red \u0000red _Red .red rêd r\\êd \u007F\u0080\u0081", [
+"\\- red0 -red --red -\\-red\\ blue 0red -0red \u0000\\\u0000red _Red .red rêd r\\êd \u007F\u0080\u0081", [
+	["ident", "-"], " ",
 	["ident", "red0"], " ",
 	["ident", "-red"], " ",
-	"-", ["ident", "-red"], " ",
+	["ident", "--red"], " ",
 	["ident", "--red blue"], " ",
 	["dimension", "0", 0, "integer", "red"], " ",
 	["dimension", "-0", 0, "integer", "red"], " ",
-	["ident", "\uFFFDred"], " ",
+	["ident", "\uFFFD\uFFFDred"], " ",
 	["ident", "_Red"], " ",
 	".", ["ident", "red"], " ",
 	["ident", "rêd"], " ",
@@ -54,7 +55,7 @@
 "rgba0() -rgba() --rgba() -\\-rgba() 0rgba() -0rgba() _rgba() .rgba() rgbâ() \\30rgba() rgba () @rgba() #rgba()", [
 	["function", "rgba0"], " ",
 	["function", "-rgba"], " ",
-	"-", ["function", "-rgba"], " ",
+	["function", "--rgba"], " ",
 	["function", "--rgba"], " ",
 	["dimension", "0", 0, "integer", "rgba"], ["()"], " ",
 	["dimension", "-0", 0, "integer", "rgba"], ["()"], " ",
@@ -70,7 +71,7 @@
 "@media0 @-Media @--media @-\\-media @0media @-0media @_media @.media @medİa @\\30 media\\", [
 	["at-keyword", "media0"], " ",
 	["at-keyword", "-Media"], " ",
-	"@", "-", ["ident", "-media"], " ",
+	["at-keyword", "--media"], " ",
 	["at-keyword", "--media"], " ",
 	"@", ["dimension", "0", 0, "integer", "media"], " ",
 	"@", ["dimension", "-0", 0, "integer", "media"], " ",
@@ -80,16 +81,17 @@
 	["at-keyword", "0media\uFFFD"]
 ],
 
-"#red0 #-Red #--red #-\\-red #0red #-0red #_Red #.red #rêd #\\.red\\", [
+"#red0 #-Red #--red #-\\-red #0red #-0red #_Red #.red #rêd #êrd #\\.red\\", [
 	["hash", "red0", "id"], " ",
 	["hash", "-Red", "id"], " ",
-	["hash", "--red", "unrestricted"], " ",
+	["hash", "--red", "id"], " ",
 	["hash", "--red", "id"], " ",
 	["hash", "0red", "unrestricted"], " ",
 	["hash", "-0red", "unrestricted"], " ",
 	["hash", "_Red", "id"], " ",
 	"#", ".", ["ident", "red"], " ",
 	["hash", "rêd", "id"], " ",
+	["hash", "êrd", "id"], " ",
 	["hash", ".red\uFFFD", "id"]
 ],
 
@@ -120,12 +122,12 @@
 	["string", "Ͷ76Ͷ76"]
 ],
 
-"url( '') url('Lorem \"îpsum\"'\n) url('a\\\nb' ) url('a\nb' \\){ ) url('eof", [
-	["url", ""], " ",
-	["url", "Lorem \"îpsum\""], " ",
-	["url", "ab"], " ",
-	["error", "bad-url"], " ",
-	["url", "eof"]
+"url( '') url('Lorem \"îpsum\"'\n) url('a\\\nb' ) url('a\nb) url('eof", [
+	["function", "url", " ", ["string", ""]], " ",
+	["function", "url", ["string", "Lorem \"îpsum\""], " "], " ",
+	["function", "url", ["string", "ab"], " "], " ",
+	["function", "url", ["error", "bad-string"], " ", ["ident", "b"]], " ",
+	["function", "url", ["string", "eof"]]
 ],
 
 "url(", [
@@ -136,17 +138,17 @@
 	["url", ""]
 ],
 
-"url(\"\") url(\"Lorem 'îpsum'\"\n) url(\"a\\\nb\" ) url(\"a\nb\" \\){ ) url(\"eof", [
-	["url", ""], " ",
-	["url", "Lorem 'îpsum'"], " ",
-	["url", "ab"], " ",
-	["error", "bad-url"], " ",
-	["url", "eof"]
+"url(\"\") url(\"Lorem 'îpsum'\"\n) url(\"a\\\nb\" ) url(\"a\nb) url(\"eof", [
+	["function", "url", ["string", ""]], " ",
+	["function", "url", ["string", "Lorem 'îpsum'"], " "], " ",
+	["function", "url", ["string", "ab"], " "], " ",
+	["function", "url", ["error", "bad-string"], " ", ["ident", "b"]], " ",
+	["function", "url", ["string", "eof"]]
 ],
 
 "url(\"Lo\\rem \\130 ps\\u m\") url('\\376\\37 6\\000376\\0000376\\", [
-	["url", "Lorem İpsu m"], " ",
-	["url", "Ͷ76Ͷ76"]
+	["function", "url", ["string", "Lorem İpsu m"]], " ",
+	["function", "url", ["string", "Ͷ76Ͷ76"]]
 ],
 
 "URL(foo) Url(foo) ûrl(foo) url (foo) url\\ (foo) url(\t 'foo' ", [
@@ -155,12 +157,18 @@
 	["function", "ûrl", ["ident", "foo"]], " ",
 	["ident", "url"], " ", ["()", ["ident", "foo"]], " ",
 	["function", "url ", ["ident", "foo"]], " ",
-	["url", "foo"]
+	["function", "url", " ", ["string", "foo"], " "]
 ],
 
-"url('a' b) url('c' d)", [["error", "bad-url"], " ", ["error", "bad-url"]],
+"url('a' b) url('c' d)", [
+	["function", "url", ["string", "a"], " ", ["ident", "b"]], " ",
+	["function", "url", ["string", "c"], " ", ["ident", "d"]]
+],
 
-"url('a\nb') url('c\n", [["error", "bad-url"], " ", ["error", "bad-url"]],
+"url('a\nb) url('c\n", [
+	["function", "url", ["error", "bad-string"], " ", ["ident", "b"]], " ",
+	["function", "url", ["error", "bad-string"], " "]
+],
 
 "url() url( \t) url(\n Foô\\030\n!\n) url(\na\nb\n) url(a\\ b) url(a(b) url(a\\(b) url(a'b) url(a\\'b) url(a\"b) url(a\\\"b) url(a\nb) url(a\\\nb) url(a\\a b) url(a\\", [
 	["url", ""], " ",
@@ -219,24 +227,24 @@
 	["number", "12", 12, "integer"], " ",
 	["number", "+34", 34, "integer"], " ",
 	["number", "-45", -45, "integer"], " ",
-	["number", ".67", 0.67, "number"], " ",
-	["number", "+.89", 0.89, "number"], " ",
-	["number", "-.01", -0.01, "number"], " ",
+	["number", "0.67", 0.67, "number"], " ",
+	["number", "+0.89", 0.89, "number"], " ",
+	["number", "-0.01", -0.01, "number"], " ",
 	["number", "2.3", 2.3, "number"], " ",
 	["number", "+45.0", 45, "number"], " ",
 	["number", "-0.67", -0.67, "number"]
 ],
 
 "12e2 +34e+1 -45E-0 .68e+3 +.79e-1 -.01E2 2.3E+1 +45.0e6 -0.67e0", [
-	["number", "12e2", 1200, "number"], " ",
-	["number", "+34e+1", 340, "number"], " ",
-	["number", "-45E-0", -45, "number"], " ",
-	["number", ".68e+3", 680, "number"], " ",
-	["number", "+.79e-1", 0.079, "number"], " ",
-	["number", "-.01E2", -1, "number"], " ",
-	["number", "2.3E+1", 23, "number"], " ",
-	["number", "+45.0e6", 45000000, "number"], " ",
-	["number", "-0.67e0", -0.67, "number"]
+	["number", "1200.0", 1200, "number"], " ",
+	["number", "+340.0", 340, "number"], " ",
+	["number", "-45.0", -45, "number"], " ",
+	["number", "680.0", 680, "number"], " ",
+	["number", "+0.079", 0.079, "number"], " ",
+	["number", "-1.0", -1, "number"], " ",
+	["number", "23.0", 23, "number"], " ",
+	["number", "+45000000.0", 45000000, "number"], " ",
+	["number", "-0.67", -0.67, "number"]
 ],
 
 "3. /* Decimal point must have following digits */", [
@@ -248,32 +256,32 @@
 ],
 
 "3e-2.1 /* Integer exponents only */", [
-	["number", "3e-2", 0.03, "number"],
-	["number", ".1", 0.1, "number"], " "
+	["number", "0.03", 0.03, "number"],
+	["number", "0.1", 0.1, "number"], " "
 ],
 
 "12% +34% -45% .67% +.89% -.01% 2.3% +45.0% -0.67%", [
 	["percentage", "12", 12, "integer"], " ",
 	["percentage", "+34", 34, "integer"], " ",
 	["percentage", "-45", -45, "integer"], " ",
-	["percentage", ".67", 0.67, "number"], " ",
-	["percentage", "+.89", 0.89, "number"], " ",
-	["percentage", "-.01", -0.01, "number"], " ",
+	["percentage", "0.67", 0.67, "number"], " ",
+	["percentage", "+0.89", 0.89, "number"], " ",
+	["percentage", "-0.01", -0.01, "number"], " ",
 	["percentage", "2.3", 2.3, "number"], " ",
 	["percentage", "+45.0", 45, "number"], " ",
 	["percentage", "-0.67", -0.67, "number"]
 ],
 
 "12e2% +34e+1% -45E-0% .68e+3% +.79e-1% -.01E2% 2.3E+1% +45.0e6% -0.67e0%", [
-	["percentage", "12e2", 1200, "number"], " ",
-	["percentage", "+34e+1", 340, "number"], " ",
-	["percentage", "-45E-0", -45, "number"], " ",
-	["percentage", ".68e+3", 680, "number"], " ",
-	["percentage", "+.79e-1", 0.079, "number"], " ",
-	["percentage", "-.01E2", -1, "number"], " ",
-	["percentage", "2.3E+1", 23, "number"], " ",
-	["percentage", "+45.0e6", 45000000, "number"], " ",
-	["percentage", "-0.67e0", -0.67, "number"]
+	["percentage", "1200.0", 1200, "number"], " ",
+	["percentage", "+340.0", 340, "number"], " ",
+	["percentage", "-45.0", -45, "number"], " ",
+	["percentage", "680.0", 680, "number"], " ",
+	["percentage", "+0.079", 0.079, "number"], " ",
+	["percentage", "-1.0", -1, "number"], " ",
+	["percentage", "23.0", 23, "number"], " ",
+	["percentage", "+45000000.0", 45000000, "number"], " ",
+	["percentage", "-0.67", -0.67, "number"]
 ],
 
 "12\\% /* Percent sign can not be escaped */", [
@@ -284,30 +292,30 @@
 	["dimension", "12", 12, "integer", "px"], " ",
 	["dimension", "+34", 34, "integer", "px"], " ",
 	["dimension", "-45", -45, "integer", "px"], " ",
-	["dimension", ".67", 0.67, "number", "px"], " ",
-	["dimension", "+.89", 0.89, "number", "px"], " ",
-	["dimension", "-.01", -0.01, "number", "px"], " ",
+	["dimension", "0.67", 0.67, "number", "px"], " ",
+	["dimension", "+0.89", 0.89, "number", "px"], " ",
+	["dimension", "-0.01", -0.01, "number", "px"], " ",
 	["dimension", "2.3", 2.3, "number", "px"], " ",
 	["dimension", "+45.0", 45, "number", "px"], " ",
 	["dimension", "-0.67", -0.67, "number", "px"]
 ],
 
 "12e2px +34e+1px -45E-0px .68e+3px +.79e-1px -.01E2px 2.3E+1px +45.0e6px -0.67e0px", [
-	["dimension", "12e2", 1200, "number", "px"], " ",
-	["dimension", "+34e+1", 340, "number", "px"], " ",
-	["dimension", "-45E-0", -45, "number", "px"], " ",
-	["dimension", ".68e+3", 680, "number", "px"], " ",
-	["dimension", "+.79e-1", 0.079, "number", "px"], " ",
-	["dimension", "-.01E2", -1, "number", "px"], " ",
-	["dimension", "2.3E+1", 23, "number", "px"], " ",
-	["dimension", "+45.0e6", 45000000, "number", "px"], " ",
-	["dimension", "-0.67e0", -0.67, "number", "px"]
+	["dimension", "1200.0", 1200, "number", "px"], " ",
+	["dimension", "+340.0", 340, "number", "px"], " ",
+	["dimension", "-45.0", -45, "number", "px"], " ",
+	["dimension", "680.0", 680, "number", "px"], " ",
+	["dimension", "+0.079", 0.079, "number", "px"], " ",
+	["dimension", "-1.0", -1, "number", "px"], " ",
+	["dimension", "23.0", 23, "number", "px"], " ",
+	["dimension", "+45000000.0", 45000000, "number", "px"], " ",
+	["dimension", "-0.67", -0.67, "number", "px"]
 ],
 
 "12red0 12.0-red 12--red 12-\\-red 120red 12-0red 12\u0000red 12_Red 12.red 12rêd", [
 	["dimension", "12", 12, "integer", "red0"], " ",
 	["dimension", "12.0", 12, "number", "-red"], " ",
-	["number", "12", 12, "integer"], "-", ["ident", "-red"], " ",
+	["dimension", "12", 12, "integer", "--red"], " ",
 	["dimension", "12", 12, "integer", "--red"], " ",
 	["dimension", "120", 120, "integer", "red"], " ",
 	["number", "12", 12, "integer"], ["dimension", "-0", 0, "integer", "red"], " ",
@@ -391,7 +399,7 @@
 ],
 
 "~=|=^=$=*=||<!------> |/**/| ~/**/=", [
-	"~=", "|=", "^=", "$=", "*=", "||", "<!--", "-", "-", "-->",
+	"~=", "|=", "^=", "$=", "*=", "||", "<!--", ["ident", "----"], ">",
 	" ", "|", "|", " ", "~", "="
 ],
 
diff --git a/src/css-parsing-tests/declaration_list.json b/src/css-parsing-tests/declaration_list.json
index 4866c703..8f171265 100644
--- a/src/css-parsing-tests/declaration_list.json
+++ b/src/css-parsing-tests/declaration_list.json
@@ -7,7 +7,22 @@
     ["declaration", "c", [["ident", "d"], " ", ["number", "42", 42, "integer"]], true]
 ],
 
-"@import 'foo.css'; a:b; @import 'bar.css'", [
+"z;a:b", [
+    ["error", "invalid"],
+    ["declaration", "a", [["ident", "b"]], false]
+],
+
+"z:x!;a:b", [
+    ["declaration", "z", [["ident", "x"], "!"], false],
+    ["declaration", "a", [["ident", "b"]], false]
+],
+
+"a:b; c+:d", [
+    ["declaration", "a", [["ident", "b"]], false],
+    ["error", "invalid"]
+],
+
+"@import 'foo.css'; a:b/**/; @import 'bar.css'", [
     ["at-rule", "import", [" ", ["string", "foo.css"]], null],
     ["declaration", "a", [["ident", "b"]], false],
     ["at-rule", "import", [" ", ["string", "bar.css"]], null]
diff --git a/src/css-parsing-tests/one_component_value.json b/src/css-parsing-tests/one_component_value.json
index b6c8a384..c487b570 100644
--- a/src/css-parsing-tests/one_component_value.json
+++ b/src/css-parsing-tests/one_component_value.json
@@ -12,7 +12,7 @@
     ["percentage", "100", 100, "integer"], ",", " ",
     ["percentage", "0", 0, "integer"], ",", " ",
     ["percentage", "50", 50, "integer"], ",", " ",
-    ["number", ".5", 0.5, "number"]
+    ["number", "0.5", 0.5, "number"]
 ],
 
 " /**/ { foo: bar; @baz [)", ["{}",
diff --git a/src/css-parsing-tests/one_declaration.json b/src/css-parsing-tests/one_declaration.json
index 00e08abb..b7fa610e 100644
--- a/src/css-parsing-tests/one_declaration.json
+++ b/src/css-parsing-tests/one_declaration.json
@@ -12,9 +12,9 @@
 "foo:", ["declaration", "foo", [], false],
 "foo :", ["declaration", "foo", [], false],
 "\n/**/ foo: ", ["declaration", "foo", [" "], false],
-"foo:;", ["declaration", "foo", [], false],
+"foo:;", ["declaration", "foo", [";"], false],
 " /**/ foo /**/ :", ["declaration", "foo", [], false],
-"foo:;bar:;", ["error", "extra-input"],
+"foo:;bar:;", ["declaration", "foo", [";", ["ident", "bar"], ":", ";"], false],
 
 "foo: 9000  !Important", ["declaration", "foo", [
     " ", ["number", "9000", 9000, "integer"], " "
@@ -23,8 +23,12 @@
     " ", ["number", "9000", 9000, "integer"], " "
 ], true],
 
-"foo: 9000  /* Dotted capital I */!İmportant", ["error", "invalid"],
-"foo: 9000  !important!", ["error", "invalid"],
+"foo: 9000  /* Dotted capital I */!İmportant", ["declaration", "foo", [
+    " ", ["number", "9000", 9000, "integer"], " ", "!", ["ident", "İmportant"]
+], false],
+"foo: 9000  !important!", ["declaration", "foo", [
+    " ", ["number", "9000", 9000, "integer"], " ", "!", ["ident", "important"], "!"
+], false],
 
 "foo: 9000  important", ["declaration", "foo", [
     " ", ["number", "9000", 9000, "integer"], " ", ["ident", "important"]
diff --git a/src/css-parsing-tests/stylesheet_bytes.json b/src/css-parsing-tests/stylesheet_bytes.json
index 8b2c512e..9f061997 100644
--- a/src/css-parsing-tests/stylesheet_bytes.json
+++ b/src/css-parsing-tests/stylesheet_bytes.json
@@ -63,6 +63,12 @@
   ["at-rule", "�", [], null]],
  "utf-8"],
 
+{"css_bytes": "@charset \"ISO-8859-5\" ; @\u00E9",
+ "comment": "@charset has to match an exact byte pattern"},
+[[["at-rule", "charset", [" ", ["string", "ISO-8859-5"], " "], null],
+  ["at-rule", "�", [], null]],
+ "utf-8"],
+
 
 {"css_bytes": "@\u0000c\u0000h\u0000a\u0000r\u0000s\u0000e\u0000t\u0000 \u0000\"\u0000U\u0000T\u0000F\u0000-\u00001\u00006\u0000L\u0000E\u0000\"\u0000;\u0000@\u0000\u00e9\u0000",
  "comment": "@charset has to be ASCII-compatible itself"},
@@ -97,6 +103,13 @@
   ["at-rule", "é", [], null]],
  "iso-8859-2"],
 
+{"css_bytes": "@charset \"ISO-8859-5\"; @\u00E9",
+ "protocol_encoding": "kamoulox",
+ "comment": "Unknow protocol encoding falls back to @charset"},
+[[["at-rule", "charset", [" ", ["string", "ISO-8859-5"]], null],
+  ["at-rule", "щ", [], null]],
+ "iso-8859-5"],
+
 
 {"css_bytes": "@\u00E9", "environment_encoding": "ISO-8859-2"},
 [[["at-rule", "é", [], null]], "iso-8859-2"],
@@ -111,6 +124,13 @@
   ["at-rule", "щ", [], null]],
  "iso-8859-5"],
 
+{"css_bytes": "@charset \"kamoulox\"; @\u00E9",
+ "environment_encoding": "ISO-8859-2",
+ "comment": "@character with unknown encoding falls back to environment encoding"},
+[[["at-rule", "charset", [" ", ["string", "kamoulox"]], null],
+  ["at-rule", "é", [], null]],
+ "iso-8859-2"],
+
 {"css_bytes": "@\u00E9",
  "protocol_encoding": "ISO-8859-2",
  "environment_encoding": "ISO-8859-5",
diff --git a/src/from_bytes.rs b/src/from_bytes.rs
index e4285d65..5dd68fa1 100644
--- a/src/from_bytes.rs
+++ b/src/from_bytes.rs
@@ -8,8 +8,7 @@ use encoding::label::encoding_from_whatwg_label;
 use encoding::all::UTF_8;
 use encoding::{EncodingRef, DecoderTrap, decode};
 
-use tokenizer::{tokenize, Tokenizer};
-use parser::{parse_stylesheet_rules, StylesheetParser};
+use super::{Parser, RuleListParser, QualifiedRuleParser, AtRuleParser};
 
 
 /// Determine the character encoding of a CSS stylesheet and decode it.
@@ -80,11 +79,18 @@ fn decode_replace(input: &[u8], fallback_encoding: EncodingRef)-> (String, Encod
 ///
 /// Returns a 2-tuple of a `Iterator<Result<Rule, SyntaxError>>`
 /// and the `Encoding` object that was used.
-pub fn parse_stylesheet_rules_from_bytes(
-        css_bytes: &[u8], protocol_encoding_label: Option<&str>,
-        environment_encoding: Option<EncodingRef>)
-     -> (StylesheetParser<Tokenizer>, EncodingRef) {
+pub fn parse_stylesheet_rules_from_bytes<QP, AP, R, P, T>(
+        css_bytes: &[u8],
+        protocol_encoding_label: Option<&str>,
+        environment_encoding: Option<EncodingRef>,
+        rules_parser: P,
+        parse: |EncodingRef, RuleListParser<R, QP, AP, P>| -> T)
+        -> T
+        where P: QualifiedRuleParser<QP, R> + AtRuleParser<AP, R> {
     let (css_unicode, encoding) = decode_stylesheet_bytes(
         css_bytes, protocol_encoding_label, environment_encoding);
-    (parse_stylesheet_rules(tokenize(css_unicode.as_slice())), encoding)
+    // FIXME: Remove option dance when unboxed closures permit.
+    let mut rules_parser = Some(rules_parser);
+    let input = &mut Parser::new(css_unicode.as_slice());
+    parse(encoding, RuleListParser::new_for_stylesheet(input, rules_parser.take().unwrap()))
 }
diff --git a/src/lib.rs b/src/lib.rs
index 66ce3d66..780f33ce 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,29 +5,66 @@
 #![crate_name = "cssparser"]
 #![crate_type = "rlib"]
 
-#![feature(globs, macro_rules)]
+#![feature(globs, macro_rules, unsafe_destructor, phase)]
 
 extern crate encoding;
 extern crate text_writer;
+#[phase(plugin)] extern crate matches;
+#[cfg(test)] extern crate test;
+#[cfg(test)] extern crate serialize;
 
-#[cfg(test)]
-extern crate test;
-
-#[cfg(test)]
-extern crate serialize;
-
-pub use color::{parse_color_keyword};
-pub use tokenizer::{tokenize, Tokenizer};
-pub use parser::{parse_stylesheet_rules, StylesheetParser,
-                 parse_rule_list, RuleListParser,
-                 parse_declaration_list, DeclarationListParser,
-                 parse_one_rule, parse_one_declaration, parse_one_component_value};
+pub use tokenizer::{Token, NumericValue, PercentageValue, SourceLocation};
+pub use rules_and_declarations::{parse_important};
+pub use rules_and_declarations::{DeclarationParser, DeclarationListParser, parse_one_declaration};
+pub use rules_and_declarations::{RuleListParser, parse_one_rule};
+pub use rules_and_declarations::{AtRuleType, QualifiedRuleParser, AtRuleParser};
 pub use from_bytes::{decode_stylesheet_bytes, parse_stylesheet_rules_from_bytes};
-pub use color::{RGBA, Color};
+pub use color::{RGBA, Color, parse_color_keyword};
 pub use nth::parse_nth;
 pub use serializer::{ToCss, CssStringWriter, serialize_identifier, serialize_string};
+pub use parser::{Parser, Delimiter, Delimiters, SourcePosition};
+
+
+/**
+
+This macro is equivalent to a `match` expression on an `&str` value,
+but matching is case-insensitive in the ASCII range.
+
+Usage example:
+
+```{rust,ignore}
+match_ignore_ascii_case! { string:
+    "foo" => Some(Foo),
+    "bar" => Some(Bar),
+    "baz" => Some(Baz)
+    _ => None
+}
+```
+
+The macro also calls `.as_slice()` on the value,
+so that a `String` or `CowString` could be passed directly instead of a `&str`.
+
+Note that because of `macro_rules` ambiguity resolutions quirks,
+each arm except the fallback and the one before it must end with a comma.
+
+*/
+#[macro_export]
+macro_rules! match_ignore_ascii_case {
+    ( $value: expr: $( $string: expr => $result: expr ),+ _ => $fallback: expr ) => {
+        {
+            use std::ascii::AsciiExt;
+            match $value.as_slice() {
+                $(
+                    s if s.eq_ignore_ascii_case($string) => $result,
+                )+
+                _ => $fallback
+            }
+        }
+    };
+}
+
 
-pub mod ast;
+mod rules_and_declarations;
 mod tokenizer;
 mod parser;
 mod from_bytes;
diff --git a/src/nth.rs b/src/nth.rs
index 9b9fd8e9..d235c953 100644
--- a/src/nth.rs
+++ b/src/nth.rs
@@ -4,68 +4,47 @@
 
 use std::ascii::AsciiExt;
 
-use ast::{ComponentValue, NumericValue, SkipWhitespaceIterator, SkipWhitespaceIterable};
-use ast::ComponentValue::{Number, Dimension, Ident, Delim};
+use super::{Token, Parser};
 
 
 /// Parse the *An+B* notation, as found in the `:nth-child()` selector.
-/// The input is typically the arguments of a function component value.
+/// The input is typically the arguments of a function,
+/// in which case the caller needs to check if the arguments’ parser is exhausted.
 /// Return `Ok((A, B))`, or `Err(())` for a syntax error.
-pub fn parse_nth(input: &[ComponentValue]) -> Result<(i32, i32), ()> {
-    let iter = &mut input.skip_whitespace();
-    match iter.next() {
-        Some(&Number(ref value)) => match value.int_value {
-            Some(b) => parse_end(iter, 0, b as i32),
-            _ => Err(()),
-        },
-        Some(&Dimension(ref value, ref unit)) => match value.int_value {
-            Some(a) => {
-                let unit = unit.as_slice().to_ascii_lower();
-                let unit = unit.as_slice();
-                match unit {
-                    "n" => parse_b(iter, a as i32),
-                    "n-" => parse_signless_b(iter, a as i32, -1),
-                    _ => match parse_n_dash_digits(unit) {
-                        Some(b) => parse_end(iter, a as i32, b),
-                        _ => Err(())
-                    },
+pub fn parse_nth(input: &mut Parser) -> Result<(i32, i32), ()> {
+    match try!(input.next()) {
+        Token::Number(value) => Ok((0, try!(value.int_value.ok_or(())) as i32)),
+        Token::Dimension(value, unit) => {
+            let a = try!(value.int_value.ok_or(())) as i32;
+            match_ignore_ascii_case! { unit:
+                "n" => parse_b(input, a),
+                "n-" => parse_signless_b(input, a, -1)
+                _ => Ok((a, try!(parse_n_dash_digits(unit.as_slice()))))
+            }
+        }
+        Token::Ident(value) => {
+            match_ignore_ascii_case! { value:
+                "even" => Ok((2, 0)),
+                "odd" => Ok((2, 1)),
+                "n" => parse_b(input, 1),
+                "-n" => parse_b(input, -1),
+                "n-" => parse_signless_b(input, 1, -1),
+                "-n-" => parse_signless_b(input, -1, -1)
+                _ => if value.starts_with("-") {
+                    Ok((-1, try!(parse_n_dash_digits(value.slice_from(1)))))
+                } else {
+                    Ok((1, try!(parse_n_dash_digits(value.as_slice()))))
                 }
-            },
-            _ => Err(()),
-        },
-        Some(&Ident(ref value)) => {
-            let ident = value.as_slice().to_ascii_lower();
-            let ident = ident.as_slice();
-            match ident {
-                "even" => parse_end(iter, 2, 0),
-                "odd" => parse_end(iter, 2, 1),
-                "n" => parse_b(iter, 1),
-                "-n" => parse_b(iter, -1),
-                "n-" => parse_signless_b(iter, 1, -1),
-                "-n-" => parse_signless_b(iter, -1, -1),
-                _ if ident.starts_with("-") => match parse_n_dash_digits(ident.slice_from(1)) {
-                    Some(b) => parse_end(iter, -1, b),
-                    _ => Err(())
-                },
-                _ =>  match parse_n_dash_digits(ident) {
-                    Some(b) => parse_end(iter, 1, b),
-                    _ => Err(())
-                },
             }
-        },
-        Some(&Delim('+')) => match iter.iter_with_whitespace.next() {
-            Some(&Ident(ref value)) => {
-                let ident = value.as_slice().to_ascii_lower();
-                let ident = ident.as_slice();
-                match ident {
-                    "n" => parse_b(iter, 1),
-                    "n-" => parse_signless_b(iter, 1, -1),
-                    _ => match parse_n_dash_digits(ident) {
-                        Some(b) => parse_end(iter, 1, b),
-                        _ => Err(())
-                    },
+        }
+        Token::Delim('+') => match try!(input.next_including_whitespace()) {
+            Token::Ident(value) => {
+                match_ignore_ascii_case! { value:
+                    "n" => parse_b(input, 1),
+                    "n-" => parse_signless_b(input, 1, -1)
+                    _ => Ok((1, try!(parse_n_dash_digits(value.as_slice()))))
                 }
-            },
+            }
             _ => Err(())
         },
         _ => Err(())
@@ -73,55 +52,37 @@ pub fn parse_nth(input: &[ComponentValue]) -> Result<(i32, i32), ()> {
 }
 
 
-type Nth = Result<(i32, i32), ()>;
-type Iter<'a> = SkipWhitespaceIterator<'a>;
-
-fn parse_b(iter: &mut Iter, a: i32) -> Nth {
-    match iter.next() {
-        None => Ok((a, 0)),
-        Some(&Delim('+')) => parse_signless_b(iter, a, 1),
-        Some(&Delim('-')) => parse_signless_b(iter, a, -1),
-        Some(&Number(ref value)) => match value.int_value {
-            Some(b) if has_sign(value) => parse_end(iter, a, b as i32),
-            _ => Err(()),
-        },
-        _ => Err(())
+fn parse_b(input: &mut Parser, a: i32) -> Result<(i32, i32), ()> {
+    let start_position = input.position();
+    match input.next() {
+        Ok(Token::Delim('+')) => parse_signless_b(input, a, 1),
+        Ok(Token::Delim('-')) => parse_signless_b(input, a, -1),
+        Ok(Token::Number(ref value)) if value.signed => {
+            Ok((a, try!(value.int_value.ok_or(())) as i32))
+        }
+        _ => {
+            input.reset(start_position);
+            Ok((a, 0))
+        }
     }
 }
 
-fn parse_signless_b(iter: &mut Iter, a: i32, b_sign: i32) -> Nth {
-    match iter.next() {
-        Some(&Number(ref value)) => match value.int_value {
-            Some(b) if !has_sign(value) => parse_end(iter, a, b_sign * (b as i32)),
-            _ => Err(()),
-        },
+fn parse_signless_b(input: &mut Parser, a: i32, b_sign: i32) -> Result<(i32, i32), ()> {
+    match try!(input.next()) {
+        Token::Number(ref value) if !value.signed => {
+            Ok((a, b_sign * (try!(value.int_value.ok_or(())) as i32)))
+        }
         _ => Err(())
     }
 }
 
-fn parse_end(iter: &mut Iter, a: i32, b: i32) -> Nth {
-    match iter.next() {
-        None => Ok((a, b)),
-        Some(_) => Err(()),
-    }
-}
-
-fn parse_n_dash_digits(string: &str) -> Option<i32> {
+fn parse_n_dash_digits(string: &str) -> Result<i32, ()> {
     if string.len() >= 3
-    && string.starts_with("n-")
-    && string.slice_from(2).chars().all(|c| match c { '0'...'9' => true, _ => false })
+    && string.slice_to(2).eq_ignore_ascii_case("n-")
+    && string.slice_from(2).chars().all(|c| matches!(c, '0'...'9'))
     {
-        let result = from_str(string.slice_from(1));  // Include the minus sign
-        assert!(result.is_some());
-        result
-    }
-    else { None }
-}
-
-#[inline]
-fn has_sign(value: &NumericValue) -> bool {
-    match value.representation.as_bytes()[0] as char {
-        '+' | '-' => true,
-        _ => false
+        Ok(from_str(string.slice_from(1)).unwrap())  // Include the minus sign
+    } else {
+        Err(())
     }
 }
diff --git a/src/parser.rs b/src/parser.rs
index 192cf040..68d3a820 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -2,274 +2,499 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-// http://dev.w3.org/csswg/css-syntax/#parsing
+use std::ascii::AsciiExt;
+use std::str::CowString;
+use std::ops;
+use tokenizer::{mod, Token, NumericValue, PercentageValue, Tokenizer, SourceLocation};
 
-/// The input to these functions needs to implement `Iterator<(ComponentValue, SourceLocation)>`.
-/// The input is consumed to avoid doing a lot of copying.
-/// A conforming input can be obtained:
-///
-/// * From a string in CSS syntax, with tokenize()
-/// * From a ~[(ComponentValue, SourceLocation)] vector
-///   (as found in "nested" component values such as CurlyBracketBlock),
-///   with v.consume_iter()
 
+#[deriving(PartialEq, Eq, Show, Clone, Copy)]
+pub struct SourcePosition {
+    position: tokenizer::SourcePosition,
+    at_start_of: Option<BlockType>,
+}
 
-use std::iter::Iterator;
-use std::ascii::AsciiExt;
 
-use ast::*;
-use ast::ComponentValue::{WhiteSpace, CDC, CDO, Ident, Delim, AtKeyword,
-                          Semicolon, Colon, CurlyBracketBlock};
+/// Like std::borrow::Cow, except:
+///
+/// * The Owned variant is boxed
+/// * The Borrowed variant contains a mutable reference.
+enum MaybeOwned<'a, T: 'a> {
+    Owned(Box<T>),
+    Borrowed(&'a mut T),
+}
 
+impl<'a, T> ops::Deref<T> for MaybeOwned<'a, T> {
+    fn deref<'a>(&'a self) -> &'a T {
+        match *self {
+            MaybeOwned::Owned(ref pointer) => &**pointer,
+            MaybeOwned::Borrowed(ref pointer) => &**pointer,
+        }
+    }
+}
 
-pub struct StylesheetParser<T>{ iter: T }
-pub struct RuleListParser<T>{ iter: T }
-pub struct DeclarationListParser<T>{ iter: T }
+impl<'a, T> ops::DerefMut<T> for MaybeOwned<'a, T> {
+    fn deref_mut<'a>(&'a mut self) -> &'a mut T {
+        match *self {
+            MaybeOwned::Owned(ref mut pointer) => &mut **pointer,
+            MaybeOwned::Borrowed(ref mut pointer) => &mut **pointer,
+        }
+    }
+}
 
-/// Parse top-level of a CSS stylesheet.
-/// Return a `Iterator<Result<Rule, SyntaxError>>`
-#[inline]
-pub fn parse_stylesheet_rules<T: Iterator<Node>>(iter: T) -> StylesheetParser<T> {
-    StylesheetParser{ iter: iter }
+impl<'a, T> Clone for MaybeOwned<'a, T> where T: Clone {
+    fn clone(&self) -> MaybeOwned<'a, T> {
+        MaybeOwned::Owned(box() (**self).clone())
+    }
 }
 
 
-/// Parse a non-top level list of rules eg. the content of an @media rule.
-/// Return a `Iterator<Result<Rule, SyntaxError>>`
-#[inline]
-pub fn parse_rule_list<T: Iterator<Node>>(iter: T) -> RuleListParser<T> {
-    RuleListParser{ iter: iter }
+#[deriving(Clone)]
+pub struct Parser<'i: 't, 't> {
+    tokenizer: MaybeOwned<'t, Tokenizer<'i>>,
+    /// If `Some(_)`, .parse_nested_block() can be called.
+    at_start_of: Option<BlockType>,
+    /// For parsers from `parse_until` or `parse_nested_block`
+    stop_before: Delimiters,
 }
 
 
-/// Parse a list of declarations and at-rules,
-/// like @page in CSS 2.1, all declaration lists in level 3
-/// Return a `Iterator<Result<DeclarationListItem, SyntaxError>>`
-#[inline]
-pub fn parse_declaration_list<T: Iterator<Node>>(iter: T) -> DeclarationListParser<T> {
-    DeclarationListParser{ iter: iter }
+#[deriving(Copy, Clone, PartialEq, Eq, Show)]
+enum BlockType {
+    Parenthesis,
+    SquareBracket,
+    CurlyBracket,
 }
 
 
-/// Parse a single rule.
-/// Used eg. for CSSRuleList.insertRule()
-pub fn parse_one_rule<T: Iterator<Node>>(iter: T) -> Result<Rule, SyntaxError> {
-    let mut parser = RuleListParser{ iter: iter };
-    match parser.next() {
-        None => error(START_LOCATION, ErrorReason::EmptyInput),
-        Some(result) => {
-            if result.is_err() { result }
-            else { match next_non_whitespace(&mut parser.iter) {
-                None => result,
-                Some((_component_value, location)) => error(location, ErrorReason::ExtraInput),
-            }}
+impl BlockType {
+    fn opening(token: &Token) -> Option<BlockType> {
+        match *token {
+            Token::Function(_) |
+            Token::ParenthesisBlock => Some(BlockType::Parenthesis),
+            Token::SquareBracketBlock => Some(BlockType::SquareBracket),
+            Token::CurlyBracketBlock => Some(BlockType::CurlyBracket),
+            _ => None
+        }
+    }
+
+    fn closing(token: &Token) -> Option<BlockType> {
+        match *token {
+            Token::CloseParenthesis => Some(BlockType::Parenthesis),
+            Token::CloseSquareBracket => Some(BlockType::SquareBracket),
+            Token::CloseCurlyBracket => Some(BlockType::CurlyBracket),
+            _ => None
         }
     }
 }
 
 
-/// Parse a single declaration (not an at-rule)
-/// Used eg. in @supports
-pub fn parse_one_declaration<T: Iterator<Node>>(mut iter: T) -> Result<Declaration, SyntaxError> {
-    match next_non_whitespace(&mut iter) {
-        None => error(START_LOCATION, ErrorReason::EmptyInput),
-        Some((component_value, location)) => {
-            let result = parse_declaration(&mut iter, component_value, location);
-            if result.is_err() { result }
-            else { match next_non_whitespace(&mut iter) {
-                None => result,
-                Some((_component_value, location)) => error(location, ErrorReason::ExtraInput),
-            }}
+
+#[deriving(Copy, Clone, PartialEq, Eq, Show)]
+pub struct Delimiters {
+    bits: u8,
+}
+
+#[allow(non_upper_case_globals, non_snake_case)]
+pub mod Delimiter {
+    use super::Delimiters;
+
+    pub const None: Delimiters = Delimiters { bits: 0 };
+    /// `{`
+    pub const CurlyBracketBlock: Delimiters = Delimiters { bits: 1 << 1 };
+    /// `;`
+    pub const Semicolon: Delimiters = Delimiters { bits: 1 << 2 };
+    /// `!`
+    pub const Bang: Delimiters = Delimiters { bits: 1 << 3 };
+    /// `,`
+    pub const Comma: Delimiters = Delimiters { bits: 1 << 4 };
+}
+
+#[allow(non_upper_case_globals, non_snake_case)]
+mod ClosingDelimiter {
+    use super::Delimiters;
+
+    pub const CloseCurlyBracket: Delimiters = Delimiters { bits: 1 << 5 };
+    pub const CloseSquareBracket: Delimiters = Delimiters { bits: 1 << 6 };
+    pub const CloseParenthesis: Delimiters = Delimiters { bits: 1 << 7 };
+}
+
+impl BitOr<Delimiters, Delimiters> for Delimiters {
+    fn bitor(&self, other: &Delimiters) -> Delimiters {
+        Delimiters { bits: self.bits | other.bits }
+    }
+}
+
+impl Delimiters {
+    fn contains(self, other: Delimiters) -> bool {
+        (self.bits & other.bits) != 0
+    }
+
+    fn from_byte(byte: Option<u8>) -> Delimiters {
+        match byte {
+            Some(b';') => Delimiter::Semicolon,
+            Some(b',') => Delimiter::Comma,
+            Some(b'!') => Delimiter::Bang,
+            Some(b'{') => Delimiter::CurlyBracketBlock,
+            Some(b'}') => ClosingDelimiter::CloseCurlyBracket,
+            Some(b']') => ClosingDelimiter::CloseSquareBracket,
+            Some(b')') => ClosingDelimiter::CloseParenthesis,
+            _ => Delimiter::None,
         }
     }
 }
 
+impl<'i, 't> Parser<'i, 't> {
+    #[inline]
+    pub fn new(input: &'i str) -> Parser<'i, 'i> {
+        Parser {
+            tokenizer: MaybeOwned::Owned(box Tokenizer::new(input)),
+            at_start_of: None,
+            stop_before: Delimiter::None,
+        }
+    }
+
+    #[inline]
+    pub fn is_exhausted(&mut self) -> bool {
+        self.expect_exhausted().is_ok()
+    }
 
-/// Parse a single component value.
-/// Used eg. in attr(foo, color)
-pub fn parse_one_component_value<T: Iterator<Node>>(mut iter: T)
-                                -> Result<ComponentValue, SyntaxError> {
-    match next_non_whitespace(&mut iter) {
-        None => error(START_LOCATION, ErrorReason::EmptyInput),
-        Some((component_value, _location)) => {
-            match next_non_whitespace(&mut iter) {
-                None => Ok(component_value),
-                Some((_component_value, location)) => error(location, ErrorReason::ExtraInput),
+    #[inline]
+    pub fn expect_exhausted(&mut self) -> Result<(), ()> {
+        let start_position = self.position();
+        let result = match self.next() {
+            Err(()) => Ok(()),
+            Ok(_) => {
+                Err(())
             }
+        };
+        self.reset(start_position);
+        result
+    }
+
+    #[inline]
+    pub fn position(&self) -> SourcePosition {
+        SourcePosition {
+            position: self.tokenizer.position(),
+            at_start_of: self.at_start_of,
         }
     }
-}
 
+    #[inline]
+    pub fn reset(&mut self, new_position: SourcePosition) {
+        self.tokenizer.reset(new_position.position);
+        self.at_start_of = new_position.at_start_of;
+    }
 
-//  ***********  End of public API  ***********
+    #[inline]
+    pub fn try<T, E>(&mut self, thing: |&mut Parser<'i, 't>| -> Result<T, E>) -> Result<T, E> {
+        let start_position = self.position();
+        let result = thing(self);
+        if result.is_err() {
+            self.reset(start_position)
+        }
+        result
+    }
+
+    #[inline]
+    pub fn slice_from(&self, start_position: SourcePosition) -> &'i str {
+        self.tokenizer.slice_from(start_position.position)
+    }
 
+    #[inline]
+    pub fn current_source_location(&self) -> SourceLocation {
+        self.tokenizer.current_source_location()
+    }
 
-// Work around "error: cannot borrow `*iter` as mutable more than once at a time"
-// when using a normal for loop.
-macro_rules! for_iter {
-    ($iter: ident, $pattern: pat, $loop_body: expr) => (
+    #[inline]
+    pub fn source_location(&self, target: SourcePosition) -> SourceLocation {
+        self.tokenizer.source_location(target.position)
+    }
+
+    pub fn next(&mut self) -> Result<Token<'i>, ()> {
         loop {
-            match $iter.next() { None => break, Some($pattern) => $loop_body }
+            match self.next_including_whitespace_and_comments() {
+                Ok(Token::WhiteSpace(_)) | Ok(Token::Comment(_)) => {},
+                result => return result
+            }
         }
-    );
-}
-
+    }
 
-impl<T: Iterator<Node>> Iterator<Result<Rule, SyntaxError>> for StylesheetParser<T> {
-    fn next(&mut self) -> Option<Result<Rule, SyntaxError>> {
-        let iter = &mut self.iter;
-        for_iter!(iter, (component_value, location), {
-            match component_value {
-                WhiteSpace | CDO | CDC => (),
-                AtKeyword(name) => return Some(Ok(
-                    Rule::AtRule(parse_at_rule(iter, name, location)))),
-                _ => return Some(match parse_qualified_rule(iter, component_value, location) {
-                    Ok(rule) => Ok(Rule::QualifiedRule(rule)),
-                    Err(e) => Err(e),
-                }),
+    pub fn next_including_whitespace(&mut self) -> Result<Token<'i>, ()> {
+        loop {
+            match self.next_including_whitespace_and_comments() {
+                Ok(Token::Comment(_)) => {},
+                result => return result
             }
-        });
-        None
+        }
     }
-}
 
+    pub fn next_including_whitespace_and_comments(&mut self) -> Result<Token<'i>, ()> {
+        if let Some(block_type) = self.at_start_of.take() {
+            consume_until_end_of_block(block_type, &mut *self.tokenizer);
+        }
+        if self.stop_before.contains(Delimiters::from_byte(self.tokenizer.next_byte())) {
+            return Err(())
+        }
+        let token = try!(self.tokenizer.next());
+        if let Some(block_type) = BlockType::opening(&token) {
+            self.at_start_of = Some(block_type);
+        }
+        Ok(token)
+    }
+
+    // FIXME: Take an unboxed `FnOnce` closure.
+    #[inline]
+    pub fn parse_entirely<T>(&mut self, parse: |&mut Parser| -> Result<T, ()>)
+                             -> Result<T, ()> {
+        let result = parse(self);
+        try!(self.expect_exhausted());
+        result
+    }
 
-impl<T: Iterator<Node>> Iterator<Result<Rule, SyntaxError>> for RuleListParser<T> {
-    fn next(&mut self) -> Option<Result<Rule, SyntaxError>> {
-        let iter = &mut self.iter;
-        for_iter!(iter, (component_value, location), {
-            match component_value {
-                WhiteSpace => (),
-                AtKeyword(name) => return Some(Ok(
-                    Rule::AtRule(parse_at_rule(iter, name, location)))),
-                _ => return Some(match parse_qualified_rule(iter, component_value, location) {
-                    Ok(rule) => Ok(Rule::QualifiedRule(rule)),
-                    Err(e) => Err(e),
-                }),
+    #[inline]
+    pub fn parse_comma_separated<T>(&mut self, parse_one: |&mut Parser| -> Result<T, ()>)
+                                    -> Result<Vec<T>, ()> {
+        let mut values = vec![];
+        loop {
+            values.push(try!(self.parse_until_before(Delimiter::Comma, |parser| parse_one(parser))));
+            match self.next() {
+                Err(()) => return Ok(values),
+                Ok(Token::Comma) => continue,
+                Ok(_) => unreachable!(),
             }
-        });
-        None
+        }
     }
-}
 
+    #[inline]
+    pub fn parse_nested_block<T>(&mut self, parse: |&mut Parser| -> Result<T, ()>)
+                                 -> Result <T, ()> {
+        let block_type = self.at_start_of.take().expect("\
+            A nested parser can only be created when a Function, \
+            ParenthesisBlock, SquareBracketBlock, or CurlyBracketBlock \
+            token was just consumed.\
+        ");
+        let closing_delimiter = match block_type {
+            BlockType::CurlyBracket => ClosingDelimiter::CloseCurlyBracket,
+            BlockType::SquareBracket => ClosingDelimiter::CloseSquareBracket,
+            BlockType::Parenthesis => ClosingDelimiter::CloseParenthesis,
+        };
+        let result;
+        // Introduce a new scope to limit duration of nested_parser’s borrow
+        {
+            let mut nested_parser = Parser {
+                tokenizer: MaybeOwned::Borrowed(&mut *self.tokenizer),
+                at_start_of: None,
+                stop_before: closing_delimiter,
+            };
+            result = nested_parser.parse_entirely(parse);
+        }
+        consume_until_end_of_block(block_type, &mut *self.tokenizer);
+        result
+    }
 
-impl<T: Iterator<Node>> Iterator<Result<DeclarationListItem, SyntaxError>>
-for DeclarationListParser<T> {
-    fn next(&mut self) -> Option<Result<DeclarationListItem, SyntaxError>> {
-        let iter = &mut self.iter;
-        for_iter!(iter, (component_value, location), {
-            match component_value {
-                WhiteSpace | Semicolon => (),
-                AtKeyword(name) => return Some(Ok(
-                    DeclarationListItem::AtRule(parse_at_rule(iter, name, location)))),
-                _ => return Some(match parse_declaration(iter, component_value, location) {
-                    Ok(declaration) => Ok(DeclarationListItem::Declaration(declaration)),
-                    Err(e) => {
-                        // Find the end of the declaration
-                        for (v, _) in *iter { if v == Semicolon { break } }
-                        Err(e)
-                    }
-                }),
+    #[inline]
+    pub fn parse_until_before<T>(&mut self, delimiters: Delimiters,
+                                 parse: |&mut Parser| -> Result<T, ()>)
+                                 -> Result <T, ()> {
+        let delimiters = self.stop_before | delimiters;
+        let result;
+        // Introduce a new scope to limit duration of nested_parser’s borrow
+        {
+            let mut delimited_parser = Parser {
+                tokenizer: MaybeOwned::Borrowed(&mut *self.tokenizer),
+                at_start_of: self.at_start_of.take(),
+                stop_before: delimiters,
+            };
+            result = delimited_parser.parse_entirely(parse);
+        }
+        // FIXME: have a special-purpose tokenizer method for this that does less work.
+        loop {
+            if delimiters.contains(Delimiters::from_byte(self.tokenizer.next_byte())) {
+                break
+            }
+            if let Ok(token) = self.tokenizer.next() {
+                if let Some(block_type) = BlockType::opening(&token) {
+                    consume_until_end_of_block(block_type, &mut *self.tokenizer);
+                }
+            } else {
+                break
             }
-        });
-        None
+        }
+        result
     }
-}
 
+    #[inline]
+    pub fn parse_until_after<T>(&mut self, delimiters: Delimiters,
+                                parse: |&mut Parser| -> Result<T, ()>)
+                                -> Result <T, ()> {
+        let result = self.parse_until_before(delimiters, parse);
+        let next_byte = self.tokenizer.next_byte();
+        if next_byte.is_some() && !self.stop_before.contains(Delimiters::from_byte(next_byte)) {
+            debug_assert!(delimiters.contains(Delimiters::from_byte(next_byte)));
+            self.tokenizer.advance(1);
+        }
+        result
+    }
 
-fn parse_at_rule<T: Iterator<Node>>(iter: &mut T, name: String, location: SourceLocation)
-                 -> AtRule {
-    let mut prelude = Vec::new();
-    let mut block = None;
-    for_iter!(iter, (component_value, _location), {
-        match component_value {
-            CurlyBracketBlock(content) => { block = Some(content); break },
-            Semicolon => break,
-            component_value => prelude.push(component_value),
+    #[inline]
+    pub fn expect_ident(&mut self) -> Result<CowString<'i>, ()> {
+        match try!(self.next()) {
+            Token::Ident(value) => Ok(value),
+            _ => Err(())
         }
-    });
-    AtRule {location: location, name: name, prelude: prelude, block: block}
-}
+    }
 
+    /// Expect an *ident* token whose value is an ASCII-insensitive match for the given value.
+    #[inline]
+    pub fn expect_ident_matching<'a>(&mut self, expected_value: &str) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::Ident(ref value) if value.eq_ignore_ascii_case(expected_value) => Ok(()),
+            _ => Err(())
+        }
+    }
 
-fn parse_qualified_rule<T: Iterator<Node>>(iter: &mut T, first: ComponentValue,
-                                           location: SourceLocation)
-                                           -> Result<QualifiedRule, SyntaxError> {
-    match first {
-        CurlyBracketBlock(content)
-        => return Ok(QualifiedRule { location: location, prelude: Vec::new(), block: content }),
-        _ => (),
+    #[inline]
+    pub fn expect_string(&mut self) -> Result<CowString<'i>, ()> {
+        match try!(self.next()) {
+            Token::QuotedString(value) => Ok(value),
+            _ => Err(())
+        }
     }
-    let mut prelude = vec!(first);
-    for_iter!(iter, (component_value, _location), {
-        match component_value {
-            CurlyBracketBlock(content)
-            => return Ok(QualifiedRule {location: location, prelude: prelude, block: content}),
-            component_value => prelude.push(component_value),
+
+    #[inline]
+    pub fn expect_ident_or_string(&mut self) -> Result<CowString<'i>, ()> {
+        match try!(self.next()) {
+            Token::Ident(value) => Ok(value),
+            Token::QuotedString(value) => Ok(value),
+            _ => Err(())
         }
-    });
-    error(location, ErrorReason::MissingQualifiedRuleBlock)
-}
+    }
 
+    #[inline]
+    pub fn expect_url(&mut self) -> Result<CowString<'i>, ()> {
+        match try!(self.next()) {
+            Token::Url(value) => Ok(value),
+            _ => Err(())
+        }
+    }
 
-fn parse_declaration<T: Iterator<Node>>(iter: &mut T, first: ComponentValue,
-                                        location: SourceLocation)
-                                        -> Result<Declaration, SyntaxError> {
-    let name = match first {
-        Ident(name) => name,
-        _ => return error(location, ErrorReason::InvalidDeclarationSyntax)
-    };
-    match next_non_whitespace(iter) {
-        Some((Colon, _)) => (),
-        _ => return error(location, ErrorReason::InvalidDeclarationSyntax),
-    }
-    let mut value = Vec::new();
-    let mut important = false;
-    for_iter!(iter, (component_value, _location), {
-        match component_value {
-            Semicolon => break,
-            Delim('!') => if parse_declaration_important(iter) {
-                important = true;
-                break
-            } else {
-                return error(location, ErrorReason::InvalidBangImportantSyntax)
-            },
-            component_value => value.push(component_value),
+    #[inline]
+    pub fn expect_url_or_string(&mut self) -> Result<CowString<'i>, ()> {
+        match try!(self.next()) {
+            Token::Url(value) => Ok(value),
+            Token::QuotedString(value) => Ok(value),
+            _ => Err(())
         }
-    });
-    Ok(Declaration{location: location, name: name, value: value, important: important})
-}
+    }
 
+    #[inline]
+    pub fn expect_number(&mut self) -> Result<f64, ()> {
+        match try!(self.next()) {
+            Token::Number(NumericValue { value, .. }) => Ok(value),
+            _ => Err(())
+        }
+    }
 
-#[inline]
-fn parse_declaration_important<T: Iterator<Node>>(iter: &mut T) -> bool {
-    let ident_value = match next_non_whitespace(iter) {
-        Some((Ident(value), _)) => value,
-        _ => return false,
-    };
-    if !ident_value.as_slice().eq_ignore_ascii_case("important") { return false }
-    match next_non_whitespace(iter) {
-        Some((Semicolon, _)) => true,
-        None => true,
-        _ => false
+    #[inline]
+    pub fn expect_integer(&mut self) -> Result<i64, ()> {
+        match try!(self.next()) {
+            Token::Number(NumericValue { int_value, .. }) => int_value.ok_or(()),
+            _ => Err(())
+        }
     }
-}
 
+    #[inline]
+    pub fn expect_percentage(&mut self) -> Result<f64, ()> {
+        match try!(self.next()) {
+            Token::Percentage(PercentageValue { unit_value, .. }) => Ok(unit_value),
+            _ => Err(())
+        }
+    }
 
-#[inline]
-fn next_non_whitespace<T: Iterator<Node>>(iter: &mut T) -> Option<Node> {
-    for (component_value, location) in *iter {
-        if component_value != WhiteSpace { return Some((component_value, location)) }
+    #[inline]
+    pub fn expect_colon(&mut self) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::Colon => Ok(()),
+            _ => Err(())
+        }
+    }
+
+    #[inline]
+    pub fn expect_semicolon(&mut self) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::Semicolon => Ok(()),
+            _ => Err(())
+        }
+    }
+
+    #[inline]
+    pub fn expect_comma(&mut self) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::Comma => Ok(()),
+            _ => Err(())
+        }
+    }
+
+    #[inline]
+    pub fn expect_delim(&mut self, expected_value: char) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::Delim(value) if value == expected_value => Ok(()),
+            _ => Err(())
+        }
+    }
+
+    #[inline]
+    pub fn expect_curly_bracket_block(&mut self) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::CurlyBracketBlock => Ok(()),
+            _ => Err(())
+        }
+    }
+
+    #[inline]
+    pub fn expect_square_bracket_block(&mut self) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::SquareBracketBlock => Ok(()),
+            _ => Err(())
+        }
     }
-    None
-}
 
+    #[inline]
+    pub fn expect_parenthesis_block(&mut self) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::ParenthesisBlock => Ok(()),
+            _ => Err(())
+        }
+    }
 
-#[inline]
-fn error<T>(location: SourceLocation, reason: ErrorReason) -> Result<T, SyntaxError> {
-    Err(SyntaxError{location: location, reason: reason})
+    #[inline]
+    pub fn expect_function(&mut self) -> Result<CowString<'i>, ()> {
+        match try!(self.next()) {
+            Token::Function(name) => Ok(name),
+            _ => Err(())
+        }
+    }
+
+    #[inline]
+    pub fn expect_function_matching(&mut self, expected_name: &str) -> Result<(), ()> {
+        match try!(self.next()) {
+            Token::Function(ref name) if name.eq_ignore_ascii_case(expected_name) => Ok(()),
+            _ => Err(())
+        }
+    }
 }
 
 
-// When parsing one thing on an empty input
-static START_LOCATION: SourceLocation = SourceLocation{ line: 1, column: 1 };
+/// Return value indicates whether the end of the input was reached.
+fn consume_until_end_of_block(block_type: BlockType, tokenizer: &mut Tokenizer) {
+    // FIXME: have a special-purpose tokenizer method for this that does less work.
+    while let Ok(ref token) = tokenizer.next() {
+        if BlockType::closing(token) == Some(block_type) {
+            return
+        }
+        if let Some(block_type) = BlockType::opening(token) {
+            consume_until_end_of_block(block_type, tokenizer);
+        }
+    }
+}
diff --git a/src/rules_and_declarations.rs b/src/rules_and_declarations.rs
new file mode 100644
index 00000000..f7d82501
--- /dev/null
+++ b/src/rules_and_declarations.rs
@@ -0,0 +1,276 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// http://dev.w3.org/csswg/css-syntax/#parsing
+
+use std::str::CowString;
+use super::{Token, Parser, Delimiter};
+
+
+pub fn parse_important(input: &mut Parser) -> Result<(), ()> {
+    try!(input.expect_delim('!'));
+    input.expect_ident_matching("important")
+}
+
+
+pub enum AtRuleType<P, R> {
+    WithoutBlock(R),
+    WithBlock(P),
+    OptionalBlock(P),
+}
+
+
+// FIXME: Use associated types
+pub trait DeclarationParser<D> {
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<D, ()> {
+        let _ = name;
+        let _ = input;
+        Err(())
+    }
+}
+
+pub trait AtRuleParser<P, R> {
+    fn parse_prelude(&mut self, name: &str, input: &mut Parser)
+                     -> Result<AtRuleType<P, R>, ()> {
+        let _ = name;
+        let _ = input;
+        Err(())
+    }
+
+    fn parse_block(&mut self, prelude: P, input: &mut Parser) -> Result<R, ()> {
+        let _ = prelude;
+        let _ = input;
+        Err(())
+    }
+
+    /// An `OptionalBlock` prelude was followed by `;`
+    fn rule_without_block(&mut self, prelude: P) -> Result<R, ()> {
+        let _ = prelude;
+        Err(())
+    }
+}
+
+pub trait QualifiedRuleParser<P, R> {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<P, ()> {
+        let _ = input;
+        Err(())
+    }
+
+    fn parse_block(&mut self, prelude: P, input: &mut Parser) -> Result<R, ()> {
+        let _ = prelude;
+        let _ = input;
+        Err(())
+    }
+}
+
+
+pub struct DeclarationListParser<'i: 't, 't: 'a, 'a, AP, I, P>
+where P: DeclarationParser<I> + AtRuleParser<AP, I> {
+    pub input: &'a mut Parser<'i, 't>,
+    pub parser: P,
+}
+
+
+impl<'i, 't, 'a, AP, I, P> DeclarationListParser<'i, 't, 'a, AP, I, P>
+where P: DeclarationParser<I> + AtRuleParser<AP, I> {
+    pub fn new(input: &'a mut Parser<'i, 't>, parser: P)
+               -> DeclarationListParser<'i, 't, 'a, AP, I, P> {
+        DeclarationListParser {
+            input: input,
+            parser: parser,
+        }
+    }
+
+    /// Parse until the input is exhausted, and ignore all results.
+    /// This can be useful when `parser` collects results by mutating itself.
+    pub fn run(mut self) -> P {
+        while let Some(_) = self.next() {}
+        self.parser
+    }
+}
+
+impl<'i, 't, 'a, AP, I, P> Iterator<Result<I, ()>>
+for DeclarationListParser<'i, 't, 'a, AP, I, P>
+where P: DeclarationParser<I> + AtRuleParser<AP, I> {
+    fn next(&mut self) -> Option<Result<I, ()>> {
+        loop {
+            match self.input.next() {
+                Ok(Token::Semicolon) => {}
+                Ok(Token::Ident(name)) => {
+                    let parser = &mut self.parser;
+                    return Some(self.input.parse_until_after(Delimiter::Semicolon, |input| {
+                        try!(input.expect_colon());
+                        parser.parse_value(name.as_slice(), input)
+                    }))
+                }
+                Ok(Token::AtKeyword(name)) => {
+                    return Some(parse_at_rule(name, self.input, &mut self.parser))
+                }
+                Ok(_) => {
+                    return Some(self.input.parse_until_after(Delimiter::Semicolon, |_| Err(())))
+                }
+                Err(()) => return None,
+            }
+        }
+    }
+}
+
+
+pub struct RuleListParser<'i: 't, 't: 'a, 'a, R, QP, AP, P>
+where P: QualifiedRuleParser<QP, R> + AtRuleParser<AP, R> {
+    pub input: &'a mut Parser<'i, 't>,
+    pub parser: P,
+    is_stylesheet: bool,
+}
+
+
+impl<'i: 't, 't: 'a, 'a, R, QP, AP, P> RuleListParser<'i, 't, 'a, R, QP, AP, P>
+where P: QualifiedRuleParser<QP, R> + AtRuleParser<AP, R> {
+    pub fn new_for_stylesheet(input: &'a mut Parser<'i, 't>, parser: P)
+                              -> RuleListParser<'i, 't, 'a, R, QP, AP, P> {
+        RuleListParser {
+            input: input,
+            parser: parser,
+            is_stylesheet: true,
+        }
+    }
+
+    pub fn new_for_nested_rule(input: &'a mut Parser<'i, 't>, parser: P)
+                               -> RuleListParser<'i, 't, 'a, R, QP, AP, P> {
+        RuleListParser {
+            input: input,
+            parser: parser,
+            is_stylesheet: false,
+        }
+    }
+
+    /// Parse until the input is exhausted, and ignore all results.
+    /// This can be useful when `parser` collects results by mutating itself.
+    pub fn run(mut self) -> P {
+        while let Some(_) = self.next() {}
+        self.parser
+    }
+}
+
+
+
+impl<'i, 't, 'a, R, QP, AP, P> Iterator<Result<R, ()>>
+for RuleListParser<'i, 't, 'a, R, QP, AP, P>
+where P: QualifiedRuleParser<QP, R> + AtRuleParser<AP, R> {
+    fn next(&mut self) -> Option<Result<R, ()>> {
+        loop {
+            let start_position = self.input.position();
+            match self.input.next_including_whitespace_and_comments() {
+                Ok(Token::WhiteSpace(_)) | Ok(Token::Comment(_)) => {}
+                Ok(Token::CDO) | Ok(Token::CDC) if self.is_stylesheet => {}
+                Ok(Token::AtKeyword(name)) => {
+                    return Some(parse_at_rule(name, self.input, &mut self.parser))
+                }
+                Ok(_) => {
+                    self.input.reset(start_position);
+                    return Some(parse_qualified_rule(self.input, &mut self.parser))
+                }
+                Err(()) => return None,
+            }
+        }
+    }
+}
+
+pub fn parse_one_declaration<D, P>(input: &mut Parser, parser: &mut P)
+                                   -> Result<D, ()>
+                                   where P: DeclarationParser<D> {
+    input.parse_entirely(|input| {
+        let name = try!(input.expect_ident());
+        try!(input.expect_colon());
+        parser.parse_value(name.as_slice(), input)
+    })
+}
+
+
+pub fn parse_one_rule<QP, AP, R, P>(input: &mut Parser, parser: &mut P)
+                                    -> Result<R, ()>
+                                    where P: QualifiedRuleParser<QP, R> + AtRuleParser<AP, R> {
+    input.parse_entirely(|input| {
+        loop {
+            let start_position = input.position();
+            match try!(input.next_including_whitespace_and_comments()) {
+                Token::WhiteSpace(_) | Token::Comment(_) => {}
+                Token::AtKeyword(name) => {
+                    return parse_at_rule(name, input, parser)
+                }
+                _ => {
+                    input.reset(start_position);
+                    return parse_qualified_rule(input, parser)
+                }
+            }
+        }
+    })
+}
+
+
+fn parse_at_rule<R, AP, P>(name: CowString, input: &mut Parser, parser: &mut P)
+                           -> Result<R, ()>
+                           where P: AtRuleParser<AP, R> {
+    let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock;
+    let result = try!(input.parse_until_before(delimiters, |input| {
+        parser.parse_prelude(name.as_slice(), input)
+    }));
+    match result {
+        AtRuleType::WithoutBlock(rule) => {
+            match input.next() {
+                Ok(Token::Semicolon) | Err(()) => Ok(rule),
+                Ok(Token::CurlyBracketBlock) => Err(()),
+                Ok(_) => unreachable!()
+            }
+        }
+        AtRuleType::WithBlock(prelude) => {
+            match input.next() {
+                Ok(Token::CurlyBracketBlock) => {
+                    // FIXME: Make parse_entirely take `FnOnce`
+                    // and remove this Option dance.
+                    let mut prelude = Some(prelude);
+                    input.parse_nested_block(|input| {
+                        parser.parse_block(prelude.take().unwrap(), input)
+                    })
+                }
+                Ok(Token::Semicolon) | Err(()) => Err(()),
+                Ok(_) => unreachable!()
+            }
+        }
+        AtRuleType::OptionalBlock(prelude) => {
+            match input.next() {
+                Ok(Token::Semicolon) | Err(()) => parser.rule_without_block(prelude),
+                Ok(Token::CurlyBracketBlock) => {
+                    // FIXME: Make parse_entirely take `FnOnce`
+                    // and remove this Option dance.
+                    let mut prelude = Some(prelude);
+                    input.parse_nested_block(|input| {
+                        parser.parse_block(prelude.take().unwrap(), input)
+                    })
+                }
+                _ => unreachable!()
+            }
+        }
+    }
+}
+
+
+fn parse_qualified_rule<R, AP, P>(input: &mut Parser, parser: &mut P)
+                                  -> Result<R, ()>
+                                  where P: QualifiedRuleParser<AP, R> {
+    let prelude = input.parse_until_before(Delimiter::CurlyBracketBlock, |input| {
+        parser.parse_prelude(input)
+    });
+    match try!(input.next()) {
+        Token::CurlyBracketBlock => {
+            // FIXME: Make parse_entirely take `FnOnce`
+            // and remove this Option dance.
+            let mut prelude = Some(try!(prelude));
+            input.parse_nested_block(|input| {
+                parser.parse_block(prelude.take().unwrap(), input)
+            })
+        }
+        _ => unreachable!(),
+    }
+}
diff --git a/src/serializer.rs b/src/serializer.rs
index ba911edf..0841db86 100644
--- a/src/serializer.rs
+++ b/src/serializer.rs
@@ -3,11 +3,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use std::fmt;
+use std::cmp;
+use std::num::{Float, Int};
 
 use text_writer::{mod, TextWriter};
 
-use ast::*;
-use ast::ComponentValue::*;
+use super::{Token, NumericValue, PercentageValue};
 
 
 pub trait ToCss for Sized? {
@@ -43,39 +44,66 @@ pub trait ToCss for Sized? {
 }
 
 
-impl ToCss for ComponentValue {
+#[inline]
+fn write_numeric<W>(value: NumericValue, dest: &mut W) -> text_writer::Result
+where W: TextWriter {
+    // `value.value >= 0` is true for negative 0.
+    if value.signed && value.value.is_positive() {
+        try!(dest.write_str("+"));
+    }
+
+    if value.value == 0.0 && value.value.is_negative() {
+        // Negative zero. Work around #20596.
+        try!(dest.write_str("-0"))
+    } else {
+        try!(write!(dest, "{}", value.value))
+    }
+
+    if value.int_value.is_none() && value.value.fract() == 0. {
+        try!(dest.write_str(".0"));
+    }
+    Ok(())
+}
+
+
+impl<'a> ToCss for Token<'a> {
     fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        match self {
-            &Ident(ref value) => try!(serialize_identifier(value.as_slice(), dest)),
-            &AtKeyword(ref value) => {
+        match *self {
+            Token::Ident(ref value) => try!(serialize_identifier(value.as_slice(), dest)),
+            Token::AtKeyword(ref value) => {
                 try!(dest.write_char('@'));
                 try!(serialize_identifier(value.as_slice(), dest));
             },
-            &Hash(ref value) => {
+            Token::Hash(ref value) => {
                 try!(dest.write_char('#'));
-                for c in value.as_slice().chars() {
+                for c in value.chars() {
                     try!(serialize_char(c, dest, /* is_identifier_start = */ false));
                 }
             },
-            &IDHash(ref value) => {
+            Token::IDHash(ref value) => {
                 try!(dest.write_char('#'));
                 try!(serialize_identifier(value.as_slice(), dest));
             }
-            &QuotedString(ref value) => try!(serialize_string(value.as_slice(), dest)),
-            &URL(ref value) => {
+            Token::QuotedString(ref value) => try!(serialize_string(value.as_slice(), dest)),
+            Token::Url(ref value) => {
                 try!(dest.write_str("url("));
                 try!(serialize_string(value.as_slice(), dest));
                 try!(dest.write_char(')'));
             },
-            &Delim(value) => try!(dest.write_char(value)),
-
-            &Number(ref value) => try!(dest.write_str(value.representation.as_slice())),
-            &Percentage(ref value) => {
-                try!(dest.write_str(value.representation.as_slice()));
+            Token::Delim(value) => try!(dest.write_char(value)),
+
+            Token::Number(value) => try!(write_numeric(value, dest)),
+            Token::Percentage(PercentageValue { unit_value, int_value, signed }) => {
+                let value = NumericValue {
+                    value: unit_value * 100.,
+                    int_value: int_value,
+                    signed: signed,
+                };
+                try!(write_numeric(value, dest));
                 try!(dest.write_char('%'));
             },
-            &Dimension(ref value, ref unit) => {
-                try!(dest.write_str(value.representation.as_slice()));
+            Token::Dimension(value, ref unit) => {
+                try!(write_numeric(value, dest));
                 // Disambiguate with scientific notation.
                 let unit = unit.as_slice();
                 if unit == "e" || unit == "E" || unit.starts_with("e-") || unit.starts_with("E-") {
@@ -88,53 +116,53 @@ impl ToCss for ComponentValue {
                 }
             },
 
-            &UnicodeRange(start, end) => {
-                try!(dest.write_str(format!("U+{:X}", start).as_slice()));
-                if end != start {
-                    try!(dest.write_str(format!("-{:X}", end).as_slice()));
+            Token::UnicodeRange(start, end) => {
+                try!(dest.write_str("U+"));
+                let bits = cmp::min(start.trailing_zeros(), (!end).trailing_zeros());
+                if bits >= 4 && start >> bits == end >> bits {
+                    let question_marks = bits / 4;
+                    let common = start >> question_marks * 4;
+                    if common != 0 {
+                        try!(write!(dest, "{:X}", common));
+                    }
+                    for _ in range(0, question_marks) {
+                        try!(dest.write_str("?"));
+                    }
+                } else {
+                    try!(write!(dest, "{:X}", start));
+                    if end != start {
+                        try!(write!(dest, "-{:X}", end));
+                    }
                 }
             }
 
-            &WhiteSpace => try!(dest.write_char(' ')),
-            &Colon => try!(dest.write_char(':')),
-            &Semicolon => try!(dest.write_char(';')),
-            &Comma => try!(dest.write_char(',')),
-            &IncludeMatch => try!(dest.write_str("~=")),
-            &DashMatch => try!(dest.write_str("|=")),
-            &PrefixMatch => try!(dest.write_str("^=")),
-            &SuffixMatch => try!(dest.write_str("$=")),
-            &SubstringMatch => try!(dest.write_str("*=")),
-            &Column => try!(dest.write_str("||")),
-            &CDO => try!(dest.write_str("<!--")),
-            &CDC => try!(dest.write_str("-->")),
-
-            &Function(ref name, ref arguments) => {
+            Token::WhiteSpace(content) => try!(dest.write_str(content)),
+            Token::Comment(content) => try!(write!(dest, "/*{}*/", content)),
+            Token::Colon => try!(dest.write_char(':')),
+            Token::Semicolon => try!(dest.write_char(';')),
+            Token::Comma => try!(dest.write_char(',')),
+            Token::IncludeMatch => try!(dest.write_str("~=")),
+            Token::DashMatch => try!(dest.write_str("|=")),
+            Token::PrefixMatch => try!(dest.write_str("^=")),
+            Token::SuffixMatch => try!(dest.write_str("$=")),
+            Token::SubstringMatch => try!(dest.write_str("*=")),
+            Token::Column => try!(dest.write_str("||")),
+            Token::CDO => try!(dest.write_str("<!--")),
+            Token::CDC => try!(dest.write_str("-->")),
+
+            Token::Function(ref name) => {
                 try!(serialize_identifier(name.as_slice(), dest));
                 try!(dest.write_char('('));
-                try!(arguments.to_css(dest));
-                try!(dest.write_char(')'));
-            },
-            &ParenthesisBlock(ref content) => {
-                try!(dest.write_char('('));
-                try!(content.to_css(dest));
-                try!(dest.write_char(')'));
-            },
-            &SquareBracketBlock(ref content) => {
-                try!(dest.write_char('['));
-                try!(content.to_css(dest));
-                try!(dest.write_char(']'));
             },
-            &CurlyBracketBlock(ref content) => {
-                try!(dest.write_char('{'));
-                try!(content.to_css(dest));
-                try!(dest.write_char('}'));
-            },
-
-            &BadURL => try!(dest.write_str("url(<bad url>)")),
-            &BadString => try!(dest.write_str("\"<bad string>\n")),
-            &CloseParenthesis => try!(dest.write_char(')')),
-            &CloseSquareBracket => try!(dest.write_char(']')),
-            &CloseCurlyBracket => try!(dest.write_char('}')),
+            Token::ParenthesisBlock => try!(dest.write_char('(')),
+            Token::SquareBracketBlock => try!(dest.write_char('[')),
+            Token::CurlyBracketBlock => try!(dest.write_char('{')),
+
+            Token::BadUrl => try!(dest.write_str("url(<bad url>)")),
+            Token::BadString => try!(dest.write_str("\"<bad string>\n")),
+            Token::CloseParenthesis => try!(dest.write_char(')')),
+            Token::CloseSquareBracket => try!(dest.write_char(']')),
+            Token::CloseCurlyBracket => try!(dest.write_char('}')),
         }
         Ok(())
     }
@@ -164,7 +192,7 @@ where W:TextWriter {
 fn serialize_char<W>(c: char, dest: &mut W, is_identifier_start: bool) -> text_writer::Result
 where W: TextWriter {
     match c {
-        '0'...'9' if is_identifier_start => try!(dest.write_str(format!("\\3{} ", c).as_slice())),
+        '0'...'9' if is_identifier_start => try!(write!(dest, "\\3{} ", c)),
         '-' if is_identifier_start => try!(dest.write_str("\\-")),
         '0'...'9' | 'A'...'Z' | 'a'...'z' | '_' | '-' => try!(dest.write_char(c)),
         _ if c > '\x7F' => try!(dest.write_char(c)),
@@ -232,163 +260,3 @@ impl<'a, W> TextWriter for CssStringWriter<'a, W> where W: TextWriter {
         }
     }
 }
-
-
-impl<'a> ToCss for [ComponentValue] {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        component_values_to_css(self.iter(), dest)
-    }
-}
-
-impl<'a> ToCss for [Node] {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        let component_values = self.iter().map(|n| match n { &(ref c, _) => c });
-        component_values_to_css(component_values, dest)
-    }
-}
-
-fn component_values_to_css<'a, I, W>(mut iter: I, dest: &mut W) -> text_writer::Result
-where I: Iterator<&'a ComponentValue>, W: TextWriter {
-    let mut previous = match iter.next() {
-        None => return Ok(()),
-        Some(first) => { try!(first.to_css(dest)); first }
-    };
-    macro_rules! matches(
-        ($value:expr, $($pattern:pat)|+) => (
-            match $value { $($pattern)|+ => true, _ => false }
-        );
-    );
-    // This does not borrow-check: for component_value in iter {
-    loop { match iter.next() { None => break, Some(component_value) => {
-        let (a, b) = (previous, component_value);
-        if (
-            matches!(*a, Ident(..) | AtKeyword(..) | Hash(..) | IDHash(..) |
-                         Dimension(..) | Delim('#') | Delim('-') | Number(..)) &&
-            matches!(*b, Ident(..) | Function(..) | URL(..) | BadURL(..) |
-                         Number(..) | Percentage(..) | Dimension(..) | UnicodeRange(..))
-        ) || (
-            matches!(*a, Ident(..)) &&
-            matches!(*b, ParenthesisBlock(..))
-        ) || (
-            matches!(*a, Ident(..) | AtKeyword(..) | Hash(..) | IDHash(..) | Dimension(..)) &&
-            matches!(*b, Delim('-') | CDC)
-        ) || (
-            matches!(*a, Delim('#') | Delim('-') | Number(..) | Delim('@')) &&
-            matches!(*b, Ident(..) | Function(..) | URL(..) | BadURL(..))
-        ) || (
-            matches!(*a, Delim('@')) &&
-            matches!(*b, Ident(..) | Function(..) | URL(..) | BadURL(..) |
-                         UnicodeRange(..) | Delim('-'))
-        ) || (
-            matches!(*a, UnicodeRange(..) | Delim('.') | Delim('+')) &&
-            matches!(*b, Number(..) | Percentage(..) | Dimension(..))
-        ) || (
-            matches!(*a, UnicodeRange(..)) &&
-            matches!(*b, Ident(..) | Function(..) | Delim('?'))
-        ) || (match (a, b) { (&Delim(a), &Delim(b)) => matches!((a, b),
-            ('#', '-') |
-            ('$', '=') |
-            ('*', '=') |
-            ('^', '=') |
-            ('~', '=') |
-            ('|', '=') |
-            ('|', '|') |
-            ('/', '*')
-        ), _ => false }) {
-            try!(dest.write_str("/**/"));
-        }
-        // Skip whitespace when '\n' was previously written at the previous iteration.
-        if !matches!((previous, component_value), (&Delim('\\'), &WhiteSpace)) {
-            try!(component_value.to_css(dest));
-        }
-        if component_value == &Delim('\\') {
-            try!(dest.write_char('\n'));
-        }
-        previous = component_value;
-    }}}
-    Ok(())
-}
-
-
-impl ToCss for Declaration {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        try!(dest.write_str(self.name.as_slice()));
-        try!(dest.write_char(':'));
-        try!(self.value.to_css(dest));
-        Ok(())
-    }
-}
-
-
-impl ToCss for [Declaration] {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        for declaration in self.iter() {
-            try!(declaration.to_css(dest));
-            try!(dest.write_char(';'));
-        }
-        Ok(())
-    }
-}
-
-
-impl ToCss for QualifiedRule {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        try!(self.prelude.to_css(dest));
-        try!(dest.write_char('{'));
-        try!(self.block.to_css(dest));
-        try!(dest.write_char('}'));
-        Ok(())
-    }
-}
-
-
-impl ToCss for AtRule {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        try!(dest.write_char('@'));
-        try!(dest.write_str(self.name.as_slice()));
-        try!(self.prelude.to_css(dest));
-        match self.block {
-            Some(ref block) => {
-                try!(dest.write_char('{'));
-                try!(block.to_css(dest));
-                try!(dest.write_char('}'));
-            }
-            None => try!(dest.write_char(';'))
-        }
-        Ok(())
-    }
-}
-
-
-impl ToCss for DeclarationListItem {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        match self {
-            &DeclarationListItem::Declaration(ref declaration) => declaration.to_css(dest),
-            &DeclarationListItem::AtRule(ref at_rule) => at_rule.to_css(dest),
-        }
-    }
-}
-
-
-impl ToCss for [DeclarationListItem] {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        for item in self.iter() {
-            try!(item.to_css(dest));
-            match item {
-                &DeclarationListItem::AtRule(_) => {}
-                &DeclarationListItem::Declaration(_) => try!(dest.write_char(';'))
-            }
-        }
-        Ok(())
-    }
-}
-
-
-impl ToCss for Rule {
-    fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
-        match self {
-            &Rule::QualifiedRule(ref rule) => rule.to_css(dest),
-            &Rule::AtRule(ref rule) => rule.to_css(dest),
-        }
-    }
-}
diff --git a/src/tests.rs b/src/tests.rs
index 6e50a81d..b4465b75 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -2,24 +2,26 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::io;
-use std::io::{File, Command, Writer, TempDir, IoResult};
+use std::borrow::Cow::Borrowed;
+use std::io::{mod, File, Command, Writer, TempDir, IoResult};
 use std::num::Float;
+use std::mem;
 use serialize::json::{mod, Json, ToJson};
 use test;
 
 use encoding::label::encoding_from_whatwg_label;
 
-use super::*;
-use ast::*;
-use ast::ComponentValue::*;
+use super::{Parser, Token, NumericValue, PercentageValue, SourceLocation,
+            DeclarationListParser, DeclarationParser, RuleListParser,
+            AtRuleType, AtRuleParser, QualifiedRuleParser,
+            parse_one_declaration, parse_one_rule, parse_important,
+            parse_stylesheet_rules_from_bytes,
+            Color, RGBA, parse_color_keyword, parse_nth, ToCss};
 
-macro_rules! JString {
-    ($e: expr) => { Json::String($e.to_string()) }
-}
 
 macro_rules! JArray {
-    ($($e: expr),*) => { Json::Array(vec!( $($e),* )) }
+    ($($e: expr,)*) => { JArray![ $( $e ),* ] };
+    ($($e: expr),*) => { Json::Array(vec!( $( $e.to_json() ),* )) }
 }
 
 
@@ -61,17 +63,68 @@ fn almost_equals(a: &Json, b: &Json) -> bool {
 
         (&Json::Boolean(a), &Json::Boolean(b)) => a == b,
         (&Json::String(ref a), &Json::String(ref b)) => a == b,
-        (&Json::Array(ref a), &Json::Array(ref b))
-            => a.iter().zip(b.iter()).all(|(ref a, ref b)| almost_equals(*a, *b)),
-        (&Json::Object(_), &Json::Object(_))
-            => panic!("Not implemented"),
+        (&Json::Array(ref a), &Json::Array(ref b)) => {
+            a.len() == b.len() &&
+            a.iter().zip(b.iter()).all(|(ref a, ref b)| almost_equals(*a, *b))
+        },
+        (&Json::Object(_), &Json::Object(_)) => panic!("Not implemented"),
         (&Json::Null, &Json::Null) => true,
         _ => false,
     }
 }
 
+fn normalize(json: &mut Json) {
+    match *json {
+        Json::Array(ref mut list) => {
+            match find_url(list.as_mut_slice()) {
+                Some(Ok(url)) => *list = vec!["url".to_json(), Json::String(url)],
+                Some(Err(())) => *list = vec!["error".to_json(), "bad-url".to_json()],
+                None => {
+                    for item in list.iter_mut() {
+                        normalize(item)
+                    }
+                }
+            }
+        }
+        Json::String(ref mut s) => {
+            if s.as_slice() == "extra-input" || s.as_slice() == "empty" {
+                *s = "invalid".into_string()
+            }
+        }
+        _ => {}
+    }
+}
 
-fn assert_json_eq(results: Json, expected: Json, message: String) {
+fn find_url(list: &mut [Json]) -> Option<Result<String, ()>> {
+    if let [Json::String(ref a1), Json::String(ref a2), ..] = list.as_mut_slice() {
+        if !(a1.as_slice() == "function" && a2.as_slice() == "url") {
+            return None
+        }
+    } else {
+        return None
+    };
+    let args = list.slice_from_mut(2);
+
+    let args = if !args.is_empty() && args[0] == " ".to_json() {
+        args.slice_from_mut(1)
+    } else {
+        args.as_mut_slice()
+    };
+
+    if let [Json::Array(ref mut arg1), ref rest..] = args.as_mut_slice() {
+        if let [Json::String(ref a11), Json::String(ref mut a12)] = arg1.as_mut_slice() {
+            if a11.as_slice() == "string" && rest.iter().all(|a| a == &" ".to_json()) {
+                return Some(Ok(mem::replace(a12, String::new())))
+            }
+        }
+    }
+
+    Some(Err(()))
+}
+
+
+fn assert_json_eq(results: json::Json, mut expected: json::Json, message: String) {
+    normalize(&mut expected);
     if !almost_equals(&results, &expected) {
         print_json_diff(&results, &expected).unwrap();
         panic!(message)
@@ -98,11 +151,11 @@ fn run_raw_json_tests(json_data: &str, run: |Json, Json|) {
 }
 
 
-fn run_json_tests<T: ToJson>(json_data: &str, parse: |input: &str| -> T) {
+fn run_json_tests(json_data: &str, parse: |input: &mut Parser| -> Json) {
     run_raw_json_tests(json_data, |input, expected| {
         match input {
             Json::String(input) => {
-                let result = parse(input.as_slice()).to_json();
+                let result = parse(&mut Parser::new(input.as_slice()));
                 assert_json_eq(result, expected, input);
             },
             _ => panic!("Unexpected JSON")
@@ -114,7 +167,7 @@ fn run_json_tests<T: ToJson>(json_data: &str, parse: |input: &str| -> T) {
 #[test]
 fn component_value_list() {
     run_json_tests(include_str!("css-parsing-tests/component_value_list.json"), |input| {
-        tokenize(input).map(|(c, _)| c).collect::<Vec<ComponentValue>>()
+        Json::Array(component_values_to_json(input))
     });
 }
 
@@ -122,7 +175,9 @@ fn component_value_list() {
 #[test]
 fn one_component_value() {
     run_json_tests(include_str!("css-parsing-tests/one_component_value.json"), |input| {
-        parse_one_component_value(tokenize(input))
+        input.parse_entirely(|input| {
+            Ok(one_component_value_to_json(try!(input.next()), input))
+        }).unwrap_or(JArray!["error", "invalid"])
     });
 }
 
@@ -130,7 +185,9 @@ fn one_component_value() {
 #[test]
 fn declaration_list() {
     run_json_tests(include_str!("css-parsing-tests/declaration_list.json"), |input| {
-        parse_declaration_list(tokenize(input)).collect::<Vec<Result<DeclarationListItem, SyntaxError>>>()
+        Json::Array(DeclarationListParser::new(input, JsonParser).map(|result| {
+            result.unwrap_or(JArray!["error", "invalid"])
+        }).collect())
     });
 }
 
@@ -138,7 +195,7 @@ fn declaration_list() {
 #[test]
 fn one_declaration() {
     run_json_tests(include_str!("css-parsing-tests/one_declaration.json"), |input| {
-        parse_one_declaration(tokenize(input))
+        parse_one_declaration(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"])
     });
 }
 
@@ -146,7 +203,9 @@ fn one_declaration() {
 #[test]
 fn rule_list() {
     run_json_tests(include_str!("css-parsing-tests/rule_list.json"), |input| {
-        parse_rule_list(tokenize(input)).collect::<Vec<Result<Rule, SyntaxError>>>()
+        Json::Array(RuleListParser::new_for_nested_rule(input, JsonParser).map(|result| {
+            result.unwrap_or(JArray!["error", "invalid"])
+        }).collect())
     });
 }
 
@@ -154,7 +213,9 @@ fn rule_list() {
 #[test]
 fn stylesheet() {
     run_json_tests(include_str!("css-parsing-tests/stylesheet.json"), |input| {
-        parse_stylesheet_rules(tokenize(input)).collect::<Vec<Result<Rule, SyntaxError>>>()
+        Json::Array(RuleListParser::new_for_stylesheet(input, JsonParser).map(|result| {
+            result.unwrap_or(JArray!["error", "invalid"])
+        }).collect())
     });
 }
 
@@ -162,7 +223,7 @@ fn stylesheet() {
 #[test]
 fn one_rule() {
     run_json_tests(include_str!("css-parsing-tests/one_rule.json"), |input| {
-        parse_one_rule(tokenize(input))
+        parse_one_rule(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"])
     });
 }
 
@@ -170,7 +231,7 @@ fn one_rule() {
 #[test]
 fn stylesheet_from_bytes() {
     run_raw_json_tests(include_str!("css-parsing-tests/stylesheet_bytes.json"),
-    |input, expected| {
+                       |input, expected| {
         let map = match input {
             Json::Object(map) => map,
             _ => panic!("Unexpected JSON")
@@ -185,10 +246,16 @@ fn stylesheet_from_bytes() {
             let environment_encoding = get_string(&map, "environment_encoding")
                 .and_then(encoding_from_whatwg_label);
 
-            let (rules, used_encoding) = parse_stylesheet_rules_from_bytes(
-                css.as_slice(), protocol_encoding_label, environment_encoding);
-
-            (rules.collect::<Vec<_>>(), used_encoding.name().to_string()).to_json()
+            parse_stylesheet_rules_from_bytes(
+                css.as_slice(), protocol_encoding_label, environment_encoding,
+                JsonParser, |encoding, rules| {
+                    Json::Array(vec![
+                        Json::Array(rules.map(|result| {
+                            result.unwrap_or(JArray!["error", "invalid"])
+                        }).collect()),
+                        encoding.name().to_json()
+                    ])
+                })
         };
         assert_json_eq(result, expected, Json::Object(map).to_string());
     });
@@ -204,25 +271,22 @@ fn stylesheet_from_bytes() {
 }
 
 
-fn run_color_tests(json_data: &str, to_json: |result: Option<Color>| -> Json) {
+fn run_color_tests(json_data: &str, to_json: |result: Result<Color, ()>| -> Json) {
     run_json_tests(json_data, |input| {
-        match parse_one_component_value(tokenize(input)) {
-            Ok(component_value) => to_json(Color::parse(&component_value).ok()),
-            Err(_reason) => Json::Null,
-        }
+        to_json(input.parse_entirely(Color::parse))
     });
 }
 
 
 #[test]
 fn color3() {
-    run_color_tests(include_str!("css-parsing-tests/color3.json"), |c| c.to_json())
+    run_color_tests(include_str!("css-parsing-tests/color3.json"), |c| c.ok().to_json())
 }
 
 
 #[test]
 fn color3_hsl() {
-    run_color_tests(include_str!("css-parsing-tests/color3_hsl.json"), |c| c.to_json())
+    run_color_tests(include_str!("css-parsing-tests/color3_hsl.json"), |c| c.ok().to_json())
 }
 
 
@@ -231,10 +295,10 @@ fn color3_hsl() {
 fn color3_keywords() {
     run_color_tests(include_str!("css-parsing-tests/color3_keywords.json"), |c| {
         match c {
-            Some(Color::RGBA(RGBA { red: r, green: g, blue: b, alpha: a }))
-            => vec!(r * 255., g * 255., b * 255., a).to_json(),
-            Some(Color::CurrentColor) => JString!("currentColor"),
-            None => Json::Null,
+            Ok(Color::RGBA(RGBA { red: r, green: g, blue: b, alpha: a }))
+            => [r * 255., g * 255., b * 255., a].to_json(),
+            Ok(Color::CurrentColor) => "currentColor".to_json(),
+            Err(()) => Json::Null,
         }
     });
 }
@@ -242,29 +306,32 @@ fn color3_keywords() {
 
 #[bench]
 fn bench_color_lookup_red(b: &mut test::Bencher) {
-    let ident = parse_one_component_value(tokenize("red")).unwrap();
-    b.iter(|| assert!(Color::parse(&ident).is_ok()));
+    b.iter(|| {
+        test::black_box(parse_color_keyword("red"))
+    });
 }
 
 
 #[bench]
 fn bench_color_lookup_lightgoldenrodyellow(b: &mut test::Bencher) {
-    let ident = parse_one_component_value(tokenize("lightgoldenrodyellow")).unwrap();
-    b.iter(|| assert!(Color::parse(&ident).is_ok()));
+    b.iter(|| {
+        test::black_box(parse_color_keyword("lightgoldenrodyellow"))
+    });
 }
 
 
 #[bench]
 fn bench_color_lookup_fail(b: &mut test::Bencher) {
-    let ident = parse_one_component_value(tokenize("lightgoldenrodyellowbazinga")).unwrap();
-    b.iter(|| assert!(Color::parse(&ident).is_err()));
+    b.iter(|| {
+        test::black_box(parse_color_keyword("lightgoldenrodyellowbazinga"))
+    });
 }
 
 
 #[test]
 fn nth() {
     run_json_tests(include_str!("css-parsing-tests/An+B.json"), |input| {
-        parse_nth(tokenize(input).map(|(c, _)| c).collect::<Vec<ComponentValue>>().as_slice()).ok()
+        input.parse_entirely(parse_nth).ok().to_json()
     });
 }
 
@@ -272,9 +339,28 @@ fn nth() {
 #[test]
 fn serializer() {
     run_json_tests(include_str!("css-parsing-tests/component_value_list.json"), |input| {
-        let component_values = tokenize(input).map(|(c, _)| c).collect::<Vec<ComponentValue>>();
-        let serialized = component_values.to_css_string();
-        tokenize(serialized.as_slice()).map(|(c, _)| c).collect::<Vec<ComponentValue>>()
+        fn write_to(input: &mut Parser, string: &mut String) {
+            while let Ok(token) = input.next_including_whitespace_and_comments() {
+                token.to_css(string).unwrap();
+                let closing_token = match token {
+                    Token::Function(_) | Token::ParenthesisBlock => Some(Token::CloseParenthesis),
+                    Token::SquareBracketBlock => Some(Token::CloseSquareBracket),
+                    Token::CurlyBracketBlock => Some(Token::CloseCurlyBracket),
+                    _ => None
+                };
+                if let Some(closing_token) = closing_token {
+                    input.parse_nested_block(|input| {
+                        write_to(input, string);
+                        Ok(())
+                    }).unwrap();
+                    closing_token.to_css(string).unwrap();
+                }
+            }
+        }
+        let mut serialized = String::new();
+        write_to(input, &mut serialized);
+        let parser = &mut Parser::new(serialized.as_slice());
+        Json::Array(component_values_to_json(parser))
     });
 }
 
@@ -282,212 +368,202 @@ fn serializer() {
 #[test]
 fn serialize_current_color() {
     let c = Color::CurrentColor;
-    assert!(format!("{}", c).as_slice() == "currentColor");
+    assert!(c.to_css_string().as_slice() == "currentColor");
 }
 
 
 #[test]
 fn serialize_rgb_full_alpha() {
     let c = Color::RGBA(RGBA { red: 1.0, green: 0.9, blue: 0.8, alpha: 1.0 });
-    assert!(format!("{}", c).as_slice() == "rgb(255, 230, 204)");
+    assert!(c.to_css_string().as_slice() == "rgb(255, 230, 204)");
 }
 
 
 #[test]
 fn serialize_rgba() {
     let c = Color::RGBA(RGBA { red: 0.1, green: 0.2, blue: 0.3, alpha: 0.5 });
-    assert!(format!("{}", c).as_slice() == "rgba(26, 51, 77, 0.5)");
+    assert!(c.to_css_string().as_slice() == "rgba(26, 51, 77, 0.5)");
 }
 
-
-impl ToJson for Result<Rule, SyntaxError> {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            Ok(ref a) => a.to_json(),
-            Err(ref b) => b.to_json(),
-        }
-    }
+#[test]
+fn line_numbers() {
+    let mut input = Parser::new("foo bar\nbaz\r\n\n\"a\\\r\nb\"");
+    assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 1 });
+    assert_eq!(input.next_including_whitespace(), Ok(Token::Ident(Borrowed("foo"))));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 4 });
+    assert_eq!(input.next_including_whitespace(), Ok(Token::WhiteSpace(" ")));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 5 });
+    assert_eq!(input.next_including_whitespace(), Ok(Token::Ident(Borrowed("bar"))));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 8 });
+    assert_eq!(input.next_including_whitespace(), Ok(Token::WhiteSpace("\n")));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 2, column: 1 });
+    assert_eq!(input.next_including_whitespace(), Ok(Token::Ident(Borrowed("baz"))));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 2, column: 4 });
+    let position = input.position();
+
+    assert_eq!(input.next_including_whitespace(), Ok(Token::WhiteSpace("\r\n\n")));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 4, column: 1 });
+
+    assert_eq!(input.source_location(position), SourceLocation { line: 2, column: 4 });
+
+    assert_eq!(input.next_including_whitespace(), Ok(Token::QuotedString(Borrowed("ab"))));
+    assert_eq!(input.current_source_location(), SourceLocation { line: 5, column: 3 });
+    assert_eq!(input.next_including_whitespace(), Err(()));
 }
 
-
-impl ToJson for Result<DeclarationListItem, SyntaxError> {
+impl ToJson for Color {
     fn to_json(&self) -> json::Json {
         match *self {
-            Ok(ref a) => a.to_json(),
-            Err(ref b) => b.to_json(),
+            Color::RGBA(RGBA { red, green, blue, alpha }) => {
+                [red, green, blue, alpha].to_json()
+            },
+            Color::CurrentColor => "currentColor".to_json(),
         }
     }
 }
 
 
-impl ToJson for Result<Declaration, SyntaxError> {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            Ok(ref a) => a.to_json(),
-            Err(ref b) => b.to_json(),
+struct JsonParser;
+
+
+impl DeclarationParser<Json> for JsonParser {
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<Json, ()> {
+        let mut value = vec![];
+        let mut important = false;
+        loop {
+            let start_position = input.position();
+            if let Ok(mut token) = input.next_including_whitespace() {
+                // Hack to deal with css-parsing-tests assuming that
+                // `!important` in the middle of a declaration value is OK.
+                // This can never happen per spec
+                // (even CSS Variables forbid top-level `!`)
+                if token == Token::Delim('!') {
+                    input.reset(start_position);
+                    if parse_important(input).is_ok() {
+                        if input.is_exhausted() {
+                            important = true;
+                            break
+                        }
+                    }
+                    input.reset(start_position);
+                    token = input.next_including_whitespace().unwrap();
+                }
+                value.push(one_component_value_to_json(token, input));
+            } else {
+                break
+            }
         }
+        Ok(JArray![
+            "declaration",
+            name,
+            value,
+            important,
+        ])
     }
 }
 
-
-impl ToJson for Result<ComponentValue, SyntaxError> {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            Ok(ref a) => a.to_json(),
-            Err(ref b) => b.to_json(),
-        }
+impl AtRuleParser<Vec<Json>, Json> for JsonParser {
+    fn parse_prelude(&mut self, name: &str, input: &mut Parser)
+                     -> Result<AtRuleType<Vec<Json>, Json>, ()> {
+        Ok(AtRuleType::OptionalBlock(vec![
+            "at-rule".to_json(),
+            name.to_json(),
+            Json::Array(component_values_to_json(input)),
+        ]))
     }
-}
-
 
-impl ToJson for SyntaxError {
-    fn to_json(&self) -> json::Json {
-        Json::Array(vec!(JString!("error"), JString!(match self.reason {
-            ErrorReason::EmptyInput => "empty",
-            ErrorReason::ExtraInput => "extra-input",
-            _ => "invalid",
-        })))
+    fn parse_block(&mut self, mut prelude: Vec<Json>, input: &mut Parser) -> Result<Json, ()> {
+        prelude.push(Json::Array(component_values_to_json(input)));
+        Ok(Json::Array(prelude))
     }
-}
-
 
-impl ToJson for Color {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            Color::RGBA(RGBA { red: r, green: g, blue: b, alpha: a }) => vec!(r, g, b, a).to_json(),
-            Color::CurrentColor => JString!("currentColor"),
-        }
+    fn rule_without_block(&mut self, mut prelude: Vec<Json>) -> Result<Json, ()> {
+        prelude.push(Json::Null);
+        Ok(Json::Array(prelude))
     }
 }
 
-
-impl ToJson for Rule {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            Rule::QualifiedRule(ref rule) => rule.to_json(),
-            Rule::AtRule(ref rule) => rule.to_json(),
-        }
+impl QualifiedRuleParser<Vec<Json>, Json> for JsonParser {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<Vec<Json>, ()> {
+        Ok(component_values_to_json(input))
     }
-}
 
-
-impl ToJson for DeclarationListItem {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            DeclarationListItem::Declaration(ref declaration) => declaration.to_json(),
-            DeclarationListItem::AtRule(ref at_rule) => at_rule.to_json(),
-        }
+    fn parse_block(&mut self, prelude: Vec<Json>, input: &mut Parser) -> Result<Json, ()> {
+        Ok(JArray![
+            "qualified rule",
+            prelude,
+            component_values_to_json(input),
+        ])
     }
 }
 
-
-fn list_to_json(list: &Vec<(ComponentValue, SourceLocation)>) -> Vec<json::Json> {
-    list.iter().map(|tuple| {
-        match *tuple {
-            (ref c, _) => c.to_json()
-        }
-    }).collect()
-}
-
-
-impl ToJson for AtRule {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            AtRule{ ref name, ref prelude, ref block, ..}
-            => Json::Array(vec!(JString!("at-rule"), name.to_json(),
-                                prelude.to_json(), block.as_ref().map(list_to_json).to_json()))
-        }
+fn component_values_to_json(input: &mut Parser) -> Vec<Json> {
+    let mut values = vec![];
+    while let Ok(token) = input.next_including_whitespace() {
+        values.push(one_component_value_to_json(token, input));
     }
+    values
 }
 
 
-impl ToJson for QualifiedRule {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            QualifiedRule{ ref prelude, ref block, ..}
-            => Json::Array(vec!(JString!("qualified rule"),
-                                prelude.to_json(), Json::Array(list_to_json(block))))
-        }
+fn one_component_value_to_json(token: Token, input: &mut Parser) -> Json {
+    fn numeric(value: NumericValue) -> Vec<json::Json> {
+        vec![
+            Token::Number(value).to_css_string().to_json(),
+            match value.int_value { Some(i) => i.to_json(), None => value.value.to_json() },
+            match value.int_value { Some(_) => "integer", None => "number" }.to_json()
+        ]
     }
-}
 
-
-impl ToJson for Declaration {
-    fn to_json(&self) -> json::Json {
-        match *self {
-            Declaration{ ref name, ref value, ref important, ..}
-            =>  Json::Array(vec!(JString!("declaration"), name.to_json(),
-                                 value.to_json(), important.to_json()))
-        }
+    fn nested(input: &mut Parser) -> Vec<Json> {
+        input.parse_nested_block(|input| Ok(component_values_to_json(input))).unwrap()
     }
-}
-
-
-impl ToJson for ComponentValue {
-    fn to_json(&self) -> json::Json {
-        fn numeric(value: &NumericValue) -> Vec<json::Json> {
-            match *value {
-                NumericValue{representation: ref r, value: ref v, int_value: ref i}
-                => vec!(r.to_json(), v.to_json(),
-                        JString!(match *i { Some(_) => "integer", _ => "number" }))
-            }
-        }
 
-        match *self {
-            Ident(ref value) => JArray!(JString!("ident"), value.to_json()),
-            AtKeyword(ref value) => JArray!(JString!("at-keyword"), value.to_json()),
-            Hash(ref value) => JArray!(JString!("hash"), value.to_json(),
-                                      JString!("unrestricted")),
-            IDHash(ref value) => JArray!(JString!("hash"), value.to_json(), JString!("id")),
-            QuotedString(ref value) => JArray!(JString!("string"), value.to_json()),
-            URL(ref value) => JArray!(JString!("url"), value.to_json()),
-            Delim('\\') => JString!("\\"),
-            Delim(value) => Json::String(String::from_char(1, value)),
-
-            Number(ref value) => Json::Array(
-                vec!(JString!("number")) + numeric(value).as_slice()),
-            Percentage(ref value) => Json::Array(
-                vec!(JString!("percentage")) + numeric(value).as_slice()),
-            Dimension(ref value, ref unit) => Json::Array(
-                vec!(JString!("dimension")) + numeric(value).as_slice()
-                + [unit.to_json()].as_slice()),
-
-            UnicodeRange(start, end)
-            => JArray!(JString!("unicode-range"), start.to_json(), end.to_json()),
-
-            WhiteSpace => JString!(" "),
-            Colon => JString!(":"),
-            Semicolon => JString!(";"),
-            Comma => JString!(","),
-            IncludeMatch => JString!("~="),
-            DashMatch => JString!("|="),
-            PrefixMatch => JString!("^="),
-            SuffixMatch => JString!("$="),
-            SubstringMatch => JString!("*="),
-            Column => JString!("||"),
-            CDO => JString!("<!--"),
-            CDC => JString!("-->"),
-
-            Function(ref name, ref arguments)
-            => Json::Array(
-                vec!(JString!("function"), name.to_json())
-                + arguments.iter().map(|a| a.to_json()).collect::<Vec<json::Json>>().as_slice()),
-            ParenthesisBlock(ref content)
-            => Json::Array(
-                vec!(JString!("()"))
-                + content.iter().map(|c| c.to_json()).collect::<Vec<json::Json>>().as_slice()),
-            SquareBracketBlock(ref content)
-            => Json::Array(
-                vec!(JString!("[]"))
-                + content.iter().map(|c| c.to_json()).collect::<Vec<json::Json>>().as_slice()),
-            CurlyBracketBlock(ref content)
-            => Json::Array(vec!(JString!("{}")) + list_to_json(content).as_slice()),
-
-            BadURL => JArray!(JString!("error"), JString!("bad-url")),
-            BadString => JArray!(JString!("error"), JString!("bad-string")),
-            CloseParenthesis => JArray!(JString!("error"), JString!(")")),
-            CloseSquareBracket => JArray!(JString!("error"), JString!("]")),
-            CloseCurlyBracket => JArray!(JString!("error"), JString!("}")),
-        }
+    match token {
+        Token::Ident(value) => JArray!["ident", value],
+        Token::AtKeyword(value) => JArray!["at-keyword", value],
+        Token::Hash(value) => JArray!["hash", value, "unrestricted"],
+        Token::IDHash(value) => JArray!["hash", value, "id"],
+        Token::QuotedString(value) => JArray!["string", value],
+        Token::Url(value) => JArray!["url", value],
+        Token::Delim('\\') => "\\".to_json(),
+        Token::Delim(value) => String::from_char(1, value).to_json(),
+
+        Token::Number(value) => Json::Array(vec!["number".to_json()] + numeric(value)),
+        Token::Percentage(PercentageValue { unit_value, int_value, signed }) => Json::Array(
+            vec!["percentage".to_json()] + numeric(NumericValue {
+                value: unit_value * 100.,
+                int_value: int_value,
+                signed: signed,
+            })),
+        Token::Dimension(value, unit) => Json::Array(
+            vec!["dimension".to_json()] + numeric(value) + [unit.to_json()].as_slice()),
+
+        Token::UnicodeRange(start, end) => JArray!["unicode-range", start, end],
+
+        Token::WhiteSpace(_) => " ".to_json(),
+        Token::Comment(_) => "/**/".to_json(),
+        Token::Colon => ":".to_json(),
+        Token::Semicolon => ";".to_json(),
+        Token::Comma => ",".to_json(),
+        Token::IncludeMatch => "~=".to_json(),
+        Token::DashMatch => "|=".to_json(),
+        Token::PrefixMatch => "^=".to_json(),
+        Token::SuffixMatch => "$=".to_json(),
+        Token::SubstringMatch => "*=".to_json(),
+        Token::Column => "||".to_json(),
+        Token::CDO => "<!--".to_json(),
+        Token::CDC => "-->".to_json(),
+
+        Token::Function(name) => Json::Array(vec!["function".to_json(), name.to_json()] +
+                                             nested(input)),
+        Token::ParenthesisBlock => Json::Array(vec!["()".to_json()] + nested(input)),
+        Token::SquareBracketBlock => Json::Array(vec!["[]".to_json()] + nested(input)),
+        Token::CurlyBracketBlock => Json::Array(vec!["{}".to_json()] + nested(input)),
+        Token::BadUrl => JArray!["error", "bad-url"],
+        Token::BadString => JArray!["error", "bad-string"],
+        Token::CloseParenthesis => JArray!["error", ")"],
+        Token::CloseSquareBracket => JArray!["error", "]"],
+        Token::CloseCurlyBracket => JArray!["error", "}"],
     }
 }
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index 7950057d..4f3b35f7 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -4,587 +4,752 @@
 
 // http://dev.w3.org/csswg/css3-syntax/#tokenization
 
-use std::{char, num};
+use std::cell::Cell;
+use std::char;
+use std::num;
 use std::ascii::AsciiExt;
-
-use ast::*;
-use ast::ComponentValue::*;
+use std::borrow::{Cow, ToOwned};
+use std::str::CowString;
+use std::borrow::Cow::{Owned, Borrowed};
+
+use self::Token::*;
+
+
+#[deriving(PartialEq, Show, Clone)]
+pub enum Token<'a> {
+    // Preserved tokens.
+    Ident(CowString<'a>),
+    AtKeyword(CowString<'a>),
+    Hash(CowString<'a>),
+    IDHash(CowString<'a>),  // Hash that is a valid ID selector.
+    QuotedString(CowString<'a>),
+    Url(CowString<'a>),
+    Delim(char),
+    Number(NumericValue),
+    Percentage(PercentageValue),
+    Dimension(NumericValue, CowString<'a>),
+    UnicodeRange(u32, u32),  // (start, end) of range
+    WhiteSpace(&'a str),
+    Comment(&'a str),
+    Colon,  // :
+    Semicolon,  // ;
+    Comma,  // ,
+    IncludeMatch, // ~=
+    DashMatch, // |=
+    PrefixMatch, // ^=
+    SuffixMatch, // $=
+    SubstringMatch, // *=
+    Column, // ||
+    CDO,  // <!--
+    CDC,  // -->
+
+    // Function
+    Function(CowString<'a>),  // name
+
+    // Simple block
+    ParenthesisBlock,  // (…)
+    SquareBracketBlock,  // […]
+    CurlyBracketBlock,  // {…}
+
+    // These are always invalid
+    BadUrl,
+    BadString,
+    CloseParenthesis, // )
+    CloseSquareBracket, // ]
+    CloseCurlyBracket, // }
+}
 
 
-/// Returns a `Iterator<(ComponentValue, SourceLocation)>`
-pub fn tokenize(input: &str) -> Tokenizer {
-    let input = preprocess(input);
-    Tokenizer {
-        length: input.len(),
-        input: input,
-        position: 0,
-        line: 1,
-        last_line_start: 0,
+impl<'a> Token<'a> {
+    pub fn into_owned(self) -> Token<'static> {
+        match self {
+            Token::Ident(value) => Token::Ident(Cow::Owned(value.into_owned())),
+            Token::AtKeyword(value) => Token::AtKeyword(Cow::Owned(value.into_owned())),
+            Token::Hash(value) => Token::Hash(Cow::Owned(value.into_owned())),
+            Token::IDHash(value) => Token::IDHash(Cow::Owned(value.into_owned())),
+            Token::QuotedString(value) => Token::QuotedString(Cow::Owned(value.into_owned())),
+            Token::Url(value) => Token::Url(Cow::Owned(value.into_owned())),
+            Token::Delim(ch) => Token::Delim(ch),
+            Token::Number(value) => Token::Number(value),
+            Token::Percentage(value) => Token::Percentage(value),
+            Token::Dimension(value, unit) => Token::Dimension(value, Cow::Owned(unit.into_owned())),
+            Token::UnicodeRange(start, end) => Token::UnicodeRange(start, end),
+            Token::WhiteSpace(content) => {
+                Token::WhiteSpace(if matches!(content.as_bytes()[0], b'\n' | b'\r' | b'\x0C') { "\n" } else { " " })
+            }
+            Token::Comment(_) => Token::Comment(""),
+            Token::Colon => Token::Colon,
+            Token::Semicolon => Token::Semicolon,
+            Token::Comma => Token::Comma,
+            Token::IncludeMatch => Token::IncludeMatch,
+            Token::DashMatch => Token::DashMatch,
+            Token::PrefixMatch => Token::PrefixMatch,
+            Token::SuffixMatch => Token::SuffixMatch,
+            Token::SubstringMatch => Token::SubstringMatch,
+            Token::Column => Token::Column,
+            Token::CDO => Token::CDO,
+            Token::CDC => Token::CDC,
+            Token::Function(name) => Token::Function(Cow::Owned(name.into_owned())),
+            Token::ParenthesisBlock => Token::ParenthesisBlock,
+            Token::SquareBracketBlock => Token::SquareBracketBlock,
+            Token::CurlyBracketBlock => Token::CurlyBracketBlock,
+            Token::BadUrl => Token::BadUrl,
+            Token::BadString => Token::BadString,
+            Token::CloseParenthesis => Token::CloseParenthesis,
+            Token::CloseSquareBracket => Token::CloseSquareBracket,
+            Token::CloseCurlyBracket => Token::CloseCurlyBracket,
+        }
     }
 }
 
-impl Iterator<Node> for Tokenizer {
-    #[inline]
-    fn next(&mut self) -> Option<Node> { next_component_value(self) }
+
+#[deriving(PartialEq, Show, Copy, Clone)]
+pub struct NumericValue {
+    pub value: f64,
+    pub int_value: Option<i64>,
+    /// Whether the number had a `+` or `-` sign.
+    pub signed: bool,
 }
 
 
-//  ***********  End of public API  ***********
+#[deriving(PartialEq, Show, Copy, Clone)]
+pub struct PercentageValue {
+    /// This (but not int_value) is divided by 100
+    pub unit_value: f64,
+    pub int_value: Option<i64>,
+    /// Whether the number had a `+` or `-` sign.
+    pub signed: bool,
+}
+
 
+#[deriving(Clone)]
+pub struct Tokenizer<'a> {
+    input: &'a str,
 
-#[inline]
-fn preprocess(input: &str) -> String {
-    // Replace:
-    // "\r\n" => "\n"
-    // "\r"   => "\n"
-    // "\x0C" => "\n"
-    // "\x00" => "\u{FFFD}"
-
-    let bytes = input.as_bytes();
-    let mut result: Vec<u8> = Vec::with_capacity(bytes.len());
-    let mut last: u8 = 0;
-    for byte in bytes.iter() {
-        match *byte {
-            b'\n' if last == b'\r' => (),
-            b'\r' | b'\x0C'        => result.push(b'\n'),
-            b'\0'                  => result.push_all("\u{FFFD}".as_bytes()),
-            _                      => result.push(*byte),
+    /// Counted in bytes, not code points. From 0.
+    position: uint,
+
+    /// Cache for `source_location()`
+    last_known_line_break: Cell<(uint, uint)>,
+}
+
+
+impl<'a> Tokenizer<'a> {
+    #[inline]
+    pub fn new(input: &str) -> Tokenizer {
+        Tokenizer {
+            input: input,
+            position: 0,
+            last_known_line_break: Cell::new((1, 0)),
         }
+    }
 
-        last = *byte;
+    #[inline]
+    pub fn next(&mut self) -> Result<Token<'a>, ()> {
+        next_token(self).ok_or(())
     }
 
-    unsafe { String::from_utf8_unchecked(result) }
-}
+    #[inline]
+    pub fn position(&self) -> SourcePosition {
+        SourcePosition(self.position)
+    }
 
+    #[inline]
+    pub fn reset(&mut self, new_position: SourcePosition) {
+        self.position = new_position.0;
+    }
 
-#[test]
-fn test_preprocess() {
-    assert!("" == preprocess("").as_slice());
-    assert!("Lorem\n\n\t\u{FFFD}ipusm\ndoror\u{FFFD}á\n" ==
-            preprocess("Lorem\r\n\n\t\x00ipusm\ndoror\u{FFFD}á\r").as_slice());
-}
+    #[inline]
+    pub fn slice_from(&self, start_pos: SourcePosition) -> &'a str {
+        self.input.slice(start_pos.0, self.position)
+    }
 
-#[cfg(test)]
-mod bench_preprocess {
-    extern crate test;
+    #[inline]
+    pub fn current_source_location(&self) -> SourceLocation {
+        let position = SourcePosition(self.position);
+        self.source_location(position)
+    }
 
-    #[bench]
-    fn bench_preprocess(b: &mut test::Bencher) {
-        let source = "Lorem\n\t\u{FFFD}ipusm\ndoror\u{FFFD}á\n";
-        b.iter(|| {
-            let _ = super::preprocess(source);
-        });
+    pub fn source_location(&self, position: SourcePosition) -> SourceLocation {
+        let target = position.0;
+        let mut line_number;
+        let mut position;
+        let (last_known_line_number, position_after_last_known_newline) =
+            self.last_known_line_break.get();
+        if target >= position_after_last_known_newline {
+            position = position_after_last_known_newline;
+            line_number = last_known_line_number;
+        } else {
+            position = 0;
+            line_number = 1;
+        }
+        let mut source = self.input.slice(position, target);
+        while let Some(newline_position) = source.find(['\n', '\r', '\x0C'].as_slice()) {
+            let offset = newline_position +
+            if source.slice_from(newline_position).starts_with("\r\n") {
+                2
+            } else {
+                1
+            };
+            source = source.slice_from(offset);
+            position += offset;
+            line_number += 1;
+        }
+        debug_assert!(position <= target);
+        self.last_known_line_break.set((line_number, position));
+        SourceLocation {
+            line: line_number,
+            // `target == position` when `target` is at the beginning of the line,
+            // so add 1 so that the column numbers start at 1.
+            column: target - position + 1,
+        }
     }
-}
 
+    #[inline]
+    pub fn next_byte(&self) -> Option<u8> {
+        if self.is_eof() {
+            None
+        } else {
+            Some(self.input.as_bytes()[self.position])
+        }
+    }
 
-pub struct Tokenizer {
-    input: String,
-    length: uint,  // All counted in bytes, not characters
-    position: uint,  // All counted in bytes, not characters
-    line: uint,
-    last_line_start: uint,  // All counted in bytes, not characters
-}
+    // If false, `tokenizer.next_char()` will not panic.
+    #[inline]
+    fn is_eof(&self) -> bool { !self.has_at_least(0) }
 
+    // If true, the input has at least `n` bytes left *after* the current one.
+    // That is, `tokenizer.char_at(n)` will not panic.
+    #[inline]
+    fn has_at_least(&self, n: uint) -> bool { self.position + n < self.input.len() }
 
-impl Tokenizer {
     #[inline]
-    fn is_eof(&self) -> bool { self.position >= self.length }
+    pub fn advance(&mut self, n: uint) { self.position += n }
 
     // Assumes non-EOF
     #[inline]
-    fn current_char(&self) -> char { self.char_at(0) }
+    fn next_char(&self) -> char { self.char_at(0) }
 
     #[inline]
     fn char_at(&self, offset: uint) -> char {
-        self.input.as_slice().char_at(self.position + offset)
+        self.input.char_at(self.position + offset)
+    }
+
+    #[inline]
+    fn has_newline_at(&self, offset: uint) -> bool {
+        self.position + offset < self.input.len() &&
+        matches!(self.char_at(offset), '\n' | '\r' | '\x0C')
     }
 
     #[inline]
     fn consume_char(&mut self) -> char {
-        let range = self.input.as_slice().char_range_at(self.position);
+        let range = self.input.char_range_at(self.position);
         self.position = range.next;
         range.ch
     }
 
     #[inline]
     fn starts_with(&self, needle: &str) -> bool {
-        self.input.as_slice().slice_from(self.position).starts_with(needle)
-    }
-
-    #[inline]
-    fn new_line(&mut self) {
-        if cfg!(test) {
-            assert!(self.input.as_slice().char_at(self.position - 1) == '\n')
-        }
-        self.line += 1;
-        self.last_line_start = self.position;
+        self.input.slice_from(self.position).starts_with(needle)
     }
 }
 
-macro_rules! is_match {
-    ($value:expr, $($pattern:pat)|+) => (
-        match $value { $($pattern)|+ => true, _ => false }
-    );
+
+#[deriving(PartialEq, Eq, PartialOrd, Ord, Show, Clone, Copy)]
+pub struct SourcePosition(uint);
+
+
+#[deriving(PartialEq, Eq, Show, Clone, Copy)]
+pub struct SourceLocation {
+    /// Starts at 1
+    pub line: uint,
+    /// Starts at 1
+    pub column: uint,
 }
 
 
-fn next_component_value(tokenizer: &mut Tokenizer) -> Option<Node> {
-    consume_comments(tokenizer);
+fn next_token<'a>(tokenizer: &mut Tokenizer<'a>) -> Option<Token<'a>> {
     if tokenizer.is_eof() {
-        if cfg!(test) {
-            assert!(tokenizer.line == tokenizer.input.as_slice().split('\n').count(),
-                    "The tokenizer is missing a tokenizer.new_line() call somewhere.")
-        }
         return None
     }
-    let start_location = SourceLocation{
-        line: tokenizer.line,
-        // The start of the line is column 1:
-        column: tokenizer.position - tokenizer.last_line_start + 1,
-    };
-    let c = tokenizer.current_char();
-    let component_value = match c {
-        '\t' | '\n' | ' ' => {
+    let c = tokenizer.next_char();
+    let token = match c {
+        '\t' | '\n' | ' ' | '\r' | '\x0C' => {
+            let start_position = tokenizer.position();
+            tokenizer.advance(1);
             while !tokenizer.is_eof() {
-                match tokenizer.current_char() {
-                    ' ' | '\t' => tokenizer.position += 1,
-                    '\n' => {
-                        tokenizer.position += 1;
-                        tokenizer.new_line();
-                    },
+                match tokenizer.next_char() {
+                    ' ' | '\t' | '\n' | '\r' | '\x0C' => tokenizer.advance(1),
                     _ => break,
                 }
             }
-            WhiteSpace
+            WhiteSpace(tokenizer.slice_from(start_position))
         },
         '"' => consume_string(tokenizer, false),
         '#' => {
-            tokenizer.position += 1;
+            tokenizer.advance(1);
             if is_ident_start(tokenizer) { IDHash(consume_name(tokenizer)) }
-            else if !tokenizer.is_eof() && match tokenizer.current_char() {
+            else if !tokenizer.is_eof() && match tokenizer.next_char() {
                 'a'...'z' | 'A'...'Z' | '0'...'9' | '-' | '_' => true,
-                '\\' => !tokenizer.starts_with("\\\n"),
+                '\\' => !tokenizer.has_newline_at(1),
                 _ => c > '\x7F',  // Non-ASCII
             } { Hash(consume_name(tokenizer)) }
             else { Delim(c) }
         },
         '$' => {
-            if tokenizer.starts_with("$=") { tokenizer.position += 2; SuffixMatch }
-            else { tokenizer.position += 1; Delim(c) }
+            if tokenizer.starts_with("$=") { tokenizer.advance(2); SuffixMatch }
+            else { tokenizer.advance(1); Delim(c) }
         },
         '\'' => consume_string(tokenizer, true),
-        '(' => ParenthesisBlock(consume_block(tokenizer, CloseParenthesis)),
-        ')' => { tokenizer.position += 1; CloseParenthesis },
+        '(' => { tokenizer.advance(1); ParenthesisBlock },
+        ')' => { tokenizer.advance(1); CloseParenthesis },
         '*' => {
-            if tokenizer.starts_with("*=") { tokenizer.position += 2; SubstringMatch }
-            else { tokenizer.position += 1; Delim(c) }
+            if tokenizer.starts_with("*=") { tokenizer.advance(2); SubstringMatch }
+            else { tokenizer.advance(1); Delim(c) }
         },
         '+' => {
             if (
-                tokenizer.position + 1 < tokenizer.length
-                && is_match!(tokenizer.char_at(1), '0'...'9')
+                tokenizer.has_at_least(1)
+                && matches!(tokenizer.char_at(1), '0'...'9')
             ) || (
-                tokenizer.position + 2 < tokenizer.length
+                tokenizer.has_at_least(2)
                 && tokenizer.char_at(1) == '.'
-                && is_match!(tokenizer.char_at(2), '0'...'9')
+                && matches!(tokenizer.char_at(2), '0'...'9')
             ) {
                 consume_numeric(tokenizer)
             } else {
-                tokenizer.position += 1;
+                tokenizer.advance(1);
                 Delim(c)
             }
         },
-        ',' => { tokenizer.position += 1; Comma },
+        ',' => { tokenizer.advance(1); Comma },
         '-' => {
             if (
-                tokenizer.position + 1 < tokenizer.length
-                && is_match!(tokenizer.char_at(1), '0'...'9')
+                tokenizer.has_at_least(1)
+                && matches!(tokenizer.char_at(1), '0'...'9')
             ) || (
-                tokenizer.position + 2 < tokenizer.length
+                tokenizer.has_at_least(2)
                 && tokenizer.char_at(1) == '.'
-                && is_match!(tokenizer.char_at(2), '0'...'9')
+                && matches!(tokenizer.char_at(2), '0'...'9')
             ) {
                 consume_numeric(tokenizer)
-            } else if is_ident_start(tokenizer) {
-                consume_ident_like(tokenizer)
             } else if tokenizer.starts_with("-->") {
-                tokenizer.position += 3;
+                tokenizer.advance(3);
                 CDC
+            } else if is_ident_start(tokenizer) {
+                consume_ident_like(tokenizer)
             } else {
-                tokenizer.position += 1;
+                tokenizer.advance(1);
                 Delim(c)
             }
         },
         '.' => {
-            if tokenizer.position + 1 < tokenizer.length
-                && is_match!(tokenizer.char_at(1), '0'...'9'
+            if tokenizer.has_at_least(1)
+                && matches!(tokenizer.char_at(1), '0'...'9'
             ) {
                 consume_numeric(tokenizer)
             } else {
-                tokenizer.position += 1;
+                tokenizer.advance(1);
                 Delim(c)
             }
         }
+        '/' if tokenizer.starts_with("/*") => {
+            tokenizer.advance(2);  // consume "/*"
+            let start_position = tokenizer.position();
+            let content;
+            match tokenizer.input.slice_from(tokenizer.position).find_str("*/") {
+                Some(offset) => {
+                    tokenizer.advance(offset);
+                    content = tokenizer.slice_from(start_position);
+                    tokenizer.advance(2);
+                }
+                None => {
+                    tokenizer.position = tokenizer.input.len();
+                    content = tokenizer.slice_from(start_position);
+                }
+            }
+            Comment(content)
+        }
         '0'...'9' => consume_numeric(tokenizer),
-        ':' => { tokenizer.position += 1; Colon },
-        ';' => { tokenizer.position += 1; Semicolon },
+        ':' => { tokenizer.advance(1); Colon },
+        ';' => { tokenizer.advance(1); Semicolon },
         '<' => {
             if tokenizer.starts_with("<!--") {
-                tokenizer.position += 4;
+                tokenizer.advance(4);
                 CDO
             } else {
-                tokenizer.position += 1;
+                tokenizer.advance(1);
                 Delim(c)
             }
         },
         '@' => {
-            tokenizer.position += 1;
+            tokenizer.advance(1);
             if is_ident_start(tokenizer) { AtKeyword(consume_name(tokenizer)) }
             else { Delim(c) }
         },
         'u' | 'U' => {
-            if tokenizer.position + 2 < tokenizer.length
+            if tokenizer.has_at_least(2)
                && tokenizer.char_at(1) == '+'
-               && is_match!(tokenizer.char_at(2), '0'...'9' | 'a'...'f' | 'A'...'F' | '?')
+               && matches!(tokenizer.char_at(2), '0'...'9' | 'a'...'f' | 'A'...'F' | '?')
             { consume_unicode_range(tokenizer) }
             else { consume_ident_like(tokenizer) }
         },
-        'a'...'z' | 'A'...'Z' | '_' => consume_ident_like(tokenizer),
-        '[' => SquareBracketBlock(consume_block(tokenizer, CloseSquareBracket)),
+        'a'...'z' | 'A'...'Z' | '_' | '\0' => consume_ident_like(tokenizer),
+        '[' => { tokenizer.advance(1); SquareBracketBlock },
         '\\' => {
-            if !tokenizer.starts_with("\\\n") { consume_ident_like(tokenizer) }
-            else { tokenizer.position += 1; Delim(c) }
+            if !tokenizer.has_newline_at(1) { consume_ident_like(tokenizer) }
+            else { tokenizer.advance(1); Delim(c) }
         },
-        ']' => { tokenizer.position += 1; CloseSquareBracket },
+        ']' => { tokenizer.advance(1); CloseSquareBracket },
         '^' => {
-            if tokenizer.starts_with("^=") { tokenizer.position += 2; PrefixMatch }
-            else { tokenizer.position += 1; Delim(c) }
+            if tokenizer.starts_with("^=") { tokenizer.advance(2); PrefixMatch }
+            else { tokenizer.advance(1); Delim(c) }
         },
-        '{' => CurlyBracketBlock(consume_block_with_location(tokenizer, CloseCurlyBracket)),
+        '{' => { tokenizer.advance(1); CurlyBracketBlock },
         '|' => {
-            if tokenizer.starts_with("|=") { tokenizer.position += 2; DashMatch }
-            else if tokenizer.starts_with("||") { tokenizer.position += 2; Column }
-            else { tokenizer.position += 1; Delim(c) }
+            if tokenizer.starts_with("|=") { tokenizer.advance(2); DashMatch }
+            else if tokenizer.starts_with("||") { tokenizer.advance(2); Column }
+            else { tokenizer.advance(1); Delim(c) }
         },
-        '}' => { tokenizer.position += 1; CloseCurlyBracket },
+        '}' => { tokenizer.advance(1); CloseCurlyBracket },
         '~' => {
-            if tokenizer.starts_with("~=") { tokenizer.position += 2; IncludeMatch }
-            else { tokenizer.position += 1; Delim(c) }
+            if tokenizer.starts_with("~=") { tokenizer.advance(2); IncludeMatch }
+            else { tokenizer.advance(1); Delim(c) }
         },
         _ => {
             if c > '\x7F' {  // Non-ASCII
                 consume_ident_like(tokenizer)
             } else {
-                tokenizer.position += 1;
+                tokenizer.advance(1);
                 Delim(c)
             }
         },
     };
-    Some((component_value, start_location))
+    Some(token)
 }
 
 
-#[inline]
-fn consume_comments(tokenizer: &mut Tokenizer) {
-    while tokenizer.starts_with("/*") {
-        tokenizer.position += 2;  // +2 to consume "/*"
-        while !tokenizer.is_eof() {
-            match tokenizer.consume_char() {
-                '*' => {
-                    if !tokenizer.is_eof() && tokenizer.current_char() == '/' {
-                        tokenizer.position += 1;
-                        break
-                    }
-                },
-                '\n' => tokenizer.new_line(),
-                _ => ()
-            }
-        }
+fn consume_string<'a>(tokenizer: &mut Tokenizer<'a>, single_quote: bool) -> Token<'a> {
+    match consume_quoted_string(tokenizer, single_quote) {
+        Ok(value) => QuotedString(value),
+        Err(()) => BadString
     }
 }
 
 
-fn consume_block(tokenizer: &mut Tokenizer, ending_token: ComponentValue) -> Vec<ComponentValue> {
-    tokenizer.position += 1;  // Skip the initial {[(
-    let mut content = Vec::new();
+/// Return `Err(())` on syntax error (ie. unescaped newline)
+fn consume_quoted_string<'a>(tokenizer: &mut Tokenizer<'a>, single_quote: bool)
+                             -> Result<CowString<'a>, ()> {
+    tokenizer.advance(1);  // Skip the initial quote
+    let start_pos = tokenizer.position();
+    let mut string;
     loop {
-        match next_component_value(tokenizer) {
-            Some((component_value, _location)) => {
-                if component_value == ending_token { break }
-                else { content.push(component_value) }
-            },
-            None => break,
+        if tokenizer.is_eof() {
+            return Ok(Borrowed(tokenizer.slice_from(start_pos)))
         }
-    }
-    content
-}
-
-
-fn consume_block_with_location(tokenizer: &mut Tokenizer, ending_token: ComponentValue) -> Vec<Node> {
-    tokenizer.position += 1;  // Skip the initial {[(
-    let mut content = Vec::new();
-    loop {
-        match next_component_value(tokenizer) {
-            Some((component_value, location)) => {
-                if component_value == ending_token { break }
-                else { content.push((component_value, location)) }
-            },
-            None => break,
+        match tokenizer.next_char() {
+            '"' if !single_quote => {
+                let value = tokenizer.slice_from(start_pos);
+                tokenizer.advance(1);
+                return Ok(Borrowed(value))
+            }
+            '\'' if single_quote => {
+                let value = tokenizer.slice_from(start_pos);
+                tokenizer.advance(1);
+                return Ok(Borrowed(value))
+            }
+            '\\' | '\0' => {
+                string = tokenizer.slice_from(start_pos).to_owned();
+                break
+            }
+            '\n' | '\r' | '\x0C' => return Err(()),
+            _ => {
+                tokenizer.consume_char();
+            }
         }
     }
-    content
-}
-
 
-fn consume_string(tokenizer: &mut Tokenizer, single_quote: bool) -> ComponentValue {
-    match consume_quoted_string(tokenizer, single_quote) {
-        Ok(value) => QuotedString(value),
-        Err(()) => BadString
-    }
-}
-
-
-/// Return `Err(())` on syntax error (ie. unescaped newline)
-fn consume_quoted_string(tokenizer: &mut Tokenizer, single_quote: bool) -> Result<String, ()> {
-    tokenizer.position += 1;  // Skip the initial quote
-    let mut string = String::new();
     while !tokenizer.is_eof() {
+        if matches!(tokenizer.next_char(), '\n' | '\r' | '\x0C') {
+            return Err(());
+        }
         match tokenizer.consume_char() {
             '"' if !single_quote => break,
             '\'' if single_quote => break,
-            '\n' => {
-                tokenizer.position -= 1;
-                return Err(());
-            },
             '\\' => {
                 if !tokenizer.is_eof() {
-                    if tokenizer.current_char() == '\n' {  // Escaped newline
-                        tokenizer.position += 1;
-                        tokenizer.new_line();
+                    match tokenizer.next_char() {
+                        // Escaped newline
+                        '\n' | '\x0C' => tokenizer.advance(1),
+                        '\r' => {
+                            tokenizer.advance(1);
+                            if !tokenizer.is_eof() && tokenizer.next_char() == '\n' {
+                                tokenizer.advance(1);
+                            }
+                        }
+                        _ => string.push(consume_escape(tokenizer))
                     }
-                    else { string.push(consume_escape(tokenizer)) }
                 }
                 // else: escaped EOF, do nothing.
             }
+            '\0' => string.push('\u{FFFD}'),
             c => string.push(c),
         }
     }
-    Ok(string)
+    Ok(Owned(string))
 }
 
 
 #[inline]
 fn is_ident_start(tokenizer: &mut Tokenizer) -> bool {
-    !tokenizer.is_eof() && match tokenizer.current_char() {
-        'a'...'z' | 'A'...'Z' | '_' => true,
-        '-' => tokenizer.position + 1 < tokenizer.length && match tokenizer.char_at(1) {
-            'a'...'z' | 'A'...'Z' | '_' => true,
-            '\\' => !tokenizer.input.as_slice().slice_from(tokenizer.position + 1).starts_with("\\\n"),
+    !tokenizer.is_eof() && match tokenizer.next_char() {
+        'a'...'z' | 'A'...'Z' | '_' | '\0' => true,
+        '-' => tokenizer.has_at_least(1) && match tokenizer.char_at(1) {
+            'a'...'z' | 'A'...'Z' | '-' | '_' | '\0' => true,
+            '\\' => !tokenizer.has_newline_at(1),
             c => c > '\x7F',  // Non-ASCII
         },
-        '\\' => !tokenizer.starts_with("\\\n"),
+        '\\' => !tokenizer.has_newline_at(1),
         c => c > '\x7F',  // Non-ASCII
     }
 }
 
 
-fn consume_ident_like(tokenizer: &mut Tokenizer) -> ComponentValue {
+fn consume_ident_like<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
     let value = consume_name(tokenizer);
-    if !tokenizer.is_eof() && tokenizer.current_char() == '(' {
-        if value.as_slice().eq_ignore_ascii_case("url") { consume_url(tokenizer) }
-        else { Function(value, consume_block(tokenizer, CloseParenthesis)) }
+    if !tokenizer.is_eof() && tokenizer.next_char() == '(' {
+        tokenizer.advance(1);
+        if value.eq_ignore_ascii_case("url") { consume_url(tokenizer) }
+        else { Function(value) }
     } else {
         Ident(value)
     }
 }
 
-fn consume_name(tokenizer: &mut Tokenizer) -> String {
-    let mut value = String::new();
+fn consume_name<'a>(tokenizer: &mut Tokenizer<'a>) -> CowString<'a> {
+    let start_pos = tokenizer.position();
+    let mut value;
+    loop {
+        if tokenizer.is_eof() {
+            return Borrowed(tokenizer.slice_from(start_pos))
+        }
+        match tokenizer.next_char() {
+            'a'...'z' | 'A'...'Z' | '0'...'9' | '_' | '-'  => tokenizer.advance(1),
+            '\\' | '\0' => {
+                value = tokenizer.slice_from(start_pos).to_owned();
+                break
+            }
+            c if c.is_ascii() => return Borrowed(tokenizer.slice_from(start_pos)),
+            _ => {
+                tokenizer.consume_char();
+            }
+        }
+    }
+
     while !tokenizer.is_eof() {
-        let c = tokenizer.current_char();
+        let c = tokenizer.next_char();
         value.push(match c {
-            'a'...'z' | 'A'...'Z' | '0'...'9' | '_' | '-'  => { tokenizer.position += 1; c },
+            'a'...'z' | 'A'...'Z' | '0'...'9' | '_' | '-'  => {
+                tokenizer.advance(1);
+                c
+            }
             '\\' => {
-                if tokenizer.starts_with("\\\n") { break }
-                tokenizer.position += 1;
+                if tokenizer.has_newline_at(1) { break }
+                tokenizer.advance(1);
                 consume_escape(tokenizer)
-            },
-            _ => if c > '\x7F' { tokenizer.consume_char() }  // Non-ASCII
-                 else { break }
+            }
+            '\0' => { tokenizer.advance(1); '\u{FFFD}' },
+            c if c.is_ascii() => break,
+            _ => tokenizer.consume_char(),
         })
     }
-    value
+    Owned(value)
 }
 
 
-fn consume_numeric(tokenizer: &mut Tokenizer) -> ComponentValue {
-    // Parse [+-]?\d*(\.\d+)?([eE][+-]?\d+)?
-    // But this is always called so that there is at least one digit in \d*(\.\d+)?
-    let mut representation = String::new();
-    let mut is_integer = true;
-    if is_match!(tokenizer.current_char(), '-' | '+') {
-         representation.push(tokenizer.consume_char())
-    }
+fn consume_digits(tokenizer: &mut Tokenizer) {
     while !tokenizer.is_eof() {
-        match tokenizer.current_char() {
-            '0'...'9' => representation.push(tokenizer.consume_char()),
+        match tokenizer.next_char() {
+            '0'...'9' => tokenizer.advance(1),
             _ => break
         }
     }
-    if tokenizer.position + 1 < tokenizer.length && tokenizer.current_char() == '.'
-            && is_match!(tokenizer.char_at(1), '0'...'9') {
+}
+
+
+fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
+    // Parse [+-]?\d*(\.\d+)?([eE][+-]?\d+)?
+    // But this is always called so that there is at least one digit in \d*(\.\d+)?
+    let start_pos = tokenizer.position();
+    let mut is_integer = true;
+    let signed = matches!(tokenizer.next_char(), '-' | '+');
+    if signed {
+        tokenizer.advance(1);
+    }
+    consume_digits(tokenizer);
+    if tokenizer.has_at_least(1) && tokenizer.next_char() == '.'
+            && matches!(tokenizer.char_at(1), '0'...'9') {
         is_integer = false;
-        representation.push(tokenizer.consume_char());  // '.'
-        representation.push(tokenizer.consume_char());  // digit
-        while !tokenizer.is_eof() {
-            match tokenizer.current_char() {
-                '0'...'9' => representation.push(tokenizer.consume_char()),
-                _ => break
-            }
-        }
+        tokenizer.advance(2);  // '.' and first digit
+        consume_digits(tokenizer);
     }
     if (
-        tokenizer.position + 1 < tokenizer.length
-        && is_match!(tokenizer.current_char(), 'e' | 'E')
-        && is_match!(tokenizer.char_at(1), '0'...'9')
+        tokenizer.has_at_least(1)
+        && matches!(tokenizer.next_char(), 'e' | 'E')
+        && matches!(tokenizer.char_at(1), '0'...'9')
     ) || (
-        tokenizer.position + 2 < tokenizer.length
-        && is_match!(tokenizer.current_char(), 'e' | 'E')
-        && is_match!(tokenizer.char_at(1), '+' | '-')
-        && is_match!(tokenizer.char_at(2), '0'...'9')
+        tokenizer.has_at_least(2)
+        && matches!(tokenizer.next_char(), 'e' | 'E')
+        && matches!(tokenizer.char_at(1), '+' | '-')
+        && matches!(tokenizer.char_at(2), '0'...'9')
     ) {
         is_integer = false;
-        representation.push(tokenizer.consume_char());  // 'e' or 'E'
-        representation.push(tokenizer.consume_char());  // sign or digit
-        // If the above was a sign, the first digit it consumed below
-        // and we make one extraneous is_eof() check.
-        while !tokenizer.is_eof() {
-            match tokenizer.current_char() {
-                '0'...'9' => representation.push(tokenizer.consume_char()),
-                _ => break
-            }
-        }
+        tokenizer.advance(2);  // 'e' or 'E', and sign or first digit
+        consume_digits(tokenizer);
     }
     let (value, int_value) = {
-        // TODO: handle overflow
+        let mut repr = tokenizer.slice_from(start_pos);
         // Remove any + sign as int::from_str() does not parse them.
-        let repr = if representation.starts_with("+") {
-            representation.slice_from(1)
-        } else {
-            representation.as_slice()
-        };
+        if repr.starts_with("+") {
+            repr = repr.slice_from(1)
+        }
+        // TODO: handle overflow
         (from_str::<f64>(repr).unwrap(), if is_integer {
             Some(from_str::<i64>(repr).unwrap())
         } else {
             None
         })
     };
+    if !tokenizer.is_eof() && tokenizer.next_char() == '%' {
+        tokenizer.advance(1);
+        return Percentage(PercentageValue {
+            unit_value: value / 100.,
+            int_value: int_value,
+            signed: signed,
+        })
+    }
     let value = NumericValue {
-        int_value: int_value,
         value: value,
-        representation: representation,
+        int_value: int_value,
+        signed: signed,
     };
-    if !tokenizer.is_eof() && tokenizer.current_char() == '%' {
-        tokenizer.position += 1;
-        Percentage(value)
-    }
-    else if is_ident_start(tokenizer) { Dimension(value, consume_name(tokenizer)) }
+    if is_ident_start(tokenizer) { Dimension(value, consume_name(tokenizer)) }
     else { Number(value) }
 }
 
 
-fn consume_url(tokenizer: &mut Tokenizer) -> ComponentValue {
-    tokenizer.position += 1;  // Skip the ( of url(
+fn consume_url<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
     while !tokenizer.is_eof() {
-        match tokenizer.current_char() {
-            ' ' | '\t' => tokenizer.position += 1,
-            '\n' => {
-                tokenizer.position += 1;
-                tokenizer.new_line();
-            },
+        match tokenizer.next_char() {
+            ' ' | '\t' | '\n' | '\r' | '\x0C' => tokenizer.advance(1),
             '"' => return consume_quoted_url(tokenizer, false),
             '\'' => return consume_quoted_url(tokenizer, true),
-            ')' => { tokenizer.position += 1; break },
+            ')' => { tokenizer.advance(1); break },
             _ => return consume_unquoted_url(tokenizer),
         }
     }
-    return URL(String::new());
+    return Url(Borrowed(""));
 
-    fn consume_quoted_url(tokenizer: &mut Tokenizer, single_quote: bool) -> ComponentValue {
+    fn consume_quoted_url<'a>(tokenizer: &mut Tokenizer<'a>, single_quote: bool) -> Token<'a> {
         match consume_quoted_string(tokenizer, single_quote) {
             Ok(value) => consume_url_end(tokenizer, value),
             Err(()) => consume_bad_url(tokenizer),
         }
     }
 
-    fn consume_unquoted_url(tokenizer: &mut Tokenizer) -> ComponentValue {
-        let mut string = String::new();
+    fn consume_unquoted_url<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
+        let start_pos = tokenizer.position();
+        let mut string;
+        loop {
+            if tokenizer.is_eof() {
+                return Url(Borrowed(tokenizer.slice_from(start_pos)))
+            }
+            match tokenizer.next_char() {
+                ' ' | '\t' | '\n' | '\r' | '\x0C' => {
+                    let value = tokenizer.slice_from(start_pos);
+                    tokenizer.advance(1);
+                    return consume_url_end(tokenizer, Borrowed(value))
+                }
+                ')' => {
+                    let value = tokenizer.slice_from(start_pos);
+                    tokenizer.advance(1);
+                    return Url(Borrowed(value))
+                }
+                '\x01'...'\x08' | '\x0B' | '\x0E'...'\x1F' | '\x7F'  // non-printable
+                    | '"' | '\'' | '(' => {
+                    tokenizer.advance(1);
+                    return consume_bad_url(tokenizer)
+                },
+                '\\' | '\0' => {
+                    string = tokenizer.slice_from(start_pos).to_owned();
+                    break
+                }
+                _ => {
+                    tokenizer.consume_char();
+                }
+            }
+        }
         while !tokenizer.is_eof() {
             let next_char = match tokenizer.consume_char() {
-                ' ' | '\t' => return consume_url_end(tokenizer, string),
-                '\n' => {
-                    tokenizer.new_line();
-                    return consume_url_end(tokenizer, string)
-                },
+                ' ' | '\t' | '\n' | '\r' | '\x0C' => {
+                    return consume_url_end(tokenizer, Owned(string))
+                }
                 ')' => break,
-                '\x00'...'\x08' | '\x0B' | '\x0E'...'\x1F' | '\x7F'  // non-printable
+                '\x01'...'\x08' | '\x0B' | '\x0E'...'\x1F' | '\x7F'  // non-printable
                     | '"' | '\'' | '(' => return consume_bad_url(tokenizer),
                 '\\' => {
-                    if !tokenizer.is_eof() && tokenizer.current_char() == '\n' {
+                    if tokenizer.has_newline_at(0) {
                         return consume_bad_url(tokenizer)
                     }
                     consume_escape(tokenizer)
                 },
+                '\0' => '\u{FFFD}',
                 c => c
             };
             string.push(next_char)
         }
-        URL(string)
+        Url(Owned(string))
     }
 
-    fn consume_url_end(tokenizer: &mut Tokenizer, string: String) -> ComponentValue {
+    fn consume_url_end<'a>(tokenizer: &mut Tokenizer<'a>, string: CowString<'a>) -> Token<'a> {
         while !tokenizer.is_eof() {
             match tokenizer.consume_char() {
-                ' ' | '\t' => (),
-                '\n' => tokenizer.new_line(),
+                ' ' | '\t' | '\n' | '\r' | '\x0C' => (),
                 ')' => break,
                 _ => return consume_bad_url(tokenizer)
             }
         }
-        URL(string)
+        Url(string)
     }
 
-    fn consume_bad_url(tokenizer: &mut Tokenizer) -> ComponentValue {
+    fn consume_bad_url<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
         // Consume up to the closing )
         while !tokenizer.is_eof() {
             match tokenizer.consume_char() {
                 ')' => break,
-                '\\' => tokenizer.position += 1, // Skip an escaped ')' or '\'
-                '\n' => tokenizer.new_line(),
+                '\\' => tokenizer.advance(1), // Skip an escaped ')' or '\'
                 _ => ()
             }
         }
-        BadURL
+        BadUrl
     }
 }
 
 
 
-fn consume_unicode_range(tokenizer: &mut Tokenizer) -> ComponentValue {
-    tokenizer.position += 2;  // Skip U+
+fn consume_unicode_range<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
+    tokenizer.advance(2);  // Skip U+
     let mut hex = String::new();
     while hex.len() < 6 && !tokenizer.is_eof()
-          && is_match!(tokenizer.current_char(), '0'...'9' | 'A'...'F' | 'a'...'f') {
+          && matches!(tokenizer.next_char(), '0'...'9' | 'A'...'F' | 'a'...'f') {
         hex.push(tokenizer.consume_char());
     }
     let max_question_marks = 6u - hex.len();
     let mut question_marks = 0u;
     while question_marks < max_question_marks && !tokenizer.is_eof()
-            && tokenizer.current_char() == '?' {
+            && tokenizer.next_char() == '?' {
         question_marks += 1;
-        tokenizer.position += 1
+        tokenizer.advance(1)
     }
     let first: u32 = if hex.len() > 0 {
         num::from_str_radix(hex.as_slice(), 16).unwrap()
@@ -597,13 +762,13 @@ fn consume_unicode_range(tokenizer: &mut Tokenizer) -> ComponentValue {
     } else {
         start = first;
         hex.truncate(0);
-        if !tokenizer.is_eof() && tokenizer.current_char() == '-' {
-            tokenizer.position += 1;
+        if !tokenizer.is_eof() && tokenizer.next_char() == '-' {
+            tokenizer.advance(1);
             while hex.len() < 6 && !tokenizer.is_eof() {
-                let c = tokenizer.current_char();
+                let c = tokenizer.next_char();
                 match c {
                     '0'...'9' | 'A'...'F' | 'a'...'f' => {
-                        hex.push(c); tokenizer.position += 1 },
+                        hex.push(c); tokenizer.advance(1) },
                     _ => break
                 }
             }
@@ -624,17 +789,22 @@ fn consume_escape(tokenizer: &mut Tokenizer) -> char {
         '0'...'9' | 'A'...'F' | 'a'...'f' => {
             let mut hex = String::from_char(1, c);
             while hex.len() < 6 && !tokenizer.is_eof() {
-                let c = tokenizer.current_char();
+                let c = tokenizer.next_char();
                 match c {
                     '0'...'9' | 'A'...'F' | 'a'...'f' => {
-                        hex.push(c); tokenizer.position += 1 },
+                        hex.push(c); tokenizer.advance(1) },
                     _ => break
                 }
             }
             if !tokenizer.is_eof() {
-                match tokenizer.current_char() {
-                    ' ' | '\t' => tokenizer.position += 1,
-                    '\n' => { tokenizer.position += 1; tokenizer.new_line() },
+                match tokenizer.next_char() {
+                    ' ' | '\t' | '\n' | '\x0C' => tokenizer.advance(1),
+                    '\r' => {
+                        tokenizer.advance(1);
+                        if !tokenizer.is_eof() && tokenizer.next_char() == '\n' {
+                            tokenizer.advance(1);
+                        }
+                    }
                     _ => ()
                 }
             }
@@ -647,6 +817,7 @@ fn consume_escape(tokenizer: &mut Tokenizer) -> char {
                 REPLACEMENT_CHAR
             }
         },
+        '\0' => '\u{FFFD}',
         c => c
     }
 }