pub fn font_ref_from_bytes(

    font_bytes: &[u8],

    font_index: usize,

    parse_outlines: bool,

) -> Option<FontRef> {

    let mut warnings = Vec::new();

    let parsed_font = ParsedFont::from_bytes(font_bytes, font_index, &mut warnings)?;

    Some(crate::parsed_font_to_font_ref(parsed_font))

}

    pub fn load_from_path(&self, path: &Path, font_index: usize) -> Result<FontRef, LayoutError> {

        let font_bytes = std::fs::read(path).map_err(|_| {

            LayoutError::FontNotFound(FontSelector {

                family: path.to_string_lossy().into_owned(),

                weight: rust_fontconfig::FcWeight::Normal,

                style: crate::text3::cache::FontStyle::Normal,

                unicode_ranges: Vec::new(),

            })

        })?;

        let arc_owned = std::sync::Arc::<[u8]>::from(font_bytes);

        let bytes = std::sync::Arc::new(rust_fontconfig::FontBytes::Owned(arc_owned));

        self.load_font_shared(bytes, font_index)

    }

                LayoutError::ShapingError("Failed to parse font with allsorts".to_string())

            })?;

    pub fn new_with_fc_cache(fc_cache: FcFontCache) -> Result<Self, LayoutError> {

        FontManager::new(fc_cache)

    }

    pub fn evict_unused(&self, idle: std::time::Duration) -> usize {

        let parsed = match self.parsed_fonts.lock() {

            Ok(p) => p,

            Err(_) => return 0,

        let cutoff = idle.as_nanos() as u64;

        let now_nanos = crate::font::parsed::monotonic_now_nanos();

        let mut evicted = 0usize;

        for font_ref in parsed.values() {

            let font: &ParsedFont = get_parsed_font(font_ref);

            let last = font.last_used_nanos();

            let stale = last == 0 || now_nanos.saturating_sub(last) >= cutoff;

            if stale && font.evict_loca_glyf() {

                evicted += 1;

            }

        evicted

    }

    fn get_glyph_size(&self, glyph_id: u16, font_size: f32) -> Option<LogicalSize> {

        get_parsed_font(self).get_glyph_size(glyph_id, font_size)

    }

    fn get_hyphen_glyph_and_advance(&self, font_size: f32) -> Option<(u16, f32)> {

        get_parsed_font(self).get_hyphen_glyph_and_advance(font_size)

    }

    fn get_kashida_glyph_and_advance(&self, font_size: f32) -> Option<(u16, f32)> {

        get_parsed_font(self).get_kashida_glyph_and_advance(font_size)

    }

    fn has_glyph(&self, codepoint: u32) -> bool {

        get_parsed_font(self).has_glyph(codepoint)

    }

    fn get_vertical_metrics(&self, glyph_id: u16) -> Option<VerticalMetrics> {

        get_parsed_font(self).get_vertical_metrics(glyph_id)

    }

    fn get_font_metrics(&self) -> LayoutFontMetrics {

        get_parsed_font(self).font_metrics.clone()

    }

    fn num_glyphs(&self) -> u16 {

        get_parsed_font(self).num_glyphs

    }

    fn get_space_width(&self) -> Option<usize> {

        get_parsed_font(self).get_space_width()

    }

    fn get_bytes(&self) -> &[u8] {

        get_parsed_font(self)

            .original_bytes

            .as_ref()

            .map(|b| b.as_slice())

            .unwrap_or(&[])

    }

    fn get_full_font_metrics(&self) -> azul_css::props::basic::FontMetrics {

        let parsed = get_parsed_font(self);

        let pdf = &parsed.pdf_font_metrics;

        azul_css::props::basic::FontMetrics {

            // OS/2 version 1 fields (u32 - align 4, placed first)

            ul_code_page_range1: OptionU32::None,

            ul_code_page_range2: OptionU32::None,

            // OS/2 table (u32 fields)

            ul_unicode_range1: 0,   // Not in PdfFontMetrics

            ul_unicode_range2: 0,   // Not in PdfFontMetrics

            ul_unicode_range3: 0,   // Not in PdfFontMetrics

            ul_unicode_range4: 0,   // Not in PdfFontMetrics

            ach_vend_id: 0,         // Not in PdfFontMetrics

            // OS/2 version 0 fields (optional)

            s_typo_ascender: OptionI16::None,

            s_typo_descender: OptionI16::None,

            s_typo_line_gap: OptionI16::None,

            us_win_ascent: OptionU16::None,

            us_win_descent: OptionU16::None,

            // OS/2 version 2 fields (optional)

            sx_height: OptionI16::None,

            s_cap_height: OptionI16::None,

            us_default_char: OptionU16::None,

            us_break_char: OptionU16::None,

            us_max_context: OptionU16::None,

            // OS/2 version 3 fields (optional)

            us_lower_optical_point_size: OptionU16::None,

            us_upper_optical_point_size: OptionU16::None,

            // HEAD table fields

            units_per_em: pdf.units_per_em,

            font_flags: pdf.font_flags,

            x_min: pdf.x_min,

            y_min: pdf.y_min,

            x_max: pdf.x_max,

            y_max: pdf.y_max,

            // HHEA table fields

            ascender: pdf.ascender,

            descender: pdf.descender,

            line_gap: pdf.line_gap,

            advance_width_max: pdf.advance_width_max,

            min_left_side_bearing: 0,  // Not in PdfFontMetrics

            min_right_side_bearing: 0, // Not in PdfFontMetrics

            x_max_extent: 0,           // Not in PdfFontMetrics

            caret_slope_rise: pdf.caret_slope_rise,

            caret_slope_run: pdf.caret_slope_run,

            caret_offset: 0,  // Not in PdfFontMetrics

            num_h_metrics: 0, // Not in PdfFontMetrics

            // OS/2 table fields

            x_avg_char_width: pdf.x_avg_char_width,

            us_weight_class: pdf.us_weight_class,

            us_width_class: pdf.us_width_class,

            fs_type: 0,                // Not in PdfFontMetrics

            y_subscript_x_size: 0,     // Not in PdfFontMetrics

            y_subscript_y_size: 0,     // Not in PdfFontMetrics

            y_subscript_x_offset: 0,   // Not in PdfFontMetrics

            y_subscript_y_offset: 0,   // Not in PdfFontMetrics

            y_superscript_x_size: 0,   // Not in PdfFontMetrics

            y_superscript_y_size: 0,   // Not in PdfFontMetrics

            y_superscript_x_offset: 0, // Not in PdfFontMetrics

            y_superscript_y_offset: 0, // Not in PdfFontMetrics

            y_strikeout_size: pdf.y_strikeout_size,

            y_strikeout_position: pdf.y_strikeout_position,

            s_family_class: 0, // Not in PdfFontMetrics

            fs_selection: 0,        // Not in PdfFontMetrics

            us_first_char_index: 0, // Not in PdfFontMetrics

            us_last_char_index: 0,  // Not in PdfFontMetrics

            // Panose (align 1 - last)

            panose: azul_css::props::basic::Panose::zero(),

        }

    }

    fn get_glyph_size(&self, glyph_id: u16, font_size_px: f32) -> Option<LogicalSize> {

        self.get_or_decode_glyph(glyph_id).map(|record| {

            let units_per_em = self.font_metrics.units_per_em as f32;

            let scale_factor = if units_per_em > 0.0 {

                font_size_px / units_per_em

                FALLBACK_SCALE

            let bbox = &record.bounding_box;

            LogicalSize {

                width: (bbox.max_x - bbox.min_x) as f32 * scale_factor,

                height: (bbox.max_y - bbox.min_y) as f32 * scale_factor,

            }

        })

    }

    fn get_hyphen_glyph_and_advance(&self, font_size: f32) -> Option<(u16, f32)> {

        let glyph_id = self.lookup_glyph_index('-' as u32)?;

        let advance_units = self.get_horizontal_advance(glyph_id);

        let scale_factor = if self.font_metrics.units_per_em > 0 {

            font_size / (self.font_metrics.units_per_em as f32)

            return None;

        let scaled_advance = advance_units as f32 * scale_factor;

        Some((glyph_id, scaled_advance))

    }

    fn get_kashida_glyph_and_advance(&self, font_size: f32) -> Option<(u16, f32)> {

        let glyph_id = self.lookup_glyph_index('\u{0640}' as u32)?;

        let advance_units = self.get_horizontal_advance(glyph_id);

        let scale_factor = if self.font_metrics.units_per_em > 0 {

            font_size / (self.font_metrics.units_per_em as f32)

            return None;

        let scaled_advance = advance_units as f32 * scale_factor;

        Some((glyph_id, scaled_advance))

    }

        Arabic => {

            mask |= FeatureMask::INIT; // Initial forms (at start of word)

            mask |= FeatureMask::MEDI; // Medial forms (middle of word)

            mask |= FeatureMask::FINA; // Final forms (end of word)

            mask |= FeatureMask::ISOL; // Isolated forms (standalone)

                                       // Note: RLIG (required ligatures) already in default for

                                       // lam-alef ligatures

        }

        | Telugu => {

            mask |= FeatureMask::NUKT; // Nukta forms

            mask |= FeatureMask::AKHN; // Akhand ligatures

            mask |= FeatureMask::RPHF; // Reph form

            mask |= FeatureMask::RKRF; // Rakar form

            mask |= FeatureMask::PREF; // Pre-base forms

            mask |= FeatureMask::BLWF; // Below-base forms

            mask |= FeatureMask::ABVF; // Above-base forms

            mask |= FeatureMask::HALF; // Half forms

            mask |= FeatureMask::PSTF; // Post-base forms

            mask |= FeatureMask::VATU; // Vattu variants

            mask |= FeatureMask::CJCT; // Conjunct forms

        }

        Myanmar => {

            mask |= FeatureMask::PREF; // Pre-base forms

            mask |= FeatureMask::BLWF; // Below-base forms

            mask |= FeatureMask::PSTF; // Post-base forms

        }

        Khmer => {

            mask |= FeatureMask::PREF; // Pre-base forms

            mask |= FeatureMask::BLWF; // Below-base forms

            mask |= FeatureMask::ABVF; // Above-base forms

            mask |= FeatureMask::PSTF; // Post-base forms

        }

        Thai => {

            // Thai mostly uses default features, but may have some special marks

            // The default mask is sufficient for most Thai fonts

        }

        Hebrew => {

            // Hebrew fonts may use contextual alternates already in default

            // Some fonts have special features but they're rare

        }

        Hangul => {

            // Note: Hangul jamo features (LJMO, VJMO, TJMO) are not available in allsorts'

            // FeatureMask Most modern Hangul fonts work correctly with the default

            // features as syllable composition is usually handled at a lower level

        }

        Ethiopic => {

            // Default features are usually sufficient

            // LIGA and CLIG already in default mask

        }

        Georgian => {

            // Default features sufficient

        }

        Hiragana | Katakana | Mandarin => {

            // CJK fonts may use vertical alternates, but those are controlled

            // by writing-mode, not GSUB features in the horizontal direction.

            // Default features are sufficient.

        }

        Sinhala => {

            mask |= FeatureMask::AKHN; // Akhand ligatures

            mask |= FeatureMask::RPHF; // Reph form

            mask |= FeatureMask::VATU; // Vattu variants

        }

        Arabic => u32::from_be_bytes(*b"arab"),

        Bengali => u32::from_be_bytes(*b"beng"),

        Cyrillic => u32::from_be_bytes(*b"cyrl"),

        Devanagari => u32::from_be_bytes(*b"deva"),

        Ethiopic => u32::from_be_bytes(*b"ethi"),

        Georgian => u32::from_be_bytes(*b"geor"),

        Greek => u32::from_be_bytes(*b"grek"),

        Gujarati => u32::from_be_bytes(*b"gujr"),

        Gurmukhi => u32::from_be_bytes(*b"guru"),

        Hangul => u32::from_be_bytes(*b"hang"),

        Hebrew => u32::from_be_bytes(*b"hebr"),

        Hiragana => u32::from_be_bytes(*b"kana"),

        Kannada => u32::from_be_bytes(*b"knda"),

        Katakana => u32::from_be_bytes(*b"kana"),

        Khmer => u32::from_be_bytes(*b"khmr"),

        Malayalam => u32::from_be_bytes(*b"mlym"),

        Mandarin => u32::from_be_bytes(*b"hani"),

        Myanmar => u32::from_be_bytes(*b"mymr"),

        Oriya => u32::from_be_bytes(*b"orya"),

        Sinhala => u32::from_be_bytes(*b"sinh"),

        Tamil => u32::from_be_bytes(*b"taml"),

        Telugu => u32::from_be_bytes(*b"telu"),

        Thai => u32::from_be_bytes(*b"thai"),

fn parse_font_feature(feature_str: &str) -> Option<(u32, u32)> {

    let mut parts = feature_str.split('=');

    let tag_str = parts.next()?.trim();

    let value_str = parts.next().unwrap_or("1").trim(); // Default to 1 (on) if no value

    if tag_str.len() > 4 {

        return None;

    }

    let padded_tag_str = format!("{:<4}", tag_str);

    let tag = u32::from_be_bytes(padded_tag_str.as_bytes().try_into().ok()?);

    let value = value_str.parse::<u32>().ok()?;

    Some((tag, value))

}

        features.push(FeatureInfo {

            feature_tag: u32::from_be_bytes(*tag_str),

            alternate: None,

        });

    };

        FontVariantLigatures::Discretionary => add_on(b"dlig"),

        FontVariantLigatures::Historical => add_on(b"hlig"),

        FontVariantLigatures::Contextual => add_on(b"calt"),

        FontVariantCaps::SmallCaps => add_on(b"smcp"),

        FontVariantCaps::AllSmallCaps => {

            add_on(b"c2sc");

            add_on(b"smcp");

        }

        FontVariantCaps::PetiteCaps => add_on(b"pcap"),

        FontVariantCaps::AllPetiteCaps => {

            add_on(b"c2pc");

            add_on(b"pcap");

        }

        FontVariantCaps::Unicase => add_on(b"unic"),

        FontVariantCaps::TitlingCaps => add_on(b"titl"),

        FontVariantNumeric::LiningNums => add_on(b"lnum"),

        FontVariantNumeric::OldstyleNums => add_on(b"onum"),

        FontVariantNumeric::ProportionalNums => add_on(b"pnum"),

        FontVariantNumeric::TabularNums => add_on(b"tnum"),

        FontVariantNumeric::DiagonalFractions => add_on(b"frac"),

        FontVariantNumeric::StackedFractions => add_on(b"afrc"),

        FontVariantNumeric::Ordinal => add_on(b"ordn"),

        FontVariantNumeric::SlashedZero => add_on(b"zero"),

        Afrikaans => *b"AFK ",

        Albanian => *b"SQI ",

        Armenian => *b"HYE ",

        Assamese => *b"ASM ",

        Basque => *b"EUQ ",

        Belarusian => *b"BEL ",

        Bengali => *b"BEN ",

        Bulgarian => *b"BGR ",

        Catalan => *b"CAT ",

        Chinese => *b"ZHS ",

        Coptic => *b"COP ",

        Croatian => *b"HRV ",

        Czech => *b"CSY ",

        Danish => *b"DAN ",

        Dutch => *b"NLD ",

        EnglishGB => *b"ENG ",

        Esperanto => *b"ESP ",

        Estonian => *b"ETI ",

        Ethiopic => *b"ETH ",

        Finnish => *b"FIN ",

        FinnishScholastic => *b"FIN ",

        French => *b"FRA ",

        Friulan => *b"FRL ",

        Galician => *b"GLC ",

        Georgian => *b"KAT ",

        German1901 => *b"DEU ",

        German1996 => *b"DEU ",

        GermanSwiss => *b"DES ",

        GreekAncient => *b"GRC ",

        GreekMono => *b"ELL ",

        GreekPoly => *b"ELL ",

        Gujarati => *b"GUJ ",

        Hindi => *b"HIN ",

        Hungarian => *b"HUN ",

        Icelandic => *b"ISL ",

        Indonesian => *b"IND ",

        Interlingua => *b"INA ",

        Irish => *b"IRI ",

        Italian => *b"ITA ",

        Kannada => *b"KAN ",

        Kurmanji => *b"KUR ",

        Latin => *b"LAT ",

        LatinClassic => *b"LAT ",

        LatinLiturgical => *b"LAT ",

        Latvian => *b"LVI ",

        Lithuanian => *b"LTH ",

        Macedonian => *b"MKD ",

        Malayalam => *b"MAL ",

        Marathi => *b"MAR ",

        Mongolian => *b"MNG ",

        NorwegianBokmal => *b"NOR ",

        NorwegianNynorsk => *b"NYN ",

        Occitan => *b"OCI ",

        Oriya => *b"ORI ",

        Pali => *b"PLI ",

        Panjabi => *b"PAN ",

        Piedmontese => *b"PMS ",

        Polish => *b"PLK ",

        Portuguese => *b"PTG ",

        Romanian => *b"ROM ",

        Romansh => *b"RMC ",

        Russian => *b"RUS ",

        Sanskrit => *b"SAN ",

        SerbianCyrillic => *b"SRB ",

        SerbocroatianCyrillic => *b"SHC ",

        SerbocroatianLatin => *b"SHL ",

        SlavonicChurch => *b"CSL ",

        Slovak => *b"SKY ",

        Slovenian => *b"SLV ",

        Spanish => *b"ESP ",

        Swedish => *b"SVE ",

        Tamil => *b"TAM ",

        Telugu => *b"TEL ",

        Thai => *b"THA ",

        Turkish => *b"TRK ",

        Turkmen => *b"TUK ",

        Ukrainian => *b"UKR ",

        Uppersorbian => *b"HSB ",

        Welsh => *b"CYM ",

            feature_tag: tag,

            alternate: if value > 1 {

                Some(value as usize)

                None

        })

                None

            Features::Custom(user_features.clone())

    }

    }

        FALLBACK_SCALE

                (x, y)

pub fn shape_text_for_parsed_font(

    parsed_font: &ParsedFont,

    text: &str,

    script: Script,

    language: crate::text3::script::Language,

    direction: BidiDirection,

    style: &StyleProperties,

) -> Result<Vec<Glyph>, LayoutError> {

    shape_text_internal(parsed_font, text, script, language, direction, style)

}