Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 7756 insertions, 0 deletions

diff --git a/third_party/rust/cssparser/src/color.rs b/third_party/rust/cssparser/src/color.rs
new file mode 100644
index 0000000000..f4484180ef
--- /dev/null
+++ b/third_party/rust/cssparser/src/color.rs
@@ -0,0 +1,1592 @@
+/* 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/. */
+
+// Allow text like <color> in docs.
+#![allow(rustdoc::invalid_html_tags)]
+
+use std::f32::consts::PI;
+use std::fmt;
+use std::str::FromStr;
+
+use super::{ParseError, Parser, ToCss, Token};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+const OPAQUE: f32 = 1.0;
+
+fn serialize_none_or<T>(dest: &mut impl fmt::Write, value: &Option<T>) -> fmt::Result
+where
+    T: ToCss,
+{
+    match value {
+        Some(v) => v.to_css(dest),
+        None => dest.write_str("none"),
+    }
+}
+
+/// <https://drafts.csswg.org/css-color-4/#serializing-alpha-values>
+#[inline]
+fn serialize_alpha(
+    dest: &mut impl fmt::Write,
+    alpha: Option<f32>,
+    legacy_syntax: bool,
+) -> fmt::Result {
+    let alpha = match alpha {
+        None => return dest.write_str(" / none"),
+        Some(a) => a,
+    };
+
+    // If the alpha component is full opaque, don't emit the alpha value in CSS.
+    if alpha == OPAQUE {
+        return Ok(());
+    }
+
+    dest.write_str(if legacy_syntax { ", " } else { " / " })?;
+
+    // Try first with two decimal places, then with three.
+    let mut rounded_alpha = (alpha * 100.).round() / 100.;
+    if clamp_unit_f32(rounded_alpha) != clamp_unit_f32(alpha) {
+        rounded_alpha = (alpha * 1000.).round() / 1000.;
+    }
+
+    rounded_alpha.to_css(dest)
+}
+
+// Guaratees hue in [0..360)
+fn normalize_hue(hue: f32) -> f32 {
+    // <https://drafts.csswg.org/css-values/#angles>
+    // Subtract an integer before rounding, to avoid some rounding errors:
+    hue - 360.0 * (hue / 360.0).floor()
+}
+
+/// A color with red, green, blue, and alpha components, in a byte each.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct RGBA {
+    /// The red component.
+    pub red: Option<u8>,
+    /// The green component.
+    pub green: Option<u8>,
+    /// The blue component.
+    pub blue: Option<u8>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+impl RGBA {
+    /// Constructs a new RGBA value from float components. It expects the red,
+    /// green, blue and alpha channels in that order, and all values will be
+    /// clamped to the 0.0 ... 1.0 range.
+    #[inline]
+    pub fn from_floats(
+        red: Option<f32>,
+        green: Option<f32>,
+        blue: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Self::new(
+            red.map(clamp_unit_f32),
+            green.map(clamp_unit_f32),
+            blue.map(clamp_unit_f32),
+            alpha.map(|a| a.clamp(0.0, OPAQUE)),
+        )
+    }
+
+    /// Same thing, but with `u8` values instead of floats in the 0 to 1 range.
+    #[inline]
+    pub const fn new(
+        red: Option<u8>,
+        green: Option<u8>,
+        blue: Option<u8>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Self {
+            red,
+            green,
+            blue,
+            alpha,
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for RGBA {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        (self.red, self.green, self.blue, self.alpha).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for RGBA {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (r, g, b, a) = Deserialize::deserialize(deserializer)?;
+        Ok(RGBA::new(r, g, b, a))
+    }
+}
+
+impl ToCss for RGBA {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        let has_alpha = self.alpha.unwrap_or(0.0) != OPAQUE;
+
+        dest.write_str(if has_alpha { "rgba(" } else { "rgb(" })?;
+        self.red.unwrap_or(0).to_css(dest)?;
+        dest.write_str(", ")?;
+        self.green.unwrap_or(0).to_css(dest)?;
+        dest.write_str(", ")?;
+        self.blue.unwrap_or(0).to_css(dest)?;
+
+        // Legacy syntax does not allow none components.
+        serialize_alpha(dest, Some(self.alpha.unwrap_or(0.0)), true)?;
+
+        dest.write_char(')')
+    }
+}
+
+/// Color specified by hue, saturation and lightness components.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Hsl {
+    /// The hue component.
+    pub hue: Option<f32>,
+    /// The saturation component.
+    pub saturation: Option<f32>,
+    /// The lightness component.
+    pub lightness: Option<f32>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+impl Hsl {
+    /// Construct a new HSL color from it's components.
+    pub fn new(
+        hue: Option<f32>,
+        saturation: Option<f32>,
+        lightness: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Self {
+            hue,
+            saturation,
+            lightness,
+            alpha,
+        }
+    }
+}
+
+impl ToCss for Hsl {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        // HSL serializes to RGB, so we have to convert it.
+        let (red, green, blue) = hsl_to_rgb(
+            self.hue.unwrap_or(0.0) / 360.0,
+            self.saturation.unwrap_or(0.0),
+            self.lightness.unwrap_or(0.0),
+        );
+
+        RGBA::from_floats(Some(red), Some(green), Some(blue), self.alpha).to_css(dest)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Hsl {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        (self.hue, self.saturation, self.lightness, self.alpha).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Hsl {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (lightness, a, b, alpha) = Deserialize::deserialize(deserializer)?;
+        Ok(Self::new(lightness, a, b, alpha))
+    }
+}
+
+/// Color specified by hue, whiteness and blackness components.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Hwb {
+    /// The hue component.
+    pub hue: Option<f32>,
+    /// The whiteness component.
+    pub whiteness: Option<f32>,
+    /// The blackness component.
+    pub blackness: Option<f32>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+impl Hwb {
+    /// Construct a new HWB color from it's components.
+    pub fn new(
+        hue: Option<f32>,
+        whiteness: Option<f32>,
+        blackness: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Self {
+            hue,
+            whiteness,
+            blackness,
+            alpha,
+        }
+    }
+}
+
+impl ToCss for Hwb {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        // HWB serializes to RGB, so we have to convert it.
+        let (red, green, blue) = hwb_to_rgb(
+            self.hue.unwrap_or(0.0) / 360.0,
+            self.whiteness.unwrap_or(0.0),
+            self.blackness.unwrap_or(0.0),
+        );
+
+        RGBA::from_floats(Some(red), Some(green), Some(blue), self.alpha).to_css(dest)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Hwb {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        (self.hue, self.whiteness, self.blackness, self.alpha).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Hwb {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (lightness, whiteness, blackness, alpha) = Deserialize::deserialize(deserializer)?;
+        Ok(Self::new(lightness, whiteness, blackness, alpha))
+    }
+}
+
+// NOTE: LAB and OKLAB is not declared inside the [impl_lab_like] macro,
+// because it causes cbindgen to ignore them.
+
+/// Color specified by lightness, a- and b-axis components.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Lab {
+    /// The lightness component.
+    pub lightness: Option<f32>,
+    /// The a-axis component.
+    pub a: Option<f32>,
+    /// The b-axis component.
+    pub b: Option<f32>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+/// Color specified by lightness, a- and b-axis components.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Oklab {
+    /// The lightness component.
+    pub lightness: Option<f32>,
+    /// The a-axis component.
+    pub a: Option<f32>,
+    /// The b-axis component.
+    pub b: Option<f32>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+macro_rules! impl_lab_like {
+    ($cls:ident, $fname:literal) => {
+        impl $cls {
+            /// Construct a new Lab color format with lightness, a, b and alpha components.
+            pub fn new(
+                lightness: Option<f32>,
+                a: Option<f32>,
+                b: Option<f32>,
+                alpha: Option<f32>,
+            ) -> Self {
+                Self {
+                    lightness,
+                    a,
+                    b,
+                    alpha,
+                }
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl Serialize for $cls {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                (self.lightness, self.a, self.b, self.alpha).serialize(serializer)
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl<'de> Deserialize<'de> for $cls {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                let (lightness, a, b, alpha) = Deserialize::deserialize(deserializer)?;
+                Ok(Self::new(lightness, a, b, alpha))
+            }
+        }
+
+        impl ToCss for $cls {
+            fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+            where
+                W: fmt::Write,
+            {
+                dest.write_str($fname)?;
+                dest.write_str("(")?;
+                serialize_none_or(dest, &self.lightness)?;
+                dest.write_char(' ')?;
+                serialize_none_or(dest, &self.a)?;
+                dest.write_char(' ')?;
+                serialize_none_or(dest, &self.b)?;
+                serialize_alpha(dest, self.alpha, false)?;
+                dest.write_char(')')
+            }
+        }
+    };
+}
+
+impl_lab_like!(Lab, "lab");
+impl_lab_like!(Oklab, "oklab");
+
+// NOTE: LCH and OKLCH is not declared inside the [impl_lch_like] macro,
+// because it causes cbindgen to ignore them.
+
+/// Color specified by lightness, chroma and hue components.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Lch {
+    /// The lightness component.
+    pub lightness: Option<f32>,
+    /// The chroma component.
+    pub chroma: Option<f32>,
+    /// The hue component.
+    pub hue: Option<f32>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+/// Color specified by lightness, chroma and hue components.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Oklch {
+    /// The lightness component.
+    pub lightness: Option<f32>,
+    /// The chroma component.
+    pub chroma: Option<f32>,
+    /// The hue component.
+    pub hue: Option<f32>,
+    /// The alpha component.
+    pub alpha: Option<f32>,
+}
+
+macro_rules! impl_lch_like {
+    ($cls:ident, $fname:literal) => {
+        impl $cls {
+            /// Construct a new color with lightness, chroma and hue components.
+            pub fn new(
+                lightness: Option<f32>,
+                chroma: Option<f32>,
+                hue: Option<f32>,
+                alpha: Option<f32>,
+            ) -> Self {
+                Self {
+                    lightness,
+                    chroma,
+                    hue,
+                    alpha,
+                }
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl Serialize for $cls {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                (self.lightness, self.chroma, self.hue, self.alpha).serialize(serializer)
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl<'de> Deserialize<'de> for $cls {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                let (lightness, chroma, hue, alpha) = Deserialize::deserialize(deserializer)?;
+                Ok(Self::new(lightness, chroma, hue, alpha))
+            }
+        }
+
+        impl ToCss for $cls {
+            fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+            where
+                W: fmt::Write,
+            {
+                dest.write_str($fname)?;
+                dest.write_str("(")?;
+                serialize_none_or(dest, &self.lightness)?;
+                dest.write_char(' ')?;
+                serialize_none_or(dest, &self.chroma)?;
+                dest.write_char(' ')?;
+                serialize_none_or(dest, &self.hue)?;
+                serialize_alpha(dest, self.alpha, false)?;
+                dest.write_char(')')
+            }
+        }
+    };
+}
+
+impl_lch_like!(Lch, "lch");
+impl_lch_like!(Oklch, "oklch");
+
+/// A Predefined color space specified in:
+/// <https://drafts.csswg.org/css-color-4/#predefined>
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum PredefinedColorSpace {
+    /// <https://drafts.csswg.org/css-color-4/#predefined-sRGB>
+    Srgb,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-sRGB-linear>
+    SrgbLinear,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-display-p3>
+    DisplayP3,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-a98-rgb>
+    A98Rgb,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-prophoto-rgb>
+    ProphotoRgb,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-rec2020>
+    Rec2020,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-xyz>
+    XyzD50,
+    /// <https://drafts.csswg.org/css-color-4/#predefined-xyz>
+    XyzD65,
+}
+
+impl PredefinedColorSpace {
+    /// Returns the string value of the predefined color space.
+    pub fn as_str(&self) -> &str {
+        match self {
+            PredefinedColorSpace::Srgb => "srgb",
+            PredefinedColorSpace::SrgbLinear => "srgb-linear",
+            PredefinedColorSpace::DisplayP3 => "display-p3",
+            PredefinedColorSpace::A98Rgb => "a98-rgb",
+            PredefinedColorSpace::ProphotoRgb => "prophoto-rgb",
+            PredefinedColorSpace::Rec2020 => "rec2020",
+            PredefinedColorSpace::XyzD50 => "xyz-d50",
+            PredefinedColorSpace::XyzD65 => "xyz-d65",
+        }
+    }
+}
+
+impl FromStr for PredefinedColorSpace {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match_ignore_ascii_case! { s,
+            "srgb" => PredefinedColorSpace::Srgb,
+            "srgb-linear" => PredefinedColorSpace::SrgbLinear,
+            "display-p3" => PredefinedColorSpace::DisplayP3,
+            "a98-rgb" => PredefinedColorSpace::A98Rgb,
+            "prophoto-rgb" => PredefinedColorSpace::ProphotoRgb,
+            "rec2020" => PredefinedColorSpace::Rec2020,
+            "xyz-d50" => PredefinedColorSpace::XyzD50,
+            "xyz" | "xyz-d65" => PredefinedColorSpace::XyzD65,
+
+            _ => return Err(()),
+        })
+    }
+}
+
+impl ToCss for PredefinedColorSpace {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        dest.write_str(self.as_str())
+    }
+}
+
+/// A color specified by the color() function.
+/// <https://drafts.csswg.org/css-color-4/#color-function>
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct ColorFunction {
+    /// The color space for this color.
+    pub color_space: PredefinedColorSpace,
+    /// The first component of the color.  Either red or x.
+    pub c1: Option<f32>,
+    /// The second component of the color.  Either green or y.
+    pub c2: Option<f32>,
+    /// The third component of the color.  Either blue or z.
+    pub c3: Option<f32>,
+    /// The alpha component of the color.
+    pub alpha: Option<f32>,
+}
+
+impl ColorFunction {
+    /// Construct a new color function definition with the given color space and
+    /// color components.
+    pub fn new(
+        color_space: PredefinedColorSpace,
+        c1: Option<f32>,
+        c2: Option<f32>,
+        c3: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Self {
+            color_space,
+            c1,
+            c2,
+            c3,
+            alpha,
+        }
+    }
+}
+
+impl ToCss for ColorFunction {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        dest.write_str("color(")?;
+        self.color_space.to_css(dest)?;
+        dest.write_char(' ')?;
+        serialize_none_or(dest, &self.c1)?;
+        dest.write_char(' ')?;
+        serialize_none_or(dest, &self.c2)?;
+        dest.write_char(' ')?;
+        serialize_none_or(dest, &self.c3)?;
+
+        serialize_alpha(dest, self.alpha, false)?;
+
+        dest.write_char(')')
+    }
+}
+
+/// Describes one of the value <color> values according to the CSS
+/// specification.
+///
+/// Most components are `Option<_>`, so when the value is `None`, that component
+/// serializes to the "none" keyword.
+///
+/// <https://drafts.csswg.org/css-color-4/#color-type>
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum Color {
+    /// The 'currentcolor' keyword.
+    CurrentColor,
+    /// Specify sRGB colors directly by their red/green/blue/alpha chanels.
+    Rgba(RGBA),
+    /// Specifies a color in sRGB using hue, saturation and lightness components.
+    Hsl(Hsl),
+    /// Specifies a color in sRGB using hue, whiteness and blackness components.
+    Hwb(Hwb),
+    /// Specifies a CIELAB color by CIE Lightness and its a- and b-axis hue
+    /// coordinates (red/green-ness, and yellow/blue-ness) using the CIE LAB
+    /// rectangular coordinate model.
+    Lab(Lab),
+    /// Specifies a CIELAB color by CIE Lightness, Chroma, and hue using the
+    /// CIE LCH cylindrical coordinate model.
+    Lch(Lch),
+    /// Specifies an Oklab color by Oklab Lightness and its a- and b-axis hue
+    /// coordinates (red/green-ness, and yellow/blue-ness) using the Oklab
+    /// rectangular coordinate model.
+    Oklab(Oklab),
+    /// Specifies an Oklab color by Oklab Lightness, Chroma, and hue using
+    /// the OKLCH cylindrical coordinate model.
+    Oklch(Oklch),
+    /// Specifies a color in a predefined color space.
+    ColorFunction(ColorFunction),
+}
+
+impl ToCss for Color {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        match *self {
+            Color::CurrentColor => dest.write_str("currentcolor"),
+            Color::Rgba(rgba) => rgba.to_css(dest),
+            Color::Hsl(hsl) => hsl.to_css(dest),
+            Color::Hwb(hwb) => hwb.to_css(dest),
+            Color::Lab(lab) => lab.to_css(dest),
+            Color::Lch(lch) => lch.to_css(dest),
+            Color::Oklab(lab) => lab.to_css(dest),
+            Color::Oklch(lch) => lch.to_css(dest),
+            Color::ColorFunction(color_function) => color_function.to_css(dest),
+        }
+    }
+}
+
+/// Either a number or a percentage.
+pub enum NumberOrPercentage {
+    /// `<number>`.
+    Number {
+        /// The numeric value parsed, as a float.
+        value: f32,
+    },
+    /// `<percentage>`
+    Percentage {
+        /// The value as a float, divided by 100 so that the nominal range is
+        /// 0.0 to 1.0.
+        unit_value: f32,
+    },
+}
+
+impl NumberOrPercentage {
+    fn unit_value(&self) -> f32 {
+        match *self {
+            NumberOrPercentage::Number { value } => value,
+            NumberOrPercentage::Percentage { unit_value } => unit_value,
+        }
+    }
+
+    fn value(&self, percentage_basis: f32) -> f32 {
+        match *self {
+            Self::Number { value } => value,
+            Self::Percentage { unit_value } => unit_value * percentage_basis,
+        }
+    }
+}
+
+/// Either an angle or a number.
+pub enum AngleOrNumber {
+    /// `<number>`.
+    Number {
+        /// The numeric value parsed, as a float.
+        value: f32,
+    },
+    /// `<angle>`
+    Angle {
+        /// The value as a number of degrees.
+        degrees: f32,
+    },
+}
+
+impl AngleOrNumber {
+    fn degrees(&self) -> f32 {
+        match *self {
+            AngleOrNumber::Number { value } => value,
+            AngleOrNumber::Angle { degrees } => degrees,
+        }
+    }
+}
+
+/// A trait that can be used to hook into how `cssparser` parses color
+/// components, with the intention of implementing more complicated behavior.
+///
+/// For example, this is used by Servo to support calc() in color.
+pub trait ColorParser<'i> {
+    /// The type that the parser will construct on a successful parse.
+    type Output: FromParsedColor;
+
+    /// A custom error type that can be returned from the parsing functions.
+    type Error: 'i;
+
+    /// Parse an `<angle>` or `<number>`.
+    ///
+    /// Returns the result in degrees.
+    fn parse_angle_or_number<'t>(
+        &self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<AngleOrNumber, ParseError<'i, Self::Error>> {
+        let location = input.current_source_location();
+        Ok(match *input.next()? {
+            Token::Number { value, .. } => AngleOrNumber::Number { value },
+            Token::Dimension {
+                value: v, ref unit, ..
+            } => {
+                let degrees = match_ignore_ascii_case! { unit,
+                    "deg" => v,
+                    "grad" => v * 360. / 400.,
+                    "rad" => v * 360. / (2. * PI),
+                    "turn" => v * 360.,
+                    _ => {
+                        return Err(location.new_unexpected_token_error(Token::Ident(unit.clone())))
+                    }
+                };
+
+                AngleOrNumber::Angle { degrees }
+            }
+            ref t => return Err(location.new_unexpected_token_error(t.clone())),
+        })
+    }
+
+    /// Parse a `<percentage>` value.
+    ///
+    /// Returns the result in a number from 0.0 to 1.0.
+    fn parse_percentage<'t>(
+        &self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<f32, ParseError<'i, Self::Error>> {
+        input.expect_percentage().map_err(From::from)
+    }
+
+    /// Parse a `<number>` value.
+    fn parse_number<'t>(
+        &self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<f32, ParseError<'i, Self::Error>> {
+        input.expect_number().map_err(From::from)
+    }
+
+    /// Parse a `<number>` value or a `<percentage>` value.
+    fn parse_number_or_percentage<'t>(
+        &self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<NumberOrPercentage, ParseError<'i, Self::Error>> {
+        let location = input.current_source_location();
+        Ok(match *input.next()? {
+            Token::Number { value, .. } => NumberOrPercentage::Number { value },
+            Token::Percentage { unit_value, .. } => NumberOrPercentage::Percentage { unit_value },
+            ref t => return Err(location.new_unexpected_token_error(t.clone())),
+        })
+    }
+}
+
+/// Default implementation of a [`ColorParser`]
+pub struct DefaultColorParser;
+
+impl<'i> ColorParser<'i> for DefaultColorParser {
+    type Output = Color;
+    type Error = ();
+}
+
+impl Color {
+    /// Parse a <color> value, per CSS Color Module Level 3.
+    ///
+    /// FIXME(#2) Deprecated CSS2 System Colors are not supported yet.
+    pub fn parse<'i>(input: &mut Parser<'i, '_>) -> Result<Color, ParseError<'i, ()>> {
+        parse_color_with(&DefaultColorParser, input)
+    }
+}
+
+/// This trait is used by the [`ColorParser`] to construct colors of any type.
+pub trait FromParsedColor {
+    /// Construct a new color from the CSS `currentcolor` keyword.
+    fn from_current_color() -> Self;
+
+    /// Construct a new color from red, green, blue and alpha components.
+    fn from_rgba(red: Option<u8>, green: Option<u8>, blue: Option<u8>, alpha: Option<f32>) -> Self;
+
+    /// Construct a new color from hue, saturation, lightness and alpha components.
+    fn from_hsl(
+        hue: Option<f32>,
+        saturation: Option<f32>,
+        lightness: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self;
+
+    /// Construct a new color from hue, blackness, whiteness and alpha components.
+    fn from_hwb(
+        hue: Option<f32>,
+        whiteness: Option<f32>,
+        blackness: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self;
+
+    /// Construct a new color from the `lab` notation.
+    fn from_lab(lightness: Option<f32>, a: Option<f32>, b: Option<f32>, alpha: Option<f32>)
+        -> Self;
+
+    /// Construct a new color from the `lch` notation.
+    fn from_lch(
+        lightness: Option<f32>,
+        chroma: Option<f32>,
+        hue: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self;
+
+    /// Construct a new color from the `oklab` notation.
+    fn from_oklab(
+        lightness: Option<f32>,
+        a: Option<f32>,
+        b: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self;
+
+    /// Construct a new color from the `oklch` notation.
+    fn from_oklch(
+        lightness: Option<f32>,
+        chroma: Option<f32>,
+        hue: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self;
+
+    /// Construct a new color with a predefined color space.
+    fn from_color_function(
+        color_space: PredefinedColorSpace,
+        c1: Option<f32>,
+        c2: Option<f32>,
+        c3: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self;
+}
+
+/// Parse a color hash, without the leading '#' character.
+#[inline]
+pub fn parse_hash_color<'i, O>(value: &[u8]) -> Result<O, ()>
+where
+    O: FromParsedColor,
+{
+    Ok(match value.len() {
+        8 => O::from_rgba(
+            Some(from_hex(value[0])? * 16 + from_hex(value[1])?),
+            Some(from_hex(value[2])? * 16 + from_hex(value[3])?),
+            Some(from_hex(value[4])? * 16 + from_hex(value[5])?),
+            Some((from_hex(value[6])? * 16 + from_hex(value[7])?) as f32 / 255.0),
+        ),
+        6 => O::from_rgba(
+            Some(from_hex(value[0])? * 16 + from_hex(value[1])?),
+            Some(from_hex(value[2])? * 16 + from_hex(value[3])?),
+            Some(from_hex(value[4])? * 16 + from_hex(value[5])?),
+            Some(OPAQUE),
+        ),
+        4 => O::from_rgba(
+            Some(from_hex(value[0])? * 17),
+            Some(from_hex(value[1])? * 17),
+            Some(from_hex(value[2])? * 17),
+            Some((from_hex(value[3])? * 17) as f32 / 255.0),
+        ),
+        3 => O::from_rgba(
+            Some(from_hex(value[0])? * 17),
+            Some(from_hex(value[1])? * 17),
+            Some(from_hex(value[2])? * 17),
+            Some(OPAQUE),
+        ),
+        _ => return Err(()),
+    })
+}
+
+/// Parse a CSS color using the specified [`ColorParser`] and return a new color
+/// value on success.
+pub fn parse_color_with<'i, 't, P>(
+    color_parser: &P,
+    input: &mut Parser<'i, 't>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let location = input.current_source_location();
+    let token = input.next()?;
+    match *token {
+        Token::Hash(ref value) | Token::IDHash(ref value) => parse_hash_color(value.as_bytes()),
+        Token::Ident(ref value) => parse_color_keyword(value),
+        Token::Function(ref name) => {
+            let name = name.clone();
+            return input.parse_nested_block(|arguments| {
+                parse_color_function(color_parser, &name, arguments)
+            });
+        }
+        _ => Err(()),
+    }
+    .map_err(|()| location.new_unexpected_token_error(token.clone()))
+}
+
+impl FromParsedColor for Color {
+    #[inline]
+    fn from_current_color() -> Self {
+        Color::CurrentColor
+    }
+
+    #[inline]
+    fn from_rgba(red: Option<u8>, green: Option<u8>, blue: Option<u8>, alpha: Option<f32>) -> Self {
+        Color::Rgba(RGBA::new(red, green, blue, alpha))
+    }
+
+    fn from_hsl(
+        hue: Option<f32>,
+        saturation: Option<f32>,
+        lightness: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::Hsl(Hsl::new(hue, saturation, lightness, alpha))
+    }
+
+    fn from_hwb(
+        hue: Option<f32>,
+        blackness: Option<f32>,
+        whiteness: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::Hwb(Hwb::new(hue, blackness, whiteness, alpha))
+    }
+
+    #[inline]
+    fn from_lab(
+        lightness: Option<f32>,
+        a: Option<f32>,
+        b: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::Lab(Lab::new(lightness, a, b, alpha))
+    }
+
+    #[inline]
+    fn from_lch(
+        lightness: Option<f32>,
+        chroma: Option<f32>,
+        hue: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::Lch(Lch::new(lightness, chroma, hue, alpha))
+    }
+
+    #[inline]
+    fn from_oklab(
+        lightness: Option<f32>,
+        a: Option<f32>,
+        b: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::Oklab(Oklab::new(lightness, a, b, alpha))
+    }
+
+    #[inline]
+    fn from_oklch(
+        lightness: Option<f32>,
+        chroma: Option<f32>,
+        hue: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::Oklch(Oklch::new(lightness, chroma, hue, alpha))
+    }
+
+    #[inline]
+    fn from_color_function(
+        color_space: PredefinedColorSpace,
+        c1: Option<f32>,
+        c2: Option<f32>,
+        c3: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
+        Color::ColorFunction(ColorFunction::new(color_space, c1, c2, c3, alpha))
+    }
+}
+
+/// Return the named color with the given name.
+///
+/// Matching is case-insensitive in the ASCII range.
+/// CSS escaping (if relevant) should be resolved before calling this function.
+/// (For example, the value of an `Ident` token is fine.)
+#[inline]
+pub fn parse_color_keyword<Output>(ident: &str) -> Result<Output, ()>
+where
+    Output: FromParsedColor,
+{
+    ascii_case_insensitive_phf_map! {
+        keyword -> (u8, u8, u8) = {
+            "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),
+
+            "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 ,
+        "transparent" => Ok(Output::from_rgba(Some(0), Some(0), Some(0), Some(0.0))),
+        "currentcolor" => Ok(Output::from_current_color()),
+        _ => keyword(ident)
+            .map(|(r, g, b)| Output::from_rgba(Some(*r), Some(*g), Some(*b), Some(1.0)))
+            .ok_or(()),
+    }
+}
+
+#[inline]
+fn from_hex(c: u8) -> Result<u8, ()> {
+    match c {
+        b'0'..=b'9' => Ok(c - b'0'),
+        b'a'..=b'f' => Ok(c - b'a' + 10),
+        b'A'..=b'F' => Ok(c - b'A' + 10),
+        _ => Err(()),
+    }
+}
+
+fn clamp_unit_f32(val: f32) -> u8 {
+    // Whilst scaling by 256 and flooring would provide
+    // an equal distribution of integers to percentage inputs,
+    // this is not what Gecko does so we instead multiply by 255
+    // and round (adding 0.5 and flooring is equivalent to rounding)
+    //
+    // Chrome does something similar for the alpha value, but not
+    // the rgb values.
+    //
+    // See <https://bugzilla.mozilla.org/show_bug.cgi?id=1340484>
+    //
+    // Clamping to 256 and rounding after would let 1.0 map to 256, and
+    // `256.0_f32 as u8` is undefined behavior:
+    //
+    // <https://github.com/rust-lang/rust/issues/10184>
+    clamp_floor_256_f32(val * 255.)
+}
+
+fn clamp_floor_256_f32(val: f32) -> u8 {
+    val.round().clamp(0., 255.) as u8
+}
+
+fn parse_none_or<'i, 't, F, T, E>(input: &mut Parser<'i, 't>, thing: F) -> Result<Option<T>, E>
+where
+    F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>,
+{
+    match input.try_parse(|p| p.expect_ident_matching("none")) {
+        Ok(_) => Ok(None),
+        Err(_) => Ok(Some(thing(input)?)),
+    }
+}
+
+/// Parse one of the color functions: rgba(), lab(), color(), etc.
+#[inline]
+fn parse_color_function<'i, 't, P>(
+    color_parser: &P,
+    name: &str,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let color = match_ignore_ascii_case! { name,
+        "rgb" | "rgba" => parse_rgb(color_parser, arguments),
+
+        "hsl" | "hsla" => parse_hsl(color_parser, arguments),
+
+        "hwb" => parse_hwb(color_parser, arguments),
+
+        // for L: 0% = 0.0, 100% = 100.0
+        // for a and b: -100% = -125, 100% = 125
+        "lab" => parse_lab_like(color_parser, arguments, 100.0, 125.0, P::Output::from_lab),
+
+        // for L: 0% = 0.0, 100% = 100.0
+        // for C: 0% = 0, 100% = 150
+        "lch" => parse_lch_like(color_parser, arguments, 100.0, 150.0, P::Output::from_lch),
+
+        // for L: 0% = 0.0, 100% = 1.0
+        // for a and b: -100% = -0.4, 100% = 0.4
+        "oklab" => parse_lab_like(color_parser, arguments, 1.0, 0.4, P::Output::from_oklab),
+
+        // for L: 0% = 0.0, 100% = 1.0
+        // for C: 0% = 0.0 100% = 0.4
+        "oklch" => parse_lch_like(color_parser, arguments, 1.0, 0.4, P::Output::from_oklch),
+
+        "color" => parse_color_with_color_space(color_parser, arguments),
+
+        _ => return Err(arguments.new_unexpected_token_error(Token::Ident(name.to_owned().into()))),
+    }?;
+
+    arguments.expect_exhausted()?;
+
+    Ok(color)
+}
+
+/// Parse the alpha component by itself from either number or percentage,
+/// clipping the result to [0.0..1.0].
+#[inline]
+fn parse_alpha_component<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<f32, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    Ok(color_parser
+        .parse_number_or_percentage(arguments)?
+        .unit_value()
+        .clamp(0.0, OPAQUE))
+}
+
+fn parse_legacy_alpha<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<f32, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    Ok(if !arguments.is_exhausted() {
+        arguments.expect_comma()?;
+        parse_alpha_component(color_parser, arguments)?
+    } else {
+        OPAQUE
+    })
+}
+
+fn parse_modern_alpha<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<Option<f32>, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    if !arguments.is_exhausted() {
+        arguments.expect_delim('/')?;
+        parse_none_or(arguments, |p| parse_alpha_component(color_parser, p))
+    } else {
+        Ok(Some(OPAQUE))
+    }
+}
+
+#[inline]
+fn parse_rgb<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let maybe_red = parse_none_or(arguments, |p| color_parser.parse_number_or_percentage(p))?;
+
+    // If the first component is not "none" and is followed by a comma, then we
+    // are parsing the legacy syntax.
+    let is_legacy_syntax = maybe_red.is_some() && arguments.try_parse(|p| p.expect_comma()).is_ok();
+
+    let red: Option<u8>;
+    let green: Option<u8>;
+    let blue: Option<u8>;
+
+    let alpha = if is_legacy_syntax {
+        match maybe_red.unwrap() {
+            NumberOrPercentage::Number { value } => {
+                red = Some(clamp_floor_256_f32(value));
+                green = Some(clamp_floor_256_f32(color_parser.parse_number(arguments)?));
+                arguments.expect_comma()?;
+                blue = Some(clamp_floor_256_f32(color_parser.parse_number(arguments)?));
+            }
+            NumberOrPercentage::Percentage { unit_value } => {
+                red = Some(clamp_unit_f32(unit_value));
+                green = Some(clamp_unit_f32(color_parser.parse_percentage(arguments)?));
+                arguments.expect_comma()?;
+                blue = Some(clamp_unit_f32(color_parser.parse_percentage(arguments)?));
+            }
+        }
+
+        Some(parse_legacy_alpha(color_parser, arguments)?)
+    } else {
+        #[inline]
+        fn get_component_value(c: Option<NumberOrPercentage>) -> Option<u8> {
+            c.map(|c| match c {
+                NumberOrPercentage::Number { value } => clamp_floor_256_f32(value),
+                NumberOrPercentage::Percentage { unit_value } => clamp_unit_f32(unit_value),
+            })
+        }
+
+        red = get_component_value(maybe_red);
+
+        green = get_component_value(parse_none_or(arguments, |p| {
+            color_parser.parse_number_or_percentage(p)
+        })?);
+
+        blue = get_component_value(parse_none_or(arguments, |p| {
+            color_parser.parse_number_or_percentage(p)
+        })?);
+
+        parse_modern_alpha(color_parser, arguments)?
+    };
+
+    Ok(P::Output::from_rgba(red, green, blue, alpha))
+}
+
+/// Parses hsl syntax.
+///
+/// <https://drafts.csswg.org/css-color/#the-hsl-notation>
+#[inline]
+fn parse_hsl<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let maybe_hue = parse_none_or(arguments, |p| color_parser.parse_angle_or_number(p))?;
+
+    // If the hue is not "none" and is followed by a comma, then we are parsing
+    // the legacy syntax.
+    let is_legacy_syntax = maybe_hue.is_some() && arguments.try_parse(|p| p.expect_comma()).is_ok();
+
+    let saturation: Option<f32>;
+    let lightness: Option<f32>;
+
+    let alpha = if is_legacy_syntax {
+        saturation = Some(color_parser.parse_percentage(arguments)?);
+        arguments.expect_comma()?;
+        lightness = Some(color_parser.parse_percentage(arguments)?);
+        Some(parse_legacy_alpha(color_parser, arguments)?)
+    } else {
+        saturation = parse_none_or(arguments, |p| color_parser.parse_percentage(p))?;
+        lightness = parse_none_or(arguments, |p| color_parser.parse_percentage(p))?;
+
+        parse_modern_alpha(color_parser, arguments)?
+    };
+
+    let hue = maybe_hue.map(|h| normalize_hue(h.degrees()));
+    let saturation = saturation.map(|s| s.clamp(0.0, 1.0));
+    let lightness = lightness.map(|l| l.clamp(0.0, 1.0));
+
+    Ok(P::Output::from_hsl(hue, saturation, lightness, alpha))
+}
+
+/// Parses hwb syntax.
+///
+/// <https://drafts.csswg.org/css-color/#the-hbw-notation>
+#[inline]
+fn parse_hwb<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let (hue, whiteness, blackness, alpha) = parse_components(
+        color_parser,
+        arguments,
+        P::parse_angle_or_number,
+        P::parse_percentage,
+        P::parse_percentage,
+    )?;
+
+    let hue = hue.map(|h| normalize_hue(h.degrees()));
+    let whiteness = whiteness.map(|w| w.clamp(0.0, 1.0));
+    let blackness = blackness.map(|b| b.clamp(0.0, 1.0));
+
+    Ok(P::Output::from_hwb(hue, whiteness, blackness, alpha))
+}
+
+/// <https://drafts.csswg.org/css-color-4/#hwb-to-rgb>
+#[inline]
+pub fn hwb_to_rgb(h: f32, w: f32, b: f32) -> (f32, f32, f32) {
+    if w + b >= 1.0 {
+        let gray = w / (w + b);
+        return (gray, gray, gray);
+    }
+
+    // hue is expected in the range [0..1].
+    let (mut red, mut green, mut blue) = hsl_to_rgb(h, 1.0, 0.5);
+    let x = 1.0 - w - b;
+    red = red * x + w;
+    green = green * x + w;
+    blue = blue * x + w;
+    (red, green, blue)
+}
+
+/// <https://drafts.csswg.org/css-color/#hsl-color>
+/// except with h pre-multiplied by 3, to avoid some rounding errors.
+#[inline]
+pub fn hsl_to_rgb(hue: f32, saturation: f32, lightness: f32) -> (f32, f32, f32) {
+    debug_assert!((0.0..=1.0).contains(&hue));
+
+    fn hue_to_rgb(m1: f32, m2: f32, mut h3: f32) -> f32 {
+        if h3 < 0. {
+            h3 += 3.
+        }
+        if h3 > 3. {
+            h3 -= 3.
+        }
+        if h3 * 2. < 1. {
+            m1 + (m2 - m1) * h3 * 2.
+        } else if h3 * 2. < 3. {
+            m2
+        } else if h3 < 2. {
+            m1 + (m2 - m1) * (2. - h3) * 2.
+        } else {
+            m1
+        }
+    }
+    let m2 = if lightness <= 0.5 {
+        lightness * (saturation + 1.)
+    } else {
+        lightness + saturation - lightness * saturation
+    };
+    let m1 = lightness * 2. - m2;
+    let hue_times_3 = hue * 3.;
+    let red = hue_to_rgb(m1, m2, hue_times_3 + 1.);
+    let green = hue_to_rgb(m1, m2, hue_times_3);
+    let blue = hue_to_rgb(m1, m2, hue_times_3 - 1.);
+    (red, green, blue)
+}
+
+type IntoColorFn<Output> =
+    fn(l: Option<f32>, a: Option<f32>, b: Option<f32>, alpha: Option<f32>) -> Output;
+
+#[inline]
+fn parse_lab_like<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+    lightness_range: f32,
+    a_b_range: f32,
+    into_color: IntoColorFn<P::Output>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let (lightness, a, b, alpha) = parse_components(
+        color_parser,
+        arguments,
+        P::parse_number_or_percentage,
+        P::parse_number_or_percentage,
+        P::parse_number_or_percentage,
+    )?;
+
+    let lightness = lightness.map(|l| l.value(lightness_range).max(0.0));
+    let a = a.map(|a| a.value(a_b_range));
+    let b = b.map(|b| b.value(a_b_range));
+
+    Ok(into_color(lightness, a, b, alpha))
+}
+
+#[inline]
+fn parse_lch_like<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+    lightness_range: f32,
+    chroma_range: f32,
+    into_color: IntoColorFn<P::Output>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let (lightness, chroma, hue, alpha) = parse_components(
+        color_parser,
+        arguments,
+        P::parse_number_or_percentage,
+        P::parse_number_or_percentage,
+        P::parse_angle_or_number,
+    )?;
+
+    let lightness = lightness.map(|l| l.value(lightness_range).max(0.0));
+    let chroma = chroma.map(|c| c.value(chroma_range).max(0.0));
+    let hue = hue.map(|h| normalize_hue(h.degrees()));
+
+    Ok(into_color(lightness, chroma, hue, alpha))
+}
+
+/// Parse the color() function.
+#[inline]
+fn parse_color_with_color_space<'i, 't, P>(
+    color_parser: &P,
+    arguments: &mut Parser<'i, 't>,
+) -> Result<P::Output, ParseError<'i, P::Error>>
+where
+    P: ColorParser<'i>,
+{
+    let color_space = {
+        let location = arguments.current_source_location();
+
+        let ident = arguments.expect_ident()?;
+        PredefinedColorSpace::from_str(ident)
+            .map_err(|_| location.new_unexpected_token_error(Token::Ident(ident.clone())))?
+    };
+
+    let (c1, c2, c3, alpha) = parse_components(
+        color_parser,
+        arguments,
+        P::parse_number_or_percentage,
+        P::parse_number_or_percentage,
+        P::parse_number_or_percentage,
+    )?;
+
+    let c1 = c1.map(|c| c.unit_value());
+    let c2 = c2.map(|c| c.unit_value());
+    let c3 = c3.map(|c| c.unit_value());
+
+    Ok(P::Output::from_color_function(
+        color_space,
+        c1,
+        c2,
+        c3,
+        alpha,
+    ))
+}
+
+type ComponentParseResult<'i, R1, R2, R3, Error> =
+    Result<(Option<R1>, Option<R2>, Option<R3>, Option<f32>), ParseError<'i, Error>>;
+
+/// Parse the color components and alpha with the modern [color-4] syntax.
+pub fn parse_components<'i, 't, P, F1, F2, F3, R1, R2, R3>(
+    color_parser: &P,
+    input: &mut Parser<'i, 't>,
+    f1: F1,
+    f2: F2,
+    f3: F3,
+) -> ComponentParseResult<'i, R1, R2, R3, P::Error>
+where
+    P: ColorParser<'i>,
+    F1: FnOnce(&P, &mut Parser<'i, 't>) -> Result<R1, ParseError<'i, P::Error>>,
+    F2: FnOnce(&P, &mut Parser<'i, 't>) -> Result<R2, ParseError<'i, P::Error>>,
+    F3: FnOnce(&P, &mut Parser<'i, 't>) -> Result<R3, ParseError<'i, P::Error>>,
+{
+    let r1 = parse_none_or(input, |p| f1(color_parser, p))?;
+    let r2 = parse_none_or(input, |p| f2(color_parser, p))?;
+    let r3 = parse_none_or(input, |p| f3(color_parser, p))?;
+
+    let alpha = parse_modern_alpha(color_parser, input)?;
+
+    Ok((r1, r2, r3, alpha))
+}
diff --git a/third_party/rust/cssparser/src/cow_rc_str.rs b/third_party/rust/cssparser/src/cow_rc_str.rs
new file mode 100644
index 0000000000..ecf14a0a75
--- /dev/null
+++ b/third_party/rust/cssparser/src/cow_rc_str.rs
@@ -0,0 +1,185 @@
+/* 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::borrow::{Borrow, Cow};
+use std::rc::Rc;
+use std::{cmp, fmt, hash, marker, mem, ops, slice, str, ptr};
+
+/// A string that is either shared (heap-allocated and reference-counted) or borrowed.
+///
+/// Equivalent to `enum { Borrowed(&'a str), Shared(Rc<String>) }`, but stored more compactly.
+///
+/// * If `borrowed_len_or_max == usize::MAX`, then `ptr` represents `NonZero<*const String>`
+///   from `Rc::into_raw`.
+///   The lifetime parameter `'a` is irrelevant in this case.
+///
+/// * Otherwise, `ptr` represents the `NonZero<*const u8>` data component of `&'a str`,
+///   and `borrowed_len_or_max` its length.
+pub struct CowRcStr<'a> {
+    ptr: ptr::NonNull<()>,
+    borrowed_len_or_max: usize,
+
+    phantom: marker::PhantomData<Result<&'a str, Rc<String>>>,
+}
+
+fn _static_assert_same_size<'a>() {
+    // "Instantiate" the generic function without calling it.
+    let _ = mem::transmute::<CowRcStr<'a>, Option<CowRcStr<'a>>>;
+}
+
+impl<'a> From<Cow<'a, str>> for CowRcStr<'a> {
+    #[inline]
+    fn from(s: Cow<'a, str>) -> Self {
+        match s {
+            Cow::Borrowed(s) => CowRcStr::from(s),
+            Cow::Owned(s) => CowRcStr::from(s),
+        }
+    }
+}
+
+impl<'a> From<&'a str> for CowRcStr<'a> {
+    #[inline]
+    fn from(s: &'a str) -> Self {
+        let len = s.len();
+        assert!(len < usize::MAX);
+        CowRcStr {
+            ptr: unsafe { ptr::NonNull::new_unchecked(s.as_ptr() as *mut ()) },
+            borrowed_len_or_max: len,
+            phantom: marker::PhantomData,
+        }
+    }
+}
+
+impl<'a> From<String> for CowRcStr<'a> {
+    #[inline]
+    fn from(s: String) -> Self {
+        CowRcStr::from_rc(Rc::new(s))
+    }
+}
+
+impl<'a> CowRcStr<'a> {
+    #[inline]
+    fn from_rc(s: Rc<String>) -> Self {
+        let ptr = unsafe { ptr::NonNull::new_unchecked(Rc::into_raw(s) as *mut ()) };
+        CowRcStr {
+            ptr,
+            borrowed_len_or_max: usize::MAX,
+            phantom: marker::PhantomData,
+        }
+    }
+
+    #[inline]
+    fn unpack(&self) -> Result<&'a str, *const String> {
+        if self.borrowed_len_or_max == usize::MAX {
+            Err(self.ptr.as_ptr() as *const String)
+        } else {
+            unsafe {
+                Ok(str::from_utf8_unchecked(slice::from_raw_parts(
+                    self.ptr.as_ptr() as *const u8,
+                    self.borrowed_len_or_max,
+                )))
+            }
+        }
+    }
+}
+
+impl<'a> Clone for CowRcStr<'a> {
+    #[inline]
+    fn clone(&self) -> Self {
+        match self.unpack() {
+            Err(ptr) => {
+                let rc = unsafe { Rc::from_raw(ptr) };
+                let new_rc = rc.clone();
+                mem::forget(rc); // Don’t actually take ownership of this strong reference
+                CowRcStr::from_rc(new_rc)
+            }
+            Ok(_) => CowRcStr { ..*self },
+        }
+    }
+}
+
+impl<'a> Drop for CowRcStr<'a> {
+    #[inline]
+    fn drop(&mut self) {
+        if let Err(ptr) = self.unpack() {
+            mem::drop(unsafe { Rc::from_raw(ptr) })
+        }
+    }
+}
+
+impl<'a> ops::Deref for CowRcStr<'a> {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &str {
+        self.unpack().unwrap_or_else(|ptr| unsafe { &**ptr })
+    }
+}
+
+// Boilerplate / trivial impls below.
+
+impl<'a> AsRef<str> for CowRcStr<'a> {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self
+    }
+}
+
+impl<'a> Borrow<str> for CowRcStr<'a> {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self
+    }
+}
+
+impl<'a> Default for CowRcStr<'a> {
+    #[inline]
+    fn default() -> Self {
+        Self::from("")
+    }
+}
+
+impl<'a> hash::Hash for CowRcStr<'a> {
+    #[inline]
+    fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
+        str::hash(self, hasher)
+    }
+}
+
+impl<'a, T: AsRef<str>> PartialEq<T> for CowRcStr<'a> {
+    #[inline]
+    fn eq(&self, other: &T) -> bool {
+        str::eq(self, other.as_ref())
+    }
+}
+
+impl<'a, T: AsRef<str>> PartialOrd<T> for CowRcStr<'a> {
+    #[inline]
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        str::partial_cmp(self, other.as_ref())
+    }
+}
+
+impl<'a> Eq for CowRcStr<'a> {}
+
+impl<'a> Ord for CowRcStr<'a> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        str::cmp(self, other)
+    }
+}
+
+impl<'a> fmt::Display for CowRcStr<'a> {
+    #[inline]
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        str::fmt(self, formatter)
+    }
+}
+
+impl<'a> fmt::Debug for CowRcStr<'a> {
+    #[inline]
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        str::fmt(self, formatter)
+    }
+}
diff --git a/third_party/rust/cssparser/src/from_bytes.rs b/third_party/rust/cssparser/src/from_bytes.rs
new file mode 100644
index 0000000000..78a56d3e14
--- /dev/null
+++ b/third_party/rust/cssparser/src/from_bytes.rs
@@ -0,0 +1,64 @@
+/* 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/. */
+
+/// Abstraction for avoiding a dependency from cssparser to an encoding library
+pub trait EncodingSupport {
+    /// One character encoding
+    type Encoding;
+
+    /// https://encoding.spec.whatwg.org/#concept-encoding-get
+    fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding>;
+
+    /// Return the UTF-8 encoding
+    fn utf8() -> Self::Encoding;
+
+    /// Whether the given encoding is UTF-16BE or UTF-16LE
+    fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool;
+}
+
+/// Determine the character encoding of a CSS stylesheet.
+///
+/// This is based on the presence of a BOM (Byte Order Mark), an `@charset` rule, and
+/// encoding meta-information.
+///
+/// * `css_bytes`: A byte string.
+/// * `protocol_encoding`: The encoding label, if any, defined by HTTP or equivalent protocol.
+///     (e.g. via the `charset` parameter of the `Content-Type` header.)
+/// * `environment_encoding`: An optional `Encoding` object for the [environment encoding]
+///     (https://drafts.csswg.org/css-syntax/#environment-encoding), if any.
+///
+/// Returns the encoding to use.
+pub fn stylesheet_encoding<E>(
+    css: &[u8],
+    protocol_encoding_label: Option<&[u8]>,
+    environment_encoding: Option<E::Encoding>,
+) -> E::Encoding
+where
+    E: EncodingSupport,
+{
+    // https://drafts.csswg.org/css-syntax/#the-input-byte-stream
+    if let Some(label) = protocol_encoding_label {
+        if let Some(protocol_encoding) = E::from_label(label) {
+            return protocol_encoding;
+        };
+    };
+
+    let prefix = b"@charset \"";
+    if css.starts_with(prefix) {
+        let rest = &css[prefix.len()..];
+        if let Some(label_length) = rest.iter().position(|&b| b == b'"') {
+            if rest[label_length..].starts_with(b"\";") {
+                let label = &rest[..label_length];
+                if let Some(charset_encoding) = E::from_label(label) {
+                    if E::is_utf16_be_or_le(&charset_encoding) {
+                        return E::utf8();
+                    } else {
+                        return charset_encoding;
+                    }
+                }
+            }
+        }
+    }
+    environment_encoding.unwrap_or_else(E::utf8)
+}
diff --git a/third_party/rust/cssparser/src/lib.rs b/third_party/rust/cssparser/src/lib.rs
new file mode 100644
index 0000000000..1bbcb55547
--- /dev/null
+++ b/third_party/rust/cssparser/src/lib.rs
@@ -0,0 +1,113 @@
+/* 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/. */
+
+#![crate_name = "cssparser"]
+#![crate_type = "rlib"]
+#![cfg_attr(feature = "bench", feature(test))]
+#![deny(missing_docs)]
+
+/*!
+
+Implementation of [CSS Syntax Module Level 3](https://drafts.csswg.org/css-syntax/) for Rust.
+
+# Input
+
+Everything is based on `Parser` objects, which borrow a `&str` input.
+If you have bytes (from a file, the network, or something)
+and want to support character encodings other than UTF-8,
+see the `stylesheet_encoding` function,
+which can be used together with rust-encoding or encoding-rs.
+
+# Conventions for parsing functions
+
+* Take (at least) a `input: &mut cssparser::Parser` parameter
+* Return `Result<_, ()>`
+* When returning `Ok(_)`,
+  the function must have consumed exactly the amount of input that represents the parsed value.
+* When returning `Err(())`, any amount of input may have been consumed.
+
+As a consequence, when calling another parsing function, either:
+
+* Any `Err(())` return value must be propagated.
+  This happens by definition for tail calls,
+  and can otherwise be done with the `?` operator.
+* Or the call must be wrapped in a `Parser::try` call.
+  `try` takes a closure that takes a `Parser` and returns a `Result`,
+  calls it once,
+  and returns itself that same result.
+  If the result is `Err`,
+  it restores the position inside the input to the one saved before calling the closure.
+
+Examples:
+
+```{rust,ignore}
+// 'none' | <image>
+fn parse_background_image(context: &ParserContext, input: &mut Parser)
+                                    -> Result<Option<Image>, ()> {
+    if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() {
+        Ok(None)
+    } else {
+        Image::parse(context, input).map(Some)  // tail call
+    }
+}
+```
+
+```{rust,ignore}
+// [ <length> | <percentage> ] [ <length> | <percentage> ]?
+fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
+                          -> Result<(LengthOrPercentage, LengthOrPercentage), ()> {
+    let first = LengthOrPercentage::parse?;
+    let second = input.try_parse(LengthOrPercentage::parse).unwrap_or(first);
+    (first, second)
+}
+```
+
+*/
+
+#![recursion_limit = "200"] // For color::parse_color_keyword
+
+pub use crate::color::{
+    hsl_to_rgb, hwb_to_rgb, parse_color_keyword, parse_color_with, parse_hash_color, AngleOrNumber,
+    Color, ColorFunction, ColorParser, FromParsedColor, Hsl, Hwb, Lab, Lch, NumberOrPercentage,
+    Oklab, Oklch, PredefinedColorSpace, RGBA,
+};
+pub use crate::cow_rc_str::CowRcStr;
+pub use crate::from_bytes::{stylesheet_encoding, EncodingSupport};
+#[doc(hidden)]
+pub use crate::macros::{
+    _cssparser_internal_create_uninit_array, _cssparser_internal_to_lowercase,
+};
+pub use crate::nth::parse_nth;
+pub use crate::parser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind};
+pub use crate::parser::{Delimiter, Delimiters, Parser, ParserInput, ParserState};
+pub use crate::rules_and_declarations::{parse_important, parse_one_declaration};
+pub use crate::rules_and_declarations::{parse_one_rule, StyleSheetParser};
+pub use crate::rules_and_declarations::{AtRuleParser, QualifiedRuleParser};
+pub use crate::rules_and_declarations::{RuleBodyParser, RuleBodyItemParser, DeclarationParser};
+pub use crate::serializer::{serialize_identifier, serialize_name, serialize_string};
+pub use crate::serializer::{CssStringWriter, ToCss, TokenSerializationType};
+pub use crate::tokenizer::{SourceLocation, SourcePosition, Token};
+pub use crate::unicode_range::UnicodeRange;
+pub use cssparser_macros::*;
+#[doc(hidden)]
+pub use phf as _cssparser_internal_phf;
+
+#[macro_use]
+mod macros;
+
+mod rules_and_declarations;
+mod tokenizer;
+
+mod color;
+mod cow_rc_str;
+mod from_bytes;
+mod nth;
+mod parser;
+mod serializer;
+mod unicode_range;
+
+#[cfg(test)]
+mod size_of_tests;
+#[cfg(test)]
+mod tests;
diff --git a/third_party/rust/cssparser/src/macros.rs b/third_party/rust/cssparser/src/macros.rs
new file mode 100644
index 0000000000..981af01005
--- /dev/null
+++ b/third_party/rust/cssparser/src/macros.rs
@@ -0,0 +1,185 @@
+/* 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::mem::MaybeUninit;
+
+/// Expands to a `match` expression with string patterns,
+/// matching case-insensitively in the ASCII range.
+///
+/// The patterns must not contain ASCII upper case letters. (They must be already be lower-cased.)
+///
+/// # Example
+///
+/// ```rust
+/// # fn main() {}  // Make doctest not wrap everything in its own main
+/// # fn dummy(function_name: &String) { let _ =
+/// cssparser::match_ignore_ascii_case! { &function_name,
+///     "rgb" => parse_rgb(..),
+/// #   #[cfg(not(something))]
+///     "rgba" => parse_rgba(..),
+///     "hsl" => parse_hsl(..),
+///     "hsla" => parse_hsla(..),
+///     _ => Err(format!("unknown function: {}", function_name))
+/// }
+/// # ;}
+/// # use std::ops::RangeFull;
+/// # fn parse_rgb(_: RangeFull) -> Result<(), String> { Ok(()) }
+/// # fn parse_rgba(_: RangeFull) -> Result<(), String> { Ok(()) }
+/// # fn parse_hsl(_: RangeFull) -> Result<(), String> { Ok(()) }
+/// # fn parse_hsla(_: RangeFull) -> Result<(), String> { Ok(()) }
+/// ```
+#[macro_export]
+macro_rules! match_ignore_ascii_case {
+    ( $input:expr,
+        $(
+            $( #[$meta: meta] )*
+            $( $pattern: pat )|+ $( if $guard: expr )? => $then: expr
+        ),+
+        $(,)?
+    ) => {
+        {
+            // This dummy module works around the feature gate
+            // `error[E0658]: procedural macros cannot be expanded to statements`
+            // by forcing the macro to be in an item context
+            // rather than expression/statement context,
+            // even though the macro only expands to items.
+            mod cssparser_internal {
+                $crate::_cssparser_internal_max_len! {
+                    $( $( $pattern )+ )+
+                }
+            }
+            $crate::_cssparser_internal_to_lowercase!($input, cssparser_internal::MAX_LENGTH => lowercase);
+            // "A" is a short string that we know is different for every string pattern,
+            // since we’ve verified that none of them include ASCII upper case letters.
+            match lowercase.unwrap_or("A") {
+                $(
+                    $( #[$meta] )*
+                    $( $pattern )|+ $( if $guard )? => $then,
+                )+
+            }
+        }
+    };
+}
+
+/// Define a function `$name(&str) -> Option<&'static $ValueType>`
+///
+/// The function finds a match for the input string
+/// in a [`phf` map](https://github.com/sfackler/rust-phf)
+/// and returns a reference to the corresponding value.
+/// Matching is case-insensitive in the ASCII range.
+///
+/// ## Example:
+///
+/// ```rust
+/// # fn main() {}  // Make doctest not wrap everything in its own main
+///
+/// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> {
+///     cssparser::ascii_case_insensitive_phf_map! {
+///         keyword -> (u8, u8, u8) = {
+///             "red" => (255, 0, 0),
+///             "green" => (0, 255, 0),
+///             "blue" => (0, 0, 255),
+///         }
+///     }
+///     keyword(input).cloned()
+/// }
+#[macro_export]
+macro_rules! ascii_case_insensitive_phf_map {
+    ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr ),+ }) => {
+        ascii_case_insensitive_phf_map!($name -> $ValueType = { $( $key => $value, )+ })
+    };
+    ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr, )+ }) => {
+        pub fn $name(input: &str) -> Option<&'static $ValueType> {
+            // This dummy module works around a feature gate,
+            // see comment on the similar module in `match_ignore_ascii_case!` above.
+            mod _cssparser_internal {
+                $crate::_cssparser_internal_max_len! {
+                    $( $key )+
+                }
+            }
+            use $crate::_cssparser_internal_phf as phf;
+            static MAP: phf::Map<&'static str, $ValueType> = phf::phf_map! {
+                $(
+                    $key => $value,
+                )*
+            };
+            $crate::_cssparser_internal_to_lowercase!(input, _cssparser_internal::MAX_LENGTH => lowercase);
+            lowercase.and_then(|s| MAP.get(s))
+        }
+    }
+}
+
+/// Create a new array of MaybeUninit<T> items, in an uninitialized state.
+#[inline(always)]
+pub fn _cssparser_internal_create_uninit_array<const N: usize>() -> [MaybeUninit<u8>; N] {
+    unsafe {
+        // SAFETY: An uninitialized `[MaybeUninit<_>; LEN]` is valid.
+        // See: https://doc.rust-lang.org/stable/core/mem/union.MaybeUninit.html#method.uninit_array
+        MaybeUninit::<[MaybeUninit<u8>; N]>::uninit().assume_init()
+    }
+}
+
+/// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros.
+///
+/// **This macro is not part of the public API. It can change or be removed between any versions.**
+///
+/// Define a local variable named `$output`
+/// and assign it the result of calling `_cssparser_internal_to_lowercase`
+/// with a stack-allocated buffer of length `$BUFFER_SIZE`.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! _cssparser_internal_to_lowercase {
+    ($input: expr, $BUFFER_SIZE: expr => $output: ident) => {
+        let mut buffer = $crate::_cssparser_internal_create_uninit_array::<{ $BUFFER_SIZE }>();
+        let input: &str = $input;
+        let $output = $crate::_cssparser_internal_to_lowercase(&mut buffer, input);
+    };
+}
+
+/// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros.
+///
+/// **This function is not part of the public API. It can change or be removed between any versions.**
+///
+/// If `input` is larger than buffer, return `None`.
+/// Otherwise, return `input` ASCII-lowercased, using `buffer` as temporary space if necessary.
+#[doc(hidden)]
+#[allow(non_snake_case)]
+#[inline]
+pub fn _cssparser_internal_to_lowercase<'a>(
+    buffer: &'a mut [MaybeUninit<u8>],
+    input: &'a str,
+) -> Option<&'a str> {
+    let buffer = buffer.get_mut(..input.len())?;
+
+    #[cold]
+    fn make_ascii_lowercase<'a>(
+        buffer: &'a mut [MaybeUninit<u8>],
+        input: &'a str,
+        first_uppercase: usize,
+    ) -> &'a str {
+        // This cast doesn't change the pointer's validity
+        // since `u8` has the same layout as `MaybeUninit<u8>`:
+        let input_bytes =
+            unsafe { &*(input.as_bytes() as *const [u8] as *const [MaybeUninit<u8>]) };
+
+        buffer.copy_from_slice(&*input_bytes);
+
+        // Same as above re layout, plus these bytes have been initialized:
+        let buffer = unsafe { &mut *(buffer as *mut [MaybeUninit<u8>] as *mut [u8]) };
+
+        buffer[first_uppercase..].make_ascii_lowercase();
+        // `buffer` was initialized to a copy of `input`
+        // (which is `&str` so well-formed UTF-8)
+        // then ASCII-lowercased (which preserves UTF-8 well-formedness):
+        unsafe { ::std::str::from_utf8_unchecked(buffer) }
+    }
+
+    Some(
+        match input.bytes().position(|byte| matches!(byte, b'A'..=b'Z')) {
+            Some(first_uppercase) => make_ascii_lowercase(buffer, input, first_uppercase),
+            // common case: input is already lower-case
+            None => input,
+        },
+    )
+}
diff --git a/third_party/rust/cssparser/src/nth.rs b/third_party/rust/cssparser/src/nth.rs
new file mode 100644
index 0000000000..518de4d9b4
--- /dev/null
+++ b/third_party/rust/cssparser/src/nth.rs
@@ -0,0 +1,145 @@
+/* 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 super::{BasicParseError, Parser, ParserInput, Token};
+
+/// Parse the *An+B* notation, as found in the `:nth-child()` selector.
+/// 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<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(i32, i32), BasicParseError<'i>> {
+    match *input.next()? {
+        Token::Number {
+            int_value: Some(b), ..
+        } => Ok((0, b)),
+        Token::Dimension {
+            int_value: Some(a),
+            ref unit,
+            ..
+        } => {
+            match_ignore_ascii_case! {
+                unit,
+                "n" => Ok(parse_b(input, a)?),
+                "n-" => Ok(parse_signless_b(input, a, -1)?),
+                _ => match parse_n_dash_digits(&*unit) {
+                    Ok(b) => Ok((a, b)),
+                    Err(()) => {
+                        let unit = unit.clone();
+                        Err(input.new_basic_unexpected_token_error(Token::Ident(unit)))
+                    }
+                }
+            }
+        }
+        Token::Ident(ref value) => {
+            match_ignore_ascii_case! { value,
+                "even" => Ok((2, 0)),
+                "odd" => Ok((2, 1)),
+                "n" => Ok(parse_b(input, 1)?),
+                "-n" => Ok(parse_b(input, -1)?),
+                "n-" => Ok(parse_signless_b(input, 1, -1)?),
+                "-n-" => Ok(parse_signless_b(input, -1, -1)?),
+                _ => {
+                    let (slice, a) = if value.starts_with("-") {
+                        (&value[1..], -1)
+                    } else {
+                        (&**value, 1)
+                    };
+                    match parse_n_dash_digits(slice) {
+                        Ok(b) => Ok((a, b)),
+                        Err(()) => {
+                            let value = value.clone();
+                            Err(input.new_basic_unexpected_token_error(Token::Ident(value)))
+                        }
+                    }
+                }
+            }
+        }
+        Token::Delim('+') => match *input.next_including_whitespace()? {
+            Token::Ident(ref value) => {
+                match_ignore_ascii_case! { value,
+                    "n" => parse_b(input, 1),
+                    "n-" => parse_signless_b(input, 1, -1),
+                    _ => match parse_n_dash_digits(value) {
+                        Ok(b) => Ok((1, b)),
+                        Err(()) => {
+                            let value = value.clone();
+                            Err(input.new_basic_unexpected_token_error(Token::Ident(value)))
+                        }
+                    }
+                }
+            }
+            ref token => {
+                let token = token.clone();
+                Err(input.new_basic_unexpected_token_error(token))
+            }
+        },
+        ref token => {
+            let token = token.clone();
+            Err(input.new_basic_unexpected_token_error(token))
+        }
+    }
+}
+
+fn parse_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32) -> Result<(i32, i32), BasicParseError<'i>> {
+    let start = input.state();
+    match input.next() {
+        Ok(&Token::Delim('+')) => parse_signless_b(input, a, 1),
+        Ok(&Token::Delim('-')) => parse_signless_b(input, a, -1),
+        Ok(&Token::Number {
+            has_sign: true,
+            int_value: Some(b),
+            ..
+        }) => Ok((a, b)),
+        _ => {
+            input.reset(&start);
+            Ok((a, 0))
+        }
+    }
+}
+
+fn parse_signless_b<'i, 't>(
+    input: &mut Parser<'i, 't>,
+    a: i32,
+    b_sign: i32,
+) -> Result<(i32, i32), BasicParseError<'i>> {
+    // FIXME: remove .clone() when lifetimes are non-lexical.
+    match input.next()?.clone() {
+        Token::Number {
+            has_sign: false,
+            int_value: Some(b),
+            ..
+        } => Ok((a, b_sign * b)),
+        token => Err(input.new_basic_unexpected_token_error(token)),
+    }
+}
+
+fn parse_n_dash_digits(string: &str) -> Result<i32, ()> {
+    let bytes = string.as_bytes();
+    if bytes.len() >= 3
+        && bytes[..2].eq_ignore_ascii_case(b"n-")
+        && bytes[2..].iter().all(|&c| matches!(c, b'0'..=b'9'))
+    {
+        Ok(parse_number_saturate(&string[1..]).unwrap()) // Include the minus sign
+    } else {
+        Err(())
+    }
+}
+
+fn parse_number_saturate(string: &str) -> Result<i32, ()> {
+    let mut input = ParserInput::new(string);
+    let mut parser = Parser::new(&mut input);
+    let int = if let Ok(&Token::Number {
+        int_value: Some(int),
+        ..
+    }) = parser.next_including_whitespace_and_comments()
+    {
+        int
+    } else {
+        return Err(());
+    };
+    if !parser.is_exhausted() {
+        return Err(());
+    }
+    Ok(int)
+}
diff --git a/third_party/rust/cssparser/src/parser.rs b/third_party/rust/cssparser/src/parser.rs
new file mode 100644
index 0000000000..afc6281da6
--- /dev/null
+++ b/third_party/rust/cssparser/src/parser.rs
@@ -0,0 +1,1142 @@
+/* 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 crate::cow_rc_str::CowRcStr;
+use crate::tokenizer::{SourceLocation, SourcePosition, Token, Tokenizer};
+use smallvec::SmallVec;
+use std::fmt;
+use std::ops::BitOr;
+use std::ops::Range;
+
+/// A capture of the internal state of a `Parser` (including the position within the input),
+/// obtained from the `Parser::position` method.
+///
+/// Can be used with the `Parser::reset` method to restore that state.
+/// Should only be used with the `Parser` instance it came from.
+#[derive(Debug, Clone)]
+pub struct ParserState {
+    pub(crate) position: usize,
+    pub(crate) current_line_start_position: usize,
+    pub(crate) current_line_number: u32,
+    pub(crate) at_start_of: Option<BlockType>,
+}
+
+impl ParserState {
+    /// The position from the start of the input, counted in UTF-8 bytes.
+    #[inline]
+    pub fn position(&self) -> SourcePosition {
+        SourcePosition(self.position)
+    }
+
+    /// The line number and column number
+    #[inline]
+    pub fn source_location(&self) -> SourceLocation {
+        SourceLocation {
+            line: self.current_line_number,
+            column: (self.position - self.current_line_start_position + 1) as u32,
+        }
+    }
+}
+
+/// Details about a `BasicParseError`
+#[derive(Clone, Debug, PartialEq)]
+pub enum BasicParseErrorKind<'i> {
+    /// An unexpected token was encountered.
+    UnexpectedToken(Token<'i>),
+    /// The end of the input was encountered unexpectedly.
+    EndOfInput,
+    /// An `@` rule was encountered that was invalid.
+    AtRuleInvalid(CowRcStr<'i>),
+    /// The body of an '@' rule was invalid.
+    AtRuleBodyInvalid,
+    /// A qualified rule was encountered that was invalid.
+    QualifiedRuleInvalid,
+}
+
+impl<'i> fmt::Display for BasicParseErrorKind<'i> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BasicParseErrorKind::UnexpectedToken(token) => {
+                write!(f, "unexpected token: {:?}", token)
+            }
+            BasicParseErrorKind::EndOfInput => write!(f, "unexpected end of input"),
+            BasicParseErrorKind::AtRuleInvalid(rule) => {
+                write!(f, "invalid @ rule encountered: '@{}'", rule)
+            }
+            BasicParseErrorKind::AtRuleBodyInvalid => write!(f, "invalid @ rule body encountered"),
+            BasicParseErrorKind::QualifiedRuleInvalid => {
+                write!(f, "invalid qualified rule encountered")
+            }
+        }
+    }
+}
+
+/// The fundamental parsing errors that can be triggered by built-in parsing routines.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BasicParseError<'i> {
+    /// Details of this error
+    pub kind: BasicParseErrorKind<'i>,
+    /// Location where this error occurred
+    pub location: SourceLocation,
+}
+
+impl<'i, T> From<BasicParseError<'i>> for ParseError<'i, T> {
+    #[inline]
+    fn from(this: BasicParseError<'i>) -> ParseError<'i, T> {
+        ParseError {
+            kind: ParseErrorKind::Basic(this.kind),
+            location: this.location,
+        }
+    }
+}
+
+impl SourceLocation {
+    /// Create a new BasicParseError at this location for an unexpected token
+    #[inline]
+    pub fn new_basic_unexpected_token_error<'i>(self, token: Token<'i>) -> BasicParseError<'i> {
+        BasicParseError {
+            kind: BasicParseErrorKind::UnexpectedToken(token),
+            location: self,
+        }
+    }
+
+    /// Create a new ParseError at this location for an unexpected token
+    #[inline]
+    pub fn new_unexpected_token_error<'i, E>(self, token: Token<'i>) -> ParseError<'i, E> {
+        ParseError {
+            kind: ParseErrorKind::Basic(BasicParseErrorKind::UnexpectedToken(token)),
+            location: self,
+        }
+    }
+
+    /// Create a new custom ParseError at this location
+    #[inline]
+    pub fn new_custom_error<'i, E1: Into<E2>, E2>(self, error: E1) -> ParseError<'i, E2> {
+        ParseError {
+            kind: ParseErrorKind::Custom(error.into()),
+            location: self,
+        }
+    }
+}
+
+/// Details of a `ParseError`
+#[derive(Clone, Debug, PartialEq)]
+pub enum ParseErrorKind<'i, T: 'i> {
+    /// A fundamental parse error from a built-in parsing routine.
+    Basic(BasicParseErrorKind<'i>),
+    /// A parse error reported by downstream consumer code.
+    Custom(T),
+}
+
+impl<'i, T> ParseErrorKind<'i, T> {
+    /// Like `std::convert::Into::into`
+    pub fn into<U>(self) -> ParseErrorKind<'i, U>
+    where
+        T: Into<U>,
+    {
+        match self {
+            ParseErrorKind::Basic(basic) => ParseErrorKind::Basic(basic),
+            ParseErrorKind::Custom(custom) => ParseErrorKind::Custom(custom.into()),
+        }
+    }
+}
+
+impl<'i, E: fmt::Display> fmt::Display for ParseErrorKind<'i, E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ParseErrorKind::Basic(ref basic) => basic.fmt(f),
+            ParseErrorKind::Custom(ref custom) => custom.fmt(f),
+        }
+    }
+}
+
+/// Extensible parse errors that can be encountered by client parsing implementations.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParseError<'i, E> {
+    /// Details of this error
+    pub kind: ParseErrorKind<'i, E>,
+    /// Location where this error occurred
+    pub location: SourceLocation,
+}
+
+impl<'i, T> ParseError<'i, T> {
+    /// Extract the fundamental parse error from an extensible error.
+    pub fn basic(self) -> BasicParseError<'i> {
+        match self.kind {
+            ParseErrorKind::Basic(kind) => BasicParseError {
+                kind,
+                location: self.location,
+            },
+            ParseErrorKind::Custom(_) => panic!("Not a basic parse error"),
+        }
+    }
+
+    /// Like `std::convert::Into::into`
+    pub fn into<U>(self) -> ParseError<'i, U>
+    where
+        T: Into<U>,
+    {
+        ParseError {
+            kind: self.kind.into(),
+            location: self.location,
+        }
+    }
+}
+
+impl<'i, E: fmt::Display> fmt::Display for ParseError<'i, E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.kind.fmt(f)
+    }
+}
+
+impl<'i, E: fmt::Display + fmt::Debug> std::error::Error for ParseError<'i, E> {}
+
+/// The owned input for a parser.
+pub struct ParserInput<'i> {
+    tokenizer: Tokenizer<'i>,
+    cached_token: Option<CachedToken<'i>>,
+}
+
+struct CachedToken<'i> {
+    token: Token<'i>,
+    start_position: SourcePosition,
+    end_state: ParserState,
+}
+
+impl<'i> ParserInput<'i> {
+    /// Create a new input for a parser.
+    pub fn new(input: &'i str) -> ParserInput<'i> {
+        ParserInput {
+            tokenizer: Tokenizer::new(input),
+            cached_token: None,
+        }
+    }
+
+    /// Create a new input for a parser.  Line numbers in locations
+    /// are offset by the given value.
+    pub fn new_with_line_number_offset(input: &'i str, first_line_number: u32) -> ParserInput<'i> {
+        ParserInput {
+            tokenizer: Tokenizer::with_first_line_number(input, first_line_number),
+            cached_token: None,
+        }
+    }
+
+    #[inline]
+    fn cached_token_ref(&self) -> &Token<'i> {
+        &self.cached_token.as_ref().unwrap().token
+    }
+}
+
+/// A CSS parser that borrows its `&str` input,
+/// yields `Token`s,
+/// and keeps track of nested blocks and functions.
+pub struct Parser<'i, 't> {
+    input: &'t mut ParserInput<'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,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub(crate) enum BlockType {
+    Parenthesis,
+    SquareBracket,
+    CurlyBracket,
+}
+
+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,
+        }
+    }
+}
+
+/// A set of characters, to be used with the `Parser::parse_until*` methods.
+///
+/// The union of two sets can be obtained with the `|` operator. Example:
+///
+/// ```{rust,ignore}
+/// input.parse_until_before(Delimiter::CurlyBracketBlock | Delimiter::Semicolon)
+/// ```
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Delimiters {
+    bits: u8,
+}
+
+/// `Delimiters` constants.
+#[allow(non_upper_case_globals, non_snake_case)]
+pub mod Delimiter {
+    use super::Delimiters;
+
+    /// The empty delimiter set
+    pub const None: Delimiters = Delimiters { bits: 0 };
+    /// The delimiter set with only the `{` opening curly bracket
+    pub const CurlyBracketBlock: Delimiters = Delimiters { bits: 1 << 1 };
+    /// The delimiter set with only the `;` semicolon
+    pub const Semicolon: Delimiters = Delimiters { bits: 1 << 2 };
+    /// The delimiter set with only the `!` exclamation point
+    pub const Bang: Delimiters = Delimiters { bits: 1 << 3 };
+    /// The delimiter set with only the `,` comma
+    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> for Delimiters {
+    type Output = Delimiters;
+
+    #[inline]
+    fn bitor(self, other: Delimiters) -> Delimiters {
+        Delimiters {
+            bits: self.bits | other.bits,
+        }
+    }
+}
+
+impl Delimiters {
+    #[inline]
+    fn contains(self, other: Delimiters) -> bool {
+        (self.bits & other.bits) != 0
+    }
+
+    #[inline]
+    fn from_byte(byte: Option<u8>) -> Delimiters {
+        match byte {
+            Some(b';') => Delimiter::Semicolon,
+            Some(b'!') => Delimiter::Bang,
+            Some(b',') => Delimiter::Comma,
+            Some(b'{') => Delimiter::CurlyBracketBlock,
+            Some(b'}') => ClosingDelimiter::CloseCurlyBracket,
+            Some(b']') => ClosingDelimiter::CloseSquareBracket,
+            Some(b')') => ClosingDelimiter::CloseParenthesis,
+            _ => Delimiter::None,
+        }
+    }
+}
+
+/// Used in some `fn expect_*` methods
+macro_rules! expect {
+    ($parser: ident, $($branches: tt)+) => {
+        {
+            let start_location = $parser.current_source_location();
+            match *$parser.next()? {
+                $($branches)+
+                ref token => {
+                    return Err(start_location.new_basic_unexpected_token_error(token.clone()))
+                }
+            }
+        }
+    }
+}
+
+impl<'i: 't, 't> Parser<'i, 't> {
+    /// Create a new parser
+    #[inline]
+    pub fn new(input: &'t mut ParserInput<'i>) -> Parser<'i, 't> {
+        Parser {
+            input: input,
+            at_start_of: None,
+            stop_before: Delimiter::None,
+        }
+    }
+
+    /// Return the current line that is being parsed.
+    pub fn current_line(&self) -> &'i str {
+        self.input.tokenizer.current_source_line()
+    }
+
+    /// Check whether the input is exhausted. That is, if `.next()` would return a token.
+    ///
+    /// This ignores whitespace and comments.
+    #[inline]
+    pub fn is_exhausted(&mut self) -> bool {
+        self.expect_exhausted().is_ok()
+    }
+
+    /// Check whether the input is exhausted. That is, if `.next()` would return a token.
+    /// Return a `Result` so that the `?` operator can be used: `input.expect_exhausted()?`
+    ///
+    /// This ignores whitespace and comments.
+    #[inline]
+    pub fn expect_exhausted(&mut self) -> Result<(), BasicParseError<'i>> {
+        let start = self.state();
+        let result = match self.next() {
+            Err(BasicParseError {
+                kind: BasicParseErrorKind::EndOfInput,
+                ..
+            }) => Ok(()),
+            Err(e) => unreachable!("Unexpected error encountered: {:?}", e),
+            Ok(t) => Err(start
+                .source_location()
+                .new_basic_unexpected_token_error(t.clone())),
+        };
+        self.reset(&start);
+        result
+    }
+
+    /// Return the current position within the input.
+    ///
+    /// This can be used with the `Parser::slice` and `slice_from` methods.
+    #[inline]
+    pub fn position(&self) -> SourcePosition {
+        self.input.tokenizer.position()
+    }
+
+    /// The current line number and column number.
+    #[inline]
+    pub fn current_source_location(&self) -> SourceLocation {
+        self.input.tokenizer.current_source_location()
+    }
+
+    /// The source map URL, if known.
+    ///
+    /// The source map URL is extracted from a specially formatted
+    /// comment.  The last such comment is used, so this value may
+    /// change as parsing proceeds.
+    pub fn current_source_map_url(&self) -> Option<&str> {
+        self.input.tokenizer.current_source_map_url()
+    }
+
+    /// The source URL, if known.
+    ///
+    /// The source URL is extracted from a specially formatted
+    /// comment.  The last such comment is used, so this value may
+    /// change as parsing proceeds.
+    pub fn current_source_url(&self) -> Option<&str> {
+        self.input.tokenizer.current_source_url()
+    }
+
+    /// Create a new BasicParseError at the current location
+    #[inline]
+    pub fn new_basic_error(&self, kind: BasicParseErrorKind<'i>) -> BasicParseError<'i> {
+        BasicParseError {
+            kind,
+            location: self.current_source_location(),
+        }
+    }
+
+    /// Create a new basic ParseError at the current location
+    #[inline]
+    pub fn new_error<E>(&self, kind: BasicParseErrorKind<'i>) -> ParseError<'i, E> {
+        ParseError {
+            kind: ParseErrorKind::Basic(kind),
+            location: self.current_source_location(),
+        }
+    }
+
+    /// Create a new custom BasicParseError at the current location
+    #[inline]
+    pub fn new_custom_error<E1: Into<E2>, E2>(&self, error: E1) -> ParseError<'i, E2> {
+        self.current_source_location().new_custom_error(error)
+    }
+
+    /// Create a new unexpected token BasicParseError at the current location
+    #[inline]
+    pub fn new_basic_unexpected_token_error(&self, token: Token<'i>) -> BasicParseError<'i> {
+        self.new_basic_error(BasicParseErrorKind::UnexpectedToken(token))
+    }
+
+    /// Create a new unexpected token ParseError at the current location
+    #[inline]
+    pub fn new_unexpected_token_error<E>(&self, token: Token<'i>) -> ParseError<'i, E> {
+        self.new_error(BasicParseErrorKind::UnexpectedToken(token))
+    }
+
+    /// Create a new unexpected token or EOF ParseError at the current location
+    #[inline]
+    pub fn new_error_for_next_token<E>(&mut self) -> ParseError<'i, E> {
+        let token = match self.next() {
+            Ok(token) => token.clone(),
+            Err(e) => return e.into(),
+        };
+        self.new_error(BasicParseErrorKind::UnexpectedToken(token))
+    }
+
+    /// Return the current internal state of the parser (including position within the input).
+    ///
+    /// This state can later be restored with the `Parser::reset` method.
+    #[inline]
+    pub fn state(&self) -> ParserState {
+        ParserState {
+            at_start_of: self.at_start_of,
+            ..self.input.tokenizer.state()
+        }
+    }
+
+    /// Advance the input until the next token that’s not whitespace or a comment.
+    #[inline]
+    pub fn skip_whitespace(&mut self) {
+        if let Some(block_type) = self.at_start_of.take() {
+            consume_until_end_of_block(block_type, &mut self.input.tokenizer);
+        }
+
+        self.input.tokenizer.skip_whitespace()
+    }
+
+    #[inline]
+    pub(crate) fn skip_cdc_and_cdo(&mut self) {
+        if let Some(block_type) = self.at_start_of.take() {
+            consume_until_end_of_block(block_type, &mut self.input.tokenizer);
+        }
+
+        self.input.tokenizer.skip_cdc_and_cdo()
+    }
+
+    #[inline]
+    pub(crate) fn next_byte(&self) -> Option<u8> {
+        let byte = self.input.tokenizer.next_byte();
+        if self.stop_before.contains(Delimiters::from_byte(byte)) {
+            return None;
+        }
+        byte
+    }
+
+    /// Restore the internal state of the parser (including position within the input)
+    /// to what was previously saved by the `Parser::position` method.
+    ///
+    /// Should only be used with `SourcePosition` values from the same `Parser` instance.
+    #[inline]
+    pub fn reset(&mut self, state: &ParserState) {
+        self.input.tokenizer.reset(state);
+        self.at_start_of = state.at_start_of;
+    }
+
+    /// Start looking for `var()` / `env()` functions. (See the
+    /// `.seen_var_or_env_functions()` method.)
+    #[inline]
+    pub fn look_for_var_or_env_functions(&mut self) {
+        self.input.tokenizer.look_for_var_or_env_functions()
+    }
+
+    /// Return whether a `var()` or `env()` function has been seen by the
+    /// tokenizer since either `look_for_var_or_env_functions` was called, and
+    /// stop looking.
+    #[inline]
+    pub fn seen_var_or_env_functions(&mut self) -> bool {
+        self.input.tokenizer.seen_var_or_env_functions()
+    }
+
+    /// The old name of `try_parse`, which requires raw identifiers in the Rust 2018 edition.
+    #[inline]
+    pub fn r#try<F, T, E>(&mut self, thing: F) -> Result<T, E>
+    where
+        F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>,
+    {
+        self.try_parse(thing)
+    }
+
+    /// Execute the given closure, passing it the parser.
+    /// If the result (returned unchanged) is `Err`,
+    /// the internal state of the parser  (including position within the input)
+    /// is restored to what it was before the call.
+    #[inline]
+    pub fn try_parse<F, T, E>(&mut self, thing: F) -> Result<T, E>
+    where
+        F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>,
+    {
+        let start = self.state();
+        let result = thing(self);
+        if result.is_err() {
+            self.reset(&start)
+        }
+        result
+    }
+
+    /// Return a slice of the CSS input
+    #[inline]
+    pub fn slice(&self, range: Range<SourcePosition>) -> &'i str {
+        self.input.tokenizer.slice(range)
+    }
+
+    /// Return a slice of the CSS input, from the given position to the current one.
+    #[inline]
+    pub fn slice_from(&self, start_position: SourcePosition) -> &'i str {
+        self.input.tokenizer.slice_from(start_position)
+    }
+
+    /// Return the next token in the input that is neither whitespace or a comment,
+    /// and advance the position accordingly.
+    ///
+    /// After returning a `Function`, `ParenthesisBlock`,
+    /// `CurlyBracketBlock`, or `SquareBracketBlock` token,
+    /// the next call will skip until after the matching `CloseParenthesis`,
+    /// `CloseCurlyBracket`, or `CloseSquareBracket` token.
+    ///
+    /// See the `Parser::parse_nested_block` method to parse the content of functions or blocks.
+    ///
+    /// This only returns a closing token when it is unmatched (and therefore an error).
+    pub fn next(&mut self) -> Result<&Token<'i>, BasicParseError<'i>> {
+        self.skip_whitespace();
+        self.next_including_whitespace_and_comments()
+    }
+
+    /// Same as `Parser::next`, but does not skip whitespace tokens.
+    pub fn next_including_whitespace(&mut self) -> Result<&Token<'i>, BasicParseError<'i>> {
+        loop {
+            match self.next_including_whitespace_and_comments() {
+                Err(e) => return Err(e),
+                Ok(&Token::Comment(_)) => {}
+                _ => break,
+            }
+        }
+        Ok(self.input.cached_token_ref())
+    }
+
+    /// Same as `Parser::next`, but does not skip whitespace or comment tokens.
+    ///
+    /// **Note**: This should only be used in contexts like a CSS pre-processor
+    /// where comments are preserved.
+    /// When parsing higher-level values, per the CSS Syntax specification,
+    /// comments should always be ignored between tokens.
+    pub fn next_including_whitespace_and_comments(
+        &mut self,
+    ) -> Result<&Token<'i>, BasicParseError<'i>> {
+        if let Some(block_type) = self.at_start_of.take() {
+            consume_until_end_of_block(block_type, &mut self.input.tokenizer);
+        }
+
+        let byte = self.input.tokenizer.next_byte();
+        if self.stop_before.contains(Delimiters::from_byte(byte)) {
+            return Err(self.new_basic_error(BasicParseErrorKind::EndOfInput));
+        }
+
+        let token_start_position = self.input.tokenizer.position();
+        let using_cached_token = self
+            .input
+            .cached_token
+            .as_ref()
+            .map_or(false, |cached_token| {
+                cached_token.start_position == token_start_position
+            });
+        let token = if using_cached_token {
+            let cached_token = self.input.cached_token.as_ref().unwrap();
+            self.input.tokenizer.reset(&cached_token.end_state);
+            match cached_token.token {
+                Token::Function(ref name) => self.input.tokenizer.see_function(name),
+                _ => {}
+            }
+            &cached_token.token
+        } else {
+            let new_token = self
+                .input
+                .tokenizer
+                .next()
+                .map_err(|()| self.new_basic_error(BasicParseErrorKind::EndOfInput))?;
+            self.input.cached_token = Some(CachedToken {
+                token: new_token,
+                start_position: token_start_position,
+                end_state: self.input.tokenizer.state(),
+            });
+            self.input.cached_token_ref()
+        };
+
+        if let Some(block_type) = BlockType::opening(token) {
+            self.at_start_of = Some(block_type);
+        }
+        Ok(token)
+    }
+
+    /// Have the given closure parse something, then check the the input is exhausted.
+    /// The result is overridden to `Err(())` if some input remains.
+    ///
+    /// This can help tell e.g. `color: green;` from `color: green 4px;`
+    #[inline]
+    pub fn parse_entirely<F, T, E>(&mut self, parse: F) -> Result<T, ParseError<'i, E>>
+    where
+        F: FnOnce(&mut Parser<'i, 't>) -> Result<T, ParseError<'i, E>>,
+    {
+        let result = parse(self)?;
+        self.expect_exhausted()?;
+        Ok(result)
+    }
+
+    /// Parse a list of comma-separated values, all with the same syntax.
+    ///
+    /// The given closure is called repeatedly with a "delimited" parser
+    /// (see the `Parser::parse_until_before` method) so that it can over
+    /// consume the input past a comma at this block/function nesting level.
+    ///
+    /// Successful results are accumulated in a vector.
+    ///
+    /// This method returns `Err(())` the first time that a closure call does,
+    /// or if a closure call leaves some input before the next comma or the end
+    /// of the input.
+    #[inline]
+    pub fn parse_comma_separated<F, T, E>(
+        &mut self,
+        parse_one: F,
+    ) -> Result<Vec<T>, ParseError<'i, E>>
+    where
+        F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+    {
+        self.parse_comma_separated_internal(parse_one, /* ignore_errors = */ false)
+    }
+
+    /// Like `parse_comma_separated`, but ignores errors on unknown components,
+    /// rather than erroring out in the whole list.
+    ///
+    /// Caller must deal with the fact that the resulting list might be empty,
+    /// if there's no valid component on the list.
+    #[inline]
+    pub fn parse_comma_separated_ignoring_errors<F, T, E: 'i>(&mut self, parse_one: F) -> Vec<T>
+    where
+        F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+    {
+        match self.parse_comma_separated_internal(parse_one, /* ignore_errors = */ true) {
+            Ok(values) => values,
+            Err(..) => unreachable!(),
+        }
+    }
+
+    #[inline]
+    fn parse_comma_separated_internal<F, T, E>(
+        &mut self,
+        mut parse_one: F,
+        ignore_errors: bool,
+    ) -> Result<Vec<T>, ParseError<'i, E>>
+    where
+        F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+    {
+        // Vec grows from 0 to 4 by default on first push().  So allocate with
+        // capacity 1, so in the somewhat common case of only one item we don't
+        // way overallocate.  Note that we always push at least one item if
+        // parsing succeeds.
+        let mut values = Vec::with_capacity(1);
+        loop {
+            self.skip_whitespace(); // Unnecessary for correctness, but may help try() in parse_one rewind less.
+            match self.parse_until_before(Delimiter::Comma, &mut parse_one) {
+                Ok(v) => values.push(v),
+                Err(e) if !ignore_errors => return Err(e),
+                Err(_) => {},
+            }
+            match self.next() {
+                Err(_) => return Ok(values),
+                Ok(&Token::Comma) => continue,
+                Ok(_) => unreachable!(),
+            }
+        }
+    }
+
+    /// Parse the content of a block or function.
+    ///
+    /// This method panics if the last token yielded by this parser
+    /// (from one of the `next*` methods)
+    /// is not a on that marks the start of a block or function:
+    /// a `Function`, `ParenthesisBlock`, `CurlyBracketBlock`, or `SquareBracketBlock`.
+    ///
+    /// The given closure is called with a "delimited" parser
+    /// that stops at the end of the block or function (at the matching closing token).
+    ///
+    /// The result is overridden to `Err(())` if the closure leaves some input before that point.
+    #[inline]
+    pub fn parse_nested_block<F, T, E>(&mut self, parse: F) -> Result<T, ParseError<'i, E>>
+    where
+        F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+    {
+        parse_nested_block(self, parse)
+    }
+
+    /// Limit parsing to until a given delimiter or the end of the input. (E.g.
+    /// a semicolon for a property value.)
+    ///
+    /// The given closure is called with a "delimited" parser
+    /// that stops before the first character at this block/function nesting level
+    /// that matches the given set of delimiters, or at the end of the input.
+    ///
+    /// The result is overridden to `Err(())` if the closure leaves some input before that point.
+    #[inline]
+    pub fn parse_until_before<F, T, E>(
+        &mut self,
+        delimiters: Delimiters,
+        parse: F,
+    ) -> Result<T, ParseError<'i, E>>
+    where
+        F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+    {
+        parse_until_before(self, delimiters, parse)
+    }
+
+    /// Like `parse_until_before`, but also consume the delimiter token.
+    ///
+    /// This can be useful when you don’t need to know which delimiter it was
+    /// (e.g. if these is only one in the given set)
+    /// or if it was there at all (as opposed to reaching the end of the input).
+    #[inline]
+    pub fn parse_until_after<F, T, E>(
+        &mut self,
+        delimiters: Delimiters,
+        parse: F,
+    ) -> Result<T, ParseError<'i, E>>
+    where
+        F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+    {
+        parse_until_after(self, delimiters, parse)
+    }
+
+    /// Parse a <whitespace-token> and return its value.
+    #[inline]
+    pub fn expect_whitespace(&mut self) -> Result<&'i str, BasicParseError<'i>> {
+        let start_location = self.current_source_location();
+        match *self.next_including_whitespace()? {
+            Token::WhiteSpace(value) => Ok(value),
+            ref t => Err(start_location.new_basic_unexpected_token_error(t.clone())),
+        }
+    }
+
+    /// Parse a <ident-token> and return the unescaped value.
+    #[inline]
+    pub fn expect_ident(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> {
+        expect! {self,
+            Token::Ident(ref value) => Ok(value),
+        }
+    }
+
+    /// expect_ident, but clone the CowRcStr
+    #[inline]
+    pub fn expect_ident_cloned(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> {
+        self.expect_ident().map(|s| s.clone())
+    }
+
+    /// Parse a <ident-token> whose unescaped value is an ASCII-insensitive match for the given value.
+    #[inline]
+    pub fn expect_ident_matching(
+        &mut self,
+        expected_value: &str,
+    ) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::Ident(ref value) if value.eq_ignore_ascii_case(expected_value) => Ok(()),
+        }
+    }
+
+    /// Parse a <string-token> and return the unescaped value.
+    #[inline]
+    pub fn expect_string(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> {
+        expect! {self,
+            Token::QuotedString(ref value) => Ok(value),
+        }
+    }
+
+    /// expect_string, but clone the CowRcStr
+    #[inline]
+    pub fn expect_string_cloned(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> {
+        self.expect_string().map(|s| s.clone())
+    }
+
+    /// Parse either a <ident-token> or a <string-token>, and return the unescaped value.
+    #[inline]
+    pub fn expect_ident_or_string(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> {
+        expect! {self,
+            Token::Ident(ref value) => Ok(value),
+            Token::QuotedString(ref value) => Ok(value),
+        }
+    }
+
+    /// Parse a <url-token> and return the unescaped value.
+    #[inline]
+    pub fn expect_url(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> {
+        expect! {self,
+            Token::UnquotedUrl(ref value) => Ok(value.clone()),
+            Token::Function(ref name) if name.eq_ignore_ascii_case("url") => {
+                self.parse_nested_block(|input| {
+                    input.expect_string().map_err(Into::into).map(|s| s.clone())
+                })
+                .map_err(ParseError::<()>::basic)
+            }
+        }
+    }
+
+    /// Parse either a <url-token> or a <string-token>, and return the unescaped value.
+    #[inline]
+    pub fn expect_url_or_string(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> {
+        expect! {self,
+            Token::UnquotedUrl(ref value) => Ok(value.clone()),
+            Token::QuotedString(ref value) => Ok(value.clone()),
+            Token::Function(ref name) if name.eq_ignore_ascii_case("url") => {
+                self.parse_nested_block(|input| {
+                    input.expect_string().map_err(Into::into).map(|s| s.clone())
+                })
+                .map_err(ParseError::<()>::basic)
+            }
+        }
+    }
+
+    /// Parse a <number-token> and return the integer value.
+    #[inline]
+    pub fn expect_number(&mut self) -> Result<f32, BasicParseError<'i>> {
+        expect! {self,
+            Token::Number { value, .. } => Ok(value),
+        }
+    }
+
+    /// Parse a <number-token> that does not have a fractional part, and return the integer value.
+    #[inline]
+    pub fn expect_integer(&mut self) -> Result<i32, BasicParseError<'i>> {
+        expect! {self,
+            Token::Number { int_value: Some(int_value), .. } => Ok(int_value),
+        }
+    }
+
+    /// Parse a <percentage-token> and return the value.
+    /// `0%` and `100%` map to `0.0` and `1.0` (not `100.0`), respectively.
+    #[inline]
+    pub fn expect_percentage(&mut self) -> Result<f32, BasicParseError<'i>> {
+        expect! {self,
+            Token::Percentage { unit_value, .. } => Ok(unit_value),
+        }
+    }
+
+    /// Parse a `:` <colon-token>.
+    #[inline]
+    pub fn expect_colon(&mut self) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::Colon => Ok(()),
+        }
+    }
+
+    /// Parse a `;` <semicolon-token>.
+    #[inline]
+    pub fn expect_semicolon(&mut self) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::Semicolon => Ok(()),
+        }
+    }
+
+    /// Parse a `,` <comma-token>.
+    #[inline]
+    pub fn expect_comma(&mut self) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::Comma => Ok(()),
+        }
+    }
+
+    /// Parse a <delim-token> with the given value.
+    #[inline]
+    pub fn expect_delim(&mut self, expected_value: char) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::Delim(value) if value == expected_value => Ok(()),
+        }
+    }
+
+    /// Parse a `{ /* ... */ }` curly brackets block.
+    ///
+    /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method.
+    #[inline]
+    pub fn expect_curly_bracket_block(&mut self) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::CurlyBracketBlock => Ok(()),
+        }
+    }
+
+    /// Parse a `[ /* ... */ ]` square brackets block.
+    ///
+    /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method.
+    #[inline]
+    pub fn expect_square_bracket_block(&mut self) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::SquareBracketBlock => Ok(()),
+        }
+    }
+
+    /// Parse a `( /* ... */ )` parenthesis block.
+    ///
+    /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method.
+    #[inline]
+    pub fn expect_parenthesis_block(&mut self) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::ParenthesisBlock => Ok(()),
+        }
+    }
+
+    /// Parse a <function> token and return its name.
+    ///
+    /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method.
+    #[inline]
+    pub fn expect_function(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> {
+        expect! {self,
+            Token::Function(ref name) => Ok(name),
+        }
+    }
+
+    /// Parse a <function> token whose name is an ASCII-insensitive match for the given value.
+    ///
+    /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method.
+    #[inline]
+    pub fn expect_function_matching(
+        &mut self,
+        expected_name: &str,
+    ) -> Result<(), BasicParseError<'i>> {
+        expect! {self,
+            Token::Function(ref name) if name.eq_ignore_ascii_case(expected_name) => Ok(()),
+        }
+    }
+
+    /// Parse the input until exhaustion and check that it contains no “error” token.
+    ///
+    /// See `Token::is_parse_error`. This also checks nested blocks and functions recursively.
+    #[inline]
+    pub fn expect_no_error_token(&mut self) -> Result<(), BasicParseError<'i>> {
+        loop {
+            match self.next_including_whitespace_and_comments() {
+                Ok(&Token::Function(_))
+                | Ok(&Token::ParenthesisBlock)
+                | Ok(&Token::SquareBracketBlock)
+                | Ok(&Token::CurlyBracketBlock) => self
+                    .parse_nested_block(|input| input.expect_no_error_token().map_err(Into::into))
+                    .map_err(ParseError::<()>::basic)?,
+                Ok(t) => {
+                    // FIXME: maybe these should be separate variants of
+                    // BasicParseError instead?
+                    if t.is_parse_error() {
+                        let token = t.clone();
+                        return Err(self.new_basic_unexpected_token_error(token));
+                    }
+                }
+                Err(_) => return Ok(()),
+            }
+        }
+    }
+}
+
+pub fn parse_until_before<'i: 't, 't, F, T, E>(
+    parser: &mut Parser<'i, 't>,
+    delimiters: Delimiters,
+    parse: F,
+) -> Result<T, ParseError<'i, E>>
+where
+    F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+{
+    let delimiters = parser.stop_before | delimiters;
+    let result;
+    // Introduce a new scope to limit duration of nested_parser’s borrow
+    {
+        let mut delimited_parser = Parser {
+            input: parser.input,
+            at_start_of: parser.at_start_of.take(),
+            stop_before: delimiters,
+        };
+        result = delimited_parser.parse_entirely(parse);
+        if let Some(block_type) = delimited_parser.at_start_of {
+            consume_until_end_of_block(block_type, &mut delimited_parser.input.tokenizer);
+        }
+    }
+    // FIXME: have a special-purpose tokenizer method for this that does less work.
+    loop {
+        if delimiters.contains(Delimiters::from_byte(parser.input.tokenizer.next_byte())) {
+            break;
+        }
+        if let Ok(token) = parser.input.tokenizer.next() {
+            if let Some(block_type) = BlockType::opening(&token) {
+                consume_until_end_of_block(block_type, &mut parser.input.tokenizer);
+            }
+        } else {
+            break;
+        }
+    }
+    result
+}
+
+pub fn parse_until_after<'i: 't, 't, F, T, E>(
+    parser: &mut Parser<'i, 't>,
+    delimiters: Delimiters,
+    parse: F,
+) -> Result<T, ParseError<'i, E>>
+where
+    F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+{
+    let result = parser.parse_until_before(delimiters, parse);
+    let next_byte = parser.input.tokenizer.next_byte();
+    if next_byte.is_some()
+        && !parser
+            .stop_before
+            .contains(Delimiters::from_byte(next_byte))
+    {
+        debug_assert!(delimiters.contains(Delimiters::from_byte(next_byte)));
+        // We know this byte is ASCII.
+        parser.input.tokenizer.advance(1);
+        if next_byte == Some(b'{') {
+            consume_until_end_of_block(BlockType::CurlyBracket, &mut parser.input.tokenizer);
+        }
+    }
+    result
+}
+
+pub fn parse_nested_block<'i: 't, 't, F, T, E>(
+    parser: &mut Parser<'i, 't>,
+    parse: F,
+) -> Result<T, ParseError<'i, E>>
+where
+    F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>,
+{
+    let block_type = parser.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 {
+            input: parser.input,
+            at_start_of: None,
+            stop_before: closing_delimiter,
+        };
+        result = nested_parser.parse_entirely(parse);
+        if let Some(block_type) = nested_parser.at_start_of {
+            consume_until_end_of_block(block_type, &mut nested_parser.input.tokenizer);
+        }
+    }
+    consume_until_end_of_block(block_type, &mut parser.input.tokenizer);
+    result
+}
+
+#[inline(never)]
+#[cold]
+fn consume_until_end_of_block(block_type: BlockType, tokenizer: &mut Tokenizer) {
+    let mut stack = SmallVec::<[BlockType; 16]>::new();
+    stack.push(block_type);
+
+    // FIXME: have a special-purpose tokenizer method for this that does less work.
+    while let Ok(ref token) = tokenizer.next() {
+        if let Some(b) = BlockType::closing(token) {
+            if *stack.last().unwrap() == b {
+                stack.pop();
+                if stack.is_empty() {
+                    return;
+                }
+            }
+        }
+
+        if let Some(block_type) = BlockType::opening(token) {
+            stack.push(block_type);
+        }
+    }
+}
diff --git a/third_party/rust/cssparser/src/rules_and_declarations.rs b/third_party/rust/cssparser/src/rules_and_declarations.rs
new file mode 100644
index 0000000000..34ba8e985d
--- /dev/null
+++ b/third_party/rust/cssparser/src/rules_and_declarations.rs
@@ -0,0 +1,496 @@
+/* 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/. */
+
+// https://drafts.csswg.org/css-syntax/#parsing
+
+use super::{
+    BasicParseError, BasicParseErrorKind, Delimiter, Delimiters, ParseError, Parser, Token,
+};
+use crate::cow_rc_str::CowRcStr;
+use crate::parser::{parse_nested_block, parse_until_after, parse_until_before, ParserState};
+
+/// Parse `!important`.
+///
+/// Typical usage is `input.try_parse(parse_important).is_ok()`
+/// at the end of a `DeclarationParser::parse_value` implementation.
+pub fn parse_important<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(), BasicParseError<'i>> {
+    input.expect_delim('!')?;
+    input.expect_ident_matching("important")
+}
+
+/// A trait to provide various parsing of declaration values.
+///
+/// For example, there could be different implementations for property declarations in style rules
+/// and for descriptors in `@font-face` rules.
+pub trait DeclarationParser<'i> {
+    /// The finished representation of a declaration.
+    type Declaration;
+
+    /// The error type that is included in the ParseError value that can be returned.
+    type Error: 'i;
+
+    /// Parse the value of a declaration with the given `name`.
+    ///
+    /// Return the finished representation for the declaration
+    /// as returned by `DeclarationListParser::next`,
+    /// or `Err(())` to ignore the entire declaration as invalid.
+    ///
+    /// Declaration name matching should be case-insensitive in the ASCII range.
+    /// This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`,
+    /// or with the `match_ignore_ascii_case!` macro.
+    ///
+    /// The given `input` is a "delimited" parser
+    /// that ends wherever the declaration value should end.
+    /// (In declaration lists, before the next semicolon or end of the current block.)
+    ///
+    /// If `!important` can be used in a given context,
+    /// `input.try_parse(parse_important).is_ok()` should be used at the end
+    /// of the implementation of this method and the result should be part of the return value.
+    fn parse_value<'t>(
+        &mut self,
+        name: CowRcStr<'i>,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self::Declaration, ParseError<'i, Self::Error>> {
+        Err(input.new_error(BasicParseErrorKind::UnexpectedToken(Token::Ident(name))))
+    }
+}
+
+/// A trait to provide various parsing of at-rules.
+///
+/// For example, there could be different implementations for top-level at-rules
+/// (`@media`, `@font-face`, …)
+/// and for page-margin rules inside `@page`.
+///
+/// Default implementations that reject all at-rules are provided,
+/// so that `impl AtRuleParser<(), ()> for ... {}` can be used
+/// for using `DeclarationListParser` to parse a declarations list with only qualified rules.
+pub trait AtRuleParser<'i> {
+    /// The intermediate representation of prelude of an at-rule.
+    type Prelude;
+
+    /// The finished representation of an at-rule.
+    type AtRule;
+
+    /// The error type that is included in the ParseError value that can be returned.
+    type Error: 'i;
+
+    /// Parse the prelude of an at-rule with the given `name`.
+    ///
+    /// Return the representation of the prelude and the type of at-rule,
+    /// or `Err(())` to ignore the entire at-rule as invalid.
+    ///
+    /// The prelude is the part after the at-keyword
+    /// and before the `;` semicolon or `{ /* ... */ }` block.
+    ///
+    /// At-rule name matching should be case-insensitive in the ASCII range.
+    /// This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`,
+    /// or with the `match_ignore_ascii_case!` macro.
+    ///
+    /// The given `input` is a "delimited" parser
+    /// that ends wherever the prelude should end.
+    /// (Before the next semicolon, the next `{`, or the end of the current block.)
+    fn parse_prelude<'t>(
+        &mut self,
+        name: CowRcStr<'i>,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
+        Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name)))
+    }
+
+    /// End an at-rule which doesn't have block. Return the finished
+    /// representation of the at-rule.
+    ///
+    /// The location passed in is source location of the start of the prelude.
+    ///
+    /// This is only called when `parse_prelude` returned `WithoutBlock`, and
+    /// either the `;` semicolon indeed follows the prelude, or parser is at
+    /// the end of the input.
+    fn rule_without_block(
+        &mut self,
+        prelude: Self::Prelude,
+        start: &ParserState,
+    ) -> Result<Self::AtRule, ()> {
+        let _ = prelude;
+        let _ = start;
+        Err(())
+    }
+
+    /// Parse the content of a `{ /* ... */ }` block for the body of the at-rule.
+    ///
+    /// The location passed in is source location of the start of the prelude.
+    ///
+    /// Return the finished representation of the at-rule
+    /// as returned by `RuleListParser::next` or `DeclarationListParser::next`,
+    /// or `Err(())` to ignore the entire at-rule as invalid.
+    ///
+    /// This is only called when `parse_prelude` returned `WithBlock`, and a block
+    /// was indeed found following the prelude.
+    fn parse_block<'t>(
+        &mut self,
+        prelude: Self::Prelude,
+        start: &ParserState,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> {
+        let _ = prelude;
+        let _ = start;
+        Err(input.new_error(BasicParseErrorKind::AtRuleBodyInvalid))
+    }
+}
+
+/// A trait to provide various parsing of qualified rules.
+///
+/// For example, there could be different implementations for top-level qualified rules (i.e. style
+/// rules with Selectors as prelude) and for qualified rules inside `@keyframes` (keyframe rules
+/// with keyframe selectors as prelude).
+///
+/// Default implementations that reject all qualified rules are provided, so that
+/// `impl QualifiedRuleParser<(), ()> for ... {}` can be used for example for using
+/// `RuleListParser` to parse a rule list with only at-rules (such as inside
+/// `@font-feature-values`).
+pub trait QualifiedRuleParser<'i> {
+    /// The intermediate representation of a qualified rule prelude.
+    type Prelude;
+
+    /// The finished representation of a qualified rule.
+    type QualifiedRule;
+
+    /// The error type that is included in the ParseError value that can be returned.
+    type Error: 'i;
+
+    /// Parse the prelude of a qualified rule. For style rules, this is as Selector list.
+    ///
+    /// Return the representation of the prelude,
+    /// or `Err(())` to ignore the entire at-rule as invalid.
+    ///
+    /// The prelude is the part before the `{ /* ... */ }` block.
+    ///
+    /// The given `input` is a "delimited" parser
+    /// that ends where the prelude should end (before the next `{`).
+    fn parse_prelude<'t>(
+        &mut self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
+        Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid))
+    }
+
+    /// Parse the content of a `{ /* ... */ }` block for the body of the qualified rule.
+    ///
+    /// The location passed in is source location of the start of the prelude.
+    ///
+    /// Return the finished representation of the qualified rule
+    /// as returned by `RuleListParser::next`,
+    /// or `Err(())` to ignore the entire at-rule as invalid.
+    fn parse_block<'t>(
+        &mut self,
+        prelude: Self::Prelude,
+        start: &ParserState,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self::QualifiedRule, ParseError<'i, Self::Error>> {
+        let _ = prelude;
+        let _ = start;
+        Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid))
+    }
+}
+
+/// Provides an iterator for rule bodies and declaration lists.
+pub struct RuleBodyParser<'i, 't, 'a, P, I, E> {
+    /// The input given to the parser.
+    pub input: &'a mut Parser<'i, 't>,
+    /// The parser given to `DeclarationListParser::new`
+    pub parser: &'a mut P,
+
+    _phantom: std::marker::PhantomData<(I, E)>,
+}
+
+/// A parser for a rule body item.
+pub trait RuleBodyItemParser<'i, DeclOrRule, Error: 'i>:
+    DeclarationParser<'i, Declaration = DeclOrRule, Error = Error>
+    + QualifiedRuleParser<'i, QualifiedRule = DeclOrRule, Error = Error>
+    + AtRuleParser<'i, AtRule = DeclOrRule, Error = Error>
+{
+    /// Whether we should attempt to parse declarations. If you know you won't, returning false
+    /// here is slightly faster.
+    fn parse_declarations(&self) -> bool;
+    /// Whether we should attempt to parse qualified rules. If you know you won't, returning false
+    /// would be slightly faster.
+    fn parse_qualified(&self) -> bool;
+}
+
+impl<'i, 't, 'a, P, I, E> RuleBodyParser<'i, 't, 'a, P, I, E> {
+    /// Create a new `DeclarationListParser` for the given `input` and `parser`.
+    ///
+    /// Note that all CSS declaration lists can on principle contain at-rules.
+    /// Even if no such valid at-rule exists (yet),
+    /// this affects error handling: at-rules end at `{}` blocks, not just semicolons.
+    ///
+    /// The given `parser` therefore needs to implement
+    /// both `DeclarationParser` and `AtRuleParser` traits.
+    /// However, the latter can be an empty `impl`
+    /// since `AtRuleParser` provides default implementations of its methods.
+    ///
+    /// The return type for finished declarations and at-rules also needs to be the same,
+    /// since `<DeclarationListParser as Iterator>::next` can return either.
+    /// It could be a custom enum.
+    pub fn new(input: &'a mut Parser<'i, 't>, parser: &'a mut P) -> Self {
+        Self {
+            input,
+            parser,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+/// https://drafts.csswg.org/css-syntax/#consume-a-blocks-contents
+impl<'i, 't, 'a, I, P, E: 'i> Iterator for RuleBodyParser<'i, 't, 'a, P, I, E>
+where
+    P: RuleBodyItemParser<'i, I, E>,
+{
+    type Item = Result<I, (ParseError<'i, E>, &'i str)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            self.input.skip_whitespace();
+            let start = self.input.state();
+            match self.input.next_including_whitespace_and_comments().ok()? {
+                Token::CloseCurlyBracket |
+                Token::WhiteSpace(..) |
+                Token::Semicolon |
+                Token::Comment(..) => continue,
+                Token::AtKeyword(ref name) => {
+                    let name = name.clone();
+                    return Some(parse_at_rule(&start, name, self.input, &mut *self.parser));
+                }
+                // https://drafts.csswg.org/css-syntax/#consume-a-declaration bails out just to
+                // keep parsing as a qualified rule if the token is not an ident, so we implement
+                // that in a slightly more straight-forward way
+                Token::Ident(ref name) if self.parser.parse_declarations() => {
+                    let name = name.clone();
+                    let result = {
+                        let parser = &mut self.parser;
+                        parse_until_after(self.input, Delimiter::Semicolon, |input| {
+                            input.expect_colon()?;
+                            parser.parse_value(name, input)
+                        })
+                    };
+                    if result.is_err() && self.parser.parse_qualified() {
+                        self.input.reset(&start);
+                        // We ignore the resulting error here. The property declaration parse error
+                        // is likely to be more relevant.
+                        if let Ok(qual) = parse_qualified_rule(
+                            &start,
+                            self.input,
+                            &mut *self.parser,
+                            Delimiter::Semicolon | Delimiter::CurlyBracketBlock,
+                        ) {
+                            return Some(Ok(qual))
+                        }
+                    }
+
+                    return Some(result.map_err(|e| (e, self.input.slice_from(start.position()))));
+                }
+                token => {
+                    let result = if self.parser.parse_qualified() {
+                        self.input.reset(&start);
+                        let delimiters = if self.parser.parse_declarations() {
+                            Delimiter::Semicolon | Delimiter::CurlyBracketBlock
+                        } else {
+                            Delimiter::CurlyBracketBlock
+                        };
+                        parse_qualified_rule(&start, self.input, &mut *self.parser, delimiters)
+                    } else {
+                        let token = token.clone();
+                        self.input.parse_until_after(Delimiter::Semicolon, |_| {
+                            Err(start.source_location().new_unexpected_token_error(token))
+                        })
+                    };
+                    return Some(result.map_err(|e| (e, self.input.slice_from(start.position()))));
+                }
+            }
+        }
+    }
+}
+
+/// Provides an iterator for rule list parsing at the top-level of a stylesheet.
+pub struct StyleSheetParser<'i, 't, 'a, P> {
+    /// The input given.
+    pub input: &'a mut Parser<'i, 't>,
+
+    /// The parser given.
+    pub parser: &'a mut P,
+
+    any_rule_so_far: bool,
+}
+
+impl<'i, 't, 'a, R, P, E: 'i> StyleSheetParser<'i, 't, 'a, P>
+where
+    P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>
+        + AtRuleParser<'i, AtRule = R, Error = E>,
+{
+    /// The given `parser` needs to implement both `QualifiedRuleParser` and `AtRuleParser` traits.
+    /// However, either of them can be an empty `impl` since the traits provide default
+    /// implementations of their methods.
+    ///
+    /// The return type for finished qualified rules and at-rules also needs to be the same,
+    /// since `<RuleListParser as Iterator>::next` can return either. It could be a custom enum.
+    pub fn new(input: &'a mut Parser<'i, 't>, parser: &'a mut P) -> Self {
+        Self {
+            input,
+            parser,
+            any_rule_so_far: false,
+        }
+    }
+}
+
+/// `RuleListParser` is an iterator that yields `Ok(_)` for a rule or `Err(())` for an invalid one.
+impl<'i, 't, 'a, R, P, E: 'i> Iterator for StyleSheetParser<'i, 't, 'a, P>
+where
+    P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>
+        + AtRuleParser<'i, AtRule = R, Error = E>,
+{
+    type Item = Result<R, (ParseError<'i, E>, &'i str)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            self.input.skip_cdc_and_cdo();
+            let start = self.input.state();
+            let at_keyword = match self.input.next_byte()? {
+                b'@' => match self.input.next_including_whitespace_and_comments() {
+                    Ok(&Token::AtKeyword(ref name)) => Some(name.clone()),
+                    _ => {
+                        self.input.reset(&start);
+                        None
+                    }
+                },
+                _ => None,
+            };
+
+            if let Some(name) = at_keyword {
+                let first_stylesheet_rule = !self.any_rule_so_far;
+                self.any_rule_so_far = true;
+                if first_stylesheet_rule && name.eq_ignore_ascii_case("charset") {
+                    let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock;
+                    let _: Result<(), ParseError<()>> =
+                        self.input.parse_until_after(delimiters, |_| Ok(()));
+                } else {
+                    return Some(parse_at_rule(
+                        &start,
+                        name.clone(),
+                        self.input,
+                        &mut *self.parser,
+                    ));
+                }
+            } else {
+                self.any_rule_so_far = true;
+                let result = parse_qualified_rule(
+                    &start,
+                    self.input,
+                    &mut *self.parser,
+                    Delimiter::CurlyBracketBlock,
+                );
+                return Some(result.map_err(|e| (e, self.input.slice_from(start.position()))));
+            }
+        }
+    }
+}
+
+/// Parse a single declaration, such as an `( /* ... */ )` parenthesis in an `@supports` prelude.
+pub fn parse_one_declaration<'i, 't, P, E>(
+    input: &mut Parser<'i, 't>,
+    parser: &mut P,
+) -> Result<<P as DeclarationParser<'i>>::Declaration, (ParseError<'i, E>, &'i str)>
+where
+    P: DeclarationParser<'i, Error = E>,
+{
+    let start_position = input.position();
+    input
+        .parse_entirely(|input| {
+            let name = input.expect_ident()?.clone();
+            input.expect_colon()?;
+            parser.parse_value(name, input)
+        })
+        .map_err(|e| (e, input.slice_from(start_position)))
+}
+
+/// Parse a single rule, such as for CSSOM’s `CSSStyleSheet.insertRule`.
+pub fn parse_one_rule<'i, 't, R, P, E>(
+    input: &mut Parser<'i, 't>,
+    parser: &mut P,
+) -> Result<R, ParseError<'i, E>>
+where
+    P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>
+        + AtRuleParser<'i, AtRule = R, Error = E>,
+{
+    input.parse_entirely(|input| {
+        input.skip_whitespace();
+        let start = input.state();
+        let at_keyword = if input.next_byte() == Some(b'@') {
+            match *input.next_including_whitespace_and_comments()? {
+                Token::AtKeyword(ref name) => Some(name.clone()),
+                _ => {
+                    input.reset(&start);
+                    None
+                }
+            }
+        } else {
+            None
+        };
+
+        if let Some(name) = at_keyword {
+            parse_at_rule(&start, name, input, parser).map_err(|e| e.0)
+        } else {
+            parse_qualified_rule(&start, input, parser, Delimiter::CurlyBracketBlock)
+        }
+    })
+}
+
+fn parse_at_rule<'i, 't, P, E>(
+    start: &ParserState,
+    name: CowRcStr<'i>,
+    input: &mut Parser<'i, 't>,
+    parser: &mut P,
+) -> Result<<P as AtRuleParser<'i>>::AtRule, (ParseError<'i, E>, &'i str)>
+where
+    P: AtRuleParser<'i, Error = E>,
+{
+    let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock;
+    let result = parse_until_before(input, delimiters, |input| parser.parse_prelude(name, input));
+    match result {
+        Ok(prelude) => {
+            let result = match input.next() {
+                Ok(&Token::Semicolon) | Err(_) => parser
+                    .rule_without_block(prelude, start)
+                    .map_err(|()| input.new_unexpected_token_error(Token::Semicolon)),
+                Ok(&Token::CurlyBracketBlock) => {
+                    parse_nested_block(input, |input| parser.parse_block(prelude, start, input))
+                }
+                Ok(_) => unreachable!(),
+            };
+            result.map_err(|e| (e, input.slice_from(start.position())))
+        }
+        Err(error) => {
+            let end_position = input.position();
+            match input.next() {
+                Ok(&Token::CurlyBracketBlock) | Ok(&Token::Semicolon) | Err(_) => {}
+                _ => unreachable!(),
+            };
+            Err((error, input.slice(start.position()..end_position)))
+        }
+    }
+}
+
+fn parse_qualified_rule<'i, 't, P, E>(
+    start: &ParserState,
+    input: &mut Parser<'i, 't>,
+    parser: &mut P,
+    delimiters: Delimiters,
+) -> Result<<P as QualifiedRuleParser<'i>>::QualifiedRule, ParseError<'i, E>>
+where
+    P: QualifiedRuleParser<'i, Error = E>,
+{
+    let prelude = parse_until_before(input, delimiters, |input| parser.parse_prelude(input));
+    input.expect_curly_bracket_block()?;
+    // Do this here so that we consume the `{` even if the prelude is `Err`.
+    let prelude = prelude?;
+    parse_nested_block(input, |input| parser.parse_block(prelude, &start, input))
+}
diff --git a/third_party/rust/cssparser/src/serializer.rs b/third_party/rust/cssparser/src/serializer.rs
new file mode 100644
index 0000000000..ec970d176a
--- /dev/null
+++ b/third_party/rust/cssparser/src/serializer.rs
@@ -0,0 +1,526 @@
+/* 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 dtoa_short::{self, Notation};
+use itoa;
+use std::fmt::{self, Write};
+use std::str;
+
+use super::Token;
+
+/// Trait for things the can serialize themselves in CSS syntax.
+pub trait ToCss {
+    /// Serialize `self` in CSS syntax, writing to `dest`.
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write;
+
+    /// Serialize `self` in CSS syntax and return a string.
+    ///
+    /// (This is a convenience wrapper for `to_css` and probably should not be overridden.)
+    #[inline]
+    fn to_css_string(&self) -> String {
+        let mut s = String::new();
+        self.to_css(&mut s).unwrap();
+        s
+    }
+}
+
+#[inline]
+fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    // `value.value >= 0` is true for negative 0.
+    if has_sign && value.is_sign_positive() {
+        dest.write_str("+")?;
+    }
+
+    let notation = if value == 0.0 && value.is_sign_negative() {
+        // Negative zero. Work around #20596.
+        dest.write_str("-0")?;
+        Notation {
+            decimal_point: false,
+            scientific: false,
+        }
+    } else {
+        dtoa_short::write(dest, value)?
+    };
+
+    if int_value.is_none() && value.fract() == 0. {
+        if !notation.decimal_point && !notation.scientific {
+            dest.write_str(".0")?;
+        }
+    }
+    Ok(())
+}
+
+impl<'a> ToCss for Token<'a> {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        match *self {
+            Token::Ident(ref value) => serialize_identifier(&**value, dest)?,
+            Token::AtKeyword(ref value) => {
+                dest.write_str("@")?;
+                serialize_identifier(&**value, dest)?;
+            }
+            Token::Hash(ref value) => {
+                dest.write_str("#")?;
+                serialize_name(value, dest)?;
+            }
+            Token::IDHash(ref value) => {
+                dest.write_str("#")?;
+                serialize_identifier(&**value, dest)?;
+            }
+            Token::QuotedString(ref value) => serialize_string(&**value, dest)?,
+            Token::UnquotedUrl(ref value) => {
+                dest.write_str("url(")?;
+                serialize_unquoted_url(&**value, dest)?;
+                dest.write_str(")")?;
+            }
+            Token::Delim(value) => dest.write_char(value)?,
+
+            Token::Number {
+                value,
+                int_value,
+                has_sign,
+            } => write_numeric(value, int_value, has_sign, dest)?,
+            Token::Percentage {
+                unit_value,
+                int_value,
+                has_sign,
+            } => {
+                write_numeric(unit_value * 100., int_value, has_sign, dest)?;
+                dest.write_str("%")?;
+            }
+            Token::Dimension {
+                value,
+                int_value,
+                has_sign,
+                ref unit,
+            } => {
+                write_numeric(value, int_value, has_sign, dest)?;
+                // Disambiguate with scientific notation.
+                let unit = &**unit;
+                // TODO(emilio): This doesn't handle e.g. 100E1m, which gets us
+                // an unit of "E1m"...
+                if unit == "e" || unit == "E" || unit.starts_with("e-") || unit.starts_with("E-") {
+                    dest.write_str("\\65 ")?;
+                    serialize_name(&unit[1..], dest)?;
+                } else {
+                    serialize_identifier(unit, dest)?;
+                }
+            }
+
+            Token::WhiteSpace(content) => dest.write_str(content)?,
+            Token::Comment(content) => {
+                dest.write_str("/*")?;
+                dest.write_str(content)?;
+                dest.write_str("*/")?
+            }
+            Token::Colon => dest.write_str(":")?,
+            Token::Semicolon => dest.write_str(";")?,
+            Token::Comma => dest.write_str(",")?,
+            Token::IncludeMatch => dest.write_str("~=")?,
+            Token::DashMatch => dest.write_str("|=")?,
+            Token::PrefixMatch => dest.write_str("^=")?,
+            Token::SuffixMatch => dest.write_str("$=")?,
+            Token::SubstringMatch => dest.write_str("*=")?,
+            Token::CDO => dest.write_str("<!--")?,
+            Token::CDC => dest.write_str("-->")?,
+
+            Token::Function(ref name) => {
+                serialize_identifier(&**name, dest)?;
+                dest.write_str("(")?;
+            }
+            Token::ParenthesisBlock => dest.write_str("(")?,
+            Token::SquareBracketBlock => dest.write_str("[")?,
+            Token::CurlyBracketBlock => dest.write_str("{")?,
+
+            Token::BadUrl(ref contents) => {
+                dest.write_str("url(")?;
+                dest.write_str(contents)?;
+                dest.write_char(')')?;
+            }
+            Token::BadString(ref value) => {
+                // During tokenization, an unescaped newline after a quote causes
+                // the token to be a BadString instead of a QuotedString.
+                // The BadString token ends just before the newline
+                // (which is in a separate WhiteSpace token),
+                // and therefore does not have a closing quote.
+                dest.write_char('"')?;
+                CssStringWriter::new(dest).write_str(value)?;
+            }
+            Token::CloseParenthesis => dest.write_str(")")?,
+            Token::CloseSquareBracket => dest.write_str("]")?,
+            Token::CloseCurlyBracket => dest.write_str("}")?,
+        }
+        Ok(())
+    }
+}
+
+fn hex_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    static HEX_DIGITS: &'static [u8; 16] = b"0123456789abcdef";
+    let b3;
+    let b4;
+    let bytes = if ascii_byte > 0x0F {
+        let high = (ascii_byte >> 4) as usize;
+        let low = (ascii_byte & 0x0F) as usize;
+        b4 = [b'\\', HEX_DIGITS[high], HEX_DIGITS[low], b' '];
+        &b4[..]
+    } else {
+        b3 = [b'\\', HEX_DIGITS[ascii_byte as usize], b' '];
+        &b3[..]
+    };
+    dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) })
+}
+
+fn char_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    let bytes = [b'\\', ascii_byte];
+    dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) })
+}
+
+/// Write a CSS identifier, escaping characters as necessary.
+pub fn serialize_identifier<W>(mut value: &str, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    if value.is_empty() {
+        return Ok(());
+    }
+
+    if value.starts_with("--") {
+        dest.write_str("--")?;
+        serialize_name(&value[2..], dest)
+    } else if value == "-" {
+        dest.write_str("\\-")
+    } else {
+        if value.as_bytes()[0] == b'-' {
+            dest.write_str("-")?;
+            value = &value[1..];
+        }
+        if let digit @ b'0'..=b'9' = value.as_bytes()[0] {
+            hex_escape(digit, dest)?;
+            value = &value[1..];
+        }
+        serialize_name(value, dest)
+    }
+}
+
+/// Write a CSS name, like a custom property name.
+///
+/// You should only use this when you know what you're doing, when in doubt,
+/// consider using `serialize_identifier`.
+pub fn serialize_name<W>(value: &str, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    let mut chunk_start = 0;
+    for (i, b) in value.bytes().enumerate() {
+        let escaped = match b {
+            b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z' | b'_' | b'-' => continue,
+            _ if !b.is_ascii() => continue,
+            b'\0' => Some("\u{FFFD}"),
+            _ => None,
+        };
+        dest.write_str(&value[chunk_start..i])?;
+        if let Some(escaped) = escaped {
+            dest.write_str(escaped)?;
+        } else if (b >= b'\x01' && b <= b'\x1F') || b == b'\x7F' {
+            hex_escape(b, dest)?;
+        } else {
+            char_escape(b, dest)?;
+        }
+        chunk_start = i + 1;
+    }
+    dest.write_str(&value[chunk_start..])
+}
+
+fn serialize_unquoted_url<W>(value: &str, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    let mut chunk_start = 0;
+    for (i, b) in value.bytes().enumerate() {
+        let hex = match b {
+            b'\0'..=b' ' | b'\x7F' => true,
+            b'(' | b')' | b'"' | b'\'' | b'\\' => false,
+            _ => continue,
+        };
+        dest.write_str(&value[chunk_start..i])?;
+        if hex {
+            hex_escape(b, dest)?;
+        } else {
+            char_escape(b, dest)?;
+        }
+        chunk_start = i + 1;
+    }
+    dest.write_str(&value[chunk_start..])
+}
+
+/// Write a double-quoted CSS string token, escaping content as necessary.
+pub fn serialize_string<W>(value: &str, dest: &mut W) -> fmt::Result
+where
+    W: fmt::Write,
+{
+    dest.write_str("\"")?;
+    CssStringWriter::new(dest).write_str(value)?;
+    dest.write_str("\"")?;
+    Ok(())
+}
+
+/// A `fmt::Write` adapter that escapes text for writing as a double-quoted CSS string.
+/// Quotes are not included.
+///
+/// Typical usage:
+///
+/// ```{rust,ignore}
+/// fn write_foo<W>(foo: &Foo, dest: &mut W) -> fmt::Result where W: fmt::Write {
+///     dest.write_str("\"")?;
+///     {
+///         let mut string_dest = CssStringWriter::new(dest);
+///         // Write into string_dest...
+///     }
+///     dest.write_str("\"")?;
+///     Ok(())
+/// }
+/// ```
+pub struct CssStringWriter<'a, W> {
+    inner: &'a mut W,
+}
+
+impl<'a, W> CssStringWriter<'a, W>
+where
+    W: fmt::Write,
+{
+    /// Wrap a text writer to create a `CssStringWriter`.
+    pub fn new(inner: &'a mut W) -> CssStringWriter<'a, W> {
+        CssStringWriter { inner: inner }
+    }
+}
+
+impl<'a, W> fmt::Write for CssStringWriter<'a, W>
+where
+    W: fmt::Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let mut chunk_start = 0;
+        for (i, b) in s.bytes().enumerate() {
+            let escaped = match b {
+                b'"' => Some("\\\""),
+                b'\\' => Some("\\\\"),
+                b'\0' => Some("\u{FFFD}"),
+                b'\x01'..=b'\x1F' | b'\x7F' => None,
+                _ => continue,
+            };
+            self.inner.write_str(&s[chunk_start..i])?;
+            match escaped {
+                Some(x) => self.inner.write_str(x)?,
+                None => hex_escape(b, self.inner)?,
+            };
+            chunk_start = i + 1;
+        }
+        self.inner.write_str(&s[chunk_start..])
+    }
+}
+
+macro_rules! impl_tocss_for_int {
+    ($T: ty) => {
+        impl<'a> ToCss for $T {
+            fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+            where
+                W: fmt::Write,
+            {
+                let mut buf = itoa::Buffer::new();
+                dest.write_str(buf.format(*self))
+            }
+        }
+    };
+}
+
+impl_tocss_for_int!(i8);
+impl_tocss_for_int!(u8);
+impl_tocss_for_int!(i16);
+impl_tocss_for_int!(u16);
+impl_tocss_for_int!(i32);
+impl_tocss_for_int!(u32);
+impl_tocss_for_int!(i64);
+impl_tocss_for_int!(u64);
+
+macro_rules! impl_tocss_for_float {
+    ($T: ty) => {
+        impl<'a> ToCss for $T {
+            fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+            where
+                W: fmt::Write,
+            {
+                dtoa_short::write(dest, *self).map(|_| ())
+            }
+        }
+    };
+}
+
+impl_tocss_for_float!(f32);
+impl_tocss_for_float!(f64);
+
+/// A category of token. See the `needs_separator_when_before` method.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub struct TokenSerializationType(TokenSerializationTypeVariants);
+
+impl TokenSerializationType {
+    /// Return a value that represents the absence of a token, e.g. before the start of the input.
+    pub fn nothing() -> TokenSerializationType {
+        TokenSerializationType(TokenSerializationTypeVariants::Nothing)
+    }
+
+    /// If this value is `TokenSerializationType::nothing()`, set it to the given value instead.
+    pub fn set_if_nothing(&mut self, new_value: TokenSerializationType) {
+        if self.0 == TokenSerializationTypeVariants::Nothing {
+            self.0 = new_value.0
+        }
+    }
+
+    /// Return true if, when a token of category `self` is serialized just before
+    /// a token of category `other` with no whitespace in between,
+    /// an empty comment `/**/` needs to be inserted between them
+    /// so that they are not re-parsed as a single token.
+    ///
+    /// See https://drafts.csswg.org/css-syntax/#serialization
+    ///
+    /// See https://github.com/w3c/csswg-drafts/issues/4088 for the
+    /// `DelimPercent` bits.
+    pub fn needs_separator_when_before(self, other: TokenSerializationType) -> bool {
+        use self::TokenSerializationTypeVariants::*;
+        match self.0 {
+            Ident => matches!(
+                other.0,
+                Ident
+                    | Function
+                    | UrlOrBadUrl
+                    | DelimMinus
+                    | Number
+                    | Percentage
+                    | Dimension
+                    | CDC
+                    | OpenParen
+            ),
+            AtKeywordOrHash | Dimension => matches!(
+                other.0,
+                Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension | CDC
+            ),
+            DelimHash | DelimMinus => matches!(
+                other.0,
+                Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension
+            ),
+            Number => matches!(
+                other.0,
+                Ident
+                    | Function
+                    | UrlOrBadUrl
+                    | DelimMinus
+                    | Number
+                    | Percentage
+                    | DelimPercent
+                    | Dimension
+            ),
+            DelimAt => matches!(other.0, Ident | Function | UrlOrBadUrl | DelimMinus),
+            DelimDotOrPlus => matches!(other.0, Number | Percentage | Dimension),
+            DelimAssorted | DelimAsterisk => matches!(other.0, DelimEquals),
+            DelimBar => matches!(other.0, DelimEquals | DelimBar | DashMatch),
+            DelimSlash => matches!(other.0, DelimAsterisk | SubstringMatch),
+            Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen
+            | DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => {
+                false
+            }
+        }
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+enum TokenSerializationTypeVariants {
+    Nothing,
+    WhiteSpace,
+    AtKeywordOrHash,
+    Number,
+    Dimension,
+    Percentage,
+    UrlOrBadUrl,
+    Function,
+    Ident,
+    CDC,
+    DashMatch,
+    SubstringMatch,
+    OpenParen,      // '('
+    DelimHash,      // '#'
+    DelimAt,        // '@'
+    DelimDotOrPlus, // '.', '+'
+    DelimMinus,     // '-'
+    DelimQuestion,  // '?'
+    DelimAssorted,  // '$', '^', '~'
+    DelimEquals,    // '='
+    DelimBar,       // '|'
+    DelimSlash,     // '/'
+    DelimAsterisk,  // '*'
+    DelimPercent,   // '%'
+    Other,          // anything else
+}
+
+impl<'a> Token<'a> {
+    /// Categorize a token into a type that determines when `/**/` needs to be inserted
+    /// between two tokens when serialized next to each other without whitespace in between.
+    ///
+    /// See the `TokenSerializationType::needs_separator_when_before` method.
+    pub fn serialization_type(&self) -> TokenSerializationType {
+        use self::TokenSerializationTypeVariants::*;
+        TokenSerializationType(match *self {
+            Token::Ident(_) => Ident,
+            Token::AtKeyword(_) | Token::Hash(_) | Token::IDHash(_) => AtKeywordOrHash,
+            Token::UnquotedUrl(_) | Token::BadUrl(_) => UrlOrBadUrl,
+            Token::Delim('#') => DelimHash,
+            Token::Delim('@') => DelimAt,
+            Token::Delim('.') | Token::Delim('+') => DelimDotOrPlus,
+            Token::Delim('-') => DelimMinus,
+            Token::Delim('?') => DelimQuestion,
+            Token::Delim('$') | Token::Delim('^') | Token::Delim('~') => DelimAssorted,
+            Token::Delim('%') => DelimPercent,
+            Token::Delim('=') => DelimEquals,
+            Token::Delim('|') => DelimBar,
+            Token::Delim('/') => DelimSlash,
+            Token::Delim('*') => DelimAsterisk,
+            Token::Number { .. } => Number,
+            Token::Percentage { .. } => Percentage,
+            Token::Dimension { .. } => Dimension,
+            Token::WhiteSpace(_) => WhiteSpace,
+            Token::Comment(_) => DelimSlash,
+            Token::DashMatch => DashMatch,
+            Token::SubstringMatch => SubstringMatch,
+            Token::CDC => CDC,
+            Token::Function(_) => Function,
+            Token::ParenthesisBlock => OpenParen,
+            Token::SquareBracketBlock
+            | Token::CurlyBracketBlock
+            | Token::CloseParenthesis
+            | Token::CloseSquareBracket
+            | Token::CloseCurlyBracket
+            | Token::QuotedString(_)
+            | Token::BadString(_)
+            | Token::Delim(_)
+            | Token::Colon
+            | Token::Semicolon
+            | Token::Comma
+            | Token::CDO
+            | Token::IncludeMatch
+            | Token::PrefixMatch
+            | Token::SuffixMatch => Other,
+        })
+    }
+}
diff --git a/third_party/rust/cssparser/src/size_of_tests.rs b/third_party/rust/cssparser/src/size_of_tests.rs
new file mode 100644
index 0000000000..edd2b439f0
--- /dev/null
+++ b/third_party/rust/cssparser/src/size_of_tests.rs
@@ -0,0 +1,52 @@
+/* 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 crate::cow_rc_str::CowRcStr;
+use crate::tokenizer::Token;
+
+macro_rules! size_of_test {
+    ($testname: ident, $t: ty, $expected_min_size: expr, $expected_max_size: expr) => {
+        #[test]
+        fn $testname() {
+            let new = ::std::mem::size_of::<$t>();
+            if new < $expected_min_size {
+                panic!(
+                    "Your changes have decreased the stack size of {} from {} to {}. \
+                     Good work! Please update the expected size in {}.",
+                    stringify!($t),
+                    $expected_min_size,
+                    new,
+                    file!()
+                )
+            } else if new > $expected_max_size {
+                panic!(
+                    "Your changes have increased the stack size of {} from {} to {}. \
+                     Please consider choosing a design which avoids this increase. \
+                     If you feel that the increase is necessary, update the size in {}.",
+                    stringify!($t),
+                    $expected_max_size,
+                    new,
+                    file!()
+                )
+            }
+        }
+    };
+    ($testname: ident, $t: ty, $expected_size: expr) => {
+        size_of_test!($testname, $t, $expected_size, $expected_size);
+    };
+}
+
+// Some of these assume 64-bit
+size_of_test!(token, Token, 32);
+size_of_test!(std_cow_str, std::borrow::Cow<'static, str>, 24, 32);
+size_of_test!(cow_rc_str, CowRcStr, 16);
+
+size_of_test!(tokenizer, crate::tokenizer::Tokenizer, 72);
+size_of_test!(parser_input, crate::parser::ParserInput, 136);
+size_of_test!(parser, crate::parser::Parser, 16);
+size_of_test!(source_position, crate::SourcePosition, 8);
+size_of_test!(parser_state, crate::ParserState, 24);
+
+size_of_test!(basic_parse_error, crate::BasicParseError, 40, 48);
+size_of_test!(parse_error_lower_bound, crate::ParseError<()>, 40, 48);
diff --git a/third_party/rust/cssparser/src/tests.rs b/third_party/rust/cssparser/src/tests.rs
new file mode 100644
index 0000000000..e8f94a4053
--- /dev/null
+++ b/third_party/rust/cssparser/src/tests.rs
@@ -0,0 +1,1670 @@
+/* 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/. */
+
+#[cfg(feature = "bench")]
+extern crate test;
+
+use encoding_rs;
+use serde_json::{self, json, Map, Value};
+
+use crate::color::{parse_color_with, FromParsedColor};
+use crate::{ColorParser, PredefinedColorSpace};
+
+#[cfg(feature = "bench")]
+use self::test::Bencher;
+
+use super::{
+    parse_important, parse_nth, parse_one_declaration, parse_one_rule, stylesheet_encoding,
+    AtRuleParser, BasicParseError, BasicParseErrorKind, Color, CowRcStr, DeclarationParser,
+    Delimiter, EncodingSupport, ParseError, ParseErrorKind, Parser, ParserInput, ParserState,
+    QualifiedRuleParser, RuleBodyItemParser, RuleBodyParser, SourceLocation, StyleSheetParser,
+    ToCss, Token, TokenSerializationType, UnicodeRange, RGBA,
+};
+
+macro_rules! JArray {
+    ($($e: expr,)*) => { JArray![ $( $e ),* ] };
+    ($($e: expr),*) => { Value::Array(vec!( $( $e.to_json() ),* )) }
+}
+
+fn almost_equals(a: &Value, b: &Value) -> bool {
+    match (a, b) {
+        (&Value::Number(ref a), &Value::Number(ref b)) => {
+            let a = a.as_f64().unwrap();
+            let b = b.as_f64().unwrap();
+            (a - b).abs() <= a.abs() * 1e-6
+        }
+
+        (&Value::Bool(a), &Value::Bool(b)) => a == b,
+        (&Value::String(ref a), &Value::String(ref b)) => a == b,
+        (&Value::Array(ref a), &Value::Array(ref b)) => {
+            a.len() == b.len()
+                && a.iter()
+                    .zip(b.iter())
+                    .all(|(ref a, ref b)| almost_equals(*a, *b))
+        }
+        (&Value::Object(_), &Value::Object(_)) => panic!("Not implemented"),
+        (&Value::Null, &Value::Null) => true,
+        _ => false,
+    }
+}
+
+fn normalize(json: &mut Value) {
+    match *json {
+        Value::Array(ref mut list) => {
+            for item in list.iter_mut() {
+                normalize(item)
+            }
+        }
+        Value::String(ref mut s) => {
+            if *s == "extra-input" || *s == "empty" {
+                *s = "invalid".to_string()
+            }
+        }
+        _ => {}
+    }
+}
+
+fn assert_json_eq(results: Value, mut expected: Value, message: &str) {
+    normalize(&mut expected);
+    if !almost_equals(&results, &expected) {
+        println!(
+            "{}",
+            ::difference::Changeset::new(
+                &serde_json::to_string_pretty(&results).unwrap(),
+                &serde_json::to_string_pretty(&expected).unwrap(),
+                "\n",
+            )
+        );
+        panic!("{}", message)
+    }
+}
+
+fn run_raw_json_tests<F: Fn(Value, Value) -> ()>(json_data: &str, run: F) {
+    let items = match serde_json::from_str(json_data) {
+        Ok(Value::Array(items)) => items,
+        other => panic!("Invalid JSON: {:?}", other),
+    };
+    assert!(items.len() % 2 == 0);
+    let mut input = None;
+    for item in items.into_iter() {
+        match (&input, item) {
+            (&None, json_obj) => input = Some(json_obj),
+            (&Some(_), expected) => {
+                let input = input.take().unwrap();
+                run(input, expected)
+            }
+        };
+    }
+}
+
+fn run_json_tests<F: Fn(&mut Parser) -> Value>(json_data: &str, parse: F) {
+    run_raw_json_tests(json_data, |input, expected| match input {
+        Value::String(input) => {
+            let mut parse_input = ParserInput::new(&input);
+            let result = parse(&mut Parser::new(&mut parse_input));
+            assert_json_eq(result, expected, &input);
+        }
+        _ => panic!("Unexpected JSON"),
+    });
+}
+
+#[test]
+fn component_value_list() {
+    run_json_tests(
+        include_str!("css-parsing-tests/component_value_list.json"),
+        |input| Value::Array(component_values_to_json(input)),
+    );
+}
+
+#[test]
+fn one_component_value() {
+    run_json_tests(
+        include_str!("css-parsing-tests/one_component_value.json"),
+        |input| {
+            let result: Result<Value, ParseError<()>> = input.parse_entirely(|input| {
+                Ok(one_component_value_to_json(input.next()?.clone(), input))
+            });
+            result.unwrap_or(JArray!["error", "invalid"])
+        },
+    );
+}
+
+#[test]
+fn declaration_list() {
+    run_json_tests(
+        include_str!("css-parsing-tests/declaration_list.json"),
+        |input| {
+            Value::Array(
+                RuleBodyParser::new(input, &mut JsonParser)
+                    .map(|result| result.unwrap_or(JArray!["error", "invalid"]))
+                    .collect(),
+            )
+        },
+    );
+}
+
+#[test]
+fn one_declaration() {
+    run_json_tests(
+        include_str!("css-parsing-tests/one_declaration.json"),
+        |input| {
+            parse_one_declaration(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"])
+        },
+    );
+}
+
+#[test]
+fn rule_list() {
+    run_json_tests(include_str!("css-parsing-tests/rule_list.json"), |input| {
+        Value::Array(
+            RuleBodyParser::new(input, &mut JsonParser)
+                .map(|result| result.unwrap_or(JArray!["error", "invalid"]))
+                .collect(),
+        )
+    });
+}
+
+#[test]
+fn stylesheet() {
+    run_json_tests(include_str!("css-parsing-tests/stylesheet.json"), |input| {
+        Value::Array(
+            StyleSheetParser::new(input, &mut JsonParser)
+                .map(|result| result.unwrap_or(JArray!["error", "invalid"]))
+                .collect(),
+        )
+    });
+}
+
+#[test]
+fn one_rule() {
+    run_json_tests(include_str!("css-parsing-tests/one_rule.json"), |input| {
+        parse_one_rule(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"])
+    });
+}
+
+#[test]
+fn stylesheet_from_bytes() {
+    pub struct EncodingRs;
+
+    impl EncodingSupport for EncodingRs {
+        type Encoding = &'static encoding_rs::Encoding;
+
+        fn utf8() -> Self::Encoding {
+            encoding_rs::UTF_8
+        }
+
+        fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool {
+            *encoding == encoding_rs::UTF_16LE || *encoding == encoding_rs::UTF_16BE
+        }
+
+        fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding> {
+            encoding_rs::Encoding::for_label(ascii_label)
+        }
+    }
+
+    run_raw_json_tests(
+        include_str!("css-parsing-tests/stylesheet_bytes.json"),
+        |input, expected| {
+            let map = match input {
+                Value::Object(map) => map,
+                _ => panic!("Unexpected JSON"),
+            };
+
+            let result = {
+                let css = get_string(&map, "css_bytes")
+                    .unwrap()
+                    .chars()
+                    .map(|c| {
+                        assert!(c as u32 <= 0xFF);
+                        c as u8
+                    })
+                    .collect::<Vec<u8>>();
+                let protocol_encoding_label =
+                    get_string(&map, "protocol_encoding").map(|s| s.as_bytes());
+                let environment_encoding = get_string(&map, "environment_encoding")
+                    .map(|s| s.as_bytes())
+                    .and_then(EncodingRs::from_label);
+
+                let encoding = stylesheet_encoding::<EncodingRs>(
+                    &css,
+                    protocol_encoding_label,
+                    environment_encoding,
+                );
+                let (css_unicode, used_encoding, _) = encoding.decode(&css);
+                let mut input = ParserInput::new(&css_unicode);
+                let input = &mut Parser::new(&mut input);
+                let rules = StyleSheetParser::new(input, &mut JsonParser)
+                    .map(|result| result.unwrap_or(JArray!["error", "invalid"]))
+                    .collect::<Vec<_>>();
+                JArray![rules, used_encoding.name().to_lowercase()]
+            };
+            assert_json_eq(result, expected, &Value::Object(map).to_string());
+        },
+    );
+
+    fn get_string<'a>(map: &'a Map<String, Value>, key: &str) -> Option<&'a str> {
+        match map.get(key) {
+            Some(&Value::String(ref s)) => Some(s),
+            Some(&Value::Null) => None,
+            None => None,
+            _ => panic!("Unexpected JSON"),
+        }
+    }
+}
+
+#[test]
+fn expect_no_error_token() {
+    let mut input = ParserInput::new("foo 4px ( / { !bar }");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_ok());
+    let mut input = ParserInput::new(")");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+    let mut input = ParserInput::new("}");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+    let mut input = ParserInput::new("(a){]");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+    let mut input = ParserInput::new("'\n'");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+    let mut input = ParserInput::new("url('\n'");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+    let mut input = ParserInput::new("url(a b)");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+    let mut input = ParserInput::new("url(\u{7F}))");
+    assert!(Parser::new(&mut input).expect_no_error_token().is_err());
+}
+
+/// https://github.com/servo/rust-cssparser/issues/71
+#[test]
+fn outer_block_end_consumed() {
+    let mut input = ParserInput::new("(calc(true))");
+    let mut input = Parser::new(&mut input);
+    assert!(input.expect_parenthesis_block().is_ok());
+    assert!(input
+        .parse_nested_block(|input| input
+            .expect_function_matching("calc")
+            .map_err(Into::<ParseError<()>>::into))
+        .is_ok());
+    println!("{:?}", input.position());
+    assert!(input.next().is_err());
+}
+
+/// https://github.com/servo/rust-cssparser/issues/174
+#[test]
+fn bad_url_slice_out_of_bounds() {
+    let mut input = ParserInput::new("url(\u{1}\\");
+    let mut parser = Parser::new(&mut input);
+    let result = parser.next_including_whitespace_and_comments(); // This used to panic
+    assert_eq!(result, Ok(&Token::BadUrl("\u{1}\\".into())));
+}
+
+/// https://bugzilla.mozilla.org/show_bug.cgi?id=1383975
+#[test]
+fn bad_url_slice_not_at_char_boundary() {
+    let mut input = ParserInput::new("url(9\n۰");
+    let mut parser = Parser::new(&mut input);
+    let result = parser.next_including_whitespace_and_comments(); // This used to panic
+    assert_eq!(result, Ok(&Token::BadUrl("9\n۰".into())));
+}
+
+#[test]
+fn unquoted_url_escaping() {
+    let token = Token::UnquotedUrl(
+        "\
+         \x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\
+         \x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f \
+         !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]\
+         ^_`abcdefghijklmnopqrstuvwxyz{|}~\x7fé\
+         "
+        .into(),
+    );
+    let serialized = token.to_css_string();
+    assert_eq!(
+        serialized,
+        "\
+         url(\
+         \\1 \\2 \\3 \\4 \\5 \\6 \\7 \\8 \\9 \\a \\b \\c \\d \\e \\f \\10 \
+         \\11 \\12 \\13 \\14 \\15 \\16 \\17 \\18 \\19 \\1a \\1b \\1c \\1d \\1e \\1f \\20 \
+         !\\\"#$%&\\'\\(\\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]\
+         ^_`abcdefghijklmnopqrstuvwxyz{|}~\\7f é\
+         )\
+         "
+    );
+    let mut input = ParserInput::new(&serialized);
+    assert_eq!(Parser::new(&mut input).next(), Ok(&token));
+}
+
+#[test]
+fn test_expect_url() {
+    fn parse<'a>(s: &mut ParserInput<'a>) -> Result<CowRcStr<'a>, BasicParseError<'a>> {
+        Parser::new(s).expect_url()
+    }
+    let mut input = ParserInput::new("url()");
+    assert_eq!(parse(&mut input).unwrap(), "");
+    let mut input = ParserInput::new("url( ");
+    assert_eq!(parse(&mut input).unwrap(), "");
+    let mut input = ParserInput::new("url( abc");
+    assert_eq!(parse(&mut input).unwrap(), "abc");
+    let mut input = ParserInput::new("url( abc \t)");
+    assert_eq!(parse(&mut input).unwrap(), "abc");
+    let mut input = ParserInput::new("url( 'abc' \t)");
+    assert_eq!(parse(&mut input).unwrap(), "abc");
+    let mut input = ParserInput::new("url(abc more stuff)");
+    assert!(parse(&mut input).is_err());
+    // The grammar at https://drafts.csswg.org/css-values/#urls plans for `<url-modifier>*`
+    // at the position of "more stuff", but no such modifier is defined yet.
+    let mut input = ParserInput::new("url('abc' more stuff)");
+    assert!(parse(&mut input).is_err());
+}
+
+fn run_color_tests<F: Fn(Result<Color, ()>) -> Value>(json_data: &str, to_json: F) {
+    run_json_tests(json_data, |input| {
+        let result: Result<_, ParseError<()>> =
+            input.parse_entirely(|i| Color::parse(i).map_err(Into::into));
+        to_json(result.map_err(|_| ()))
+    });
+}
+
+#[test]
+fn color3() {
+    run_color_tests(include_str!("css-parsing-tests/color3.json"), |c| {
+        c.ok()
+            .map(|v| v.to_css_string().to_json())
+            .unwrap_or(Value::Null)
+    })
+}
+
+#[test]
+fn color3_hsl() {
+    run_color_tests(include_str!("css-parsing-tests/color3_hsl.json"), |c| {
+        c.ok()
+            .map(|v| v.to_css_string().to_json())
+            .unwrap_or(Value::Null)
+    })
+}
+
+/// color3_keywords.json is different: R, G and B are in 0..255 rather than 0..1
+#[test]
+fn color3_keywords() {
+    run_color_tests(
+        include_str!("css-parsing-tests/color3_keywords.json"),
+        |c| {
+            c.ok()
+                .map(|v| v.to_css_string().to_json())
+                .unwrap_or(Value::Null)
+        },
+    )
+}
+
+#[test]
+fn color4_hwb() {
+    run_color_tests(include_str!("css-parsing-tests/color4_hwb.json"), |c| {
+        c.ok()
+            .map(|v| v.to_css_string().to_json())
+            .unwrap_or(Value::Null)
+    })
+}
+
+#[test]
+fn color4_lab_lch_oklab_oklch() {
+    run_color_tests(
+        include_str!("css-parsing-tests/color4_lab_lch_oklab_oklch.json"),
+        |c| {
+            c.ok()
+                .map(|v| v.to_css_string().to_json())
+                .unwrap_or(Value::Null)
+        },
+    )
+}
+
+#[test]
+fn color4_color_function() {
+    run_color_tests(
+        include_str!("css-parsing-tests/color4_color_function.json"),
+        |c| {
+            c.ok()
+                .map(|v| v.to_css_string().to_json())
+                .unwrap_or(Value::Null)
+        },
+    )
+}
+
+macro_rules! parse_single_color {
+    ($i:expr) => {{
+        let input = $i;
+        let mut input = ParserInput::new(input);
+        let mut input = Parser::new(&mut input);
+        Color::parse(&mut input).map_err(Into::<ParseError<()>>::into)
+    }};
+}
+
+#[test]
+fn color4_invalid_color_space() {
+    let result = parse_single_color!("color(invalid 1 1 1)");
+    assert!(result.is_err());
+}
+
+#[test]
+fn nth() {
+    run_json_tests(include_str!("css-parsing-tests/An+B.json"), |input| {
+        input
+            .parse_entirely(|i| {
+                let result: Result<_, ParseError<()>> = parse_nth(i).map_err(Into::into);
+                result
+            })
+            .ok()
+            .map(|(v0, v1)| json!([v0, v1]))
+            .unwrap_or(Value::Null)
+    });
+}
+
+#[test]
+fn parse_comma_separated_ignoring_errors() {
+    let input = "red, green something, yellow, whatever, blue";
+    let mut input = ParserInput::new(input);
+    let mut input = Parser::new(&mut input);
+    let result = input.parse_comma_separated_ignoring_errors(|input| {
+        Color::parse(input).map_err(Into::<ParseError<()>>::into)
+    });
+    assert_eq!(result.len(), 3);
+    assert_eq!(result[0].to_css_string(), "rgb(255, 0, 0)");
+    assert_eq!(result[1].to_css_string(), "rgb(255, 255, 0)");
+    assert_eq!(result[2].to_css_string(), "rgb(0, 0, 255)");
+}
+
+#[test]
+fn unicode_range() {
+    run_json_tests(include_str!("css-parsing-tests/urange.json"), |input| {
+        let result: Result<_, ParseError<()>> = input.parse_comma_separated(|input| {
+            let result = UnicodeRange::parse(input).ok().map(|r| (r.start, r.end));
+            if input.is_exhausted() {
+                Ok(result)
+            } else {
+                while let Ok(_) = input.next() {}
+                Ok(None)
+            }
+        });
+        result
+            .unwrap()
+            .iter()
+            .map(|v| {
+                if let Some((v0, v1)) = v {
+                    json!([v0, v1])
+                } else {
+                    Value::Null
+                }
+            })
+            .collect::<Vec<_>>()
+            .to_json()
+    });
+}
+
+#[test]
+fn serializer_not_preserving_comments() {
+    serializer(false)
+}
+
+#[test]
+fn serializer_preserving_comments() {
+    serializer(true)
+}
+
+fn serializer(preserve_comments: bool) {
+    run_json_tests(
+        include_str!("css-parsing-tests/component_value_list.json"),
+        |input| {
+            fn write_to(
+                mut previous_token: TokenSerializationType,
+                input: &mut Parser,
+                string: &mut String,
+                preserve_comments: bool,
+            ) {
+                while let Ok(token) = if preserve_comments {
+                    input
+                        .next_including_whitespace_and_comments()
+                        .map(|t| t.clone())
+                } else {
+                    input.next_including_whitespace().map(|t| t.clone())
+                } {
+                    let token_type = token.serialization_type();
+                    if !preserve_comments && previous_token.needs_separator_when_before(token_type)
+                    {
+                        string.push_str("/**/")
+                    }
+                    previous_token = token_type;
+                    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 {
+                        let result: Result<_, ParseError<()>> = input.parse_nested_block(|input| {
+                            write_to(previous_token, input, string, preserve_comments);
+                            Ok(())
+                        });
+                        result.unwrap();
+                        closing_token.to_css(string).unwrap();
+                    }
+                }
+            }
+            let mut serialized = String::new();
+            write_to(
+                TokenSerializationType::nothing(),
+                input,
+                &mut serialized,
+                preserve_comments,
+            );
+            let mut input = ParserInput::new(&serialized);
+            let parser = &mut Parser::new(&mut input);
+            Value::Array(component_values_to_json(parser))
+        },
+    );
+}
+
+#[test]
+fn serialize_bad_tokens() {
+    let mut input = ParserInput::new("url(foo\\) b\\)ar)'ba\\'\"z\n4");
+    let mut parser = Parser::new(&mut input);
+
+    let token = parser.next().unwrap().clone();
+    assert!(matches!(token, Token::BadUrl(_)));
+    assert_eq!(token.to_css_string(), "url(foo\\) b\\)ar)");
+
+    let token = parser.next().unwrap().clone();
+    assert!(matches!(token, Token::BadString(_)));
+    assert_eq!(token.to_css_string(), "\"ba'\\\"z");
+
+    let token = parser.next().unwrap().clone();
+    assert!(matches!(token, Token::Number { .. }));
+    assert_eq!(token.to_css_string(), "4");
+
+    assert!(parser.next().is_err());
+}
+
+#[test]
+fn serialize_current_color() {
+    let c = Color::CurrentColor;
+    assert!(c.to_css_string() == "currentcolor");
+}
+
+#[test]
+fn serialize_rgb_full_alpha() {
+    let c = Color::Rgba(RGBA::new(Some(255), Some(230), Some(204), Some(1.0)));
+    assert_eq!(c.to_css_string(), "rgb(255, 230, 204)");
+}
+
+#[test]
+fn serialize_rgba() {
+    let c = Color::Rgba(RGBA::new(Some(26), Some(51), Some(77), Some(0.125)));
+    assert_eq!(c.to_css_string(), "rgba(26, 51, 77, 0.125)");
+}
+
+#[test]
+fn serialize_rgba_two_digit_float_if_roundtrips() {
+    let c = Color::Rgba(RGBA::from_floats(Some(0.), Some(0.), Some(0.), Some(0.5)));
+    assert_eq!(c.to_css_string(), "rgba(0, 0, 0, 0.5)");
+}
+
+#[test]
+fn line_numbers() {
+    let mut input = ParserInput::new(concat!(
+        "fo\\30\r\n",
+        "0o bar/*\n",
+        "*/baz\r\n",
+        "\n",
+        "url(\r\n",
+        "  u \r\n",
+        ")\"a\\\r\n",
+        "b\""
+    ));
+    let mut input = Parser::new(&mut input);
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 0, column: 1 }
+    );
+    assert_eq!(
+        input.next_including_whitespace(),
+        Ok(&Token::Ident("fo00o".into()))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 1, column: 3 }
+    );
+    assert_eq!(
+        input.next_including_whitespace(),
+        Ok(&Token::WhiteSpace(" "))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 1, column: 4 }
+    );
+    assert_eq!(
+        input.next_including_whitespace(),
+        Ok(&Token::Ident("bar".into()))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 1, column: 7 }
+    );
+    assert_eq!(
+        input.next_including_whitespace_and_comments(),
+        Ok(&Token::Comment("\n"))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 2, column: 3 }
+    );
+    assert_eq!(
+        input.next_including_whitespace(),
+        Ok(&Token::Ident("baz".into()))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 2, column: 6 }
+    );
+    let state = input.state();
+
+    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!(
+        state.source_location(),
+        SourceLocation { line: 2, column: 6 }
+    );
+
+    assert_eq!(
+        input.next_including_whitespace(),
+        Ok(&Token::UnquotedUrl("u".into()))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 6, column: 2 }
+    );
+
+    assert_eq!(
+        input.next_including_whitespace(),
+        Ok(&Token::QuotedString("ab".into()))
+    );
+    assert_eq!(
+        input.current_source_location(),
+        SourceLocation { line: 7, column: 3 }
+    );
+    assert!(input.next_including_whitespace().is_err());
+}
+
+#[test]
+fn overflow() {
+    use std::iter::repeat;
+
+    let css = r"
+         2147483646
+         2147483647
+         2147483648
+         10000000000000
+         1000000000000000000000000000000000000000
+         1{309 zeros}
+
+         -2147483647
+         -2147483648
+         -2147483649
+         -10000000000000
+         -1000000000000000000000000000000000000000
+         -1{309 zeros}
+
+         3.30282347e+38
+         3.40282347e+38
+         3.402824e+38
+
+         -3.30282347e+38
+         -3.40282347e+38
+         -3.402824e+38
+
+    "
+    .replace("{309 zeros}", &repeat('0').take(309).collect::<String>());
+    let mut input = ParserInput::new(&css);
+    let mut input = Parser::new(&mut input);
+
+    assert_eq!(input.expect_integer(), Ok(2147483646));
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+    assert_eq!(input.expect_integer(), Ok(2147483647)); // Clamp on overflow
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+
+    assert_eq!(input.expect_integer(), Ok(-2147483647));
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+    assert_eq!(input.expect_integer(), Ok(-2147483648)); // Clamp on overflow
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+
+    assert_eq!(input.expect_number(), Ok(3.30282347e+38));
+    assert_eq!(input.expect_number(), Ok(f32::MAX));
+    assert_eq!(input.expect_number(), Ok(f32::INFINITY));
+    assert!(f32::MAX != f32::INFINITY);
+
+    assert_eq!(input.expect_number(), Ok(-3.30282347e+38));
+    assert_eq!(input.expect_number(), Ok(f32::MIN));
+    assert_eq!(input.expect_number(), Ok(f32::NEG_INFINITY));
+    assert!(f32::MIN != f32::NEG_INFINITY);
+}
+
+#[test]
+fn line_delimited() {
+    let mut input = ParserInput::new(" { foo ; bar } baz;,");
+    let mut input = Parser::new(&mut input);
+    assert_eq!(input.next(), Ok(&Token::CurlyBracketBlock));
+    assert!({
+        let result: Result<_, ParseError<()>> =
+            input.parse_until_after(Delimiter::Semicolon, |_| Ok(42));
+        result
+    }
+    .is_err());
+    assert_eq!(input.next(), Ok(&Token::Comma));
+    assert!(input.next().is_err());
+}
+
+#[test]
+fn identifier_serialization() {
+    // Null bytes
+    assert_eq!(Token::Ident("\0".into()).to_css_string(), "\u{FFFD}");
+    assert_eq!(Token::Ident("a\0".into()).to_css_string(), "a\u{FFFD}");
+    assert_eq!(Token::Ident("\0b".into()).to_css_string(), "\u{FFFD}b");
+    assert_eq!(Token::Ident("a\0b".into()).to_css_string(), "a\u{FFFD}b");
+
+    // Replacement character
+    assert_eq!(Token::Ident("\u{FFFD}".into()).to_css_string(), "\u{FFFD}");
+    assert_eq!(
+        Token::Ident("a\u{FFFD}".into()).to_css_string(),
+        "a\u{FFFD}"
+    );
+    assert_eq!(
+        Token::Ident("\u{FFFD}b".into()).to_css_string(),
+        "\u{FFFD}b"
+    );
+    assert_eq!(
+        Token::Ident("a\u{FFFD}b".into()).to_css_string(),
+        "a\u{FFFD}b"
+    );
+
+    // Number prefix
+    assert_eq!(Token::Ident("0a".into()).to_css_string(), "\\30 a");
+    assert_eq!(Token::Ident("1a".into()).to_css_string(), "\\31 a");
+    assert_eq!(Token::Ident("2a".into()).to_css_string(), "\\32 a");
+    assert_eq!(Token::Ident("3a".into()).to_css_string(), "\\33 a");
+    assert_eq!(Token::Ident("4a".into()).to_css_string(), "\\34 a");
+    assert_eq!(Token::Ident("5a".into()).to_css_string(), "\\35 a");
+    assert_eq!(Token::Ident("6a".into()).to_css_string(), "\\36 a");
+    assert_eq!(Token::Ident("7a".into()).to_css_string(), "\\37 a");
+    assert_eq!(Token::Ident("8a".into()).to_css_string(), "\\38 a");
+    assert_eq!(Token::Ident("9a".into()).to_css_string(), "\\39 a");
+
+    // Letter number prefix
+    assert_eq!(Token::Ident("a0b".into()).to_css_string(), "a0b");
+    assert_eq!(Token::Ident("a1b".into()).to_css_string(), "a1b");
+    assert_eq!(Token::Ident("a2b".into()).to_css_string(), "a2b");
+    assert_eq!(Token::Ident("a3b".into()).to_css_string(), "a3b");
+    assert_eq!(Token::Ident("a4b".into()).to_css_string(), "a4b");
+    assert_eq!(Token::Ident("a5b".into()).to_css_string(), "a5b");
+    assert_eq!(Token::Ident("a6b".into()).to_css_string(), "a6b");
+    assert_eq!(Token::Ident("a7b".into()).to_css_string(), "a7b");
+    assert_eq!(Token::Ident("a8b".into()).to_css_string(), "a8b");
+    assert_eq!(Token::Ident("a9b".into()).to_css_string(), "a9b");
+
+    // Dash number prefix
+    assert_eq!(Token::Ident("-0a".into()).to_css_string(), "-\\30 a");
+    assert_eq!(Token::Ident("-1a".into()).to_css_string(), "-\\31 a");
+    assert_eq!(Token::Ident("-2a".into()).to_css_string(), "-\\32 a");
+    assert_eq!(Token::Ident("-3a".into()).to_css_string(), "-\\33 a");
+    assert_eq!(Token::Ident("-4a".into()).to_css_string(), "-\\34 a");
+    assert_eq!(Token::Ident("-5a".into()).to_css_string(), "-\\35 a");
+    assert_eq!(Token::Ident("-6a".into()).to_css_string(), "-\\36 a");
+    assert_eq!(Token::Ident("-7a".into()).to_css_string(), "-\\37 a");
+    assert_eq!(Token::Ident("-8a".into()).to_css_string(), "-\\38 a");
+    assert_eq!(Token::Ident("-9a".into()).to_css_string(), "-\\39 a");
+
+    // Double dash prefix
+    assert_eq!(Token::Ident("--a".into()).to_css_string(), "--a");
+
+    // Various tests
+    assert_eq!(
+        Token::Ident("\x01\x02\x1E\x1F".into()).to_css_string(),
+        "\\1 \\2 \\1e \\1f "
+    );
+    assert_eq!(
+        Token::Ident("\u{0080}\x2D\x5F\u{00A9}".into()).to_css_string(),
+        "\u{0080}\x2D\x5F\u{00A9}"
+    );
+    assert_eq!(Token::Ident("\x7F\u{0080}\u{0081}\u{0082}\u{0083}\u{0084}\u{0085}\u{0086}\u{0087}\u{0088}\u{0089}\
+        \u{008A}\u{008B}\u{008C}\u{008D}\u{008E}\u{008F}\u{0090}\u{0091}\u{0092}\u{0093}\u{0094}\u{0095}\u{0096}\
+        \u{0097}\u{0098}\u{0099}\u{009A}\u{009B}\u{009C}\u{009D}\u{009E}\u{009F}".into()).to_css_string(),
+        "\\7f \u{0080}\u{0081}\u{0082}\u{0083}\u{0084}\u{0085}\u{0086}\u{0087}\u{0088}\u{0089}\u{008A}\u{008B}\u{008C}\
+        \u{008D}\u{008E}\u{008F}\u{0090}\u{0091}\u{0092}\u{0093}\u{0094}\u{0095}\u{0096}\u{0097}\u{0098}\u{0099}\
+        \u{009A}\u{009B}\u{009C}\u{009D}\u{009E}\u{009F}");
+    assert_eq!(
+        Token::Ident("\u{00A0}\u{00A1}\u{00A2}".into()).to_css_string(),
+        "\u{00A0}\u{00A1}\u{00A2}"
+    );
+    assert_eq!(
+        Token::Ident("a0123456789b".into()).to_css_string(),
+        "a0123456789b"
+    );
+    assert_eq!(
+        Token::Ident("abcdefghijklmnopqrstuvwxyz".into()).to_css_string(),
+        "abcdefghijklmnopqrstuvwxyz"
+    );
+    assert_eq!(
+        Token::Ident("ABCDEFGHIJKLMNOPQRSTUVWXYZ".into()).to_css_string(),
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    );
+    assert_eq!(
+        Token::Ident("\x20\x21\x78\x79".into()).to_css_string(),
+        "\\ \\!xy"
+    );
+
+    // astral symbol (U+1D306 TETRAGRAM FOR CENTRE)
+    assert_eq!(
+        Token::Ident("\u{1D306}".into()).to_css_string(),
+        "\u{1D306}"
+    );
+}
+
+trait ToJson {
+    fn to_json(&self) -> Value;
+}
+
+impl<T> ToJson for T
+where
+    T: Clone,
+    Value: From<T>,
+{
+    fn to_json(&self) -> Value {
+        Value::from(self.clone())
+    }
+}
+
+impl ToJson for Color {
+    fn to_json(&self) -> Value {
+        match *self {
+            Color::CurrentColor => "currentcolor".to_json(),
+            Color::Rgba(ref rgba) => {
+                json!([rgba.red, rgba.green, rgba.blue, rgba.alpha])
+            }
+            Color::Hsl(ref c) => json!([c.hue, c.saturation, c.lightness, c.alpha]),
+            Color::Hwb(ref c) => json!([c.hue, c.whiteness, c.blackness, c.alpha]),
+            Color::Lab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]),
+            Color::Lch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]),
+            Color::Oklab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]),
+            Color::Oklch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]),
+            Color::ColorFunction(ref c) => {
+                json!([c.color_space.as_str(), c.c1, c.c2, c.c3, c.alpha])
+            }
+        }
+    }
+}
+
+impl<'a> ToJson for CowRcStr<'a> {
+    fn to_json(&self) -> Value {
+        let s: &str = &*self;
+        s.to_json()
+    }
+}
+
+#[cfg(feature = "bench")]
+const BACKGROUND_IMAGE: &'static str = include_str!("big-data-url.css");
+
+#[cfg(feature = "bench")]
+#[bench]
+fn unquoted_url(b: &mut Bencher) {
+    b.iter(|| {
+        let mut input = ParserInput::new(BACKGROUND_IMAGE);
+        let mut input = Parser::new(&mut input);
+        input.look_for_var_or_env_functions();
+
+        let result = input.try_parse(|input| input.expect_url());
+
+        assert!(result.is_ok());
+
+        input.seen_var_or_env_functions();
+        (result.is_ok(), input.seen_var_or_env_functions())
+    })
+}
+
+#[cfg(feature = "bench")]
+#[bench]
+fn numeric(b: &mut Bencher) {
+    b.iter(|| {
+        for _ in 0..1000000 {
+            let mut input = ParserInput::new("10px");
+            let mut input = Parser::new(&mut input);
+            let _ = test::black_box(input.next());
+        }
+    })
+}
+
+struct JsonParser;
+
+#[test]
+fn no_stack_overflow_multiple_nested_blocks() {
+    let mut input: String = "{{".into();
+    for _ in 0..20 {
+        let dup = input.clone();
+        input.push_str(&dup);
+    }
+    let mut input = ParserInput::new(&input);
+    let mut input = Parser::new(&mut input);
+    while let Ok(..) = input.next() {}
+}
+
+impl<'i> DeclarationParser<'i> for JsonParser {
+    type Declaration = Value;
+    type Error = ();
+
+    fn parse_value<'t>(
+        &mut self,
+        name: CowRcStr<'i>,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Value, ParseError<'i, ()>> {
+        let mut value = vec![];
+        let mut important = false;
+        loop {
+            let start = input.state();
+            if let Ok(mut token) = input.next_including_whitespace().map(|t| t.clone()) {
+                // 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);
+                    if parse_important(input).is_ok() {
+                        if input.is_exhausted() {
+                            important = true;
+                            break;
+                        }
+                    }
+                    input.reset(&start);
+                    token = input.next_including_whitespace().unwrap().clone();
+                }
+                value.push(one_component_value_to_json(token, input));
+            } else {
+                break;
+            }
+        }
+        Ok(JArray!["declaration", name, value, important,])
+    }
+}
+
+impl<'i> AtRuleParser<'i> for JsonParser {
+    type Prelude = Vec<Value>;
+    type AtRule = Value;
+    type Error = ();
+
+    fn parse_prelude<'t>(
+        &mut self,
+        name: CowRcStr<'i>,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Vec<Value>, ParseError<'i, ()>> {
+        let prelude = vec![
+            "at-rule".to_json(),
+            name.to_json(),
+            Value::Array(component_values_to_json(input)),
+        ];
+        match_ignore_ascii_case! { &*name,
+            "charset" => {
+                Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name.clone()).into()))
+            },
+            _ => Ok(prelude),
+        }
+    }
+
+    fn rule_without_block(
+        &mut self,
+        mut prelude: Vec<Value>,
+        _: &ParserState,
+    ) -> Result<Value, ()> {
+        prelude.push(Value::Null);
+        Ok(Value::Array(prelude))
+    }
+
+    fn parse_block<'t>(
+        &mut self,
+        mut prelude: Vec<Value>,
+        _: &ParserState,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Value, ParseError<'i, ()>> {
+        prelude.push(Value::Array(component_values_to_json(input)));
+        Ok(Value::Array(prelude))
+    }
+}
+
+impl<'i> QualifiedRuleParser<'i> for JsonParser {
+    type Prelude = Vec<Value>;
+    type QualifiedRule = Value;
+    type Error = ();
+
+    fn parse_prelude<'t>(
+        &mut self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Vec<Value>, ParseError<'i, ()>> {
+        Ok(component_values_to_json(input))
+    }
+
+    fn parse_block<'t>(
+        &mut self,
+        prelude: Vec<Value>,
+        _: &ParserState,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Value, ParseError<'i, ()>> {
+        Ok(JArray![
+            "qualified rule",
+            prelude,
+            component_values_to_json(input),
+        ])
+    }
+}
+
+impl<'i> RuleBodyItemParser<'i, Value, ()> for JsonParser {
+    fn parse_qualified(&self) -> bool {
+        true
+    }
+    fn parse_declarations(&self) -> bool {
+        true
+    }
+}
+
+fn component_values_to_json(input: &mut Parser) -> Vec<Value> {
+    let mut values = vec![];
+    while let Ok(token) = input.next_including_whitespace().map(|t| t.clone()) {
+        values.push(one_component_value_to_json(token, input));
+    }
+    values
+}
+
+fn one_component_value_to_json(token: Token, input: &mut Parser) -> Value {
+    fn numeric(value: f32, int_value: Option<i32>, has_sign: bool) -> Vec<Value> {
+        vec![
+            Token::Number {
+                value: value,
+                int_value: int_value,
+                has_sign: has_sign,
+            }
+            .to_css_string()
+            .to_json(),
+            match int_value {
+                Some(i) => i.to_json(),
+                None => value.to_json(),
+            },
+            match int_value {
+                Some(_) => "integer",
+                None => "number",
+            }
+            .to_json(),
+        ]
+    }
+
+    fn nested(input: &mut Parser) -> Vec<Value> {
+        let result: Result<_, ParseError<()>> =
+            input.parse_nested_block(|input| Ok(component_values_to_json(input)));
+        result.unwrap()
+    }
+
+    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::UnquotedUrl(value) => JArray!["url", value],
+        Token::Delim('\\') => "\\".to_json(),
+        Token::Delim(value) => value.to_string().to_json(),
+
+        Token::Number {
+            value,
+            int_value,
+            has_sign,
+        } => Value::Array({
+            let mut v = vec!["number".to_json()];
+            v.extend(numeric(value, int_value, has_sign));
+            v
+        }),
+        Token::Percentage {
+            unit_value,
+            int_value,
+            has_sign,
+        } => Value::Array({
+            let mut v = vec!["percentage".to_json()];
+            v.extend(numeric(unit_value * 100., int_value, has_sign));
+            v
+        }),
+        Token::Dimension {
+            value,
+            int_value,
+            has_sign,
+            unit,
+        } => Value::Array({
+            let mut v = vec!["dimension".to_json()];
+            v.extend(numeric(value, int_value, has_sign));
+            v.push(unit.to_json());
+            v
+        }),
+
+        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::CDO => "<!--".to_json(),
+        Token::CDC => "-->".to_json(),
+
+        Token::Function(name) => Value::Array({
+            let mut v = vec!["function".to_json(), name.to_json()];
+            v.extend(nested(input));
+            v
+        }),
+        Token::ParenthesisBlock => Value::Array({
+            let mut v = vec!["()".to_json()];
+            v.extend(nested(input));
+            v
+        }),
+        Token::SquareBracketBlock => Value::Array({
+            let mut v = vec!["[]".to_json()];
+            v.extend(nested(input));
+            v
+        }),
+        Token::CurlyBracketBlock => Value::Array({
+            let mut v = vec!["{}".to_json()];
+            v.extend(nested(input));
+            v
+        }),
+        Token::BadUrl(_) => JArray!["error", "bad-url"],
+        Token::BadString(_) => JArray!["error", "bad-string"],
+        Token::CloseParenthesis => JArray!["error", ")"],
+        Token::CloseSquareBracket => JArray!["error", "]"],
+        Token::CloseCurlyBracket => JArray!["error", "}"],
+    }
+}
+
+/// A previous version of procedural-masquerade had a bug where it
+/// would normalize consecutive whitespace to a single space,
+/// including in string literals.
+#[test]
+fn procedural_masquerade_whitespace() {
+    ascii_case_insensitive_phf_map! {
+        map -> () = {
+            "  \t\n" => ()
+        }
+    }
+    assert_eq!(map("  \t\n"), Some(&()));
+    assert_eq!(map(" "), None);
+
+    match_ignore_ascii_case! { "  \t\n",
+        " " => panic!("1"),
+        "  \t\n" => {},
+        _ => panic!("2"),
+    }
+
+    match_ignore_ascii_case! { " ",
+        "  \t\n" => panic!("3"),
+        " " => {},
+        _ => panic!("4"),
+    }
+}
+
+#[test]
+fn parse_until_before_stops_at_delimiter_or_end_of_input() {
+    // For all j and k, inputs[i].1[j] should parse the same as inputs[i].1[k]
+    // when we use delimiters inputs[i].0.
+    let inputs = vec![
+        (
+            Delimiter::Bang | Delimiter::Semicolon,
+            // Note that the ';extra' is fine, because the ';' acts the same as
+            // the end of input.
+            vec!["token stream;extra", "token stream!", "token stream"],
+        ),
+        (Delimiter::Bang | Delimiter::Semicolon, vec![";", "!", ""]),
+    ];
+    for equivalent in inputs {
+        for (j, x) in equivalent.1.iter().enumerate() {
+            for y in equivalent.1[j + 1..].iter() {
+                let mut ix = ParserInput::new(x);
+                let mut ix = Parser::new(&mut ix);
+
+                let mut iy = ParserInput::new(y);
+                let mut iy = Parser::new(&mut iy);
+
+                let _ = ix.parse_until_before::<_, _, ()>(equivalent.0, |ix| {
+                    iy.parse_until_before::<_, _, ()>(equivalent.0, |iy| {
+                        loop {
+                            let ox = ix.next();
+                            let oy = iy.next();
+                            assert_eq!(ox, oy);
+                            if let Err(_) = ox {
+                                break;
+                            }
+                        }
+                        Ok(())
+                    })
+                });
+            }
+        }
+    }
+}
+
+#[test]
+fn parser_maintains_current_line() {
+    let mut input = ParserInput::new("ident ident;\nident ident ident;\nident");
+    let mut parser = Parser::new(&mut input);
+    assert_eq!(parser.current_line(), "ident ident;");
+    assert_eq!(parser.next(), Ok(&Token::Ident("ident".into())));
+    assert_eq!(parser.next(), Ok(&Token::Ident("ident".into())));
+    assert_eq!(parser.next(), Ok(&Token::Semicolon));
+
+    assert_eq!(parser.next(), Ok(&Token::Ident("ident".into())));
+    assert_eq!(parser.current_line(), "ident ident ident;");
+    assert_eq!(parser.next(), Ok(&Token::Ident("ident".into())));
+    assert_eq!(parser.next(), Ok(&Token::Ident("ident".into())));
+    assert_eq!(parser.next(), Ok(&Token::Semicolon));
+
+    assert_eq!(parser.next(), Ok(&Token::Ident("ident".into())));
+    assert_eq!(parser.current_line(), "ident");
+}
+
+#[test]
+fn parser_with_line_number_offset() {
+    let mut input = ParserInput::new_with_line_number_offset("ident\nident", 72);
+    let mut parser = Parser::new(&mut input);
+    assert_eq!(
+        parser.current_source_location(),
+        SourceLocation {
+            line: 72,
+            column: 1
+        }
+    );
+    assert_eq!(
+        parser.next_including_whitespace_and_comments(),
+        Ok(&Token::Ident("ident".into()))
+    );
+    assert_eq!(
+        parser.current_source_location(),
+        SourceLocation {
+            line: 72,
+            column: 6
+        }
+    );
+    assert_eq!(
+        parser.next_including_whitespace_and_comments(),
+        Ok(&Token::WhiteSpace("\n".into()))
+    );
+    assert_eq!(
+        parser.current_source_location(),
+        SourceLocation {
+            line: 73,
+            column: 1
+        }
+    );
+    assert_eq!(
+        parser.next_including_whitespace_and_comments(),
+        Ok(&Token::Ident("ident".into()))
+    );
+    assert_eq!(
+        parser.current_source_location(),
+        SourceLocation {
+            line: 73,
+            column: 6
+        }
+    );
+}
+
+#[test]
+fn cdc_regression_test() {
+    let mut input = ParserInput::new("-->x");
+    let mut parser = Parser::new(&mut input);
+    parser.skip_cdc_and_cdo();
+    assert_eq!(parser.next(), Ok(&Token::Ident("x".into())));
+    assert_eq!(
+        parser.next(),
+        Err(BasicParseError {
+            kind: BasicParseErrorKind::EndOfInput,
+            location: SourceLocation { line: 0, column: 5 }
+        })
+    );
+}
+
+#[test]
+fn parse_entirely_reports_first_error() {
+    #[derive(PartialEq, Debug)]
+    enum E {
+        Foo,
+    }
+    let mut input = ParserInput::new("ident");
+    let mut parser = Parser::new(&mut input);
+    let result: Result<(), _> = parser.parse_entirely(|p| Err(p.new_custom_error(E::Foo)));
+    assert_eq!(
+        result,
+        Err(ParseError {
+            kind: ParseErrorKind::Custom(E::Foo),
+            location: SourceLocation { line: 0, column: 1 },
+        })
+    );
+}
+
+#[test]
+fn parse_sourcemapping_comments() {
+    let tests = vec![
+        ("/*# sourceMappingURL=here*/", Some("here")),
+        ("/*# sourceMappingURL=here  */", Some("here")),
+        ("/*@ sourceMappingURL=here*/", Some("here")),
+        (
+            "/*@ sourceMappingURL=there*/ /*# sourceMappingURL=here*/",
+            Some("here"),
+        ),
+        ("/*# sourceMappingURL=here there  */", Some("here")),
+        ("/*# sourceMappingURL=  here  */", Some("")),
+        ("/*# sourceMappingURL=*/", Some("")),
+        ("/*# sourceMappingUR=here  */", None),
+        ("/*! sourceMappingURL=here  */", None),
+        ("/*# sourceMappingURL = here  */", None),
+        ("/*   # sourceMappingURL=here   */", None),
+    ];
+
+    for test in tests {
+        let mut input = ParserInput::new(test.0);
+        let mut parser = Parser::new(&mut input);
+        while let Ok(_) = parser.next_including_whitespace() {}
+        assert_eq!(parser.current_source_map_url(), test.1);
+    }
+}
+
+#[test]
+fn parse_sourceurl_comments() {
+    let tests = vec![
+        ("/*# sourceURL=here*/", Some("here")),
+        ("/*# sourceURL=here  */", Some("here")),
+        ("/*@ sourceURL=here*/", Some("here")),
+        ("/*@ sourceURL=there*/ /*# sourceURL=here*/", Some("here")),
+        ("/*# sourceURL=here there  */", Some("here")),
+        ("/*# sourceURL=  here  */", Some("")),
+        ("/*# sourceURL=*/", Some("")),
+        ("/*# sourceMappingUR=here  */", None),
+        ("/*! sourceURL=here  */", None),
+        ("/*# sourceURL = here  */", None),
+        ("/*   # sourceURL=here   */", None),
+    ];
+
+    for test in tests {
+        let mut input = ParserInput::new(test.0);
+        let mut parser = Parser::new(&mut input);
+        while let Ok(_) = parser.next_including_whitespace() {}
+        assert_eq!(parser.current_source_url(), test.1);
+    }
+}
+
+#[test]
+fn roundtrip_percentage_token() {
+    fn test_roundtrip(value: &str) {
+        let mut input = ParserInput::new(value);
+        let mut parser = Parser::new(&mut input);
+        let token = parser.next().unwrap();
+        assert_eq!(token.to_css_string(), value);
+    }
+    // Test simple number serialization
+    for i in 0..101 {
+        test_roundtrip(&format!("{}%", i));
+        for j in 0..10 {
+            if j != 0 {
+                test_roundtrip(&format!("{}.{}%", i, j));
+            }
+            for k in 1..10 {
+                test_roundtrip(&format!("{}.{}{}%", i, j, k));
+            }
+        }
+    }
+}
+
+#[test]
+fn utf16_columns() {
+    // This particular test serves two purposes.  First, it checks
+    // that the column number computations are correct.  Second, it
+    // checks that tokenizer code paths correctly differentiate
+    // between the different UTF-8 encoding bytes.  In particular
+    // different leader bytes and continuation bytes are treated
+    // differently, so we make sure to include all lengths in the
+    // tests, using the string "QΡ✈🆒".  Also, remember that because
+    // the column is in units of UTF-16, the 4-byte sequence results
+    // in two columns.
+    let tests = vec![
+        ("", 1),
+        ("ascii", 6),
+        ("/*QΡ✈🆒*/", 10),
+        ("'QΡ✈🆒*'", 9),
+        ("\"\\\"'QΡ✈🆒*'", 12),
+        ("\\Q\\Ρ\\✈\\🆒", 10),
+        ("QΡ✈🆒", 6),
+        ("QΡ✈🆒\\Q\\Ρ\\✈\\🆒", 15),
+        ("newline\r\nQΡ✈🆒", 6),
+        ("url(QΡ✈🆒\\Q\\Ρ\\✈\\🆒)", 20),
+        ("url(QΡ✈🆒)", 11),
+        ("url(\r\nQΡ✈🆒\\Q\\Ρ\\✈\\🆒)", 16),
+        ("url(\r\nQΡ✈🆒\\Q\\Ρ\\✈\\🆒", 15),
+        ("url(\r\nQΡ✈🆒\\Q\\Ρ\\✈\\🆒 x", 17),
+        ("QΡ✈🆒()", 8),
+        // Test that under/over-flow of current_line_start_position is
+        // handled properly; see the special case in consume_4byte_intro.
+        ("🆒", 3),
+    ];
+
+    for test in tests {
+        let mut input = ParserInput::new(test.0);
+        let mut parser = Parser::new(&mut input);
+
+        // Read all tokens.
+        loop {
+            match parser.next() {
+                Err(BasicParseError {
+                    kind: BasicParseErrorKind::EndOfInput,
+                    ..
+                }) => {
+                    break;
+                }
+                Err(_) => {
+                    assert!(false);
+                }
+                Ok(_) => {}
+            };
+        }
+
+        // Check the resulting column.
+        assert_eq!(parser.current_source_location().column, test.1);
+    }
+}
+
+#[test]
+fn servo_define_css_keyword_enum() {
+    macro_rules! define_css_keyword_enum {
+        (pub enum $name:ident { $($variant:ident = $css:pat,)+ }) => {
+            #[derive(PartialEq, Debug)]
+            pub enum $name {
+                $($variant),+
+            }
+
+            impl $name {
+                pub fn from_ident(ident: &str) -> Result<$name, ()> {
+                    match_ignore_ascii_case! { ident,
+                        $($css => Ok($name::$variant),)+
+                        _ => Err(())
+                    }
+                }
+            }
+        }
+    }
+    define_css_keyword_enum! {
+        pub enum UserZoom {
+            Zoom = "zoom",
+            Fixed = "fixed",
+        }
+    }
+
+    assert_eq!(UserZoom::from_ident("fixed"), Ok(UserZoom::Fixed));
+}
+
+#[test]
+fn generic_parser() {
+    #[derive(Debug, PartialEq)]
+    enum OutputType {
+        CurrentColor,
+        Rgba(Option<u8>, Option<u8>, Option<u8>, Option<f32>),
+        Hsl(Option<f32>, Option<f32>, Option<f32>, Option<f32>),
+        Hwb(Option<f32>, Option<f32>, Option<f32>, Option<f32>),
+        Lab(Option<f32>, Option<f32>, Option<f32>, Option<f32>),
+        Lch(Option<f32>, Option<f32>, Option<f32>, Option<f32>),
+        Oklab(Option<f32>, Option<f32>, Option<f32>, Option<f32>),
+        Oklch(Option<f32>, Option<f32>, Option<f32>, Option<f32>),
+        ColorFunction(
+            PredefinedColorSpace,
+            Option<f32>,
+            Option<f32>,
+            Option<f32>,
+            Option<f32>,
+        ),
+    }
+
+    impl FromParsedColor for OutputType {
+        fn from_current_color() -> Self {
+            OutputType::CurrentColor
+        }
+
+        fn from_rgba(
+            red: Option<u8>,
+            green: Option<u8>,
+            blue: Option<u8>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Rgba(red, green, blue, alpha)
+        }
+
+        fn from_hsl(
+            hue: Option<f32>,
+            saturation: Option<f32>,
+            lightness: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Hsl(hue, saturation, lightness, alpha)
+        }
+
+        fn from_hwb(
+            hue: Option<f32>,
+            blackness: Option<f32>,
+            whiteness: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Hwb(hue, blackness, whiteness, alpha)
+        }
+
+        fn from_lab(
+            lightness: Option<f32>,
+            a: Option<f32>,
+            b: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Lab(lightness, a, b, alpha)
+        }
+
+        fn from_lch(
+            lightness: Option<f32>,
+            chroma: Option<f32>,
+            hue: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Lch(lightness, chroma, hue, alpha)
+        }
+
+        fn from_oklab(
+            lightness: Option<f32>,
+            a: Option<f32>,
+            b: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Oklab(lightness, a, b, alpha)
+        }
+
+        fn from_oklch(
+            lightness: Option<f32>,
+            chroma: Option<f32>,
+            hue: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::Oklch(lightness, chroma, hue, alpha)
+        }
+
+        fn from_color_function(
+            color_space: PredefinedColorSpace,
+            c1: Option<f32>,
+            c2: Option<f32>,
+            c3: Option<f32>,
+            alpha: Option<f32>,
+        ) -> Self {
+            OutputType::ColorFunction(color_space, c1, c2, c3, alpha)
+        }
+    }
+
+    struct TestColorParser;
+    impl<'i> ColorParser<'i> for TestColorParser {
+        type Output = OutputType;
+        type Error = ();
+    }
+
+    #[rustfmt::skip]
+    const TESTS: &[(&str, OutputType)] = &[
+        ("currentColor",                OutputType::CurrentColor),
+        ("rgb(1, 2, 3)",                OutputType::Rgba(Some(1), Some(2), Some(3), Some(1.0))),
+        ("rgba(1, 2, 3, 0.4)",          OutputType::Rgba(Some(1), Some(2), Some(3), Some(0.4))),
+        ("rgb(none none none / none)",  OutputType::Rgba(None, None, None, None)),
+        ("rgb(1 none 3 / none)",        OutputType::Rgba(Some(1), None, Some(3), None)),
+
+        ("hsla(45deg, 20%, 30%, 0.4)",  OutputType::Hsl(Some(45.0), Some(0.2), Some(0.3), Some(0.4))),
+        ("hsl(45deg none none)",        OutputType::Hsl(Some(45.0), None, None, Some(1.0))),
+        ("hsl(none 10% none / none)",   OutputType::Hsl(None, Some(0.1), None, None)),
+        ("hsl(120 100.0% 50.0%)",       OutputType::Hsl(Some(120.0), Some(1.0), Some(0.5), Some(1.0))),
+
+        ("hwb(45deg 20% 30% / 0.4)",    OutputType::Hwb(Some(45.0), Some(0.2), Some(0.3), Some(0.4))),
+
+        ("lab(100 20 30 / 0.4)",        OutputType::Lab(Some(100.0), Some(20.0), Some(30.0), Some(0.4))),
+        ("lch(100 20 30 / 0.4)",        OutputType::Lch(Some(100.0), Some(20.0), Some(30.0), Some(0.4))),
+
+        ("oklab(100 20 30 / 0.4)",      OutputType::Oklab(Some(100.0), Some(20.0), Some(30.0), Some(0.4))),
+        ("oklch(100 20 30 / 0.4)",      OutputType::Oklch(Some(100.0), Some(20.0), Some(30.0), Some(0.4))),
+
+        ("color(srgb 0.1 0.2 0.3 / 0.4)",           OutputType::ColorFunction(PredefinedColorSpace::Srgb, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(srgb none none none)",              OutputType::ColorFunction(PredefinedColorSpace::Srgb, None, None, None, Some(1.0))),
+        ("color(srgb none none none / none)",       OutputType::ColorFunction(PredefinedColorSpace::Srgb, None, None, None, None)),
+        ("color(srgb-linear 0.1 0.2 0.3 / 0.4)",    OutputType::ColorFunction(PredefinedColorSpace::SrgbLinear, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(display-p3 0.1 0.2 0.3 / 0.4)",     OutputType::ColorFunction(PredefinedColorSpace::DisplayP3, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(a98-rgb 0.1 0.2 0.3 / 0.4)",        OutputType::ColorFunction(PredefinedColorSpace::A98Rgb, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(prophoto-rgb 0.1 0.2 0.3 / 0.4)",   OutputType::ColorFunction(PredefinedColorSpace::ProphotoRgb, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(rec2020 0.1 0.2 0.3 / 0.4)",        OutputType::ColorFunction(PredefinedColorSpace::Rec2020, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(xyz-d50 0.1 0.2 0.3 / 0.4)",        OutputType::ColorFunction(PredefinedColorSpace::XyzD50, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+        ("color(xyz-d65 0.1 0.2 0.3 / 0.4)",        OutputType::ColorFunction(PredefinedColorSpace::XyzD65, Some(0.1), Some(0.2), Some(0.3), Some(0.4))),
+    ];
+
+    for (input, expected) in TESTS {
+        let mut input = ParserInput::new(*input);
+        let mut input = Parser::new(&mut input);
+
+        let actual: OutputType = parse_color_with(&TestColorParser, &mut input).unwrap();
+        assert_eq!(actual, *expected);
+    }
+}
diff --git a/third_party/rust/cssparser/src/tokenizer.rs b/third_party/rust/cssparser/src/tokenizer.rs
new file mode 100644
index 0000000000..4cc6c178bf
--- /dev/null
+++ b/third_party/rust/cssparser/src/tokenizer.rs
@@ -0,0 +1,1405 @@
+/* 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/. */
+
+// https://drafts.csswg.org/css-syntax/#tokenization
+
+use self::Token::*;
+use crate::cow_rc_str::CowRcStr;
+use crate::parser::ParserState;
+use std::char;
+use std::ops::Range;
+
+#[cfg(not(feature = "dummy_match_byte"))]
+use cssparser_macros::match_byte;
+
+#[cfg(feature = "dummy_match_byte")]
+macro_rules! match_byte {
+    ($value:expr, $($rest:tt)* ) => {
+        match $value {
+            $(
+                $rest
+            )+
+        }
+    };
+}
+
+/// One of the pieces the CSS input is broken into.
+///
+/// Some components use `Cow` in order to borrow from the original input string
+/// and avoid allocating/copying when possible.
+#[derive(PartialEq, Debug, Clone)]
+pub enum Token<'a> {
+    /// A [`<ident-token>`](https://drafts.csswg.org/css-syntax/#ident-token-diagram)
+    Ident(CowRcStr<'a>),
+
+    /// A [`<at-keyword-token>`](https://drafts.csswg.org/css-syntax/#at-keyword-token-diagram)
+    ///
+    /// The value does not include the `@` marker.
+    AtKeyword(CowRcStr<'a>),
+
+    /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "unrestricted"
+    ///
+    /// The value does not include the `#` marker.
+    Hash(CowRcStr<'a>),
+
+    /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "id"
+    ///
+    /// The value does not include the `#` marker.
+    IDHash(CowRcStr<'a>), // Hash that is a valid ID selector.
+
+    /// A [`<string-token>`](https://drafts.csswg.org/css-syntax/#string-token-diagram)
+    ///
+    /// The value does not include the quotes.
+    QuotedString(CowRcStr<'a>),
+
+    /// A [`<url-token>`](https://drafts.csswg.org/css-syntax/#url-token-diagram)
+    ///
+    /// The value does not include the `url(` `)` markers.  Note that `url( <string-token> )` is represented by a
+    /// `Function` token.
+    UnquotedUrl(CowRcStr<'a>),
+
+    /// A `<delim-token>`
+    Delim(char),
+
+    /// A [`<number-token>`](https://drafts.csswg.org/css-syntax/#number-token-diagram)
+    Number {
+        /// Whether the number had a `+` or `-` sign.
+        ///
+        /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.)
+        has_sign: bool,
+
+        /// The value as a float
+        value: f32,
+
+        /// If the origin source did not include a fractional part, the value as an integer.
+        int_value: Option<i32>,
+    },
+
+    /// A [`<percentage-token>`](https://drafts.csswg.org/css-syntax/#percentage-token-diagram)
+    Percentage {
+        /// Whether the number had a `+` or `-` sign.
+        has_sign: bool,
+
+        /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
+        unit_value: f32,
+
+        /// If the origin source did not include a fractional part, the value as an integer.
+        /// It is **not** divided by 100.
+        int_value: Option<i32>,
+    },
+
+    /// A [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram)
+    Dimension {
+        /// Whether the number had a `+` or `-` sign.
+        ///
+        /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.)
+        has_sign: bool,
+
+        /// The value as a float
+        value: f32,
+
+        /// If the origin source did not include a fractional part, the value as an integer.
+        int_value: Option<i32>,
+
+        /// The unit, e.g. "px" in `12px`
+        unit: CowRcStr<'a>,
+    },
+
+    /// A [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram)
+    WhiteSpace(&'a str),
+
+    /// A comment.
+    ///
+    /// The CSS Syntax spec does not generate tokens for comments,
+    /// But we do, because we can (borrowed &str makes it cheap).
+    ///
+    /// The value does not include the `/*` `*/` markers.
+    Comment(&'a str),
+
+    /// A `:` `<colon-token>`
+    Colon, // :
+
+    /// A `;` `<semicolon-token>`
+    Semicolon, // ;
+
+    /// A `,` `<comma-token>`
+    Comma, // ,
+
+    /// A `~=` [`<include-match-token>`](https://drafts.csswg.org/css-syntax/#include-match-token-diagram)
+    IncludeMatch,
+
+    /// A `|=` [`<dash-match-token>`](https://drafts.csswg.org/css-syntax/#dash-match-token-diagram)
+    DashMatch,
+
+    /// A `^=` [`<prefix-match-token>`](https://drafts.csswg.org/css-syntax/#prefix-match-token-diagram)
+    PrefixMatch,
+
+    /// A `$=` [`<suffix-match-token>`](https://drafts.csswg.org/css-syntax/#suffix-match-token-diagram)
+    SuffixMatch,
+
+    /// A `*=` [`<substring-match-token>`](https://drafts.csswg.org/css-syntax/#substring-match-token-diagram)
+    SubstringMatch,
+
+    /// A `<!--` [`<CDO-token>`](https://drafts.csswg.org/css-syntax/#CDO-token-diagram)
+    CDO,
+
+    /// A `-->` [`<CDC-token>`](https://drafts.csswg.org/css-syntax/#CDC-token-diagram)
+    CDC,
+
+    /// A [`<function-token>`](https://drafts.csswg.org/css-syntax/#function-token-diagram)
+    ///
+    /// The value (name) does not include the `(` marker.
+    Function(CowRcStr<'a>),
+
+    /// A `<(-token>`
+    ParenthesisBlock,
+
+    /// A `<[-token>`
+    SquareBracketBlock,
+
+    /// A `<{-token>`
+    CurlyBracketBlock,
+
+    /// A `<bad-url-token>`
+    ///
+    /// This token always indicates a parse error.
+    BadUrl(CowRcStr<'a>),
+
+    /// A `<bad-string-token>`
+    ///
+    /// This token always indicates a parse error.
+    BadString(CowRcStr<'a>),
+
+    /// A `<)-token>`
+    ///
+    /// When obtained from one of the `Parser::next*` methods,
+    /// this token is always unmatched and indicates a parse error.
+    CloseParenthesis,
+
+    /// A `<]-token>`
+    ///
+    /// When obtained from one of the `Parser::next*` methods,
+    /// this token is always unmatched and indicates a parse error.
+    CloseSquareBracket,
+
+    /// A `<}-token>`
+    ///
+    /// When obtained from one of the `Parser::next*` methods,
+    /// this token is always unmatched and indicates a parse error.
+    CloseCurlyBracket,
+}
+
+impl<'a> Token<'a> {
+    /// Return whether this token represents a parse error.
+    ///
+    /// `BadUrl` and `BadString` are tokenizer-level parse errors.
+    ///
+    /// `CloseParenthesis`, `CloseSquareBracket`, and `CloseCurlyBracket` are *unmatched*
+    /// and therefore parse errors when returned by one of the `Parser::next*` methods.
+    pub fn is_parse_error(&self) -> bool {
+        matches!(
+            *self,
+            BadUrl(_) | BadString(_) | CloseParenthesis | CloseSquareBracket | CloseCurlyBracket
+        )
+    }
+}
+
+#[derive(Clone)]
+pub struct Tokenizer<'a> {
+    input: &'a str,
+    /// Counted in bytes, not code points. From 0.
+    position: usize,
+    /// The position at the start of the current line; but adjusted to
+    /// ensure that computing the column will give the result in units
+    /// of UTF-16 characters.
+    current_line_start_position: usize,
+    current_line_number: u32,
+    var_or_env_functions: SeenStatus,
+    source_map_url: Option<&'a str>,
+    source_url: Option<&'a str>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+enum SeenStatus {
+    DontCare,
+    LookingForThem,
+    SeenAtLeastOne,
+}
+
+impl<'a> Tokenizer<'a> {
+    #[inline]
+    pub fn new(input: &str) -> Tokenizer {
+        Tokenizer::with_first_line_number(input, 0)
+    }
+
+    #[inline]
+    pub fn with_first_line_number(input: &str, first_line_number: u32) -> Tokenizer {
+        Tokenizer {
+            input,
+            position: 0,
+            current_line_start_position: 0,
+            current_line_number: first_line_number,
+            var_or_env_functions: SeenStatus::DontCare,
+            source_map_url: None,
+            source_url: None,
+        }
+    }
+
+    #[inline]
+    pub fn look_for_var_or_env_functions(&mut self) {
+        self.var_or_env_functions = SeenStatus::LookingForThem;
+    }
+
+    #[inline]
+    pub fn seen_var_or_env_functions(&mut self) -> bool {
+        let seen = self.var_or_env_functions == SeenStatus::SeenAtLeastOne;
+        self.var_or_env_functions = SeenStatus::DontCare;
+        seen
+    }
+
+    #[inline]
+    pub fn see_function(&mut self, name: &str) {
+        if self.var_or_env_functions == SeenStatus::LookingForThem {
+            if name.eq_ignore_ascii_case("var") || name.eq_ignore_ascii_case("env") {
+                self.var_or_env_functions = SeenStatus::SeenAtLeastOne;
+            }
+        }
+    }
+
+    #[inline]
+    pub fn next(&mut self) -> Result<Token<'a>, ()> {
+        next_token(self)
+    }
+
+    #[inline]
+    pub fn position(&self) -> SourcePosition {
+        SourcePosition(self.position)
+    }
+
+    #[inline]
+    pub fn current_source_location(&self) -> SourceLocation {
+        SourceLocation {
+            line: self.current_line_number,
+            column: (self.position - self.current_line_start_position + 1) as u32,
+        }
+    }
+
+    #[inline]
+    pub fn current_source_map_url(&self) -> Option<&'a str> {
+        self.source_map_url
+    }
+
+    #[inline]
+    pub fn current_source_url(&self) -> Option<&'a str> {
+        self.source_url
+    }
+
+    #[inline]
+    pub fn state(&self) -> ParserState {
+        ParserState {
+            position: self.position,
+            current_line_start_position: self.current_line_start_position,
+            current_line_number: self.current_line_number,
+            at_start_of: None,
+        }
+    }
+
+    #[inline]
+    pub fn reset(&mut self, state: &ParserState) {
+        self.position = state.position;
+        self.current_line_start_position = state.current_line_start_position;
+        self.current_line_number = state.current_line_number;
+    }
+
+    #[inline]
+    pub fn slice_from(&self, start_pos: SourcePosition) -> &'a str {
+        &self.input[start_pos.0..self.position]
+    }
+
+    #[inline]
+    pub fn slice(&self, range: Range<SourcePosition>) -> &'a str {
+        &self.input[range.start.0..range.end.0]
+    }
+
+    pub fn current_source_line(&self) -> &'a str {
+        let current = self.position;
+        let start = self.input[0..current]
+            .rfind(|c| matches!(c, '\r' | '\n' | '\x0C'))
+            .map_or(0, |start| start + 1);
+        let end = self.input[current..]
+            .find(|c| matches!(c, '\r' | '\n' | '\x0C'))
+            .map_or(self.input.len(), |end| current + end);
+        &self.input[start..end]
+    }
+
+    #[inline]
+    pub fn next_byte(&self) -> Option<u8> {
+        if self.is_eof() {
+            None
+        } else {
+            Some(self.input.as_bytes()[self.position])
+        }
+    }
+
+    // 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: usize) -> bool {
+        self.position + n < self.input.len()
+    }
+
+    // Advance over N bytes in the input.  This function can advance
+    // over ASCII bytes (excluding newlines), or UTF-8 sequence
+    // leaders (excluding leaders for 4-byte sequences).
+    #[inline]
+    pub fn advance(&mut self, n: usize) {
+        if cfg!(debug_assertions) {
+            // Each byte must either be an ASCII byte or a sequence
+            // leader, but not a 4-byte leader; also newlines are
+            // rejected.
+            for i in 0..n {
+                let b = self.byte_at(i);
+                debug_assert!(b.is_ascii() || (b & 0xF0 != 0xF0 && b & 0xC0 != 0x80));
+                debug_assert!(b != b'\r' && b != b'\n' && b != b'\x0C');
+            }
+        }
+        self.position += n
+    }
+
+    // Assumes non-EOF
+    #[inline]
+    fn next_byte_unchecked(&self) -> u8 {
+        self.byte_at(0)
+    }
+
+    #[inline]
+    fn byte_at(&self, offset: usize) -> u8 {
+        self.input.as_bytes()[self.position + offset]
+    }
+
+    // Advance over a single byte; the byte must be a UTF-8 sequence
+    // leader for a 4-byte sequence.
+    #[inline]
+    fn consume_4byte_intro(&mut self) {
+        debug_assert!(self.next_byte_unchecked() & 0xF0 == 0xF0);
+        // This takes two UTF-16 characters to represent, so we
+        // actually have an undercount.
+        self.current_line_start_position = self.current_line_start_position.wrapping_sub(1);
+        self.position += 1;
+    }
+
+    // Advance over a single byte; the byte must be a UTF-8
+    // continuation byte.
+    #[inline]
+    fn consume_continuation_byte(&mut self) {
+        debug_assert!(self.next_byte_unchecked() & 0xC0 == 0x80);
+        // Continuation bytes contribute to column overcount.  Note
+        // that due to the special case for the 4-byte sequence intro,
+        // we must use wrapping add here.
+        self.current_line_start_position = self.current_line_start_position.wrapping_add(1);
+        self.position += 1;
+    }
+
+    // Advance over any kind of byte, excluding newlines.
+    #[inline(never)]
+    fn consume_known_byte(&mut self, byte: u8) {
+        debug_assert!(byte != b'\r' && byte != b'\n' && byte != b'\x0C');
+        self.position += 1;
+        // Continuation bytes contribute to column overcount.
+        if byte & 0xF0 == 0xF0 {
+            // This takes two UTF-16 characters to represent, so we
+            // actually have an undercount.
+            self.current_line_start_position = self.current_line_start_position.wrapping_sub(1);
+        } else if byte & 0xC0 == 0x80 {
+            // Note that due to the special case for the 4-byte
+            // sequence intro, we must use wrapping add here.
+            self.current_line_start_position = self.current_line_start_position.wrapping_add(1);
+        }
+    }
+
+    #[inline]
+    fn next_char(&self) -> char {
+        self.input[self.position..].chars().next().unwrap()
+    }
+
+    // Given that a newline has been seen, advance over the newline
+    // and update the state.
+    #[inline]
+    fn consume_newline(&mut self) {
+        let byte = self.next_byte_unchecked();
+        debug_assert!(byte == b'\r' || byte == b'\n' || byte == b'\x0C');
+        self.position += 1;
+        if byte == b'\r' && self.next_byte() == Some(b'\n') {
+            self.position += 1;
+        }
+        self.current_line_start_position = self.position;
+        self.current_line_number += 1;
+    }
+
+    #[inline]
+    fn has_newline_at(&self, offset: usize) -> bool {
+        self.position + offset < self.input.len()
+            && matches!(self.byte_at(offset), b'\n' | b'\r' | b'\x0C')
+    }
+
+    #[inline]
+    fn consume_char(&mut self) -> char {
+        let c = self.next_char();
+        let len_utf8 = c.len_utf8();
+        self.position += len_utf8;
+        // Note that due to the special case for the 4-byte sequence
+        // intro, we must use wrapping add here.
+        self.current_line_start_position = self
+            .current_line_start_position
+            .wrapping_add(len_utf8 - c.len_utf16());
+        c
+    }
+
+    #[inline]
+    fn starts_with(&self, needle: &[u8]) -> bool {
+        self.input.as_bytes()[self.position..].starts_with(needle)
+    }
+
+    pub fn skip_whitespace(&mut self) {
+        while !self.is_eof() {
+            match_byte! { self.next_byte_unchecked(),
+                b' ' | b'\t' => {
+                    self.advance(1)
+                },
+                b'\n' | b'\x0C' | b'\r' => {
+                    self.consume_newline();
+                },
+                b'/' => {
+                    if self.starts_with(b"/*") {
+                        consume_comment(self);
+                    } else {
+                        return
+                    }
+                }
+                _ => return,
+            }
+        }
+    }
+
+    pub fn skip_cdc_and_cdo(&mut self) {
+        while !self.is_eof() {
+            match_byte! { self.next_byte_unchecked(),
+                b' ' | b'\t' => {
+                    self.advance(1)
+                },
+                b'\n' | b'\x0C' | b'\r' => {
+                    self.consume_newline();
+                },
+                b'/' => {
+                    if self.starts_with(b"/*") {
+                        consume_comment(self);
+                    } else {
+                        return
+                    }
+                }
+                b'<' => {
+                    if self.starts_with(b"<!--") {
+                        self.advance(4)
+                    } else {
+                        return
+                    }
+                }
+                b'-' => {
+                    if self.starts_with(b"-->") {
+                        self.advance(3)
+                    } else {
+                        return
+                    }
+                }
+                _ => {
+                    return
+                }
+            }
+        }
+    }
+}
+
+/// A position from the start of the input, counted in UTF-8 bytes.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
+pub struct SourcePosition(pub(crate) usize);
+
+impl SourcePosition {
+    /// Returns the current byte index in the original input.
+    #[inline]
+    pub fn byte_index(&self) -> usize {
+        self.0
+    }
+}
+
+/// The line and column number for a given position within the input.
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+pub struct SourceLocation {
+    /// The line number, starting at 0 for the first line, unless `with_first_line_number` was used.
+    pub line: u32,
+
+    /// The column number within a line, starting at 1 for first the character of the line.
+    /// Column numbers are counted in UTF-16 code units.
+    pub column: u32,
+}
+
+fn next_token<'a>(tokenizer: &mut Tokenizer<'a>) -> Result<Token<'a>, ()> {
+    if tokenizer.is_eof() {
+        return Err(());
+    }
+    let b = tokenizer.next_byte_unchecked();
+    let token = match_byte! { b,
+        b' ' | b'\t' => {
+            consume_whitespace(tokenizer, false)
+        },
+        b'\n' | b'\x0C' | b'\r' => consume_whitespace(tokenizer, true),
+        b'"' => consume_string(tokenizer, false),
+        b'#' => {
+            tokenizer.advance(1);
+            if is_ident_start(tokenizer) { IDHash(consume_name(tokenizer)) }
+            else if !tokenizer.is_eof() && match tokenizer.next_byte_unchecked() {
+                // Any other valid case here already resulted in IDHash.
+                b'0'..=b'9' | b'-' => true,
+                _ => false,
+            } { Hash(consume_name(tokenizer)) }
+            else { Delim('#') }
+        },
+        b'$' => {
+            if tokenizer.starts_with(b"$=") { tokenizer.advance(2); SuffixMatch }
+            else { tokenizer.advance(1); Delim('$') }
+        },
+        b'\'' => consume_string(tokenizer, true),
+        b'(' => { tokenizer.advance(1); ParenthesisBlock },
+        b')' => { tokenizer.advance(1); CloseParenthesis },
+        b'*' => {
+            if tokenizer.starts_with(b"*=") { tokenizer.advance(2); SubstringMatch }
+            else { tokenizer.advance(1); Delim('*') }
+        },
+        b'+' => {
+            if (
+                tokenizer.has_at_least(1)
+                && matches!(tokenizer.byte_at(1), b'0'..=b'9')
+            ) || (
+                tokenizer.has_at_least(2)
+                && tokenizer.byte_at(1) == b'.'
+                && matches!(tokenizer.byte_at(2), b'0'..=b'9')
+            ) {
+                consume_numeric(tokenizer)
+            } else {
+                tokenizer.advance(1);
+                Delim('+')
+            }
+        },
+        b',' => { tokenizer.advance(1); Comma },
+        b'-' => {
+            if (
+                tokenizer.has_at_least(1)
+                && matches!(tokenizer.byte_at(1), b'0'..=b'9')
+            ) || (
+                tokenizer.has_at_least(2)
+                && tokenizer.byte_at(1) == b'.'
+                && matches!(tokenizer.byte_at(2), b'0'..=b'9')
+            ) {
+                consume_numeric(tokenizer)
+            } else if tokenizer.starts_with(b"-->") {
+                tokenizer.advance(3);
+                CDC
+            } else if is_ident_start(tokenizer) {
+                consume_ident_like(tokenizer)
+            } else {
+                tokenizer.advance(1);
+                Delim('-')
+            }
+        },
+        b'.' => {
+            if tokenizer.has_at_least(1)
+                && matches!(tokenizer.byte_at(1), b'0'..=b'9'
+            ) {
+                consume_numeric(tokenizer)
+            } else {
+                tokenizer.advance(1);
+                Delim('.')
+            }
+        }
+        b'/' => {
+            if tokenizer.starts_with(b"/*") {
+                Comment(consume_comment(tokenizer))
+            } else {
+                tokenizer.advance(1);
+                Delim('/')
+            }
+        }
+        b'0'..=b'9' => consume_numeric(tokenizer),
+        b':' => { tokenizer.advance(1); Colon },
+        b';' => { tokenizer.advance(1); Semicolon },
+        b'<' => {
+            if tokenizer.starts_with(b"<!--") {
+                tokenizer.advance(4);
+                CDO
+            } else {
+                tokenizer.advance(1);
+                Delim('<')
+            }
+        },
+        b'@' => {
+            tokenizer.advance(1);
+            if is_ident_start(tokenizer) { AtKeyword(consume_name(tokenizer)) }
+            else { Delim('@') }
+        },
+        b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'\0' => consume_ident_like(tokenizer),
+        b'[' => { tokenizer.advance(1); SquareBracketBlock },
+        b'\\' => {
+            if !tokenizer.has_newline_at(1) { consume_ident_like(tokenizer) }
+            else { tokenizer.advance(1); Delim('\\') }
+        },
+        b']' => { tokenizer.advance(1); CloseSquareBracket },
+        b'^' => {
+            if tokenizer.starts_with(b"^=") { tokenizer.advance(2); PrefixMatch }
+            else { tokenizer.advance(1); Delim('^') }
+        },
+        b'{' => { tokenizer.advance(1); CurlyBracketBlock },
+        b'|' => {
+            if tokenizer.starts_with(b"|=") { tokenizer.advance(2); DashMatch }
+            else { tokenizer.advance(1); Delim('|') }
+        },
+        b'}' => { tokenizer.advance(1); CloseCurlyBracket },
+        b'~' => {
+            if tokenizer.starts_with(b"~=") { tokenizer.advance(2); IncludeMatch }
+            else { tokenizer.advance(1); Delim('~') }
+        },
+        _ => {
+            if !b.is_ascii() {
+                consume_ident_like(tokenizer)
+            } else {
+                tokenizer.advance(1);
+                Delim(b as char)
+            }
+        },
+    };
+    Ok(token)
+}
+
+fn consume_whitespace<'a>(tokenizer: &mut Tokenizer<'a>, newline: bool) -> Token<'a> {
+    let start_position = tokenizer.position();
+    if newline {
+        tokenizer.consume_newline();
+    } else {
+        tokenizer.advance(1);
+    }
+    while !tokenizer.is_eof() {
+        let b = tokenizer.next_byte_unchecked();
+        match_byte! { b,
+            b' ' | b'\t' => {
+                tokenizer.advance(1);
+            }
+            b'\n' | b'\x0C' | b'\r' => {
+                tokenizer.consume_newline();
+            }
+            _ => {
+                break
+            }
+        }
+    }
+    WhiteSpace(tokenizer.slice_from(start_position))
+}
+
+// Check for sourceMappingURL or sourceURL comments and update the
+// tokenizer appropriately.
+fn check_for_source_map<'a>(tokenizer: &mut Tokenizer<'a>, contents: &'a str) {
+    let directive = "# sourceMappingURL=";
+    let directive_old = "@ sourceMappingURL=";
+
+    // If there is a source map directive, extract the URL.
+    if contents.starts_with(directive) || contents.starts_with(directive_old) {
+        let contents = &contents[directive.len()..];
+        tokenizer.source_map_url = contents
+            .split(|c| c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n')
+            .next()
+    }
+
+    let directive = "# sourceURL=";
+    let directive_old = "@ sourceURL=";
+
+    // If there is a source map directive, extract the URL.
+    if contents.starts_with(directive) || contents.starts_with(directive_old) {
+        let contents = &contents[directive.len()..];
+        tokenizer.source_url = contents
+            .split(|c| c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n')
+            .next()
+    }
+}
+
+fn consume_comment<'a>(tokenizer: &mut Tokenizer<'a>) -> &'a str {
+    tokenizer.advance(2); // consume "/*"
+    let start_position = tokenizer.position();
+    while !tokenizer.is_eof() {
+        match_byte! { tokenizer.next_byte_unchecked(),
+            b'*' => {
+                let end_position = tokenizer.position();
+                tokenizer.advance(1);
+                if tokenizer.next_byte() == Some(b'/') {
+                    tokenizer.advance(1);
+                    let contents = tokenizer.slice(start_position..end_position);
+                    check_for_source_map(tokenizer, contents);
+                    return contents
+                }
+            }
+            b'\n' | b'\x0C' | b'\r' => {
+                tokenizer.consume_newline();
+            }
+            b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); }
+            b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); }
+            _ => {
+                // ASCII or other leading byte.
+                tokenizer.advance(1);
+            }
+        }
+    }
+    let contents = tokenizer.slice_from(start_position);
+    check_for_source_map(tokenizer, contents);
+    contents
+}
+
+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(value) => BadString(value),
+    }
+}
+
+/// Return `Err(())` on syntax error (ie. unescaped newline)
+fn consume_quoted_string<'a>(
+    tokenizer: &mut Tokenizer<'a>,
+    single_quote: bool,
+) -> Result<CowRcStr<'a>, CowRcStr<'a>> {
+    tokenizer.advance(1); // Skip the initial quote
+                          // start_pos is at code point boundary, after " or '
+    let start_pos = tokenizer.position();
+    let mut string_bytes;
+    loop {
+        if tokenizer.is_eof() {
+            return Ok(tokenizer.slice_from(start_pos).into());
+        }
+        match_byte! { tokenizer.next_byte_unchecked(),
+            b'"' => {
+                if !single_quote {
+                    let value = tokenizer.slice_from(start_pos);
+                    tokenizer.advance(1);
+                    return Ok(value.into())
+                }
+                tokenizer.advance(1);
+            }
+            b'\'' => {
+                if single_quote {
+                    let value = tokenizer.slice_from(start_pos);
+                    tokenizer.advance(1);
+                    return Ok(value.into())
+                }
+                tokenizer.advance(1);
+            }
+            b'\\' | b'\0' => {
+                // * The tokenizer’s input is UTF-8 since it’s `&str`.
+                // * start_pos is at a code point boundary
+                // * so is the current position (which is before '\\' or '\0'
+                //
+                // So `string_bytes` is well-formed UTF-8.
+                string_bytes = tokenizer.slice_from(start_pos).as_bytes().to_owned();
+                break
+            }
+            b'\n' | b'\r' | b'\x0C' => {
+                return Err(tokenizer.slice_from(start_pos).into())
+            },
+            b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); }
+            b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); }
+            _ => {
+                // ASCII or other leading byte.
+                tokenizer.advance(1);
+            }
+        }
+    }
+
+    while !tokenizer.is_eof() {
+        let b = tokenizer.next_byte_unchecked();
+        match_byte! { b,
+            b'\n' | b'\r' | b'\x0C' => {
+                return Err(
+                    // string_bytes is well-formed UTF-8, see other comments.
+                    unsafe {
+                        from_utf8_release_unchecked(string_bytes)
+                    }.into()
+                );
+            }
+            b'"' => {
+                tokenizer.advance(1);
+                if !single_quote {
+                    break;
+                }
+            }
+            b'\'' => {
+                tokenizer.advance(1);
+                if single_quote {
+                    break;
+                }
+            }
+            b'\\' => {
+                tokenizer.advance(1);
+                if !tokenizer.is_eof() {
+                    match tokenizer.next_byte_unchecked() {
+                        // Escaped newline
+                        b'\n' | b'\x0C' | b'\r' => {
+                            tokenizer.consume_newline();
+                        }
+                        // This pushes one well-formed code point
+                        _ => consume_escape_and_write(tokenizer, &mut string_bytes)
+                    }
+                }
+                // else: escaped EOF, do nothing.
+                continue;
+            }
+            b'\0' => {
+                tokenizer.advance(1);
+                string_bytes.extend("\u{FFFD}".as_bytes());
+                continue;
+            }
+            b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); }
+            b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); }
+            _ => {
+                // ASCII or other leading byte.
+                tokenizer.advance(1);
+            },
+        }
+
+        // If this byte is part of a multi-byte code point,
+        // we’ll end up copying the whole code point before this loop does something else.
+        string_bytes.push(b);
+    }
+
+    Ok(
+        // string_bytes is well-formed UTF-8, see other comments.
+        unsafe { from_utf8_release_unchecked(string_bytes) }.into(),
+    )
+}
+
+#[inline]
+fn is_ident_start(tokenizer: &mut Tokenizer) -> bool {
+    !tokenizer.is_eof()
+        && match_byte! { tokenizer.next_byte_unchecked(),
+            b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'\0' => true,
+            b'-' => {
+                tokenizer.has_at_least(1) && match_byte! { tokenizer.byte_at(1),
+                    b'a'..=b'z' | b'A'..=b'Z' | b'-' | b'_' | b'\0' => {
+                        true
+                    }
+                    b'\\' => !tokenizer.has_newline_at(1),
+                    b => !b.is_ascii(),
+                }
+            },
+            b'\\' => !tokenizer.has_newline_at(1),
+            b => !b.is_ascii(),
+        }
+}
+
+fn consume_ident_like<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
+    let value = consume_name(tokenizer);
+    if !tokenizer.is_eof() && tokenizer.next_byte_unchecked() == b'(' {
+        tokenizer.advance(1);
+        if value.eq_ignore_ascii_case("url") {
+            consume_unquoted_url(tokenizer).unwrap_or(Function(value))
+        } else {
+            tokenizer.see_function(&value);
+            Function(value)
+        }
+    } else {
+        Ident(value)
+    }
+}
+
+fn consume_name<'a>(tokenizer: &mut Tokenizer<'a>) -> CowRcStr<'a> {
+    // start_pos is the end of the previous token, therefore at a code point boundary
+    let start_pos = tokenizer.position();
+    let mut value_bytes;
+    loop {
+        if tokenizer.is_eof() {
+            return tokenizer.slice_from(start_pos).into();
+        }
+        match_byte! { tokenizer.next_byte_unchecked(),
+            b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-' => tokenizer.advance(1),
+            b'\\' | b'\0' => {
+                // * The tokenizer’s input is UTF-8 since it’s `&str`.
+                // * start_pos is at a code point boundary
+                // * so is the current position (which is before '\\' or '\0'
+                //
+                // So `value_bytes` is well-formed UTF-8.
+                value_bytes = tokenizer.slice_from(start_pos).as_bytes().to_owned();
+                break
+            }
+            b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); }
+            b'\xC0'..=b'\xEF' => { tokenizer.advance(1); }
+            b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); }
+            _b => {
+                return tokenizer.slice_from(start_pos).into();
+            }
+        }
+    }
+
+    while !tokenizer.is_eof() {
+        let b = tokenizer.next_byte_unchecked();
+        match_byte! { b,
+            b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-'  => {
+                tokenizer.advance(1);
+                value_bytes.push(b)  // ASCII
+            }
+            b'\\' => {
+                if tokenizer.has_newline_at(1) { break }
+                tokenizer.advance(1);
+                // This pushes one well-formed code point
+                consume_escape_and_write(tokenizer, &mut value_bytes)
+            }
+            b'\0' => {
+                tokenizer.advance(1);
+                value_bytes.extend("\u{FFFD}".as_bytes());
+            },
+            b'\x80'..=b'\xBF' => {
+                // This byte *is* part of a multi-byte code point,
+                // we’ll end up copying the whole code point before this loop does something else.
+                tokenizer.consume_continuation_byte();
+                value_bytes.push(b)
+            }
+            b'\xC0'..=b'\xEF' => {
+                // This byte *is* part of a multi-byte code point,
+                // we’ll end up copying the whole code point before this loop does something else.
+                tokenizer.advance(1);
+                value_bytes.push(b)
+            }
+            b'\xF0'..=b'\xFF' => {
+                tokenizer.consume_4byte_intro();
+                value_bytes.push(b)
+            }
+            _ => {
+                // ASCII
+                break;
+            }
+        }
+    }
+    // string_bytes is well-formed UTF-8, see other comments.
+    unsafe { from_utf8_release_unchecked(value_bytes) }.into()
+}
+
+fn byte_to_hex_digit(b: u8) -> Option<u32> {
+    Some(match_byte! { b,
+        b'0' ..= b'9' => b - b'0',
+        b'a' ..= b'f' => b - b'a' + 10,
+        b'A' ..= b'F' => b - b'A' + 10,
+        _ => {
+            return None
+        }
+    } as u32)
+}
+
+fn byte_to_decimal_digit(b: u8) -> Option<u32> {
+    if b >= b'0' && b <= b'9' {
+        Some((b - b'0') as u32)
+    } else {
+        None
+    }
+}
+
+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+)?
+
+    // Do all the math in f64 so that large numbers overflow to +/-inf
+    // and i32::{MIN, MAX} are within range.
+
+    let (has_sign, sign) = match tokenizer.next_byte_unchecked() {
+        b'-' => (true, -1.),
+        b'+' => (true, 1.),
+        _ => (false, 1.),
+    };
+    if has_sign {
+        tokenizer.advance(1);
+    }
+
+    let mut integral_part: f64 = 0.;
+    while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) {
+        integral_part = integral_part * 10. + digit as f64;
+        tokenizer.advance(1);
+        if tokenizer.is_eof() {
+            break;
+        }
+    }
+
+    let mut is_integer = true;
+
+    let mut fractional_part: f64 = 0.;
+    if tokenizer.has_at_least(1)
+        && tokenizer.next_byte_unchecked() == b'.'
+        && matches!(tokenizer.byte_at(1), b'0'..=b'9')
+    {
+        is_integer = false;
+        tokenizer.advance(1); // Consume '.'
+        let mut factor = 0.1;
+        while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) {
+            fractional_part += digit as f64 * factor;
+            factor *= 0.1;
+            tokenizer.advance(1);
+            if tokenizer.is_eof() {
+                break;
+            }
+        }
+    }
+
+    let mut value = sign * (integral_part + fractional_part);
+
+    if tokenizer.has_at_least(1) && matches!(tokenizer.next_byte_unchecked(), b'e' | b'E') {
+        if matches!(tokenizer.byte_at(1), b'0'..=b'9')
+            || (tokenizer.has_at_least(2)
+                && matches!(tokenizer.byte_at(1), b'+' | b'-')
+                && matches!(tokenizer.byte_at(2), b'0'..=b'9'))
+        {
+            is_integer = false;
+            tokenizer.advance(1);
+            let (has_sign, sign) = match tokenizer.next_byte_unchecked() {
+                b'-' => (true, -1.),
+                b'+' => (true, 1.),
+                _ => (false, 1.),
+            };
+            if has_sign {
+                tokenizer.advance(1);
+            }
+            let mut exponent: f64 = 0.;
+            while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) {
+                exponent = exponent * 10. + digit as f64;
+                tokenizer.advance(1);
+                if tokenizer.is_eof() {
+                    break;
+                }
+            }
+            value *= f64::powf(10., sign * exponent);
+        }
+    }
+
+    let int_value = if is_integer {
+        Some(if value >= i32::MAX as f64 {
+            i32::MAX
+        } else if value <= i32::MIN as f64 {
+            i32::MIN
+        } else {
+            value as i32
+        })
+    } else {
+        None
+    };
+
+    if !tokenizer.is_eof() && tokenizer.next_byte_unchecked() == b'%' {
+        tokenizer.advance(1);
+        return Percentage {
+            unit_value: (value / 100.) as f32,
+            int_value,
+            has_sign,
+        };
+    }
+    let value = value as f32;
+    if is_ident_start(tokenizer) {
+        let unit = consume_name(tokenizer);
+        Dimension {
+            value,
+            int_value,
+            has_sign,
+            unit,
+        }
+    } else {
+        Number {
+            value,
+            int_value,
+            has_sign,
+        }
+    }
+}
+
+#[inline]
+unsafe fn from_utf8_release_unchecked(string_bytes: Vec<u8>) -> String {
+    if cfg!(debug_assertions) {
+        String::from_utf8(string_bytes).unwrap()
+    } else {
+        String::from_utf8_unchecked(string_bytes)
+    }
+}
+
+fn consume_unquoted_url<'a>(tokenizer: &mut Tokenizer<'a>) -> Result<Token<'a>, ()> {
+    // This is only called after "url(", so the current position is a code point boundary.
+    let start_position = tokenizer.position;
+    let from_start = &tokenizer.input[tokenizer.position..];
+    let mut newlines = 0;
+    let mut last_newline = 0;
+    let mut found_printable_char = false;
+    let mut iter = from_start.bytes().enumerate();
+    loop {
+        let (offset, b) = match iter.next() {
+            Some(item) => item,
+            None => {
+                tokenizer.position = tokenizer.input.len();
+                break;
+            }
+        };
+        match_byte! { b,
+            b' ' | b'\t' => {},
+            b'\n' | b'\x0C' => {
+                newlines += 1;
+                last_newline = offset;
+            }
+            b'\r' => {
+                if from_start.as_bytes().get(offset + 1) != Some(&b'\n') {
+                    newlines += 1;
+                    last_newline = offset;
+                }
+            }
+            b'"' | b'\'' => return Err(()),  // Do not advance
+            b')' => {
+                // Don't use advance, because we may be skipping
+                // newlines here, and we want to avoid the assert.
+                tokenizer.position += offset + 1;
+                break
+            }
+            _ => {
+                // Don't use advance, because we may be skipping
+                // newlines here, and we want to avoid the assert.
+                tokenizer.position += offset;
+                found_printable_char = true;
+                break
+            }
+        }
+    }
+
+    if newlines > 0 {
+        tokenizer.current_line_number += newlines;
+        // No need for wrapping_add here, because there's no possible
+        // way to wrap.
+        tokenizer.current_line_start_position = start_position + last_newline + 1;
+    }
+
+    if found_printable_char {
+        // This function only consumed ASCII (whitespace) bytes,
+        // so the current position is a code point boundary.
+        return Ok(consume_unquoted_url_internal(tokenizer));
+    } else {
+        return Ok(UnquotedUrl("".into()));
+    }
+
+    fn consume_unquoted_url_internal<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
+        // This function is only called with start_pos at a code point boundary.
+        let start_pos = tokenizer.position();
+        let mut string_bytes: Vec<u8>;
+        loop {
+            if tokenizer.is_eof() {
+                return UnquotedUrl(tokenizer.slice_from(start_pos).into());
+            }
+            match_byte! { tokenizer.next_byte_unchecked(),
+                b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' => {
+                    let value = tokenizer.slice_from(start_pos);
+                    return consume_url_end(tokenizer, start_pos, value.into())
+                }
+                b')' => {
+                    let value = tokenizer.slice_from(start_pos);
+                    tokenizer.advance(1);
+                    return UnquotedUrl(value.into())
+                }
+                b'\x01'..=b'\x08' | b'\x0B' | b'\x0E'..=b'\x1F' | b'\x7F'  // non-printable
+                    | b'"' | b'\'' | b'(' => {
+                    tokenizer.advance(1);
+                    return consume_bad_url(tokenizer, start_pos)
+                },
+                b'\\' | b'\0' => {
+                    // * The tokenizer’s input is UTF-8 since it’s `&str`.
+                    // * start_pos is at a code point boundary
+                    // * so is the current position (which is before '\\' or '\0'
+                    //
+                    // So `string_bytes` is well-formed UTF-8.
+                    string_bytes = tokenizer.slice_from(start_pos).as_bytes().to_owned();
+                    break
+                }
+                b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); }
+                b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); }
+                _ => {
+                    // ASCII or other leading byte.
+                    tokenizer.advance(1);
+                }
+            }
+        }
+        while !tokenizer.is_eof() {
+            let b = tokenizer.next_byte_unchecked();
+            match_byte! { b,
+                b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' => {
+                    // string_bytes is well-formed UTF-8, see other comments.
+                    let string = unsafe { from_utf8_release_unchecked(string_bytes) }.into();
+                    return consume_url_end(tokenizer, start_pos, string)
+                }
+                b')' => {
+                    tokenizer.advance(1);
+                    break;
+                }
+                b'\x01'..=b'\x08' | b'\x0B' | b'\x0E'..=b'\x1F' | b'\x7F'  // non-printable
+                    | b'"' | b'\'' | b'(' => {
+                    tokenizer.advance(1);
+                    return consume_bad_url(tokenizer, start_pos);
+                }
+                b'\\' => {
+                    tokenizer.advance(1);
+                    if tokenizer.has_newline_at(0) {
+                        return consume_bad_url(tokenizer, start_pos)
+                    }
+
+                    // This pushes one well-formed code point to string_bytes
+                    consume_escape_and_write(tokenizer, &mut string_bytes)
+                },
+                b'\0' => {
+                    tokenizer.advance(1);
+                    string_bytes.extend("\u{FFFD}".as_bytes());
+                }
+                b'\x80'..=b'\xBF' => {
+                    // We’ll end up copying the whole code point
+                    // before this loop does something else.
+                    tokenizer.consume_continuation_byte();
+                    string_bytes.push(b);
+                }
+                b'\xF0'..=b'\xFF' => {
+                    // We’ll end up copying the whole code point
+                    // before this loop does something else.
+                    tokenizer.consume_4byte_intro();
+                    string_bytes.push(b);
+                }
+                // If this byte is part of a multi-byte code point,
+                // we’ll end up copying the whole code point before this loop does something else.
+                b => {
+                    // ASCII or other leading byte.
+                    tokenizer.advance(1);
+                    string_bytes.push(b)
+                }
+            }
+        }
+        UnquotedUrl(
+            // string_bytes is well-formed UTF-8, see other comments.
+            unsafe { from_utf8_release_unchecked(string_bytes) }.into(),
+        )
+    }
+
+    fn consume_url_end<'a>(
+        tokenizer: &mut Tokenizer<'a>,
+        start_pos: SourcePosition,
+        string: CowRcStr<'a>,
+    ) -> Token<'a> {
+        while !tokenizer.is_eof() {
+            match_byte! { tokenizer.next_byte_unchecked(),
+                b')' => {
+                    tokenizer.advance(1);
+                    break
+                }
+                b' ' | b'\t' => { tokenizer.advance(1); }
+                b'\n' | b'\x0C' | b'\r' => {
+                    tokenizer.consume_newline();
+                }
+                b => {
+                    tokenizer.consume_known_byte(b);
+                    return consume_bad_url(tokenizer, start_pos);
+                }
+            }
+        }
+        UnquotedUrl(string)
+    }
+
+    fn consume_bad_url<'a>(tokenizer: &mut Tokenizer<'a>, start_pos: SourcePosition) -> Token<'a> {
+        // Consume up to the closing )
+        while !tokenizer.is_eof() {
+            match_byte! { tokenizer.next_byte_unchecked(),
+                b')' => {
+                    let contents = tokenizer.slice_from(start_pos).into();
+                    tokenizer.advance(1);
+                    return BadUrl(contents)
+                }
+                b'\\' => {
+                    tokenizer.advance(1);
+                    if matches!(tokenizer.next_byte(), Some(b')') | Some(b'\\')) {
+                        tokenizer.advance(1); // Skip an escaped ')' or '\'
+                    }
+                }
+                b'\n' | b'\x0C' | b'\r' => {
+                    tokenizer.consume_newline();
+                }
+                b => {
+                    tokenizer.consume_known_byte(b);
+                }
+            }
+        }
+        BadUrl(tokenizer.slice_from(start_pos).into())
+    }
+}
+
+// (value, number of digits up to 6)
+fn consume_hex_digits<'a>(tokenizer: &mut Tokenizer<'a>) -> (u32, u32) {
+    let mut value = 0;
+    let mut digits = 0;
+    while digits < 6 && !tokenizer.is_eof() {
+        match byte_to_hex_digit(tokenizer.next_byte_unchecked()) {
+            Some(digit) => {
+                value = value * 16 + digit;
+                digits += 1;
+                tokenizer.advance(1);
+            }
+            None => break,
+        }
+    }
+    (value, digits)
+}
+
+// Same constraints as consume_escape except it writes into `bytes` the result
+// instead of returning it.
+fn consume_escape_and_write(tokenizer: &mut Tokenizer, bytes: &mut Vec<u8>) {
+    bytes.extend(
+        consume_escape(tokenizer)
+            .encode_utf8(&mut [0; 4])
+            .as_bytes(),
+    )
+}
+
+// Assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed
+// and that the next input character has already been verified
+// to not be a newline.
+fn consume_escape(tokenizer: &mut Tokenizer) -> char {
+    if tokenizer.is_eof() {
+        return '\u{FFFD}';
+    } // Escaped EOF
+    match_byte! { tokenizer.next_byte_unchecked(),
+        b'0'..=b'9' | b'A'..=b'F' | b'a'..=b'f' => {
+            let (c, _) = consume_hex_digits(tokenizer);
+            if !tokenizer.is_eof() {
+                match_byte! { tokenizer.next_byte_unchecked(),
+                    b' ' | b'\t' => {
+                        tokenizer.advance(1)
+                    }
+                    b'\n' | b'\x0C' | b'\r' => {
+                        tokenizer.consume_newline();
+                    }
+                    _ => {}
+                }
+            }
+            static REPLACEMENT_CHAR: char = '\u{FFFD}';
+            if c != 0 {
+                let c = char::from_u32(c);
+                c.unwrap_or(REPLACEMENT_CHAR)
+            } else {
+                REPLACEMENT_CHAR
+            }
+        },
+        b'\0' => {
+            tokenizer.advance(1);
+            '\u{FFFD}'
+        }
+        _ => tokenizer.consume_char(),
+    }
+}
diff --git a/third_party/rust/cssparser/src/unicode_range.rs b/third_party/rust/cssparser/src/unicode_range.rs
new file mode 100644
index 0000000000..b0a2017cbf
--- /dev/null
+++ b/third_party/rust/cssparser/src/unicode_range.rs
@@ -0,0 +1,181 @@
+/* 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/. */
+
+//! https://drafts.csswg.org/css-syntax/#urange
+
+use crate::tokenizer::Token;
+use crate::{BasicParseError, Parser, ToCss};
+use std::char;
+use std::fmt;
+
+/// One contiguous range of code points.
+///
+/// Can not be empty. Can represent a single code point when start == end.
+#[derive(PartialEq, Eq, Clone, Hash)]
+#[repr(C)]
+pub struct UnicodeRange {
+    /// Inclusive start of the range. In [0, end].
+    pub start: u32,
+
+    /// Inclusive end of the range. In [0, 0x10FFFF].
+    pub end: u32,
+}
+
+impl UnicodeRange {
+    /// https://drafts.csswg.org/css-syntax/#urange-syntax
+    pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, BasicParseError<'i>> {
+        // <urange> =
+        //   u '+' <ident-token> '?'* |
+        //   u <dimension-token> '?'* |
+        //   u <number-token> '?'* |
+        //   u <number-token> <dimension-token> |
+        //   u <number-token> <number-token> |
+        //   u '+' '?'+
+
+        input.expect_ident_matching("u")?;
+        let after_u = input.position();
+        parse_tokens(input)?;
+
+        // This deviates from the spec in case there are CSS comments
+        // between tokens in the middle of one <unicode-range>,
+        // but oh well…
+        let concatenated_tokens = input.slice_from(after_u);
+
+        let range = match parse_concatenated(concatenated_tokens.as_bytes()) {
+            Ok(range) => range,
+            Err(()) => {
+                return Err(input
+                    .new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into())))
+            }
+        };
+        if range.end > char::MAX as u32 || range.start > range.end {
+            Err(input.new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into())))
+        } else {
+            Ok(range)
+        }
+    }
+}
+
+fn parse_tokens<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(), BasicParseError<'i>> {
+    match input.next_including_whitespace()?.clone() {
+        Token::Delim('+') => {
+            match *input.next_including_whitespace()? {
+                Token::Ident(_) => {}
+                Token::Delim('?') => {}
+                ref t => {
+                    let t = t.clone();
+                    return Err(input.new_basic_unexpected_token_error(t));
+                }
+            }
+            parse_question_marks(input)
+        }
+        Token::Dimension { .. } => parse_question_marks(input),
+        Token::Number { .. } => {
+            let after_number = input.state();
+            match input.next_including_whitespace() {
+                Ok(&Token::Delim('?')) => parse_question_marks(input),
+                Ok(&Token::Dimension { .. }) => {}
+                Ok(&Token::Number { .. }) => {}
+                _ => input.reset(&after_number),
+            }
+        }
+        t => return Err(input.new_basic_unexpected_token_error(t)),
+    }
+    Ok(())
+}
+
+/// Consume as many '?' as possible
+fn parse_question_marks(input: &mut Parser) {
+    loop {
+        let start = input.state();
+        match input.next_including_whitespace() {
+            Ok(&Token::Delim('?')) => {}
+            _ => {
+                input.reset(&start);
+                return;
+            }
+        }
+    }
+}
+
+fn parse_concatenated(text: &[u8]) -> Result<UnicodeRange, ()> {
+    let mut text = match text.split_first() {
+        Some((&b'+', text)) => text,
+        _ => return Err(()),
+    };
+    let (first_hex_value, hex_digit_count) = consume_hex(&mut text);
+    let question_marks = consume_question_marks(&mut text);
+    let consumed = hex_digit_count + question_marks;
+    if consumed == 0 || consumed > 6 {
+        return Err(());
+    }
+
+    if question_marks > 0 {
+        if text.is_empty() {
+            return Ok(UnicodeRange {
+                start: first_hex_value << (question_marks * 4),
+                end: ((first_hex_value + 1) << (question_marks * 4)) - 1,
+            });
+        }
+    } else if text.is_empty() {
+        return Ok(UnicodeRange {
+            start: first_hex_value,
+            end: first_hex_value,
+        });
+    } else {
+        if let Some((&b'-', mut text)) = text.split_first() {
+            let (second_hex_value, hex_digit_count) = consume_hex(&mut text);
+            if hex_digit_count > 0 && hex_digit_count <= 6 && text.is_empty() {
+                return Ok(UnicodeRange {
+                    start: first_hex_value,
+                    end: second_hex_value,
+                });
+            }
+        }
+    }
+    Err(())
+}
+
+fn consume_hex(text: &mut &[u8]) -> (u32, usize) {
+    let mut value = 0;
+    let mut digits = 0;
+    while let Some((&byte, rest)) = text.split_first() {
+        if let Some(digit_value) = (byte as char).to_digit(16) {
+            value = value * 0x10 + digit_value;
+            digits += 1;
+            *text = rest
+        } else {
+            break;
+        }
+    }
+    (value, digits)
+}
+
+fn consume_question_marks(text: &mut &[u8]) -> usize {
+    let mut question_marks = 0;
+    while let Some((&b'?', rest)) = text.split_first() {
+        question_marks += 1;
+        *text = rest
+    }
+    question_marks
+}
+
+impl fmt::Debug for UnicodeRange {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.to_css(formatter)
+    }
+}
+
+impl ToCss for UnicodeRange {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        write!(dest, "U+{:X}", self.start)?;
+        if self.end != self.start {
+            write!(dest, "-{:X}", self.end)?;
+        }
+        Ok(())
+    }
+}