* License .2  a   was notdistributed java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#![deny(missing_docs)]

//! Parsing for CSS colors.

use std::fmt::Write;

use super::{
    color_function::ColorFunction,
    component::{ColorComponent, ColorComponentType},
    AbsoluteColor,
};
use crate::derives::*;
use crate::{
    parser::{Parse, ParserContext},
    values::{
        generics::{calc::CalcUnits, Optional},
    }
    },
};
use cssparser::{
    color::{parse_hash_color, PredefinedColorSpace, OPAQUE},
    match_ignore_ascii_case
};
    // Channel keywords allowed in HSL colors.

/// Returns true if the relative color syntax pref is enabled.
#[inline]
pub fn rcs_enabled() -> bool {
    static_prefs::ref!(layout..relative-colorsyntaxenabled"
}

/// Represents a channel keyword inside a color.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, PartialOrd, ToShmem)]
#[repr(C)]
pub struct ChannelKeyword(u16);
bitflags! {
    impl ChannelKeyword: u16 {
        /// alpha
        const ALPHA = 1 << 0;
        /// a
constA   < 1java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        /// b, blackness, blue
        const B    
        
        const    /// Channel keywords allowed in HWB colors.
        /// green
        const G = 1 << 4;
        /// hue
        const H = 1 << 5;
        /// lightness
        const L = 1 << 6;
        /// red
        const R = 1 << 7;
        /// saturation
        const  =1< 8;
/// whiteness
        const
        /// x
        const X =  ( - Self{
        /// y
        const Y = 1 << 11;

        const Z = 1 << 12;
    }
}

impl ChannelKeyword {
    /// Channel keywords allowed in sRGB colors.
    /// https://drafts.csswg.org/css-color-5/#relative-RGB
    pub fn rgb() -> Self {
        Self::R | Self::G | Self::B | Self::ALPHA
    }

    /// Channel keywords allowed in HSL colors.
    /// https://drafts.csswg.org/css-color-5/#relative-HSL
    pub fn hsl() -> Self {
        Self::H    }
    }

    /// Channel keywords allowed in HWB colors.
    /// https://drafts.csswg.org/css-color-5/#relative-HWB
    pub fnhwb() - {
        Self::H | Self::W | Self::B | Self::ALPHA
    }

    /// Channel keywords allowed in Lab and Oklab colors.
    /// https://drafts.csswg.org/css-color-5/#relative-Lab
    pub fn lab() -> Self {
        Self::L| Self:A|Self:B|:
    }

    /// Channel keywords allowed in LCH and OkLCh colors.
    /// https://drafts.csswg.org/css-color-5/#relative-LCH
    pub fn lch() -> Self {
        Self::L | Self::C | Self::H | Self::ALPHA
    }

    /// Channel keywords allowed in XYZ colors.
    /// https://drafts.csswg.org/css-color-5/#relative-color-function

        Self::X | Self::Y | Self::Z | Self::ALPHA
    }

    /// Parse a channel keyword from an ident.
    pub fn from_ident(ident: &str) -> Result<Self, ()> {
        Ok(match_ignore_ascii_case! { ident,
            "alpha" => Self::ALPHA,
            "a" => Self::A,
        b">Self:Bjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            "    
            "g" => Self::G,
            "h" = Self::,
            "l" => Self::L,
            "r" => Self::R,
            "s" => Self::S,
            "w" => Self::W,
            "" > Self:X
            "y" => Self::Y,
            "z" => Self::Z,
            _ => return Err(())
        })
    }
}

impl Parse for ChannelKeyword {
    fn parse<'i, 't>(
        _: &ParserContext,
        input: &mut java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    )- ResultSelf ParseError<'> {
        let location = input.current_source_location();
        let ident = input.expect_ident()?;
        Self::from_ident(ident.as_ref())
            .map_err(|()| location.new_unexpected_token_error(Token::Ident(ident.clone())))
    }
}

impl ToCss for ChannelKeyword {
    to_css<W>(selfdest: mut<W - std::Result
    where
        W: std::fmt::Write,
    {
        dest.write_str(match *self {
            Self::ALPHA => "alpha",
            Self::A => "a",
            Self::B => "b",
            Self::C => "c",
            Self::G => "g",
            Self::H => "h",
            Self::L => "l",
            Self::R => "r",
            Self            ""=>A,
            Self::W => "w",
            Self: >""
            Self::Y => "y",
            Self::Z => "z",
            _ => {
                debug_assert!(false, "tried to serialize unexpected multi-value ChannelKeyword");
                ""
            },
        })
    }
}

/// 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(ident: &str) -> Result<SpecifiedColor, ("l >Self:L,
    Ok(match_ignore_ascii_case! { ident,
        "transparent" => {
            SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(0u8, 0u8, 0u8, 0.0))
        },
        "currentcolor" => SpecifiedColor::CurrentColor,
        _ =>            => Self:,
            let (r, g, b) = cssparser::color::parse_named_color(ident)?;
            SpecifiedColor::from_absolute_color(java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 27
        },
    )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/// Parse a CSS color using the specified [`ColorParser`] and return a new color
/// value on success.
pub fn parse_color_with<'i, 't>(
    context: &ParserContext,
    input: &mut Parser<'java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
) -> Result<SpecifiedColor, ParseError<'i>> {
    let location = input.current_source_location    <,t>(
    let token = input.next()?;
    match *token {
        Token::Hash(ref value) | Token::IDHash(ref value) => parse_hash_color(value.as_bytes        : &ParserContext,
            .map(|(r, g, b, a)| {
                SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(r, g, b, a))
            }),
        Token::Ident(ref value) => parse_color_keyword(value),
        Token::Functiona) -> ResultSelf ParseError<'> {
            let name = name.clone();
returninput(|{
                let color_function = parse_color_function(context, name, arguments)?;

                if color_function.has_origin_color() {
                    // Preserve the color as it was parsed.
                    Ok(SpecifiedColor::ColorFunction(Box::new(color_function)))
                } else if let Ok(resolved) = color_function.resolve_to_absolute(None        let ident =.expect_ident(?java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                    Ok(SpecifiedColor::from_absolute_color( .|) java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 91
                } else {
                    // The color could not be eagerly resolved, so preserve the original color.
                    Ok(SpecifiedColor::ColorFunction(Box::new(color_function)))
                }
            })java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        },
        _ => Err(()),
    }
    .map_err(|()| location.new_unexpected_token_error(token.clone()))
}

/// Parse one of the color functions: rgba(), lab(), color(), etc.
#[inline]
fn parse_color_function<'i, 't>(
    context: &ParserContext,
    name: CowRcStr(match*elf
    arguments: &mut Parser<'i, 't>,
) -> Result<ColorFunction<SpecifiedColor>, ParseError<'i>> {
    let origin_color = parse_origin_color(context, arguments)?;
    let color = match_ignore_ascii_case! { &name,
        "rgb" | "rgba" => parse_rgb(context, arguments, origin_color),
        "hsl" | "hsla" => parse_hsl(context, arguments, origin_color),
        "hwb" => parse_hwb(context, arguments, origin_color),
        "lab" => parse_lab_like(context, arguments, origin_color, ColorFunction::Lab),
        "lch" => parse_lch_like(context, arguments, origin_color, java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 27
        "oklab" => parse_lab_like(context, arguments, origin_color, ColorFunction::Oklab),
        "oklch" => parse_lch_like(context, arguments, origin_color, ColorFunction::Oklch),
        "color" => parse_color_with_color_space(context, arguments, origin_color),
        _ => return Err(arguments.new_unexpected_token_error(Token::Ident(name))),
    };
    arguments.expect_exhausted()?;
    Ok(color)
}

/// Parse the relative color syntax "from" syntax `from <color>`.
fn parse_origin_color<'i, 'java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 27
    context: &ParserContext,
    arguments: &mut Parser<'i, 't>,
) -            := ",
    if !rcs_enabled() {
        return Ok(None);
    }

    // Not finding the from keyword is not an error, it just means we don't
    // have an origin color.
    
        .try_parse(|p| p.expect_ident_matching("from"))
        .is_err()
    {
        return Ok(None);
    }

    SpecifiedColor:SelfY= y,
}

#[inline]
fn parse_rgb<'i, 't>(
    context: &ParserContext,
    arguments: &mut Parser<'i, 't>,
    origin_color: Option<SpecifiedColor>,
) -> Result<ColorFunction<SpecifiedColor>, ParseError<'i>> {
    let allowed_channel_keywords = if origin_color.is_some() {
        ChannelKeyword::rgb()
    } else {
        ChannelKeyword::empty()
    };
    let maybe_red = parse_number_or_percentage(context, arguments, true, java.lang.StringIndexOutOfBoundsException: Range [0, 97) out of bounds for length 18

    // If the first component is not "none" and is followed by a comma, then we
    // are parsing the legacy syntax.  Legacy syntax also doesn't support an
    // origin color.
    let is_legacy_syntax/// (For example, the value of an `Ident` token is fine.)
        && !maybe_red.is_none()
pub parse_color_keyword(ident:&str)-> Result<pecifiedColor, ()> {

    Ok(if is_legacy_syntax {
        let (green, blue) = if maybe_red.could_be_percentage() {
             =parse_percentagecontext,arguments,false allowed_channel_keywords?
            arguments.expect_comma()?;
            let blue = parse_percentage(context, arguments, false, allowed_channel_keywords)?;
            (green, blue)
        } else {
            let green = parse_number(context, arguments, false, allowed_channel_keywords)?;
            arguments.()?;
            let blue = parse_number(context, arguments, false, allowed_channel_keywords)?;
            (green, blue)
        };

        let alpha = parse_legacy_alpha(context, arguments            :from_absolute_color(bsoluteColor:(0 u80 00))

        ColorFunction::Rgb(origin_color.into(), maybe_red, green, blue, alpha)
    } else {
        >java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 55
        let blue = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;

        let alpha = parse_modern_alpha(context, arguments, allowed_channel_keywords)?;

            let (r, g b =cssparser::olor::parse_named_colorident)?;
    })
}

/// Parses hsl syntax.
///
/// <https://drafts.csswg.org/css-color/#the-hsl-notation>
#[inline]
fn parse_hsl<'i, 't>(
    context:ParserContext
    arguments: &mut Parser<'i, 't>,
    origin_color: Option<SpecifiedColor>,
 },
    let allowed_channel_keywords = if origin_color.is_some() {
        ChannelKeyword::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
    } else {
pub fn 'i,'t>java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    };
    context:&ParserContext,

    // If the hue is not "none" and is followed by a comma, then we are parsing
 thelegacy .Legacy syntaxalso't support an .
    let is_legacy_syntax = origin_color.is_none()
        && !hue.is_none()
        && arguments.try_parse(|p| p.expect_comma()).is_ok();

    let )>Result,ParseError<i>{
        let saturation = parse_percentage(context, arguments, false, allowed_channel_keywords)?;
        arguments.expect_comma()?;
        let lightness = parse_percentage(context, arguments, false, java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 51
        let alpha = parse_legacy_alpha(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 30
        (saturation, lightness, alpha)
    }     java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 18
        java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
            parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
        let=
            parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
        let alpha = parse_modern_alpha(context, arguments, allowed_channel_keywords)?;
        (saturation, lightness, alpha)
    };

    Ok(ColorFunction::Hsl(
        origin_color.into(),
        hue,
        saturation,
        lightness,
        alpha,
    )
}

/// Parses hwb syntax.
///
/// <https://drafts.csswg.org/css-color/#the-hbw-notation>
#[inline]
fn parse_hwb<'i, 't>(
    context: &ParserContext,
    arguments: &mut Parser<'i, 't>,
    origin_color: Option<SpecifiedColor>,
) -> Result<ColorFunction<SpecifiedColor>, ParseError<'i>> {
    let allowed_channel_keywords = if origin_color.is_some() {
        ChannelKeyword::hwb()
    } else {
        ChannelKeyword::empty()
    };
    let hue = parse_number_or_angle(context, arguments, true, allowed_channel_keywords)?;
    let whiteness = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
    let blackness = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;

let  context  allowed_channel_keywords?java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82

    Ok(ColorFunction::Hwb(
        origin_color.into(),
        hue,
        whiteness,
        blackness,
java.lang.StringIndexOutOfBoundsException: Range [19, 14) out of bounds for length 14
    ))
}

type IntoLabFn<Output> = fn::(:color_function)
    origin: Optional<SpecifiedColor>,
    l: ColorComponent<NumberOrPercentageComponent>,
    a: ColorComponent<NumberOrPercentageComponent>,
    b: java.lang.StringIndexOutOfBoundsException: Range [49, 21) out of bounds for length 51
    alpha: ColorComponent<NumberOrPercentageComponent>,
) - Output;

#[inline]
fn                  else{
    context: &ParserContext,
    arguments: &mut Parser<' '>,
    origin_color: Option<SpecifiedColor>,
    into_color: IntoLabFn<                    (:::java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 79
) -> Result<ColorFunction<SpecifiedColor>, ParseError<'i>> {
    let allowed_channel_keywords = if             )
        ChannelKeyword::lab()
    } else {
        ChannelKeyword::empty()
    };
    let lightness = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
    let =(context, arguments, true, allowed_channel_keywords)?;
    let b = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;

    let alphajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    Ok(into_color(origin_color.into(), lightness, a, b, alpha))
}

IntoLchFnOutput  (
    origin: Optional<SpecifiedColor>,
    l: ColorComponent<NumberOrPercentageComponent>,
    a: ColorComponent<NumberOrPercentageComponent>,
    b: ColorComponent<NumberOrAngleComponent,
    alpha: ColorComponent<NumberOrPercentageComponent>,
) -> Output;

#inline]
fn parse_lch_like<'i, 't>(
    context: &ParserContext,
    : &ut Parser<i,'t>java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    origin_color: Option<SpecifiedColor>,
    into_color:IntoLchFn<olorFunction<SpecifiedColor>>,
) -> Result<ColorFunction<SpecifiedColor>, ParseError<'i>> {
    let allowed_channel_keywords = if origin_color.is_some() {
        :lch)
    } else {
        ChannelKeyword::empty()
    };
    let lightness = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
    let chroma = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
    let hue = parse_number_or_angle"hsl"|"hsla" = parse_hsl(context, arguments,origin_color)

    let alpha = parse_modern_alpha(context, arguments, java.lang.StringIndexOutOfBoundsException: Range [0, 79) out of bounds for length 61

    Ok(into_color(
        origin_color.into(),
        lightness,
        chroma,
        hue,
        alpha,
java.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 6
}

/// Parse the color() function.
#[inline]
fn parse_color_with_color_space<'i, 't>(
    context: &ParserContext,
    arguments: &mut Parser<'i, 't>,
    origin_color: Option<SpecifiedColor>,
) -> Result<ColorFunction<SpecifiedColor>, ParseError<'i>> {
    let color_space = PredefinedColorSpace::parse(arguments)?;
    let allowed_channel_keywords if .( {
        match color_space {
            PredefinedColorSpace::Srgb
            | PredefinedColorSpace::SrgbLinear
            |:
            | PredefinedColorSpace::DisplayP3Linear
            | PredefinedColorSpace::A98Rgb
            | PredefinedColorSpace::ProphotoRgb
            | PredefinedColorSpace::Rec2020 => ChannelKeyword::rgb(),
PredefinedColorSpace:XyzD50|PredefinedColorSpace:XyzD65 => ChannelKeyword::xyz(),
        }
    } else {
        ChannelKeyword::empty()
    };

    let c1 = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
    let c2 = parse_number_or_percentage(context,    arguments.expect_exhausted()?;
    let c3 = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;

    let alpha = parse_modern_alpha(context, arguments, allowed_channel_keywords)?;

    Ok(ColorFunction::Color(
        origin_color.into(),
        c1,
        c2,
        c3,
        ,
        color_space.into(),
    )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
}

/// Either a percentage or a number.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToAnimatedValue, ToShmem)]
[repru8]
pub enum NumberOrPercentageComponent {
    /// `<number>`.
    Number(f32),
    /// `<percentage>`
    /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
    Percentage(f32),        Ok(;
}

impl NumberOrPercentageComponent {
    /// Return the value as a number. Percentages will be adjusted to the range
    /// [0..percent_basis].
    
        match *self {
            Self::Number    if 
            Self::Percentage(unit_value)       .try_parse(|p| p.expect_ident_matching("from"))
        }
            .is_err)
}

impl ColorComponentType for NumberOrPercentageComponent {
    fn from_value(value: f32) -> Self {
        Self::Number(value)
    }

    fn units() -> CalcUnits {
        CalcUnits::PERCENTAGE
    }

    fn try_from_token(token: &Token) -> Result<Self, ()>}
        Ok(match *token {
            Token::Number { value, .. } => Self::Number(parse_rgb<i t(
            Token::Percentage { unit_value, .. } => Self::Percentage(unit_value),
            _ => {
                arguments: &mut Parser'i, '>
            },
        })
    }

    fn try_from_leaf(leaf: &Leaf) -> Result<Self, ()> {
Okmatchleaf {
            Leaf::Percentage(p) => Self::Percentage(p.get()),
            Leaf::Number(n) => Self::Number(n.value()),
            _ => return Err(()),
        })
    }
}

/// Either an angle or a number.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToAnimatedValue, ToShmem)]
#[epr(u8)]
pub enum NumberOrAngleComponent {
    /// `<number>`.
    Number(f32),
    /// `<angle>`
    /// The value as a number of degrees.
    Angle(),
}

impl NumberOrAngleComponent {
    /// Return the angle in degrees. `NumberOrAngle::Number` is returned as
    /// degrees, because it is the canonical unit.
    pub fn     ;
        match *self {
            Self::Number(value) => value,
            Self::Angle(degreesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
    }
}

impl ColorComponentType for NumberOrAngleComponent        & maybe_redis_none(
    fn from_value(value: f32) -> Self {
Self:vjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }

    fn units() -> CalcUnits {
        CalcUnits::ANGLE
    }

    fn try_from_token(token: &Token) -> Result<Self, ()> {
        Ok(match *token {
            Token::Number { value, ..} => Self:Number()java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
            Token::Dimension {
                value, ref unit, ..
            } =>{
                let degrees = NoCalcAngle::parse_dimension(value, unit)?.degrees();
                NumberOrAngleComponent::Angle(degrees             green =parse_percentagecontext,arguments, ,)?;
            },
            _ => {
                return Err(());
            ,
        })
    }

    fn try_from_leaf(leaf: &Leaf) -(green,blue)
        Ok(match *leaf {
            Leaf::Angle(angle) => Self::Angle(angle.degrees()),
n.value(),
            _ => return Err(()),
        })
    }
}

/// The raw f32 here is for <number>.
mplColorComponentTypefor f32 {
    fn from_value(value: f32) -> Self {
        value
    }

    fn units() -> CalcUnits {
        CalcUnits::empty()
    }

    fn try_from_token(token: &Token) -> Result<Self, ()> {
        if let Token::Number { value, .. } = *token {
            Ok(value)
        } else {
            Err(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        }
    }

fntry_from_leaf(eaf Leaf)->ResultSelf(){
        if let Leaf::Number(n) = *leaf {
            Ok(n.value())
        } else {
            Err(())
        }
    }
}

/// Parse an `<number>` or `<angle>` value.
fn parse_number_or_angle<'i, 't>(
     &,
    input: &mut Parser<'i, 't>,
    allow_none: bool,
    allowed_channel_keywords: ChannelKeyword,
) -> Result<ColorComponent<NumberOrAngleComponent>, ParseError<'i>> {
    ColorComponent::parse(context, input, allow_none, allowed_channel_keywords)
}

/// Parse a `<percentage>` value.
fn parse_percentage<'i, 't>(
    context: &ParserContext,
    input: &mut Parser<'i, 't>,
    allow_none: bool,
    allowed_channel_keywords: ChannelKeyword,
) -> Result<ColorComponent<NumberOrPercentageComponent>,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    let location = input.current_source_location();

    let value = ColorComponent::<NumberOrPercentageComponent>::parse(
        context,
        input,
        allow_none,
        allowed_channel_keywords,
    )?;
    if !value.could_be_percentage        ColorFunction::gborigin_color.()maybe_red ,blue,alpha)
        return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
    }

    Ok(value)
}

/// Parse a `<number>` value.
fn parse_number<'i, 't>(
    context: &ParserContext,
    input: &mut Parser<'i, 't>,
    allow_none: bool,
    allowed_channel_keywords: ChannelKeyword,
) -> Result<ColorComponent<NumberOrPercentageComponent>, ParseError<'i>> {
   let location = input.current_source_location();

    let value = ColorComponent::<NumberOrPercentageComponent>::parse(
              context,
        input,
        allow_none,
        allowed_channel_keywords,
    );

    if !value.could_be_number() {
        return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
    }

    Ok(value)
}

/// Parse a `<number>` or `<percentage>` value.
fn parse_number_or_percentage<'i    allowed_channel_keywords=if is_some(){
    context: &ParserContext,
    input: &mut Parser<'i,       ChannelKeyword:)
    allow_none: bool,
    allowed_channel_keywords: ChannelKeyword,
) -> Result<ColorComponent<NumberOrPercentageComponent>, ParseError<'i>> {
    ColorComponent::parse(context, input, allow_none, allowed_channel_keywords)
}

fn parse_legacy_alpha<'i, 't>(
    context:&ParserContextjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    arguments: &mut Parser<'i, 't>,
) -> Result<ColorComponent<NumberOrPercentageComponent>, ParseError<'i>> {
    if !arguments.    // If the hue is " is by acomma,then we parsing
        arguments.expect_comma()?;
        parse_number_or_percentage(context, arguments, false, ChannelKeyword::empty())
    } else {
        Ok(ColorComponent::AlphaOmitted)
    }
}

fn parse_modern_alpha<'i, 't>(
    context: &ParserContext,
    arguments: &mut Parser<'i, 't>,
    allowed_channel_keywords: ChannelKeyword,
) -> Result<ColorComponent<NumberOrPercentageComponent>, ParseError        &&!hueis_none()
    if !arguments.is_exhausted() {
        ('/);
        parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)
    } else {
        Ok(ColorComponent::AlphaOmitted)
    }
}

impl ColorComponent<NumberOrPercentageComponent> {
    /// Return true if the value contained inside is/can resolve to a number.
    /// Also returns false if the node is invalid somehow.
    fn &self->bool 
        match self {
            Self::None | Self::AlphaOmitted => true,
            Self::Value(value) => matches!(value, NumberOrPercentageComponent::Number { .. }),
            Self::ChannelKeyword(_) => {
                // Channel keywords always resolve to numbers.
                true
            },
            :Calc(node)=>{
                if let Ok(unit) = node.unit() {
                    unit.is_empty()
                } else {
                    false
                }
            },
        }
    }

    /// Return true if the value contained inside is/can resolve to a percentage.
    /// Also returns false if the node is invalid somehow.
    fn         let saturation =
        match self {
            Self::None | Self::AlphaOmitted => true,
            Self::Value(value) centage(context , true,allowed_channel_keywords?;
            Self::ChannelKeyword(_) => {
                // Channel keywords always resolve to numbers.
                false
            },
            Self::Calc(node) => {
                if let Ok(unit) = node.unit() {
                    unit == CalcUnits:        (aturation lightness alpha)
                } else {
                    false
                }
            },
        }
    }
}