#![deny(missing_docs)]

//! Parsing and writing of the `glyf` table.

//!

//! > This table contains information that describes the glyphs in the font in the TrueType outline

//! > format. Information regarding the rasterizer (scaler) refers to the TrueType rasterizer.

//!

//! — <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf>

mod outline;

mod subset;

mod variation;

use std::mem;

use std::sync::Arc;

use log::warn;

use pathfinder_geometry::transform2d::Matrix2x2F;

use pathfinder_geometry::vector::Vector2F;

use rustc_hash::FxHashMap;

use crate::binary::read::{

    ReadBinary, ReadBinaryDep, ReadCtxt, ReadFrom, ReadScope, ReadUnchecked,

};

use crate::binary::write::{WriteBinary, WriteBinaryDep, WriteContext};

use crate::binary::{word_align, I16Be, U16Be, I8, U8};

use crate::error::{ParseError, WriteError};

use crate::tables::loca::{owned, LocaTable};

use crate::tables::os2::Os2;

use crate::tables::{

    read_and_box_table, F2Dot14, FontTableProvider, HeadTable, HheaTable, HmtxTable,

    IndexToLocFormat, MaxpTable,

};

use crate::{tag, SafeFrom};

pub use outline::{GlyfVisitorContext, VariableGlyfContext, VariableGlyfContextStore};

pub use subset::SubsetGlyph;

/// Recursion limit for nested composite glyphs

///

/// "There is no minimum nesting depth that must be supported" so we use the same value as Harfbuzz.

#[allow(unused)]

const COMPOSITE_GLYPH_RECURSION_LIMIT: u8 = 6;

/// Flags for [simple glyphs](https://learn.microsoft.com/en-us/typography/opentype/spec/glyf#simple-glyph-description)

#[enumflags2::bitflags]

#[repr(u8)]

#[derive(Debug, Clone, Copy, Eq, PartialEq)]

#[allow(non_camel_case_types)]

pub enum SimpleGlyphFlag {

    /// Bit 0: If set, the point is on the curve; otherwise, it is off the curve.

    ON_CURVE_POINT = 0b00000001,

    /// Bit 1: If set, the corresponding x-coordinate is 1 byte long, and the sign is determined

    /// by the `X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR` flag.

    X_SHORT_VECTOR = 0b00000010,

    /// Bit 2: If set, the corresponding y-coordinate is 1 byte long, and the sign is determined

    /// by the `Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR` flag.

    Y_SHORT_VECTOR = 0b00000100,

    /// Bit 3: If set, the next byte (or bytes) specifies the number of additional times this

    /// flag byte is to be repeated — the number of additional logical flags inserted after this flag.

    REPEAT_FLAG = 0b00001000,

    /// Bit 4: This flag has two meanings, depending on the `X_SHORT_VECTOR` flag.

    X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR = 0b00010000,

    /// Bit 5: This flag has two meanings, depending on the `Y_SHORT_VECTOR` flag.

    Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR = 0b00100000,

}

/// A set of `SimpleGlyphFlag` flags.

pub type SimpleGlyphFlags = enumflags2::BitFlags<SimpleGlyphFlag>;

/// Flags for [composite glyphs](https://learn.microsoft.com/en-us/typography/opentype/spec/glyf#composite-glyph-description)

#[enumflags2::bitflags]

#[repr(u16)]

#[derive(Debug, Clone, Copy, Eq, PartialEq)]

#[allow(non_camel_case_types)]

pub enum CompositeGlyphFlag {

    /// Bit 0: If this is set, the arguments are 16-bit (uint16 or int16); otherwise, they are

    /// bytes (uint8 or int8).

    ARG_1_AND_2_ARE_WORDS = 0x0001,

    /// Bit 1: If this is set, the arguments are signed xy values; otherwise, they are unsigned

    /// point numbers.

    ARGS_ARE_XY_VALUES = 0x0002,

    /// Bit 2: For the xy values if the preceding is true.

    ROUND_XY_TO_GRID = 0x0004,

    /// Bit 3: This indicates that there is a simple scale for the component.

    ///

    /// Otherwise, scale = 1.0.

    WE_HAVE_A_SCALE = 0x0008,

    /// Bit 4: Reserved, set to 0

    /// Bit 5: Indicates at least one more glyph after this one.

    MORE_COMPONENTS = 0x0020,

    /// Bit 6: The x direction will use a different scale from the y direction.

    WE_HAVE_AN_X_AND_Y_SCALE = 0x0040,

    /// Bit 7: There is a 2 by 2 transformation that will be used to scale the component.

    WE_HAVE_A_TWO_BY_TWO = 0x0080,

    /// Bit 8: Following the last component are instructions for the composite character.

    WE_HAVE_INSTRUCTIONS = 0x0100,

    /// Bit 9: If set, this forces the aw and lsb (and rsb) for the composite to be equal to

    /// those from this original glyph. This works for hinted and unhinted characters.

    USE_MY_METRICS = 0x0200,

    /// Bit 10: If set, the components of the compound glyph overlap.

    ///

    /// Use of this flag is not required in OpenType — that is, it is valid to have components

    /// overlap without having this flag set. It may affect behaviors in some platforms,

    /// however. (See Apple’s specification for details regarding behavior in Apple platforms.)

    /// When used, it must be set on the flag word for the first component. See additional

    /// remarks, above, for the similar OVERLAP_SIMPLE flag used in simple-glyph descriptions.

    OVERLAP_COMPOUND = 0x0400,

    /// Bit 11: The composite is designed to have the component offset scaled.

    SCALED_COMPONENT_OFFSET = 0x0800,

    /// Bit 12: The composite is designed not to have the component offset scaled.

    UNSCALED_COMPONENT_OFFSET = 0x1000,

    // 0xE010 	Reserved 	Bits 4, 13, 14 and 15 are reserved: set to 0.

}

/// A set of `CompositeGlyphFlag` flags.

pub type CompositeGlyphFlags = enumflags2::BitFlags<CompositeGlyphFlag>;

/// `glyf` table

///

/// This table contains glyph outlines. Functionality is provided for reading glyphs,

/// serializing to a `glyf` table, and subsetting.

///

/// **See also:** [LocaGlyf].<br>

/// **Reference:** <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf>

#[derive(Debug, PartialEq)]

pub struct GlyfTable<'a> {

    records: Vec<GlyfRecord<'a>>,

}

/// Alternate representation of `glyf` table

///

/// This is an alternate structure for the `glyf` table that combines `glyf` and

/// `loca` data together. This makes it easier to access glyphs. `LocaGlyph` also

/// contains a glyph cache so repeated calls to [glyph][Self::glyph] will only

/// fetch and parse the glyph once.

///

/// `LocaGlyf` also implements [OutlineBuilder][crate::outline::OutlineBuilder],

/// which allows the outline of the glyph to be visited.

///

/// **Reference:** <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf>

pub struct LocaGlyf {

    /// Flag that indicates whether this structure has been loaded.

    ///

    /// This allows and empty version of the table to be created, removing the need

    /// to wrap an unloaded table in Option or similar.

    loaded: bool,

    /// Data from `loca` table.

    loca: owned::LocaTable,

    /// Raw `glyf` table data (owned copy, or a zero-copy view into shared

    /// already-resident font bytes — see [`GlyfBytes`]).

    glyf: GlyfBytes,

    /// Cache of parsed glyphs indexed by glyph ID.

    cache: FxHashMap<u16, Arc<Glyph>>,

}

/// Backing storage for the `glyf` table.

///

/// The classic path copies the whole `glyf` table onto the heap

/// ([`GlyfBytes::Owned`]) — for a large font (e.g. a CJK or macOS system

/// `.ttc`) that is a ~20-40 MB allocation kept for the font's lifetime, even

/// though the source bytes are usually already resident (mmap'd) elsewhere.

/// [`GlyfBytes::Shared`] instead keeps an `Arc` to those source bytes plus the

/// `glyf` table's `(offset, len)`, so no copy is made. See

/// [`LocaGlyf::load_shared`].

pub enum GlyfBytes {

    /// Owned heap copy of the `glyf` table.

    Owned(Box<[u8]>),

    /// Zero-copy view: `owner.as_ref()[offset..offset + len]` is the `glyf`

    /// table. `owner` keeps the whole font buffer alive.

    Shared {

        /// The font buffer the `glyf` table lives inside; kept alive so the

        /// view stays valid.

        owner: Arc<dyn AsRef<[u8]> + Send + Sync>,

        /// Byte offset of the `glyf` table within `owner`.

        offset: usize,

        /// Length of the `glyf` table in bytes.

        len: usize,

    },

}

impl GlyfBytes {

    /// The `glyf` table bytes.

    #[inline]

                // Bounds were validated at construction (`load_shared`); clamp

                // defensively so a bad range degrades to a short read (parse

                // error) rather than a panic.

            }

        }

}

impl From<Box<[u8]>> for GlyfBytes {

}

/// If `table` is a sub-slice that lives inside `owner`'s allocation, return its

/// `(offset, len)` within `owner`; otherwise `None` (the provider returned an

/// owned/relocated copy, so a zero-copy view is impossible). Uses address-range

/// containment — valid because a `Cow::Borrowed` from a table provider points

/// directly into the font buffer `owner` wraps.

    // Must lie fully within owner. (A zero-length table has no address to

    // anchor and isn't worth sharing — fall back to Owned.)

/// A record from the `glyf` table that maybe parsed

#[derive(Debug, PartialEq, Clone)]

pub enum GlyfRecord<'a> {

    /// An unparsed glyph

    Present {

        /// The number of contours of this glyph

        ///

        /// - Zero for empty glyphs

        /// - Negative for composite glyphs

        number_of_contours: i16,

        /// A scope for parsing the glyph

        scope: ReadScope<'a>,

    },

    /// A parsed glyph

    Parsed(Glyph),

}

/// Storage for [phantom points](https://learn.microsoft.com/en-us/typography/opentype/spec/tt_instructing_glyphs#phantoms)

pub type PhantomPoints = [Point; 4];

/// A single glyph

#[derive(Debug, PartialEq, Clone)]

pub enum Glyph {

    /// A glyph with no outline

    Empty(EmptyGlyph),

    /// A glyph with an outline

    Simple(SimpleGlyph),

    /// A glyph composed of other glyphs

    Composite(CompositeGlyph),

}

/// A glyph with no outline

#[derive(Debug, PartialEq, Clone)]

pub struct EmptyGlyph {

    /// The [phantom points](https://learn.microsoft.com/en-us/typography/opentype/spec/tt_instructing_glyphs#phantoms) of this glyph

    pub phantom_points: Option<PhantomPoints>,

}

/// A glyph with an outline

#[derive(Debug, PartialEq, Clone)]

pub struct SimpleGlyph {

    /// The bounding box of this glyph

    pub bounding_box: BoundingBox,

    /// The end points of the contours of this glyph

    ///

    /// Array of point indices for the last point of each contour, in increasing numeric order.

    pub end_pts_of_contours: Vec<u16>,

    /// Hinting instruction byte code

    pub instructions: Box<[u8]>,

    /// Contour point coordinates

    pub coordinates: Vec<(SimpleGlyphFlags, Point)>,

    /// Phantom points, only populated when applying glyph variation deltas

    pub phantom_points: Option<Box<PhantomPoints>>,

}

/// A glyph composed from other glyphs

#[derive(Debug, PartialEq, Clone)]

pub struct CompositeGlyph {

    /// The bounding box of this glyph

    pub bounding_box: BoundingBox,

    /// The glyph components

    pub glyphs: Vec<CompositeGlyphComponent>,

    /// Hinting instruction byte code

    pub instructions: Box<[u8]>,

    /// Phantom points, only populated when applying glyph variation deltas

    pub phantom_points: Option<Box<PhantomPoints>>,

}

/// A component of a [CompositeGlyph]

#[derive(Debug, PartialEq, Clone)]

pub struct CompositeGlyphComponent {

    /// Flags for this component

    pub flags: CompositeGlyphFlags,

    /// The index of the child glyph for this component

    pub glyph_index: u16,

    /// First argument

    ///

    /// Meaning depends on `flags`

    pub argument1: CompositeGlyphArgument,

    /// Second argument

    ///

    /// Meaning depends on `flags`

    pub argument2: CompositeGlyphArgument,

    /// Optional scale applied to this child component

    pub scale: Option<CompositeGlyphScale>,

}

/// Variable size composite glyph argument

#[allow(missing_docs)]

#[derive(Debug, PartialEq, Copy, Clone)]

pub enum CompositeGlyphArgument {

    U8(u8),

    I8(i8),

    U16(u16),

    I16(i16),

}

/// A scale applied to a [CompositeGlyphComponent]

#[derive(Debug, PartialEq, Copy, Clone)]

pub enum CompositeGlyphScale {

    /// Simple scale for the component

    Scale(F2Dot14),

    /// Separate X and Y scales

    XY {

        /// The X scale

        x_scale: F2Dot14,

        /// The Y scale

        y_scale: F2Dot14,

    },

    /// A 2 by 2 transformation that will be used to scale the component

    Matrix([[F2Dot14; 2]; 2]),

}

/// Wrapper for composite glyph components

pub struct CompositeGlyphs {

    /// The child components

    pub glyphs: Vec<CompositeGlyphComponent>,

    /// Flag indicating if there are hinting instructions for this glyph

    pub have_instructions: bool,

}

/// An (x, y) point

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

pub struct Point(pub i16, pub i16);

/// Glyph bounding box

#[derive(Debug, PartialEq, Copy, Clone)]

pub struct BoundingBox {

    /// X minimum

    pub x_min: i16,

    /// X maximum

    pub x_max: i16,

    /// Y minimum

    pub y_min: i16,

    /// Y maximum

    pub y_max: i16,

}

impl ReadBinaryDep for GlyfTable<'_> {

    type Args<'a> = &'a LocaTable<'a>;

    type HostType<'a> = GlyfTable<'a>;

                // NOTE(unwrap): Bounded by `loca.offsets.len() - 1`, both

                // indices are guaranteed in range.

                        }

                        Err(ParseError::BadEof) => {

                            // The length specified by `loca` is beyond the end of the `glyf`

                            // table. Try parsing the glyph without a length limit to see if it's

                            // valid. This is a workaround for a font where the last `loca` offset

                            // was incorrectly 1 byte beyond the end of the `glyf` table but the

                            // actual glyph data was valid.

                        }

                    }

                }

}

impl<'a> WriteBinaryDep<Self> for GlyfTable<'a> {

    type Output = owned::LocaTable;

    type Args = IndexToLocFormat;

    /// Write this glyf table into `ctxt`.

    ///

    /// ## A Note About Padding

    ///

    /// On the [loca table documentation](https://docs.microsoft.com/en-us/typography/opentype/spec/loca#long-version)

    /// at the bottom it states:

    ///

    /// > Note that the local offsets should be 32-bit aligned. Offsets which are not 32-bit

    /// > aligned may seriously degrade performance of some processors.

    ///

    /// On the [Recommendations for OpenType Fonts](https://docs.microsoft.com/en-us/typography/opentype/spec/recom#loca-table)

    /// page it states:

    ///

    /// > We recommend that local offsets should be 16-bit aligned, in both the short and long

    /// > formats of this table.

    ///

    /// On [Apple's loca documentation](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6loca.html)

    /// it says:

    ///

    /// > The glyph data is always word aligned.

    ///

    /// Elsewhere in the Apple docs they refer to long as 32-bits, so assuming word here means

    /// 16-bits.

    ///

    /// [An issue](https://github.com/MicrosoftDocs/typography-issues/issues/241) was raised against

    /// Microsoft's docs regarding this.

    /// Behdad Esfahbod [commented](https://github.com/MicrosoftDocs/typography-issues/issues/241#issuecomment-495265379):

    ///

    /// > All the requirements should be removed since 2019.

    /// >

    /// > In reality, in the short format, you are forced to do 16-bit alignment because of how

    /// > offsets are stored. In the long format, use alignment 1. We've been doing that in

    /// > fonttools for years and never ever heard a complaint whatsoever.

    ///

    /// So with this in mind we implement 16-bit alignment when `index_to_loc_format` is 0,

    /// and no alignment/padding otherwise.

            }

        }

        // Add the final loca entry

}

impl Glyph {

    /// Construct a new empty glyph

    /// The number of contours of this glyph

    ///

    /// - Zero for empty glyphs

    /// - Negative for composite glyphs

        }

    /// Returns the bounding box of the glyph.

    ///

    /// Returns `None` if the glyph is an [EmptyGlyph].

        }

    /// Returns the phantom points of the glyph.

    ///

    /// Returns `None` if the phantom points have not been assigned through glyph variation.

            }

        }

    /// The number of delta adjustable points in this glyph excluding phantom points.

        }

}

/// Calculate the phantom points from the glyph.

///

/// Requires that the bounding box of the glyph is accurate/up-to-date.

    // In a font with TrueType outlines, xMin and xMax values for each glyph are given in the

    // 'glyf' table. The advance width (“aw”) and left side bearing (“lsb”) can be derived from

    // the glyph “phantom points”.

    //

    // If pp1 and pp2 are TrueType phantom points used to control lsb and rsb, their initial

    // position in the X-direction is calculated as follows:

    //

    // pp1 = xMin - lsb

    // pp2 = pp1 + aw

    //

    // If a glyph has no contours, xMax/xMin are not defined. The left side bearing indicated

    // in the 'hmtx' table for such glyphs should be zero.

    //

    // https://learn.microsoft.com/en-us/typography/opentype/spec/hmtx

    //

    // See also notes in FreeType:

    // https://gitlab.freedesktop.org/freetype/freetype/-/blob/7d45cf2c8f219263c5b9d84763a9a101138b0ed1/src/truetype/ttgload.c#L1280-1363

        // Fall back on OS/2 table if vmtx table is not present

        None => {

                };

        }

    };

impl ReadBinary for Glyph {

    type HostType<'a> = Glyph;

            // Simple glyph

            // Cast is safe as we've checked value is positive above

        } else {

            // Composite glyph

        }

}

impl WriteBinary for Glyph {

    type Output = ();

        }

}

impl SimpleGlyph {

    /// The number of contours in this glyph

        // TODO: Revisit this to see how we might enforce its validity

        // In theory there could be more than i16::MAX items in end_pts_of_contours

    /// Iterator over the contours of this glyph

    /// The bounding box of this glyph

}

impl ReadBinaryDep for SimpleGlyph {

    type Args<'a> = u16;

    type HostType<'a> = SimpleGlyph;

        // end_pts_of_contours stores the index of the end points.

        // Therefore the number of coordinates is the last index + 1

        // Read all the flags

        }

        // Read the x coordinates

            } else {

            }

        }

        // Read y coordinates, updating the Points in `coordinates`

            } else {

            };

            // The x and y coordinates are stored as deltas against the previous point, with the

            // first one being implicitly against (0, 0). Here we resolve these deltas into

            // absolute (x, y) values.

        }

}

impl WriteBinary for SimpleGlyph {

    type Output = ();

        // Flags and coordinates are written without any attempt to compact them using

        // smaller representation, use of REPEAT, or X/Y_IS_SAME.

        // TODO: try to compact the values written

        // flags

        }

        // x coordinates

        }

        // y coordinates

        }

}

impl ReadFrom for SimpleGlyphFlags {

    type ReadType = U8;

}

impl ReadBinary for CompositeGlyphs {

    type HostType<'a> = Self;

        loop {

        }

}

impl ReadBinary for CompositeGlyph {

    type HostType<'a> = CompositeGlyph;

        } else {

        };

}

impl WriteBinary for CompositeGlyph {

    type Output = ();

        }

}

#[allow(missing_docs)]

pub trait SimpleGlyphFlagExt {

    fn is_on_curve(self) -> bool;

    fn x_is_short(self) -> bool;

    fn y_is_short(self) -> bool;

    fn is_repeated(self) -> bool;

    fn x_short_sign(self) -> i16;

    fn y_short_sign(self) -> i16;

    fn x_is_same_or_positive(self) -> bool;

    fn y_is_same_or_positive(self) -> bool;

}

impl SimpleGlyphFlagExt for SimpleGlyphFlags {

        } else {

        }

        } else {

        }

}

impl ReadFrom for CompositeGlyphFlags {

    type ReadType = U16Be;

}

impl ReadBinaryDep for CompositeGlyphArgument {

    type Args<'a> = CompositeGlyphFlags;

    type HostType<'a> = Self;

        };

}

impl WriteBinary for CompositeGlyphArgument {

    type Output = ();

        }

}

impl ReadBinaryDep for CompositeGlyphComponent {

    type Args<'a> = CompositeGlyphFlags;

    type HostType<'a> = Self;

            Some(CompositeGlyphScale::XY {

            })

            Some(CompositeGlyphScale::Matrix([

            ]))

        } else {

        };

}

impl WriteBinary for CompositeGlyphComponent {

    type Output = ();

}

impl WriteBinary for CompositeGlyphScale {

    type Output = ();

            }

            }

        }

}

impl ReadFrom for BoundingBox {

    type ReadType = ((I16Be, I16Be), (I16Be, I16Be));

}

impl WriteBinary for BoundingBox {

    type Output = ();

}

impl<'a> GlyfTable<'a> {

    /// Construct a glyph table from the supplied glyphs

    /// Returns the number of glyphs in this `glyf` table.

    ///

    /// Returns a `u16` for convenience of interacting with other parts of the code.

        // NOTE(cast): Safe as we check records length in `new` and `push`.

    /// The glyphs in this `glyf` table

    /// Mutable access to the glyphs of this table

    /// Append a new glyph to this glyph table

    ///

    /// If the maximum number of glyphs is reached `ParseError::LimitExceeded` is returned.

        } else {

        }

    /// Returns a parsed glyph, converting [GlyfRecord::Present] into [GlyfRecord::Parsed] if

    /// necessary.

        }

    /// Takes the glyph at `glyph_index` out of the table replacing it with `GlyphRecord::Empty`

    /// and returns it.

    ///

    /// Returns `None` if the index is out-of-bounds.

    /// Replaces the glyph at `glyph_index` with the supplied `GlyfRecord`.

    ///

    /// Returns an error if the index is out-of-bounds.

}

impl LocaGlyf {

    /// Construct an unloaded LocaGlyf structure

    ///

    /// Attempts to read glyphs when the type is in this state will fail.

    /// Load tables from the supplied FontTableProvider

    /// Load like [`load`][Self::load], but keep the `glyf` table as a

    /// **zero-copy** view into `owner` instead of copying it onto the heap.

    ///

    /// `owner` must be the exact byte buffer the `provider` reads its tables

    /// from (typically an `Arc` over the mmap'd/owned font file). The `glyf`

    /// table is located within `owner` by matching the provider's borrowed

    /// slice against `owner`'s address range; if the provider returns an

    /// *owned* `glyf` (e.g. a WOFF-decompressed table) or the range can't be

    /// validated, this transparently falls back to an owned copy — so the

    /// result is always correct, only sometimes not zero-copy.

    ///

    /// Saves a per-font `glyf`-sized allocation (tens of MB for large CJK /

    /// system fonts). See scripts/RELEASE_SIZE_MEMORY_AUDIT_2026_07_04.md §3.3a.

            // The provider handed back a slice that lives inside `owner` — take

            // a zero-copy view. `owner` keeps the buffer alive.

            // Owned/relocated table: fall back to a copy (still correct).

        };

    /// Construct a loaded LocaGlyf structure from the supplied `loca` and `glyf` tables.

    ///

    /// [owned::LocaTable] can be constructed by

    /// parsing a `loca` table and then converting it to the owned version with

    /// [owned::LocaTable::from][crate::tables::loca::owned::LocaTable::from].

    /// Returns true if this is a loaded instance.

    /// Look up the glyph at the supplied index

        // Get the start and end offsets for the glyph

        // The end is clamped to the length of the glyf table. This is a workaround for a font where

        // the last `loca` offset was incorrectly 1 byte beyond the end of the `glyf` table but the

        // actual glyph data did not extend beyond the table.

            )

        // Fetch the slice for the glyph

        // If the slice is empty, then this is a valid, but empty glyph

        } else {

        };

}

impl GlyfRecord<'_> {

    /// Construct an empty glyph record

    /// The number of contours of this glyph

    ///

    /// - Zero for empty glyphs

    /// - Negative for composite glyphs

            GlyfRecord::Present {

        }

    /// The number of delta adjustable points in this glyph record excluding phantom points.

        // The `maxp` table contains fields:

        //

        // * maxPoints            Maximum points in a non-composite glyph.

        // * maxCompositePoints   Maximum points in a composite glyph.

        //

        // Both of which are u16 so that's what we return here.

            GlyfRecord::Present {

            } => {

                // skip glyph header: number_of_contours and the bounding box

                    // Simple glyph

                    // end_pts_of_contours stores the index of the end points.

                    // Therefore the number of coordinates is the last index + 1

                    }

                } else {

                    // Composite glyph

                    loop {

                    }

                }

            }

        }

    /// True if this is a composite glyph

    /// Turn self from GlyfRecord::Present into GlyfRecord::Parsed

}