truetype

type AATAnchor struct {
	X, Y int16
}

type AATFeature struct {
	Type, Setting 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 AATFeatureName struct {
	Settings  []AATSettingName
	Feature   uint16
	Flags     uint16
	NameIndex NameID
}

type AATFeatureSelector struct {
	Name    NameID // selector's name identifier
	Enable  uint16 // value to turn the selector on
	Disable uint16 // value to turn the selector off
}

type AATSettingName struct {
	Setting uint16
	Name    NameID
}

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

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

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

type CaretValueFormat1 int16 // X or Y value, in design units

type CaretValueFormat2 uint16

type CaretValueFormat3 struct {
	Device     DeviceTable
	Coordinate int16 // X or Y value, in design units
}

type ChainedSequenceRule struct {
	SequenceRule
	Backtrack []uint16
	Lookahead []uint16
}

type Class interface {
	// ClassID returns the class ID for the provided glyph. Returns (0, false)
	// for glyphs not covered by this class.
	ClassID(GID) (uint32, bool)

	// GlyphSize returns the number of glyphs covered.
	GlyphSize() int

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

type Cmap = fonts.Cmap

type CmapID struct {
	Platform PlatformID
	Encoding PlatformEncodingID
}

type CmapIter = fonts.CmapIter

type CmapSubtable struct {
	Cmap Cmap
	ID   CmapID
}

type ConditionFormat1 struct {
	Axis uint16 // Index (zero-based) for the variation axis within the 'fvar' table.
	// Minimum and maximum values of the font variation instances
	// that satisfy this condition.
	Min, Max float32
}

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 tables.
	Index(GID) (int, bool)

	// Size return the number of glyphs covered. For non empty Coverages, it is also
	// 1 + (maximum index returned)
	Size() int
}

type CoverageList []GID

type CoverageRange struct {
	Start, End    GID
	StartCoverage int
}

type CoverageRanges []CoverageRange

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 DeviceVariation VariationStoreIndex

type FaceVariable interface {
	// Variations returns the variations for the font,
	// or an empty table for non-variable fonts.
	Variations() TableFvar

	// SetVarCoordinates apply the normalized coordinates values.
	// Use `NormalizeVariations` to convert from design space units.
	// See also `SetVariations`.
	SetVarCoordinates(coords []float32)

	// VarCoordinates returns the current variable coordinates,
	// in normalized units.
	VarCoordinates() []float32

	// NormalizeVariations should normalize the given design-space coordinates.
	// The minimum and maximum values for the axis are mapped to the interval
	// [-1,1], with the default axis value mapped to 0. This should be a no-op
	// for non-variable fonts.
	NormalizeVariations(coords []float32) []float32
}

type Feature struct {
	LookupIndices []uint16
	// contains filtered or unexported fields
}

type FeatureRecord struct {
	Feature
	Tag Tag
}

type FeatureSubstitution struct {
	AlternateFeature Feature
	FeatureIndex     uint16 // The feature table index to match.
}

type FeatureVariation struct {
	ConditionSet         []ConditionFormat1
	FeatureSubstitutions []FeatureSubstitution
}

type Float1616 = float32

type Font struct {
	Names TableName

	Maxp TableMaxp

	Glyf TableGlyf
	Hmtx TableHVmtx

	OS2 *TableOS2 // optional

	// graphite font, optional
	Graphite *GraphiteTables

	Head TableHead

	// NumGlyphs exposes the number of glyph indexes present in the font,
	// as exposed in the 'maxp' table.
	NumGlyphs int // TODO: check usage

	// Type represents the kind of glyphs in this font.
	// It is one of TypeTrueType, TypeTrueTypeApple, TypePostScript1, TypeOpenType
	Type Tag

	// HasHint is true if the font has a prep table.
	HasHint bool

	// A six letter string for PDF inclusion. Empty until Subset() is called.
	SubsetID string
	// contains filtered or unexported fields
}

type FontParser struct {
	Type Tag
	// contains filtered or unexported fields
}

type GID = fonts.GID

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

type GPOSAnchorFormat1 struct {
	X, Y int16 // in design units
}

type GPOSAnchorFormat2 struct {
	GPOSAnchorFormat1
	AnchorPoint uint16
}

type GPOSAnchorFormat3 struct {
	XDevice, YDevice DeviceTable // may be null
	GPOSAnchorFormat1
}

type GPOSChainedContext1 LookupChainedContext1

type GPOSChainedContext2 LookupChainedContext2

type GPOSChainedContext3 LookupChainedContext3

type GPOSContext1 LookupContext1

type GPOSContext2 LookupContext2

type GPOSContext3 LookupContext3

type GPOSCursive1 [][2]GPOSAnchor // entry, exit (may be null)

type GPOSMark struct {
	Anchor     GPOSAnchor
	ClassValue uint16
}

type GPOSMarkToBase1 struct {
	BaseCoverage Coverage
	// same length as the associated Coverage, marks can't be nil
	Marks []GPOSMark
	// one set for each index in `BaseCoverage`, each with same length
	// anchors may be nil
	Bases [][]GPOSAnchor
}

type GPOSMarkToLigature1 struct {
	LigatureCoverage Coverage
	Marks            []GPOSMark       // marks can't be nil
	Ligatures        [][][]GPOSAnchor // one set for each index in `LigatureCoverage`
}

type GPOSMarkToMark1 struct {
	Mark2Coverage Coverage
	Marks1        []GPOSMark
	Marks2        [][]GPOSAnchor // one set for each index in `Mark2Coverage`, each with same length
}

type GPOSPair1 struct {
	// After successul parsing, has one set for each glyph in the coverage
	Values  []GPOSPairSet
	Formats [2]GPOSValueFormat // first, second
}

type GPOSPair2 struct {
	First, Second Class
	// Positionning for first and second glyphs.
	// After successful parsing, it has size First.Extent() x Second.Extent()
	Values  [][][2]GPOSValueRecord
	Formats [2]GPOSValueFormat // first, second
}

type GPOSPairSet []GPOSPairValueRecord

type GPOSPairValueRecord struct {
	Pos         [2]GPOSValueRecord // Positioning data for first and second glyphs
	SecondGlyph GID                // Glyph ID of second glyph in the pair
}

type GPOSSingle1 struct {
	Value  GPOSValueRecord
	Format GPOSValueFormat
}

type GPOSSingle2 struct {
	// After successful parsing, has same length as associated coverage.
	Values []GPOSValueRecord
	Format GPOSValueFormat
}

type GPOSSubtable struct {
	// For GPOSChained - Format 3, its the coverage of the first input.
	Coverage Coverage
	Data     interface{ Type() GPOSType }
}

type GPOSType uint16

type GPOSValueFormat uint16

type GPOSValueRecord struct {
	XPlaDevice DeviceTable // Device table for horizontal placement (may be nil)
	YPlaDevice DeviceTable // Device table for vertical placement (may be nil)
	XAdvDevice DeviceTable // Device table for horizontal advance (may be nil)
	YAdvDevice DeviceTable // Device table for vertical advance (may be nil)
	// format     gposValueFormat
	XPlacement int16 // Horizontal adjustment for placement--in design units
	YPlacement int16 // Vertical adjustment for placement--in design units
	XAdvance   int16 // Horizontal adjustment for advance--in design units (only used for horizontal writing)
	YAdvance   int16 // Vertical adjustment for advance--in design units (only used for vertical writing)
}

type GSUBAlternate1 [][]GID

type GSUBChainedContext1 LookupChainedContext1

type GSUBChainedContext2 LookupChainedContext2

type GSUBChainedContext3 LookupChainedContext3

type GSUBContext1 LookupContext1

type GSUBContext2 LookupContext2

type GSUBContext3 LookupContext3

type GSUBLigature1 [][]LigatureGlyph

type GSUBMultiple1 [][]GID

type GSUBReverseChainedContext1 struct {
	Backtrack   []Coverage
	Lookahead   []Coverage
	Substitutes []GID
}

type GSUBSingle1 int16

type GSUBSingle2 []GID

type GSUBSubtable struct {
	// For SubChaining - Format 3, its the coverage of the first input.
	Coverage Coverage
	Data     interface{ Type() GSUBType }
}

type GSUBType uint16

type GlyphData struct {
	Xmin, Ymin, Xmax, Ymax int16
	// contains filtered or unexported fields
}

type GlyphNames interface {
	// GlyphName return the postscript name of a
	// glyph, or an empty string if it not found
	GlyphName(x GID) string
}

type GlyphProps = uint16

type GraphiteTables struct {
	Sill, Feat, Gloc, Glat, Silf []byte
}

type ItemVariationData struct {
	RegionIndexes []uint16  // Array of indices into the variation region list for the regions referenced by this item variation data table.
	Deltas        [][]int16 // Each row as the same length as `RegionIndexes`
}

type Kern0 []KerningPair

type Kern1 struct {
	Values  []int16 // After successful parsing, may be safely indexed by AATStateEntry.AsKernxIndex() from `Machine`
	Machine AATStateTable
}

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

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

type KernSubtable struct {
	Data interface {
		// contains filtered or unexported methods
	}

	IsExtended bool // `true` for AAT `kerx` subtables
	TupleCount int  // 0 for scalar values
	// contains filtered or unexported fields
}

type KerningPair struct {
	Left, Right GID
	// Note: For 'kerx' table version 4 with tuples, this is
	// the first element of the kerning tuple.
	Value int16
}

type Kerx4 struct {
	Anchors []KerxAnchor
	Machine AATStateTable
	// contains filtered or unexported fields
}

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

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

type KerxAnchorAnchor struct {
	Mark, Current uint16
}

type KerxAnchorControl struct {
	Mark, Current uint16
}

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

type LangSys struct {
	// Features contains the index of the features for this language,
	// relative to the Features slice of the table
	Features []uint16
	// Index of a feature required for this language system.
	// If no required features, default to 0xFFFF
	RequiredFeatureIndex uint16
	Tag                  Tag
}

type LayoutTables struct {
	GDEF TableGDEF // An absent table has a nil Class
	Trak TableTrak
	Ankr TableAnkr
	Feat TableFeat
	Morx TableMorx
	Kern TableKernx
	Kerx TableKernx
	GSUB TableGSUB // An absent table has a nil slice of lookups
	GPOS TableGPOS // An absent table has a nil slice of lookups
}

type LigatureCaretList struct {
	Coverage  Coverage
	LigCarets [][]CaretValue // once successfully parsed, has same length as Coverage.Size()
}

type LigatureGlyph struct {
	// Glyphs composing the ligature, starting after the
	// implicit first glyph, given in the coverage of the
	// SubstitutionLigature table
	Components []uint16
	// Output ligature glyph
	Glyph GID
}

type LookupChainedContext1 [][]ChainedSequenceRule

type LookupChainedContext2 struct {
	BacktrackClass Class
	InputClass     Class
	LookaheadClass Class
	SequenceSets   [][]ChainedSequenceRule
}

type LookupChainedContext3 struct {
	Backtrack       []Coverage
	Input           []Coverage
	Lookahead       []Coverage
	SequenceLookups []SequenceLookup
}

type LookupContext1 [][]SequenceRule

type LookupContext2 struct {
	Class        Class
	SequenceSets [][]SequenceRule
}

type LookupContext3 struct {
	Coverages       []Coverage
	SequenceLookups []SequenceLookup
}

type LookupFlag = uint16

type LookupGPOS struct {
	// After successful parsing, it is a non empty array
	// with all subtables of the same `GPOSType`.
	Subtables []GPOSSubtable
	Type      GPOSType
	LookupOptions
}

type LookupGSUB struct {
	// After successful parsing, all subtables have the `GSUBType`.
	Subtables []GSUBSubtable
	LookupOptions
	Type GSUBType
}

type LookupOptions struct {
	Flag LookupFlag // Lookup qualifiers.
	// Index (base 0) into GDEF mark glyph sets structure,
	// meaningfull only if UseMarkFilteringSet is set.
	MarkFilteringSet uint16 // TODO: sanitize with gdef
}

type Metric struct {
	Advance, SideBearing int16
}

type MortxSubtable struct {
	Data     interface{ Type() MorxSubtableType }
	Coverage uint8  // high byte of the coverage flag
	Flags    uint32 // Mask identifying which subtable this is.
}

type MorxChain struct {
	Features     []AATFeature
	Subtables    []MortxSubtable
	DefaultFlags uint32
}

type MorxContextualSubtable struct {
	Substitutions []Class
	Machine       AATStateTable
}

type MorxInsertionSubtable struct {
	// After successul parsing, this array may be safely
	// indexed by the indexes and counts from Machine entries.
	Insertions []GID
	Machine    AATStateTable
}

type MorxLigatureSubtable struct {
	LigatureAction []uint32
	Component      []uint16
	Ligatures      []GID
	Machine        AATStateTable
}

type MorxNonContextualSubtable struct {
	Class // the lookup value is interpreted as a GlyphIndex
}

type MorxRearrangementSubtable AATStateTable

type MorxSubtableType uint8

type NameEntry struct {
	Value      []byte // raw value of the name
	PlatformID PlatformID
	EncodingID PlatformEncodingID
	LanguageID PlatformLanguageID
	NameID     NameID
}

type NameID uint16

type PlatformEncodingID uint16

type PlatformID uint16

type PlatformLanguageID uint16

type Script struct {
	DefaultLanguage *LangSys
	Languages       []LangSys
	Tag             Tag
}

type SequenceLookup struct {
	InputIndex  uint16 // Index (zero-based) into the input glyph sequence
	LookupIndex uint16 // Index (zero-based) into the LookupList
}

type SequenceRule struct {
	// Starts with the second glyph
	// For format1, it is interpreted as GlyphIndex, for format 2, as ClassID
	Input   []uint16
	Lookups []SequenceLookup
}

type SimpleKerns interface {
	// KernPair return the kern value for the given pair, or zero.
	// The value is expressed in glyph units and
	// is negative when glyphs should be closer.
	KernPair(left, right GID) int16
}

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

type TableCmap struct {
	Cmaps []CmapSubtable
	// contains filtered or unexported fields
}

type TableFeat []AATFeatureName

type TableFvar struct {
	Axis      []VarAxis
	Instances []VarInstance // contains the default instance
}

type TableGDEF struct {
	// Identify the class of the glyph:
	//	1:	Base glyph, single character, spacing glyph
	//	2:	Ligature glyph (multiple character, spacing glyph)
	//	3:	Mark glyph (non-spacing combining glyph)
	//	4:	Component glyph (part of single character, spacing glyph)
	// May be nil
	Class Class
	// Class to which a mark glyph may belong (may be nil)
	MarkAttach        Class
	MarkGlyphSet      []Coverage        // used in GSUB and GPOS lookups to filter which marks in a string are considered or ignored
	VariationStore    VariationStore    // for variable fonts, may be empty
	LigatureCaretList LigatureCaretList // optional
}

type TableGPOS struct {
	Lookups []LookupGPOS
	TableLayout
}

type TableGSUB struct {
	Lookups []LookupGSUB
	TableLayout
}

type TableGlyf []GlyphData // length numGlyphs

type TableHVhea struct {
	Ascent               int16 // typoAscent in version 1.1
	Descent              int16 // typoDescent in version 1.1
	LineGap              int16 // typoLineGap in version 1.1
	AdvanceMax           uint16
	MinFirstSideBearing  int16 // left/top
	MinSecondSideBearing int16 // right/bottom
	MaxExtent            int16
	CaretSlopeRise       int16
	CaretSlopeRun        int16
	CaretOffset          int16

	MetricDataFormat int16
	NumberOfHMetrics uint16
	// contains filtered or unexported fields
}

type TableHVmtx []Metric // with length numGlyphs

type TableHead struct {
	Created      longdatetime
	Updated      longdatetime
	FontRevision uint32

	UnitsPerEm    uint16
	Flags         uint16
	XMin          int16
	YMin          int16
	XMax          int16
	YMax          int16
	MacStyle      uint16
	LowestRecPPEM uint16
	FontDirection int16
	// contains filtered or unexported fields
}

type TableKernx []KernSubtable

type TableLayout struct {
	Scripts           []Script
	Features          []FeatureRecord
	FeatureVariations []FeatureVariation
	// contains filtered or unexported fields
}

type TableMaxp struct {
	Version               uint32
	NumGlyphs             uint16
	MaxPoints             uint16
	MaxContours           uint16
	MaxCompositePoints    uint16
	MaxCompositeContours  uint16
	MaxZones              uint16
	MaxTwilightPoints     uint16
	MaxStorage            uint16
	MaxFunctionDefs       uint16
	MaxInstructionDefs    uint16
	MaxStackElements      uint16
	MaxSizeOfInstructions uint16
	MaxComponentElements  uint16
	MaxComponentDepth     uint16
}

type TableMorx []MorxChain

type TableMvar struct {
	Values []VarValueRecord // sorted by tag
	Store  VariationStore
}

type TableName []NameEntry

type TableOS2 struct {
	TableOS2Version4

	UsLowerPointSize uint16
	UsUpperPointSize uint16
}

type TableOS2Version0 struct {
	Version             uint16
	XAvgCharWidth       uint16
	USWeightClass       uint16
	USWidthClass        uint16
	FSType              uint16
	YSubscriptXSize     int16
	YSubscriptYSize     int16
	YSubscriptXOffset   int16
	YSubscriptYOffset   int16
	YSuperscriptXSize   int16
	YSuperscriptYSize   int16
	YSuperscriptXOffset int16
	YSuperscriptYOffset int16
	YStrikeoutSize      int16
	YStrikeoutPosition  int16
	SFamilyClass        int16
	Panose              [10]byte
	UlCharRange         [4]uint32
	AchVendID           Tag
	FsSelection         uint16
	USFirstCharIndex    uint16
	USLastCharIndex     uint16
	STypoAscender       int16
	STypoDescender      int16
	STypoLineGap        int16
	UsWinAscent         uint16
	UsWinDescent        uint16
}

type TableOS2Version1 struct {
	TableOS2Version0

	UlCodePageRange1 uint32
	UlCodePageRange2 uint32
}

type TableOS2Version4 struct {
	TableOS2Version1

	SxHeigh       int16
	SCapHeight    int16
	UsDefaultChar uint16
	UsBreakChar   uint16
	UsMaxContext  uint16
}

type TablePost struct {
	// Names stores the glyph names. It may be nil.
	Names GlyphNames
	// ItalicAngle in counter-clockwise degrees from the vertical. Zero for
	// upright text, negative for text that leans to the right (forward).
	ItalicAngle float64
	// Version of the version tag of the "post" table.
	Version uint32
	// UnderlinePosition is the suggested distance of the top of the
	// underline from the baseline (negative values indicate below baseline).
	UnderlinePosition int16
	// Suggested values for the underline thickness.
	UnderlineThickness int16
	// IsFixedPitch indicates that the font is not proportionally spaced
	// (i.e. monospaced).
	IsFixedPitch bool
}

type TableTrak struct {
	Horizontal, Vertical TrakData // may be empty
}

type Tag uint32

type TrackEntry struct {
	PerSizeTracking []int16 // in font units, with length len(Sizes)
	Track           float32
	NameIndex       NameID
}

type TrakData struct {
	Entries []TrackEntry
	Sizes   []float32
}

type VarAxis struct {
	Tag     Tag       // Tag identifying the design variation for the axis.
	Minimum Float1616 // minium value on the variation axis that the font covers
	Default Float1616 // default position on the axis
	Maximum Float1616 // maximum value on the variation axis that the font covers
	// contains filtered or unexported fields
}

type VarInstance struct {
	Coords    []float32 // in design units; length: number of axis
	Subfamily NameID

	PSStringID NameID
}

type VarValueRecord struct {
	Tag   Tag
	Index VariationStoreIndex
}

type Variation struct {
	Tag   Tag     // variation-axis identifier tag
	Value float32 // in design units
}

type VariationRegion [3]float32

type VariationStore struct {
	Regions [][]VariationRegion // for each region, for each axis
	Datas   []ItemVariationData
}

type VariationStoreIndex struct {
	DeltaSetOuter, DeltaSetInner uint16
}