fn from(p: azul_simplecss::ErrorPos) -> Self {

        Self { row: p.row, col: p.col }

    }

    fn from(e: SimplecssError) -> Self {

        match e {

            SimplecssError::UnexpectedEndOfStream(pos) => Self::UnexpectedEndOfStream(pos.into()),

            SimplecssError::UnknownToken(pos) => Self::UnknownToken(pos.into()),

    }

    #[must_use] pub fn to_contained(&self) -> CssParseErrorOwned {

        CssParseErrorOwned {

            css_string: self.css_string.to_string().into(),

            error: self.error.to_contained(),

            location: self.location,

        }

    }

    #[must_use] pub fn to_shared(&self) -> CssParseError<'_> {

        CssParseError {

            css_string: self.css_string.as_str(),

            error: self.error.to_shared(),

            location: self.location,

        }

    }

fn clamp_to_char_boundary(s: &str, pos: usize) -> usize {

    let mut pos = pos.min(s.len());

    while pos > 0 && !s.is_char_boundary(pos) {

        pos -= 1;

    }

    pos

}

    #[must_use] pub fn get_error_string(&self) -> &'a str {

        let (start, end) = (self.location.start.original_pos, self.location.end.original_pos);

        let start = clamp_to_char_boundary(self.css_string, start);

        let end = clamp_to_char_boundary(self.css_string, end);

        let (start, end) = (start.min(end), start.max(end));

        self.css_string[start..end].trim()

    }

    #[must_use] pub fn to_contained(&self) -> CssParseErrorInnerOwned {

        match self {

            CssParseErrorInner::ParseError(e) => CssParseErrorInnerOwned::ParseError(*e),

            CssParseErrorInner::UnclosedBlock => CssParseErrorInnerOwned::UnclosedBlock,

            CssParseErrorInner::MalformedCss => CssParseErrorInnerOwned::MalformedCss,

            CssParseErrorInner::DynamicCssParseError(e) => {

                CssParseErrorInnerOwned::DynamicCssParseError(e.to_contained())

            CssParseErrorInner::PseudoSelectorParseError(e) => {

                CssParseErrorInnerOwned::PseudoSelectorParseError(e.to_contained())

            CssParseErrorInner::NodeTypeTag(e) => {

                CssParseErrorInnerOwned::NodeTypeTag(e.to_contained())

            CssParseErrorInner::UnknownPropertyKey(a, b) => {

                CssParseErrorInnerOwned::UnknownPropertyKey(UnknownPropertyKeyError { key: (*a).to_string().into(), value: (*b).to_string().into() })

            CssParseErrorInner::VarOnShorthandProperty { key, value } => {

                CssParseErrorInnerOwned::VarOnShorthandProperty(VarOnShorthandPropertyError {

                    key: *key,

                    value: (*value).to_string().into(),

                })

    }

    #[must_use] pub fn to_shared(&self) -> CssParseErrorInner<'_> {

        match self {

            Self::ParseError(e) => CssParseErrorInner::ParseError(*e),

            Self::UnclosedBlock => CssParseErrorInner::UnclosedBlock,

            Self::MalformedCss => CssParseErrorInner::MalformedCss,

            Self::DynamicCssParseError(e) => {

                CssParseErrorInner::DynamicCssParseError(e.to_shared())

            Self::PseudoSelectorParseError(e) => {

                CssParseErrorInner::PseudoSelectorParseError(e.to_shared())

            Self::NodeTypeTag(e) => {

                CssParseErrorInner::NodeTypeTag(e.to_shared())

            Self::UnknownPropertyKey(e) => {

                CssParseErrorInner::UnknownPropertyKey(e.key.as_str(), e.value.as_str())

            Self::VarOnShorthandProperty(e) => {

                CssParseErrorInner::VarOnShorthandProperty {

                    key: e.key,

                    value: e.value.as_str(),

                }

    }

    fn from(e: SimplecssError) -> Self {

        CssParseErrorInner::ParseError(CssSyntaxError::from(e))

    }

    fn from(e: ParseIntError) -> Self {

        CssPseudoSelectorParseError::InvalidNthChild(e)

    }

    #[must_use] pub fn to_contained(&self) -> CssPseudoSelectorParseErrorOwned {

        match self {

                CssPseudoSelectorParseErrorOwned::EmptyNthChild

            CssPseudoSelectorParseError::UnknownSelector(a, b) => {

                    selector: (*a).to_string().into(),

                    suggestion: b.map(|s| AzString::from(s.to_string())).into(),

            CssPseudoSelectorParseError::InvalidNthChildPattern(s) => {

                CssPseudoSelectorParseErrorOwned::InvalidNthChildPattern((*s).to_string().into())

            CssPseudoSelectorParseError::InvalidNthChild(e) => {

                CssPseudoSelectorParseErrorOwned::InvalidNthChild(e.clone().into())

    }

    #[must_use] pub fn to_shared(&self) -> CssPseudoSelectorParseError<'_> {

        match self {

                CssPseudoSelectorParseError::EmptyNthChild

            Self::UnknownSelector(e) => {

                CssPseudoSelectorParseError::UnknownSelector(e.selector.as_str(), e.suggestion.as_ref().map(AzString::as_str))

            Self::InvalidNthChildPattern(s) => {

                CssPseudoSelectorParseError::InvalidNthChildPattern(s)

            Self::InvalidNthChild(e) => {

                CssPseudoSelectorParseError::InvalidNthChild(e.to_std())

    }

    fn from(e: CssParsingError<'a>) -> Self {

        DynamicCssParseError::UnexpectedValue(e)

    }

    #[must_use] pub fn to_contained(&self) -> DynamicCssParseErrorOwned {

        match self {

            DynamicCssParseError::InvalidBraceContents(s) => {

                DynamicCssParseErrorOwned::InvalidBraceContents((*s).to_string().into())

            DynamicCssParseError::UnexpectedValue(e) => {

                DynamicCssParseErrorOwned::UnexpectedValue(e.to_contained())

    }

    #[must_use] pub fn to_shared(&self) -> DynamicCssParseError<'_> {

        match self {

            Self::InvalidBraceContents(s) => {

                DynamicCssParseError::InvalidBraceContents(s)

            Self::UnexpectedValue(e) => {

                DynamicCssParseError::UnexpectedValue(e.to_shared())

    }

pub fn pseudo_selector_from_str<'a>(

    selector: &'a str,

    value: Option<&'a str>,

) -> Result<CssPathPseudoSelector, CssPseudoSelectorParseError<'a>> {

    match selector {

        "first" => Ok(CssPathPseudoSelector::First),

        "last" => Ok(CssPathPseudoSelector::Last),

        "hover" => Ok(CssPathPseudoSelector::Hover),

        "active" => Ok(CssPathPseudoSelector::Active),

        "focus" => Ok(CssPathPseudoSelector::Focus),

        "dragging" => Ok(CssPathPseudoSelector::Dragging),

        "drag-over" => Ok(CssPathPseudoSelector::DragOver),

        "root" => Ok(CssPathPseudoSelector::Root),

        "nth-child" => {

            let value = value.ok_or(CssPseudoSelectorParseError::EmptyNthChild)?;

            let parsed = parse_nth_child_selector(value)?;

            Ok(CssPathPseudoSelector::NthChild(parsed))

        "lang" => {

            let lang_value = value.ok_or(CssPseudoSelectorParseError::UnknownSelector(

                selector, value,

            ))?;

            let lang_value = lang_value

                .trim()

                .trim_start_matches('"')

                .trim_end_matches('"')

                .trim_start_matches('\'')

                .trim_end_matches('\'')

                .trim();

            Ok(CssPathPseudoSelector::Lang(AzString::from(

                lang_value.to_string(),

            )))

        _ => Err(CssPseudoSelectorParseError::UnknownSelector(

            selector, value,

        )),

}

#[must_use] pub fn parse_attribute_selector(input: &str) -> Option<CssAttributeSelector> {

    let s = input.trim();

    if s.is_empty() {

        return None;

    }

    let compound_ops: [(&str, AttributeMatchOp); 5] = [

        ("~=", AttributeMatchOp::Includes),

        ("|=", AttributeMatchOp::DashMatch),

        ("^=", AttributeMatchOp::Prefix),

        ("$=", AttributeMatchOp::Suffix),

        ("*=", AttributeMatchOp::Substring),

    ];

    let (op, op_pos): (AttributeMatchOp, Option<usize>) = compound_ops

        .iter()

        .find_map(|(pat, op)| s.find(pat).map(|i| (*op, Some(i))))

        .or_else(|| s.find('=').map(|i| (AttributeMatchOp::Eq, Some(i))))

        .unwrap_or((AttributeMatchOp::Exists, None));

    let (name, value) = match op_pos {

        None => (s, None),

        Some(i) => {

            let name = s[..i].trim();

            let op_len = if matches!(op, AttributeMatchOp::Eq) { 1 } else { 2 };

            let raw_value = s[i + op_len..].trim();

            let unquoted = strip_attribute_quotes(raw_value)?;

            (name, Some(unquoted))

    if name.is_empty() {

        return None;

    }

    if name.chars().any(|c| c.is_whitespace() || c == '"' || c == '\'') {

        return None;

    }

        name: name.to_string().into(),

        op,

        value: value

            .map_or_else(|| OptionString::None, |v| OptionString::Some(v.to_string().into())),

}

fn strip_attribute_quotes(s: &str) -> Option<&str> {

    let bytes = s.as_bytes();

    if bytes.len() >= 2 {

        let first = bytes[0];

        let last = bytes[bytes.len() - 1];

        if (first == b'"' && last == b'"') || (first == b'\'' && last == b'\'') {

            return Some(&s[1..s.len() - 1]);

        }

        if first == b'"' || first == b'\'' || last == b'"' || last == b'\'' {

            return None;

        }

    } else if bytes.len() == 1 && (bytes[0] == b'"' || bytes[0] == b'\'') {

        return None;

    }

    Some(s)

}

fn parse_nth_child_selector(

    value: &str,

) -> Result<CssNthChildSelector, CssPseudoSelectorParseError<'_>> {

    let value = value.trim();

    if value.is_empty() {

        return Err(CssPseudoSelectorParseError::EmptyNthChild);

    }

    if let Ok(number) = value.parse::<u32>() {

        return Ok(CssNthChildSelector::Number(number));

    }

    match value {

        "even" => Ok(CssNthChildSelector::Even),

        "odd" => Ok(CssNthChildSelector::Odd),

        _ => parse_nth_child_pattern(value),

}

fn parse_nth_child_pattern(

    value: &str,

) -> Result<CssNthChildSelector, CssPseudoSelectorParseError<'_>> {

    let value = value.trim();

    if value.is_empty() {

        return Err(CssPseudoSelectorParseError::EmptyNthChild);

    }

    let repeat = value

        .split('n')

        .next()

        .ok_or(CssPseudoSelectorParseError::InvalidNthChildPattern(value))?

        .trim()

        .parse::<u32>()?;

    let mut offset_iterator = value.split('+');

    offset_iterator.next().unwrap();

    let offset = match offset_iterator.next() {

        Some(offset_string) => {

            let offset_string = offset_string.trim();

            if offset_string.is_empty() {

                return Err(CssPseudoSelectorParseError::InvalidNthChildPattern(value));

            }

            offset_string.parse::<u32>()?

        None => 0,

    Ok(CssNthChildSelector::Pattern(CssNthChildPattern {

        pattern_repeat: repeat,

        offset,

    }))

}

    #[must_use] pub fn get_line_column_from_error(&self, css_string: &str) -> (usize, usize) {

        let error_location =

            clamp_to_char_boundary(css_string, self.original_pos.saturating_sub(1));

        let (mut line_number, mut total_characters) = (0, 0);

        for line in css_string[0..error_location].lines() {

            line_number += 1;

            total_characters += line.chars().count();

        }

        let total_characters = total_characters + line_number;

        let column_pos = error_location - total_characters.saturating_sub(2);

        (line_number, column_pos)

    }

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let start_location = self.location.start.get_line_column_from_error(self.css_string);

        let end_location = self.location.end.get_line_column_from_error(self.css_string);

        write!(

            f,

            "    start: line {}:{}\r\n    end: line {}:{}\r\n    text: \"{}\"\r\n    reason: {}",

            self.get_error_string(),

    }

#[must_use] pub fn new_from_str(css_string: &str) -> (Css, Vec<CssParseWarnMsg<'_>>) {

    let mut tokenizer = Tokenizer::new(css_string);

    let mut keyframes: Vec<crate::css::Keyframes> = Vec::new();

    let (rules, warnings) = new_from_str_inner(css_string, &mut tokenizer, &mut keyframes);

    (

        Css { rules: rules.into(), keyframes: keyframes.into() },

        warnings,

    )

}

fn stop_selector_permille(sel: &str) -> Option<u16> {

    match sel {

        "from" => Some(0),

        "to" => Some(1000),

        s => s.strip_suffix('%').and_then(|n| {

            n.trim().parse::<f32>().ok().and_then(|pct| {

                if (0.0..=100.0).contains(&pct) {

                    Some((pct * 10.0).round() as u16)

            })

        }),

}

fn get_error_location(tokenizer: &Tokenizer<'_>) -> ErrorLocation {

    ErrorLocation {

        original_pos: tokenizer.pos(),

    }

}

    fn from(e: SimplecssError) -> Self {

        CssPathParseError::SyntaxError(CssSyntaxError::from(e))

    }

    #[must_use] pub fn to_contained(&self) -> CssPathParseErrorOwned {

        match self {

            CssPathParseError::EmptyPath => CssPathParseErrorOwned::EmptyPath,

            CssPathParseError::InvalidTokenEncountered(s) => {

                CssPathParseErrorOwned::InvalidTokenEncountered((*s).to_string().into())

            CssPathParseError::UnexpectedEndOfStream(s) => {

                CssPathParseErrorOwned::UnexpectedEndOfStream((*s).to_string().into())

            CssPathParseError::SyntaxError(e) => CssPathParseErrorOwned::SyntaxError(*e),

            CssPathParseError::NodeTypeTag(e) => {

                CssPathParseErrorOwned::NodeTypeTag(e.to_contained())

            CssPathParseError::PseudoSelectorParseError(e) => {

                CssPathParseErrorOwned::PseudoSelectorParseError(e.to_contained())

    }

    #[must_use] pub fn to_shared(&self) -> CssPathParseError<'_> {

        match self {

            Self::EmptyPath => CssPathParseError::EmptyPath,

            Self::InvalidTokenEncountered(s) => {

                CssPathParseError::InvalidTokenEncountered(s)

            Self::UnexpectedEndOfStream(s) => {

                CssPathParseError::UnexpectedEndOfStream(s)

            Self::SyntaxError(e) => CssPathParseError::SyntaxError(*e),

            Self::NodeTypeTag(e) => CssPathParseError::NodeTypeTag(e.to_shared()),

            Self::PseudoSelectorParseError(e) => {

                CssPathParseError::PseudoSelectorParseError(e.to_shared())

    }

pub fn parse_css_path(input: &str) -> Result<CssPath, CssPathParseError<'_>> {

    let input = input.trim();

    if input.is_empty() {

        return Err(CssPathParseError::EmptyPath);

    }

    let mut tokenizer = Tokenizer::new(input);

    let mut selectors = Vec::new();

        let token = tokenizer.parse_next()?;

        match token {

            Token::UniversalSelector => {

                selectors.push(CssPathSelector::Global);

            }

            Token::TypeSelector(div_type) => match NodeTypeTag::from_str(div_type) {

                Ok(nt) => selectors.push(CssPathSelector::Type(nt)),

                Err(e) => return Err(CssPathParseError::NodeTypeTag(e)),

            Token::IdSelector(id) => {

                selectors.push(CssPathSelector::Id(id.to_string().into()));

            }

            Token::ClassSelector(class) => {

                selectors.push(CssPathSelector::Class(class.to_string().into()));

            }

            Token::Combinator(Combinator::GreaterThan) => {

                selectors.push(CssPathSelector::DirectChildren);

            }

            Token::Combinator(Combinator::Space) => {

                selectors.push(CssPathSelector::Children);

            }

            Token::PseudoClass { selector, value } => {

                selectors.push(CssPathSelector::PseudoSelector(pseudo_selector_from_str(

                    selector, value,

                )?));

                break;

                return Err(CssPathParseError::InvalidTokenEncountered(input));

    if selectors.is_empty() {

        Err(CssPathParseError::EmptyPath)

        Ok(CssPath {

            selectors: selectors.into(),

        })

}

    #[must_use] pub fn to_contained(&self) -> UnparsedCssRuleBlockOwned {

            path: self.path.clone(),

            declarations: self

                .declarations

                .iter()

                .map(|(k, (v, loc))| ((*k).to_string(), ((*v).to_string(), *loc)))

                .collect(),

            conditions: self.conditions.clone(),

    }

    #[must_use] pub fn to_shared(&self) -> UnparsedCssRuleBlock<'_> {

            path: self.path.clone(),

            declarations: self

                .declarations

                .iter()

                .map(|(k, (v, loc))| (k.as_str(), (v.as_str(), *loc)))

                .collect(),

            conditions: self.conditions.clone(),

    }

    #[must_use] pub fn to_contained(&self) -> CssParseWarnMsgOwned {

        CssParseWarnMsgOwned {

            warning: self.warning.to_contained(),

            location: self.location,

        }

    }

    #[must_use] pub fn to_shared(&self) -> CssParseWarnMsg<'_> {

        CssParseWarnMsg {

            warning: self.warning.to_shared(),

            location: self.location,

        }

    }

    #[must_use] pub fn to_contained(&self) -> CssParseWarnMsgInnerOwned {

        match self {

            Self::UnsupportedKeyValuePair { key, value } => {

                CssParseWarnMsgInnerOwned::UnsupportedKeyValuePair {

                    key: (*key).to_string(),

                    value: (*value).to_string(),

                }

            Self::ParseError(e) => CssParseWarnMsgInnerOwned::ParseError(e.to_contained()),

            Self::SkippedRule { selector, error } => CssParseWarnMsgInnerOwned::SkippedRule {

                selector: selector.map(std::string::ToString::to_string),

                error: error.to_contained(),

            },

            Self::SkippedDeclaration { key, value, error } => {

                CssParseWarnMsgInnerOwned::SkippedDeclaration {

                    key: (*key).to_string(),

                    value: (*value).to_string(),

                    error: error.to_contained(),

                }

            Self::MalformedStructure { message } => CssParseWarnMsgInnerOwned::MalformedStructure {

                message: (*message).to_string(),

            },

    }

    #[must_use] pub fn to_shared(&self) -> CssParseWarnMsgInner<'_> {

        match self {

            Self::UnsupportedKeyValuePair { key, value } => {

                CssParseWarnMsgInner::UnsupportedKeyValuePair { key, value }

            Self::ParseError(e) => CssParseWarnMsgInner::ParseError(e.to_shared()),

            Self::SkippedRule { selector, error } => CssParseWarnMsgInner::SkippedRule {

                selector: selector.as_deref(),

                error: error.to_shared(),

            },

            Self::SkippedDeclaration { key, value, error } => {

                CssParseWarnMsgInner::SkippedDeclaration {

                    key,

                    value,

                    error: error.to_shared(),

                }

            Self::MalformedStructure { message } => {

                CssParseWarnMsgInner::MalformedStructure { message }

    }

fn parse_media_conditions(content: &str) -> Vec<DynamicSelector> {

    let mut conditions = Vec::new();

    let content = content.trim();

    if content.eq_ignore_ascii_case("screen") {

        conditions.push(DynamicSelector::Media(MediaType::Screen));

        return conditions;

    }

    if content.eq_ignore_ascii_case("print") {

        conditions.push(DynamicSelector::Media(MediaType::Print));

        return conditions;

    }

    if content.eq_ignore_ascii_case("all") {

        conditions.push(DynamicSelector::Media(MediaType::All));

        return conditions;

    }

    for part in content.split(" and ") {

        let part = part.trim();

        if part.eq_ignore_ascii_case("screen")

            || part.eq_ignore_ascii_case("print")

            || part.eq_ignore_ascii_case("all")

            if part.eq_ignore_ascii_case("screen") {

                conditions.push(DynamicSelector::Media(MediaType::Screen));

            } else if part.eq_ignore_ascii_case("print") {

            continue;

        }

        if let Some(inner) = part.strip_prefix('(').and_then(|s| s.strip_suffix(')')) {

            if let Some(selector) = parse_media_feature(inner) {

                conditions.push(selector);

            }

        }

    conditions

}

fn parse_media_feature(feature: &str) -> Option<DynamicSelector> {

    let parts: Vec<&str> = feature.splitn(2, ':').collect();

    if parts.len() != 2 {

        return None;

    }

    let key = parts[0].trim();

    let value = parts[1].trim();

    match key.to_lowercase().as_str() {

        "min-width" => {

            if let Some(px) = parse_px_value(value) {

                return Some(DynamicSelector::ViewportWidth(MinMaxRange::new(

                    Some(px),

                    None,

                )));

            }

        "max-width" => {

            if let Some(px) = parse_px_value(value) {

                return Some(DynamicSelector::ViewportWidth(MinMaxRange::new(

                    None,

                    Some(px),

                )));

            }

        "min-height" => {

            if let Some(px) = parse_px_value(value) {

                return Some(DynamicSelector::ViewportHeight(MinMaxRange::new(

                    Some(px),

                    None,

                )));

        "max-height" => {

            if let Some(px) = parse_px_value(value) {

                return Some(DynamicSelector::ViewportHeight(MinMaxRange::new(

                    None,

                    Some(px),

                )));

        "orientation" => {

            if value.eq_ignore_ascii_case("portrait") {

                return Some(DynamicSelector::Orientation(OrientationType::Portrait));

            } else if value.eq_ignore_ascii_case("landscape") {

                return Some(DynamicSelector::Orientation(OrientationType::Landscape));

            }

        "prefers-color-scheme" => {

            if value.eq_ignore_ascii_case("dark") {

                return Some(DynamicSelector::Theme(ThemeCondition::Dark));

        "prefers-reduced-motion" => {

            if value.eq_ignore_ascii_case("reduce") {

                return Some(DynamicSelector::PrefersReducedMotion(BoolCondition::True));

        "prefers-contrast" | "prefers-high-contrast" => {

            if value.eq_ignore_ascii_case("more") || value.eq_ignore_ascii_case("high") || value.eq_ignore_ascii_case("active") {

                return Some(DynamicSelector::PrefersHighContrast(BoolCondition::True));

        "aspect-ratio" => {

        "min-aspect-ratio" => {

        "max-aspect-ratio" => {

        _ => {}

    None

}

fn parse_px_value(value: &str) -> Option<f32> {

    let value = value.trim();

    value

        .strip_suffix("px")

        .map_or_else(

            || value.parse::<f32>().ok(),

            |num_str| num_str.trim().parse::<f32>().ok(),

        .filter(|v| v.is_finite())

}

fn parse_ratio_value(value: &str) -> Option<f32> {

    let value = value.trim();

    if let Some((num, den)) = value.split_once('/') {

        let num: f32 = num.trim().parse().ok()?;

        let den: f32 = den.trim().parse().ok()?;

        if den == 0.0 { return None; }

        Some(num / den).filter(|r| r.is_finite())

        value.parse::<f32>().ok().filter(|r| r.is_finite())

}

fn parse_container_conditions(content: &str) -> Vec<DynamicSelector> {

    let mut conditions = Vec::new();

    let content = content.trim();

    let (name_part, query_part) = if content.starts_with('(') {

        (None, content)

    } else if let Some(paren_idx) = content.find('(') {

        let name = content[..paren_idx].trim();

        if name.is_empty() {

            (Some(name), &content[paren_idx..])

        if !content.is_empty() {

            conditions.push(DynamicSelector::ContainerName(AzString::from(content.to_string())));

        }

        return conditions;

    if let Some(name) = name_part {

        conditions.push(DynamicSelector::ContainerName(AzString::from(name.to_string())));

    }

    for part in query_part.split(" and ") {

        let part = part.trim();

        if let Some(inner) = part.strip_prefix('(').and_then(|s| s.strip_suffix(')')) {

            if let Some(selector) = parse_container_feature(inner) {

                conditions.push(selector);

            }

        }

    conditions

}

fn parse_container_feature(feature: &str) -> Option<DynamicSelector> {

    let (key, value) = feature.split_once(':')?;

    let key = key.trim();

    let value = value.trim();

    match key.to_lowercase().as_str() {

        "min-width" => {

            parse_px_value(value).map(|px| DynamicSelector::ContainerWidth(MinMaxRange::new(Some(px), None)))

        "max-width" => {

            parse_px_value(value).map(|px| DynamicSelector::ContainerWidth(MinMaxRange::new(None, Some(px))))

        "min-height" => {

            parse_px_value(value).map(|px| DynamicSelector::ContainerHeight(MinMaxRange::new(Some(px), None)))

        "max-height" => {

        "aspect-ratio" => {

        "min-aspect-ratio" => {

        "max-aspect-ratio" => {