tables

type AATFeature struct {
	FeatureType    uint16
	FeatureSetting uint16
	EnableFlags    uint32 // Flags for the settings that this feature and setting enables.
	DisableFlags   uint32 // Complement of flags for the settings that this feature and setting disable.
}

type AATKernSubtableHeader struct {
	Coverage byte // Circumstances under which this table is used.

	TupleCount uint16 // The tuple count. This value is only used with variation fonts and should be 0 for all other fonts. The subtable's tupleCount will be ignored if the 'kerx' table version is less than 4.
	// contains filtered or unexported fields
}

type AATLookup interface {
	AatLookupMixed

	// Class returns the class ID for the provided glyph, or (0, false)
	// for glyphs not covered by this class.
	Class(g GlyphID) (uint16, bool)
	// contains filtered or unexported methods
}

type AATLookupExt interface {
	AatLookupMixed

	// Class returns the class ID for the provided glyph, or (0, false)
	// for glyphs not covered by this class.
	Class(g GlyphID) (uint32, bool)
	// contains filtered or unexported methods
}

type AATLookupRecord4 struct {
	LastGlyph  GlyphID
	FirstGlyph GlyphID
	// offset to an array of []uint16 (or []uint32 for extended) with length last - first + 1
	Values []uint16 `offsetSize:"Offset16" offsetRelativeTo:"Parent" arrayCount:"ComputedField-nValues()"`
}

type AATLoopkup0 struct {
	Values []uint16 `arrayCount:""`
	// contains filtered or unexported fields
}

type AATLoopkup10 struct {
	FirstGlyph GlyphID
	Values     []uint16 `arrayCount:"FirstUint16"`
	// contains filtered or unexported fields
}

type AATLoopkup2 struct {
	Records []LookupRecord2 `arrayCount:"ComputedField-nUnits"`
	// contains filtered or unexported fields
}

type AATLoopkup4 struct {

	// Do not include the termination segment
	Records []AATLookupRecord4 `arrayCount:"ComputedField-nUnits-1"`
	// contains filtered or unexported fields
}

type AATLoopkup6 struct {
	Records []loopkupRecord6 `arrayCount:"ComputedField-nUnits"`
	// contains filtered or unexported fields
}

type AATLoopkup8 struct {
	AATLoopkup8Data
	// contains filtered or unexported fields
}

type AATLoopkup8Data struct {
	FirstGlyph GlyphID
	Values     []uint16 `arrayCount:"FirstUint16"`
}

type AATLoopkupExt0 struct {
	Values []uint32 `arrayCount:""`
	// contains filtered or unexported fields
}

type AATLoopkupExt10 struct {
	FirstGlyph GlyphID
	Values     []uint32 `arrayCount:"FirstUint16"`
	// contains filtered or unexported fields
}

type AATLoopkupExt2 struct {
	Records []lookupRecordExt2 `arrayCount:"ComputedField-nUnits"`
	// contains filtered or unexported fields
}

type AATLoopkupExt4 struct {

	// the values pointed by the record are uint32
	Records []loopkupRecordExt4 `arrayCount:"ComputedField-nUnits"`
	// contains filtered or unexported fields
}

type AATLoopkupExt6 struct {
	Records []loopkupRecordExt6 `arrayCount:"ComputedField-nUnits"`
	// contains filtered or unexported fields
}

type AATLoopkupExt8 AATLoopkup8

type AATStateEntry struct {
	NewState uint16
	Flags    uint16 // Table specific.
	// contains filtered or unexported fields
}

type AATStateTable struct {
	StateSize  uint16     // Size of a state, in bytes. The size is limited to 8 bits, although the field is 16 bits for alignment.
	ClassTable ClassTable `offsetSize:"Offset16"` // Byte offset from the beginning of the state table to the class subtable.

	States  [][]uint8       `isOpaque:""`
	Entries []AATStateEntry `isOpaque:""` // entry data are empty
	// contains filtered or unexported fields
}

type AATStateTableExt struct {
	StateSize uint32    // Size of a state, in bytes. The size is limited to 8 bits, although the field is 16 bits for alignment.
	Class     AATLookup `offsetSize:"Offset32"` // Byte offset from the beginning of the state table to the class subtable.

	States  [][]uint16      `isOpaque:""` // each sub array has length stateSize
	Entries []AATStateEntry `isOpaque:""` // length is the maximum state + 1
	// contains filtered or unexported fields
}

type AatLookupMixed interface {
	// Returns 0 if not supported
	ClassUint32(GlyphID) uint32
}

type AlternateSet struct {
	AlternateGlyphIDs []GlyphID `arrayCount:"FirstUint16"` // Array of alternate glyph IDs, in arbitrary order
}

type AlternateSubs struct {
	Coverage      Coverage       `offsetSize:"Offset16"` //	Offset to Coverage table, from beginning of substitution subtable
	AlternateSets []AlternateSet `arrayCount:"FirstUint16"  offsetsArray:"Offset16"`
	// contains filtered or unexported fields
}

type Anchor interface {
	// contains filtered or unexported methods
}

type AnchorFormat1 struct {
	XCoordinate int16 // Horizontal value, in design units
	YCoordinate int16 // Vertical value, in design units
	// contains filtered or unexported fields
}

type AnchorFormat2 struct {
	XCoordinate int16  // Horizontal value, in design units
	YCoordinate int16  // Vertical value, in design units
	AnchorPoint uint16 // Index to glyph contour point
	// contains filtered or unexported fields
}

type AnchorFormat3 struct {
	XCoordinate int16 // Horizontal value, in design units
	YCoordinate int16 // Vertical value, in design units

	XDevice DeviceTable `isOpaque:""` // Offset to Device table (non-variable font) / VariationIndex table (variable font) for X coordinate, from beginning of Anchor table (may be NULL)
	YDevice DeviceTable `isOpaque:""` // Offset to Device table (non-variable font) / VariationIndex table (variable font) for Y coordinate, from beginning of Anchor table (may be NULL)
	// contains filtered or unexported fields
}

type AnchorMatrix struct {
	// contains filtered or unexported fields
}

type Ankr struct {
	// contains filtered or unexported fields
}

type AnkrAnchor struct {
	X, Y int16
}

type AttachList struct {
	Coverage     Coverage      `offsetSize:"Offset16"`                            // Offset to Coverage table - from beginning of AttachList table
	AttachPoints []AttachPoint `arrayCount:"FirstUint16" offsetsArray:"Offset16"` // [glyphCount] Array of offsets to AttachPoint tables-from beginning of AttachList table-in Coverage Index order
}

type AttachPoint struct {
	PointIndices []uint16 `arrayCount:"FirstUint16"` // [pointCount]	Array of contour point indices -in increasing numerical order
}

type Avar struct {
	AxisSegmentMaps []SegmentMaps `arrayCount:"FirstUint16"` //[axisCount]	The segment maps array — one segment map for each axis, in the order of axes specified in the 'fvar' table.
	// contains filtered or unexported fields
}

type AxisValueMap struct {
	FromCoordinate Coord // A normalized coordinate value obtained using default normalization.
	ToCoordinate   Coord // The modified, normalized coordinate value.
}

type BaseArray struct {
	// contains filtered or unexported fields
}

type BigGlyphMetrics struct {
	SmallGlyphMetrics
	// contains filtered or unexported fields
}

type BitmapData17 struct {
	SmallGlyphMetrics
	Image []byte `arrayCount:"FirstUint32"`
}

type BitmapData18 struct {
	BigGlyphMetrics
	Image []byte `arrayCount:"FirstUint32"`
}

type BitmapData19 struct {
	Image []byte `arrayCount:"FirstUint32"`
}

type BitmapData2 struct {
	SmallGlyphMetrics
	Image []byte `arrayCount:"ToEnd"`
}

type BitmapData5 struct {
	Image []byte `arrayCount:"ToEnd"`
}

type BitmapGlyphData struct {
	OriginOffsetX int16  //	The horizontal (x-axis) position of the left edge of the bitmap graphic in relation to the glyph design space origin.
	OriginOffsetY int16  //	The vertical (y-axis) position of the bottom edge of the bitmap graphic in relation to the glyph design space origin.
	GraphicType   Tag    //	Indicates the format of the embedded graphic data: one of 'jpg ', 'png ' or 'tiff', or the special format 'dupe'.
	Data          []byte `arrayCount:"ToEnd"` //	The actual embedded graphic data. The total length is inferred from sequential entries in the glyphDataOffsets array and the fixed size (8 bytes) of the preceding fields.
}

type BitmapSize struct {
	Hori SbitLineMetrics //	Line metrics for text rendered horizontally.
	Vert SbitLineMetrics //	Line metrics for text rendered vertically.

	PpemX uint8 //	Horizontal pixels per em.
	PpemY uint8 //	Vertical pixels per em.
	// contains filtered or unexported fields
}

type BitmapSubtable struct {
	FirstGlyph GlyphID //	First glyph ID of this range.
	LastGlyph  GlyphID //	Last glyph ID of this range (inclusive).
	IndexSubHeader
}

type Bloc = CBLC

type CBLC struct {
	BitmapSizes    []BitmapSize       `arrayCount:"FirstUint32"` // BitmapSize records array.
	IndexSubTables [][]BitmapSubtable `isOpaque:""`              // with same length as [BitmapSizes]
	// contains filtered or unexported fields
}

type CFF = []byte

type CaretValue interface {
	// contains filtered or unexported methods
}

type CaretValue1 struct {
	Coordinate int16 //	X or Y value, in design units
	// contains filtered or unexported fields
}

type CaretValue2 struct {
	CaretValuePointIndex uint16 // Contour point index on glyph
	// contains filtered or unexported fields
}

type CaretValue3 struct {
	Coordinate int16 // X or Y value, in design units

	Device DeviceTable `isOpaque:""`
	// contains filtered or unexported fields
}

type ChainedClassSequenceRuleSet = ChainedSequenceRuleSet

type ChainedContextualPos struct {
	Data ChainedContextualPosITF
}

type ChainedContextualPos1 ChainedSequenceContextFormat1

type ChainedContextualPos2 ChainedSequenceContextFormat2

type ChainedContextualPos3 ChainedSequenceContextFormat3

type ChainedContextualPosITF interface {
	Cov() Coverage
	// contains filtered or unexported methods
}

type ChainedContextualSubs struct {
	Data ChainedContextualSubsITF
}

type ChainedContextualSubs1 ChainedSequenceContextFormat1

type ChainedContextualSubs2 ChainedSequenceContextFormat2

type ChainedContextualSubs3 ChainedSequenceContextFormat3

type ChainedContextualSubsITF interface {
	Cov() Coverage
	// contains filtered or unexported methods
}

type ChainedSequenceContextFormat1 struct {
	ChainedSeqRuleSet []ChainedSequenceRuleSet `arrayCount:"FirstUint16"  offsetsArray:"Offset16"` //[chainedSeqRuleSetCount]	Array of offsets to ChainedSeqRuleSet tables, from beginning of ChainedSequenceContextFormat1 table (may be NULL)
	// contains filtered or unexported fields
}

type ChainedSequenceContextFormat2 struct {
	BacktrackClassDef      ClassDef                      `offsetSize:"Offset16"`                            // Offset to ClassDef table containing backtrack sequence context, from beginning of ChainedSequenceContextFormat2 table
	InputClassDef          ClassDef                      `offsetSize:"Offset16"`                            // Offset to ClassDef table containing input sequence context, from beginning of ChainedSequenceContextFormat2 table
	LookaheadClassDef      ClassDef                      `offsetSize:"Offset16"`                            // Offset to ClassDef table containing lookahead sequence context, from beginning of ChainedSequenceContextFormat2 table
	ChainedClassSeqRuleSet []ChainedClassSequenceRuleSet `arrayCount:"FirstUint16" offsetsArray:"Offset16"` //[chainedClassSeqRuleSetCount]	Array of offsets to ChainedClassSequenceRuleSet tables, from beginning of ChainedSequenceContextFormat2 table (may be NULL)
	// contains filtered or unexported fields
}

type ChainedSequenceContextFormat3 struct {
	BacktrackCoverages []Coverage             `arrayCount:"FirstUint16" offsetsArray:"Offset16"` //[backtrackGlyphCount]	Array of offsets to coverage tables for the backtrack sequence
	InputCoverages     []Coverage             `arrayCount:"FirstUint16" offsetsArray:"Offset16"` //[inputGlyphCount]	Array of offsets to coverage tables for the input sequence
	LookaheadCoverages []Coverage             `arrayCount:"FirstUint16" offsetsArray:"Offset16"` //[lookaheadGlyphCount]	Array of offsets to coverage tables for the lookahead sequence
	SeqLookupRecords   []SequenceLookupRecord `arrayCount:"FirstUint16"`                         //[seqLookupCount]	Array of SequenceLookupRecords
	// contains filtered or unexported fields
}

type ChainedSequenceRule struct {
	BacktrackSequence []GlyphID `arrayCount:"FirstUint16"` //[backtrackGlyphCount]	Array of backtrack glyph IDs

	InputSequence     []GlyphID              `arrayCount:"ComputedField-inputGlyphCount-1"` //[inputGlyphCount - 1]	Array of input glyph IDs—start with second glyph
	LookaheadSequence []GlyphID              `arrayCount:"FirstUint16"`                     //[lookaheadGlyphCount]	Array of lookahead glyph IDs
	SeqLookupRecords  []SequenceLookupRecord `arrayCount:"FirstUint16"`                     //[seqLookupCount]	Array of SequenceLookupRecords
	// contains filtered or unexported fields
}

type ChainedSequenceRuleSet struct {
	ChainedSeqRules []ChainedSequenceRule `arrayCount:"FirstUint16" offsetsArray:"Offset16"` // Array of offsets to SequenceRule tables, from beginning of the SequenceRuleSet table
}

type Class1Record []Class2Record //[class2Count]	Array of Class2 records, ordered by classes in classDef2.

type Class2Record struct {
	ValueRecord1 ValueRecord //	Positioning for first glyph — empty if valueFormat1 = 0.
	ValueRecord2 ValueRecord //	Positioning for second glyph — empty if valueFormat2 = 0.
}

type ClassDef interface {
	Class(gi GlyphID) (uint16, bool)

	// Extent returns the maximum class ID + 1. This is the length
	// required for an array to be indexed by the class values.
	Extent() int
	// contains filtered or unexported methods
}

type ClassDef1 struct {
	StartGlyphID    GlyphID  // First glyph ID of the classValueArray
	ClassValueArray []uint16 `arrayCount:"FirstUint16"` //[glyphCount]	Array of Class Values — one per glyph ID
	// contains filtered or unexported fields
}

type ClassDef2 struct {
	ClassRangeRecords []ClassRangeRecord `arrayCount:"FirstUint16"` //[glyphCount]	Array of Class Values — one per glyph ID
	// contains filtered or unexported fields
}

type ClassRangeRecord struct {
	StartGlyphID GlyphID // First glyph ID in the range
	EndGlyphID   GlyphID // Last glyph ID in the range
	Class        uint16  // Applied to all glyphs in the range
}

type ClassSequenceRuleSet = SequenceRuleSet

type ClassTable struct {
	StartGlyph GlyphID
	Values     []byte `arrayCount:"FirstUint16"`
}

type Cmap struct {
	Records []EncodingRecord `arrayCount:"ComputedField-numTables"`
	// contains filtered or unexported fields
}

type CmapSubtable interface {
	// contains filtered or unexported methods
}

type CmapSubtable0 struct {
	GlyphIdArray [256]uint8 //	An array that maps character codes to glyph index values.
	// contains filtered or unexported fields
}

type CmapSubtable10 struct {
	StartCharCode uint32    // First character code covered
	GlyphIdArray  []GlyphID `arrayCount:"FirstUint32"` // Array of glyph indices for the character codes covered
	// contains filtered or unexported fields
}

type CmapSubtable12 struct {
	Groups []SequentialMapGroup `arrayCount:"FirstUint32"` // Array of SequentialMapGroup records.
	// contains filtered or unexported fields
}

type CmapSubtable13 struct {
	Groups []SequentialMapGroup `arrayCount:"FirstUint32"` // Array of SequentialMapGroup records.
	// contains filtered or unexported fields
}

type CmapSubtable14 struct {
	VarSelectors []VariationSelector `arrayCount:"FirstUint32"` // [numVarSelectorRecords]	Array of VariationSelector records.
	// contains filtered or unexported fields
}

type CmapSubtable2 struct {
	// contains filtered or unexported fields
}

type CmapSubtable4 struct {
	EndCode []uint16 `arrayCount:"ComputedField-segCountX2 / 2"` // [segCount]uint16 End characterCode for each segment, last=0xFFFF.

	StartCode      []uint16 `arrayCount:"ComputedField-segCountX2 / 2"` // [segCount]uint16 Start character code for each segment.
	IdDelta        []uint16 `arrayCount:"ComputedField-segCountX2 / 2"` // [segCount]int16 Delta for all character codes in segment.
	IdRangeOffsets []uint16 `arrayCount:"ComputedField-segCountX2 / 2"` // [segCount]uint16 Offsets into glyphIdArray or 0
	GlyphIDArray   []byte   `arrayCount:"ToEnd"`                        // glyphIdArray : uint16[] glyph index array (arbitrary length)
	// contains filtered or unexported fields
}

type CmapSubtable6 struct {
	FirstCode    uint16    // First character code of subrange.
	GlyphIdArray []GlyphID `arrayCount:"FirstUint16"` // Array of glyph index values for character codes in the range.
	// contains filtered or unexported fields
}

type CompositeGlyph struct {
	Glyphs       []CompositeGlyphPart `isOpaque:""`
	Instructions []byte               `isOpaque:""`
}

type CompositeGlyphPart struct {
	Flags      uint16
	GlyphIndex GlyphID

	// Scale is a matrix x, 01, 10, y ; default to identity
	Scale [4]float32
	// contains filtered or unexported fields
}

type ConditionFormat1 struct {
	AxisIndex           uint16 // Index (zero-based) for the variation axis within the 'fvar' table.
	FilterRangeMinValue Coord  // Minimum value of the font variation instances that satisfy this condition.
	FilterRangeMaxValue Coord  // Maximum value of the font variation instances that satisfy this condition.
	// contains filtered or unexported fields
}

type ConditionSet struct {
	// uint16	conditionCount	Number of Conditions for this condition set.
	Conditions []ConditionFormat1 `arrayCount:"FirstUint16" offsetsArray:"Offset32"` // [conditionCount]	Array of offsets to condition tables, from beginning of the ConditionSet table.
}

type ContextualPos struct {
	Data ContextualPosITF
}

type ContextualPos1 SequenceContextFormat1

type ContextualPos2 SequenceContextFormat2

type ContextualPos3 SequenceContextFormat3

type ContextualPosITF interface {
	Cov() Coverage
	// contains filtered or unexported methods
}

type ContextualSubs struct {
	Data ContextualSubsITF
}

type ContextualSubs1 SequenceContextFormat1

type ContextualSubs2 SequenceContextFormat2

type ContextualSubs3 SequenceContextFormat3

type ContextualSubsITF interface {
	Cov() Coverage
	// contains filtered or unexported methods
}

type Coord int16

type Coverage interface {

	// Index returns the index of the provided glyph, or
	// `false` if the glyph is not covered by this lookup.
	// Note: this method is injective: two distincts, covered glyphs are mapped
	// to distincts indices.
	Index(GlyphID) (int, bool)

	// Len return the number of glyphs covered.
	// It is 0 for empty coverages.
	// For non empty Coverages, it is also 1 + (maximum index returned)
	Len() int
	// contains filtered or unexported methods
}

type Coverage1 struct {
	Glyphs []GlyphID `arrayCount:"FirstUint16"`
	// contains filtered or unexported fields
}

type Coverage2 struct {
	Ranges []RangeRecord `arrayCount:"FirstUint16"`
	// contains filtered or unexported fields
}

type CursivePos struct {
	EntryExits []EntryExit `isOpaque:""`
	// contains filtered or unexported fields
}

type DefaultUVSTable struct {
	Ranges []UnicodeRange `arrayCount:"FirstUint32"`
}

type DeltaSetMapping struct {

	// uint16 or uint32	mapCount : The number of mapping entries.
	Map []VariationStoreIndex `isOpaque:"" subsliceStart:"AtCurrent"`
	// contains filtered or unexported fields
}

type DeviceHinting struct {
	// with length endSize - startSize + 1
	Values []int8
	// correction range, in ppem
	StartSize, EndSize uint16
}

type DeviceTable interface {
	// contains filtered or unexported methods
}

type DeviceTableHeader struct {
	// contains filtered or unexported fields
}

type DeviceVariation VariationStoreIndex

type EBLC = CBLC

type EncodingID uint16

type EncodingRecord struct {
	PlatformID PlatformID   // Platform ID.
	EncodingID EncodingID   // Platform-specific encoding ID.
	Subtable   CmapSubtable `offsetSize:"Offset32" offsetRelativeTo:"Parent"` // Byte offset from beginning of table to the subtable for this encoding.
}

type EntryExit struct {
	EntryAnchor Anchor
	ExitAnchor  Anchor
}

type Extension struct {
	ExtensionLookupType uint16   //	Lookup type of subtable referenced by extensionOffset (that is, the extension subtable).
	ExtensionOffset     Offset32 //	Offset to the extension subtable, of lookup type extensionLookupType, relative to the start of the ExtensionSubstFormat1 subtable.
	RawData             []byte   `subsliceStart:"AtStart" arrayCount:"ToEnd"`
	// contains filtered or unexported fields
}

type ExtensionPos Extension

type ExtensionSubs Extension

type Feat struct {
	Names []FeatureName `arrayCount:"ComputedField-featureNameCount"` //	The feature name array.
	// contains filtered or unexported fields
}

type Feature struct {
	LookupListIndices []uint16 `arrayCount:"FirstUint16"` // [lookupIndexCount]	Array of indices into the LookupList — zero-based (first lookup is LookupListIndex = 0)
	// contains filtered or unexported fields
}

type FeatureList struct {
	Records  []TagOffsetRecord `arrayCount:"FirstUint16"` // Array of FeatureRecords — zero-based (first feature has FeatureIndex = 0), listed alphabetically by feature tag
	Features []Feature         `isOpaque:""`
}

type FeatureName struct {
	Feature uint16 // Feature type.

	SettingTable []FeatureSettingName `offsetSize:"Offset32" offsetRelativeTo:"Parent" arrayCount:"ComputedField-nSettings"` // Offset in bytes from the beginning of the 'feat' table to this feature's setting name array. The actual type of record this offset refers to will depend on the exclusivity value, as described below.
	FeatureFlags uint16               // Single-bit flags associated with the feature type.
	NameIndex    uint16               // The name table index for the feature's name. This index has values greater than 255 and less than 32768.
	// contains filtered or unexported fields
}

type FeatureSettingName struct {
	Setting   uint16 //	The setting.
	NameIndex uint16 //	The name table index for the setting's name. The nameIndex must be greater than 255 and less than 32768.
}

type FeatureTableSubstitution struct {
	Substitutions []FeatureTableSubstitutionRecord `arrayCount:"FirstUint16"` // [substitutionCount]	Array of feature table substitution records.
	// contains filtered or unexported fields
}

type FeatureTableSubstitutionRecord struct {
	FeatureIndex     uint16  //	The feature table index to match.
	AlternateFeature Feature `offsetSize:"Offset32" offsetRelativeTo:"Parent"` //	Offset to an alternate feature table, from start of the FeatureTableSubstitution table.
}

type FeatureVariation struct {
	FeatureVariationRecords []FeatureVariationRecord `arrayCount:"FirstUint32"` //[featureVariationRecordCount]	Array of feature variation records.
	// contains filtered or unexported fields
}

type FeatureVariationRecord struct {
	ConditionSet  ConditionSet             `offsetSize:"Offset32" offsetRelativeTo:"Parent"` // Offset to a condition set table, from beginning of FeatureVariations table.
	Substitutions FeatureTableSubstitution `offsetSize:"Offset32" offsetRelativeTo:"Parent"` // Offset to a feature table substitution table, from beginning of the FeatureVariations table.
}

type Float1616 = float32

type FontPage uint16

type Fvar struct {
	FvarRecords `isOpaque:""`
	// contains filtered or unexported fields
}

type FvarRecords struct {
	Axis      []VariationAxisRecord
	Instances []InstanceRecord `isOpaque:"" subsliceStart:"AtCurrent"`
}

type GDEF struct {
	GlyphClassDef   ClassDef     `offsetSize:"Offset16"` // Offset to class definition table for glyph type, from beginning of GDEF header (may be NULL)
	AttachList      AttachList   `offsetSize:"Offset16"` // Offset to attachment point list table, from beginning of GDEF header (may be NULL)
	LigCaretList    LigCaretList `offsetSize:"Offset16"` // Offset to ligature caret list table, from beginning of GDEF header (may be NULL)
	MarkAttachClass ClassDef     `offsetSize:"Offset16"` // Offset to class definition table for mark attachment type, from beginning of GDEF header (may be NULL)

	MarkGlyphSetsDef MarkGlyphSets `isOpaque:""` // Offset to the table of mark glyph set definitions, from beginning of GDEF header (may be NULL)
	ItemVarStore     ItemVarStore  `isOpaque:""` // Offset to the Item Variation Store table, from beginning of GDEF header (may be NULL)
	// contains filtered or unexported fields
}

type GPOS Layout

type GPOSLookup interface {

	// Coverage returns the coverage of the lookup subtable.
	// For ContextualPos3 and ChainedContextualPos3, its the coverage of the first input.
	Cov() Coverage
	// contains filtered or unexported methods
}

type GSUB Layout

type GSUBLookup interface {

	// Coverage returns the coverage of the lookup subtable.
	// For ContextualSubs3 and ChainedContextualSubs3, its the coverage of the first input.
	Cov() Coverage
	// contains filtered or unexported methods
}

type Glyf []Glyph

type Glyph struct {
	XMin int16     // Minimum x for coordinate data.
	YMin int16     // Minimum y for coordinate data.
	XMax int16     // Maximum x for coordinate data.
	YMax int16     // Maximum y for coordinate data.
	Data GlyphData `isOpaque:"" subsliceStart:"AtCurrent"`
	// contains filtered or unexported fields
}

type GlyphContourPoint struct {
	Flag uint8
	X, Y int16
}

type GlyphData interface {
	// contains filtered or unexported methods
}

type GlyphID = uint16

type GlyphIdOffsetPair struct {
	GlyphID    GlyphID  //	Glyph ID of glyph present.
	SbitOffset Offset16 //	Location in EBDT.
}

type GlyphProps = uint16

type GlyphVariationData struct {
	SerializedData        []byte                 `offsetSize:"Offset16" arrayCount:"ToEnd"`              // Offset from the start of the GlyphVariationData table to the serialized data
	TupleVariationHeaders []TupleVariationHeader `arrayCount:"ComputedField-tupleVariationCount&0x0FFF"` //[tupleCount]	Array of tuple variation headers.
	// contains filtered or unexported fields
}

type Gvar struct {
	SharedTuples `offsetSize:"Offset32" arguments:"sharedTuplesCount=.sharedTupleCount,valuesCount=.axisCount"` // Offset from the start of this table to the shared tuple records.

	GlyphVariationDatas []GlyphVariationData `isOpaque:""`
	// contains filtered or unexported fields
}

type HVAR struct {
	ItemVariationStore  ItemVarStore     `offsetSize:"Offset32"` // Offset in bytes from the start of this table to the item variation store table.
	AdvanceWidthMapping DeltaSetMapping  `offsetSize:"Offset32"` // Offset in bytes from the start of this table to the delta-set index mapping for advance widths (may be NULL).
	LsbMapping          *DeltaSetMapping `offsetSize:"Offset32"` // Offset in bytes from the start of this table to the delta-set index mapping for left side bearings (may be NULL).
	RsbMapping          *DeltaSetMapping `offsetSize:"Offset32"` // Offset in bytes from the start of this table to the delta-set index mapping for right side bearings (may be NULL).
	// contains filtered or unexported fields
}

type Head struct {
	UnitsPerEm uint16

	XMin     int16
	YMin     int16
	XMax     int16
	YMax     int16
	MacStyle uint16

	IndexToLocFormat int16
	// contains filtered or unexported fields
}

type Hhea struct {
	Ascender             int16
	Descender            int16
	LineGap              int16
	AdvanceMax           uint16
	MinFirstSideBearing  int16
	MinSecondSideBearing int16
	MaxExtent            int16
	CaretSlopeRise       int16
	CaretSlopeRun        int16
	CaretOffset          int16

	NumOfLongMetrics uint16
	// contains filtered or unexported fields
}

type Hmtx struct {
	Metrics []LongHorMetric `arrayCount:""`
	// avances are padded with the last value
	// and side bearings are given
	LeftSideBearings []int16 `arrayCount:""`
}

type IndexData interface {
	// contains filtered or unexported methods
}

type IndexData1 struct {
	// sizeOfArray = (lastGlyph - firstGlyph + 1) + 1 + 1 pad if needed
	// sbitOffsets[glyphIndex] + imageDataOffset = glyphData
	SbitOffsets []Offset32
}

type IndexData2 struct {
	ImageSize  uint32          // All the glyphs are of the same size.
	BigMetrics BigGlyphMetrics // All glyphs have the same metrics; glyph data may be compressed, byte-aligned, or bit-aligned.
}

type IndexData3 struct {
	// sizeOfArray = (lastGlyph - firstGlyph + 1) + 1 + 1 pad if needed
	// sbitOffets[glyphIndex] + imageDataOffset = glyphData
	SbitOffsets []Offset16
}

type IndexData4 struct {
	GlyphArray []GlyphIdOffsetPair `arrayCount:"ComputedField-numGlyphs+1"` //[numGlyphs + 1]	One per glyph.
	// contains filtered or unexported fields
}

type IndexData5 struct {
	ImageSize    uint32          //	All glyphs have the same data size.
	BigMetrics   BigGlyphMetrics //	All glyphs have the same metrics.
	GlyphIdArray []GlyphID       `arrayCount:"FirstUint32"` // [numGlyphs] One per glyph, sorted by glyph ID.
}

type IndexSubHeader struct {
	ImageFormat     uint16    // Format of EBDT image data.
	ImageDataOffset Offset32  // Offset to image data in EBDT table.
	IndexData       IndexData `unionField:"indexFormat"`
	// contains filtered or unexported fields
}

type IndexSubTableArray struct {
	Subtables []IndexSubTableHeader
}

type IndexSubTableHeader struct {
	FirstGlyph GlyphID //	First glyph ID of this range.
	LastGlyph  GlyphID //	Last glyph ID of this range (inclusive).
	// contains filtered or unexported fields
}

type InstanceRecord struct {
	SubfamilyNameID uint16 // The name ID for entries in the 'name' table that provide subfamily names for this instance.

	Coordinates      []Float1616 // [axisCount] The coordinates array for this instance.
	PostScriptNameID uint16      `isOpaque:"" subsliceStart:"AtCurrent"` // Optional. The name ID for entries in the 'name' table that provide PostScript names for this instance.
	// contains filtered or unexported fields
}

type ItemVarStore struct {
	VariationRegionList VariationRegionList `offsetSize:"Offset32"`                            // Offset in bytes from the start of the item variation store to the variation region list.
	ItemVariationDatas  []ItemVariationData `arrayCount:"FirstUint16" offsetsArray:"Offset32"` // [itemVariationDataCount] Offsets in bytes from the start of the item variation store to each item variation data subtable.
	// contains filtered or unexported fields
}

type ItemVariationData struct {
	RegionIndexes []uint16  `arrayCount:"ComputedField-regionIndexCount"` //[regionIndexCount]	Array of indices into the variation region list for the regions referenced by this item variation data table.
	DeltaSets     [][]int16 `isOpaque:"" subsliceStart:"AtCurrent"`       //[itemCount]	Delta-set rows.
	// contains filtered or unexported fields
}

type KAAnchor struct {
	Mark, Current uint16
}

type KAControl struct {
	Mark, Current uint16
}

type KACoordinates struct {
	MarkX, MarkY, CurrentX, CurrentY int16
}

type Kern struct {
	Tables []KernSubtable
	// contains filtered or unexported fields
}

type KernData interface {
	// contains filtered or unexported methods
}

type KernData0 struct {
	Pairs []Kernx0Record `arrayCount:"ComputedField-nPairs"`
	// contains filtered or unexported fields
}

type KernData1 struct {
	AATStateTable

	Values []int16 `isOpaque:""`
	// contains filtered or unexported fields
}

type KernData2 struct {
	Left         AATLoopkup8Data `offsetSize:"Offset16" offsetRelativeTo:"Parent"`
	Right        AATLoopkup8Data `offsetSize:"Offset16" offsetRelativeTo:"Parent"`
	KerningStart Offset16        // Offset from beginning of this subtable to the start of the kerning array.
	KerningData  []byte          `isOpaque:"" offsetRelativeTo:"Parent"` // indexed by Left + Right
	// contains filtered or unexported fields
}

type KernData3 struct {
	RightClassCount uint8 // The number of right-hand classes.

	Kernings   []int16 `arrayCount:"ComputedField-kernValueCount"`
	LeftClass  []uint8 `arrayCount:"ComputedField-glyphCount"`
	RightClass []uint8 `arrayCount:"ComputedField-glyphCount"`
	KernIndex  []uint8 `arrayCount:"ComputedField-nKernIndex()"`
	// contains filtered or unexported fields
}

type KernSubtable interface {
	// Data returns the actual kerning data
	Data() KernData
}

type Kernx0Record struct {
	Left, Right GlyphID
	Value       int16
}

type Kerx struct {
	Tables []KerxSubtable `arrayCount:"ComputedField-nTables"`
	// contains filtered or unexported fields
}

type KerxAnchorAnchors struct {
	Anchors []KAAnchor
}

type KerxAnchorControls struct {
	Anchors []KAControl
}

type KerxAnchorCoordinates struct {
	Anchors []KACoordinates
}

type KerxAnchors interface {
	// contains filtered or unexported methods
}

type KerxData interface {
	// contains filtered or unexported methods
}

type KerxData0 struct {
	Pairs []Kernx0Record `arrayCount:"ComputedField-nPairs"`
	// contains filtered or unexported fields
}

type KerxData1 struct {
	AATStateTableExt `arguments:"valuesCount=valuesCount, entryDataSize=2"`

	Values []int16 `isOpaque:""`
	// contains filtered or unexported fields
}

type KerxData2 struct {
	Left         AATLookup `offsetSize:"Offset32" offsetRelativeTo:"Parent"` // Offset from beginning of this subtable to the left-hand offset table.
	Right        AATLookup `offsetSize:"Offset32" offsetRelativeTo:"Parent"` // Offset from beginning of this subtable to right-hand offset table.
	KerningStart Offset32  // Offset from beginning of this subtable to the start of the kerning array.
	KerningData  []byte    `subsliceStart:"AtStart" arrayCount:"ToEnd"` // indexed by Left + Right
	// contains filtered or unexported fields
}

type KerxData4 struct {
	AATStateTableExt `arguments:"valuesCount=valuesCount,entryDataSize=2"`
	Flags            uint32
	Anchors          KerxAnchors `isOpaque:""`
}

type KerxData6 struct {
	Row    AatLookupMixed `isOpaque:"" offsetRelativeTo:"Parent"` // Values are pre-multiplied by `columnCount`
	Column AatLookupMixed `isOpaque:"" offsetRelativeTo:"Parent"`
	// with rowCount * columnCount
	// for tuples the values are estParseKerx (Not yet run).the first element of the tuple
	Kernings []int16 `isOpaque:""  offsetRelativeTo:"Parent"`
	// contains filtered or unexported fields
}

type KerxSubtable struct {
	Coverage uint16 // Circumstances under which this table is used.

	TupleCount uint32   // The tuple count. This value is only used with variation fonts and should be 0 for all other fonts. The subtable's tupleCount will be ignored if the 'kerx' table version is less than 4.
	Data       KerxData `unionField:"version" arguments:"tupleCount=.TupleCount, valuesCount=valuesCount"`
	// contains filtered or unexported fields
}

type LangSys struct {
	RequiredFeatureIndex uint16   // Index of a feature required for this language system; if no required features = 0xFFFF
	FeatureIndices       []uint16 `arrayCount:"FirstUint16"` // [featureIndexCount]	Array of indices into the FeatureList, in arbitrary order
	// contains filtered or unexported fields
}

type LanguageID uint16

type Layout struct {
	ScriptList        ScriptList        `offsetSize:"Offset16"` // Offset to ScriptList table, from beginning of GPOS table
	FeatureList       FeatureList       `offsetSize:"Offset16"` // Offset to FeatureList table, from beginning of GPOS table
	LookupList        lookupList        `offsetSize:"Offset16"` // Offset to LookupList table, from beginning of GPOS table
	FeatureVariations *FeatureVariation `isOpaque:""`           // Offset to FeatureVariations table, from beginning of GPOS table (may be NULL)
	// contains filtered or unexported fields
}

type LigCaretList struct {
	Coverage  Coverage   `offsetSize:"Offset16"`                            // Offset to Coverage table - from beginning of LigCaretList table
	LigGlyphs []LigGlyph `arrayCount:"FirstUint16" offsetsArray:"Offset16"` // [ligGlyphCount]	Array of offsets to LigGlyph tables, from beginning of LigCaretList table —in Coverage Index order
}

type LigGlyph struct {
	CaretValues []CaretValue `arrayCount:"FirstUint16" offsetsArray:"Offset16"` // [caretCount] Array of offsets to CaretValue tables, from beginning of LigGlyph table — in increasing coordinate order
}

type Ligature struct {
	LigatureGlyph GlyphID //	glyph ID of ligature to substitute

	ComponentGlyphIDs []GlyphID `arrayCount:"ComputedField-componentCount-1"` //  [componentCount - 1]	Array of component glyph IDs — start with the second component, ordered in writing direction
	// contains filtered or unexported fields
}

type LigatureArray struct {
	LigatureAttachs []LigatureAttach `arrayCount:"FirstUint16" offsetsArray:"Offset16"` // [ligatureCount]	Array of offsets to LigatureAttach tables. Offsets are from beginning of LigatureArray table, ordered by ligatureCoverage index.
}

type LigatureAttach struct {
	// contains filtered or unexported fields
}

type LigatureSet struct {
	Ligatures []Ligature `arrayCount:"FirstUint16"  offsetsArray:"Offset16"` // [LigatureCount]	Array of offsets to Ligature tables. Offsets are from beginning of LigatureSet table, ordered by preference.
}

type LigatureSubs struct {
	Coverage     Coverage      `offsetSize:"Offset16"`                             // Offset to Coverage table, from beginning of substitution subtable
	LigatureSets []LigatureSet `arrayCount:"FirstUint16"  offsetsArray:"Offset16"` //[ligatureSetCount]	Array of offsets to LigatureSet tables. Offsets are from beginning of substitution subtable, ordered by Coverage index
	// contains filtered or unexported fields
}

type LongHorMetric struct {
	AdvanceWidth, LeftSideBearing int16
}

type Lookup struct {
	LookupFlag uint16 // Lookup qualifiers

	MarkFilteringSet uint16 // Index (base 0) into GDEF mark glyph sets structure. This field is only present if the USE_MARK_FILTERING_SET lookup flag is set.
	// contains filtered or unexported fields
}

type LookupRecord2 struct {
	LastGlyph  GlyphID
	FirstGlyph GlyphID
	Value      uint16
}

type Ltag struct {
	// contains filtered or unexported fields
}

type MVAR struct {
	ItemVariationStore ItemVarStore     `offsetSize:"Offset16"`                 // Offset in bytes from the start of this table to the item variation store table. If valueRecordCount is zero, set to zero; if valueRecordCount is greater than zero, must be greater than zero.
	ValueRecords       []VarValueRecord `isOpaque:"" subsliceStart:"AtCurrent"` // [valueRecordCount]	Array of value records that identify target items and the associated delta-set index for each. The valueTag records must be in binary order of their valueTag field.
	// contains filtered or unexported fields
}

type Mark2Array struct {
	// contains filtered or unexported fields
}

type MarkArray struct {
	MarkRecords []MarkRecord `arrayCount:"FirstUint16"` //[markCount]	Array of MarkRecords, ordered by corresponding glyphs in the associated mark Coverage table.
	MarkAnchors []Anchor     `isOpaque:""`              // with same length as MarkRecords
}

type MarkBasePos struct {
	BaseCoverage Coverage `offsetSize:"Offset16"` // Offset to baseCoverage table, from beginning of MarkBasePos subtable.

	MarkArray MarkArray `offsetSize:"Offset16"`                                          // Offset to MarkArray table, from beginning of MarkBasePos subtable.
	BaseArray BaseArray `offsetSize:"Offset16" arguments:"offsetsCount=.markClassCount"` // Offset to BaseArray table, from beginning of MarkBasePos subtable.
	// contains filtered or unexported fields
}

type MarkGlyphSets struct {
	Coverages []Coverage `arrayCount:"FirstUint16" offsetsArray:"Offset32"` // [markGlyphSetCount] Array of offsets to mark glyph set coverage tables, from the start of the MarkGlyphSets table.
	// contains filtered or unexported fields
}

type MarkLigPos struct {
	MarkCoverage     Coverage      `offsetSize:"Offset16"` // Offset to markCoverage table, from beginning of MarkLigPos subtable.
	LigatureCoverage Coverage      `offsetSize:"Offset16"` // Offset to ligatureCoverage table, from beginning of MarkLigPos subtable.
	MarkClassCount   uint16        // Number of defined mark classes
	MarkArray        MarkArray     `offsetSize:"Offset16"`                                          // Offset to MarkArray table, from beginning of MarkLigPos subtable.
	LigatureArray    LigatureArray `offsetSize:"Offset16" arguments:"offsetsCount=.MarkClassCount"` // Offset to LigatureArray table, from beginning of MarkLigPos subtable.
	// contains filtered or unexported fields
}

type MarkMarkPos struct {
	PosFormat      uint16     //	Format identifier: format = 1
	Mark1Coverage  Coverage   `offsetSize:"Offset16"` // Offset to Combining Mark Coverage table, from beginning of MarkMarkPos subtable.
	Mark2Coverage  Coverage   `offsetSize:"Offset16"` // Offset to Base Mark Coverage table, from beginning of MarkMarkPos subtable.
	MarkClassCount uint16     //	Number of Combining Mark classes defined
	Mark1Array     MarkArray  `offsetSize:"Offset16"`                                          //	Offset to MarkArray table for mark1, from beginning of MarkMarkPos subtable.
	Mark2Array     Mark2Array `offsetSize:"Offset16" arguments:"offsetsCount=.MarkClassCount"` //	Offset to Mark2Array table for mark2, from beginning of MarkMarkPos subtable.
}

type MarkRecord struct {
	MarkClass uint16 // Class defined for the associated mark.
	// contains filtered or unexported fields
}

type Maxp struct {
	NumGlyphs uint16
	// contains filtered or unexported fields
}

type Morx struct {
	Chains []MorxChain `arrayCount:"ComputedField-nChains"`
	// contains filtered or unexported fields
}

type MorxChain struct {
	Flags uint32 // The default specification for subtables.

	Features  []AATFeature        `arrayCount:"ComputedField-nFeatureEntries"`
	Subtables []MorxChainSubtable `arrayCount:"ComputedField-nSubtable"`
	// contains filtered or unexported fields
}

type MorxChainSubtable struct {

	// Coverage flags and subtable type.
	Coverage byte

	SubFeatureFlags uint32 // The 32-bit mask identifying which subtable this is (the subtable being executed if the AND of this value and the processed defaultFlags is nonzero)

	Data MorxSubtable `unionField:"version"`
	// contains filtered or unexported fields
}