read_fonts/generated/

generated_math.rs

// THIS FILE IS AUTOGENERATED.
// Any changes to this file will be overwritten.
// For more information about how codegen works, see font-codegen/README.md

#[allow(unused_imports)]
use crate::codegen_prelude::*;

impl<'a> MinByteRange<'a> for Math<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.math_variants_offset_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl TopLevelTable for Math<'_> {
    /// `MATH`
    const TAG: Tag = Tag::new(b"MATH");
}

impl ReadArgs for Math<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for Math<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// The [MATH](https://learn.microsoft.com/en-us/typography/opentype/spec/math) table
#[derive(Clone)]
pub struct Math<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> Math<'a> {
    pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// (major, minor) Version for the MATH table (1,0)
    pub fn version(&self) -> MajorMinor {
        let range = self.version_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Offset to MathConstants table, from beginning of MATH table.
    pub fn math_constants_offset(&self) -> Offset16 {
        let range = self.math_constants_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_constants_offset`][Self::math_constants_offset].
    pub fn math_constants(&self) -> Result<MathConstants<'a>, ReadError> {
        let data = self.data;
        self.math_constants_offset().resolve(data)
    }

    /// Offset to MathGlyphInfo table, from beginning of MATH table.
    pub fn math_glyph_info_offset(&self) -> Offset16 {
        let range = self.math_glyph_info_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_glyph_info_offset`][Self::math_glyph_info_offset].
    pub fn math_glyph_info(&self) -> Result<MathGlyphInfo<'a>, ReadError> {
        let data = self.data;
        self.math_glyph_info_offset().resolve(data)
    }

    /// Offset to MathVariants table, from beginning of MATH table.
    pub fn math_variants_offset(&self) -> Offset16 {
        let range = self.math_variants_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_variants_offset`][Self::math_variants_offset].
    pub fn math_variants(&self) -> Result<MathVariants<'a>, ReadError> {
        let data = self.data;
        self.math_variants_offset().resolve(data)
    }

    pub fn version_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + MajorMinor::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_constants_offset_byte_range(&self) -> Range<usize> {
        let start = self.version_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_glyph_info_offset_byte_range(&self) -> Range<usize> {
        let start = self.math_constants_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_variants_offset_byte_range(&self) -> Range<usize> {
        let start = self.math_glyph_info_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(Math::MIN_SIZE));

impl Default for Math<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

/// [MathValueRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathvaluerecord)
///
/// The device offset is measured from the beginning of the table that contains
/// the record, not from the record itself.
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct MathValueRecord {
    /// The X or Y value in design units.
    pub value: BigEndian<FWord>,
    /// Offset to the Device table (non-variable font) / VariationIndex table
    /// (variable font) for this value, from the beginning of the parent table.
    /// May be NULL.
    pub device_offset: BigEndian<Nullable<Offset16>>,
}

impl MathValueRecord {
    /// The X or Y value in design units.
    pub fn value(&self) -> FWord {
        self.value.get()
    }

    /// Offset to the Device table (non-variable font) / VariationIndex table
    /// (variable font) for this value, from the beginning of the parent table.
    /// May be NULL.
    pub fn device_offset(&self) -> Nullable<Offset16> {
        self.device_offset.get()
    }

    /// Offset to the Device table (non-variable font) / VariationIndex table
    /// (variable font) for this value, from the beginning of the parent table.
    /// May be NULL.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn device<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<DeviceOrVariationIndex<'a>, ReadError>> {
        self.device_offset().resolve(data)
    }
}

impl FixedSize for MathValueRecord {
    const RAW_BYTE_LEN: usize = FWord::RAW_BYTE_LEN + Offset16::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for MathConstants<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.radical_degree_bottom_raise_percent_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathConstants<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathConstants<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathConstants](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathconstants-table)
#[derive(Clone)]
pub struct MathConstants<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathConstants<'a> {
    pub const MIN_SIZE: usize = (i16::RAW_BYTE_LEN
        + i16::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + MathValueRecord::RAW_BYTE_LEN
        + i16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Percentage of scaling down for level 1 superscripts and subscripts.
    pub fn script_percent_scale_down(&self) -> i16 {
        let range = self.script_percent_scale_down_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Percentage of scaling down for level 2 (scriptScript) superscripts and
    /// subscripts.
    pub fn script_script_percent_scale_down(&self) -> i16 {
        let range = self.script_script_percent_scale_down_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Minimum height required for a delimited expression (contained within
    /// parentheses, etc.) to be treated as a sub-formula.
    pub fn delimited_sub_formula_min_height(&self) -> UfWord {
        let range = self.delimited_sub_formula_min_height_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Minimum height of n-ary operators (such as integral and summation) for
    /// formulas in display mode (that is, appearing as standalone page
    /// elements, not embedded inline within text).
    pub fn display_operator_min_height(&self) -> UfWord {
        let range = self.display_operator_min_height_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// White space to be left between math formulas to ensure proper line
    /// spacing.
    pub fn math_leading(&self) -> &'a MathValueRecord {
        let range = self.math_leading_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Axis height of the font.
    pub fn axis_height(&self) -> &'a MathValueRecord {
        let range = self.axis_height_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Maximum (ink) height of accent base that does not require raising the
    /// accents.
    pub fn accent_base_height(&self) -> &'a MathValueRecord {
        let range = self.accent_base_height_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Maximum (ink) height of accent base that does not require flattening the
    /// accents.
    pub fn flattened_accent_base_height(&self) -> &'a MathValueRecord {
        let range = self.flattened_accent_base_height_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// The standard shift down applied to subscript elements.
    pub fn subscript_shift_down(&self) -> &'a MathValueRecord {
        let range = self.subscript_shift_down_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Maximum allowed height of the (ink) top of subscripts that does not
    /// require moving subscripts further down.
    pub fn subscript_top_max(&self) -> &'a MathValueRecord {
        let range = self.subscript_top_max_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum allowed drop of the baseline of subscripts relative to the (ink)
    /// bottom of the base.
    pub fn subscript_baseline_drop_min(&self) -> &'a MathValueRecord {
        let range = self.subscript_baseline_drop_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift up applied to superscript elements.
    pub fn superscript_shift_up(&self) -> &'a MathValueRecord {
        let range = self.superscript_shift_up_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift of superscripts relative to the base, in cramped style.
    pub fn superscript_shift_up_cramped(&self) -> &'a MathValueRecord {
        let range = self.superscript_shift_up_cramped_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum allowed height of the (ink) bottom of superscripts that does not
    /// require moving subscripts further up.
    pub fn superscript_bottom_min(&self) -> &'a MathValueRecord {
        let range = self.superscript_bottom_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Maximum allowed drop of the baseline of superscripts relative to the
    /// (ink) top of the base.
    pub fn superscript_baseline_drop_max(&self) -> &'a MathValueRecord {
        let range = self.superscript_baseline_drop_max_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between the superscript and subscript ink.
    pub fn sub_superscript_gap_min(&self) -> &'a MathValueRecord {
        let range = self.sub_superscript_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// The maximum level to which the (ink) bottom of superscript can be
    /// pushed to increase the gap between superscript and subscript, before
    /// subscript starts being moved down.
    pub fn superscript_bottom_max_with_subscript(&self) -> &'a MathValueRecord {
        let range = self.superscript_bottom_max_with_subscript_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Extra white space to be added after each subscript and superscript.
    pub fn space_after_script(&self) -> &'a MathValueRecord {
        let range = self.space_after_script_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between the (ink) bottom of the upper limit, and the (ink)
    /// top of the base operator.
    pub fn upper_limit_gap_min(&self) -> &'a MathValueRecord {
        let range = self.upper_limit_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum distance between baseline of upper limit and (ink) top of the
    /// base operator.
    pub fn upper_limit_baseline_rise_min(&self) -> &'a MathValueRecord {
        let range = self.upper_limit_baseline_rise_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between (ink) top of the lower limit, and (ink) bottom of
    /// the base operator.
    pub fn lower_limit_gap_min(&self) -> &'a MathValueRecord {
        let range = self.lower_limit_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum distance between baseline of the lower limit and (ink) bottom of
    /// the base operator.
    pub fn lower_limit_baseline_drop_min(&self) -> &'a MathValueRecord {
        let range = self.lower_limit_baseline_drop_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift up applied to the top element of a stack.
    pub fn stack_top_shift_up(&self) -> &'a MathValueRecord {
        let range = self.stack_top_shift_up_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift up applied to the top element of a stack in display
    /// style.
    pub fn stack_top_display_style_shift_up(&self) -> &'a MathValueRecord {
        let range = self.stack_top_display_style_shift_up_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift down applied to the bottom element of a stack.
    pub fn stack_bottom_shift_down(&self) -> &'a MathValueRecord {
        let range = self.stack_bottom_shift_down_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift down applied to the bottom element of a stack in display
    /// style.
    pub fn stack_bottom_display_style_shift_down(&self) -> &'a MathValueRecord {
        let range = self.stack_bottom_display_style_shift_down_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between (ink) bottom of the top element of a stack, and the
    /// (ink) top of the bottom element.
    pub fn stack_gap_min(&self) -> &'a MathValueRecord {
        let range = self.stack_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between (ink) bottom of the top element of a stack, and the
    /// (ink) top of the bottom element in display style.
    pub fn stack_display_style_gap_min(&self) -> &'a MathValueRecord {
        let range = self.stack_display_style_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift up applied to the top element of the stretch stack.
    pub fn stretch_stack_top_shift_up(&self) -> &'a MathValueRecord {
        let range = self.stretch_stack_top_shift_up_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift down applied to the bottom element of the stretch stack.
    pub fn stretch_stack_bottom_shift_down(&self) -> &'a MathValueRecord {
        let range = self.stretch_stack_bottom_shift_down_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between the ink of the stretched element, and the (ink)
    /// bottom of the element above.
    pub fn stretch_stack_gap_above_min(&self) -> &'a MathValueRecord {
        let range = self.stretch_stack_gap_above_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum gap between the ink of the stretched element, and the (ink) top
    /// of the element below.
    pub fn stretch_stack_gap_below_min(&self) -> &'a MathValueRecord {
        let range = self.stretch_stack_gap_below_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift up applied to the numerator.
    pub fn fraction_numerator_shift_up(&self) -> &'a MathValueRecord {
        let range = self.fraction_numerator_shift_up_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift up applied to the numerator in display style.
    pub fn fraction_numerator_display_style_shift_up(&self) -> &'a MathValueRecord {
        let range = self.fraction_numerator_display_style_shift_up_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift down applied to the denominator.
    pub fn fraction_denominator_shift_down(&self) -> &'a MathValueRecord {
        let range = self.fraction_denominator_shift_down_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Standard shift down applied to the denominator in display style.
    pub fn fraction_denominator_display_style_shift_down(&self) -> &'a MathValueRecord {
        let range = self.fraction_denominator_display_style_shift_down_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum tolerated gap between the (ink) bottom of the numerator and the
    /// ink of the fraction bar.
    pub fn fraction_numerator_gap_min(&self) -> &'a MathValueRecord {
        let range = self.fraction_numerator_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum tolerated gap between the (ink) bottom of the numerator and the
    /// ink of the fraction bar in display style.
    pub fn fraction_num_display_style_gap_min(&self) -> &'a MathValueRecord {
        let range = self.fraction_num_display_style_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Thickness of the fraction bar.
    pub fn fraction_rule_thickness(&self) -> &'a MathValueRecord {
        let range = self.fraction_rule_thickness_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum tolerated gap between the ink of the fraction bar and the (ink)
    /// top of the denominator.
    pub fn fraction_denominator_gap_min(&self) -> &'a MathValueRecord {
        let range = self.fraction_denominator_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Minimum tolerated gap between the ink of the fraction bar and the (ink)
    /// top of the denominator in display style.
    pub fn fraction_denom_display_style_gap_min(&self) -> &'a MathValueRecord {
        let range = self.fraction_denom_display_style_gap_min_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Horizontal distance between the top and bottom elements of a skewed
    /// fraction.
    pub fn skewed_fraction_horizontal_gap(&self) -> &'a MathValueRecord {
        let range = self.skewed_fraction_horizontal_gap_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Vertical distance between the ink of the top and bottom elements of a
    /// skewed fraction.
    pub fn skewed_fraction_vertical_gap(&self) -> &'a MathValueRecord {
        let range = self.skewed_fraction_vertical_gap_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Distance between the overbar and the (ink) top of he base.
    pub fn overbar_vertical_gap(&self) -> &'a MathValueRecord {
        let range = self.overbar_vertical_gap_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Thickness of overbar.
    pub fn overbar_rule_thickness(&self) -> &'a MathValueRecord {
        let range = self.overbar_rule_thickness_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Extra white space reserved above the overbar.
    pub fn overbar_extra_ascender(&self) -> &'a MathValueRecord {
        let range = self.overbar_extra_ascender_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Distance between underbar and (ink) bottom of the base.
    pub fn underbar_vertical_gap(&self) -> &'a MathValueRecord {
        let range = self.underbar_vertical_gap_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Thickness of underbar.
    pub fn underbar_rule_thickness(&self) -> &'a MathValueRecord {
        let range = self.underbar_rule_thickness_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Extra white space reserved below the underbar.
    pub fn underbar_extra_descender(&self) -> &'a MathValueRecord {
        let range = self.underbar_extra_descender_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Space between the (ink) top of the expression and the bar over it.
    pub fn radical_vertical_gap(&self) -> &'a MathValueRecord {
        let range = self.radical_vertical_gap_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Space between the (ink) top of the expression and the bar over it in
    /// display style.
    pub fn radical_display_style_vertical_gap(&self) -> &'a MathValueRecord {
        let range = self.radical_display_style_vertical_gap_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Thickness of the radical rule.
    pub fn radical_rule_thickness(&self) -> &'a MathValueRecord {
        let range = self.radical_rule_thickness_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Extra white space reserved above the radical.
    pub fn radical_extra_ascender(&self) -> &'a MathValueRecord {
        let range = self.radical_extra_ascender_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Extra horizontal kern before the degree of a radical, if such is
    /// present.
    pub fn radical_kern_before_degree(&self) -> &'a MathValueRecord {
        let range = self.radical_kern_before_degree_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Negative kern after the degree of a radical, if such is present.
    pub fn radical_kern_after_degree(&self) -> &'a MathValueRecord {
        let range = self.radical_kern_after_degree_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Height of the bottom of the radical degree, if such is present, in
    /// proportion to the ascender of the radical sign.
    pub fn radical_degree_bottom_raise_percent(&self) -> i16 {
        let range = self.radical_degree_bottom_raise_percent_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    pub fn script_percent_scale_down_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }

    pub fn script_script_percent_scale_down_byte_range(&self) -> Range<usize> {
        let start = self.script_percent_scale_down_byte_range().end;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }

    pub fn delimited_sub_formula_min_height_byte_range(&self) -> Range<usize> {
        let start = self.script_script_percent_scale_down_byte_range().end;
        let end = start + UfWord::RAW_BYTE_LEN;
        start..end
    }

    pub fn display_operator_min_height_byte_range(&self) -> Range<usize> {
        let start = self.delimited_sub_formula_min_height_byte_range().end;
        let end = start + UfWord::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_leading_byte_range(&self) -> Range<usize> {
        let start = self.display_operator_min_height_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn axis_height_byte_range(&self) -> Range<usize> {
        let start = self.math_leading_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn accent_base_height_byte_range(&self) -> Range<usize> {
        let start = self.axis_height_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn flattened_accent_base_height_byte_range(&self) -> Range<usize> {
        let start = self.accent_base_height_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn subscript_shift_down_byte_range(&self) -> Range<usize> {
        let start = self.flattened_accent_base_height_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn subscript_top_max_byte_range(&self) -> Range<usize> {
        let start = self.subscript_shift_down_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn subscript_baseline_drop_min_byte_range(&self) -> Range<usize> {
        let start = self.subscript_top_max_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn superscript_shift_up_byte_range(&self) -> Range<usize> {
        let start = self.subscript_baseline_drop_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn superscript_shift_up_cramped_byte_range(&self) -> Range<usize> {
        let start = self.superscript_shift_up_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn superscript_bottom_min_byte_range(&self) -> Range<usize> {
        let start = self.superscript_shift_up_cramped_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn superscript_baseline_drop_max_byte_range(&self) -> Range<usize> {
        let start = self.superscript_bottom_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn sub_superscript_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.superscript_baseline_drop_max_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn superscript_bottom_max_with_subscript_byte_range(&self) -> Range<usize> {
        let start = self.sub_superscript_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn space_after_script_byte_range(&self) -> Range<usize> {
        let start = self.superscript_bottom_max_with_subscript_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn upper_limit_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.space_after_script_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn upper_limit_baseline_rise_min_byte_range(&self) -> Range<usize> {
        let start = self.upper_limit_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn lower_limit_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.upper_limit_baseline_rise_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn lower_limit_baseline_drop_min_byte_range(&self) -> Range<usize> {
        let start = self.lower_limit_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stack_top_shift_up_byte_range(&self) -> Range<usize> {
        let start = self.lower_limit_baseline_drop_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stack_top_display_style_shift_up_byte_range(&self) -> Range<usize> {
        let start = self.stack_top_shift_up_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stack_bottom_shift_down_byte_range(&self) -> Range<usize> {
        let start = self.stack_top_display_style_shift_up_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stack_bottom_display_style_shift_down_byte_range(&self) -> Range<usize> {
        let start = self.stack_bottom_shift_down_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stack_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.stack_bottom_display_style_shift_down_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stack_display_style_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.stack_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stretch_stack_top_shift_up_byte_range(&self) -> Range<usize> {
        let start = self.stack_display_style_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stretch_stack_bottom_shift_down_byte_range(&self) -> Range<usize> {
        let start = self.stretch_stack_top_shift_up_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stretch_stack_gap_above_min_byte_range(&self) -> Range<usize> {
        let start = self.stretch_stack_bottom_shift_down_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn stretch_stack_gap_below_min_byte_range(&self) -> Range<usize> {
        let start = self.stretch_stack_gap_above_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_numerator_shift_up_byte_range(&self) -> Range<usize> {
        let start = self.stretch_stack_gap_below_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_numerator_display_style_shift_up_byte_range(&self) -> Range<usize> {
        let start = self.fraction_numerator_shift_up_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_denominator_shift_down_byte_range(&self) -> Range<usize> {
        let start = self
            .fraction_numerator_display_style_shift_up_byte_range()
            .end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_denominator_display_style_shift_down_byte_range(&self) -> Range<usize> {
        let start = self.fraction_denominator_shift_down_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_numerator_gap_min_byte_range(&self) -> Range<usize> {
        let start = self
            .fraction_denominator_display_style_shift_down_byte_range()
            .end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_num_display_style_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.fraction_numerator_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_rule_thickness_byte_range(&self) -> Range<usize> {
        let start = self.fraction_num_display_style_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_denominator_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.fraction_rule_thickness_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn fraction_denom_display_style_gap_min_byte_range(&self) -> Range<usize> {
        let start = self.fraction_denominator_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn skewed_fraction_horizontal_gap_byte_range(&self) -> Range<usize> {
        let start = self.fraction_denom_display_style_gap_min_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn skewed_fraction_vertical_gap_byte_range(&self) -> Range<usize> {
        let start = self.skewed_fraction_horizontal_gap_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn overbar_vertical_gap_byte_range(&self) -> Range<usize> {
        let start = self.skewed_fraction_vertical_gap_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn overbar_rule_thickness_byte_range(&self) -> Range<usize> {
        let start = self.overbar_vertical_gap_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn overbar_extra_ascender_byte_range(&self) -> Range<usize> {
        let start = self.overbar_rule_thickness_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn underbar_vertical_gap_byte_range(&self) -> Range<usize> {
        let start = self.overbar_extra_ascender_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn underbar_rule_thickness_byte_range(&self) -> Range<usize> {
        let start = self.underbar_vertical_gap_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn underbar_extra_descender_byte_range(&self) -> Range<usize> {
        let start = self.underbar_rule_thickness_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_vertical_gap_byte_range(&self) -> Range<usize> {
        let start = self.underbar_extra_descender_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_display_style_vertical_gap_byte_range(&self) -> Range<usize> {
        let start = self.radical_vertical_gap_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_rule_thickness_byte_range(&self) -> Range<usize> {
        let start = self.radical_display_style_vertical_gap_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_extra_ascender_byte_range(&self) -> Range<usize> {
        let start = self.radical_rule_thickness_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_kern_before_degree_byte_range(&self) -> Range<usize> {
        let start = self.radical_extra_ascender_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_kern_after_degree_byte_range(&self) -> Range<usize> {
        let start = self.radical_kern_before_degree_byte_range().end;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn radical_degree_bottom_raise_percent_byte_range(&self) -> Range<usize> {
        let start = self.radical_kern_after_degree_byte_range().end;
        let end = start + i16::RAW_BYTE_LEN;
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(MathConstants::MIN_SIZE));

impl Default for MathConstants<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

impl<'a> MinByteRange<'a> for MathGlyphInfo<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.math_kern_info_offset_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathGlyphInfo<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathGlyphInfo<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathGlyphInfo](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathglyphinfo-table)
#[derive(Clone)]
pub struct MathGlyphInfo<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathGlyphInfo<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to MathItalicsCorrectionInfo table, from the beginning of the
    /// MathGlyphInfo table. May be NULL.
    pub fn math_italics_correction_info_offset(&self) -> Nullable<Offset16> {
        let range = self.math_italics_correction_info_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_italics_correction_info_offset`][Self::math_italics_correction_info_offset].
    pub fn math_italics_correction_info(
        &self,
    ) -> Option<Result<MathItalicsCorrectionInfo<'a>, ReadError>> {
        let data = self.data;
        self.math_italics_correction_info_offset().resolve(data)
    }

    /// Offset to MathTopAccentAttachment table, from the beginning of the
    /// MathGlyphInfo table. May be NULL.
    pub fn math_top_accent_attachment_offset(&self) -> Nullable<Offset16> {
        let range = self.math_top_accent_attachment_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_top_accent_attachment_offset`][Self::math_top_accent_attachment_offset].
    pub fn math_top_accent_attachment(
        &self,
    ) -> Option<Result<MathTopAccentAttachment<'a>, ReadError>> {
        let data = self.data;
        self.math_top_accent_attachment_offset().resolve(data)
    }

    /// Offset to the Coverage table for glyphs with extended shapes, from the
    /// beginning of the MathGlyphInfo table. May be NULL.
    pub fn extended_shape_coverage_offset(&self) -> Nullable<Offset16> {
        let range = self.extended_shape_coverage_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`extended_shape_coverage_offset`][Self::extended_shape_coverage_offset].
    pub fn extended_shape_coverage(&self) -> Option<Result<CoverageTable<'a>, ReadError>> {
        let data = self.data;
        self.extended_shape_coverage_offset().resolve(data)
    }

    /// Offset to the MathKernInfo table, from the beginning of the
    /// MathGlyphInfo table. May be NULL.
    pub fn math_kern_info_offset(&self) -> Nullable<Offset16> {
        let range = self.math_kern_info_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_kern_info_offset`][Self::math_kern_info_offset].
    pub fn math_kern_info(&self) -> Option<Result<MathKernInfo<'a>, ReadError>> {
        let data = self.data;
        self.math_kern_info_offset().resolve(data)
    }

    pub fn math_italics_correction_info_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_top_accent_attachment_offset_byte_range(&self) -> Range<usize> {
        let start = self.math_italics_correction_info_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn extended_shape_coverage_offset_byte_range(&self) -> Range<usize> {
        let start = self.math_top_accent_attachment_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_kern_info_offset_byte_range(&self) -> Range<usize> {
        let start = self.extended_shape_coverage_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(MathGlyphInfo::MIN_SIZE));

impl Default for MathGlyphInfo<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

impl<'a> MinByteRange<'a> for MathItalicsCorrectionInfo<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.italics_correction_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathItalicsCorrectionInfo<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathItalicsCorrectionInfo<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathItalicsCorrectionInfo](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathitalicscorrectioninfo-table)
#[derive(Clone)]
pub struct MathItalicsCorrectionInfo<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathItalicsCorrectionInfo<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to the Coverage table, from the beginning of the
    /// MathItalicsCorrectionInfo table.
    pub fn coverage_offset(&self) -> Offset16 {
        let range = self.coverage_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`coverage_offset`][Self::coverage_offset].
    pub fn coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
        let data = self.data;
        self.coverage_offset().resolve(data)
    }

    /// Number of italics correction values. Should coincide with the number of
    /// covered glyphs.
    pub fn italics_correction_count(&self) -> u16 {
        let range = self.italics_correction_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of MathValueRecords defining italics correction values for each
    /// covered glyph.
    pub fn italics_correction(&self) -> &'a [MathValueRecord] {
        let range = self.italics_correction_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    pub fn coverage_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn italics_correction_count_byte_range(&self) -> Range<usize> {
        let start = self.coverage_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn italics_correction_byte_range(&self) -> Range<usize> {
        let italics_correction_count = self.italics_correction_count();
        let start = self.italics_correction_count_byte_range().end;
        let end = start
            + (transforms::to_usize(italics_correction_count))
                .saturating_mul(MathValueRecord::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(
    MathItalicsCorrectionInfo::MIN_SIZE
));

impl Default for MathItalicsCorrectionInfo<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

impl<'a> MinByteRange<'a> for MathTopAccentAttachment<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.top_accent_attachment_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathTopAccentAttachment<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathTopAccentAttachment<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathTopAccentAttachment](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathtopaccentattachment-table)
#[derive(Clone)]
pub struct MathTopAccentAttachment<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathTopAccentAttachment<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to the Coverage table, from the beginning of the
    /// MathTopAccentAttachment table.
    pub fn top_accent_coverage_offset(&self) -> Offset16 {
        let range = self.top_accent_coverage_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`top_accent_coverage_offset`][Self::top_accent_coverage_offset].
    pub fn top_accent_coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
        let data = self.data;
        self.top_accent_coverage_offset().resolve(data)
    }

    /// Number of top accent attachment point values. Should coincide with the
    /// number of covered glyphs.
    pub fn top_accent_attachment_count(&self) -> u16 {
        let range = self.top_accent_attachment_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of MathValueRecords defining top accent attachment points for each
    /// covered glyph.
    pub fn top_accent_attachment(&self) -> &'a [MathValueRecord] {
        let range = self.top_accent_attachment_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    pub fn top_accent_coverage_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn top_accent_attachment_count_byte_range(&self) -> Range<usize> {
        let start = self.top_accent_coverage_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn top_accent_attachment_byte_range(&self) -> Range<usize> {
        let top_accent_attachment_count = self.top_accent_attachment_count();
        let start = self.top_accent_attachment_count_byte_range().end;
        let end = start
            + (transforms::to_usize(top_accent_attachment_count))
                .saturating_mul(MathValueRecord::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(
    MathTopAccentAttachment::MIN_SIZE
));

impl Default for MathTopAccentAttachment<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

impl<'a> MinByteRange<'a> for MathKernInfo<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.math_kern_info_records_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathKernInfo<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathKernInfo<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathKernInfo](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathkerninfo-table)
#[derive(Clone)]
pub struct MathKernInfo<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathKernInfo<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to the Coverage table, from the beginning of the MathKernInfo
    /// table.
    pub fn math_kern_coverage_offset(&self) -> Offset16 {
        let range = self.math_kern_coverage_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`math_kern_coverage_offset`][Self::math_kern_coverage_offset].
    pub fn math_kern_coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
        let data = self.data;
        self.math_kern_coverage_offset().resolve(data)
    }

    /// Number of MathKernInfoRecords. Should coincide with the number of
    /// covered glyphs.
    pub fn math_kern_count(&self) -> u16 {
        let range = self.math_kern_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of MathKernInfoRecords, one for each covered glyph.
    pub fn math_kern_info_records(&self) -> &'a [MathKernInfoRecord] {
        let range = self.math_kern_info_records_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    pub fn math_kern_coverage_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_kern_count_byte_range(&self) -> Range<usize> {
        let start = self.math_kern_coverage_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_kern_info_records_byte_range(&self) -> Range<usize> {
        let math_kern_count = self.math_kern_count();
        let start = self.math_kern_count_byte_range().end;
        let end = start
            + (transforms::to_usize(math_kern_count))
                .saturating_mul(MathKernInfoRecord::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(MathKernInfo::MIN_SIZE));

impl Default for MathKernInfo<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

/// [MathKernInfoRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathkerninforecord)
///
/// The offsets are measured from the beginning of the MathKernInfo table.
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct MathKernInfoRecord {
    /// Offset to the MathKern table for the top right corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    pub top_right_math_kern_offset: BigEndian<Nullable<Offset16>>,
    /// Offset to the MathKern table for the top left corner, from the beginning
    /// of the MathKernInfo table. May be NULL.
    pub top_left_math_kern_offset: BigEndian<Nullable<Offset16>>,
    /// Offset to the MathKern table for the bottom right corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    pub bottom_right_math_kern_offset: BigEndian<Nullable<Offset16>>,
    /// Offset to the MathKern table for the bottom left corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    pub bottom_left_math_kern_offset: BigEndian<Nullable<Offset16>>,
}

impl MathKernInfoRecord {
    /// Offset to the MathKern table for the top right corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    pub fn top_right_math_kern_offset(&self) -> Nullable<Offset16> {
        self.top_right_math_kern_offset.get()
    }

    /// Offset to the MathKern table for the top right corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn top_right_math_kern<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<MathKern<'a>, ReadError>> {
        self.top_right_math_kern_offset().resolve(data)
    }

    /// Offset to the MathKern table for the top left corner, from the beginning
    /// of the MathKernInfo table. May be NULL.
    pub fn top_left_math_kern_offset(&self) -> Nullable<Offset16> {
        self.top_left_math_kern_offset.get()
    }

    /// Offset to the MathKern table for the top left corner, from the beginning
    /// of the MathKernInfo table. May be NULL.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn top_left_math_kern<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<MathKern<'a>, ReadError>> {
        self.top_left_math_kern_offset().resolve(data)
    }

    /// Offset to the MathKern table for the bottom right corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    pub fn bottom_right_math_kern_offset(&self) -> Nullable<Offset16> {
        self.bottom_right_math_kern_offset.get()
    }

    /// Offset to the MathKern table for the bottom right corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn bottom_right_math_kern<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<MathKern<'a>, ReadError>> {
        self.bottom_right_math_kern_offset().resolve(data)
    }

    /// Offset to the MathKern table for the bottom left corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    pub fn bottom_left_math_kern_offset(&self) -> Nullable<Offset16> {
        self.bottom_left_math_kern_offset.get()
    }

    /// Offset to the MathKern table for the bottom left corner, from the
    /// beginning of the MathKernInfo table. May be NULL.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn bottom_left_math_kern<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<MathKern<'a>, ReadError>> {
        self.bottom_left_math_kern_offset().resolve(data)
    }
}

impl FixedSize for MathKernInfoRecord {
    const RAW_BYTE_LEN: usize = Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for MathKern<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.kern_values_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathKern<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathKern<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathKern](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathkern-table)
#[derive(Clone)]
pub struct MathKern<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathKern<'a> {
    pub const MIN_SIZE: usize = u16::RAW_BYTE_LEN;
    basic_table_impls!(impl_the_methods);

    /// Number of heights at which the kern value changes.
    pub fn height_count(&self) -> u16 {
        let range = self.height_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of correction heights, in design units, sorted from lowest to
    /// highest.
    pub fn correction_height(&self) -> &'a [MathValueRecord] {
        let range = self.correction_height_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    /// Array of kerning values for different height ranges, in design units.
    ///
    /// There is one more of these than there are correction heights: the first
    /// applies below the first correction height, and the last above the last.
    pub fn kern_values(&self) -> &'a [MathValueRecord] {
        let range = self.kern_values_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    pub fn height_count_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn correction_height_byte_range(&self) -> Range<usize> {
        let height_count = self.height_count();
        let start = self.height_count_byte_range().end;
        let end = start
            + (transforms::to_usize(height_count)).saturating_mul(MathValueRecord::RAW_BYTE_LEN);
        start..end
    }

    pub fn kern_values_byte_range(&self) -> Range<usize> {
        let height_count = self.height_count();
        let start = self.correction_height_byte_range().end;
        let end = start
            + (transforms::add(height_count, 1_usize))
                .saturating_mul(MathValueRecord::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(MathKern::MIN_SIZE));

impl Default for MathKern<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

impl<'a> MinByteRange<'a> for MathVariants<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.horiz_glyph_construction_offsets_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathVariants<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathVariants<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathVariants](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathvariants-table)
#[derive(Clone)]
pub struct MathVariants<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathVariants<'a> {
    pub const MIN_SIZE: usize = (UfWord::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + u16::RAW_BYTE_LEN
        + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Minimum overlap of connecting glyphs during glyph construction, in
    /// design units.
    pub fn min_connector_overlap(&self) -> UfWord {
        let range = self.min_connector_overlap_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Offset to the Coverage table for shapes growing in the vertical
    /// direction, from the beginning of the MathVariants table. May be NULL.
    pub fn vert_glyph_coverage_offset(&self) -> Nullable<Offset16> {
        let range = self.vert_glyph_coverage_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`vert_glyph_coverage_offset`][Self::vert_glyph_coverage_offset].
    pub fn vert_glyph_coverage(&self) -> Option<Result<CoverageTable<'a>, ReadError>> {
        let data = self.data;
        self.vert_glyph_coverage_offset().resolve(data)
    }

    /// Offset to the Coverage table for shapes growing in the horizontal
    /// direction, from the beginning of the MathVariants table. May be NULL.
    pub fn horiz_glyph_coverage_offset(&self) -> Nullable<Offset16> {
        let range = self.horiz_glyph_coverage_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`horiz_glyph_coverage_offset`][Self::horiz_glyph_coverage_offset].
    pub fn horiz_glyph_coverage(&self) -> Option<Result<CoverageTable<'a>, ReadError>> {
        let data = self.data;
        self.horiz_glyph_coverage_offset().resolve(data)
    }

    /// Number of glyphs for which information is provided for vertically
    /// growing variants. Must be the same as the number of glyph IDs referenced
    /// in the vertical Coverage table.
    pub fn vert_glyph_count(&self) -> u16 {
        let range = self.vert_glyph_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Number of glyphs for which information is provided for horizontally
    /// growing variants. Must be the same as the number of glyph IDs referenced
    /// in the horizontal Coverage table.
    pub fn horiz_glyph_count(&self) -> u16 {
        let range = self.horiz_glyph_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of offsets to MathGlyphConstruction tables, from the beginning of
    /// the MathVariants table, for shapes growing in the vertical direction.
    pub fn vert_glyph_construction_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.vert_glyph_construction_offsets_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`vert_glyph_construction_offsets`][Self::vert_glyph_construction_offsets].
    pub fn vert_glyph_constructions(
        &self,
    ) -> ArrayOfOffsets<'a, MathGlyphConstruction<'a>, Offset16> {
        let data = self.data;
        let offsets = self.vert_glyph_construction_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    /// Array of offsets to MathGlyphConstruction tables, from the beginning of
    /// the MathVariants table, for shapes growing in the horizontal direction.
    pub fn horiz_glyph_construction_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.horiz_glyph_construction_offsets_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`horiz_glyph_construction_offsets`][Self::horiz_glyph_construction_offsets].
    pub fn horiz_glyph_constructions(
        &self,
    ) -> ArrayOfOffsets<'a, MathGlyphConstruction<'a>, Offset16> {
        let data = self.data;
        let offsets = self.horiz_glyph_construction_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn min_connector_overlap_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + UfWord::RAW_BYTE_LEN;
        start..end
    }

    pub fn vert_glyph_coverage_offset_byte_range(&self) -> Range<usize> {
        let start = self.min_connector_overlap_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn horiz_glyph_coverage_offset_byte_range(&self) -> Range<usize> {
        let start = self.vert_glyph_coverage_offset_byte_range().end;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn vert_glyph_count_byte_range(&self) -> Range<usize> {
        let start = self.horiz_glyph_coverage_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn horiz_glyph_count_byte_range(&self) -> Range<usize> {
        let start = self.vert_glyph_count_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn vert_glyph_construction_offsets_byte_range(&self) -> Range<usize> {
        let vert_glyph_count = self.vert_glyph_count();
        let start = self.horiz_glyph_count_byte_range().end;
        let end =
            start + (transforms::to_usize(vert_glyph_count)).saturating_mul(Offset16::RAW_BYTE_LEN);
        start..end
    }

    pub fn horiz_glyph_construction_offsets_byte_range(&self) -> Range<usize> {
        let horiz_glyph_count = self.horiz_glyph_count();
        let start = self.vert_glyph_construction_offsets_byte_range().end;
        let end = start
            + (transforms::to_usize(horiz_glyph_count)).saturating_mul(Offset16::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(MathVariants::MIN_SIZE));

impl Default for MathVariants<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

impl<'a> MinByteRange<'a> for MathGlyphConstruction<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.math_glyph_variant_records_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for MathGlyphConstruction<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for MathGlyphConstruction<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [MathGlyphConstruction](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathglyphconstruction-table)
#[derive(Clone)]
pub struct MathGlyphConstruction<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> MathGlyphConstruction<'a> {
    pub const MIN_SIZE: usize = (Offset16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Offset to the GlyphAssembly table for this shape, from the beginning of
    /// the MathGlyphConstruction table. May be NULL.
    pub fn glyph_assembly_offset(&self) -> Nullable<Offset16> {
        let range = self.glyph_assembly_offset_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Attempt to resolve [`glyph_assembly_offset`][Self::glyph_assembly_offset].
    pub fn glyph_assembly(&self) -> Option<Result<GlyphAssembly<'a>, ReadError>> {
        let data = self.data;
        self.glyph_assembly_offset().resolve(data)
    }

    /// Count of glyph growing variants for this glyph.
    pub fn variant_count(&self) -> u16 {
        let range = self.variant_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// MathGlyphVariantRecords for alternative variants of the base glyph.
    pub fn math_glyph_variant_records(&self) -> &'a [MathGlyphVariantRecord] {
        let range = self.math_glyph_variant_records_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    pub fn glyph_assembly_offset_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + Offset16::RAW_BYTE_LEN;
        start..end
    }

    pub fn variant_count_byte_range(&self) -> Range<usize> {
        let start = self.glyph_assembly_offset_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn math_glyph_variant_records_byte_range(&self) -> Range<usize> {
        let variant_count = self.variant_count();
        let start = self.variant_count_byte_range().end;
        let end = start
            + (transforms::to_usize(variant_count))
                .saturating_mul(MathGlyphVariantRecord::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(
    MathGlyphConstruction::MIN_SIZE
));

impl Default for MathGlyphConstruction<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

/// [MathGlyphVariantRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/math#mathglyphvariantrecord)
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct MathGlyphVariantRecord {
    /// Glyph ID for the variant.
    pub variant_glyph: BigEndian<GlyphId16>,
    /// Advance width/height, in design units, of the variant, in the direction
    /// of requested glyph extension.
    pub advance_measurement: BigEndian<UfWord>,
}

impl MathGlyphVariantRecord {
    /// Glyph ID for the variant.
    pub fn variant_glyph(&self) -> GlyphId16 {
        self.variant_glyph.get()
    }

    /// Advance width/height, in design units, of the variant, in the direction
    /// of requested glyph extension.
    pub fn advance_measurement(&self) -> UfWord {
        self.advance_measurement.get()
    }
}

impl FixedSize for MathGlyphVariantRecord {
    const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + UfWord::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for GlyphAssembly<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.part_records_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.data.as_bytes().get(range).unwrap_or_default()
    }
}

impl ReadArgs for GlyphAssembly<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for GlyphAssembly<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        Ok(Self { data })
    }
}

/// [GlyphAssembly](https://learn.microsoft.com/en-us/typography/opentype/spec/math#glyphassembly-table)
#[derive(Clone)]
pub struct GlyphAssembly<'a> {
    data: FontData<'a>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> GlyphAssembly<'a> {
    pub const MIN_SIZE: usize = (MathValueRecord::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Italics correction of this GlyphAssembly. Should not depend on the
    /// assembly size.
    pub fn italics_correction(&self) -> &'a MathValueRecord {
        let range = self.italics_correction_byte_range();
        self.data.read_ref_at(range.start).ok().unwrap()
    }

    /// Number of parts in this assembly.
    pub fn part_count(&self) -> u16 {
        let range = self.part_count_byte_range();
        self.data.read_at(range.start).ok().unwrap()
    }

    /// Array of part records, from left to right (for assemblies that extend
    /// horizontally) or bottom to top (for assemblies that extend vertically).
    pub fn part_records(&self) -> &'a [GlyphPartRecord] {
        let range = self.part_records_byte_range();
        self.data.read_array(range).ok().unwrap_or_default()
    }

    pub fn italics_correction_byte_range(&self) -> Range<usize> {
        let start = 0;
        let end = start + MathValueRecord::RAW_BYTE_LEN;
        start..end
    }

    pub fn part_count_byte_range(&self) -> Range<usize> {
        let start = self.italics_correction_byte_range().end;
        let end = start + u16::RAW_BYTE_LEN;
        start..end
    }

    pub fn part_records_byte_range(&self) -> Range<usize> {
        let part_count = self.part_count();
        let start = self.part_count_byte_range().end;
        let end = start
            + (transforms::to_usize(part_count)).saturating_mul(GlyphPartRecord::RAW_BYTE_LEN);
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(GlyphAssembly::MIN_SIZE));

impl Default for GlyphAssembly<'_> {
    fn default() -> Self {
        Self {
            data: FontData::default_table_data(),
        }
    }
}

/// [GlyphPartRecord](https://learn.microsoft.com/en-us/typography/opentype/spec/math#glyphpartrecord)
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct GlyphPartRecord {
    /// Glyph ID for the part.
    pub glyph_id: BigEndian<GlyphId16>,
    /// Advance width/ height, in design units, of the straight bar connector
    /// material at the start of the glyph in the direction of the extension.
    pub start_connector_length: BigEndian<UfWord>,
    /// Advance width/ height, in design units, of the straight bar connector
    /// material at the end of the glyph in the direction of the extension.
    pub end_connector_length: BigEndian<UfWord>,
    /// Full advance width/height for this part in the direction of the
    /// extension, in design units.
    pub full_advance: BigEndian<UfWord>,
    /// Part qualifiers.
    pub part_flags: BigEndian<PartFlags>,
}

impl GlyphPartRecord {
    /// Glyph ID for the part.
    pub fn glyph_id(&self) -> GlyphId16 {
        self.glyph_id.get()
    }

    /// Advance width/ height, in design units, of the straight bar connector
    /// material at the start of the glyph in the direction of the extension.
    pub fn start_connector_length(&self) -> UfWord {
        self.start_connector_length.get()
    }

    /// Advance width/ height, in design units, of the straight bar connector
    /// material at the end of the glyph in the direction of the extension.
    pub fn end_connector_length(&self) -> UfWord {
        self.end_connector_length.get()
    }

    /// Full advance width/height for this part in the direction of the
    /// extension, in design units.
    pub fn full_advance(&self) -> UfWord {
        self.full_advance.get()
    }

    /// Part qualifiers.
    pub fn part_flags(&self) -> PartFlags {
        self.part_flags.get()
    }
}

impl FixedSize for GlyphPartRecord {
    const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + PartFlags::RAW_BYTE_LEN;
}

/// Qualifiers for a [`GlyphPartRecord`].
#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, bytemuck :: AnyBitPattern)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(transparent)]
pub struct PartFlags {
    bits: u16,
}

impl PartFlags {
    /// If set, the part can be skipped or repeated.
    pub const EXTENDER_FLAG: Self = Self { bits: 0x0001 };
}

impl PartFlags {
    ///  Returns an empty set of flags.
    #[inline]
    pub const fn empty() -> Self {
        Self { bits: 0 }
    }

    /// Returns the set containing all flags.
    #[inline]
    pub const fn all() -> Self {
        Self {
            bits: Self::EXTENDER_FLAG.bits,
        }
    }

    /// Returns the raw value of the flags currently stored.
    #[inline]
    pub const fn bits(&self) -> u16 {
        self.bits
    }

    /// Convert from underlying bit representation, unless that
    /// representation contains bits that do not correspond to a flag.
    #[inline]
    pub const fn from_bits(bits: u16) -> Option<Self> {
        if (bits & !Self::all().bits()) == 0 {
            Some(Self { bits })
        } else {
            None
        }
    }

    /// Convert from underlying bit representation, dropping any bits
    /// that do not correspond to flags.
    #[inline]
    pub const fn from_bits_truncate(bits: u16) -> Self {
        Self {
            bits: bits & Self::all().bits,
        }
    }

    /// Returns `true` if no flags are currently stored.
    #[inline]
    pub const fn is_empty(&self) -> bool {
        self.bits() == Self::empty().bits()
    }

    /// Returns `true` if there are flags common to both `self` and `other`.
    #[inline]
    pub const fn intersects(&self, other: Self) -> bool {
        !(Self {
            bits: self.bits & other.bits,
        })
        .is_empty()
    }

    /// Returns `true` if all of the flags in `other` are contained within `self`.
    #[inline]
    pub const fn contains(&self, other: Self) -> bool {
        (self.bits & other.bits) == other.bits
    }

    /// Inserts the specified flags in-place.
    #[inline]
    pub fn insert(&mut self, other: Self) {
        self.bits |= other.bits;
    }

    /// Removes the specified flags in-place.
    #[inline]
    pub fn remove(&mut self, other: Self) {
        self.bits &= !other.bits;
    }

    /// Toggles the specified flags in-place.
    #[inline]
    pub fn toggle(&mut self, other: Self) {
        self.bits ^= other.bits;
    }

    /// Returns the intersection between the flags in `self` and
    /// `other`.
    ///
    /// Specifically, the returned set contains only the flags which are
    /// present in *both* `self` *and* `other`.
    ///
    /// This is equivalent to using the `&` operator (e.g.
    /// [`ops::BitAnd`]), as in `flags & other`.
    ///
    /// [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.html
    #[inline]
    #[must_use]
    pub const fn intersection(self, other: Self) -> Self {
        Self {
            bits: self.bits & other.bits,
        }
    }

    /// Returns the union of between the flags in `self` and `other`.
    ///
    /// Specifically, the returned set contains all flags which are
    /// present in *either* `self` *or* `other`, including any which are
    /// present in both.
    ///
    /// This is equivalent to using the `|` operator (e.g.
    /// [`ops::BitOr`]), as in `flags | other`.
    ///
    /// [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.html
    #[inline]
    #[must_use]
    pub const fn union(self, other: Self) -> Self {
        Self {
            bits: self.bits | other.bits,
        }
    }

    /// Returns the difference between the flags in `self` and `other`.
    ///
    /// Specifically, the returned set contains all flags present in
    /// `self`, except for the ones present in `other`.
    ///
    /// It is also conceptually equivalent to the "bit-clear" operation:
    /// `flags & !other` (and this syntax is also supported).
    ///
    /// This is equivalent to using the `-` operator (e.g.
    /// [`ops::Sub`]), as in `flags - other`.
    ///
    /// [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.html
    #[inline]
    #[must_use]
    pub const fn difference(self, other: Self) -> Self {
        Self {
            bits: self.bits & !other.bits,
        }
    }
}

impl std::ops::BitOr for PartFlags {
    type Output = Self;

    /// Returns the union of the two sets of flags.
    #[inline]
    fn bitor(self, other: PartFlags) -> Self {
        Self {
            bits: self.bits | other.bits,
        }
    }
}

impl std::ops::BitOrAssign for PartFlags {
    /// Adds the set of flags.
    #[inline]
    fn bitor_assign(&mut self, other: Self) {
        self.bits |= other.bits;
    }
}

impl std::ops::BitXor for PartFlags {
    type Output = Self;

    /// Returns the left flags, but with all the right flags toggled.
    #[inline]
    fn bitxor(self, other: Self) -> Self {
        Self {
            bits: self.bits ^ other.bits,
        }
    }
}

impl std::ops::BitXorAssign for PartFlags {
    /// Toggles the set of flags.
    #[inline]
    fn bitxor_assign(&mut self, other: Self) {
        self.bits ^= other.bits;
    }
}

impl std::ops::BitAnd for PartFlags {
    type Output = Self;

    /// Returns the intersection between the two sets of flags.
    #[inline]
    fn bitand(self, other: Self) -> Self {
        Self {
            bits: self.bits & other.bits,
        }
    }
}

impl std::ops::BitAndAssign for PartFlags {
    /// Disables all flags disabled in the set.
    #[inline]
    fn bitand_assign(&mut self, other: Self) {
        self.bits &= other.bits;
    }
}

impl std::ops::Sub for PartFlags {
    type Output = Self;

    /// Returns the set difference of the two sets of flags.
    #[inline]
    fn sub(self, other: Self) -> Self {
        Self {
            bits: self.bits & !other.bits,
        }
    }
}

impl std::ops::SubAssign for PartFlags {
    /// Disables all flags enabled in the set.
    #[inline]
    fn sub_assign(&mut self, other: Self) {
        self.bits &= !other.bits;
    }
}

impl std::ops::Not for PartFlags {
    type Output = Self;

    /// Returns the complement of this set of flags.
    #[inline]
    fn not(self) -> Self {
        Self { bits: !self.bits } & Self::all()
    }
}

impl std::fmt::Debug for PartFlags {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        let members: &[(&str, Self)] = &[("EXTENDER_FLAG", Self::EXTENDER_FLAG)];
        let mut first = true;
        for (name, value) in members {
            if self.contains(*value) {
                if !first {
                    f.write_str(" | ")?;
                }
                first = false;
                f.write_str(name)?;
            }
        }
        if first {
            f.write_str("(empty)")?;
        }
        Ok(())
    }
}

impl std::fmt::Binary for PartFlags {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Binary::fmt(&self.bits, f)
    }
}

impl std::fmt::Octal for PartFlags {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Octal::fmt(&self.bits, f)
    }
}

impl std::fmt::LowerHex for PartFlags {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::LowerHex::fmt(&self.bits, f)
    }
}

impl std::fmt::UpperHex for PartFlags {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::UpperHex::fmt(&self.bits, f)
    }
}

impl font_types::Scalar for PartFlags {
    type Raw = <u16 as font_types::Scalar>::Raw;
    fn to_raw(self) -> Self::Raw {
        self.bits().to_raw()
    }
    fn from_raw(raw: Self::Raw) -> Self {
        let t = <u16>::from_raw(raw);
        Self::from_bits_truncate(t)
    }
}