// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    super::typeface::TypefaceAndLangScore,
    fidl_fuchsia_fonts::{
        self as fonts, Slant, Style2, TypefaceQuery, Width, WEIGHT_MEDIUM, WEIGHT_NORMAL,
    },
    lazy_static::lazy_static,
};

lazy_static! {
    /// The default style (or its individual properties) are is applied to fill any style properties
    /// that are missing from a query passed to the matcher.
    static ref DEFAULT_STYLE: Style2 = Style2 {
        slant: Some(fonts::DEFAULT_SLANT),
        weight: Some(fonts::DEFAULT_WEIGHT),
        width: Some(fonts::DEFAULT_WIDTH),
        ..Style2::EMPTY
    };
}

/// Selects between typefaces `a` and `b` for the `request`. Typefaces are passed in
/// `TypefaceAndLangScore` so the language match score is calculated only once for each typeface. If
/// `a` and `b` are equivalent then `a` is returned.
///
/// The style matching logic follows the CSS3 Fonts spec (see
/// [Section 5.2, Item 4](https://www.w3.org/TR/css-fonts-3/#font-style-matching) with two
/// additions:
///
///   1. Typefaces with a higher language match score are preferred. The score value is expected to
///      be pre-calculated by `get_lang_match_score()`. Note that if the request specifies a code
///      point then the typefaces are expected to be already filtered based on that code point, i.e.
///      they both contain that character, so this function doesn't need to verify it.
///   2. If the request specifies a `fallback_family`, then fonts with the same `fallback_family`
///      are preferred.
///   3. The matcher supports any integer font weight in the range `[1, 1000]`, and not just
///      multiples of 100 as in CSS3. Therefore, if the request specifies a weight between 400
///      (normal) and 500 (medium), inclusive, then then the algorithm used is from
///      [CSS _4_, Section 5.2](https://www.w3.org/TR/css-fonts-4/#font-style-matching), Item 4.3,
///      first bullet.
pub fn select_best_match<'a, 'b>(
    a: TypefaceAndLangScore<'a>,
    b: TypefaceAndLangScore<'a>,
    query: &'b TypefaceQuery,
) -> TypefaceAndLangScore<'a> {
    if a.lang_score != b.lang_score {
        if a.lang_score < b.lang_score {
            return a;
        } else {
            return b;
        }
    }

    if let Some(fallback_family) = query.fallback_family {
        if a.typeface.generic_family != b.typeface.generic_family {
            if a.typeface.generic_family == Some(fallback_family) {
                return a;
            } else if b.typeface.generic_family == Some(fallback_family) {
                return b;
            }
            // If `generic_family` of `a` and `b` doesn't match the request, then fall through to
            // compare them based on style parameters.
        }
    }

    let query_style = query.style.as_ref().unwrap_or(&*DEFAULT_STYLE);
    // Select based on width, see CSS3 Section 5.2, Item 4.a.
    let query_width = query_style.width.unwrap_or(fonts::DEFAULT_WIDTH);
    if a.typeface.width != b.typeface.width {
        // Reorder a and b, so a has lower width.
        let (a, b) = if a.typeface.width > b.typeface.width { (b, a) } else { (a, b) };
        if query_width <= Width::Normal {
            if b.typeface.width <= query_width {
                return b;
            } else {
                return a;
            }
        } else {
            if a.typeface.width >= query_width {
                return a;
            } else {
                return b;
            }
        }
    }

    // Select based on slant, CSS3 Section 5.2, Item 4.b.
    let query_slant = query_style.slant.unwrap_or(fonts::DEFAULT_SLANT);
    match (query_slant, a.typeface.slant, b.typeface.slant) {
        // If both fonts have the same slant then fall through to select based
        // on weight.
        (_, a_s, b_s) if a_s == b_s => (),

        // If we have a font that exactly matches the request's slant, then use it.
        (r_s, a_s, _) if r_s == a_s => return a,
        (r_s, _, b_s) if r_s == b_s => return b,

        // If an italic or oblique font is requested, pick whichever of italic or oblique is
        // available.
        (Slant::Italic, Slant::Oblique, _) => return a,
        (Slant::Italic, _, Slant::Oblique) => return b,

        (Slant::Oblique, Slant::Italic, _) => return a,
        (Slant::Oblique, _, Slant::Italic) => return b,

        // If an upright font is requested, but we have only italic and oblique, then fall through
        // to select based on weight.
        //
        // Technically, we could strictly follow "normal faces are checked first, then oblique
        // faces, then italic faces" in this case, but "User agents are permitted to distinguish
        // between italic and oblique faces within platform font families but this is not required."
        // A better matching weight seems more important.
        (Slant::Upright, _, _) => (),

        // Patterns above cover all possible inputs, but exhaustiveness
        // checker doesn't see it.
        _ => (),
    }

    // Select based on weight, CSS3 Section 5.2, Item 4.c.
    let query_weight = query_style.weight.unwrap_or(fonts::DEFAULT_WEIGHT);
    if a.typeface.weight != b.typeface.weight {
        // Reorder a and b, so a has lower weight.
        let ordered = if a.typeface.weight > b.typeface.weight { (b, a) } else { (a, b) };
        let (a, b) = ordered;

        if a.typeface.weight == query_weight {
            return a;
        }
        if b.typeface.weight == query_weight {
            return b;
        }

        if query_weight < WEIGHT_NORMAL {
            // If query_weight < 400, then typefaces with weights <= query_weight are
            // preferred.
            if b.typeface.weight <= query_weight {
                return b;
            } else {
                return a;
            }
        } else if query_weight > WEIGHT_MEDIUM {
            // If query_weight > 500, then typefaces with weights >= query_weight are
            // preferred.
            if a.typeface.weight >= query_weight {
                return a;
            } else {
                return b;
            }
        } else {
            // This case is not adequately covered in CSS3, which only deals with weights in
            // multiples of 100. Since we support units of 1, we have to resort to CSS4
            // Section 5.2, Item 4.3, first bullet.

            // If query_weight is between 400 and 500, inclusive, then the preferred intervals are
            // 1. `(query_weight, 500]`, in ascending order
            // 2. `[1, query_weight)`, in descending order
            // 3. `[501, 1000]`, in ascending order
            if b.typeface.weight <= WEIGHT_MEDIUM {
                if a.typeface.weight > query_weight {
                    // q...a...b...500
                    return a;
                } else {
                    // a...b...q...500 OR a...q...b...500
                    return b;
                }
            } else {
                return a;
            }
        }
    }

    // If a and b are equivalent then give priority according to the order in the manifest.
    a
}

#[cfg(test)]
mod tests {
    use {
        super::super::{test_util::*, Typeface},
        super::*,
        fidl_fuchsia_fonts::{
            GenericFontFamily, Slant, TypefaceRequestFlags, Width, WEIGHT_BOLD, WEIGHT_EXTRA_BOLD,
            WEIGHT_EXTRA_LIGHT, WEIGHT_LIGHT, WEIGHT_MEDIUM, WEIGHT_NORMAL, WEIGHT_SEMI_BOLD,
            WEIGHT_THIN,
        },
    };

    /// Substitute for `TypefaceAndLangScore` that owns its typeface. Convert to a
    /// `TypefaceAndLangScore` using `(&self).into()`.
    struct TypefaceAndLangScoreWrapper {
        typeface: Typeface,
        lang_score: usize,
    }

    impl From<Typeface> for TypefaceAndLangScoreWrapper {
        fn from(typeface: Typeface) -> Self {
            TypefaceAndLangScoreWrapper { typeface, lang_score: 0 }
        }
    }

    impl<'a> From<&'a Typeface> for TypefaceAndLangScore<'a> {
        fn from(typeface: &'a Typeface) -> Self {
            TypefaceAndLangScore { typeface, lang_score: 0 }
        }
    }

    impl<'a> From<&'a TypefaceAndLangScoreWrapper> for TypefaceAndLangScore<'a> {
        fn from(source: &'a TypefaceAndLangScoreWrapper) -> TypefaceAndLangScore<'a> {
            TypefaceAndLangScore { typeface: &source.typeface, lang_score: source.lang_score }
        }
    }

    fn make_fake_typeface_and_lang_score(
        width: Width,
        slant: Slant,
        weight: u16,
        lang_score: usize,
    ) -> TypefaceAndLangScoreWrapper {
        TypefaceAndLangScoreWrapper {
            typeface: make_fake_typeface_style(width, slant, weight),
            lang_score,
        }
    }

    /// Lang score is more important than everything else.
    #[test]
    fn select_best_match_lang_score_over_others() {
        let better_lang_typeface =
            make_fake_typeface_and_lang_score(Width::Condensed, Slant::Italic, WEIGHT_MEDIUM, 3);
        let worse_lang_typeface = make_fake_typeface_and_lang_score(
            Width::UltraExpanded,
            Slant::Upright,
            WEIGHT_LIGHT,
            6,
        );

        assert_eq!(
            select_best_match(
                (&better_lang_typeface).into(),
                (&worse_lang_typeface).into(),
                make_style_request(Width::UltraExpanded, Slant::Upright, WEIGHT_LIGHT, false)
                    .query
                    .as_ref()
                    .unwrap()
            )
            .typeface,
            &better_lang_typeface.typeface
        );
    }

    /// Generic family is more important than style.
    #[test]
    fn test_fallback_generic_family_over_style() {
        let serif_typeface = make_fake_typeface(
            Width::Condensed,
            Slant::Italic,
            WEIGHT_MEDIUM,
            &vec![],
            &vec![],
            GenericFontFamily::Serif,
        );

        let fantasy_typeface = make_fake_typeface(
            Width::UltraExpanded,
            Slant::Upright,
            WEIGHT_LIGHT,
            &vec![],
            &vec![],
            GenericFontFamily::Fantasy,
        );

        let request = make_typeface_request(
            Width::Condensed,
            Slant::Italic,
            WEIGHT_MEDIUM,
            None,
            TypefaceRequestFlags::empty(),
            GenericFontFamily::Fantasy,
        );

        assert_eq!(
            select_best_match(
                (&serif_typeface).into(),
                (&fantasy_typeface).into(),
                request.query.as_ref().unwrap()
            )
            .typeface,
            &fantasy_typeface
        );
    }

    /// Calls `select_best_match` for the given type faces with the given simplified style request.
    fn compare_for_request<'a>(
        a: &'a Typeface,
        b: &'a Typeface,
        width: impl Into<Option<Width>>,
        slant: impl Into<Option<Slant>>,
        weight: impl Into<Option<u16>>,
    ) -> &'a Typeface {
        let request = make_style_request(width, slant, weight, false);
        select_best_match(a.into(), b.into(), request.query.as_ref().unwrap()).typeface
    }

    /// Width is more important than other style parameters.
    #[test]
    fn select_best_match_width_over_other_style() {
        let extra_condensed_upright_semi_bold =
            make_fake_typeface_style(Width::ExtraCondensed, Slant::Upright, WEIGHT_SEMI_BOLD);
        let condensed_italic_thin =
            make_fake_typeface_style(Width::Condensed, Slant::Italic, WEIGHT_THIN);

        assert_eq!(
            compare_for_request(
                &extra_condensed_upright_semi_bold,
                &condensed_italic_thin,
                Width::Condensed,
                Slant::Upright,
                WEIGHT_SEMI_BOLD
            )
            .width,
            Width::Condensed
        );
    }

    /// Uses default width value when omitted.
    #[test]
    fn select_best_match_width_default() {
        let extra_condensed_upright_semi_bold =
            make_fake_typeface_style(Width::ExtraCondensed, Slant::Upright, WEIGHT_SEMI_BOLD);
        let normal_italic_thin =
            make_fake_typeface_style(Width::Normal, Slant::Italic, WEIGHT_THIN);
        let extra_expanded_oblique_normal =
            make_fake_typeface_style(Width::ExtraExpanded, Slant::Oblique, WEIGHT_NORMAL);

        assert_eq!(
            compare_for_request(
                &extra_condensed_upright_semi_bold,
                &normal_italic_thin,
                None,
                Slant::Italic,
                WEIGHT_NORMAL
            )
            .width,
            Width::Normal
        );
        assert_eq!(
            compare_for_request(
                &normal_italic_thin,
                &extra_expanded_oblique_normal,
                None,
                Slant::Italic,
                WEIGHT_NORMAL
            )
            .width,
            Width::Normal
        );
    }

    fn make_width_style(width: Width) -> Typeface {
        make_fake_typeface_style(width, Slant::Upright, WEIGHT_NORMAL)
    }

    /// For requested width <= Normal (5), the priority is lower widths descending, then higher
    /// widths ascending.
    #[test]
    fn select_best_match_width_normal_or_condensed_prefers_lower_widths() {
        assert_eq!(
            compare_for_request(
                &make_width_style(Width::UltraCondensed),
                &make_width_style(Width::Condensed),
                Width::ExtraCondensed,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::UltraCondensed
        );

        assert_eq!(
            compare_for_request(
                &make_width_style(Width::Condensed),
                &make_width_style(Width::Normal),
                Width::SemiCondensed,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::Condensed
        );

        // This makes no sense as a user, but it's what the spec apparently dictates.
        assert_eq!(
            compare_for_request(
                &make_width_style(Width::UltraCondensed),
                &make_width_style(Width::SemiExpanded),
                Width::Normal,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::UltraCondensed
        );
    }

    /// For requested width >= SemiExpanded (6), the priority is higher widths ascending, then lower
    /// widths descending.
    #[test]
    fn select_best_match_width_expanded_prefers_higher_widths() {
        assert_eq!(
            compare_for_request(
                &make_width_style(Width::Normal),
                &make_width_style(Width::Expanded),
                Width::SemiExpanded,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::Expanded
        );

        assert_eq!(
            compare_for_request(
                &make_width_style(Width::Expanded),
                &make_width_style(Width::UltraExpanded),
                Width::ExtraExpanded,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::UltraExpanded
        );

        assert_eq!(
            compare_for_request(
                &make_width_style(Width::ExtraExpanded),
                &make_width_style(Width::UltraExpanded),
                Width::Expanded,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::ExtraExpanded
        );

        // Follow the spec, not common sense.
        assert_eq!(
            compare_for_request(
                &make_width_style(Width::Normal),
                &make_width_style(Width::UltraExpanded),
                Width::SemiExpanded,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .width,
            Width::UltraExpanded
        );
    }

    /// Slant is more important than weight.
    #[test]
    fn select_best_match_slant_vs_weight() {
        let italic_thin = make_fake_typeface_style(Width::Normal, Slant::Italic, WEIGHT_THIN);
        let upright_semi_bold =
            make_fake_typeface_style(Width::Normal, Slant::Upright, WEIGHT_SEMI_BOLD);
        let oblique_normal = make_fake_typeface_style(Width::Normal, Slant::Oblique, WEIGHT_NORMAL);

        assert_eq!(
            compare_for_request(
                &italic_thin,
                &upright_semi_bold,
                Width::Condensed,
                Slant::Upright,
                WEIGHT_THIN
            )
            .slant,
            Slant::Upright
        );

        assert_eq!(
            compare_for_request(
                &upright_semi_bold,
                &oblique_normal,
                Width::Condensed,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Upright
        );
    }

    /// Uses default slant value when omitted.
    #[test]
    fn select_best_match_slant_default() {
        let italic_thin = make_fake_typeface_style(Width::Normal, Slant::Italic, WEIGHT_THIN);
        let upright_semi_bold =
            make_fake_typeface_style(Width::Normal, Slant::Upright, WEIGHT_SEMI_BOLD);
        let oblique_normal = make_fake_typeface_style(Width::Normal, Slant::Oblique, WEIGHT_NORMAL);

        assert_eq!(
            compare_for_request(
                &italic_thin,
                &upright_semi_bold,
                Width::Condensed,
                None,
                WEIGHT_THIN
            )
            .slant,
            Slant::Upright
        );

        assert_eq!(
            compare_for_request(
                &upright_semi_bold,
                &oblique_normal,
                Width::Condensed,
                None,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Upright
        );
    }

    fn make_slant_style(slant: Slant) -> Typeface {
        make_fake_typeface_style(Width::Normal, slant, WEIGHT_NORMAL)
    }

    #[test]
    fn select_best_match_slant_exact_match() {
        assert_eq!(
            compare_for_request(
                &make_slant_style(Slant::Upright),
                &make_slant_style(Slant::Oblique),
                Width::Normal,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Upright
        );

        assert_eq!(
            compare_for_request(
                &make_slant_style(Slant::Italic),
                &make_slant_style(Slant::Oblique),
                Width::Normal,
                Slant::Oblique,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Oblique
        );

        assert_eq!(
            compare_for_request(
                &make_slant_style(Slant::Italic),
                &make_slant_style(Slant::Oblique),
                Width::Normal,
                Slant::Italic,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Italic
        );
    }

    /// Oblique can be substituted for italic and vice versa.
    #[test]
    fn select_best_match_slant_substitutes() {
        assert_eq!(
            compare_for_request(
                &make_slant_style(Slant::Upright),
                &make_slant_style(Slant::Oblique),
                Width::Normal,
                Slant::Italic,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Oblique
        );

        assert_eq!(
            compare_for_request(
                &make_slant_style(Slant::Upright),
                &make_slant_style(Slant::Italic),
                Width::Normal,
                Slant::Oblique,
                WEIGHT_NORMAL
            )
            .slant,
            Slant::Italic
        );
    }

    /// Requesting upright when it's unavailable means fall through to weight.
    #[test]
    fn select_best_match_slant_no_upright() {
        assert_eq!(
            compare_for_request(
                &make_fake_typeface_style(Width::Normal, Slant::Italic, WEIGHT_THIN),
                &make_fake_typeface_style(Width::Normal, Slant::Oblique, WEIGHT_BOLD),
                Width::Normal,
                Slant::Upright,
                WEIGHT_BOLD
            )
            .weight,
            WEIGHT_BOLD
        );
    }

    fn make_weight_style(weight: u16) -> Typeface {
        make_fake_typeface_style(Width::Normal, Slant::Upright, weight)
    }

    /// Uses default weight value when omitted.
    #[test]
    fn select_best_match_weight_default() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_BOLD),
                &make_weight_style(WEIGHT_NORMAL),
                Width::Normal,
                Slant::Upright,
                None
            )
            .weight,
            WEIGHT_NORMAL
        );
    }

    #[test]
    fn select_best_match_weight_exact_match() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_BOLD),
                &make_weight_style(WEIGHT_NORMAL),
                Width::Normal,
                Slant::Upright,
                WEIGHT_BOLD
            )
            .weight,
            WEIGHT_BOLD
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(517),
                &make_weight_style(WEIGHT_THIN),
                Width::Normal,
                Slant::Upright,
                517
            )
            .weight,
            517
        );
    }

    /// For requested weight < `WEIGHT_NORMAL`, the priority is lower weights descending, then
    /// higher weights ascending.
    #[test]
    fn select_best_match_weight_thinner_prefers_thinner() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_THIN),
                &make_weight_style(WEIGHT_EXTRA_LIGHT),
                Width::Normal,
                Slant::Upright,
                WEIGHT_LIGHT
            )
            .weight,
            WEIGHT_EXTRA_LIGHT
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_THIN),
                &make_weight_style(WEIGHT_LIGHT),
                Width::Normal,
                Slant::Upright,
                WEIGHT_EXTRA_LIGHT
            )
            .weight,
            WEIGHT_THIN
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_SEMI_BOLD),
                &make_weight_style(WEIGHT_EXTRA_BOLD),
                Width::Normal,
                Slant::Upright,
                WEIGHT_LIGHT
            )
            .weight,
            WEIGHT_SEMI_BOLD
        );
    }

    /// For requested weight > `WEIGHT_MEDIUM`, the priority is higher weights ascending, then lower
    /// weights descending.
    #[test]
    fn select_best_match_weight_thicker_prefers_thicker() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_SEMI_BOLD),
                &make_weight_style(WEIGHT_EXTRA_BOLD),
                Width::Normal,
                Slant::Upright,
                WEIGHT_BOLD
            )
            .weight,
            WEIGHT_EXTRA_BOLD
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_THIN),
                &make_weight_style(WEIGHT_NORMAL),
                Width::Normal,
                Slant::Upright,
                WEIGHT_EXTRA_BOLD
            )
            .weight,
            WEIGHT_NORMAL
        );
    }

    /// For requested weight `WEIGHT_NORMAL`, `WEIGHT_MEDIUM` is preferred, followed by lower
    /// weights.
    #[test]
    fn select_best_match_weight_normal_prefers_medium_then_thinner() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_MEDIUM),
                &make_weight_style(WEIGHT_LIGHT),
                Width::Normal,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .weight,
            WEIGHT_MEDIUM
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_BOLD),
                &make_weight_style(WEIGHT_EXTRA_LIGHT),
                Width::Normal,
                Slant::Upright,
                WEIGHT_NORMAL
            )
            .weight,
            WEIGHT_EXTRA_LIGHT
        );
    }

    /// For requested weight `WEIGHT_MEDIUM`, `WEIGHT_NORMAL` is preferred, followed by lower
    /// weights.
    #[test]
    fn select_best_match_weight_medium_prefers_normal_then_thinner() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_NORMAL),
                &make_weight_style(WEIGHT_EXTRA_BOLD),
                Width::Normal,
                Slant::Upright,
                WEIGHT_MEDIUM
            )
            .weight,
            WEIGHT_NORMAL
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(WEIGHT_LIGHT),
                &make_weight_style(WEIGHT_BOLD),
                Width::Normal,
                Slant::Upright,
                WEIGHT_MEDIUM
            )
            .weight,
            WEIGHT_LIGHT
        );
    }

    /// For requested weight between `WEIGHT_NORMAL` and `WEIGHT_MEDIUM`, inclusive, weights above
    /// the requested <= 500 are preferred, then below the requested descending, then above 500
    /// ascending.
    #[test]
    fn select_best_match_weight_between_normal_and_medium() {
        assert_eq!(
            compare_for_request(
                &make_weight_style(440),
                &make_weight_style(460),
                Width::Normal,
                Slant::Upright,
                450
            )
            .weight,
            460
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(440),
                &make_weight_style(500),
                Width::Normal,
                Slant::Upright,
                450
            )
            .weight,
            500
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(440),
                &make_weight_style(501),
                Width::Normal,
                Slant::Upright,
                450
            )
            .weight,
            440
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(300),
                &make_weight_style(501),
                Width::Normal,
                Slant::Upright,
                450
            )
            .weight,
            300
        );

        assert_eq!(
            compare_for_request(
                &make_weight_style(413),
                &make_weight_style(449),
                Width::Normal,
                Slant::Upright,
                450
            )
            .weight,
            449
        );
    }
}