read_fonts/generated/

generated_gpos.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 Gpos<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.lookup_list_offset_byte_range().end
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        let range = self.min_byte_range();
        self.offset_data().as_bytes().get(range).unwrap_or_default()
    }
}

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

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

impl<'a> FontRead<'a> for Gpos<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct GposFixedHeader {
    pub version: BigEndian<MajorMinor>,
    pub script_list_offset: BigEndian<Offset16>,
    pub feature_list_offset: BigEndian<Offset16>,
    pub lookup_list_offset: BigEndian<Offset16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<GposFixedHeader>() <= Gpos::MIN_SIZE);

/// [Class Definition Table Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-1)
/// [GPOS Version 1.0](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#gpos-header)
#[derive(Clone)]
pub struct Gpos<'a> {
    data: TableDataRef<'a, GposFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> Gpos<'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);

    /// The major and minor version of the GPOS table, as a tuple (u16, u16)
    pub fn version(&self) -> MajorMinor {
        self.data.header().version.get()
    }

    /// Offset to ScriptList table, from beginning of GPOS table
    pub fn script_list_offset(&self) -> Offset16 {
        self.data.header().script_list_offset.get()
    }

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

    /// Offset to FeatureList table, from beginning of GPOS table
    pub fn feature_list_offset(&self) -> Offset16 {
        self.data.header().feature_list_offset.get()
    }

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

    /// Offset to LookupList table, from beginning of GPOS table
    pub fn lookup_list_offset(&self) -> Offset16 {
        self.data.header().lookup_list_offset.get()
    }

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

    pub fn feature_variations_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.feature_variations_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Attempt to resolve [`feature_variations_offset`][Self::feature_variations_offset].
    pub fn feature_variations(&self) -> Option<Result<FeatureVariations<'a>, ReadError>> {
        let data = self.offset_data();
        self.feature_variations_offset().map(|x| x.resolve(data))?
    }

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

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

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

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

    pub fn feature_variations_offset_byte_range(&self) -> Range<usize> {
        let start = self.lookup_list_offset_byte_range().end;
        let end = if self.version().compatible((1u16, 1u16)) {
            start + Offset32::RAW_BYTE_LEN
        } else {
            start
        };
        start..end
    }
}

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

impl Default for Gpos<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

/// A [GPOS Lookup](https://learn.microsoft.com/en-us/typography/opentype/spec/gpos#gsubLookupTypeEnum) subtable.
pub enum PositionLookup<'a> {
    Single(Lookup<'a, SinglePos<'a>>),
    Pair(Lookup<'a, PairPos<'a>>),
    Cursive(Lookup<'a, CursivePosFormat1<'a>>),
    MarkToBase(Lookup<'a, MarkBasePosFormat1<'a>>),
    MarkToLig(Lookup<'a, MarkLigPosFormat1<'a>>),
    MarkToMark(Lookup<'a, MarkMarkPosFormat1<'a>>),
    Contextual(Lookup<'a, PositionSequenceContext<'a>>),
    ChainContextual(Lookup<'a, PositionChainContext<'a>>),
    Extension(Lookup<'a, ExtensionSubtable<'a>>),
}

impl Default for PositionLookup<'_> {
    fn default() -> Self {
        Self::Single(Default::default())
    }
}

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

impl<'a> FontRead<'a> for PositionLookup<'a> {
    fn read_with_args(bytes: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let discriminant = Lookup::read_discriminant(bytes)?;
        match discriminant {
            1 => Ok(PositionLookup::Single(FontRead::read(bytes)?)),
            2 => Ok(PositionLookup::Pair(FontRead::read(bytes)?)),
            3 => Ok(PositionLookup::Cursive(FontRead::read(bytes)?)),
            4 => Ok(PositionLookup::MarkToBase(FontRead::read(bytes)?)),
            5 => Ok(PositionLookup::MarkToLig(FontRead::read(bytes)?)),
            6 => Ok(PositionLookup::MarkToMark(FontRead::read(bytes)?)),
            7 => Ok(PositionLookup::Contextual(FontRead::read(bytes)?)),
            8 => Ok(PositionLookup::ChainContextual(FontRead::read(bytes)?)),
            9 => Ok(PositionLookup::Extension(FontRead::read(bytes)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> PositionLookup<'a> {
    #[allow(dead_code)]
    /// Return the inner table, removing the specific generics.
    ///
    /// This lets us return a single concrete type we can call methods on.
    pub(crate) fn of_unit_type(&self) -> Lookup<'a, ()> {
        match self {
            PositionLookup::Single(inner) => inner.of_unit_type(),
            PositionLookup::Pair(inner) => inner.of_unit_type(),
            PositionLookup::Cursive(inner) => inner.of_unit_type(),
            PositionLookup::MarkToBase(inner) => inner.of_unit_type(),
            PositionLookup::MarkToLig(inner) => inner.of_unit_type(),
            PositionLookup::MarkToMark(inner) => inner.of_unit_type(),
            PositionLookup::Contextual(inner) => inner.of_unit_type(),
            PositionLookup::ChainContextual(inner) => inner.of_unit_type(),
            PositionLookup::Extension(inner) => inner.of_unit_type(),
        }
    }
}

/// See [ValueRecord]
#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, bytemuck :: AnyBitPattern)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(transparent)]
pub struct ValueFormat {
    bits: u16,
}

impl ValueFormat {
    /// Includes horizontal adjustment for placement
    pub const X_PLACEMENT: Self = Self { bits: 0x0001 };

    /// Includes vertical adjustment for placement
    pub const Y_PLACEMENT: Self = Self { bits: 0x0002 };

    /// Includes horizontal adjustment for advance
    pub const X_ADVANCE: Self = Self { bits: 0x0004 };

    /// Includes vertical adjustment for advance
    pub const Y_ADVANCE: Self = Self { bits: 0x0008 };

    /// Includes Device table (non-variable font) / VariationIndex
    /// table (variable font) for horizontal placement
    pub const X_PLACEMENT_DEVICE: Self = Self { bits: 0x0010 };

    /// Includes Device table (non-variable font) / VariationIndex
    /// table (variable font) for vertical placement
    pub const Y_PLACEMENT_DEVICE: Self = Self { bits: 0x0020 };

    /// Includes Device table (non-variable font) / VariationIndex
    /// table (variable font) for horizontal advance
    pub const X_ADVANCE_DEVICE: Self = Self { bits: 0x0040 };

    /// Includes Device table (non-variable font) / VariationIndex
    /// table (variable font) for vertical advance
    pub const Y_ADVANCE_DEVICE: Self = Self { bits: 0x0080 };
}

impl ValueFormat {
    ///  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::X_PLACEMENT.bits
                | Self::Y_PLACEMENT.bits
                | Self::X_ADVANCE.bits
                | Self::Y_ADVANCE.bits
                | Self::X_PLACEMENT_DEVICE.bits
                | Self::Y_PLACEMENT_DEVICE.bits
                | Self::X_ADVANCE_DEVICE.bits
                | Self::Y_ADVANCE_DEVICE.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 ValueFormat {
    type Output = Self;

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

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

impl std::ops::BitXor for ValueFormat {
    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 ValueFormat {
    /// Toggles the set of flags.
    #[inline]
    fn bitxor_assign(&mut self, other: Self) {
        self.bits ^= other.bits;
    }
}

impl std::ops::BitAnd for ValueFormat {
    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 ValueFormat {
    /// Disables all flags disabled in the set.
    #[inline]
    fn bitand_assign(&mut self, other: Self) {
        self.bits &= other.bits;
    }
}

impl std::ops::Sub for ValueFormat {
    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 ValueFormat {
    /// Disables all flags enabled in the set.
    #[inline]
    fn sub_assign(&mut self, other: Self) {
        self.bits &= !other.bits;
    }
}

impl std::ops::Not for ValueFormat {
    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 ValueFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        let members: &[(&str, Self)] = &[
            ("X_PLACEMENT", Self::X_PLACEMENT),
            ("Y_PLACEMENT", Self::Y_PLACEMENT),
            ("X_ADVANCE", Self::X_ADVANCE),
            ("Y_ADVANCE", Self::Y_ADVANCE),
            ("X_PLACEMENT_DEVICE", Self::X_PLACEMENT_DEVICE),
            ("Y_PLACEMENT_DEVICE", Self::Y_PLACEMENT_DEVICE),
            ("X_ADVANCE_DEVICE", Self::X_ADVANCE_DEVICE),
            ("Y_ADVANCE_DEVICE", Self::Y_ADVANCE_DEVICE),
        ];
        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 ValueFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Binary::fmt(&self.bits, f)
    }
}

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

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

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

impl font_types::Scalar for ValueFormat {
    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)
    }
}

/// [Anchor Tables](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#anchor-tables)
/// position one glyph with respect to another.
#[derive(Clone)]
pub enum AnchorTable<'a> {
    Format1(AnchorFormat1<'a>),
    Format2(AnchorFormat2<'a>),
    Format3(AnchorFormat3<'a>),
}

impl Default for AnchorTable<'_> {
    fn default() -> Self {
        Self::Format1(Default::default())
    }
}

impl<'a> AnchorTable<'a> {
    ///Return the `FontData` used to resolve offsets for this table.
    pub fn offset_data(&self) -> FontData<'a> {
        match self {
            Self::Format1(item) => item.offset_data(),
            Self::Format2(item) => item.offset_data(),
            Self::Format3(item) => item.offset_data(),
        }
    }

    /// Format identifier, = 1
    pub fn anchor_format(&self) -> u16 {
        match self {
            Self::Format1(item) => item.anchor_format(),
            Self::Format2(item) => item.anchor_format(),
            Self::Format3(item) => item.anchor_format(),
        }
    }

    /// Horizontal value, in design units
    pub fn x_coordinate(&self) -> i16 {
        match self {
            Self::Format1(item) => item.x_coordinate(),
            Self::Format2(item) => item.x_coordinate(),
            Self::Format3(item) => item.x_coordinate(),
        }
    }

    /// Vertical value, in design units
    pub fn y_coordinate(&self) -> i16 {
        match self {
            Self::Format1(item) => item.y_coordinate(),
            Self::Format2(item) => item.y_coordinate(),
            Self::Format3(item) => item.y_coordinate(),
        }
    }
}

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

impl<'a> FontRead<'a> for AnchorTable<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let format: u16 = data.read_at(0usize)?;
        match format {
            AnchorFormat1::FORMAT => Ok(Self::Format1(FontRead::read(data)?)),
            AnchorFormat2::FORMAT => Ok(Self::Format2(FontRead::read(data)?)),
            AnchorFormat3::FORMAT => Ok(Self::Format3(FontRead::read(data)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> MinByteRange<'a> for AnchorTable<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        match self {
            Self::Format1(item) => item.min_byte_range(),
            Self::Format2(item) => item.min_byte_range(),
            Self::Format3(item) => item.min_byte_range(),
        }
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        match self {
            Self::Format1(item) => item.min_table_bytes(),
            Self::Format2(item) => item.min_table_bytes(),
            Self::Format3(item) => item.min_table_bytes(),
        }
    }
}

impl Format<u16> for AnchorFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for AnchorFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct AnchorFormat1FixedHeader {
    pub anchor_format: BigEndian<u16>,
    pub x_coordinate: BigEndian<i16>,
    pub y_coordinate: BigEndian<i16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<AnchorFormat1FixedHeader>() <= AnchorFormat1::MIN_SIZE);

/// [Anchor Table Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#anchor-table-format-1-design-units): Design Units
#[derive(Clone)]
pub struct AnchorFormat1<'a> {
    data: TableDataRef<'a, AnchorFormat1FixedHeader>,
}

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

    /// Format identifier, = 1
    pub fn anchor_format(&self) -> u16 {
        self.data.header().anchor_format.get()
    }

    /// Horizontal value, in design units
    pub fn x_coordinate(&self) -> i16 {
        self.data.header().x_coordinate.get()
    }

    /// Vertical value, in design units
    pub fn y_coordinate(&self) -> i16 {
        self.data.header().y_coordinate.get()
    }

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

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

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

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

impl Default for AnchorFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl Format<u16> for AnchorFormat2<'_> {
    const FORMAT: u16 = 2;
}

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

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

impl<'a> FontRead<'a> for AnchorFormat2<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct AnchorFormat2FixedHeader {
    pub anchor_format: BigEndian<u16>,
    pub x_coordinate: BigEndian<i16>,
    pub y_coordinate: BigEndian<i16>,
    pub anchor_point: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<AnchorFormat2FixedHeader>() <= AnchorFormat2::MIN_SIZE);

/// [Anchor Table Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#anchor-table-format-2-design-units-plus-contour-point): Design Units Plus Contour Point
#[derive(Clone)]
pub struct AnchorFormat2<'a> {
    data: TableDataRef<'a, AnchorFormat2FixedHeader>,
}

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

    /// Format identifier, = 2
    pub fn anchor_format(&self) -> u16 {
        self.data.header().anchor_format.get()
    }

    /// Horizontal value, in design units
    pub fn x_coordinate(&self) -> i16 {
        self.data.header().x_coordinate.get()
    }

    /// Vertical value, in design units
    pub fn y_coordinate(&self) -> i16 {
        self.data.header().y_coordinate.get()
    }

    /// Index to glyph contour point
    pub fn anchor_point(&self) -> u16 {
        self.data.header().anchor_point.get()
    }

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

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

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

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

impl Format<u16> for AnchorFormat3<'_> {
    const FORMAT: u16 = 3;
}

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

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

impl<'a> FontRead<'a> for AnchorFormat3<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct AnchorFormat3FixedHeader {
    pub anchor_format: BigEndian<u16>,
    pub x_coordinate: BigEndian<i16>,
    pub y_coordinate: BigEndian<i16>,
    pub x_device_offset: BigEndian<Nullable<Offset16>>,
    pub y_device_offset: BigEndian<Nullable<Offset16>>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<AnchorFormat3FixedHeader>() <= AnchorFormat3::MIN_SIZE);

/// [Anchor Table Format 3](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#anchor-table-format-3-design-units-plus-device-or-variationindex-tables): Design Units Plus Device or VariationIndex Tables
#[derive(Clone)]
pub struct AnchorFormat3<'a> {
    data: TableDataRef<'a, AnchorFormat3FixedHeader>,
}

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

    /// Format identifier, = 3
    pub fn anchor_format(&self) -> u16 {
        self.data.header().anchor_format.get()
    }

    /// Horizontal value, in design units
    pub fn x_coordinate(&self) -> i16 {
        self.data.header().x_coordinate.get()
    }

    /// Vertical value, in design units
    pub fn y_coordinate(&self) -> i16 {
        self.data.header().y_coordinate.get()
    }

    /// Offset to Device table (non-variable font) / VariationIndex
    /// table (variable font) for X coordinate, from beginning of
    /// Anchor table (may be NULL)
    pub fn x_device_offset(&self) -> Nullable<Offset16> {
        self.data.header().x_device_offset.get()
    }

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

    /// Offset to Device table (non-variable font) / VariationIndex
    /// table (variable font) for Y coordinate, from beginning of
    /// Anchor table (may be NULL)
    pub fn y_device_offset(&self) -> Nullable<Offset16> {
        self.data.header().y_device_offset.get()
    }

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

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

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

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

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

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

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

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

impl<'a> FontRead<'a> for MarkArray<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct MarkArrayFixedHeader {
    pub mark_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<MarkArrayFixedHeader>() <= MarkArray::MIN_SIZE);

/// [Mark Array Table](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#mark-array-table)
#[derive(Clone)]
pub struct MarkArray<'a> {
    data: TableDataRef<'a, MarkArrayFixedHeader>,
}

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

    /// Number of MarkRecords
    pub fn mark_count(&self) -> u16 {
        self.data.header().mark_count.get()
    }

    /// Array of MarkRecords, ordered by corresponding glyphs in the
    /// associated mark Coverage table.
    pub fn mark_records(&self) -> &'a [MarkRecord] {
        let range = self.mark_records_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

    pub fn mark_records_byte_range(&self) -> Range<usize> {
        let mark_count = self.mark_count();
        let start = self.mark_count_byte_range().end;
        let end =
            start + (transforms::to_usize(mark_count)).saturating_mul(MarkRecord::RAW_BYTE_LEN);
        start..end
    }
}

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

impl Default for MarkArray<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

/// Part of [MarkArray]
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct MarkRecord {
    /// Class defined for the associated mark.
    pub mark_class: BigEndian<u16>,
    /// Offset to Anchor table, from beginning of MarkArray table.
    pub mark_anchor_offset: BigEndian<Offset16>,
}

impl MarkRecord {
    /// Class defined for the associated mark.
    pub fn mark_class(&self) -> u16 {
        self.mark_class.get()
    }

    /// Offset to Anchor table, from beginning of MarkArray table.
    pub fn mark_anchor_offset(&self) -> Offset16 {
        self.mark_anchor_offset.get()
    }

    /// Offset to Anchor table, from beginning of MarkArray table.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn mark_anchor<'a>(&self, data: FontData<'a>) -> Result<AnchorTable<'a>, ReadError> {
        self.mark_anchor_offset().resolve(data)
    }
}

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

/// [Lookup Type 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-1-single-adjustment-positioning-subtable): Single Adjustment Positioning Subtable
#[derive(Clone)]
pub enum SinglePos<'a> {
    Format1(SinglePosFormat1<'a>),
    Format2(SinglePosFormat2<'a>),
}

impl Default for SinglePos<'_> {
    fn default() -> Self {
        Self::Format1(Default::default())
    }
}

impl<'a> SinglePos<'a> {
    ///Return the `FontData` used to resolve offsets for this table.
    pub fn offset_data(&self) -> FontData<'a> {
        match self {
            Self::Format1(item) => item.offset_data(),
            Self::Format2(item) => item.offset_data(),
        }
    }

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        match self {
            Self::Format1(item) => item.pos_format(),
            Self::Format2(item) => item.pos_format(),
        }
    }

    /// Offset to Coverage table, from beginning of SinglePos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        match self {
            Self::Format1(item) => item.coverage_offset(),
            Self::Format2(item) => item.coverage_offset(),
        }
    }

    /// Defines the types of data in the ValueRecord.
    pub fn value_format(&self) -> ValueFormat {
        match self {
            Self::Format1(item) => item.value_format(),
            Self::Format2(item) => item.value_format(),
        }
    }
}

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

impl<'a> FontRead<'a> for SinglePos<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let format: u16 = data.read_at(0usize)?;
        match format {
            SinglePosFormat1::FORMAT => Ok(Self::Format1(FontRead::read(data)?)),
            SinglePosFormat2::FORMAT => Ok(Self::Format2(FontRead::read(data)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> MinByteRange<'a> for SinglePos<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        match self {
            Self::Format1(item) => item.min_byte_range(),
            Self::Format2(item) => item.min_byte_range(),
        }
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        match self {
            Self::Format1(item) => item.min_table_bytes(),
            Self::Format2(item) => item.min_table_bytes(),
        }
    }
}

impl Format<u16> for SinglePosFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for SinglePosFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct SinglePosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub coverage_offset: BigEndian<Offset16>,
    pub value_format: BigEndian<ValueFormat>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<SinglePosFormat1FixedHeader>() <= SinglePosFormat1::MIN_SIZE);

/// [Single Adjustment Positioning Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#single-adjustment-positioning-format-1-single-positioning-value): Single Positioning Value
#[derive(Clone)]
pub struct SinglePosFormat1<'a> {
    data: TableDataRef<'a, SinglePosFormat1FixedHeader>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to Coverage table, from beginning of SinglePos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

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

    /// Defines the types of data in the ValueRecord.
    pub fn value_format(&self) -> ValueFormat {
        self.data.header().value_format.get()
    }

    /// Defines positioning value(s) — applied to all glyphs in the
    /// Coverage table.
    pub fn value_record(&self) -> ValueRecord<'a> {
        let range = self.value_record_byte_range();
        ValueRecord::read_at(self.offset_data(), range.start, self.value_format())
            .unwrap_or_default()
    }

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

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

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

    pub fn value_record_byte_range(&self) -> Range<usize> {
        let start = self.value_format_byte_range().end;
        let end =
            start + <ValueRecord as ComputeSize>::compute_size(self.value_format()).unwrap_or(0);
        start..end
    }
}

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

impl Default for SinglePosFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

impl Format<u16> for SinglePosFormat2<'_> {
    const FORMAT: u16 = 2;
}

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

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

impl<'a> FontRead<'a> for SinglePosFormat2<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct SinglePosFormat2FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub coverage_offset: BigEndian<Offset16>,
    pub value_format: BigEndian<ValueFormat>,
    pub value_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<SinglePosFormat2FixedHeader>() <= SinglePosFormat2::MIN_SIZE);

/// [Single Adjustment Positioning Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#single-adjustment-positioning-format-2-array-of-positioning-values): Array of Positioning Values
#[derive(Clone)]
pub struct SinglePosFormat2<'a> {
    data: TableDataRef<'a, SinglePosFormat2FixedHeader>,
}

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

    /// Format identifier: format = 2
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to Coverage table, from beginning of SinglePos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

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

    /// Defines the types of data in the ValueRecords.
    pub fn value_format(&self) -> ValueFormat {
        self.data.header().value_format.get()
    }

    /// Number of ValueRecords — must equal glyphCount in the
    /// Coverage table.
    pub fn value_count(&self) -> u16 {
        self.data.header().value_count.get()
    }

    /// Array of ValueRecords — positioning values applied to glyphs.
    pub fn value_records(&self) -> ComputedArray<'a, ValueRecord<'a>> {
        let range = self.value_records_byte_range();
        ComputedArray::new(self.offset_data(), range, self.value_format()).unwrap_or_default()
    }

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

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

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

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

    pub fn value_records_byte_range(&self) -> Range<usize> {
        let value_count = self.value_count();
        let start = self.value_count_byte_range().end;
        let end = start
            + (transforms::to_usize(value_count)).saturating_mul(
                <ValueRecord as ComputeSize>::compute_size(self.value_format()).unwrap_or(0),
            );
        start..end
    }
}

/// [Lookup Type 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-1-single-adjustment-positioning-subtable): Single Adjustment Positioning Subtable
#[derive(Clone)]
pub enum PairPos<'a> {
    Format1(PairPosFormat1<'a>),
    Format2(PairPosFormat2<'a>),
}

impl Default for PairPos<'_> {
    fn default() -> Self {
        Self::Format1(Default::default())
    }
}

impl<'a> PairPos<'a> {
    ///Return the `FontData` used to resolve offsets for this table.
    pub fn offset_data(&self) -> FontData<'a> {
        match self {
            Self::Format1(item) => item.offset_data(),
            Self::Format2(item) => item.offset_data(),
        }
    }

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        match self {
            Self::Format1(item) => item.pos_format(),
            Self::Format2(item) => item.pos_format(),
        }
    }

    /// Offset to Coverage table, from beginning of PairPos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        match self {
            Self::Format1(item) => item.coverage_offset(),
            Self::Format2(item) => item.coverage_offset(),
        }
    }

    /// Defines the types of data in valueRecord1 — for the first
    /// glyph in the pair (may be zero).
    pub fn value_format1(&self) -> ValueFormat {
        match self {
            Self::Format1(item) => item.value_format1(),
            Self::Format2(item) => item.value_format1(),
        }
    }

    /// Defines the types of data in valueRecord2 — for the second
    /// glyph in the pair (may be zero).
    pub fn value_format2(&self) -> ValueFormat {
        match self {
            Self::Format1(item) => item.value_format2(),
            Self::Format2(item) => item.value_format2(),
        }
    }
}

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

impl<'a> FontRead<'a> for PairPos<'a> {
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let format: u16 = data.read_at(0usize)?;
        match format {
            PairPosFormat1::FORMAT => Ok(Self::Format1(FontRead::read(data)?)),
            PairPosFormat2::FORMAT => Ok(Self::Format2(FontRead::read(data)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> MinByteRange<'a> for PairPos<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        match self {
            Self::Format1(item) => item.min_byte_range(),
            Self::Format2(item) => item.min_byte_range(),
        }
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        match self {
            Self::Format1(item) => item.min_table_bytes(),
            Self::Format2(item) => item.min_table_bytes(),
        }
    }
}

impl Format<u16> for PairPosFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for PairPosFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct PairPosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub coverage_offset: BigEndian<Offset16>,
    pub value_format1: BigEndian<ValueFormat>,
    pub value_format2: BigEndian<ValueFormat>,
    pub pair_set_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<PairPosFormat1FixedHeader>() <= PairPosFormat1::MIN_SIZE);

/// [Pair Adjustment Positioning Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#pair-adjustment-positioning-format-1-adjustments-for-glyph-pairs): Adjustments for Glyph Pairs
#[derive(Clone)]
pub struct PairPosFormat1<'a> {
    data: TableDataRef<'a, PairPosFormat1FixedHeader>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to Coverage table, from beginning of PairPos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

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

    /// Defines the types of data in valueRecord1 — for the first
    /// glyph in the pair (may be zero).
    pub fn value_format1(&self) -> ValueFormat {
        self.data.header().value_format1.get()
    }

    /// Defines the types of data in valueRecord2 — for the second
    /// glyph in the pair (may be zero).
    pub fn value_format2(&self) -> ValueFormat {
        self.data.header().value_format2.get()
    }

    /// Number of PairSet tables
    pub fn pair_set_count(&self) -> u16 {
        self.data.header().pair_set_count.get()
    }

    /// Array of offsets to PairSet tables. Offsets are from beginning
    /// of PairPos subtable, ordered by Coverage Index.
    pub fn pair_set_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.pair_set_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`pair_set_offsets`][Self::pair_set_offsets].
    pub fn pair_sets(&self) -> ArrayOfOffsets<'a, PairSet<'a>, Offset16> {
        let data = self.offset_data();
        let offsets = self.pair_set_offsets();
        let args = (self.value_format1(), self.value_format2());
        ArrayOfOffsets::new(offsets, data, args)
    }

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

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

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

    pub fn value_format2_byte_range(&self) -> Range<usize> {
        let start = self.value_format1_byte_range().end;
        let end = start + ValueFormat::RAW_BYTE_LEN;
        start..end
    }

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

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

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

impl Default for PairPosFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

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

impl ReadArgs for PairSet<'_> {
    type Args = (ValueFormat, ValueFormat);
}

impl<'a> FontRead<'a> for PairSet<'a> {
    fn read_with_args(
        data: FontData<'a>,
        args: (ValueFormat, ValueFormat),
    ) -> Result<Self, ReadError> {
        let (value_format1, value_format2) = args;

        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self {
            data,
            value_format1,
            value_format2,
        })
    }
}

impl<'a> PairSet<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(
        data: FontData<'a>,
        value_format1: ValueFormat,
        value_format2: ValueFormat,
    ) -> Result<Self, ReadError> {
        let args = (value_format1, value_format2);
        Self::read_with_args(data, args)
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct PairSetFixedHeader {
    pub pair_value_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<PairSetFixedHeader>() <= PairSet::MIN_SIZE);

/// Part of [PairPosFormat1]
#[derive(Clone)]
pub struct PairSet<'a> {
    data: TableDataRef<'a, PairSetFixedHeader>,
    value_format1: ValueFormat,
    value_format2: ValueFormat,
}

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

    /// Number of PairValueRecords
    pub fn pair_value_count(&self) -> u16 {
        self.data.header().pair_value_count.get()
    }

    /// Array of PairValueRecords, ordered by glyph ID of the second
    /// glyph.
    pub fn pair_value_records(&self) -> ComputedArray<'a, PairValueRecord<'a>> {
        let range = self.pair_value_records_byte_range();
        ComputedArray::new(
            self.offset_data(),
            range,
            (self.value_format1(), self.value_format2()),
        )
        .unwrap_or_default()
    }

    pub(crate) fn value_format1(&self) -> ValueFormat {
        self.value_format1
    }

    pub(crate) fn value_format2(&self) -> ValueFormat {
        self.value_format2
    }

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

    pub fn pair_value_records_byte_range(&self) -> Range<usize> {
        let pair_value_count = self.pair_value_count();
        let start = self.pair_value_count_byte_range().end;
        let end = start
            + (transforms::to_usize(pair_value_count)).saturating_mul(
                <PairValueRecord as ComputeSize>::compute_size((
                    self.value_format1(),
                    self.value_format2(),
                ))
                .unwrap_or(0),
            );
        start..end
    }
}

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

impl Default for PairSet<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
            value_format1: Default::default(),
            value_format2: Default::default(),
        }
    }
}

/// Part of [PairSet]
#[derive(Clone, Debug)]
pub struct PairValueRecord<'a> {
    /// Glyph ID of second glyph in the pair (first glyph is listed in
    /// the Coverage table).
    pub second_glyph: BigEndian<GlyphId16>,
    /// Positioning data for the first glyph in the pair.
    pub value_record1: ValueRecord<'a>,
    /// Positioning data for the second glyph in the pair.
    pub value_record2: ValueRecord<'a>,
}

impl<'a> PairValueRecord<'a> {
    /// Glyph ID of second glyph in the pair (first glyph is listed in
    /// the Coverage table).
    pub fn second_glyph(&self) -> GlyphId16 {
        self.second_glyph.get()
    }

    /// Positioning data for the first glyph in the pair.
    pub fn value_record1(&self) -> &ValueRecord<'a> {
        &self.value_record1
    }

    /// Positioning data for the second glyph in the pair.
    pub fn value_record2(&self) -> &ValueRecord<'a> {
        &self.value_record2
    }
}

impl ReadArgs for PairValueRecord<'_> {
    type Args = (ValueFormat, ValueFormat);
}

impl ComputeSize for PairValueRecord<'_> {
    #[allow(clippy::needless_question_mark)]
    fn compute_size(args: (ValueFormat, ValueFormat)) -> Result<usize, ReadError> {
        let (value_format1, value_format2) = args;
        let mut result = 0usize;
        result = result
            .checked_add(GlyphId16::RAW_BYTE_LEN)
            .ok_or(ReadError::OutOfBounds)?;
        result = result
            .checked_add(<ValueRecord as ComputeSize>::compute_size(value_format1).unwrap_or(0))
            .ok_or(ReadError::OutOfBounds)?;
        result = result
            .checked_add(<ValueRecord as ComputeSize>::compute_size(value_format2).unwrap_or(0))
            .ok_or(ReadError::OutOfBounds)?;
        Ok(result)
    }
}

impl<'a> FontReadAt<'a> for PairValueRecord<'a> {
    fn read_at(
        data: FontData<'a>,
        offset: usize,
        args: (ValueFormat, ValueFormat),
    ) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        cursor.advance_by(offset);
        let (value_format1, value_format2) = args;
        Ok(Self {
            second_glyph: cursor.read_be()?,
            value_record1: cursor.read_at_with_args(value_format1)?,
            value_record2: cursor.read_at_with_args(value_format2)?,
        })
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PairValueRecord<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(
        data: FontData<'a>,
        offset: usize,
        value_format1: ValueFormat,
        value_format2: ValueFormat,
    ) -> Result<Self, ReadError> {
        let args = (value_format1, value_format2);
        Self::read_at(data, offset, args)
    }
}

impl Format<u16> for PairPosFormat2<'_> {
    const FORMAT: u16 = 2;
}

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

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

impl<'a> FontRead<'a> for PairPosFormat2<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct PairPosFormat2FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub coverage_offset: BigEndian<Offset16>,
    pub value_format1: BigEndian<ValueFormat>,
    pub value_format2: BigEndian<ValueFormat>,
    pub class_def1_offset: BigEndian<Offset16>,
    pub class_def2_offset: BigEndian<Offset16>,
    pub class1_count: BigEndian<u16>,
    pub class2_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<PairPosFormat2FixedHeader>() <= PairPosFormat2::MIN_SIZE);

/// [Pair Adjustment Positioning Format 2](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#pair-adjustment-positioning-format-2-class-pair-adjustment): Class Pair Adjustment
#[derive(Clone)]
pub struct PairPosFormat2<'a> {
    data: TableDataRef<'a, PairPosFormat2FixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PairPosFormat2<'a> {
    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN
        + Offset16::RAW_BYTE_LEN
        + ValueFormat::RAW_BYTE_LEN
        + ValueFormat::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);

    /// Format identifier: format = 2
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to Coverage table, from beginning of PairPos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

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

    /// ValueRecord definition — for the first glyph of the pair (may
    /// be zero).
    pub fn value_format1(&self) -> ValueFormat {
        self.data.header().value_format1.get()
    }

    /// ValueRecord definition — for the second glyph of the pair
    /// (may be zero).
    pub fn value_format2(&self) -> ValueFormat {
        self.data.header().value_format2.get()
    }

    /// Offset to ClassDef table, from beginning of PairPos subtable
    /// — for the first glyph of the pair.
    pub fn class_def1_offset(&self) -> Offset16 {
        self.data.header().class_def1_offset.get()
    }

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

    /// Offset to ClassDef table, from beginning of PairPos subtable
    /// — for the second glyph of the pair.
    pub fn class_def2_offset(&self) -> Offset16 {
        self.data.header().class_def2_offset.get()
    }

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

    /// Number of classes in classDef1 table — includes Class 0.
    pub fn class1_count(&self) -> u16 {
        self.data.header().class1_count.get()
    }

    /// Number of classes in classDef2 table — includes Class 0.
    pub fn class2_count(&self) -> u16 {
        self.data.header().class2_count.get()
    }

    /// Array of Class1 records, ordered by classes in classDef1.
    pub fn class1_records(&self) -> ComputedArray<'a, Class1Record<'a>> {
        let range = self.class1_records_byte_range();
        ComputedArray::new(
            self.offset_data(),
            range,
            (
                self.class2_count(),
                self.value_format1(),
                self.value_format2(),
            ),
        )
        .unwrap_or_default()
    }

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

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

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

    pub fn value_format2_byte_range(&self) -> Range<usize> {
        let start = self.value_format1_byte_range().end;
        let end = start + ValueFormat::RAW_BYTE_LEN;
        start..end
    }

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

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

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

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

    pub fn class1_records_byte_range(&self) -> Range<usize> {
        let class1_count = self.class1_count();
        let start = self.class2_count_byte_range().end;
        let end = start
            + (transforms::to_usize(class1_count)).saturating_mul(
                <Class1Record as ComputeSize>::compute_size((
                    self.class2_count(),
                    self.value_format1(),
                    self.value_format2(),
                ))
                .unwrap_or(0),
            );
        start..end
    }
}

/// Part of [PairPosFormat2]
#[derive(Clone, Debug)]
pub struct Class1Record<'a> {
    /// Array of Class2 records, ordered by classes in classDef2.
    pub class2_records: ComputedArray<'a, Class2Record<'a>>,
}

impl<'a> Class1Record<'a> {
    /// Array of Class2 records, ordered by classes in classDef2.
    pub fn class2_records(&self) -> &ComputedArray<'a, Class2Record<'a>> {
        &self.class2_records
    }
}

impl ReadArgs for Class1Record<'_> {
    type Args = (u16, ValueFormat, ValueFormat);
}

impl ComputeSize for Class1Record<'_> {
    #[allow(clippy::needless_question_mark)]
    fn compute_size(args: (u16, ValueFormat, ValueFormat)) -> Result<usize, ReadError> {
        let (class2_count, value_format1, value_format2) = args;
        Ok((transforms::to_usize(class2_count)).saturating_mul(
            <Class2Record as ComputeSize>::compute_size((value_format1, value_format2))
                .unwrap_or(0),
        ))
    }
}

impl<'a> FontReadAt<'a> for Class1Record<'a> {
    fn read_at(
        data: FontData<'a>,
        offset: usize,
        args: (u16, ValueFormat, ValueFormat),
    ) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        cursor.advance_by(offset);
        let (class2_count, value_format1, value_format2) = args;
        Ok(Self {
            class2_records: cursor.read_computed_array(
                transforms::to_usize(class2_count),
                (value_format1, value_format2),
            )?,
        })
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> Class1Record<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(
        data: FontData<'a>,
        offset: usize,
        class2_count: u16,
        value_format1: ValueFormat,
        value_format2: ValueFormat,
    ) -> Result<Self, ReadError> {
        let args = (class2_count, value_format1, value_format2);
        Self::read_at(data, offset, args)
    }
}

/// Part of [PairPosFormat2]
#[derive(Clone, Debug)]
pub struct Class2Record<'a> {
    /// Positioning for first glyph — empty if valueFormat1 = 0.
    pub value_record1: ValueRecord<'a>,
    /// Positioning for second glyph — empty if valueFormat2 = 0.
    pub value_record2: ValueRecord<'a>,
}

impl<'a> Class2Record<'a> {
    /// Positioning for first glyph — empty if valueFormat1 = 0.
    pub fn value_record1(&self) -> &ValueRecord<'a> {
        &self.value_record1
    }

    /// Positioning for second glyph — empty if valueFormat2 = 0.
    pub fn value_record2(&self) -> &ValueRecord<'a> {
        &self.value_record2
    }
}

impl ReadArgs for Class2Record<'_> {
    type Args = (ValueFormat, ValueFormat);
}

impl ComputeSize for Class2Record<'_> {
    #[allow(clippy::needless_question_mark)]
    fn compute_size(args: (ValueFormat, ValueFormat)) -> Result<usize, ReadError> {
        let (value_format1, value_format2) = args;
        let mut result = 0usize;
        result = result
            .checked_add(<ValueRecord as ComputeSize>::compute_size(value_format1).unwrap_or(0))
            .ok_or(ReadError::OutOfBounds)?;
        result = result
            .checked_add(<ValueRecord as ComputeSize>::compute_size(value_format2).unwrap_or(0))
            .ok_or(ReadError::OutOfBounds)?;
        Ok(result)
    }
}

impl<'a> FontReadAt<'a> for Class2Record<'a> {
    fn read_at(
        data: FontData<'a>,
        offset: usize,
        args: (ValueFormat, ValueFormat),
    ) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        cursor.advance_by(offset);
        let (value_format1, value_format2) = args;
        Ok(Self {
            value_record1: cursor.read_at_with_args(value_format1)?,
            value_record2: cursor.read_at_with_args(value_format2)?,
        })
    }
}

#[allow(clippy::needless_lifetimes)]
impl<'a> Class2Record<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(
        data: FontData<'a>,
        offset: usize,
        value_format1: ValueFormat,
        value_format2: ValueFormat,
    ) -> Result<Self, ReadError> {
        let args = (value_format1, value_format2);
        Self::read_at(data, offset, args)
    }
}

impl Format<u16> for CursivePosFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for CursivePosFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct CursivePosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub coverage_offset: BigEndian<Offset16>,
    pub entry_exit_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<CursivePosFormat1FixedHeader>() <= CursivePosFormat1::MIN_SIZE);

/// [Cursive Attachment Positioning Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#cursive-attachment-positioning-format1-cursive-attachment): Cursvie attachment
#[derive(Clone)]
pub struct CursivePosFormat1<'a> {
    data: TableDataRef<'a, CursivePosFormat1FixedHeader>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to Coverage table, from beginning of CursivePos subtable.
    pub fn coverage_offset(&self) -> Offset16 {
        self.data.header().coverage_offset.get()
    }

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

    /// Number of EntryExit records
    pub fn entry_exit_count(&self) -> u16 {
        self.data.header().entry_exit_count.get()
    }

    /// Array of EntryExit records, in Coverage index order.
    pub fn entry_exit_record(&self) -> &'a [EntryExitRecord] {
        let range = self.entry_exit_record_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

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

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

    pub fn entry_exit_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 entry_exit_record_byte_range(&self) -> Range<usize> {
        let entry_exit_count = self.entry_exit_count();
        let start = self.entry_exit_count_byte_range().end;
        let end = start
            + (transforms::to_usize(entry_exit_count))
                .saturating_mul(EntryExitRecord::RAW_BYTE_LEN);
        start..end
    }
}

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

impl Default for CursivePosFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

/// Part of [CursivePosFormat1]
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct EntryExitRecord {
    /// Offset to entryAnchor table, from beginning of CursivePos
    /// subtable (may be NULL).
    pub entry_anchor_offset: BigEndian<Nullable<Offset16>>,
    /// Offset to exitAnchor table, from beginning of CursivePos
    /// subtable (may be NULL).
    pub exit_anchor_offset: BigEndian<Nullable<Offset16>>,
}

impl EntryExitRecord {
    /// Offset to entryAnchor table, from beginning of CursivePos
    /// subtable (may be NULL).
    pub fn entry_anchor_offset(&self) -> Nullable<Offset16> {
        self.entry_anchor_offset.get()
    }

    /// Offset to entryAnchor table, from beginning of CursivePos
    /// subtable (may be NULL).
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn entry_anchor<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<AnchorTable<'a>, ReadError>> {
        self.entry_anchor_offset().resolve(data)
    }

    /// Offset to exitAnchor table, from beginning of CursivePos
    /// subtable (may be NULL).
    pub fn exit_anchor_offset(&self) -> Nullable<Offset16> {
        self.exit_anchor_offset.get()
    }

    /// Offset to exitAnchor table, from beginning of CursivePos
    /// subtable (may be NULL).
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn exit_anchor<'a>(
        &self,
        data: FontData<'a>,
    ) -> Option<Result<AnchorTable<'a>, ReadError>> {
        self.exit_anchor_offset().resolve(data)
    }
}

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

impl Format<u16> for MarkBasePosFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for MarkBasePosFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct MarkBasePosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub mark_coverage_offset: BigEndian<Offset16>,
    pub base_coverage_offset: BigEndian<Offset16>,
    pub mark_class_count: BigEndian<u16>,
    pub mark_array_offset: BigEndian<Offset16>,
    pub base_array_offset: BigEndian<Offset16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<MarkBasePosFormat1FixedHeader>() <= MarkBasePosFormat1::MIN_SIZE);

/// [Mark-to-Base Attachment Positioning Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#mark-to-base-attachment-positioning-format-1-mark-to-base-attachment-point): Mark-to-base Attachment Point
#[derive(Clone)]
pub struct MarkBasePosFormat1<'a> {
    data: TableDataRef<'a, MarkBasePosFormat1FixedHeader>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to markCoverage table, from beginning of MarkBasePos
    /// subtable.
    pub fn mark_coverage_offset(&self) -> Offset16 {
        self.data.header().mark_coverage_offset.get()
    }

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

    /// Offset to baseCoverage table, from beginning of MarkBasePos
    /// subtable.
    pub fn base_coverage_offset(&self) -> Offset16 {
        self.data.header().base_coverage_offset.get()
    }

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

    /// Number of classes defined for marks
    pub fn mark_class_count(&self) -> u16 {
        self.data.header().mark_class_count.get()
    }

    /// Offset to MarkArray table, from beginning of MarkBasePos
    /// subtable.
    pub fn mark_array_offset(&self) -> Offset16 {
        self.data.header().mark_array_offset.get()
    }

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

    /// Offset to BaseArray table, from beginning of MarkBasePos
    /// subtable.
    pub fn base_array_offset(&self) -> Offset16 {
        self.data.header().base_array_offset.get()
    }

    /// Attempt to resolve [`base_array_offset`][Self::base_array_offset].
    pub fn base_array(&self) -> Result<BaseArray<'a>, ReadError> {
        let data = self.offset_data();
        let args = self.mark_class_count();
        self.base_array_offset().resolve_with_args(data, args)
    }

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

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

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

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

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

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

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

impl Default for MarkBasePosFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

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

impl ReadArgs for BaseArray<'_> {
    type Args = u16;
}

impl<'a> FontRead<'a> for BaseArray<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mark_class_count = args;

        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self {
            data,
            mark_class_count,
        })
    }
}

impl<'a> BaseArray<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct BaseArrayFixedHeader {
    pub base_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<BaseArrayFixedHeader>() <= BaseArray::MIN_SIZE);

/// Part of [MarkBasePosFormat1]
#[derive(Clone)]
pub struct BaseArray<'a> {
    data: TableDataRef<'a, BaseArrayFixedHeader>,
    mark_class_count: u16,
}

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

    /// Number of BaseRecords
    pub fn base_count(&self) -> u16 {
        self.data.header().base_count.get()
    }

    /// Array of BaseRecords, in order of baseCoverage Index.
    pub fn base_records(&self) -> ComputedArray<'a, BaseRecord<'a>> {
        let range = self.base_records_byte_range();
        ComputedArray::new(self.offset_data(), range, self.mark_class_count()).unwrap_or_default()
    }

    pub(crate) fn mark_class_count(&self) -> u16 {
        self.mark_class_count
    }

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

    pub fn base_records_byte_range(&self) -> Range<usize> {
        let base_count = self.base_count();
        let start = self.base_count_byte_range().end;
        let end = start
            + (transforms::to_usize(base_count)).saturating_mul(
                <BaseRecord as ComputeSize>::compute_size(self.mark_class_count()).unwrap_or(0),
            );
        start..end
    }
}

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

impl Default for BaseArray<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
            mark_class_count: Default::default(),
        }
    }
}

/// Part of [BaseArray]
#[derive(Clone, Debug)]
pub struct BaseRecord<'a> {
    /// Array of offsets (one per mark class) to Anchor tables. Offsets
    /// are from beginning of BaseArray table, ordered by class
    /// (offsets may be NULL).
    pub base_anchor_offsets: &'a [BigEndian<Nullable<Offset16>>],
}

impl<'a> BaseRecord<'a> {
    /// Array of offsets (one per mark class) to Anchor tables. Offsets
    /// are from beginning of BaseArray table, ordered by class
    /// (offsets may be NULL).
    pub fn base_anchor_offsets(&self) -> &'a [BigEndian<Nullable<Offset16>>] {
        self.base_anchor_offsets
    }

    /// Array of offsets (one per mark class) to Anchor tables. Offsets
    /// are from beginning of BaseArray table, ordered by class
    /// (offsets may be NULL).
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn base_anchors(
        &self,
        data: FontData<'a>,
    ) -> ArrayOfNullableOffsets<'a, AnchorTable<'a>, Offset16> {
        let offsets = self.base_anchor_offsets();
        ArrayOfNullableOffsets::new(offsets, data, ())
    }
}

impl ReadArgs for BaseRecord<'_> {
    type Args = u16;
}

impl ComputeSize for BaseRecord<'_> {
    #[allow(clippy::needless_question_mark)]
    fn compute_size(args: u16) -> Result<usize, ReadError> {
        let mark_class_count = args;
        Ok((transforms::to_usize(mark_class_count)).saturating_mul(Offset16::RAW_BYTE_LEN))
    }
}

impl<'a> FontRead<'a> for BaseRecord<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        let mark_class_count = args;
        Ok(Self {
            base_anchor_offsets: cursor.read_array(transforms::to_usize(mark_class_count))?,
        })
    }
}

crate::impl_font_read_at!(BaseRecord<'a>);

#[allow(clippy::needless_lifetimes)]
impl<'a> BaseRecord<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

impl Format<u16> for MarkLigPosFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for MarkLigPosFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct MarkLigPosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub mark_coverage_offset: BigEndian<Offset16>,
    pub ligature_coverage_offset: BigEndian<Offset16>,
    pub mark_class_count: BigEndian<u16>,
    pub mark_array_offset: BigEndian<Offset16>,
    pub ligature_array_offset: BigEndian<Offset16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<MarkLigPosFormat1FixedHeader>() <= MarkLigPosFormat1::MIN_SIZE);

/// [Mark-to-Ligature Positioning Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#mark-to-ligature-attachment-positioning-format-1-mark-to-ligature-attachment): Mark-to-Ligature Attachment
#[derive(Clone)]
pub struct MarkLigPosFormat1<'a> {
    data: TableDataRef<'a, MarkLigPosFormat1FixedHeader>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to markCoverage table, from beginning of MarkLigPos
    /// subtable.
    pub fn mark_coverage_offset(&self) -> Offset16 {
        self.data.header().mark_coverage_offset.get()
    }

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

    /// Offset to ligatureCoverage table, from beginning of MarkLigPos
    /// subtable.
    pub fn ligature_coverage_offset(&self) -> Offset16 {
        self.data.header().ligature_coverage_offset.get()
    }

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

    /// Number of defined mark classes
    pub fn mark_class_count(&self) -> u16 {
        self.data.header().mark_class_count.get()
    }

    /// Offset to MarkArray table, from beginning of MarkLigPos
    /// subtable.
    pub fn mark_array_offset(&self) -> Offset16 {
        self.data.header().mark_array_offset.get()
    }

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

    /// Offset to LigatureArray table, from beginning of MarkLigPos
    /// subtable.
    pub fn ligature_array_offset(&self) -> Offset16 {
        self.data.header().ligature_array_offset.get()
    }

    /// Attempt to resolve [`ligature_array_offset`][Self::ligature_array_offset].
    pub fn ligature_array(&self) -> Result<LigatureArray<'a>, ReadError> {
        let data = self.offset_data();
        let args = self.mark_class_count();
        self.ligature_array_offset().resolve_with_args(data, args)
    }

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

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

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

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

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

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

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

impl Default for MarkLigPosFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

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

impl ReadArgs for LigatureArray<'_> {
    type Args = u16;
}

impl<'a> FontRead<'a> for LigatureArray<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mark_class_count = args;

        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self {
            data,
            mark_class_count,
        })
    }
}

impl<'a> LigatureArray<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct LigatureArrayFixedHeader {
    pub ligature_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<LigatureArrayFixedHeader>() <= LigatureArray::MIN_SIZE);

/// Part of [MarkLigPosFormat1]
#[derive(Clone)]
pub struct LigatureArray<'a> {
    data: TableDataRef<'a, LigatureArrayFixedHeader>,
    mark_class_count: u16,
}

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

    /// Number of LigatureAttach table offsets
    pub fn ligature_count(&self) -> u16 {
        self.data.header().ligature_count.get()
    }

    /// Array of offsets to LigatureAttach tables. Offsets are from
    /// beginning of LigatureArray table, ordered by ligatureCoverage
    /// index.
    pub fn ligature_attach_offsets(&self) -> &'a [BigEndian<Offset16>] {
        let range = self.ligature_attach_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`ligature_attach_offsets`][Self::ligature_attach_offsets].
    pub fn ligature_attaches(&self) -> ArrayOfOffsets<'a, LigatureAttach<'a>, Offset16> {
        let data = self.offset_data();
        let offsets = self.ligature_attach_offsets();
        let args = self.mark_class_count();
        ArrayOfOffsets::new(offsets, data, args)
    }

    pub(crate) fn mark_class_count(&self) -> u16 {
        self.mark_class_count
    }

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

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

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

impl Default for LigatureArray<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
            mark_class_count: Default::default(),
        }
    }
}

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

impl ReadArgs for LigatureAttach<'_> {
    type Args = u16;
}

impl<'a> FontRead<'a> for LigatureAttach<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mark_class_count = args;

        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self {
            data,
            mark_class_count,
        })
    }
}

impl<'a> LigatureAttach<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct LigatureAttachFixedHeader {
    pub component_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<LigatureAttachFixedHeader>() <= LigatureAttach::MIN_SIZE);

/// Part of [MarkLigPosFormat1]
#[derive(Clone)]
pub struct LigatureAttach<'a> {
    data: TableDataRef<'a, LigatureAttachFixedHeader>,
    mark_class_count: u16,
}

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

    /// Number of ComponentRecords in this ligature
    pub fn component_count(&self) -> u16 {
        self.data.header().component_count.get()
    }

    /// Array of Component records, ordered in writing direction.
    pub fn component_records(&self) -> ComputedArray<'a, ComponentRecord<'a>> {
        let range = self.component_records_byte_range();
        ComputedArray::new(self.offset_data(), range, self.mark_class_count()).unwrap_or_default()
    }

    pub(crate) fn mark_class_count(&self) -> u16 {
        self.mark_class_count
    }

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

    pub fn component_records_byte_range(&self) -> Range<usize> {
        let component_count = self.component_count();
        let start = self.component_count_byte_range().end;
        let end = start
            + (transforms::to_usize(component_count)).saturating_mul(
                <ComponentRecord as ComputeSize>::compute_size(self.mark_class_count())
                    .unwrap_or(0),
            );
        start..end
    }
}

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

impl Default for LigatureAttach<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
            mark_class_count: Default::default(),
        }
    }
}

/// Part of [MarkLigPosFormat1]
#[derive(Clone, Debug)]
pub struct ComponentRecord<'a> {
    /// Array of offsets (one per class) to Anchor tables. Offsets are
    /// from beginning of LigatureAttach table, ordered by class
    /// (offsets may be NULL).
    pub ligature_anchor_offsets: &'a [BigEndian<Nullable<Offset16>>],
}

impl<'a> ComponentRecord<'a> {
    /// Array of offsets (one per class) to Anchor tables. Offsets are
    /// from beginning of LigatureAttach table, ordered by class
    /// (offsets may be NULL).
    pub fn ligature_anchor_offsets(&self) -> &'a [BigEndian<Nullable<Offset16>>] {
        self.ligature_anchor_offsets
    }

    /// Array of offsets (one per class) to Anchor tables. Offsets are
    /// from beginning of LigatureAttach table, ordered by class
    /// (offsets may be NULL).
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn ligature_anchors(
        &self,
        data: FontData<'a>,
    ) -> ArrayOfNullableOffsets<'a, AnchorTable<'a>, Offset16> {
        let offsets = self.ligature_anchor_offsets();
        ArrayOfNullableOffsets::new(offsets, data, ())
    }
}

impl ReadArgs for ComponentRecord<'_> {
    type Args = u16;
}

impl ComputeSize for ComponentRecord<'_> {
    #[allow(clippy::needless_question_mark)]
    fn compute_size(args: u16) -> Result<usize, ReadError> {
        let mark_class_count = args;
        Ok((transforms::to_usize(mark_class_count)).saturating_mul(Offset16::RAW_BYTE_LEN))
    }
}

impl<'a> FontRead<'a> for ComponentRecord<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        let mark_class_count = args;
        Ok(Self {
            ligature_anchor_offsets: cursor.read_array(transforms::to_usize(mark_class_count))?,
        })
    }
}

crate::impl_font_read_at!(ComponentRecord<'a>);

#[allow(clippy::needless_lifetimes)]
impl<'a> ComponentRecord<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

impl Format<u16> for MarkMarkPosFormat1<'_> {
    const FORMAT: u16 = 1;
}

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

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

impl<'a> FontRead<'a> for MarkMarkPosFormat1<'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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self { data })
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct MarkMarkPosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub mark1_coverage_offset: BigEndian<Offset16>,
    pub mark2_coverage_offset: BigEndian<Offset16>,
    pub mark_class_count: BigEndian<u16>,
    pub mark1_array_offset: BigEndian<Offset16>,
    pub mark2_array_offset: BigEndian<Offset16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () =
    assert!(std::mem::size_of::<MarkMarkPosFormat1FixedHeader>() <= MarkMarkPosFormat1::MIN_SIZE);

/// [Mark-to-Mark Attachment Positioning Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#mark-to-mark-attachment-positioning-format-1-mark-to-mark-attachment): Mark-to-Mark Attachment
#[derive(Clone)]
pub struct MarkMarkPosFormat1<'a> {
    data: TableDataRef<'a, MarkMarkPosFormat1FixedHeader>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Offset to Combining Mark Coverage table, from beginning of
    /// MarkMarkPos subtable.
    pub fn mark1_coverage_offset(&self) -> Offset16 {
        self.data.header().mark1_coverage_offset.get()
    }

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

    /// Offset to Base Mark Coverage table, from beginning of
    /// MarkMarkPos subtable.
    pub fn mark2_coverage_offset(&self) -> Offset16 {
        self.data.header().mark2_coverage_offset.get()
    }

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

    /// Number of Combining Mark classes defined
    pub fn mark_class_count(&self) -> u16 {
        self.data.header().mark_class_count.get()
    }

    /// Offset to MarkArray table for mark1, from beginning of
    /// MarkMarkPos subtable.
    pub fn mark1_array_offset(&self) -> Offset16 {
        self.data.header().mark1_array_offset.get()
    }

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

    /// Offset to Mark2Array table for mark2, from beginning of
    /// MarkMarkPos subtable.
    pub fn mark2_array_offset(&self) -> Offset16 {
        self.data.header().mark2_array_offset.get()
    }

    /// Attempt to resolve [`mark2_array_offset`][Self::mark2_array_offset].
    pub fn mark2_array(&self) -> Result<Mark2Array<'a>, ReadError> {
        let data = self.offset_data();
        let args = self.mark_class_count();
        self.mark2_array_offset().resolve_with_args(data, args)
    }

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

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

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

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

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

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

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

impl Default for MarkMarkPosFormat1<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
        }
    }
}

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

impl ReadArgs for Mark2Array<'_> {
    type Args = u16;
}

impl<'a> FontRead<'a> for Mark2Array<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mark_class_count = args;

        #[allow(clippy::absurd_extreme_comparisons)]
        if data.len() < Self::MIN_SIZE {
            return Err(ReadError::OutOfBounds);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self {
            data,
            mark_class_count,
        })
    }
}

impl<'a> Mark2Array<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct Mark2ArrayFixedHeader {
    pub mark2_count: BigEndian<u16>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(std::mem::size_of::<Mark2ArrayFixedHeader>() <= Mark2Array::MIN_SIZE);

/// Part of [MarkMarkPosFormat1]Class2Record
#[derive(Clone)]
pub struct Mark2Array<'a> {
    data: TableDataRef<'a, Mark2ArrayFixedHeader>,
    mark_class_count: u16,
}

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

    /// Number of Mark2 records
    pub fn mark2_count(&self) -> u16 {
        self.data.header().mark2_count.get()
    }

    /// Array of Mark2Records, in Coverage order.
    pub fn mark2_records(&self) -> ComputedArray<'a, Mark2Record<'a>> {
        let range = self.mark2_records_byte_range();
        ComputedArray::new(self.offset_data(), range, self.mark_class_count()).unwrap_or_default()
    }

    pub(crate) fn mark_class_count(&self) -> u16 {
        self.mark_class_count
    }

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

    pub fn mark2_records_byte_range(&self) -> Range<usize> {
        let mark2_count = self.mark2_count();
        let start = self.mark2_count_byte_range().end;
        let end = start
            + (transforms::to_usize(mark2_count)).saturating_mul(
                <Mark2Record as ComputeSize>::compute_size(self.mark_class_count()).unwrap_or(0),
            );
        start..end
    }
}

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

impl Default for Mark2Array<'_> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
            mark_class_count: Default::default(),
        }
    }
}

/// Part of [MarkMarkPosFormat1]
#[derive(Clone, Debug)]
pub struct Mark2Record<'a> {
    /// Array of offsets (one per class) to Anchor tables. Offsets are
    /// from beginning of Mark2Array table, in class order (offsets may
    /// be NULL).
    pub mark2_anchor_offsets: &'a [BigEndian<Nullable<Offset16>>],
}

impl<'a> Mark2Record<'a> {
    /// Array of offsets (one per class) to Anchor tables. Offsets are
    /// from beginning of Mark2Array table, in class order (offsets may
    /// be NULL).
    pub fn mark2_anchor_offsets(&self) -> &'a [BigEndian<Nullable<Offset16>>] {
        self.mark2_anchor_offsets
    }

    /// Array of offsets (one per class) to Anchor tables. Offsets are
    /// from beginning of Mark2Array table, in class order (offsets may
    /// be NULL).
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn mark2_anchors(
        &self,
        data: FontData<'a>,
    ) -> ArrayOfNullableOffsets<'a, AnchorTable<'a>, Offset16> {
        let offsets = self.mark2_anchor_offsets();
        ArrayOfNullableOffsets::new(offsets, data, ())
    }
}

impl ReadArgs for Mark2Record<'_> {
    type Args = u16;
}

impl ComputeSize for Mark2Record<'_> {
    #[allow(clippy::needless_question_mark)]
    fn compute_size(args: u16) -> Result<usize, ReadError> {
        let mark_class_count = args;
        Ok((transforms::to_usize(mark_class_count)).saturating_mul(Offset16::RAW_BYTE_LEN))
    }
}

impl<'a> FontRead<'a> for Mark2Record<'a> {
    fn read_with_args(data: FontData<'a>, args: u16) -> Result<Self, ReadError> {
        let mut cursor = data.cursor();
        let mark_class_count = args;
        Ok(Self {
            mark2_anchor_offsets: cursor.read_array(transforms::to_usize(mark_class_count))?,
        })
    }
}

crate::impl_font_read_at!(Mark2Record<'a>);

#[allow(clippy::needless_lifetimes)]
impl<'a> Mark2Record<'a> {
    /// A constructor that requires additional arguments.
    ///
    /// This type requires some external state in order to be
    /// parsed.
    pub fn read(data: FontData<'a>, mark_class_count: u16) -> Result<Self, ReadError> {
        let args = mark_class_count;
        Self::read_with_args(data, args)
    }
}

impl Format<u16> for ExtensionPosFormat1<'_> {
    const FORMAT: u16 = 1;
}

impl Discriminant for ExtensionPosFormat1<'_, ()> {
    fn read_discriminant(data: FontData<'_>) -> Result<u16, ReadError> {
        data.read_at(u16::RAW_BYTE_LEN)
    }
}

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

impl<T> ReadArgs for ExtensionPosFormat1<'_, T> {
    type Args = ();
}

impl<'a, T> FontRead<'a> for ExtensionPosFormat1<'a, T> {
    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);
        }
        let Some(data) = TableDataRef::new(data.as_bytes()) else {
            return Err(ReadError::OutOfBounds);
        };
        Ok(Self {
            data,
            offset_type: std::marker::PhantomData,
        })
    }
}

impl<'a, T> ExtensionPosFormat1<'a, T> {
    #[allow(dead_code)]
    /// Replace the specific generic type on this implementation with `()`
    pub(crate) fn of_unit_type(&self) -> ExtensionPosFormat1<'a, ()> {
        ExtensionPosFormat1 {
            data: self.data,
            offset_type: std::marker::PhantomData,
        }
    }
}

/// The fields at the start of the table, which are read directly.
#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
#[repr(C, packed)]
#[doc(hidden)]
pub struct ExtensionPosFormat1FixedHeader {
    pub pos_format: BigEndian<u16>,
    pub extension_lookup_type: BigEndian<u16>,
    pub extension_offset: BigEndian<Offset32>,
}

#[allow(clippy::absurd_extreme_comparisons)]
const _: () = assert!(
    std::mem::size_of::<ExtensionPosFormat1FixedHeader>() <= ExtensionPosFormat1::<()>::MIN_SIZE
);

/// [Extension Positioning Subtable Format 1](https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#extension-positioning-subtable-format-1)
#[derive(Clone)]
pub struct ExtensionPosFormat1<'a, T = ()> {
    data: TableDataRef<'a, ExtensionPosFormat1FixedHeader>,
    offset_type: std::marker::PhantomData<*const T>,
}

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

    /// Format identifier: format = 1
    pub fn pos_format(&self) -> u16 {
        self.data.header().pos_format.get()
    }

    /// Lookup type of subtable referenced by extensionOffset (i.e. the
    /// extension subtable).
    pub fn extension_lookup_type(&self) -> u16 {
        self.data.header().extension_lookup_type.get()
    }

    /// Offset to the extension subtable, of lookup type
    /// extensionLookupType, relative to the start of the
    /// ExtensionPosFormat1 subtable.
    pub fn extension_offset(&self) -> Offset32 {
        self.data.header().extension_offset.get()
    }

    /// Attempt to resolve [`extension_offset`][Self::extension_offset].
    pub fn extension(&self) -> Result<T, ReadError>
    where
        T: FontRead<'a, Args = ()>,
    {
        let data = self.offset_data();
        self.extension_offset().resolve(data)
    }

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

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

    pub fn extension_offset_byte_range(&self) -> Range<usize> {
        let start = self.extension_lookup_type_byte_range().end;
        let end = start + Offset32::RAW_BYTE_LEN;
        start..end
    }
}

const _: () = assert!(FontData::default_data_long_enough(
    ExtensionPosFormat1::<()>::MIN_SIZE
));

impl<T> Default for ExtensionPosFormat1<'_, T> {
    fn default() -> Self {
        Self {
            data: TableDataRef::new(FontData::default_format_1_u16_table_data().as_bytes())
                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
            offset_type: std::marker::PhantomData,
        }
    }
}

/// A [GPOS Extension Positioning](https://learn.microsoft.com/en-us/typography/opentype/spec/gpos#lookuptype-9-extension-positioning) subtable
pub enum ExtensionSubtable<'a> {
    Single(ExtensionPosFormat1<'a, SinglePos<'a>>),
    Pair(ExtensionPosFormat1<'a, PairPos<'a>>),
    Cursive(ExtensionPosFormat1<'a, CursivePosFormat1<'a>>),
    MarkToBase(ExtensionPosFormat1<'a, MarkBasePosFormat1<'a>>),
    MarkToLig(ExtensionPosFormat1<'a, MarkLigPosFormat1<'a>>),
    MarkToMark(ExtensionPosFormat1<'a, MarkMarkPosFormat1<'a>>),
    Contextual(ExtensionPosFormat1<'a, PositionSequenceContext<'a>>),
    ChainContextual(ExtensionPosFormat1<'a, PositionChainContext<'a>>),
}

impl Default for ExtensionSubtable<'_> {
    fn default() -> Self {
        Self::Single(Default::default())
    }
}

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

impl<'a> FontRead<'a> for ExtensionSubtable<'a> {
    fn read_with_args(bytes: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let discriminant = ExtensionPosFormat1::read_discriminant(bytes)?;
        match discriminant {
            1 => Ok(ExtensionSubtable::Single(FontRead::read(bytes)?)),
            2 => Ok(ExtensionSubtable::Pair(FontRead::read(bytes)?)),
            3 => Ok(ExtensionSubtable::Cursive(FontRead::read(bytes)?)),
            4 => Ok(ExtensionSubtable::MarkToBase(FontRead::read(bytes)?)),
            5 => Ok(ExtensionSubtable::MarkToLig(FontRead::read(bytes)?)),
            6 => Ok(ExtensionSubtable::MarkToMark(FontRead::read(bytes)?)),
            7 => Ok(ExtensionSubtable::Contextual(FontRead::read(bytes)?)),
            8 => Ok(ExtensionSubtable::ChainContextual(FontRead::read(bytes)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> ExtensionSubtable<'a> {
    #[allow(dead_code)]
    /// Return the inner table, removing the specific generics.
    ///
    /// This lets us return a single concrete type we can call methods on.
    pub(crate) fn of_unit_type(&self) -> ExtensionPosFormat1<'a, ()> {
        match self {
            ExtensionSubtable::Single(inner) => inner.of_unit_type(),
            ExtensionSubtable::Pair(inner) => inner.of_unit_type(),
            ExtensionSubtable::Cursive(inner) => inner.of_unit_type(),
            ExtensionSubtable::MarkToBase(inner) => inner.of_unit_type(),
            ExtensionSubtable::MarkToLig(inner) => inner.of_unit_type(),
            ExtensionSubtable::MarkToMark(inner) => inner.of_unit_type(),
            ExtensionSubtable::Contextual(inner) => inner.of_unit_type(),
            ExtensionSubtable::ChainContextual(inner) => inner.of_unit_type(),
        }
    }
}