None => Err(ParseError::UnsuitableCmap),

    pub fn set_embedded_image_filter(&mut self, flags: GlyphTableFlags) {

        self.embedded_image_filter = flags;

    }

    pub fn lookup_glyph_index(

        &mut self,

        ch: char,

        match_presentation: MatchingPresentation,

        variation_selector: Option<VariationSelector>,

    ) -> (u16, VariationSelector) {

        self.glyph_cache.get(ch).unwrap_or_else(|| {

            let (glyph_index, used_variation) =

                self.map_unicode_to_glyph(ch, match_presentation, variation_selector);

            self.glyph_cache.put(ch, glyph_index, used_variation);

            (glyph_index, used_variation)

        })

    }

    pub fn shape(

        &mut self,

        mut glyphs: Vec<RawGlyph<()>>,

        script_tag: u32,

        opt_lang_tag: Option<u32>,

        feature_mask: FeatureMask,

        custom_features: &[FeatureInfo],

        tuple: Option<Tuple<'_>>,

        kerning: bool,

    ) -> Result<Vec<Info>, (ShapingError, Vec<Info>)> {

        let mut err: Option<ShapingError> = None;

        let opt_gsub_cache = check_set_err(self.gsub_cache(), &mut err);

        let opt_gpos_cache = check_set_err(self.gpos_cache(), &mut err);

        let opt_gdef_table = check_set_err(self.gdef_table(), &mut err);

        let opt_morx_table = check_set_err(self.morx_table(), &mut err);

        let opt_gdef_table = opt_gdef_table.as_ref().map(Arc::as_ref);

        let opt_kern_table = check_set_err(self.kern_table(), &mut err);

        let opt_kern_table = opt_kern_table

            .as_ref()

            .map(|x| kern::KernTable::from(x.as_ref()));

        let (dotted_circle_index, _) =

            self.lookup_glyph_index(DOTTED_CIRCLE, MatchingPresentation::NotRequired, None);

        let num_glyphs = self.num_glyphs();

        let mut applied_morx = false;

        if let Some(gsub_cache) = opt_gsub_cache {

            // Apply gsub if table is present

            let res = gsub::apply(

                dotted_circle_index,

                &gsub_cache,

                opt_gdef_table,

                script_tag,

                opt_lang_tag,

                feature_mask,

                custom_features,

                tuple,

                num_glyphs,

                &mut glyphs,

            );

            check_set_err(res, &mut err);

        } else if let Some(morx_cache) = opt_morx_table {

            morx_cache.with_table(|morx_table: &MorxTable<'_>| {

                let res = morx::apply(morx_table, &mut glyphs, feature_mask, script_tag);

                check_set_err(res, &mut err);

                applied_morx = true;

            })

        }

        let mut infos = Info::init_from_glyphs(opt_gdef_table, glyphs);

        if let Some(gpos_cache) = opt_gpos_cache {

            if applied_morx {

                infos.retain(|i| i.get_glyph_index() != DELETED_GLYPH);

            }

            let res = gpos::apply(

                &gpos_cache,

                opt_gdef_table,

                opt_kern_table,

                kerning,

                feature_mask,

                custom_features,

                tuple,

                script_tag,

                opt_lang_tag,

                &mut infos,

            check_set_err(res, &mut err);

            let mut has_cross_stream = false;

            if let Some(kern_table) = opt_kern_table {

                let res = kern::apply(&kern_table, script_tag, &mut infos);

                has_cross_stream = check_set_err(res, &mut err);

            }

            if applied_morx {

                infos.retain(|i| i.get_glyph_index() != DELETED_GLYPH);

            }

            if !has_cross_stream {

                gpos::apply_fallback_mark_positioning(&mut infos);

            }

        match err {

            Some(err) => Err((err, infos)),

            None => Ok(infos),

    }

    pub fn map_glyphs(

        &mut self,

        text: &str,

        script_tag: u32,

        match_presentation: MatchingPresentation,

    ) -> Vec<RawGlyph<()>> {

        let mut chars = text.chars().collect();

        preprocess_text(&mut chars, script_tag);

        let mut glyphs = Vec::with_capacity(chars.len());

        let mut chars_iter = chars.into_iter().peekable();

        while let Some(ch) = chars_iter.next() {

            match VariationSelector::try_from(ch) {

                Ok(_) => {} // filter out variation selectors

                    let vs = chars_iter

                        .peek()

                        .and_then(|&next| VariationSelector::try_from(next).ok());

                    let (glyph_index, used_variation) =

                        self.lookup_glyph_index(ch, match_presentation, vs);

                    let glyph = RawGlyph {

                        unicodes: tiny_vec![[char; 1] => ch],

                        glyph_index,

                        glyph_origin: GlyphOrigin::Char(ch),

                        flags: RawGlyphFlags::empty(),

                        extra_data: (),

                        variation: Some(used_variation),

                    glyphs.push(glyph);

        glyphs.shrink_to_fit();

        glyphs

    }

    pub fn is_variable(&self) -> bool {

        self.axis_count > 0

    }

    pub fn variation_axes(&self) -> Result<Vec<VariationAxisRecord>, ParseError> {

        let table = self.font_table_provider.read_table_data(tag::FVAR)?;

        let fvar = ReadScope::new(&table).read::<FvarTable<'_>>()?;

        Ok(fvar.axes().collect())

    }

    fn map_glyph(&self, char_code: u32) -> u16 {

        match ReadScope::new(self.cmap_subtable_data()).read::<CmapSubtable<'_>>() {

            Ok(cmap_subtable) => match cmap_subtable.map_glyph(char_code) {

                Ok(Some(glyph_index)) => glyph_index,

                _ => 0,

            Err(_err) => 0,

    }

    fn map_unicode_to_glyph(

        &mut self,

        ch: char,

        match_presentation: MatchingPresentation,

        variation_selector: Option<VariationSelector>,

    ) -> (u16, VariationSelector) {

        let match_presentation = if matches!(

            variation_selector,

            MatchingPresentation::Required

            match_presentation

        let used_selector = Self::resolve_default_presentation(ch, variation_selector);

        let glyph_index = match self.cmap_subtable_encoding {

                self.lookup_glyph_index_with_variation(ch as u32, match_presentation, used_selector)

                let char_code = self.legacy_symbol_char_code(ch);

                self.lookup_glyph_index_with_variation(char_code, match_presentation, used_selector)

            Encoding::AppleRoman => match char_to_macroman(ch) {

                Some(char_code) => self.lookup_glyph_index_with_variation(

                    u32::from(char_code),

                    match_presentation,

                    used_selector,

                    let char_code = self.legacy_symbol_char_code(ch);

                    self.lookup_glyph_index_with_variation(

                        char_code,

                        match_presentation,

                        used_selector,

            Encoding::Big5 => match unicode_to_big5(ch) {

                Some(char_code) => self.lookup_glyph_index_with_variation(

                    u32::from(char_code),

                    match_presentation,

                    used_selector,

                None => 0,

        (glyph_index, used_selector)

    }

    fn legacy_symbol_char_code(&mut self, ch: char) -> u32 {

        let char_code0 = if ch < '\u{F000}' || ch > '\u{F0FF}' {

            ch as u32

            ch as u32 - 0xF000

        let provider = &self.font_table_provider;

        let first_char = if let Ok(Some(us_first_char_index)) =

            self.os2_us_first_char_index.get_or_load(|| {

                load_os2_table(provider)?

                    .map(|os2| Ok(os2.us_first_char_index))

                    .transpose()

            }) {

            u32::from(us_first_char_index)

            0x20

        (char_code0 + first_char) - 0x20 // Perform subtraction last to avoid underflow.

    }

    fn lookup_glyph_index_with_variation(

        &mut self,

        char_code: u32,

        match_presentation: MatchingPresentation,

        variation_selector: VariationSelector,

    ) -> u16 {

        if match_presentation == MatchingPresentation::Required {

            if (variation_selector == VariationSelector::VS16 && self.has_embedded_images())

                || (variation_selector == VariationSelector::VS15 && self.has_glyph_outlines())

                self.map_glyph(char_code)

                0

            self.map_glyph(char_code)

    }

    fn resolve_default_presentation(

        ch: char,

        variation_selector: Option<VariationSelector>,

    ) -> VariationSelector {

        variation_selector.unwrap_or_else(|| {

            if unicode::bool_prop_emoji_presentation(ch) {

                VariationSelector::VS16

                VariationSelector::VS15

        })

    }

    pub fn glyph_names<'a>(&self, ids: &[u16]) -> Vec<Cow<'a, str>> {

        let post = read_and_box_optional_table(&self.font_table_provider, tag::POST)

            .ok()

            .and_then(convert::identity);

        let cmap = ReadScope::new(self.cmap_subtable_data())

            .read::<CmapSubtable<'_>>()

            .ok()

            .map(|table| (self.cmap_subtable_encoding, table));

        let glyph_namer = GlyphNames::new(&cmap, post);

        glyph_namer.unique_glyph_names(ids)

    }

    pub fn axis_names<'a>(&self) -> Result<Vec<NamedAxis<'a>>, AxisNamesError> {

        variations::axis_names(&self.font_table_provider)

    }

    pub fn lookup_glyph_image(

        &mut self,

        glyph_index: GlyphId,

        target_ppem: u16,

        max_bit_depth: BitDepth,

    ) -> Result<Option<BitmapGlyph>, ParseError> {

        let embedded_bitmaps = match self.embedded_images()? {

            Some(embedded_bitmaps) => embedded_bitmaps,

            None => return Ok(None),

        match embedded_bitmaps.as_ref() {

            Images::Embedded { cblc, cbdt } => cblc.with_table(|cblc: &CBLCTable<'_>| {

                let target_ppem = if target_ppem > u16::from(u8::MAX) {

                    u8::MAX

                    target_ppem as u8

                let bitmap = match cblc.find_strike(glyph_index, target_ppem, max_bit_depth) {

                    Some(matching_strike) => {

                        let cbdt = cbdt.borrow_table();

                        matching_strike.bitmap(cbdt)?.map(|bitmap| {

                            BitmapGlyph::try_from((

                                &matching_strike.bitmap_size.inner,

                                bitmap,

                                glyph_index,

                            ))

                        })

                    None => None,

                bitmap.transpose()

            }),

            Images::Colr { .. } => Ok(None),

            Images::Sbix(sbix) => self.lookup_sbix_glyph_bitmap(

                sbix,

                glyph_index,

                target_ppem,

                max_bit_depth,

            Images::Svg(svg) => self.lookup_svg_glyph(svg, glyph_index),

    }

    pub fn visit_colr_glyph<P>(

        &mut self,

        glyph_id: u16,

        palette_index: u16,

        painter: &mut P,

    ) -> Result<(), P::Error>

    where

        P: Painter,

        P::Error: From<ParseError> + From<cff::CFFError>,

        let Some(embedded_images) = self.embedded_images()? else {

            return Err(ParseError::MissingValue.into());

        if self.glyph_table_flags.contains(GlyphTableFlag::CFF2) {

            let cff2 = self

                .cff2_table()?

                .ok_or(ParseError::MissingTable(tag::CFF2))?;

            cff2.with(|cff2| {

                let mut cff2_outlines = CFF2Outlines { table: cff2.table };

                Self::visit_colr_glyph_inner(

                    glyph_id,

                    palette_index,

                    painter,

                    &mut cff2_outlines,

                    &embedded_images,

            })

        } else if self.glyph_table_flags.contains(GlyphTableFlag::CFF) {

            let cff = self

                .cff_table()?

                .ok_or(ParseError::MissingTable(tag::CFF))?;

            cff.with(|cff| {

                let mut cff_outlines = CFFOutlines { table: cff.table };

                Self::visit_colr_glyph_inner(

                    glyph_id,

                    palette_index,

                    painter,

                    &mut cff_outlines,

                    &embedded_images,

            })

        } else if self.glyph_table_flags.contains(GlyphTableFlag::GLYF) {

            self.maybe_load_loca_glyf()?;

            let mut context = GlyfVisitorContext::new(&mut self.loca_glyf, None);

            Self::visit_colr_glyph_inner(

                glyph_id,

                palette_index,

                painter,

                &mut context,

                &embedded_images,

            Err(ParseError::MissingValue.into())

    }

    fn visit_colr_glyph_inner<P, G>(

        glyph_id: u16,

        palette_index: u16,

        painter: &mut P,

        glyphs: &mut G,

        embedded_images: &Images,

    ) -> Result<(), P::Error>

    where

        P: Painter,

        P::Error: From<ParseError> + From<G::Error>,

        G: OutlineBuilder,

        match embedded_images {

            Images::Colr(tables) => tables.with(|fields| {

                let palette = fields

                    .cpal

                    .palette(palette_index)

                    .ok_or(ParseError::BadIndex)?;

                let Some(glyph) = fields.colr.lookup(glyph_id)? else {

                    return Ok(());

                glyph.visit(painter, glyphs, palette)

            }),

            _ => Err(ParseError::MissingTable(tag::COLR).into()),

    }

    pub fn has_colr(&mut self, glyph_id: u16) -> Result<bool, ParseError> {

        let Some(embedded_images) = self.embedded_images()? else {

            return Ok(false);

        match embedded_images.as_ref() {

            Images::Colr(tables) => tables.with_colr(|colr| Ok(colr.lookup(glyph_id)?.is_some())),

            _ => Ok(false),

    }

    pub fn colr_clip_box(&mut self, glyph_id: u16) -> Result<Option<RectF>, ParseError> {

        let Some(embedded_images) = self.embedded_images()? else {

            return Err(ParseError::MissingValue);

        match embedded_images.as_ref() {

            Images::Colr(tables) => tables.with_colr(|colr| {

                let glyph = colr.lookup(glyph_id)?.ok_or(ParseError::BadIndex)?;

                glyph.clip_box()

            }),

            _ => Err(ParseError::MissingValue),

    }

    fn lookup_sbix_glyph_bitmap(

        &self,

        sbix: &tables::Sbix,

        dupe: bool,

        flip: bool,

        glyph_index: GlyphId,

        target_ppem: u16,

        max_bit_depth: BitDepth,

    ) -> Result<Option<BitmapGlyph>, ParseError> {

        sbix.with_table(|sbix_table: &SbixTable<'_>| {

            match sbix_table.find_strike(glyph_index, target_ppem, max_bit_depth) {

                Some(strike) => {

                    match strike.read_glyph(glyph_index)? {

                        Some(ref glyph) if glyph.graphic_type == tag::DUPE => {

                            if dupe {

                                Ok(None)

                                let dupe_glyph_index =

                                    ReadScope::new(glyph.data).ctxt().read_u16be()?;

                                self.lookup_sbix_glyph_bitmap(

                                    sbix,

                                    flip,

                                    dupe_glyph_index,

                                    target_ppem,

                                    max_bit_depth,

                        Some(ref glyph) if glyph.graphic_type == tag::FLIP => {

                            if flip {

                                Ok(None)

                                let flip_glyph_index =

                                    ReadScope::new(glyph.data).ctxt().read_u16be()?;

                                self.lookup_sbix_glyph_bitmap(

                                    sbix,

                                    dupe,

                                    flip_glyph_index,

                                    target_ppem,

                                    max_bit_depth,

                        Some(glyph) => {

                            Ok(Some(BitmapGlyph::from((strike, &glyph, glyph_index, flip))))

                        None => Ok(None),

                None => Ok(None),

        })

    }

    fn lookup_svg_glyph(

        &self,

        svg: &tables::Svg,

        glyph_index: GlyphId,

    ) -> Result<Option<BitmapGlyph>, ParseError> {

        svg.with_table(

            |svg_table: &SvgTable<'_>| match svg_table.lookup_glyph(glyph_index)? {

                Some(svg_record) => BitmapGlyph::try_from((&svg_record, glyph_index)).map(Some),

                None => Ok(None),

            },

    }

    fn embedded_images(&mut self) -> Result<Option<Arc<Images>>, ParseError> {

        let provider = &self.font_table_provider;

        let num_glyphs = usize::from(self.maxp_table.num_glyphs);

        let tables_to_check = self.glyph_table_flags & self.embedded_image_filter;

        self.embedded_images.get_or_load(|| {

            if tables_to_check.contains(GlyphTableFlag::COLR) {

                let images = load_colr_cpal(provider).map(Images::Colr)?;

                Ok(Some(Arc::new(images)))

            } else if tables_to_check.contains(GlyphTableFlag::SVG) {

                let images = load_svg(provider).map(Images::Svg)?;

                Ok(Some(Arc::new(images)))

            } else if tables_to_check.contains(GlyphTableFlag::CBDT) {

                let images = load_cblc_cbdt(provider, tag::CBLC, tag::CBDT)

                    .map(|(cblc, cbdt)| Images::Embedded { cblc, cbdt })?;

                Ok(Some(Arc::new(images)))

            } else if tables_to_check.contains(GlyphTableFlag::SBIX) {

                let images = load_sbix(provider, num_glyphs).map(Images::Sbix)?;

                Ok(Some(Arc::new(images)))

            } else if tables_to_check.contains(GlyphTableFlag::EBDT) {

                let images =

                    load_cblc_cbdt(provider, tag::EBLC, tag::EBDT).map(|(eblc, ebdt)| {

                        Images::Embedded {

                            cblc: eblc,

                            cbdt: ebdt,

                        }

                    })?;

                Ok(Some(Arc::new(images)))

                Ok(None)

        })

    }

    pub fn has_embedded_images(&mut self) -> bool {

        matches!(self.embedded_images(), Ok(Some(_)))

    }

    pub fn has_glyph_outlines(&self) -> bool {

        self.glyph_table_flags

            .intersects(GlyphTableFlag::GLYF | GlyphTableFlag::CFF | GlyphTableFlag::CFF2)

    }

    pub fn horizontal_advance(&mut self, glyph: GlyphId) -> Option<u16> {

        glyph_info::advance(&self.maxp_table, &self.hhea_table, &self.hmtx_table, glyph).ok()

    }

    pub fn vertical_advance(&mut self, glyph: GlyphId) -> Option<u16> {

        let provider = &self.font_table_provider;

        let vmtx = self

            .vmtx_table

            .get_or_load(|| {

                read_and_box_optional_table(provider, tag::VMTX).map(|ok| ok.map(Arc::from))

            })

            .ok()?;

        let vhea = self.vhea_table().ok()?;

        if let (Some(vhea), Some(vmtx_table)) = (vhea, vmtx) {

            Some(glyph_info::advance(&self.maxp_table, &vhea, &vmtx_table, glyph).unwrap())

            None

    }

    pub fn bounding_box(&mut self, glyph_id: u16) -> Result<Option<BoundingBox>, CFFError> {

        if self.glyph_table_flags.contains(GlyphTableFlag::CFF2) {

            let cff2 = self

                .cff2_table()?

                .ok_or(ParseError::MissingTable(tag::CFF2))?;

            cff2.with(|cff2| {

                let mut cff2_outlines = CFF2Outlines { table: cff2.table };

                cff2_outlines.visit(glyph_id, None, &mut NullSink)

            })

        } else if self.glyph_table_flags.contains(GlyphTableFlag::CFF) {

            let cff = self

                .cff_table()?

                .ok_or(ParseError::MissingTable(tag::CFF))?;

            cff.with(|cff| {

                let mut cff_outlines = CFFOutlines { table: cff.table };

                cff_outlines.visit(glyph_id, None, &mut NullSink)

            })

        } else if self.glyph_table_flags.contains(GlyphTableFlag::GLYF) {

            self.maybe_load_loca_glyf()?;

            let mut context = GlyfVisitorContext::new(&mut self.loca_glyf, None);

            let mut sink = BoundingBoxSink::new();

            context.visit(glyph_id, None, &mut sink)?;

            Ok(sink.to_bounding_box())

            Err(ParseError::MissingValue.into())

    }

    pub fn cff_table(&mut self) -> Result<Option<Arc<tables::CFF>>, ParseError> {

        let provider = &self.font_table_provider;

        self.cff_cache.get_or_load(|| {

            let cff_data = provider.read_table_data(tag::CFF).map(Box::from)?;

            let cff = tables::CFFTryBuilder {

                data: cff_data,

                table_builder: |data: &Box<[u8]>| ReadScope::new(data).read::<CFF<'_>>(),

            .try_build()?;

            Ok(Some(Arc::new(cff)))

        })

    }

    pub fn cff2_table(&mut self) -> Result<Option<Arc<tables::CFF2>>, ParseError> {

        let provider = &self.font_table_provider;

        self.cff2_cache.get_or_load(|| {

            let cff_data = provider.read_table_data(tag::CFF2).map(Box::from)?;

            let cff = tables::CFF2TryBuilder {

                data: cff_data,

                table_builder: |data: &Box<[u8]>| ReadScope::new(data).read::<CFF2<'_>>(),

            .try_build()?;

            Ok(Some(Arc::new(cff)))

        })

    }

    pub fn os2_table(&self) -> Result<Option<Os2>, ParseError> {

        load_os2_table(&self.font_table_provider)

    }

    pub fn maybe_load_loca_glyf(&mut self) -> Result<(), ParseError> {

        if !self.loca_glyf.is_loaded() {

            let provider = &self.font_table_provider;

            let loca_data = self.font_table_provider.read_table_data(tag::LOCA)?;

            let loca = ReadScope::new(&loca_data).read_dep::<LocaTable<'_>>((

                self.num_glyphs(),

                self.head_table.index_to_loc_format,

            ))?;

            let loca = owned::LocaTable::from(&loca);

            let glyf = read_and_box_table(provider, tag::GLYF)?;

            self.loca_glyf = LocaGlyf::loaded(loca, glyf);

        }

        Ok(())

    }

    pub fn morx_table(&mut self) -> Result<Option<Arc<tables::Morx>>, ParseError> {

        let provider = &self.font_table_provider;

        let num_glyphs = self.num_glyphs();

        self.morx_cache.get_or_load(|| {

            if let Some(morx_data) = provider.table_data(tag::MORX)? {

                let morx = tables::Morx::try_new(morx_data.into(), |data| {

                    ReadScope::new(data).read_dep::<MorxTable<'_>>(num_glyphs)

                })?;

                Ok(Some(Arc::new(morx)))

                Ok(None)

        })

    }

    pub fn gsub_cache(&mut self) -> Result<Option<LayoutCache<GSUB>>, ParseError> {

        let provider = &self.font_table_provider;

        self.gsub_cache.get_or_load(|| {

            if let Some(gsub_data) = provider.table_data(tag::GSUB)? {

                let gsub = ReadScope::new(&gsub_data).read::<LayoutTable<GSUB>>()?;

                let cache = new_layout_cache::<GSUB>(gsub);

                Ok(Some(cache))

                Ok(None)

        })

    }

    pub fn gpos_cache(&mut self) -> Result<Option<LayoutCache<GPOS>>, ParseError> {

        let provider = &self.font_table_provider;

        self.gpos_cache.get_or_load(|| {

            if let Some(gpos_data) = provider.table_data(tag::GPOS)? {

                let gpos = ReadScope::new(&gpos_data).read::<LayoutTable<GPOS>>()?;

                let cache = new_layout_cache::<GPOS>(gpos);

                Ok(Some(cache))

                Ok(None)

        })

    }

                    Err(ParseError::BadVersion) => Ok(None),

                    Err(err) => Err(err),

    pub fn vhea_table(&mut self) -> Result<Option<Arc<HheaTable>>, ParseError> {

        let provider = &self.font_table_provider;

        self.vhea_table.get_or_load(|| {

            if let Some(vhea_data) = provider.table_data(tag::VHEA)? {

                let vhea = ReadScope::new(&vhea_data).read::<HheaTable>()?;

                Ok(Some(Arc::new(vhea)))

                Ok(None)

        })

    }

        match self {

            LazyLoad::Loaded(Some(ref data)) => Ok(Some(data.clone())),

            LazyLoad::Loaded(None) => Ok(None),

    fn get(&self, ch: char) -> Option<(u16, VariationSelector)> {

        if ch == DOTTED_CIRCLE {

            self.0

            None

    }

    fn put(&mut self, ch: char, glyph_index: GlyphId, variation_selector: VariationSelector) {

        if ch == DOTTED_CIRCLE {

            match self.0 {

                Some(_) => panic!("duplicate entry"),

                None => self.0 = Some((glyph_index, variation_selector)),

        }

    }

    fn move_to(&mut self, _to: Vector2F) {}

    fn line_to(&mut self, _to: Vector2F) {}

    fn quadratic_curve_to(&mut self, _ctrl: Vector2F, _to: Vector2F) {}

    fn cubic_curve_to(&mut self, _ctrl: LineSegment2F, _to: Vector2F) {}

    fn close(&mut self) {}

fn load_os2_table(provider: &impl FontTableProvider) -> Result<Option<Os2>, ParseError> {

    provider

        .table_data(tag::OS_2)?

        .map(|data| ReadScope::new(&data).read_dep::<Os2>(data.len()))

        .transpose()

}

fn load_cblc_cbdt(

    provider: &impl FontTableProvider,

    bitmap_location_table_tag: u32,

    bitmap_data_table_tag: u32,

) -> Result<(tables::CBLC, tables::CBDT), ParseError> {

    let cblc_data = read_and_box_table(provider, bitmap_location_table_tag)?;

    let cbdt_data = read_and_box_table(provider, bitmap_data_table_tag)?;

    let cblc = tables::CBLC::try_new(cblc_data, |data| {

        ReadScope::new(data).read::<CBLCTable<'_>>()

    })?;

    let cbdt = tables::CBDT::try_new(cbdt_data, |data| {

        ReadScope::new(data).read::<CBDTTable<'_>>()

    })?;

    Ok((cblc, cbdt))

}

fn load_colr_cpal(provider: &impl FontTableProvider) -> Result<tables::ColrCpal, ParseError> {

    let colr_data = read_and_box_table(provider, tag::COLR)?;

    let cpal_data = read_and_box_table(provider, tag::CPAL)?;

    let colr_cpal = ColrCpalTryBuilder {

        colr_data,

        cpal_data,

        colr_builder: |data: &Box<[u8]>| ReadScope::new(data).read::<ColrTable<'_>>(),

        cpal_builder: |data: &Box<[u8]>| ReadScope::new(data).read::<CpalTable<'_>>(),

    .try_build()?;

    Ok(colr_cpal)

}

fn load_sbix(

    provider: &impl FontTableProvider,

    num_glyphs: usize,

) -> Result<tables::Sbix, ParseError> {

    let sbix_data = read_and_box_table(provider, tag::SBIX)?;

    tables::Sbix::try_new(sbix_data, |data| {

        ReadScope::new(data).read_dep::<SbixTable<'_>>(num_glyphs)

    })

}

fn load_svg(provider: &impl FontTableProvider) -> Result<tables::Svg, ParseError> {

    let svg_data = read_and_box_table(provider, tag::SVG)?;

    tables::Svg::try_new(svg_data, |data| ReadScope::new(data).read::<SvgTable<'_>>())

}