/rust/registry/src/index.crates.io-1949cf8c6b5b557f/read-fonts-0.46.0/generated/generated_maxp.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 Maxp<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.num_glyphs_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 Maxp<'_> {
    /// `maxp`
    const TAG: Tag = Tag::new(b"maxp");
}

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

impl<'a> FontRead<'a> for Maxp<'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 MaxpFixedHeader {
    pub version: BigEndian<Version16Dot16>,
    pub num_glyphs: BigEndian<u16>,
}

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

/// [`maxp`](https://docs.microsoft.com/en-us/typography/opentype/spec/maxp)
#[derive(Clone)]
pub struct Maxp<'a> {
    data: TableDataRef<'a, MaxpFixedHeader>,
}

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

    /// The version: 0x00005000 for version 0.5, 0x00010000 for version 1.0.
    pub fn version(&self) -> Version16Dot16 {
        self.data.header().version.get()
    }

    /// The number of glyphs in the font.
    pub fn num_glyphs(&self) -> u16 {
        self.data.header().num_glyphs.get()
    }

    /// Maximum points in a non-composite glyph.
    pub fn max_points(&self) -> Option<u16> {
        let range = self.max_points_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum contours in a non-composite glyph.
    pub fn max_contours(&self) -> Option<u16> {
        let range = self.max_contours_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum points in a composite glyph.
    pub fn max_composite_points(&self) -> Option<u16> {
        let range = self.max_composite_points_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum contours in a composite glyph.
    pub fn max_composite_contours(&self) -> Option<u16> {
        let range = self.max_composite_contours_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// 1 if instructions do not use the twilight zone (Z0), or 2 if
    /// instructions do use Z0; should be set to 2 in most cases.
    pub fn max_zones(&self) -> Option<u16> {
        let range = self.max_zones_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum points used in Z0.
    pub fn max_twilight_points(&self) -> Option<u16> {
        let range = self.max_twilight_points_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of Storage Area locations.
    pub fn max_storage(&self) -> Option<u16> {
        let range = self.max_storage_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of FDEFs, equal to the highest function number + 1.
    pub fn max_function_defs(&self) -> Option<u16> {
        let range = self.max_function_defs_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of IDEFs.
    pub fn max_instruction_defs(&self) -> Option<u16> {
        let range = self.max_instruction_defs_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum stack depth across Font Program ('fpgm' table), CVT
    /// Program ('prep' table) and all glyph instructions (in the
    /// 'glyf' table).
    pub fn max_stack_elements(&self) -> Option<u16> {
        let range = self.max_stack_elements_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum byte count for glyph instructions.
    pub fn max_size_of_instructions(&self) -> Option<u16> {
        let range = self.max_size_of_instructions_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum number of components referenced at “top level” for
    /// any composite glyph.
    pub fn max_component_elements(&self) -> Option<u16> {
        let range = self.max_component_elements_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum levels of recursion; 1 for simple components.
    pub fn max_component_depth(&self) -> Option<u16> {
        let range = self.max_component_depth_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Default for Maxp<'_> {
    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 MaxpExtended<'a> {
    fn min_byte_range(&self) -> Range<usize> {
        0..self.num_glyphs_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 MaxpExtended<'_> {
    /// `MAXP`
    const TAG: Tag = Tag::new(b"MAXP");
}

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

impl<'a> FontRead<'a> for MaxpExtended<'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 MaxpExtendedFixedHeader {
    pub version: BigEndian<Version16Dot16>,
    pub num_glyphs: BigEndian<Uint24>,
}

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

/// MAXP maximum profile table (ISO/IEC 14496-22:2026, 5.1.12).
#[derive(Clone)]
pub struct MaxpExtended<'a> {
    data: TableDataRef<'a, MaxpExtendedFixedHeader>,
}

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

    pub fn version(&self) -> Version16Dot16 {
        self.data.header().version.get()
    }

    /// The number of glyphs in the font.
    pub fn num_glyphs(&self) -> Uint24 {
        self.data.header().num_glyphs.get()
    }

    /// Maximum points in a non-composite glyph.
    pub fn max_points(&self) -> Option<u16> {
        let range = self.max_points_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum contours in a non-composite glyph.
    pub fn max_contours(&self) -> Option<u16> {
        let range = self.max_contours_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum points in a composite glyph.
    pub fn max_composite_points(&self) -> Option<u16> {
        let range = self.max_composite_points_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum contours in a composite glyph.
    pub fn max_composite_contours(&self) -> Option<u16> {
        let range = self.max_composite_contours_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of zones used by instructions.
    pub fn max_zones(&self) -> Option<u16> {
        let range = self.max_zones_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum points in the twilight zone.
    pub fn max_twilight_points(&self) -> Option<u16> {
        let range = self.max_twilight_points_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of storage locations.
    pub fn max_storage(&self) -> Option<u16> {
        let range = self.max_storage_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of function definitions.
    pub fn max_function_defs(&self) -> Option<u16> {
        let range = self.max_function_defs_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Number of instruction definitions.
    pub fn max_instruction_defs(&self) -> Option<u16> {
        let range = self.max_instruction_defs_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum interpreter stack depth.
    pub fn max_stack_elements(&self) -> Option<u16> {
        let range = self.max_stack_elements_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum glyph instruction byte count.
    pub fn max_size_of_instructions(&self) -> Option<u16> {
        let range = self.max_size_of_instructions_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum top-level component count.
    pub fn max_component_elements(&self) -> Option<u16> {
        let range = self.max_component_elements_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

    /// Maximum component recursion depth.
    pub fn max_component_depth(&self) -> Option<u16> {
        let range = self.max_component_depth_byte_range();
        (!range.is_empty())
            .then(|| self.offset_data().read_at(range.start).ok())
            .flatten()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Coverage Report

Created: 2026-10-24 07:19

Line	Count	Source
1		// THIS FILE IS AUTOGENERATED.
2		// Any changes to this file will be overwritten.
3		// For more information about how codegen works, see font-codegen/README.md
4
5		#[allow(unused_imports)]
6		use crate::codegen_prelude::*;
7
8		impl<'a> MinByteRange<'a> for Maxp<'a> {
9	0	fn min_byte_range(&self) -> Range<usize> {
10	0	0..self.num_glyphs_byte_range().end
11	0	}
12	0	fn min_table_bytes(&self) -> &'a [u8] {
13	0	let range = self.min_byte_range();
14	0	self.offset_data().as_bytes().get(range).unwrap_or_default()
15	0	}
16		}
17
18		impl TopLevelTable for Maxp<'_> {
19		/// `maxp`
20		const TAG: Tag = Tag::new(b"maxp");
21		}
22
23		impl ReadArgs for Maxp<'_> {
24		type Args = ();
25		}
26
27		impl<'a> FontRead<'a> for Maxp<'a> {
28	7.45k	fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
29		#[allow(clippy::absurd_extreme_comparisons)]
30	7.45k	if data.len() < Self::MIN_SIZE {
31	3	return Err(ReadError::OutOfBounds);
32	7.45k	}
33	7.45k	let Some(data) = TableDataRef::new(data.as_bytes()) else {
34	0	return Err(ReadError::OutOfBounds);
35		};
36	7.45k	Ok(Self { data })
37	7.45k	}
38		}
39
40		/// The fields at the start of the table, which are read directly.
41		#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
42		#[repr(C, packed)]
43		#[doc(hidden)]
44		pub struct MaxpFixedHeader {
45		pub version: BigEndian<Version16Dot16>,
46		pub num_glyphs: BigEndian<u16>,
47		}
48
49		#[allow(clippy::absurd_extreme_comparisons)]
50		const _: () = assert!(std::mem::size_of::<MaxpFixedHeader>() <= Maxp::MIN_SIZE);
51
52		/// [`maxp`](https://docs.microsoft.com/en-us/typography/opentype/spec/maxp)
53		#[derive(Clone)]
54		pub struct Maxp<'a> {
55		data: TableDataRef<'a, MaxpFixedHeader>,
56		}
57
58		#[allow(clippy::needless_lifetimes)]
59		impl<'a> Maxp<'a> {
60		pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN + u16::RAW_BYTE_LEN);
61		basic_table_impls!(impl_the_methods);
62
63		/// The version: 0x00005000 for version 0.5, 0x00010000 for version 1.0.
64	0	pub fn version(&self) -> Version16Dot16 {
65	0	self.data.header().version.get()
66	0	}
67
68		/// The number of glyphs in the font.
69	7.45k	pub fn num_glyphs(&self) -> u16 {
70	7.45k	self.data.header().num_glyphs.get()
71	7.45k	}
72
73		/// Maximum points in a non-composite glyph.
74	0	pub fn max_points(&self) -> Option<u16> {
75	0	let range = self.max_points_byte_range();
76	0	(!range.is_empty())
77	0	.then(\|\| self.offset_data().read_at(range.start).ok())
78	0	.flatten()
79	0	}
80
81		/// Maximum contours in a non-composite glyph.
82	0	pub fn max_contours(&self) -> Option<u16> {
83	0	let range = self.max_contours_byte_range();
84	0	(!range.is_empty())
85	0	.then(\|\| self.offset_data().read_at(range.start).ok())
86	0	.flatten()
87	0	}
88
89		/// Maximum points in a composite glyph.
90	0	pub fn max_composite_points(&self) -> Option<u16> {
91	0	let range = self.max_composite_points_byte_range();
92	0	(!range.is_empty())
93	0	.then(\|\| self.offset_data().read_at(range.start).ok())
94	0	.flatten()
95	0	}
96
97		/// Maximum contours in a composite glyph.
98	0	pub fn max_composite_contours(&self) -> Option<u16> {
99	0	let range = self.max_composite_contours_byte_range();
100	0	(!range.is_empty())
101	0	.then(\|\| self.offset_data().read_at(range.start).ok())
102	0	.flatten()
103	0	}
104
105		/// 1 if instructions do not use the twilight zone (Z0), or 2 if
106		/// instructions do use Z0; should be set to 2 in most cases.
107	0	pub fn max_zones(&self) -> Option<u16> {
108	0	let range = self.max_zones_byte_range();
109	0	(!range.is_empty())
110	0	.then(\|\| self.offset_data().read_at(range.start).ok())
111	0	.flatten()
112	0	}
113
114		/// Maximum points used in Z0.
115	0	pub fn max_twilight_points(&self) -> Option<u16> {
116	0	let range = self.max_twilight_points_byte_range();
117	0	(!range.is_empty())
118	0	.then(\|\| self.offset_data().read_at(range.start).ok())
119	0	.flatten()
120	0	}
121
122		/// Number of Storage Area locations.
123	0	pub fn max_storage(&self) -> Option<u16> {
124	0	let range = self.max_storage_byte_range();
125	0	(!range.is_empty())
126	0	.then(\|\| self.offset_data().read_at(range.start).ok())
127	0	.flatten()
128	0	}
129
130		/// Number of FDEFs, equal to the highest function number + 1.
131	0	pub fn max_function_defs(&self) -> Option<u16> {
132	0	let range = self.max_function_defs_byte_range();
133	0	(!range.is_empty())
134	0	.then(\|\| self.offset_data().read_at(range.start).ok())
135	0	.flatten()
136	0	}
137
138		/// Number of IDEFs.
139	0	pub fn max_instruction_defs(&self) -> Option<u16> {
140	0	let range = self.max_instruction_defs_byte_range();
141	0	(!range.is_empty())
142	0	.then(\|\| self.offset_data().read_at(range.start).ok())
143	0	.flatten()
144	0	}
145
146		/// Maximum stack depth across Font Program ('fpgm' table), CVT
147		/// Program ('prep' table) and all glyph instructions (in the
148		/// 'glyf' table).
149	0	pub fn max_stack_elements(&self) -> Option<u16> {
150	0	let range = self.max_stack_elements_byte_range();
151	0	(!range.is_empty())
152	0	.then(\|\| self.offset_data().read_at(range.start).ok())
153	0	.flatten()
154	0	}
155
156		/// Maximum byte count for glyph instructions.
157	0	pub fn max_size_of_instructions(&self) -> Option<u16> {
158	0	let range = self.max_size_of_instructions_byte_range();
159	0	(!range.is_empty())
160	0	.then(\|\| self.offset_data().read_at(range.start).ok())
161	0	.flatten()
162	0	}
163
164		/// Maximum number of components referenced at “top level” for
165		/// any composite glyph.
166	0	pub fn max_component_elements(&self) -> Option<u16> {
167	0	let range = self.max_component_elements_byte_range();
168	0	(!range.is_empty())
169	0	.then(\|\| self.offset_data().read_at(range.start).ok())
170	0	.flatten()
171	0	}
172
173		/// Maximum levels of recursion; 1 for simple components.
174	0	pub fn max_component_depth(&self) -> Option<u16> {
175	0	let range = self.max_component_depth_byte_range();
176	0	(!range.is_empty())
177	0	.then(\|\| self.offset_data().read_at(range.start).ok())
178	0	.flatten()
179	0	}
180
181	0	pub fn version_byte_range(&self) -> Range<usize> {
182	0	let start = 0;
183	0	let end = start + Version16Dot16::RAW_BYTE_LEN;
184	0	start..end
185	0	}
186
187	0	pub fn num_glyphs_byte_range(&self) -> Range<usize> {
188	0	let start = self.version_byte_range().end;
189	0	let end = start + u16::RAW_BYTE_LEN;
190	0	start..end
191	0	}
192
193	0	pub fn max_points_byte_range(&self) -> Range<usize> {
194	0	let start = self.num_glyphs_byte_range().end;
195	0	let end = if self.version().compatible((1u16, 0u16)) {
196	0	start + u16::RAW_BYTE_LEN
197		} else {
198	0	start
199		};
200	0	start..end
201	0	}
202
203	0	pub fn max_contours_byte_range(&self) -> Range<usize> {
204	0	let start = self.max_points_byte_range().end;
205	0	let end = if self.version().compatible((1u16, 0u16)) {
206	0	start + u16::RAW_BYTE_LEN
207		} else {
208	0	start
209		};
210	0	start..end
211	0	}
212
213	0	pub fn max_composite_points_byte_range(&self) -> Range<usize> {
214	0	let start = self.max_contours_byte_range().end;
215	0	let end = if self.version().compatible((1u16, 0u16)) {
216	0	start + u16::RAW_BYTE_LEN
217		} else {
218	0	start
219		};
220	0	start..end
221	0	}
222
223	0	pub fn max_composite_contours_byte_range(&self) -> Range<usize> {
224	0	let start = self.max_composite_points_byte_range().end;
225	0	let end = if self.version().compatible((1u16, 0u16)) {
226	0	start + u16::RAW_BYTE_LEN
227		} else {
228	0	start
229		};
230	0	start..end
231	0	}
232
233	0	pub fn max_zones_byte_range(&self) -> Range<usize> {
234	0	let start = self.max_composite_contours_byte_range().end;
235	0	let end = if self.version().compatible((1u16, 0u16)) {
236	0	start + u16::RAW_BYTE_LEN
237		} else {
238	0	start
239		};
240	0	start..end
241	0	}
242
243	0	pub fn max_twilight_points_byte_range(&self) -> Range<usize> {
244	0	let start = self.max_zones_byte_range().end;
245	0	let end = if self.version().compatible((1u16, 0u16)) {
246	0	start + u16::RAW_BYTE_LEN
247		} else {
248	0	start
249		};
250	0	start..end
251	0	}
252
253	0	pub fn max_storage_byte_range(&self) -> Range<usize> {
254	0	let start = self.max_twilight_points_byte_range().end;
255	0	let end = if self.version().compatible((1u16, 0u16)) {
256	0	start + u16::RAW_BYTE_LEN
257		} else {
258	0	start
259		};
260	0	start..end
261	0	}
262
263	0	pub fn max_function_defs_byte_range(&self) -> Range<usize> {
264	0	let start = self.max_storage_byte_range().end;
265	0	let end = if self.version().compatible((1u16, 0u16)) {
266	0	start + u16::RAW_BYTE_LEN
267		} else {
268	0	start
269		};
270	0	start..end
271	0	}
272
273	0	pub fn max_instruction_defs_byte_range(&self) -> Range<usize> {
274	0	let start = self.max_function_defs_byte_range().end;
275	0	let end = if self.version().compatible((1u16, 0u16)) {
276	0	start + u16::RAW_BYTE_LEN
277		} else {
278	0	start
279		};
280	0	start..end
281	0	}
282
283	0	pub fn max_stack_elements_byte_range(&self) -> Range<usize> {
284	0	let start = self.max_instruction_defs_byte_range().end;
285	0	let end = if self.version().compatible((1u16, 0u16)) {
286	0	start + u16::RAW_BYTE_LEN
287		} else {
288	0	start
289		};
290	0	start..end
291	0	}
292
293	0	pub fn max_size_of_instructions_byte_range(&self) -> Range<usize> {
294	0	let start = self.max_stack_elements_byte_range().end;
295	0	let end = if self.version().compatible((1u16, 0u16)) {
296	0	start + u16::RAW_BYTE_LEN
297		} else {
298	0	start
299		};
300	0	start..end
301	0	}
302
303	0	pub fn max_component_elements_byte_range(&self) -> Range<usize> {
304	0	let start = self.max_size_of_instructions_byte_range().end;
305	0	let end = if self.version().compatible((1u16, 0u16)) {
306	0	start + u16::RAW_BYTE_LEN
307		} else {
308	0	start
309		};
310	0	start..end
311	0	}
312
313	0	pub fn max_component_depth_byte_range(&self) -> Range<usize> {
314	0	let start = self.max_component_elements_byte_range().end;
315	0	let end = if self.version().compatible((1u16, 0u16)) {
316	0	start + u16::RAW_BYTE_LEN
317		} else {
318	0	start
319		};
320	0	start..end
321	0	}
322		}
323
324		const _: () = assert!(FontData::default_data_long_enough(Maxp::MIN_SIZE));
325
326		impl Default for Maxp<'_> {
327	0	fn default() -> Self {
328		Self {
329	0	data: TableDataRef::new(FontData::default_table_data().as_bytes())
330	0	.unwrap_or_else(\|\| unreachable!("the default data covers MIN_SIZE")),
331		}
332	0	}
333		}
334
335		impl<'a> MinByteRange<'a> for MaxpExtended<'a> {
336	0	fn min_byte_range(&self) -> Range<usize> {
337	0	0..self.num_glyphs_byte_range().end
338	0	}
339	0	fn min_table_bytes(&self) -> &'a [u8] {
340	0	let range = self.min_byte_range();
341	0	self.offset_data().as_bytes().get(range).unwrap_or_default()
342	0	}
343		}
344
345		impl TopLevelTable for MaxpExtended<'_> {
346		/// `MAXP`
347		const TAG: Tag = Tag::new(b"MAXP");
348		}
349
350		impl ReadArgs for MaxpExtended<'_> {
351		type Args = ();
352		}
353
354		impl<'a> FontRead<'a> for MaxpExtended<'a> {
355	28	fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
356		#[allow(clippy::absurd_extreme_comparisons)]
357	28	if data.len() < Self::MIN_SIZE {
358	5	return Err(ReadError::OutOfBounds);
359	23	}
360	23	let Some(data) = TableDataRef::new(data.as_bytes()) else {
361	0	return Err(ReadError::OutOfBounds);
362		};
363	23	Ok(Self { data })
364	28	}
365		}
366
367		/// The fields at the start of the table, which are read directly.
368		#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
369		#[repr(C, packed)]
370		#[doc(hidden)]
371		pub struct MaxpExtendedFixedHeader {
372		pub version: BigEndian<Version16Dot16>,
373		pub num_glyphs: BigEndian<Uint24>,
374		}
375
376		#[allow(clippy::absurd_extreme_comparisons)]
377		const _: () = assert!(std::mem::size_of::<MaxpExtendedFixedHeader>() <= MaxpExtended::MIN_SIZE);
378
379		/// MAXP maximum profile table (ISO/IEC 14496-22:2026, 5.1.12).
380		#[derive(Clone)]
381		pub struct MaxpExtended<'a> {
382		data: TableDataRef<'a, MaxpExtendedFixedHeader>,
383		}
384
385		#[allow(clippy::needless_lifetimes)]
386		impl<'a> MaxpExtended<'a> {
387		pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN + Uint24::RAW_BYTE_LEN);
388		basic_table_impls!(impl_the_methods);
389
390	0	pub fn version(&self) -> Version16Dot16 {
391	0	self.data.header().version.get()
392	0	}
393
394		/// The number of glyphs in the font.
395	23	pub fn num_glyphs(&self) -> Uint24 {
396	23	self.data.header().num_glyphs.get()
397	23	}
398
399		/// Maximum points in a non-composite glyph.
400	0	pub fn max_points(&self) -> Option<u16> {
401	0	let range = self.max_points_byte_range();
402	0	(!range.is_empty())
403	0	.then(\|\| self.offset_data().read_at(range.start).ok())
404	0	.flatten()
405	0	}
406
407		/// Maximum contours in a non-composite glyph.
408	0	pub fn max_contours(&self) -> Option<u16> {
409	0	let range = self.max_contours_byte_range();
410	0	(!range.is_empty())
411	0	.then(\|\| self.offset_data().read_at(range.start).ok())
412	0	.flatten()
413	0	}
414
415		/// Maximum points in a composite glyph.
416	0	pub fn max_composite_points(&self) -> Option<u16> {
417	0	let range = self.max_composite_points_byte_range();
418	0	(!range.is_empty())
419	0	.then(\|\| self.offset_data().read_at(range.start).ok())
420	0	.flatten()
421	0	}
422
423		/// Maximum contours in a composite glyph.
424	0	pub fn max_composite_contours(&self) -> Option<u16> {
425	0	let range = self.max_composite_contours_byte_range();
426	0	(!range.is_empty())
427	0	.then(\|\| self.offset_data().read_at(range.start).ok())
428	0	.flatten()
429	0	}
430
431		/// Number of zones used by instructions.
432	0	pub fn max_zones(&self) -> Option<u16> {
433	0	let range = self.max_zones_byte_range();
434	0	(!range.is_empty())
435	0	.then(\|\| self.offset_data().read_at(range.start).ok())
436	0	.flatten()
437	0	}
438
439		/// Maximum points in the twilight zone.
440	0	pub fn max_twilight_points(&self) -> Option<u16> {
441	0	let range = self.max_twilight_points_byte_range();
442	0	(!range.is_empty())
443	0	.then(\|\| self.offset_data().read_at(range.start).ok())
444	0	.flatten()
445	0	}
446
447		/// Number of storage locations.
448	0	pub fn max_storage(&self) -> Option<u16> {
449	0	let range = self.max_storage_byte_range();
450	0	(!range.is_empty())
451	0	.then(\|\| self.offset_data().read_at(range.start).ok())
452	0	.flatten()
453	0	}
454
455		/// Number of function definitions.
456	0	pub fn max_function_defs(&self) -> Option<u16> {
457	0	let range = self.max_function_defs_byte_range();
458	0	(!range.is_empty())
459	0	.then(\|\| self.offset_data().read_at(range.start).ok())
460	0	.flatten()
461	0	}
462
463		/// Number of instruction definitions.
464	0	pub fn max_instruction_defs(&self) -> Option<u16> {
465	0	let range = self.max_instruction_defs_byte_range();
466	0	(!range.is_empty())
467	0	.then(\|\| self.offset_data().read_at(range.start).ok())
468	0	.flatten()
469	0	}
470
471		/// Maximum interpreter stack depth.
472	0	pub fn max_stack_elements(&self) -> Option<u16> {
473	0	let range = self.max_stack_elements_byte_range();
474	0	(!range.is_empty())
475	0	.then(\|\| self.offset_data().read_at(range.start).ok())
476	0	.flatten()
477	0	}
478
479		/// Maximum glyph instruction byte count.
480	0	pub fn max_size_of_instructions(&self) -> Option<u16> {
481	0	let range = self.max_size_of_instructions_byte_range();
482	0	(!range.is_empty())
483	0	.then(\|\| self.offset_data().read_at(range.start).ok())
484	0	.flatten()
485	0	}
486
487		/// Maximum top-level component count.
488	0	pub fn max_component_elements(&self) -> Option<u16> {
489	0	let range = self.max_component_elements_byte_range();
490	0	(!range.is_empty())
491	0	.then(\|\| self.offset_data().read_at(range.start).ok())
492	0	.flatten()
493	0	}
494
495		/// Maximum component recursion depth.
496	0	pub fn max_component_depth(&self) -> Option<u16> {
497	0	let range = self.max_component_depth_byte_range();
498	0	(!range.is_empty())
499	0	.then(\|\| self.offset_data().read_at(range.start).ok())
500	0	.flatten()
501	0	}
502
503	0	pub fn version_byte_range(&self) -> Range<usize> {
504	0	let start = 0;
505	0	let end = start + Version16Dot16::RAW_BYTE_LEN;
506	0	start..end
507	0	}
508
509	0	pub fn num_glyphs_byte_range(&self) -> Range<usize> {
510	0	let start = self.version_byte_range().end;
511	0	let end = start + Uint24::RAW_BYTE_LEN;
512	0	start..end
513	0	}
514
515	0	pub fn max_points_byte_range(&self) -> Range<usize> {
516	0	let start = self.num_glyphs_byte_range().end;
517	0	let end = if self.version().compatible((1u16, 0u16)) {
518	0	start + u16::RAW_BYTE_LEN
519		} else {
520	0	start
521		};
522	0	start..end
523	0	}
524
525	0	pub fn max_contours_byte_range(&self) -> Range<usize> {
526	0	let start = self.max_points_byte_range().end;
527	0	let end = if self.version().compatible((1u16, 0u16)) {
528	0	start + u16::RAW_BYTE_LEN
529		} else {
530	0	start
531		};
532	0	start..end
533	0	}
534
535	0	pub fn max_composite_points_byte_range(&self) -> Range<usize> {
536	0	let start = self.max_contours_byte_range().end;
537	0	let end = if self.version().compatible((1u16, 0u16)) {
538	0	start + u16::RAW_BYTE_LEN
539		} else {
540	0	start
541		};
542	0	start..end
543	0	}
544
545	0	pub fn max_composite_contours_byte_range(&self) -> Range<usize> {
546	0	let start = self.max_composite_points_byte_range().end;
547	0	let end = if self.version().compatible((1u16, 0u16)) {
548	0	start + u16::RAW_BYTE_LEN
549		} else {
550	0	start
551		};
552	0	start..end
553	0	}
554
555	0	pub fn max_zones_byte_range(&self) -> Range<usize> {
556	0	let start = self.max_composite_contours_byte_range().end;
557	0	let end = if self.version().compatible((1u16, 0u16)) {
558	0	start + u16::RAW_BYTE_LEN
559		} else {
560	0	start
561		};
562	0	start..end
563	0	}
564
565	0	pub fn max_twilight_points_byte_range(&self) -> Range<usize> {
566	0	let start = self.max_zones_byte_range().end;
567	0	let end = if self.version().compatible((1u16, 0u16)) {
568	0	start + u16::RAW_BYTE_LEN
569		} else {
570	0	start
571		};
572	0	start..end
573	0	}
574
575	0	pub fn max_storage_byte_range(&self) -> Range<usize> {
576	0	let start = self.max_twilight_points_byte_range().end;
577	0	let end = if self.version().compatible((1u16, 0u16)) {
578	0	start + u16::RAW_BYTE_LEN
579		} else {
580	0	start
581		};
582	0	start..end
583	0	}
584
585	0	pub fn max_function_defs_byte_range(&self) -> Range<usize> {
586	0	let start = self.max_storage_byte_range().end;
587	0	let end = if self.version().compatible((1u16, 0u16)) {
588	0	start + u16::RAW_BYTE_LEN
589		} else {
590	0	start
591		};
592	0	start..end
593	0	}
594
595	0	pub fn max_instruction_defs_byte_range(&self) -> Range<usize> {
596	0	let start = self.max_function_defs_byte_range().end;
597	0	let end = if self.version().compatible((1u16, 0u16)) {
598	0	start + u16::RAW_BYTE_LEN
599		} else {
600	0	start
601		};
602	0	start..end
603	0	}
604
605	0	pub fn max_stack_elements_byte_range(&self) -> Range<usize> {
606	0	let start = self.max_instruction_defs_byte_range().end;
607	0	let end = if self.version().compatible((1u16, 0u16)) {
608	0	start + u16::RAW_BYTE_LEN
609		} else {
610	0	start
611		};
612	0	start..end
613	0	}
614
615	0	pub fn max_size_of_instructions_byte_range(&self) -> Range<usize> {
616	0	let start = self.max_stack_elements_byte_range().end;
617	0	let end = if self.version().compatible((1u16, 0u16)) {
618	0	start + u16::RAW_BYTE_LEN
619		} else {
620	0	start
621		};
622	0	start..end
623	0	}
624
625	0	pub fn max_component_elements_byte_range(&self) -> Range<usize> {
626	0	let start = self.max_size_of_instructions_byte_range().end;
627	0	let end = if self.version().compatible((1u16, 0u16)) {
628	0	start + u16::RAW_BYTE_LEN
629		} else {
630	0	start
631		};
632	0	start..end
633	0	}
634
635	0	pub fn max_component_depth_byte_range(&self) -> Range<usize> {
636	0	let start = self.max_component_elements_byte_range().end;
637	0	let end = if self.version().compatible((1u16, 0u16)) {
638	0	start + u16::RAW_BYTE_LEN
639		} else {
640	0	start
641		};
642	0	start..end
643	0	}
644		}
645
646		const _: () = assert!(FontData::default_data_long_enough(MaxpExtended::MIN_SIZE));
647
648		impl Default for MaxpExtended<'_> {
649	0	fn default() -> Self {
650		Self {
651	0	data: TableDataRef::new(FontData::default_table_data().as_bytes())
652	0	.unwrap_or_else(\|\| unreachable!("the default data covers MIN_SIZE")),
653		}
654	0	}
655		}