/src/fontations/read-fonts/generated/generated_colr.rs

Source
// 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 Colr<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.num_layer_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 TopLevelTable for Colr<'_> {
    /// `COLR`
    const TAG: Tag = Tag::new(b"COLR");
}

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

impl<'a> FontRead<'a> for Colr<'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 ColrFixedHeader {
    pub version: BigEndian<u16>,
    pub num_base_glyph_records: BigEndian<u16>,
    pub base_glyph_records_offset: BigEndian<Nullable<Offset32>>,
    pub layer_records_offset: BigEndian<Nullable<Offset32>>,
    pub num_layer_records: BigEndian<u16>,
}

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

/// [COLR (Color)](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#colr-header) table
#[derive(Clone)]
pub struct Colr<'a> {
    data: TableDataRef<'a, ColrFixedHeader>,
}

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

    /// Table version number - set to 0 or 1.
    pub fn version(&self) -> u16 {
        self.data.header().version.get()
    }

    /// Number of BaseGlyph records; may be 0 in a version 1 table.
    pub fn num_base_glyph_records(&self) -> u16 {
        self.data.header().num_base_glyph_records.get()
    }

    /// Offset to baseGlyphRecords array (may be NULL).
    pub fn base_glyph_records_offset(&self) -> Nullable<Offset32> {
        self.data.header().base_glyph_records_offset.get()
    }

    /// Attempt to resolve [`base_glyph_records_offset`][Self::base_glyph_records_offset].
    pub fn base_glyph_records(&self) -> Option<Result<&'a [BaseGlyph], ReadError>> {
        let data = self.offset_data();
        let args = self.num_base_glyph_records();
        self.base_glyph_records_offset()
            .resolve_with_args(data, args)
    }

    /// Offset to layerRecords array (may be NULL).
    pub fn layer_records_offset(&self) -> Nullable<Offset32> {
        self.data.header().layer_records_offset.get()
    }

    /// Attempt to resolve [`layer_records_offset`][Self::layer_records_offset].
    pub fn layer_records(&self) -> Option<Result<&'a [Layer], ReadError>> {
        let data = self.offset_data();
        let args = self.num_layer_records();
        self.layer_records_offset().resolve_with_args(data, args)
    }

    /// Number of Layer records; may be 0 in a version 1 table.
    pub fn num_layer_records(&self) -> u16 {
        self.data.header().num_layer_records.get()
    }

    /// Offset to BaseGlyphList table.
    pub fn base_glyph_list_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.base_glyph_list_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

    /// Offset to LayerList table (may be NULL).
    pub fn layer_list_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.layer_list_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

    /// Offset to ClipList table (may be NULL).
    pub fn clip_list_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.clip_list_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

    /// Offset to DeltaSetIndexMap table (may be NULL).
    pub fn var_index_map_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.var_index_map_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

    /// Offset to ItemVariationStore (may be NULL).
    pub fn item_variation_store_offset(&self) -> Option<Nullable<Offset32>> {
        let range = self.item_variation_store_offset_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

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

    pub fn num_base_glyph_records_byte_range(&self) -> Range<usize> {
        let start = self.version_byte_range().end;
        let end = start.saturating_add(u16::RAW_BYTE_LEN);
        start..end
    }

    pub fn base_glyph_records_offset_byte_range(&self) -> Range<usize> {
        let start = self.num_base_glyph_records_byte_range().end;
        let end = start.saturating_add(Offset32::RAW_BYTE_LEN);
        start..end
    }

    pub fn layer_records_offset_byte_range(&self) -> Range<usize> {
        let start = self.base_glyph_records_offset_byte_range().end;
        let end = start.saturating_add(Offset32::RAW_BYTE_LEN);
        start..end
    }

    pub fn num_layer_records_byte_range(&self) -> Range<usize> {
        let start = self.layer_records_offset_byte_range().end;
        let end = start.saturating_add(u16::RAW_BYTE_LEN);
        start..end
    }

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

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

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

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

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

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

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

/// [BaseGlyph](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyph-and-layer-records) record
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct BaseGlyph {
    /// Glyph ID of the base glyph.
    pub glyph_id: BigEndian<GlyphId16>,
    /// Index (base 0) into the layerRecords array.
    pub first_layer_index: BigEndian<u16>,
    /// Number of color layers associated with this glyph.
    pub num_layers: BigEndian<u16>,
}

impl BaseGlyph {
    /// Glyph ID of the base glyph.
    pub fn glyph_id(&self) -> GlyphId16 {
        self.glyph_id.get()
    }

    /// Index (base 0) into the layerRecords array.
    pub fn first_layer_index(&self) -> u16 {
        self.first_layer_index.get()
    }

    /// Number of color layers associated with this glyph.
    pub fn num_layers(&self) -> u16 {
        self.num_layers.get()
    }
}

impl FixedSize for BaseGlyph {
    const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
}

/// [Layer](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyph-and-layer-records) record
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct Layer {
    /// Glyph ID of the glyph used for a given layer.
    pub glyph_id: BigEndian<GlyphId16>,
    /// Index (base 0) for a palette entry in the CPAL table.
    pub palette_index: BigEndian<u16>,
}

impl Layer {
    /// Glyph ID of the glyph used for a given layer.
    pub fn glyph_id(&self) -> GlyphId16 {
        self.glyph_id.get()
    }

    /// Index (base 0) for a palette entry in the CPAL table.
    pub fn palette_index(&self) -> u16 {
        self.palette_index.get()
    }
}

impl FixedSize for Layer {
    const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for BaseGlyphList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.base_glyph_paint_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 BaseGlyphList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for BaseGlyphList<'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 BaseGlyphListFixedHeader {
    pub num_base_glyph_paint_records: BigEndian<u32>,
}

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

/// [BaseGlyphList](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) table
#[derive(Clone)]
pub struct BaseGlyphList<'a> {
    data: TableDataRef<'a, BaseGlyphListFixedHeader>,
}

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

    pub fn num_base_glyph_paint_records(&self) -> u32 {
        self.data.header().num_base_glyph_paint_records.get()
    }

    pub fn base_glyph_paint_records(&self) -> &'a [BaseGlyphPaint] {
        let range = self.base_glyph_paint_records_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    pub fn num_base_glyph_paint_records_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }

    pub fn base_glyph_paint_records_byte_range(&self) -> Range<usize> {
        let num_base_glyph_paint_records = self.num_base_glyph_paint_records();
        let start = self.num_base_glyph_paint_records_byte_range().end;
        let end = start.saturating_add(
            (transforms::to_usize(num_base_glyph_paint_records))
                .saturating_mul(BaseGlyphPaint::RAW_BYTE_LEN),
        );
        start..end
    }
}

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

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

/// [BaseGlyphPaint](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) record
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct BaseGlyphPaint {
    /// Glyph ID of the base glyph.
    pub glyph_id: BigEndian<GlyphId16>,
    /// Offset to a Paint table, from the beginning of the [`BaseGlyphList`] table.
    pub paint_offset: BigEndian<Offset32>,
}

impl BaseGlyphPaint {
    /// Glyph ID of the base glyph.
    pub fn glyph_id(&self) -> GlyphId16 {
        self.glyph_id.get()
    }

    /// Offset to a Paint table, from the beginning of the [`BaseGlyphList`] table.
    pub fn paint_offset(&self) -> Offset32 {
        self.paint_offset.get()
    }

    /// Offset to a Paint table, from the beginning of the [`BaseGlyphList`] table.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn paint<'a>(&self, data: FontData<'a>) -> Result<Paint<'a>, ReadError> {
        self.paint_offset().resolve(data)
    }
}

impl FixedSize for BaseGlyphPaint {
    const RAW_BYTE_LEN: usize = GlyphId16::RAW_BYTE_LEN + Offset32::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for LayerList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.paint_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 LayerList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for LayerList<'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 LayerListFixedHeader {
    pub num_layers: BigEndian<u32>,
}

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

/// [LayerList](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) table
#[derive(Clone)]
pub struct LayerList<'a> {
    data: TableDataRef<'a, LayerListFixedHeader>,
}

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

    pub fn num_layers(&self) -> u32 {
        self.data.header().num_layers.get()
    }

    /// Offsets to Paint tables.
    pub fn paint_offsets(&self) -> &'a [BigEndian<Offset32>] {
        let range = self.paint_offsets_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    /// A dynamically resolving wrapper for [`paint_offsets`][Self::paint_offsets].
    pub fn paints(&self) -> ArrayOfOffsets<'a, Paint<'a>, Offset32> {
        let data = self.offset_data();
        let offsets = self.paint_offsets();
        ArrayOfOffsets::new(offsets, data, ())
    }

    pub fn num_layers_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offsets_byte_range(&self) -> Range<usize> {
        let num_layers = self.num_layers();
        let start = self.num_layers_byte_range().end;
        let end = start.saturating_add(
            (transforms::to_usize(num_layers)).saturating_mul(Offset32::RAW_BYTE_LEN),
        );
        start..end
    }
}

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

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

impl<'a> MinByteRange<'a> for ClipList<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.clips_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 ClipList<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for ClipList<'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 ClipListFixedHeader {
    pub format: u8,
    pub num_clips: BigEndian<u32>,
}

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

/// [ClipList](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) table
#[derive(Clone)]
pub struct ClipList<'a> {
    data: TableDataRef<'a, ClipListFixedHeader>,
}

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

    /// Set to 1.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Number of Clip records.
    pub fn num_clips(&self) -> u32 {
        self.data.header().num_clips.get()
    }

    /// Clip records. Sorted by startGlyphID.
    pub fn clips(&self) -> &'a [Clip] {
        let range = self.clips_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn num_clips_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }

    pub fn clips_byte_range(&self) -> Range<usize> {
        let num_clips = self.num_clips();
        let start = self.num_clips_byte_range().end;
        let end = start
            .saturating_add((transforms::to_usize(num_clips)).saturating_mul(Clip::RAW_BYTE_LEN));
        start..end
    }
}

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

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

/// [Clip](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) record
#[derive(Clone, Debug, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct Clip {
    /// First glyph ID in the range.
    pub start_glyph_id: BigEndian<GlyphId16>,
    /// Last glyph ID in the range.
    pub end_glyph_id: BigEndian<GlyphId16>,
    /// Offset to a ClipBox table, from the beginning of the [`ClipList`] table.
    pub clip_box_offset: BigEndian<Offset24>,
}

impl Clip {
    /// First glyph ID in the range.
    pub fn start_glyph_id(&self) -> GlyphId16 {
        self.start_glyph_id.get()
    }

    /// Last glyph ID in the range.
    pub fn end_glyph_id(&self) -> GlyphId16 {
        self.end_glyph_id.get()
    }

    /// Offset to a ClipBox table, from the beginning of the [`ClipList`] table.
    pub fn clip_box_offset(&self) -> Offset24 {
        self.clip_box_offset.get()
    }

    /// Offset to a ClipBox table, from the beginning of the [`ClipList`] table.
    ///
    /// The `data` argument should be retrieved from the parent table
    /// By calling its `offset_data` method.
    pub fn clip_box<'a>(&self, data: FontData<'a>) -> Result<ClipBox<'a>, ReadError> {
        self.clip_box_offset().resolve(data)
    }
}

impl FixedSize for Clip {
    const RAW_BYTE_LEN: usize =
        GlyphId16::RAW_BYTE_LEN + GlyphId16::RAW_BYTE_LEN + Offset24::RAW_BYTE_LEN;
}

/// [ClipBox](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) table
#[derive(Clone)]
pub enum ClipBox<'a> {
    Format1(ClipBoxFormat1<'a>),
    Format2(ClipBoxFormat2<'a>),
}

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

impl<'a> ClipBox<'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(),
        }
    }

    /// Set to 1.
    pub fn format(&self) -> u8 {
        match self {
            Self::Format1(item) => item.format(),
            Self::Format2(item) => item.format(),
        }
    }

    /// Minimum x of clip box.
    pub fn x_min(&self) -> FWord {
        match self {
            Self::Format1(item) => item.x_min(),
            Self::Format2(item) => item.x_min(),
        }
    }

    /// Minimum y of clip box.
    pub fn y_min(&self) -> FWord {
        match self {
            Self::Format1(item) => item.y_min(),
            Self::Format2(item) => item.y_min(),
        }
    }

    /// Maximum x of clip box.
    pub fn x_max(&self) -> FWord {
        match self {
            Self::Format1(item) => item.x_max(),
            Self::Format2(item) => item.x_max(),
        }
    }

    /// Maximum y of clip box.
    pub fn y_max(&self) -> FWord {
        match self {
            Self::Format1(item) => item.y_max(),
            Self::Format2(item) => item.y_max(),
        }
    }
}

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

impl<'a> FontRead<'a> for ClipBox<'a> {
    #[inline]
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let format: u8 = data.read_at(0usize)?;
        match format {
            ClipBoxFormat1::FORMAT => Ok(Self::Format1(FontRead::read(data)?)),
            ClipBoxFormat2::FORMAT => Ok(Self::Format2(FontRead::read(data)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> MinByteRange<'a> for ClipBox<'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<u8> for ClipBoxFormat1<'_> {
    const FORMAT: u8 = 1;
}

impl<'a> MinByteRange<'a> for ClipBoxFormat1<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.y_max_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 ClipBoxFormat1<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for ClipBoxFormat1<'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 ClipBoxFormat1FixedHeader {
    pub format: u8,
    pub x_min: BigEndian<FWord>,
    pub y_min: BigEndian<FWord>,
    pub x_max: BigEndian<FWord>,
    pub y_max: BigEndian<FWord>,
}

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

/// [ClipBoxFormat1](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) record
#[derive(Clone)]
pub struct ClipBoxFormat1<'a> {
    data: TableDataRef<'a, ClipBoxFormat1FixedHeader>,
}

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

    /// Set to 1.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Minimum x of clip box.
    pub fn x_min(&self) -> FWord {
        self.data.header().x_min.get()
    }

    /// Minimum y of clip box.
    pub fn y_min(&self) -> FWord {
        self.data.header().y_min.get()
    }

    /// Maximum x of clip box.
    pub fn x_max(&self) -> FWord {
        self.data.header().x_max.get()
    }

    /// Maximum y of clip box.
    pub fn y_max(&self) -> FWord {
        self.data.header().y_max.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_min_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_min_byte_range(&self) -> Range<usize> {
        let start = self.x_min_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_max_byte_range(&self) -> Range<usize> {
        let start = self.y_min_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_max_byte_range(&self) -> Range<usize> {
        let start = self.x_max_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

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

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

impl Format<u8> for ClipBoxFormat2<'_> {
    const FORMAT: u8 = 2;
}

impl<'a> MinByteRange<'a> for ClipBoxFormat2<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 ClipBoxFormat2<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for ClipBoxFormat2<'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 ClipBoxFormat2FixedHeader {
    pub format: u8,
    pub x_min: BigEndian<FWord>,
    pub y_min: BigEndian<FWord>,
    pub x_max: BigEndian<FWord>,
    pub y_max: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [ClipBoxFormat2](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist) record
#[derive(Clone)]
pub struct ClipBoxFormat2<'a> {
    data: TableDataRef<'a, ClipBoxFormat2FixedHeader>,
}

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

    /// Set to 2.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Minimum x of clip box. For variation, use varIndexBase + 0.
    pub fn x_min(&self) -> FWord {
        self.data.header().x_min.get()
    }

    /// Minimum y of clip box. For variation, use varIndexBase + 1.
    pub fn y_min(&self) -> FWord {
        self.data.header().y_min.get()
    }

    /// Maximum x of clip box. For variation, use varIndexBase + 2.
    pub fn x_max(&self) -> FWord {
        self.data.header().x_max.get()
    }

    /// Maximum y of clip box. For variation, use varIndexBase + 3.
    pub fn y_max(&self) -> FWord {
        self.data.header().y_max.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_min_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_min_byte_range(&self) -> Range<usize> {
        let start = self.x_min_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_max_byte_range(&self) -> Range<usize> {
        let start = self.y_min_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_max_byte_range(&self) -> Range<usize> {
        let start = self.x_max_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.y_max_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

/// [ColorIndex](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) record
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct ColorIndex {
    /// Index for a CPAL palette entry.
    pub palette_index: BigEndian<u16>,
    /// Alpha value.
    pub alpha: BigEndian<F2Dot14>,
}

impl ColorIndex {
    /// Index for a CPAL palette entry.
    pub fn palette_index(&self) -> u16 {
        self.palette_index.get()
    }

    /// Alpha value.
    pub fn alpha(&self) -> F2Dot14 {
        self.alpha.get()
    }
}

impl FixedSize for ColorIndex {
    const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + F2Dot14::RAW_BYTE_LEN;
}

/// [VarColorIndex](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) record
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct VarColorIndex {
    /// Index for a CPAL palette entry.
    pub palette_index: BigEndian<u16>,
    /// Alpha value. For variation, use varIndexBase + 0.
    pub alpha: BigEndian<F2Dot14>,
    /// Base index into DeltaSetIndexMap.
    pub var_index_base: BigEndian<u32>,
}

impl VarColorIndex {
    /// Index for a CPAL palette entry.
    pub fn palette_index(&self) -> u16 {
        self.palette_index.get()
    }

    /// Alpha value. For variation, use varIndexBase + 0.
    pub fn alpha(&self) -> F2Dot14 {
        self.alpha.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.var_index_base.get()
    }
}

impl FixedSize for VarColorIndex {
    const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + F2Dot14::RAW_BYTE_LEN + u32::RAW_BYTE_LEN;
}

/// [ColorStop](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) record
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct ColorStop {
    /// Position on a color line.
    pub stop_offset: BigEndian<F2Dot14>,
    /// Index for a CPAL palette entry.
    pub palette_index: BigEndian<u16>,
    /// Alpha value.
    pub alpha: BigEndian<F2Dot14>,
}

impl ColorStop {
    /// Position on a color line.
    pub fn stop_offset(&self) -> F2Dot14 {
        self.stop_offset.get()
    }

    /// Index for a CPAL palette entry.
    pub fn palette_index(&self) -> u16 {
        self.palette_index.get()
    }

    /// Alpha value.
    pub fn alpha(&self) -> F2Dot14 {
        self.alpha.get()
    }
}

impl FixedSize for ColorStop {
    const RAW_BYTE_LEN: usize = F2Dot14::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + F2Dot14::RAW_BYTE_LEN;
}

/// [VarColorStop](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) record
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
#[repr(C)]
#[repr(packed)]
pub struct VarColorStop {
    /// Position on a color line. For variation, use varIndexBase + 0.
    pub stop_offset: BigEndian<F2Dot14>,
    /// Index for a CPAL palette entry.
    pub palette_index: BigEndian<u16>,
    /// Alpha value. For variation, use varIndexBase + 1.
    pub alpha: BigEndian<F2Dot14>,
    /// Base index into DeltaSetIndexMap.
    pub var_index_base: BigEndian<u32>,
}

impl VarColorStop {
    /// Position on a color line. For variation, use varIndexBase + 0.
    pub fn stop_offset(&self) -> F2Dot14 {
        self.stop_offset.get()
    }

    /// Index for a CPAL palette entry.
    pub fn palette_index(&self) -> u16 {
        self.palette_index.get()
    }

    /// Alpha value. For variation, use varIndexBase + 1.
    pub fn alpha(&self) -> F2Dot14 {
        self.alpha.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.var_index_base.get()
    }
}

impl FixedSize for VarColorStop {
    const RAW_BYTE_LEN: usize =
        F2Dot14::RAW_BYTE_LEN + u16::RAW_BYTE_LEN + F2Dot14::RAW_BYTE_LEN + u32::RAW_BYTE_LEN;
}

impl<'a> MinByteRange<'a> for ColorLine<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.color_stops_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 ColorLine<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for ColorLine<'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 ColorLineFixedHeader {
    pub extend: BigEndian<Extend>,
    pub num_stops: BigEndian<u16>,
}

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

/// [ColorLine](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) table
#[derive(Clone)]
pub struct ColorLine<'a> {
    data: TableDataRef<'a, ColorLineFixedHeader>,
}

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

    /// An Extend enum value.
    pub fn extend(&self) -> Extend {
        self.data.header().extend.get()
    }

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

    pub fn color_stops(&self) -> &'a [ColorStop] {
        let range = self.color_stops_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    pub fn extend_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(Extend::RAW_BYTE_LEN);
        start..end
    }

    pub fn num_stops_byte_range(&self) -> Range<usize> {
        let start = self.extend_byte_range().end;
        let end = start.saturating_add(u16::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_stops_byte_range(&self) -> Range<usize> {
        let num_stops = self.num_stops();
        let start = self.num_stops_byte_range().end;
        let end = start.saturating_add(
            (transforms::to_usize(num_stops)).saturating_mul(ColorStop::RAW_BYTE_LEN),
        );
        start..end
    }
}

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

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

impl<'a> MinByteRange<'a> for VarColorLine<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.color_stops_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 VarColorLine<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for VarColorLine<'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 VarColorLineFixedHeader {
    pub extend: BigEndian<Extend>,
    pub num_stops: BigEndian<u16>,
}

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

/// [VarColorLine](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) table
#[derive(Clone)]
pub struct VarColorLine<'a> {
    data: TableDataRef<'a, VarColorLineFixedHeader>,
}

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

    /// An Extend enum value.
    pub fn extend(&self) -> Extend {
        self.data.header().extend.get()
    }

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

    /// Allows for variations.
    pub fn color_stops(&self) -> &'a [VarColorStop] {
        let range = self.color_stops_byte_range();
        self.offset_data()
            .read_array(range)
            .ok()
            .unwrap_or_default()
    }

    pub fn extend_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(Extend::RAW_BYTE_LEN);
        start..end
    }

    pub fn num_stops_byte_range(&self) -> Range<usize> {
        let start = self.extend_byte_range().end;
        let end = start.saturating_add(u16::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_stops_byte_range(&self) -> Range<usize> {
        let num_stops = self.num_stops();
        let start = self.num_stops_byte_range().end;
        let end = start.saturating_add(
            (transforms::to_usize(num_stops)).saturating_mul(VarColorStop::RAW_BYTE_LEN),
        );
        start..end
    }
}

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

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

/// [Extend](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline) enumeration
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u8)]
#[allow(clippy::manual_non_exhaustive)]
pub enum Extend {
    #[default]
    Pad = 0,
    Repeat = 1,
    Reflect = 2,
    #[doc(hidden)]
    /// If font data is malformed we will map unknown values to this variant
    Unknown,
}

impl Extend {
    /// Create from a raw scalar.
    ///
    /// This will never fail; unknown values will be mapped to the `Unknown` variant
    pub fn new(raw: u8) -> Self {
        match raw {
            0 => Self::Pad,
            1 => Self::Repeat,
            2 => Self::Reflect,
            _ => Self::Unknown,
        }
    }
}

impl font_types::Scalar for Extend {
    type Raw = <u8 as font_types::Scalar>::Raw;
    fn to_raw(self) -> Self::Raw {
        (self as u8).to_raw()
    }
    fn from_raw(raw: Self::Raw) -> Self {
        let t = <u8>::from_raw(raw);
        Self::new(t)
    }
}

/// [Paint](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#paint-tables) tables
#[derive(Clone)]
pub enum Paint<'a> {
    ColrLayers(PaintColrLayers<'a>),
    Solid(PaintSolid<'a>),
    VarSolid(PaintVarSolid<'a>),
    LinearGradient(PaintLinearGradient<'a>),
    VarLinearGradient(PaintVarLinearGradient<'a>),
    RadialGradient(PaintRadialGradient<'a>),
    VarRadialGradient(PaintVarRadialGradient<'a>),
    SweepGradient(PaintSweepGradient<'a>),
    VarSweepGradient(PaintVarSweepGradient<'a>),
    Glyph(PaintGlyph<'a>),
    ColrGlyph(PaintColrGlyph<'a>),
    Transform(PaintTransform<'a>),
    VarTransform(PaintVarTransform<'a>),
    Translate(PaintTranslate<'a>),
    VarTranslate(PaintVarTranslate<'a>),
    Scale(PaintScale<'a>),
    VarScale(PaintVarScale<'a>),
    ScaleAroundCenter(PaintScaleAroundCenter<'a>),
    VarScaleAroundCenter(PaintVarScaleAroundCenter<'a>),
    ScaleUniform(PaintScaleUniform<'a>),
    VarScaleUniform(PaintVarScaleUniform<'a>),
    ScaleUniformAroundCenter(PaintScaleUniformAroundCenter<'a>),
    VarScaleUniformAroundCenter(PaintVarScaleUniformAroundCenter<'a>),
    Rotate(PaintRotate<'a>),
    VarRotate(PaintVarRotate<'a>),
    RotateAroundCenter(PaintRotateAroundCenter<'a>),
    VarRotateAroundCenter(PaintVarRotateAroundCenter<'a>),
    Skew(PaintSkew<'a>),
    VarSkew(PaintVarSkew<'a>),
    SkewAroundCenter(PaintSkewAroundCenter<'a>),
    VarSkewAroundCenter(PaintVarSkewAroundCenter<'a>),
    Composite(PaintComposite<'a>),
    Glyph2(PaintGlyph2<'a>),
}

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

impl<'a> Paint<'a> {
    ///Return the `FontData` used to resolve offsets for this table.
    pub fn offset_data(&self) -> FontData<'a> {
        match self {
            Self::ColrLayers(item) => item.offset_data(),
            Self::Solid(item) => item.offset_data(),
            Self::VarSolid(item) => item.offset_data(),
            Self::LinearGradient(item) => item.offset_data(),
            Self::VarLinearGradient(item) => item.offset_data(),
            Self::RadialGradient(item) => item.offset_data(),
            Self::VarRadialGradient(item) => item.offset_data(),
            Self::SweepGradient(item) => item.offset_data(),
            Self::VarSweepGradient(item) => item.offset_data(),
            Self::Glyph(item) => item.offset_data(),
            Self::ColrGlyph(item) => item.offset_data(),
            Self::Transform(item) => item.offset_data(),
            Self::VarTransform(item) => item.offset_data(),
            Self::Translate(item) => item.offset_data(),
            Self::VarTranslate(item) => item.offset_data(),
            Self::Scale(item) => item.offset_data(),
            Self::VarScale(item) => item.offset_data(),
            Self::ScaleAroundCenter(item) => item.offset_data(),
            Self::VarScaleAroundCenter(item) => item.offset_data(),
            Self::ScaleUniform(item) => item.offset_data(),
            Self::VarScaleUniform(item) => item.offset_data(),
            Self::ScaleUniformAroundCenter(item) => item.offset_data(),
            Self::VarScaleUniformAroundCenter(item) => item.offset_data(),
            Self::Rotate(item) => item.offset_data(),
            Self::VarRotate(item) => item.offset_data(),
            Self::RotateAroundCenter(item) => item.offset_data(),
            Self::VarRotateAroundCenter(item) => item.offset_data(),
            Self::Skew(item) => item.offset_data(),
            Self::VarSkew(item) => item.offset_data(),
            Self::SkewAroundCenter(item) => item.offset_data(),
            Self::VarSkewAroundCenter(item) => item.offset_data(),
            Self::Composite(item) => item.offset_data(),
            Self::Glyph2(item) => item.offset_data(),
        }
    }

    /// Set to 1.
    pub fn format(&self) -> u8 {
        match self {
            Self::ColrLayers(item) => item.format(),
            Self::Solid(item) => item.format(),
            Self::VarSolid(item) => item.format(),
            Self::LinearGradient(item) => item.format(),
            Self::VarLinearGradient(item) => item.format(),
            Self::RadialGradient(item) => item.format(),
            Self::VarRadialGradient(item) => item.format(),
            Self::SweepGradient(item) => item.format(),
            Self::VarSweepGradient(item) => item.format(),
            Self::Glyph(item) => item.format(),
            Self::ColrGlyph(item) => item.format(),
            Self::Transform(item) => item.format(),
            Self::VarTransform(item) => item.format(),
            Self::Translate(item) => item.format(),
            Self::VarTranslate(item) => item.format(),
            Self::Scale(item) => item.format(),
            Self::VarScale(item) => item.format(),
            Self::ScaleAroundCenter(item) => item.format(),
            Self::VarScaleAroundCenter(item) => item.format(),
            Self::ScaleUniform(item) => item.format(),
            Self::VarScaleUniform(item) => item.format(),
            Self::ScaleUniformAroundCenter(item) => item.format(),
            Self::VarScaleUniformAroundCenter(item) => item.format(),
            Self::Rotate(item) => item.format(),
            Self::VarRotate(item) => item.format(),
            Self::RotateAroundCenter(item) => item.format(),
            Self::VarRotateAroundCenter(item) => item.format(),
            Self::Skew(item) => item.format(),
            Self::VarSkew(item) => item.format(),
            Self::SkewAroundCenter(item) => item.format(),
            Self::VarSkewAroundCenter(item) => item.format(),
            Self::Composite(item) => item.format(),
            Self::Glyph2(item) => item.format(),
        }
    }
}

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

impl<'a> FontRead<'a> for Paint<'a> {
    #[inline]
    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
        let format: u8 = data.read_at(0usize)?;
        match format {
            PaintColrLayers::FORMAT => Ok(Self::ColrLayers(FontRead::read(data)?)),
            PaintSolid::FORMAT => Ok(Self::Solid(FontRead::read(data)?)),
            PaintVarSolid::FORMAT => Ok(Self::VarSolid(FontRead::read(data)?)),
            PaintLinearGradient::FORMAT => Ok(Self::LinearGradient(FontRead::read(data)?)),
            PaintVarLinearGradient::FORMAT => Ok(Self::VarLinearGradient(FontRead::read(data)?)),
            PaintRadialGradient::FORMAT => Ok(Self::RadialGradient(FontRead::read(data)?)),
            PaintVarRadialGradient::FORMAT => Ok(Self::VarRadialGradient(FontRead::read(data)?)),
            PaintSweepGradient::FORMAT => Ok(Self::SweepGradient(FontRead::read(data)?)),
            PaintVarSweepGradient::FORMAT => Ok(Self::VarSweepGradient(FontRead::read(data)?)),
            PaintGlyph::FORMAT => Ok(Self::Glyph(FontRead::read(data)?)),
            PaintColrGlyph::FORMAT => Ok(Self::ColrGlyph(FontRead::read(data)?)),
            PaintTransform::FORMAT => Ok(Self::Transform(FontRead::read(data)?)),
            PaintVarTransform::FORMAT => Ok(Self::VarTransform(FontRead::read(data)?)),
            PaintTranslate::FORMAT => Ok(Self::Translate(FontRead::read(data)?)),
            PaintVarTranslate::FORMAT => Ok(Self::VarTranslate(FontRead::read(data)?)),
            PaintScale::FORMAT => Ok(Self::Scale(FontRead::read(data)?)),
            PaintVarScale::FORMAT => Ok(Self::VarScale(FontRead::read(data)?)),
            PaintScaleAroundCenter::FORMAT => Ok(Self::ScaleAroundCenter(FontRead::read(data)?)),
            PaintVarScaleAroundCenter::FORMAT => {
                Ok(Self::VarScaleAroundCenter(FontRead::read(data)?))
            }
            PaintScaleUniform::FORMAT => Ok(Self::ScaleUniform(FontRead::read(data)?)),
            PaintVarScaleUniform::FORMAT => Ok(Self::VarScaleUniform(FontRead::read(data)?)),
            PaintScaleUniformAroundCenter::FORMAT => {
                Ok(Self::ScaleUniformAroundCenter(FontRead::read(data)?))
            }
            PaintVarScaleUniformAroundCenter::FORMAT => {
                Ok(Self::VarScaleUniformAroundCenter(FontRead::read(data)?))
            }
            PaintRotate::FORMAT => Ok(Self::Rotate(FontRead::read(data)?)),
            PaintVarRotate::FORMAT => Ok(Self::VarRotate(FontRead::read(data)?)),
            PaintRotateAroundCenter::FORMAT => Ok(Self::RotateAroundCenter(FontRead::read(data)?)),
            PaintVarRotateAroundCenter::FORMAT => {
                Ok(Self::VarRotateAroundCenter(FontRead::read(data)?))
            }
            PaintSkew::FORMAT => Ok(Self::Skew(FontRead::read(data)?)),
            PaintVarSkew::FORMAT => Ok(Self::VarSkew(FontRead::read(data)?)),
            PaintSkewAroundCenter::FORMAT => Ok(Self::SkewAroundCenter(FontRead::read(data)?)),
            PaintVarSkewAroundCenter::FORMAT => {
                Ok(Self::VarSkewAroundCenter(FontRead::read(data)?))
            }
            PaintComposite::FORMAT => Ok(Self::Composite(FontRead::read(data)?)),
            PaintGlyph2::FORMAT => Ok(Self::Glyph2(FontRead::read(data)?)),
            other => Err(ReadError::InvalidFormat(other.into())),
        }
    }
}

impl<'a> MinByteRange<'a> for Paint<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        match self {
            Self::ColrLayers(item) => item.min_byte_range(),
            Self::Solid(item) => item.min_byte_range(),
            Self::VarSolid(item) => item.min_byte_range(),
            Self::LinearGradient(item) => item.min_byte_range(),
            Self::VarLinearGradient(item) => item.min_byte_range(),
            Self::RadialGradient(item) => item.min_byte_range(),
            Self::VarRadialGradient(item) => item.min_byte_range(),
            Self::SweepGradient(item) => item.min_byte_range(),
            Self::VarSweepGradient(item) => item.min_byte_range(),
            Self::Glyph(item) => item.min_byte_range(),
            Self::ColrGlyph(item) => item.min_byte_range(),
            Self::Transform(item) => item.min_byte_range(),
            Self::VarTransform(item) => item.min_byte_range(),
            Self::Translate(item) => item.min_byte_range(),
            Self::VarTranslate(item) => item.min_byte_range(),
            Self::Scale(item) => item.min_byte_range(),
            Self::VarScale(item) => item.min_byte_range(),
            Self::ScaleAroundCenter(item) => item.min_byte_range(),
            Self::VarScaleAroundCenter(item) => item.min_byte_range(),
            Self::ScaleUniform(item) => item.min_byte_range(),
            Self::VarScaleUniform(item) => item.min_byte_range(),
            Self::ScaleUniformAroundCenter(item) => item.min_byte_range(),
            Self::VarScaleUniformAroundCenter(item) => item.min_byte_range(),
            Self::Rotate(item) => item.min_byte_range(),
            Self::VarRotate(item) => item.min_byte_range(),
            Self::RotateAroundCenter(item) => item.min_byte_range(),
            Self::VarRotateAroundCenter(item) => item.min_byte_range(),
            Self::Skew(item) => item.min_byte_range(),
            Self::VarSkew(item) => item.min_byte_range(),
            Self::SkewAroundCenter(item) => item.min_byte_range(),
            Self::VarSkewAroundCenter(item) => item.min_byte_range(),
            Self::Composite(item) => item.min_byte_range(),
            Self::Glyph2(item) => item.min_byte_range(),
        }
    }
    fn min_table_bytes(&self) -> &'a [u8] {
        match self {
            Self::ColrLayers(item) => item.min_table_bytes(),
            Self::Solid(item) => item.min_table_bytes(),
            Self::VarSolid(item) => item.min_table_bytes(),
            Self::LinearGradient(item) => item.min_table_bytes(),
            Self::VarLinearGradient(item) => item.min_table_bytes(),
            Self::RadialGradient(item) => item.min_table_bytes(),
            Self::VarRadialGradient(item) => item.min_table_bytes(),
            Self::SweepGradient(item) => item.min_table_bytes(),
            Self::VarSweepGradient(item) => item.min_table_bytes(),
            Self::Glyph(item) => item.min_table_bytes(),
            Self::ColrGlyph(item) => item.min_table_bytes(),
            Self::Transform(item) => item.min_table_bytes(),
            Self::VarTransform(item) => item.min_table_bytes(),
            Self::Translate(item) => item.min_table_bytes(),
            Self::VarTranslate(item) => item.min_table_bytes(),
            Self::Scale(item) => item.min_table_bytes(),
            Self::VarScale(item) => item.min_table_bytes(),
            Self::ScaleAroundCenter(item) => item.min_table_bytes(),
            Self::VarScaleAroundCenter(item) => item.min_table_bytes(),
            Self::ScaleUniform(item) => item.min_table_bytes(),
            Self::VarScaleUniform(item) => item.min_table_bytes(),
            Self::ScaleUniformAroundCenter(item) => item.min_table_bytes(),
            Self::VarScaleUniformAroundCenter(item) => item.min_table_bytes(),
            Self::Rotate(item) => item.min_table_bytes(),
            Self::VarRotate(item) => item.min_table_bytes(),
            Self::RotateAroundCenter(item) => item.min_table_bytes(),
            Self::VarRotateAroundCenter(item) => item.min_table_bytes(),
            Self::Skew(item) => item.min_table_bytes(),
            Self::VarSkew(item) => item.min_table_bytes(),
            Self::SkewAroundCenter(item) => item.min_table_bytes(),
            Self::VarSkewAroundCenter(item) => item.min_table_bytes(),
            Self::Composite(item) => item.min_table_bytes(),
            Self::Glyph2(item) => item.min_table_bytes(),
        }
    }
}

impl Format<u8> for PaintColrLayers<'_> {
    const FORMAT: u8 = 1;
}

impl<'a> MinByteRange<'a> for PaintColrLayers<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.first_layer_index_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 PaintColrLayers<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintColrLayers<'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 PaintColrLayersFixedHeader {
    pub format: u8,
    pub num_layers: u8,
    pub first_layer_index: BigEndian<u32>,
}

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

/// [PaintColrLayers](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-1-paintcolrlayers) table
#[derive(Clone)]
pub struct PaintColrLayers<'a> {
    data: TableDataRef<'a, PaintColrLayersFixedHeader>,
}

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

    /// Set to 1.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Number of offsets to paint tables to read from LayerList.
    pub fn num_layers(&self) -> u8 {
        self.data.header().num_layers
    }

    /// Index (base 0) into the LayerList.
    pub fn first_layer_index(&self) -> u32 {
        self.data.header().first_layer_index.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn num_layers_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn first_layer_index_byte_range(&self) -> Range<usize> {
        let start = self.num_layers_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

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

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

impl Format<u8> for PaintSolid<'_> {
    const FORMAT: u8 = 2;
}

impl<'a> MinByteRange<'a> for PaintSolid<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.alpha_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 PaintSolid<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintSolid<'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 PaintSolidFixedHeader {
    pub format: u8,
    pub palette_index: BigEndian<u16>,
    pub alpha: BigEndian<F2Dot14>,
}

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

/// [PaintSolid](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-2-and-3-paintsolid-paintvarsolid) table
#[derive(Clone)]
pub struct PaintSolid<'a> {
    data: TableDataRef<'a, PaintSolidFixedHeader>,
}

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

    /// Set to 2.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Index for a CPAL palette entry.
    pub fn palette_index(&self) -> u16 {
        self.data.header().palette_index.get()
    }

    /// Alpha value.
    pub fn alpha(&self) -> F2Dot14 {
        self.data.header().alpha.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn palette_index_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(u16::RAW_BYTE_LEN);
        start..end
    }

    pub fn alpha_byte_range(&self) -> Range<usize> {
        let start = self.palette_index_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarSolid<'_> {
    const FORMAT: u8 = 3;
}

impl<'a> MinByteRange<'a> for PaintVarSolid<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarSolid<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarSolid<'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 PaintVarSolidFixedHeader {
    pub format: u8,
    pub palette_index: BigEndian<u16>,
    pub alpha: BigEndian<F2Dot14>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarSolid](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-2-and-3-paintsolid-paintvarsolid) table
#[derive(Clone)]
pub struct PaintVarSolid<'a> {
    data: TableDataRef<'a, PaintVarSolidFixedHeader>,
}

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

    /// Set to 3.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Index for a CPAL palette entry.
    pub fn palette_index(&self) -> u16 {
        self.data.header().palette_index.get()
    }

    /// Alpha value. For variation, use varIndexBase + 0.
    pub fn alpha(&self) -> F2Dot14 {
        self.data.header().alpha.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn palette_index_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(u16::RAW_BYTE_LEN);
        start..end
    }

    pub fn alpha_byte_range(&self) -> Range<usize> {
        let start = self.palette_index_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.alpha_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintLinearGradient<'_> {
    const FORMAT: u8 = 4;
}

impl<'a> MinByteRange<'a> for PaintLinearGradient<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.y2_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 PaintLinearGradient<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintLinearGradient<'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 PaintLinearGradientFixedHeader {
    pub format: u8,
    pub color_line_offset: BigEndian<Offset24>,
    pub x0: BigEndian<FWord>,
    pub y0: BigEndian<FWord>,
    pub x1: BigEndian<FWord>,
    pub y1: BigEndian<FWord>,
    pub x2: BigEndian<FWord>,
    pub y2: BigEndian<FWord>,
}

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

/// [PaintLinearGradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-4-and-5-paintlineargradient-paintvarlineargradient) table
#[derive(Clone)]
pub struct PaintLinearGradient<'a> {
    data: TableDataRef<'a, PaintLinearGradientFixedHeader>,
}

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

    /// Set to 4.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to ColorLine table.
    pub fn color_line_offset(&self) -> Offset24 {
        self.data.header().color_line_offset.get()
    }

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

    /// Start point (p₀) x coordinate.
    pub fn x0(&self) -> FWord {
        self.data.header().x0.get()
    }

    /// Start point (p₀) y coordinate.
    pub fn y0(&self) -> FWord {
        self.data.header().y0.get()
    }

    /// End point (p₁) x coordinate.
    pub fn x1(&self) -> FWord {
        self.data.header().x1.get()
    }

    /// End point (p₁) y coordinate.
    pub fn y1(&self) -> FWord {
        self.data.header().y1.get()
    }

    /// Rotation point (p₂) x coordinate.
    pub fn x2(&self) -> FWord {
        self.data.header().x2.get()
    }

    /// Rotation point (p₂) y coordinate.
    pub fn y2(&self) -> FWord {
        self.data.header().y2.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_line_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x0_byte_range(&self) -> Range<usize> {
        let start = self.color_line_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y0_byte_range(&self) -> Range<usize> {
        let start = self.x0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x1_byte_range(&self) -> Range<usize> {
        let start = self.y0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y1_byte_range(&self) -> Range<usize> {
        let start = self.x1_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x2_byte_range(&self) -> Range<usize> {
        let start = self.y1_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y2_byte_range(&self) -> Range<usize> {
        let start = self.x2_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarLinearGradient<'_> {
    const FORMAT: u8 = 5;
}

impl<'a> MinByteRange<'a> for PaintVarLinearGradient<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarLinearGradient<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarLinearGradient<'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 PaintVarLinearGradientFixedHeader {
    pub format: u8,
    pub color_line_offset: BigEndian<Offset24>,
    pub x0: BigEndian<FWord>,
    pub y0: BigEndian<FWord>,
    pub x1: BigEndian<FWord>,
    pub y1: BigEndian<FWord>,
    pub x2: BigEndian<FWord>,
    pub y2: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarLinearGradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-4-and-5-paintlineargradient-paintvarlineargradient) table
#[derive(Clone)]
pub struct PaintVarLinearGradient<'a> {
    data: TableDataRef<'a, PaintVarLinearGradientFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarLinearGradient<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 5.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to VarColorLine table.
    pub fn color_line_offset(&self) -> Offset24 {
        self.data.header().color_line_offset.get()
    }

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

    /// Start point (p₀) x coordinate. For variation, use
    /// varIndexBase + 0.
    pub fn x0(&self) -> FWord {
        self.data.header().x0.get()
    }

    /// Start point (p₀) y coordinate. For variation, use
    /// varIndexBase + 1.
    pub fn y0(&self) -> FWord {
        self.data.header().y0.get()
    }

    /// End point (p₁) x coordinate. For variation, use varIndexBase
    /// + 2.
    pub fn x1(&self) -> FWord {
        self.data.header().x1.get()
    }

    /// End point (p₁) y coordinate. For variation, use varIndexBase
    /// + 3.
    pub fn y1(&self) -> FWord {
        self.data.header().y1.get()
    }

    /// Rotation point (p₂) x coordinate. For variation, use
    /// varIndexBase + 4.
    pub fn x2(&self) -> FWord {
        self.data.header().x2.get()
    }

    /// Rotation point (p₂) y coordinate. For variation, use
    /// varIndexBase + 5.
    pub fn y2(&self) -> FWord {
        self.data.header().y2.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_line_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x0_byte_range(&self) -> Range<usize> {
        let start = self.color_line_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y0_byte_range(&self) -> Range<usize> {
        let start = self.x0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x1_byte_range(&self) -> Range<usize> {
        let start = self.y0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y1_byte_range(&self) -> Range<usize> {
        let start = self.x1_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x2_byte_range(&self) -> Range<usize> {
        let start = self.y1_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y2_byte_range(&self) -> Range<usize> {
        let start = self.x2_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.y2_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintRadialGradient<'_> {
    const FORMAT: u8 = 6;
}

impl<'a> MinByteRange<'a> for PaintRadialGradient<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.radius1_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 PaintRadialGradient<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintRadialGradient<'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 PaintRadialGradientFixedHeader {
    pub format: u8,
    pub color_line_offset: BigEndian<Offset24>,
    pub x0: BigEndian<FWord>,
    pub y0: BigEndian<FWord>,
    pub radius0: BigEndian<UfWord>,
    pub x1: BigEndian<FWord>,
    pub y1: BigEndian<FWord>,
    pub radius1: BigEndian<UfWord>,
}

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

/// [PaintRadialGradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-6-and-7-paintradialgradient-paintvarradialgradient) table
#[derive(Clone)]
pub struct PaintRadialGradient<'a> {
    data: TableDataRef<'a, PaintRadialGradientFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintRadialGradient<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 6.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to ColorLine table.
    pub fn color_line_offset(&self) -> Offset24 {
        self.data.header().color_line_offset.get()
    }

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

    /// Start circle center x coordinate.
    pub fn x0(&self) -> FWord {
        self.data.header().x0.get()
    }

    /// Start circle center y coordinate.
    pub fn y0(&self) -> FWord {
        self.data.header().y0.get()
    }

    /// Start circle radius.
    pub fn radius0(&self) -> UfWord {
        self.data.header().radius0.get()
    }

    /// End circle center x coordinate.
    pub fn x1(&self) -> FWord {
        self.data.header().x1.get()
    }

    /// End circle center y coordinate.
    pub fn y1(&self) -> FWord {
        self.data.header().y1.get()
    }

    /// End circle radius.
    pub fn radius1(&self) -> UfWord {
        self.data.header().radius1.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_line_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x0_byte_range(&self) -> Range<usize> {
        let start = self.color_line_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y0_byte_range(&self) -> Range<usize> {
        let start = self.x0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn radius0_byte_range(&self) -> Range<usize> {
        let start = self.y0_byte_range().end;
        let end = start.saturating_add(UfWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x1_byte_range(&self) -> Range<usize> {
        let start = self.radius0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y1_byte_range(&self) -> Range<usize> {
        let start = self.x1_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn radius1_byte_range(&self) -> Range<usize> {
        let start = self.y1_byte_range().end;
        let end = start.saturating_add(UfWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarRadialGradient<'_> {
    const FORMAT: u8 = 7;
}

impl<'a> MinByteRange<'a> for PaintVarRadialGradient<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarRadialGradient<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarRadialGradient<'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 PaintVarRadialGradientFixedHeader {
    pub format: u8,
    pub color_line_offset: BigEndian<Offset24>,
    pub x0: BigEndian<FWord>,
    pub y0: BigEndian<FWord>,
    pub radius0: BigEndian<UfWord>,
    pub x1: BigEndian<FWord>,
    pub y1: BigEndian<FWord>,
    pub radius1: BigEndian<UfWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarRadialGradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-6-and-7-paintradialgradient-paintvarradialgradient) table
#[derive(Clone)]
pub struct PaintVarRadialGradient<'a> {
    data: TableDataRef<'a, PaintVarRadialGradientFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarRadialGradient<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + UfWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 7.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to VarColorLine table.
    pub fn color_line_offset(&self) -> Offset24 {
        self.data.header().color_line_offset.get()
    }

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

    /// Start circle center x coordinate. For variation, use
    /// varIndexBase + 0.
    pub fn x0(&self) -> FWord {
        self.data.header().x0.get()
    }

    /// Start circle center y coordinate. For variation, use
    /// varIndexBase + 1.
    pub fn y0(&self) -> FWord {
        self.data.header().y0.get()
    }

    /// Start circle radius. For variation, use varIndexBase + 2.
    pub fn radius0(&self) -> UfWord {
        self.data.header().radius0.get()
    }

    /// End circle center x coordinate. For variation, use varIndexBase
    /// + 3.
    pub fn x1(&self) -> FWord {
        self.data.header().x1.get()
    }

    /// End circle center y coordinate. For variation, use varIndexBase
    /// + 4.
    pub fn y1(&self) -> FWord {
        self.data.header().y1.get()
    }

    /// End circle radius. For variation, use varIndexBase + 5.
    pub fn radius1(&self) -> UfWord {
        self.data.header().radius1.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_line_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x0_byte_range(&self) -> Range<usize> {
        let start = self.color_line_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y0_byte_range(&self) -> Range<usize> {
        let start = self.x0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn radius0_byte_range(&self) -> Range<usize> {
        let start = self.y0_byte_range().end;
        let end = start.saturating_add(UfWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn x1_byte_range(&self) -> Range<usize> {
        let start = self.radius0_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn y1_byte_range(&self) -> Range<usize> {
        let start = self.x1_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn radius1_byte_range(&self) -> Range<usize> {
        let start = self.y1_byte_range().end;
        let end = start.saturating_add(UfWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.radius1_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintSweepGradient<'_> {
    const FORMAT: u8 = 8;
}

impl<'a> MinByteRange<'a> for PaintSweepGradient<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.end_angle_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 PaintSweepGradient<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintSweepGradient<'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 PaintSweepGradientFixedHeader {
    pub format: u8,
    pub color_line_offset: BigEndian<Offset24>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
    pub start_angle: BigEndian<F2Dot14>,
    pub end_angle: BigEndian<F2Dot14>,
}

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

/// [PaintSweepGradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-8-and-9-paintsweepgradient-paintvarsweepgradient) table
#[derive(Clone)]
pub struct PaintSweepGradient<'a> {
    data: TableDataRef<'a, PaintSweepGradientFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintSweepGradient<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 8.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to ColorLine table.
    pub fn color_line_offset(&self) -> Offset24 {
        self.data.header().color_line_offset.get()
    }

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

    /// Center x coordinate.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// Center y coordinate.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    /// Start of the angular range of the gradient, 180° in
    /// counter-clockwise degrees per 1.0 of value.
    pub fn start_angle(&self) -> F2Dot14 {
        self.data.header().start_angle.get()
    }

    /// End of the angular range of the gradient, 180° in
    /// counter-clockwise degrees per 1.0 of value.
    pub fn end_angle(&self) -> F2Dot14 {
        self.data.header().end_angle.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_line_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.color_line_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn start_angle_byte_range(&self) -> Range<usize> {
        let start = self.center_y_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn end_angle_byte_range(&self) -> Range<usize> {
        let start = self.start_angle_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarSweepGradient<'_> {
    const FORMAT: u8 = 9;
}

impl<'a> MinByteRange<'a> for PaintVarSweepGradient<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarSweepGradient<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarSweepGradient<'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 PaintVarSweepGradientFixedHeader {
    pub format: u8,
    pub color_line_offset: BigEndian<Offset24>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
    pub start_angle: BigEndian<F2Dot14>,
    pub end_angle: BigEndian<F2Dot14>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarSweepGradient](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-8-and-9-paintsweepgradient-paintvarsweepgradient) table
#[derive(Clone)]
pub struct PaintVarSweepGradient<'a> {
    data: TableDataRef<'a, PaintVarSweepGradientFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarSweepGradient<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 9.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to VarColorLine table.
    pub fn color_line_offset(&self) -> Offset24 {
        self.data.header().color_line_offset.get()
    }

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

    /// Center x coordinate. For variation, use varIndexBase + 0.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// Center y coordinate. For variation, use varIndexBase + 1.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    /// Start of the angular range of the gradient, 180° in
    /// counter-clockwise degrees per 1.0 of value. For variation, use
    /// varIndexBase + 2.
    pub fn start_angle(&self) -> F2Dot14 {
        self.data.header().start_angle.get()
    }

    /// End of the angular range of the gradient, 180° in
    /// counter-clockwise degrees per 1.0 of value. For variation, use
    /// varIndexBase + 3.
    pub fn end_angle(&self) -> F2Dot14 {
        self.data.header().end_angle.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn color_line_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.color_line_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn start_angle_byte_range(&self) -> Range<usize> {
        let start = self.center_y_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn end_angle_byte_range(&self) -> Range<usize> {
        let start = self.start_angle_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.end_angle_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintGlyph<'_> {
    const FORMAT: u8 = 10;
}

impl<'a> MinByteRange<'a> for PaintGlyph<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.glyph_id_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 PaintGlyph<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintGlyph<'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 PaintGlyphFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub glyph_id: BigEndian<GlyphId16>,
}

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

/// [PaintGlyph](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-10-paintglyph) table
#[derive(Clone)]
pub struct PaintGlyph<'a> {
    data: TableDataRef<'a, PaintGlyphFixedHeader>,
}

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

    /// Set to 10.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint table.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Glyph ID for the source outline.
    pub fn glyph_id(&self) -> GlyphId16 {
        self.data.header().glyph_id.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn glyph_id_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(GlyphId16::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintGlyph2<'_> {
    const FORMAT: u8 = 33;
}

impl<'a> MinByteRange<'a> for PaintGlyph2<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.glyph_id_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 PaintGlyph2<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintGlyph2<'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 PaintGlyph2FixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub glyph_id: BigEndian<GlyphId24>,
}

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

/// PaintGlyph2, format 33 (ISO/IEC 14496-22:2026).
#[derive(Clone)]
pub struct PaintGlyph2<'a> {
    data: TableDataRef<'a, PaintGlyph2FixedHeader>,
}

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

    /// Set to 33.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint table.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Glyph ID for the source outline.
    pub fn glyph_id(&self) -> GlyphId24 {
        self.data.header().glyph_id.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn glyph_id_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(GlyphId24::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintColrGlyph<'_> {
    const FORMAT: u8 = 11;
}

impl<'a> MinByteRange<'a> for PaintColrGlyph<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.glyph_id_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 PaintColrGlyph<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintColrGlyph<'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 PaintColrGlyphFixedHeader {
    pub format: u8,
    pub glyph_id: BigEndian<GlyphId16>,
}

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

/// [PaintColrGlyph](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-11-paintcolrglyph) table
#[derive(Clone)]
pub struct PaintColrGlyph<'a> {
    data: TableDataRef<'a, PaintColrGlyphFixedHeader>,
}

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

    /// Set to 11.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Glyph ID for a BaseGlyphList base glyph.
    pub fn glyph_id(&self) -> GlyphId16 {
        self.data.header().glyph_id.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn glyph_id_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(GlyphId16::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintTransform<'_> {
    const FORMAT: u8 = 12;
}

impl<'a> MinByteRange<'a> for PaintTransform<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.transform_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 PaintTransform<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintTransform<'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 PaintTransformFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub transform_offset: BigEndian<Offset24>,
}

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

/// [PaintTransform](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform) table
#[derive(Clone)]
pub struct PaintTransform<'a> {
    data: TableDataRef<'a, PaintTransformFixedHeader>,
}

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

    /// Set to 12.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Offset to an Affine2x3 table.
    pub fn transform_offset(&self) -> Offset24 {
        self.data.header().transform_offset.get()
    }

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

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn transform_offset_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarTransform<'_> {
    const FORMAT: u8 = 13;
}

impl<'a> MinByteRange<'a> for PaintVarTransform<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.transform_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 PaintVarTransform<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarTransform<'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 PaintVarTransformFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub transform_offset: BigEndian<Offset24>,
}

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

/// [PaintVarTransform](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform) table
#[derive(Clone)]
pub struct PaintVarTransform<'a> {
    data: TableDataRef<'a, PaintVarTransformFixedHeader>,
}

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

    /// Set to 13.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Offset to a VarAffine2x3 table.
    pub fn transform_offset(&self) -> Offset24 {
        self.data.header().transform_offset.get()
    }

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

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn transform_offset_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }
}

impl<'a> MinByteRange<'a> for Affine2x3<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.dy_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 Affine2x3<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for Affine2x3<'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 Affine2x3FixedHeader {
    pub xx: BigEndian<Fixed>,
    pub yx: BigEndian<Fixed>,
    pub xy: BigEndian<Fixed>,
    pub yy: BigEndian<Fixed>,
    pub dx: BigEndian<Fixed>,
    pub dy: BigEndian<Fixed>,
}

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

/// [Affine2x3](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform) record
#[derive(Clone)]
pub struct Affine2x3<'a> {
    data: TableDataRef<'a, Affine2x3FixedHeader>,
}

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

    /// x-component of transformed x-basis vector.
    pub fn xx(&self) -> Fixed {
        self.data.header().xx.get()
    }

    /// y-component of transformed x-basis vector.
    pub fn yx(&self) -> Fixed {
        self.data.header().yx.get()
    }

    /// x-component of transformed y-basis vector.
    pub fn xy(&self) -> Fixed {
        self.data.header().xy.get()
    }

    /// y-component of transformed y-basis vector.
    pub fn yy(&self) -> Fixed {
        self.data.header().yy.get()
    }

    /// Translation in x direction.
    pub fn dx(&self) -> Fixed {
        self.data.header().dx.get()
    }

    /// Translation in y direction.
    pub fn dy(&self) -> Fixed {
        self.data.header().dy.get()
    }

    pub fn xx_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn yx_byte_range(&self) -> Range<usize> {
        let start = self.xx_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn xy_byte_range(&self) -> Range<usize> {
        let start = self.yx_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn yy_byte_range(&self) -> Range<usize> {
        let start = self.xy_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn dx_byte_range(&self) -> Range<usize> {
        let start = self.yy_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn dy_byte_range(&self) -> Range<usize> {
        let start = self.dx_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }
}

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

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

impl<'a> MinByteRange<'a> for VarAffine2x3<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 VarAffine2x3<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for VarAffine2x3<'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 VarAffine2x3FixedHeader {
    pub xx: BigEndian<Fixed>,
    pub yx: BigEndian<Fixed>,
    pub xy: BigEndian<Fixed>,
    pub yy: BigEndian<Fixed>,
    pub dx: BigEndian<Fixed>,
    pub dy: BigEndian<Fixed>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [VarAffine2x3](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform) record
#[derive(Clone)]
pub struct VarAffine2x3<'a> {
    data: TableDataRef<'a, VarAffine2x3FixedHeader>,
}

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

    /// x-component of transformed x-basis vector. For variation, use
    /// varIndexBase + 0.
    pub fn xx(&self) -> Fixed {
        self.data.header().xx.get()
    }

    /// y-component of transformed x-basis vector. For variation, use
    /// varIndexBase + 1.
    pub fn yx(&self) -> Fixed {
        self.data.header().yx.get()
    }

    /// x-component of transformed y-basis vector. For variation, use
    /// varIndexBase + 2.
    pub fn xy(&self) -> Fixed {
        self.data.header().xy.get()
    }

    /// y-component of transformed y-basis vector. For variation, use
    /// varIndexBase + 3.
    pub fn yy(&self) -> Fixed {
        self.data.header().yy.get()
    }

    /// Translation in x direction. For variation, use varIndexBase + 4.
    pub fn dx(&self) -> Fixed {
        self.data.header().dx.get()
    }

    /// Translation in y direction. For variation, use varIndexBase + 5.
    pub fn dy(&self) -> Fixed {
        self.data.header().dy.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn xx_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn yx_byte_range(&self) -> Range<usize> {
        let start = self.xx_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn xy_byte_range(&self) -> Range<usize> {
        let start = self.yx_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn yy_byte_range(&self) -> Range<usize> {
        let start = self.xy_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn dx_byte_range(&self) -> Range<usize> {
        let start = self.yy_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn dy_byte_range(&self) -> Range<usize> {
        let start = self.dx_byte_range().end;
        let end = start.saturating_add(Fixed::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.dy_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

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

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

impl Format<u8> for PaintTranslate<'_> {
    const FORMAT: u8 = 14;
}

impl<'a> MinByteRange<'a> for PaintTranslate<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.dy_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 PaintTranslate<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintTranslate<'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 PaintTranslateFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub dx: BigEndian<FWord>,
    pub dy: BigEndian<FWord>,
}

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

/// [PaintTranslate](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-14-and-15-painttranslate-paintvartranslate) table
#[derive(Clone)]
pub struct PaintTranslate<'a> {
    data: TableDataRef<'a, PaintTranslateFixedHeader>,
}

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

    /// Set to 14.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Translation in x direction.
    pub fn dx(&self) -> FWord {
        self.data.header().dx.get()
    }

    /// Translation in y direction.
    pub fn dy(&self) -> FWord {
        self.data.header().dy.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn dx_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn dy_byte_range(&self) -> Range<usize> {
        let start = self.dx_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarTranslate<'_> {
    const FORMAT: u8 = 15;
}

impl<'a> MinByteRange<'a> for PaintVarTranslate<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarTranslate<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarTranslate<'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 PaintVarTranslateFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub dx: BigEndian<FWord>,
    pub dy: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarTranslate](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-14-and-15-painttranslate-paintvartranslate) table
#[derive(Clone)]
pub struct PaintVarTranslate<'a> {
    data: TableDataRef<'a, PaintVarTranslateFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarTranslate<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 15.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Translation in x direction. For variation, use varIndexBase + 0.
    pub fn dx(&self) -> FWord {
        self.data.header().dx.get()
    }

    /// Translation in y direction. For variation, use varIndexBase + 1.
    pub fn dy(&self) -> FWord {
        self.data.header().dy.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn dx_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn dy_byte_range(&self) -> Range<usize> {
        let start = self.dx_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.dy_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintScale<'_> {
    const FORMAT: u8 = 16;
}

impl<'a> MinByteRange<'a> for PaintScale<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.scale_y_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 PaintScale<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintScale<'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 PaintScaleFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale_x: BigEndian<F2Dot14>,
    pub scale_y: BigEndian<F2Dot14>,
}

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

/// [PaintScale](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintScale<'a> {
    data: TableDataRef<'a, PaintScaleFixedHeader>,
}

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

    /// Set to 16.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x direction.
    pub fn scale_x(&self) -> F2Dot14 {
        self.data.header().scale_x.get()
    }

    /// Scale factor in y direction.
    pub fn scale_y(&self) -> F2Dot14 {
        self.data.header().scale_y.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_x_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_y_byte_range(&self) -> Range<usize> {
        let start = self.scale_x_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarScale<'_> {
    const FORMAT: u8 = 17;
}

impl<'a> MinByteRange<'a> for PaintVarScale<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarScale<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarScale<'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 PaintVarScaleFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale_x: BigEndian<F2Dot14>,
    pub scale_y: BigEndian<F2Dot14>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarScale](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintVarScale<'a> {
    data: TableDataRef<'a, PaintVarScaleFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarScale<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 17.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x direction. For variation, use varIndexBase +
    /// 0.
    pub fn scale_x(&self) -> F2Dot14 {
        self.data.header().scale_x.get()
    }

    /// Scale factor in y direction. For variation, use varIndexBase +
    /// 1.
    pub fn scale_y(&self) -> F2Dot14 {
        self.data.header().scale_y.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_x_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_y_byte_range(&self) -> Range<usize> {
        let start = self.scale_x_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.scale_y_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintScaleAroundCenter<'_> {
    const FORMAT: u8 = 18;
}

impl<'a> MinByteRange<'a> for PaintScaleAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.center_y_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 PaintScaleAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintScaleAroundCenter<'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 PaintScaleAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale_x: BigEndian<F2Dot14>,
    pub scale_y: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
}

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

/// [PaintScaleAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintScaleAroundCenter<'a> {
    data: TableDataRef<'a, PaintScaleAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintScaleAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 18.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x direction.
    pub fn scale_x(&self) -> F2Dot14 {
        self.data.header().scale_x.get()
    }

    /// Scale factor in y direction.
    pub fn scale_y(&self) -> F2Dot14 {
        self.data.header().scale_y.get()
    }

    /// x coordinate for the center of scaling.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of scaling.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_x_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_y_byte_range(&self) -> Range<usize> {
        let start = self.scale_x_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.scale_y_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarScaleAroundCenter<'_> {
    const FORMAT: u8 = 19;
}

impl<'a> MinByteRange<'a> for PaintVarScaleAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarScaleAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarScaleAroundCenter<'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 PaintVarScaleAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale_x: BigEndian<F2Dot14>,
    pub scale_y: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarScaleAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintVarScaleAroundCenter<'a> {
    data: TableDataRef<'a, PaintVarScaleAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarScaleAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 19.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x direction. For variation, use varIndexBase +
    /// 0.
    pub fn scale_x(&self) -> F2Dot14 {
        self.data.header().scale_x.get()
    }

    /// Scale factor in y direction. For variation, use varIndexBase +
    /// 1.
    pub fn scale_y(&self) -> F2Dot14 {
        self.data.header().scale_y.get()
    }

    /// x coordinate for the center of scaling. For variation, use
    /// varIndexBase + 2.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of scaling. For variation, use
    /// varIndexBase + 3.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_x_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_y_byte_range(&self) -> Range<usize> {
        let start = self.scale_x_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.scale_y_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.center_y_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintScaleUniform<'_> {
    const FORMAT: u8 = 20;
}

impl<'a> MinByteRange<'a> for PaintScaleUniform<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.scale_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 PaintScaleUniform<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintScaleUniform<'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 PaintScaleUniformFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale: BigEndian<F2Dot14>,
}

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

/// [PaintScaleUniform](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintScaleUniform<'a> {
    data: TableDataRef<'a, PaintScaleUniformFixedHeader>,
}

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

    /// Set to 20.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x and y directions.
    pub fn scale(&self) -> F2Dot14 {
        self.data.header().scale.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarScaleUniform<'_> {
    const FORMAT: u8 = 21;
}

impl<'a> MinByteRange<'a> for PaintVarScaleUniform<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarScaleUniform<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarScaleUniform<'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 PaintVarScaleUniformFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale: BigEndian<F2Dot14>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarScaleUniform](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintVarScaleUniform<'a> {
    data: TableDataRef<'a, PaintVarScaleUniformFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarScaleUniform<'a> {
    pub const MIN_SIZE: usize =
        (u8::RAW_BYTE_LEN + Offset24::RAW_BYTE_LEN + F2Dot14::RAW_BYTE_LEN + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 21.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x and y directions. For variation, use
    /// varIndexBase + 0.
    pub fn scale(&self) -> F2Dot14 {
        self.data.header().scale.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.scale_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintScaleUniformAroundCenter<'_> {
    const FORMAT: u8 = 22;
}

impl<'a> MinByteRange<'a> for PaintScaleUniformAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.center_y_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 PaintScaleUniformAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintScaleUniformAroundCenter<'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 PaintScaleUniformAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
}

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

/// [PaintScaleUniformAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintScaleUniformAroundCenter<'a> {
    data: TableDataRef<'a, PaintScaleUniformAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintScaleUniformAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 22.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x and y directions.
    pub fn scale(&self) -> F2Dot14 {
        self.data.header().scale.get()
    }

    /// x coordinate for the center of scaling.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of scaling.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.scale_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarScaleUniformAroundCenter<'_> {
    const FORMAT: u8 = 23;
}

impl<'a> MinByteRange<'a> for PaintVarScaleUniformAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarScaleUniformAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarScaleUniformAroundCenter<'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 PaintVarScaleUniformAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub scale: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarScaleUniformAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats) table
#[derive(Clone)]
pub struct PaintVarScaleUniformAroundCenter<'a> {
    data: TableDataRef<'a, PaintVarScaleUniformAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarScaleUniformAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 23.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Scale factor in x and y directions. For variation, use
    /// varIndexBase + 0.
    pub fn scale(&self) -> F2Dot14 {
        self.data.header().scale.get()
    }

    /// x coordinate for the center of scaling. For variation, use
    /// varIndexBase + 1.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of scaling. For variation, use
    /// varIndexBase + 2.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn scale_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.scale_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.center_y_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintRotate<'_> {
    const FORMAT: u8 = 24;
}

impl<'a> MinByteRange<'a> for PaintRotate<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.angle_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 PaintRotate<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintRotate<'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 PaintRotateFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub angle: BigEndian<F2Dot14>,
}

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

/// [PaintRotate](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter) table
#[derive(Clone)]
pub struct PaintRotate<'a> {
    data: TableDataRef<'a, PaintRotateFixedHeader>,
}

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

    /// Set to 24.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Rotation angle, 180° in counter-clockwise degrees per 1.0 of
    /// value.
    pub fn angle(&self) -> F2Dot14 {
        self.data.header().angle.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarRotate<'_> {
    const FORMAT: u8 = 25;
}

impl<'a> MinByteRange<'a> for PaintVarRotate<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarRotate<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarRotate<'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 PaintVarRotateFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub angle: BigEndian<F2Dot14>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarRotate](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter) table
#[derive(Clone)]
pub struct PaintVarRotate<'a> {
    data: TableDataRef<'a, PaintVarRotateFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarRotate<'a> {
    pub const MIN_SIZE: usize =
        (u8::RAW_BYTE_LEN + Offset24::RAW_BYTE_LEN + F2Dot14::RAW_BYTE_LEN + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 25.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Rotation angle, 180° in counter-clockwise degrees per 1.0 of
    /// value. For variation, use varIndexBase + 0.
    pub fn angle(&self) -> F2Dot14 {
        self.data.header().angle.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.angle_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintRotateAroundCenter<'_> {
    const FORMAT: u8 = 26;
}

impl<'a> MinByteRange<'a> for PaintRotateAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.center_y_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 PaintRotateAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintRotateAroundCenter<'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 PaintRotateAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub angle: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
}

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

/// [PaintRotateAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter) table
#[derive(Clone)]
pub struct PaintRotateAroundCenter<'a> {
    data: TableDataRef<'a, PaintRotateAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintRotateAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 26.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Rotation angle, 180° in counter-clockwise degrees per 1.0 of
    /// value.
    pub fn angle(&self) -> F2Dot14 {
        self.data.header().angle.get()
    }

    /// x coordinate for the center of rotation.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of rotation.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.angle_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarRotateAroundCenter<'_> {
    const FORMAT: u8 = 27;
}

impl<'a> MinByteRange<'a> for PaintVarRotateAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarRotateAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarRotateAroundCenter<'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 PaintVarRotateAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub angle: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarRotateAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter) table
#[derive(Clone)]
pub struct PaintVarRotateAroundCenter<'a> {
    data: TableDataRef<'a, PaintVarRotateAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarRotateAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 27.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Rotation angle, 180° in counter-clockwise degrees per 1.0 of
    /// value. For variation, use varIndexBase + 0.
    pub fn angle(&self) -> F2Dot14 {
        self.data.header().angle.get()
    }

    /// x coordinate for the center of rotation. For variation, use
    /// varIndexBase + 1.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of rotation. For variation, use
    /// varIndexBase + 2.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.angle_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.center_y_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintSkew<'_> {
    const FORMAT: u8 = 28;
}

impl<'a> MinByteRange<'a> for PaintSkew<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.y_skew_angle_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 PaintSkew<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintSkew<'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 PaintSkewFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub x_skew_angle: BigEndian<F2Dot14>,
    pub y_skew_angle: BigEndian<F2Dot14>,
}

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

/// [PaintSkew](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter) table
#[derive(Clone)]
pub struct PaintSkew<'a> {
    data: TableDataRef<'a, PaintSkewFixedHeader>,
}

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

    /// Set to 28.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Angle of skew in the direction of the x-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value.
    pub fn x_skew_angle(&self) -> F2Dot14 {
        self.data.header().x_skew_angle.get()
    }

    /// Angle of skew in the direction of the y-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value.
    pub fn y_skew_angle(&self) -> F2Dot14 {
        self.data.header().y_skew_angle.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.x_skew_angle_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarSkew<'_> {
    const FORMAT: u8 = 29;
}

impl<'a> MinByteRange<'a> for PaintVarSkew<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarSkew<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarSkew<'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 PaintVarSkewFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub x_skew_angle: BigEndian<F2Dot14>,
    pub y_skew_angle: BigEndian<F2Dot14>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarSkew](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter) table
#[derive(Clone)]
pub struct PaintVarSkew<'a> {
    data: TableDataRef<'a, PaintVarSkewFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarSkew<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 29.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Angle of skew in the direction of the x-axis, 180° ┬░ in
    /// counter-clockwise degrees per 1.0 of value. For variation, use
    /// varIndexBase + 0.
    pub fn x_skew_angle(&self) -> F2Dot14 {
        self.data.header().x_skew_angle.get()
    }

    /// Angle of skew in the direction of the y-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value. For variation, use
    /// varIndexBase + 1.
    pub fn y_skew_angle(&self) -> F2Dot14 {
        self.data.header().y_skew_angle.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.x_skew_angle_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.y_skew_angle_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintSkewAroundCenter<'_> {
    const FORMAT: u8 = 30;
}

impl<'a> MinByteRange<'a> for PaintSkewAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.center_y_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 PaintSkewAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintSkewAroundCenter<'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 PaintSkewAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub x_skew_angle: BigEndian<F2Dot14>,
    pub y_skew_angle: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
}

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

/// [PaintSkewAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter) table
#[derive(Clone)]
pub struct PaintSkewAroundCenter<'a> {
    data: TableDataRef<'a, PaintSkewAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintSkewAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 30.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Angle of skew in the direction of the x-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value.
    pub fn x_skew_angle(&self) -> F2Dot14 {
        self.data.header().x_skew_angle.get()
    }

    /// Angle of skew in the direction of the y-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value.
    pub fn y_skew_angle(&self) -> F2Dot14 {
        self.data.header().y_skew_angle.get()
    }

    /// x coordinate for the center of rotation.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of rotation.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.x_skew_angle_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.y_skew_angle_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintVarSkewAroundCenter<'_> {
    const FORMAT: u8 = 31;
}

impl<'a> MinByteRange<'a> for PaintVarSkewAroundCenter<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.var_index_base_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 PaintVarSkewAroundCenter<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintVarSkewAroundCenter<'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 PaintVarSkewAroundCenterFixedHeader {
    pub format: u8,
    pub paint_offset: BigEndian<Offset24>,
    pub x_skew_angle: BigEndian<F2Dot14>,
    pub y_skew_angle: BigEndian<F2Dot14>,
    pub center_x: BigEndian<FWord>,
    pub center_y: BigEndian<FWord>,
    pub var_index_base: BigEndian<u32>,
}

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

/// [PaintVarSkewAroundCenter](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter) table
#[derive(Clone)]
pub struct PaintVarSkewAroundCenter<'a> {
    data: TableDataRef<'a, PaintVarSkewAroundCenterFixedHeader>,
}

#[allow(clippy::needless_lifetimes)]
impl<'a> PaintVarSkewAroundCenter<'a> {
    pub const MIN_SIZE: usize = (u8::RAW_BYTE_LEN
        + Offset24::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + F2Dot14::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + FWord::RAW_BYTE_LEN
        + u32::RAW_BYTE_LEN);
    basic_table_impls!(impl_the_methods);

    /// Set to 31.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a Paint subtable.
    pub fn paint_offset(&self) -> Offset24 {
        self.data.header().paint_offset.get()
    }

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

    /// Angle of skew in the direction of the x-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value. For variation, use
    /// varIndexBase + 0.
    pub fn x_skew_angle(&self) -> F2Dot14 {
        self.data.header().x_skew_angle.get()
    }

    /// Angle of skew in the direction of the y-axis, 180° in
    /// counter-clockwise degrees per 1.0 of value. For variation, use
    /// varIndexBase + 1.
    pub fn y_skew_angle(&self) -> F2Dot14 {
        self.data.header().y_skew_angle.get()
    }

    /// x coordinate for the center of rotation. For variation, use
    /// varIndexBase + 2.
    pub fn center_x(&self) -> FWord {
        self.data.header().center_x.get()
    }

    /// y coordinate for the center of rotation. For variation, use
    /// varIndexBase + 3.
    pub fn center_y(&self) -> FWord {
        self.data.header().center_y.get()
    }

    /// Base index into DeltaSetIndexMap.
    pub fn var_index_base(&self) -> u32 {
        self.data.header().var_index_base.get()
    }

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn x_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.paint_offset_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn y_skew_angle_byte_range(&self) -> Range<usize> {
        let start = self.x_skew_angle_byte_range().end;
        let end = start.saturating_add(F2Dot14::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_x_byte_range(&self) -> Range<usize> {
        let start = self.y_skew_angle_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn center_y_byte_range(&self) -> Range<usize> {
        let start = self.center_x_byte_range().end;
        let end = start.saturating_add(FWord::RAW_BYTE_LEN);
        start..end
    }

    pub fn var_index_base_byte_range(&self) -> Range<usize> {
        let start = self.center_y_byte_range().end;
        let end = start.saturating_add(u32::RAW_BYTE_LEN);
        start..end
    }
}

impl Format<u8> for PaintComposite<'_> {
    const FORMAT: u8 = 32;
}

impl<'a> MinByteRange<'a> for PaintComposite<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.backdrop_paint_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 PaintComposite<'_> {
    type Args = ();
}

impl<'a> FontRead<'a> for PaintComposite<'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 PaintCompositeFixedHeader {
    pub format: u8,
    pub source_paint_offset: BigEndian<Offset24>,
    pub composite_mode: BigEndian<CompositeMode>,
    pub backdrop_paint_offset: BigEndian<Offset24>,
}

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

/// [PaintComposite](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-32-paintcomposite) table
#[derive(Clone)]
pub struct PaintComposite<'a> {
    data: TableDataRef<'a, PaintCompositeFixedHeader>,
}

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

    /// Set to 32.
    pub fn format(&self) -> u8 {
        self.data.header().format
    }

    /// Offset to a source Paint table.
    pub fn source_paint_offset(&self) -> Offset24 {
        self.data.header().source_paint_offset.get()
    }

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

    /// A CompositeMode enumeration value.
    pub fn composite_mode(&self) -> CompositeMode {
        self.data.header().composite_mode.get()
    }

    /// Offset to a backdrop Paint table.
    pub fn backdrop_paint_offset(&self) -> Offset24 {
        self.data.header().backdrop_paint_offset.get()
    }

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

    pub fn format_byte_range(&self) -> Range<usize> {
        let start = 0usize;
        let end = start.saturating_add(u8::RAW_BYTE_LEN);
        start..end
    }

    pub fn source_paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.format_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }

    pub fn composite_mode_byte_range(&self) -> Range<usize> {
        let start = self.source_paint_offset_byte_range().end;
        let end = start.saturating_add(CompositeMode::RAW_BYTE_LEN);
        start..end
    }

    pub fn backdrop_paint_offset_byte_range(&self) -> Range<usize> {
        let start = self.composite_mode_byte_range().end;
        let end = start.saturating_add(Offset24::RAW_BYTE_LEN);
        start..end
    }
}

/// [CompositeMode](https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-32-paintcomposite) enumeration
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u8)]
#[allow(clippy::manual_non_exhaustive)]
pub enum CompositeMode {
    Clear = 0,
    Src = 1,
    Dest = 2,
    #[default]
    SrcOver = 3,
    DestOver = 4,
    SrcIn = 5,
    DestIn = 6,
    SrcOut = 7,
    DestOut = 8,
    SrcAtop = 9,
    DestAtop = 10,
    Xor = 11,
    Plus = 12,
    Screen = 13,
    Overlay = 14,
    Darken = 15,
    Lighten = 16,
    ColorDodge = 17,
    ColorBurn = 18,
    HardLight = 19,
    SoftLight = 20,
    Difference = 21,
    Exclusion = 22,
    Multiply = 23,
    HslHue = 24,
    HslSaturation = 25,
    HslColor = 26,
    HslLuminosity = 27,
    #[doc(hidden)]
    /// If font data is malformed we will map unknown values to this variant
    Unknown,
}

impl CompositeMode {
    /// Create from a raw scalar.
    ///
    /// This will never fail; unknown values will be mapped to the `Unknown` variant
    pub fn new(raw: u8) -> Self {
        match raw {
            0 => Self::Clear,
            1 => Self::Src,
            2 => Self::Dest,
            3 => Self::SrcOver,
            4 => Self::DestOver,
            5 => Self::SrcIn,
            6 => Self::DestIn,
            7 => Self::SrcOut,
            8 => Self::DestOut,
            9 => Self::SrcAtop,
            10 => Self::DestAtop,
            11 => Self::Xor,
            12 => Self::Plus,
            13 => Self::Screen,
            14 => Self::Overlay,
            15 => Self::Darken,
            16 => Self::Lighten,
            17 => Self::ColorDodge,
            18 => Self::ColorBurn,
            19 => Self::HardLight,
            20 => Self::SoftLight,
            21 => Self::Difference,
            22 => Self::Exclusion,
            23 => Self::Multiply,
            24 => Self::HslHue,
            25 => Self::HslSaturation,
            26 => Self::HslColor,
            27 => Self::HslLuminosity,
            _ => Self::Unknown,
        }
    }
}

impl font_types::Scalar for CompositeMode {
    type Raw = <u8 as font_types::Scalar>::Raw;
    fn to_raw(self) -> Self::Raw {
        (self as u8).to_raw()
    }
    fn from_raw(raw: Self::Raw) -> Self {
        let t = <u8>::from_raw(raw);
        Self::new(t)
    }
}

Coverage Report

Created: 2026-10-28 07:26