ot

package

Go to main page

Versions in this module

v0

v0.0.7

Feb 5, 2026

Changes in this version

type Face

+ func (f *Face) GlyphOutline(gid GlyphID) (GlyphOutline, bool)

+ type GlyphOutline struct

+ Segments []Segment

+ type OutlinePoint struct

+ X float32

+ Y float32

+ type Segment struct

+ Args [3]OutlinePoint

+ Op SegmentOp

+ type SegmentOp uint8

+ const SegmentCubeTo

+ const SegmentLineTo

+ const SegmentMoveTo

+ const SegmentQuadTo

v0.0.6

Feb 5, 2026

Changes in this version

+ var TagVORG = MakeTag('V', 'O', 'R', 'G')

+ var TagVhea = MakeTag('v', 'h', 'e', 'a')

+ var TagVmtx = MakeTag('v', 'm', 't', 'x')

type Buffer

+ ClusterLevel int

+ NotFoundVSGlyph int

+ RandomState uint32

type Codepoint

+ func BidiMirror(cp Codepoint) Codepoint

type Feature

+ Random bool

type GSUB

+ func (g *GSUB) ApplyFeatureToBufferWithOpts(tag Tag, buf *Buffer, gdef *GDEF, font *Font, autoZWNJ, autoZWJ bool)

type Glyf

+ func (g *Glyf) GetContourPointCount(gid GlyphID) int

type GlyphInfo

+ HangulFeature uint8

+ type LongVerMetric struct

+ AdvanceHeight uint16

+ Tsb int16

type OTApplyContext

+ func (ctx *OTApplyContext) NextInputMatch(startIndex int, matchFn ContextMatchFunc) int

+ func (ctx *OTApplyContext) RandomNumber() uint32

type Shaper

+ func (s *Shaper) GetGlyphHAdvanceVar(glyph GlyphID) uint16

+ func (s *Shaper) GetGlyphVOrigin(glyph GlyphID) (x, y int16)

+ func (s *Shaper) SetSyntheticBold(x, y float32, inPlace bool)

+ func (s *Shaper) SetSyntheticSlant(slant float32)

+ func (s *Shaper) SyntheticBold() (x, y float32, inPlace bool)

+ func (s *Shaper) SyntheticSlant() float32

+ type VORG struct

+ func ParseVORG(data []byte) (*VORG, error)

+ func (v *VORG) GetVertOriginY(glyph GlyphID) int16

+ type Vhea struct

+ AdvanceHeightMax uint16

+ Ascender int16

+ CaretOffset int16

+ CaretSlopeRise int16

+ CaretSlopeRun int16

+ Descender int16

+ LineGap int16

+ MetricDataFormat int16

+ MinBottomSideBearing int16

+ MinTopSideBearing int16

+ NumberOfVMetrics uint16

+ Version uint32

+ YMaxExtent int16

+ func ParseVhea(data []byte) (*Vhea, error)

+ type Vmtx struct

+ func ParseVmtx(data []byte, numberOfVMetrics, numGlyphs int) (*Vmtx, error)

+ func (v *Vmtx) GetAdvanceHeight(glyph GlyphID) uint16

+ func (v *Vmtx) GetTsb(glyph GlyphID) int16

v0.0.5

Feb 2, 2026

Changes in this version

+ const MaskRphf

type Buffer

+ LanguageCandidates []Tag

+ PostContext []Codepoint

+ PreContext []Codepoint

+ type ContextMatchFunc func(info *GlyphInfo) bool

type Feature

+ ManualZWJ bool

+ PerSyllable bool

type GSUB

+ func (g *GSUB) ApplyFeatureToBufferLangSysOnly(tag Tag, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font, ...)

+ func (g *GSUB) ApplyFeatureToBufferRangeWithOpts(tag Tag, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font, ...)

+ func (g *GSUB) FindBestLanguage(scriptTag Tag, languageTags []Tag) Tag

type GlyphInfo

+ USECategory uint8

type OTApplyContext

+ MatchSyllable uint8

+ func (ctx *OTApplyContext) MayMatchInfo(info *GlyphInfo, contextMatch bool) MayMatchResult

+ func (ctx *OTApplyContext) NextContextMatch(startIndex int, matchFn ContextMatchFunc) int

+ func (ctx *OTApplyContext) PrevContextMatch(startIndex int, matchFn ContextMatchFunc) int

type OTMap

+ FeatureMasks map[Tag]featureMaskEntry

type ScriptList

+ func (sl *ScriptList) FindBestLanguage(scriptTag Tag, languageTags []Tag) Tag

type USESyllableInfo

+ Codepoint Codepoint

v0.0.4

Jan 29, 2026

Changes in this version

+ const FontPageHebrew

+ const FontPageNone

+ const FontPageOEMArabic

+ const FontPageSimpArabic

+ const FontPageSimpFarsi

+ const FontPageThai

+ const FontPageTradArabic

+ const FontPageTradFarsi

+ const GC_Cc

+ const GC_Cf

+ const GC_Cn

+ const GC_Co

+ const GC_Cs

+ const GC_Ll

+ const GC_Lm

+ const GC_Lo

+ const GC_Lt

+ const GC_Lu

+ const GC_Mc

+ const GC_Me

+ const GC_Mn

+ const GC_Nd

+ const GC_Nl

+ const GC_No

+ const GC_Pc

+ const GC_Pd

+ const GC_Pe

+ const GC_Pf

+ const GC_Pi

+ const GC_Po

+ const GC_Ps

+ const GC_Sc

+ const GC_Sk

+ const GC_Sm

+ const GC_So

+ const GC_Zl

+ const GC_Zp

+ const GC_Zs

+ const GlyphPropsBaseGlyph

+ const GlyphPropsDefaultIgnorable

+ const GlyphPropsHidden

+ const GlyphPropsLigated

+ const GlyphPropsLigature

+ const GlyphPropsMark

+ const GlyphPropsMultiplied

+ const GlyphPropsPreserve

+ const GlyphPropsSubstituted

+ const GlyphPropsZWJ

+ const GlyphPropsZWNJ

+ const HBMaxNestingLevel

+ const MaskArabicPositional

+ const MaskFin2

+ const MaskFin3

+ const MaskFina

+ const MaskGlobal

+ const MaskInit

+ const MaskIsol

+ const MaskMed2

+ const MaskMedi

+ const MaxCombiningMarks

+ const MaxNestingLevel

+ const VariationsNotFoundIndex

+ var ArabicShaper = &OTShaper

+ var BCP47ToOpenType = map[string][]Tag

+ var DefaultShaper = &OTShaper

+ var HangulShaper = &OTShaper

+ var HebrewShaper = &OTShaper

+ var IndicShaper = &OTShaper

+ var KhmerShaper = &OTShaper

+ var MyanmarShaper = &OTShaper

+ var OpenTypeToBCP47 = map[Tag]string

+ var QaagShaper = &OTShaper

+ var TagAbvm = MakeTag('a', 'b', 'v', 'm')

+ var TagBlwm = MakeTag('b', 'l', 'w', 'm')

+ var TagCurs = MakeTag('c', 'u', 'r', 's')

+ var TagDist = MakeTag('d', 'i', 's', 't')

+ var TagKernTable = MakeTag('k', 'e', 'r', 'n')

+ var TagMlym = MakeTag('M', 'l', 'y', 'm')

+ var TagTaml = MakeTag('T', 'a', 'm', 'l')

+ var ThaiShaper = &OTShaper

+ var USEShaper = &OTShaper

+ var VowelConstraints = map[string][]VowelConstraint

+ func CheckVowelConstraints(codepoints []Codepoint, pos int, script Tag) int

+ func FindSyllablesIndic(info []IndicInfo) (hasBroken bool)

+ func FindSyllablesKhmer(buf *Buffer, categories []KhmerCategory) (hasBroken bool)

+ func FindSyllablesMyanmar(buf *Buffer, categories []MyanmarCategory) (hasBroken bool)

+ func FindSyllablesUSE(syllables []USESyllableInfo) (hasBroken bool)

+ func GetIndicCategories(u Codepoint) (IndicCategory, IndicPosition)

+ func IsDefaultIgnorable(cp Codepoint) bool

+ func IsIndicConsonant(cat IndicCategory) bool

+ func IsIndicHalant(cat IndicCategory) bool

+ func IsIndicJoiner(cat IndicCategory) bool

+ func IsPositionalFeature(tag Tag) bool

+ func IsScriptCommon(cp Codepoint) bool

+ func IsUnicodeMark(cp Codepoint) bool

+ func IsVariationSelector(cp Codepoint) bool

+ func NeedsVowelConstraintProcessing(script Tag) bool

+ func PreprocessVowelConstraints(buf *Buffer)

+ func PropagateAttachmentOffsets(positions []GlyphPos, direction Direction)

+ func SetDebugGPOS(enabled bool)

+ func TagToLanguage(tag Tag) string

+ type ArabicAction uint8

+ type BasePos uint8

+ const BasePosFirst

+ const BasePosLast

+ const BasePosLastSinhala

+ type BlwfMode uint8

+ const BlwfModePostOnly

+ const BlwfModePreAndPost

type Buffer

+ Idx int

+ ScratchFlags ScratchFlags

+ func (b *Buffer) AllocateLigID() uint8

+ func (b *Buffer) BacktrackInfo(pos int) *GlyphInfo

+ func (b *Buffer) BacktrackLen() int

+ func (b *Buffer) Codepoints() []Codepoint

+ func (b *Buffer) HaveOutput() bool

+ func (b *Buffer) MergeClusters(start, end int)

+ func (b *Buffer) Reverse()

+ func (b *Buffer) ReverseRange(start, end int)

+ func (buf *Buffer) AddMasks(mask uint32)

+ func (buf *Buffer) ResetMasks(mask uint32)

+ func (buf *Buffer) SetMasksForClusterRange(value, mask uint32, clusterStart, clusterEnd int)

type CFF

+ func (c *CFF) GetGlyphFromName(name string) (GlyphID, bool)

+ func (c *CFF) GetGlyphName(glyph GlyphID) string

type Cmap

+ func (c *Cmap) IsSymbol() bool

+ func (c *Cmap) SetFontPage(fontPage uint16)

type Codepoint

+ const DottedCircle

+ func ArabicPUASimpMap(u Codepoint) Codepoint

+ func ArabicPUATradMap(u Codepoint) Codepoint

+ func Compose(first, second Codepoint) (composed Codepoint, ok bool)

+ func Decompose(cp Codepoint) (first, second Codepoint, ok bool)

+ func SymbolPUAMap(u Codepoint) Codepoint

+ type Condition struct

+ func (c *Condition) Evaluate(coords []int) bool

+ type ConditionSet struct

+ func (cs *ConditionSet) Evaluate(coords []int) bool

+ type Decomposition struct

+ First Codepoint

+ Second Codepoint

type Direction

+ func GetHorizontalDirection(script Tag) Direction

+ func (d Direction) IsBackward() bool

+ func (d Direction) IsForward() bool

+ func (d Direction) IsValid() bool

+ func (d Direction) IsVertical() bool

+ func (d Direction) Reverse() Direction

type FeatureList

+ func (f *FeatureList) FindFeatureByIndices(tag Tag, featureIndices []uint16) []uint16

+ func (f *FeatureList) FindFeatureByIndicesWithVariations(tag Tag, featureIndices []uint16, fv *FeatureVariations, ...) []uint16

+ func (f *FeatureList) FindFeatureWithVariations(tag Tag, fv *FeatureVariations, variationsIndex uint32) []uint16

+ func (f *FeatureList) FindFirstFeature(tag Tag) []uint16

+ type FeatureMap struct

+ func NewFeatureMap() *FeatureMap

+ func (fm *FeatureMap) GetMask(tag Tag) uint32

+ type FeatureTableSubstitution struct

+ type FeatureVariations struct

+ func ParseFeatureVariations(data []byte, offset int) (*FeatureVariations, error)

+ func (fv *FeatureVariations) FindIndex(coords []int) uint32

+ func (fv *FeatureVariations) GetSubstituteLookups(variationsIndex uint32, featureIndex uint16) []uint16

+ func (fv *FeatureVariations) RecordCount() int

type Font

+ func (f *Font) GetGlyphFromName(name string) (GlyphID, bool)

+ func (f *Font) GetGlyphName(glyph GlyphID) string

+ func (f *Font) HasGlyph(cp Codepoint) bool

+ func (f *Font) HasGlyphNames() bool

type GPOS

+ func (g *GPOS) ApplyLookupToBuffer(lookupIndex int, buf *Buffer, gdef *GDEF, font *Font)

+ func (g *GPOS) ApplyLookupToBufferWithMask(lookupIndex int, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font)

+ func (g *GPOS) FindVariationsIndex(coords []int) uint32

+ func (g *GPOS) GetFeatureVariations() *FeatureVariations

+ func (g *GPOS) ParseScriptList() (*ScriptList, error)

type GSUB

+ func (g *GSUB) ApplyFeatureToBuffer(tag Tag, buf *Buffer, gdef *GDEF, font *Font)

+ func (g *GSUB) ApplyFeatureToBufferRangeWithMask(tag Tag, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font, ...)

+ func (g *GSUB) ApplyFeatureToBufferWithMask(tag Tag, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font)

+ func (g *GSUB) ApplyFeatureToBufferWithMaskAndVariations(tag Tag, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font, ...)

+ func (g *GSUB) ApplyFeatureWithCodepoints(tag Tag, glyphs []GlyphID, codepoints []Codepoint, gdef *GDEF, font *Font) ([]GlyphID, []Codepoint)

+ func (g *GSUB) ApplyFeatureWithMask(tag Tag, glyphs []GlyphID, masks []uint32, featureMask uint32, gdef *GDEF, ...) ([]GlyphID, []uint32)

+ func (g *GSUB) ApplyLookupToBuffer(lookupIndex int, buf *Buffer, gdef *GDEF, font *Font)

+ func (g *GSUB) ApplyLookupToBufferRangeWithMask(lookupIndex int, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font, ...)

+ func (g *GSUB) ApplyLookupToBufferWithMask(lookupIndex int, buf *Buffer, gdef *GDEF, featureMask uint32, font *Font)

+ func (g *GSUB) ApplyLookupWithCodepoints(lookupIndex int, glyphs []GlyphID, codepoints []Codepoint, gdef *GDEF, ...) ([]GlyphID, []Codepoint)

+ func (g *GSUB) ApplyLookupWithMask(lookupIndex int, glyphs []GlyphID, masks []uint32, featureMask uint32, ...) ([]GlyphID, []uint32)

+ func (g *GSUB) FindChosenScriptTag(scriptTag Tag) Tag

+ func (g *GSUB) FindVariationsIndex(coords []int) uint32

+ func (g *GSUB) GetFeatureVariations() *FeatureVariations

+ func (g *GSUB) ParseScriptList() (*ScriptList, error)

+ func (g *GSUB) WouldSubstituteFeature(featureTag Tag, glyphs []GlyphID, zeroContext bool) bool

type GSUBLookup

+ func (l *GSUBLookup) WouldSubstitute(glyphs []GlyphID, zeroContext bool) bool

+ type GeneralCategory uint8

+ const GCClosePunctuation

+ const GCConnectPunctuation

+ const GCControl

+ const GCCurrencySymbol

+ const GCDashPunctuation

+ const GCDecimalNumber

+ const GCEnclosingMark

+ const GCFinalPunctuation

+ const GCFormat

+ const GCInitialPunctuation

+ const GCLetterNumber

+ const GCLineSeparator

+ const GCLowercaseLetter

+ const GCMathSymbol

+ const GCModifierLetter

+ const GCModifierSymbol

+ const GCNonSpacingMark

+ const GCOpenPunctuation

+ const GCOtherLetter

+ const GCOtherNumber

+ const GCOtherPunctuation

+ const GCOtherSymbol

+ const GCParagraphSeparator

+ const GCPrivateUse

+ const GCSpaceSeparator

+ const GCSpacingMark

+ const GCSurrogate

+ const GCTitlecaseLetter

+ const GCUnassigned

+ const GCUppercaseLetter

type Glyf

+ func (g *Glyf) GetGlyphExtents(gid GlyphID) (GlyphExtents, bool)

type GlyphInfo

+ ArabicShapingAction uint8

+ GlyphProps uint16

+ IndicCategory uint8

+ IndicPosition uint8

+ LigProps uint8

+ Mask uint32

+ ModifiedCCC uint8

+ MyanmarCategory uint8

+ MyanmarPosition uint8

+ Syllable uint8

+ func (g *GlyphInfo) GetLigComp() uint8

+ func (g *GlyphInfo) GetLigID() uint8

+ func (g *GlyphInfo) GetLigNumComps() int

+ func (g *GlyphInfo) IsBaseGlyph() bool

+ func (g *GlyphInfo) IsLigated() bool

+ func (g *GlyphInfo) IsLigature() bool

+ func (g *GlyphInfo) IsMark() bool

+ func (g *GlyphInfo) IsMultiplied() bool

+ func (g *GlyphInfo) SetLigPropsForComponent(compIdx int)

+ func (g *GlyphInfo) SetLigPropsForLigature(ligID uint8, numComps int)

+ func (g *GlyphInfo) SetLigPropsForMark(ligID uint8, ligComp int)

type GlyphPos

+ AttachChain int16

+ AttachType uint8

+ type IndicCategory uint8

+ const ICatA

+ const ICatC

+ const ICatCM

+ const ICatCS

+ const ICatDOTTEDCIRCLE

+ const ICatH

+ const ICatM

+ const ICatMPst

+ const ICatN

+ const ICatPLACEHOLDER

+ const ICatRS

+ const ICatRa

+ const ICatRepha

+ const ICatSM

+ const ICatSMPst

+ const ICatSymbol

+ const ICatV

+ const ICatX

+ const ICatZWJ

+ const ICatZWNJ

+ func GetIndicCategory(cp Codepoint) IndicCategory

+ type IndicConfig struct

+ BasePos BasePos

+ BlwfMode BlwfMode

+ HasOldSpec bool

+ RephMode RephMode

+ RephPos IndicPosition

+ Script Tag

+ Virama Codepoint

+ type IndicFeatureIndex int

+ type IndicInfo struct

+ Category IndicCategory

+ Position IndicPosition

+ Syllable uint8

+ type IndicPlan struct

+ type IndicPosition uint8

+ const IPosAboveC

+ const IPosAfterMain

+ const IPosAfterPost

+ const IPosAfterSub

+ const IPosBaseC

+ const IPosBeforePost

+ const IPosBeforeSub

+ const IPosBelowC

+ const IPosEnd

+ const IPosPostC

+ const IPosPreC

+ const IPosPreM

+ const IPosRaToBeReph

+ const IPosSMVD

+ const IPosStart

+ type IndicShapingInfo struct

+ Category IndicCategory

+ Position IndicPosition

+ Syllable uint8

+ type IndicSyllableType uint8

+ const IndicBrokenCluster

+ const IndicConsonantSyllable

+ const IndicNonIndicCluster

+ const IndicStandaloneCluster

+ const IndicSymbolCluster

+ const IndicVowelSyllable

+ type JoiningForm uint8

+ const JoiningFormFina

+ const JoiningFormInit

+ const JoiningFormIsol

+ const JoiningFormMedi

+ const JoiningFormNone

+ type JoiningType uint8

+ func GetJoiningTypeDebug(u Codepoint) JoiningType

+ type Kern struct

+ func ParseKern(data []byte, numGlyphs int) (*Kern, error)

+ func (k *Kern) HasKerning() bool

+ func (k *Kern) KernPair(left, right GlyphID) int16

+ type KhmerCategory uint8

+ const K_C

+ const K_DottedCircle

+ const K_H

+ const K_N

+ const K_Other

+ const K_Placeholder

+ const K_Ra

+ const K_Robatic

+ const K_V

+ const K_VAbv

+ const K_VBlw

+ const K_VPre

+ const K_VPst

+ const K_Xgroup

+ const K_Ygroup

+ const K_ZWJ

+ const K_ZWNJ

+ type KhmerSyllableType uint8

+ const KhmerBrokenCluster

+ const KhmerConsonantSyllable

+ const KhmerNonKhmerCluster

+ type LangSys struct

+ FeatureIndices []uint16

+ RequiredFeature int

+ type LookupMap struct

+ AutoZWJ bool

+ AutoZWNJ bool

+ FeatureTag Tag

+ Index uint16

+ Mask uint32

+ PerSyllable bool

+ Random bool

+ type MayMatchResult int

+ const MatchMaybe

+ const MatchNo

+ const MatchYes

+ type MaySkipResult int

+ const SkipMaybe

+ const SkipNo

+ const SkipYes

+ type MyanmarCategory uint8

+ const M_A

+ const M_As

+ const M_C

+ const M_CS

+ const M_DB

+ const M_DottedCircle

+ const M_GB

+ const M_H

+ const M_IV

+ const M_MH

+ const M_ML

+ const M_MR

+ const M_MW

+ const M_MY

+ const M_Other

+ const M_PT

+ const M_Ra

+ const M_SM

+ const M_SMPst

+ const M_VAbv

+ const M_VBlw

+ const M_VPre

+ const M_VPst

+ const M_VS

+ const M_ZWJ

+ const M_ZWNJ

+ type MyanmarPosition uint8

+ const M_POS_ABOVE_C

+ const M_POS_AFTER_MAIN

+ const M_POS_AFTER_POST

+ const M_POS_AFTER_SUB

+ const M_POS_BASE_C

+ const M_POS_BEFORE_POST

+ const M_POS_BEFORE_SUB

+ const M_POS_BELOW_C

+ const M_POS_END

+ const M_POS_POST_C

+ const M_POS_PRE_C

+ const M_POS_PRE_M

+ const M_POS_RA_TO_BECOME_REPH

+ const M_POS_SMVD

+ const M_POS_START

+ type MyanmarSyllableType uint8

+ const MyanmarBrokenCluster

+ const MyanmarConsonantSyllable

+ const MyanmarNonMyanmarCluster

+ type NormalizationMode int

+ const NormalizationModeAuto

+ const NormalizationModeComposedDiacritics

+ const NormalizationModeDecomposed

+ const NormalizationModeNone

+ type NormalizeContext struct

+ Buffer *Buffer

+ Font *Font

+ Plan *ShapePlan

+ Shaper *Shaper

+ type OTApplyContext struct

+ AutoZWJ bool

+ AutoZWNJ bool

+ Buffer *Buffer

+ Direction Direction

+ FeatureMask uint32

+ Font *Font

+ GDEF *GDEF

+ HasGlyphClasses bool

+ LastBase int

+ LastBaseUntil int

+ LookupFlag uint16

+ LookupIndex int

+ MarkFilteringSet int

+ MatchPositions []int

+ NestingLevel int

+ NewSyllables int

+ PerSyllable bool

+ Random bool

+ RangeEnd int

+ RangeStart int

+ RecurseFunc func(ctx *OTApplyContext, lookupIndex int) bool

+ TableType TableType

+ func NewOTApplyContext(tableType TableType, buf *Buffer, font *Font, gdef *GDEF) *OTApplyContext

+ func (ctx *OTApplyContext) AdjustPosition(index int, vr *ValueRecord)

+ func (ctx *OTApplyContext) CheckGlyphProperty(info *GlyphInfo) bool

+ func (ctx *OTApplyContext) DeleteGlyph()

+ func (ctx *OTApplyContext) IsDefaultIgnorableAt(index int) bool

+ func (ctx *OTApplyContext) IsVariationSelectorAt(index int) bool

+ func (ctx *OTApplyContext) LigatePositions(ligGlyph GlyphID, positions []int)

+ func (ctx *OTApplyContext) MatchPropertiesMark(info *GlyphInfo, glyphProps uint16) bool

+ func (ctx *OTApplyContext) MayMatch(index int, contextMatch bool) MayMatchResult

+ func (ctx *OTApplyContext) MaySkip(index int, contextMatch bool) MaySkipResult

+ func (ctx *OTApplyContext) MaySkipInfo(info *GlyphInfo, contextMatch bool) MaySkipResult

+ func (ctx *OTApplyContext) MergeClusters(start, end int)

+ func (ctx *OTApplyContext) NextContextGlyph(startIndex int) int

+ func (ctx *OTApplyContext) NextGlyph(startIndex int) int

+ func (ctx *OTApplyContext) OutputGlyphForComponent(newGlyph GlyphID, classGuess int)

+ func (ctx *OTApplyContext) PrevContextGlyph(startIndex int) int

+ func (ctx *OTApplyContext) PrevGlyph(startIndex int) int

+ func (ctx *OTApplyContext) Recurse(lookupIndex int) bool

+ func (ctx *OTApplyContext) ReplaceGlyph(newGlyph GlyphID)

+ func (ctx *OTApplyContext) ReplaceGlyphInplace(newGlyph GlyphID)

+ func (ctx *OTApplyContext) ReplaceGlyphWithLigature(newGlyph GlyphID, classGuess int)

+ func (ctx *OTApplyContext) ReplaceGlyphs(newGlyphs []GlyphID)

+ func (ctx *OTApplyContext) SetAutoZWJ(autoZWJ bool)

+ func (ctx *OTApplyContext) SetAutoZWNJ(autoZWNJ bool)

+ func (ctx *OTApplyContext) SetLookupMask(mask uint32)

+ func (ctx *OTApplyContext) SetLookupProps(props uint16)

+ func (ctx *OTApplyContext) SetMarkFilteringSet(set int)

+ func (ctx *OTApplyContext) SetPerSyllable(perSyllable bool)

+ func (ctx *OTApplyContext) SetRandom(random bool)

+ func (ctx *OTApplyContext) ShouldSkipContextGlyph(index int) bool

+ func (ctx *OTApplyContext) ShouldSkipGlyph(index int) bool

+ type OTMap struct

+ GPOSLookups []LookupMap

+ GSUBLookups []LookupMap

+ GlobalMask uint32

+ func CompileMap(gsub *GSUB, gpos *GPOS, features []Feature, scriptTag Tag, languageTag Tag) *OTMap

+ func NewOTMap() *OTMap

+ func (m *OTMap) AddGPOSFeature(tag Tag, mask uint32, required bool)

+ func (m *OTMap) AddGPOSLookup(index uint16, mask uint32, featureTag Tag)

+ func (m *OTMap) AddGSUBFeature(tag Tag, mask uint32, required bool)

+ func (m *OTMap) AddGSUBLookup(index uint16, mask uint32, featureTag Tag)

+ func (m *OTMap) ApplyGPOS(gpos *GPOS, buf *Buffer, font *Font, gdef *GDEF)

+ func (m *OTMap) ApplyGSUB(gsub *GSUB, buf *Buffer, font *Font, gdef *GDEF)

+ type OTShaper struct

+ CollectFeatures func(plan *ShapePlan)

+ Compose func(c *NormalizeContext, a, b Codepoint) (ab Codepoint, ok bool)

+ DataCreate func(plan *ShapePlan) interface{}

+ DataDestroy func(data interface{})

+ Decompose func(c *NormalizeContext, ab Codepoint) (a, b Codepoint, ok bool)

+ FallbackPosition bool

+ GPOSTag Tag

+ Name string

+ NormalizationPreference NormalizationMode

+ OverrideFeatures func(plan *ShapePlan)

+ PostprocessGlyphs func(plan *ShapePlan, buf *Buffer, font *Font)

+ PreprocessText func(plan *ShapePlan, buf *Buffer, font *Font)

+ ReorderMarks func(plan *ShapePlan, buf *Buffer, start, end int)

+ SetupMasks func(plan *ShapePlan, buf *Buffer, font *Font)

+ ZeroWidthMarks ZeroWidthMarksType

+ func SelectShaper(script Tag, direction Direction) *OTShaper

+ func SelectShaperWithFont(script Tag, direction Direction, fontScriptTag Tag) *OTShaper

+ type PostTable struct

+ IsFixedPitch uint32

+ ItalicAngle int32

+ UnderlinePosition int16

+ UnderlineThickness int16

+ Version uint32

+ func ParsePostTable(data []byte) (*PostTable, error)

+ func (p *PostTable) GetGlyphFromName(name string) (GlyphID, bool)

+ func (p *PostTable) GetGlyphName(glyph GlyphID) string

+ func (p *PostTable) HasGlyphNames() bool

type PrivateDict

+ StemSnapH []int

+ StemSnapV []int

+ type ReorderMarksCallback func(info []GlyphInfo, start, end int)

+ type RephMode uint8

+ const RephModeExplicit

+ const RephModeImplicit

+ const RephModeLogRepha

+ type ScratchFlags uint32

+ const ScratchFlagArabicHasStch

+ type Script uint8

+ const ScriptAdlam

+ const ScriptAhom

+ const ScriptAnatolianHieroglyphs

+ const ScriptArabic

+ const ScriptArmenian

+ const ScriptAvestan

+ const ScriptBalinese

+ const ScriptBamum

+ const ScriptBassaVah

+ const ScriptBatak

+ const ScriptBengali

+ const ScriptBeriaErfe

+ const ScriptBhaiksuki

+ const ScriptBopomofo

+ const ScriptBrahmi

+ const ScriptBraille

+ const ScriptBuginese

+ const ScriptBuhid

+ const ScriptCanadianSyllabics

+ const ScriptCarian

+ const ScriptCaucasianAlbanian

+ const ScriptChakma

+ const ScriptCham

+ const ScriptCherokee

+ const ScriptChorasmian

+ const ScriptCommon

+ const ScriptCoptic

+ const ScriptCuneiform

+ const ScriptCypriot

+ const ScriptCyproMinoan

+ const ScriptCyrillic

+ const ScriptDeseret

+ const ScriptDevanagari

+ const ScriptDivesAkuru

+ const ScriptDogra

+ const ScriptDuployan

+ const ScriptEgyptianHieroglyphs

+ const ScriptElbasan

+ const ScriptElymaic

+ const ScriptEthiopic

+ const ScriptGaray

+ const ScriptGeorgian

+ const ScriptGlagolitic

+ const ScriptGothic

+ const ScriptGrantha

+ const ScriptGreek

+ const ScriptGujarati

+ const ScriptGunjalaGondi

+ const ScriptGurmukhi

+ const ScriptGurungKhema

+ const ScriptHan

+ const ScriptHangul

+ const ScriptHanifiRohingya

+ const ScriptHanunoo

+ const ScriptHatran

+ const ScriptHebrew

+ const ScriptHiragana

+ const ScriptImperialAramaic

+ const ScriptInherited

+ const ScriptInscriptionalPahlavi

+ const ScriptInscriptionalParthian

+ const ScriptJavanese

+ const ScriptKaithi

+ const ScriptKannada

+ const ScriptKatakana

+ const ScriptKawi

+ const ScriptKayahLi

+ const ScriptKharoshthi

+ const ScriptKhitanSmallScript

+ const ScriptKhmer

+ const ScriptKhojki

+ const ScriptKhudawadi

+ const ScriptKiratRai

+ const ScriptLao

+ const ScriptLatin

+ const ScriptLepcha

+ const ScriptLimbu

+ const ScriptLinearA

+ const ScriptLinearB

+ const ScriptLisu

+ const ScriptLycian

+ const ScriptLydian

+ const ScriptMahajani

+ const ScriptMakasar

+ const ScriptMalayalam

+ const ScriptMandaic

+ const ScriptManichaean

+ const ScriptMarchen

+ const ScriptMasaramGondi

+ const ScriptMath

+ const ScriptMedefaidrin

+ const ScriptMeeteiMayek

+ const ScriptMendeKikakui

+ const ScriptMeroiticCursive

+ const ScriptMeroiticHieroglyphs

+ const ScriptMiao

+ const ScriptModi

+ const ScriptMongolian

+ const ScriptMro

+ const ScriptMultani

+ const ScriptMyanmar

+ const ScriptNabataean

+ const ScriptNagMundari

+ const ScriptNandinagari

+ const ScriptNewTaiLue

+ const ScriptNewa

+ const ScriptNko

+ const ScriptNushu

+ const ScriptNyiakengPuachueHmong

+ const ScriptOgham

+ const ScriptOlChiki

+ const ScriptOlOnal

+ const ScriptOldHungarian

+ const ScriptOldItalic

+ const ScriptOldNorthArabian

+ const ScriptOldPermic

+ const ScriptOldPersian

+ const ScriptOldSogdian

+ const ScriptOldSouthArabian

+ const ScriptOldTurkic

+ const ScriptOldUyghur

+ const ScriptOriya

+ const ScriptOsage

+ const ScriptOsmanya

+ const ScriptPahawhHmong

+ const ScriptPalmyrene

+ const ScriptPauCinHau

+ const ScriptPhagsPa

+ const ScriptPhoenician

+ const ScriptPsalterPahlavi

+ const ScriptRejang

+ const ScriptRunic

+ const ScriptSamaritan

+ const ScriptSaurashtra

+ const ScriptSharada

+ const ScriptShavian

+ const ScriptSiddham

+ const ScriptSidetic

+ const ScriptSignwriting

+ const ScriptSinhala

+ const ScriptSogdian

+ const ScriptSoraSompeng

+ const ScriptSoyombo

+ const ScriptSundanese

+ const ScriptSunuwar

+ const ScriptSylotiNagri

+ const ScriptSyriac

+ const ScriptTagalog

+ const ScriptTagbanwa

+ const ScriptTaiLe

+ const ScriptTaiTham

+ const ScriptTaiViet

+ const ScriptTaiYo

+ const ScriptTakri

+ const ScriptTamil

+ const ScriptTangsa

+ const ScriptTangut

+ const ScriptTelugu

+ const ScriptThaana

+ const ScriptThai

+ const ScriptTibetan

+ const ScriptTifinagh

+ const ScriptTirhuta

+ const ScriptTodhri

+ const ScriptTolongSiki

+ const ScriptToto

+ const ScriptTuluTigalari

+ const ScriptUgaritic

+ const ScriptUnknown

+ const ScriptVai

+ const ScriptVithkuqi

+ const ScriptWancho

+ const ScriptWarangCiti

+ const ScriptYezidi

+ const ScriptYi

+ const ScriptZanabazarSquare

+ func GetScript(cp Codepoint) Script

+ type ScriptList struct

+ func (sl *ScriptList) FindChosenScriptTag(scriptTag Tag) Tag

+ func (sl *ScriptList) GetDefaultScript() *LangSys

+ func (sl *ScriptList) GetLangSys(scriptTag Tag, languageTag Tag) *LangSys

+ func (sl *ScriptList) GetScript(scriptTag Tag) *LangSys

+ type SegmentProperties struct

+ Direction Direction

+ Language Tag

+ Script Tag

+ type ShapePlan struct

+ DnomMask uint32

+ FracMask uint32

+ HasFrac bool

+ HasVert bool

+ KernMask uint32

+ Map *OTMap

+ NumrMask uint32

+ Props SegmentProperties

+ RTLMMask uint32

+ RequestedKerning bool

+ Shaper *OTShaper

+ ShaperData interface{}

type Shaper

+ func NewShaperFromFace(face *Face) (*Shaper, error)

+ func (s *Shaper) DebugArabicFallbackPlan()

+ func (s *Shaper) HasArabicFallbackPlan() bool

+ type SyllableAccessor interface

+ GetCategory func(i int) uint8

+ GetSyllable func(i int) uint8

+ Len func() int

+ SetCategory func(i int, cat uint8)

+ type TableType int

+ const TableGPOS

+ const TableGSUB

type Tag

+ func GetScriptTag(cp Codepoint) Tag

+ func LanguageToTag(lang string) []Tag

+ func ScriptToTag(sc Script) Tag

+ type USECategory uint8

+ const USE_B

+ const USE_CGJ

+ const USE_CM

+ const USE_CMAbv

+ const USE_CMBlw

+ const USE_CS

+ const USE_F

+ const USE_FAbv

+ const USE_FBlw

+ const USE_FM

+ const USE_FMAbv

+ const USE_FMBlw

+ const USE_FMPst

+ const USE_FPst

+ const USE_G

+ const USE_GB

+ const USE_H

+ const USE_HM

+ const USE_HN

+ const USE_HR

+ const USE_HVM

+ const USE_IS

+ const USE_J

+ const USE_M

+ const USE_MAbv

+ const USE_MBlw

+ const USE_MPre

+ const USE_MPst

+ const USE_N

+ const USE_O

+ const USE_R

+ const USE_RK

+ const USE_SB

+ const USE_SE

+ const USE_SM

+ const USE_SMAbv

+ const USE_SMBlw

+ const USE_SUB

+ const USE_Sk

+ const USE_V

+ const USE_VAbv

+ const USE_VBlw

+ const USE_VM

+ const USE_VMAbv

+ const USE_VMBlw

+ const USE_VMPre

+ const USE_VMPst

+ const USE_VPre

+ const USE_VPst

+ const USE_WJ

+ const USE_ZWNJ

+ type USESyllableInfo struct

+ Category USECategory

+ Syllable uint8

+ SyllableType USESyllableType

+ type USESyllableType uint8

+ const USE_BrokenCluster

+ const USE_HieroglyphCluster

+ const USE_NonCluster

+ const USE_NumberJoinerTerminatedCluster

+ const USE_NumeralCluster

+ const USE_SakotTerminatedCluster

+ const USE_StandardCluster

+ const USE_SymbolCluster

+ const USE_ViramaTerminatedCluster

+ func (t USESyllableType) String() string

+ type VowelConstraint struct

+ Codepoints []Codepoint

+ type ZeroWidthMarksType int

+ const ZeroWidthMarksByGDEFEarly

+ const ZeroWidthMarksByGDEFLate

+ const ZeroWidthMarksNone

v0.0.3

Jan 8, 2026

Changes in this version

+ var TagAvar = MakeTag('a', 'v', 'a', 'r')

+ var TagAxisItalic = MakeTag('i', 't', 'a', 'l')

+ var TagAxisOpticalSize = MakeTag('o', 'p', 's', 'z')

+ var TagAxisSlant = MakeTag('s', 'l', 'n', 't')

+ var TagAxisWeight = MakeTag('w', 'g', 'h', 't')

+ var TagAxisWidth = MakeTag('w', 'd', 't', 'h')

+ var TagCvar = MakeTag('c', 'v', 'a', 'r')

+ var TagFvar = MakeTag('f', 'v', 'a', 'r')

+ var TagGvar = MakeTag('g', 'v', 'a', 'r')

+ var TagHvar = MakeTag('H', 'V', 'A', 'R')

+ var TagMvar = MakeTag('M', 'V', 'A', 'R')

+ var TagSTAT = MakeTag('S', 'T', 'A', 'T')

+ var TagVvar = MakeTag('V', 'V', 'A', 'R')

+ func InstanceSimpleGlyph(data []byte, xDeltas, yDeltas []int16) []byte

+ type Avar struct

+ func ParseAvar(data []byte) (*Avar, error)

+ func (a *Avar) HasData() bool

+ func (a *Avar) MapCoords(coords []int) []int

+ func (a *Avar) MapValue(axisIndex int, value int) int

+ type AxisFlags uint16

+ const AxisFlagHidden

+ type AxisInfo struct

+ DefaultValue float32

+ Flags AxisFlags

+ Index int

+ MaxValue float32

+ MinValue float32

+ NameID uint16

+ Tag Tag

type Cmap

+ func (c *Cmap) CollectMapping() map[rune]GlyphID

+ func (c *Cmap) CollectReverseMapping() map[GlyphID]rune

+ type DeltaSetIndexMap struct

+ func (dm *DeltaSetIndexMap) Map(glyph uint32) uint32

type Face

+ func (f *Face) FindVariationAxis(tag Tag) (AxisInfo, bool)

+ func (f *Face) Fvar() *Fvar

+ func (f *Face) HasVariations() bool

+ func (f *Face) NamedInstances() []NamedInstance

+ func (f *Face) VariationAxes() []AxisInfo

+ type Fvar struct

+ func ParseFvar(data []byte) (*Fvar, error)

+ func (f *Fvar) AxisCount() int

+ func (f *Fvar) AxisInfos() []AxisInfo

+ func (f *Fvar) FindAxis(tag Tag) (AxisInfo, bool)

+ func (f *Fvar) HasData() bool

+ func (f *Fvar) InstanceCount() int

+ func (f *Fvar) NamedInstanceAt(index int) (NamedInstance, bool)

+ func (f *Fvar) NamedInstances() []NamedInstance

+ func (f *Fvar) NormalizeAxisValue(axisIndex int, value float32) float32

+ func (f *Fvar) NormalizeVariations(variations []Variation) []float32

+ type GlyphDeltas struct

+ XDeltas []int16

+ YDeltas []int16

+ type GlyphPoint struct

+ X int16

+ Y int16

+ type Gvar struct

+ func ParseGvar(data []byte) (*Gvar, error)

+ func (g *Gvar) AxisCount() int

+ func (g *Gvar) GetGlyphDeltas(glyphID GlyphID, normalizedCoords []int, numPoints int) *GlyphDeltas

+ func (g *Gvar) GetGlyphDeltasWithCoords(glyphID GlyphID, normalizedCoords []int, numPoints int, ...) *GlyphDeltas

+ func (g *Gvar) GlyphCount() int

+ func (g *Gvar) HasData() bool

+ type Hvar struct

+ func ParseHvar(data []byte) (*Hvar, error)

+ func (h *Hvar) GetAdvanceDelta(glyph GlyphID, normalizedCoords []int) float32

+ func (h *Hvar) HasData() bool

+ type ItemVariationStore struct

+ func (vs *ItemVariationStore) GetDelta(varIdx uint32, coords []int) float32

+ type NamedInstance struct

+ Coords []float32

+ Index int

+ PostScriptNameID uint16

+ SubfamilyNameID uint16

type Shaper

+ func (s *Shaper) DesignCoords() []float32

+ func (s *Shaper) Fvar() *Fvar

+ func (s *Shaper) HasHvar() bool

+ func (s *Shaper) HasVariations() bool

+ func (s *Shaper) Hvar() *Hvar

+ func (s *Shaper) NormalizedCoords() []float32

+ func (s *Shaper) SetNamedInstance(index int)

+ func (s *Shaper) SetVariation(tag Tag, value float32)

+ func (s *Shaper) SetVariations(variations []Variation)

+ type SimpleGlyphPoint struct

+ OnCurve bool

+ X int16

+ Y int16

+ func ParseSimpleGlyph(data []byte) ([]SimpleGlyphPoint, int, error)

+ type VarRegionList struct

+ func (rl *VarRegionList) Evaluate(regionIndex int, coords []int) float32

+ type Variation struct

+ Tag Tag

+ Value float32

v0.0.2

Jan 8, 2026

v0.0.1

Jan 8, 2026

Changes in this version

+ const AttachTypeCursive

+ const AttachTypeMark

+ const AttachTypeNone

+ const FeatureGlobalEnd

+ const FeatureGlobalStart

+ const GPOSTypeChainContext

+ const GPOSTypeContext

+ const GPOSTypeCursive

+ const GPOSTypeExtension

+ const GPOSTypeMarkBase

+ const GPOSTypeMarkLig

+ const GPOSTypeMarkMark

+ const GPOSTypePair

+ const GPOSTypeSingle

+ const GSUBTypeAlternate

+ const GSUBTypeChainContext

+ const GSUBTypeContext

+ const GSUBTypeExtension

+ const GSUBTypeLigature

+ const GSUBTypeMultiple

+ const GSUBTypeReverseChainSingle

+ const GSUBTypeSingle

+ const GlyphClassBase

+ const GlyphClassComponent

+ const GlyphClassLigature

+ const GlyphClassMark

+ const GlyphClassUnclassified

+ const LookupFlagIgnoreBaseGlyphs

+ const LookupFlagIgnoreLigatures

+ const LookupFlagIgnoreMarks

+ const LookupFlagMarkAttachTypeMask

+ const LookupFlagRightToLeft

+ const LookupFlagUseMarkFilteringSet

+ const NotCovered

+ const ValueFormatXAdvDevice

+ const ValueFormatXAdvance

+ const ValueFormatXPlaDevice

+ const ValueFormatXPlacement

+ const ValueFormatYAdvDevice

+ const ValueFormatYAdvance

+ const ValueFormatYPlaDevice

+ const ValueFormatYPlacement

+ var ErrInvalidFeature = errors.New("invalid feature string")

+ var ErrInvalidFont = errors.New("invalid font data")

+ var ErrInvalidFormat = errors.New("unsupported format")

+ var ErrInvalidOffset = errors.New("offset out of bounds")

+ var ErrInvalidTable = errors.New("invalid table data")

+ var ErrTableNotFound = errors.New("table not found")

+ var TagCFF = MakeTag('C', 'F', 'F', ' ')

+ var TagCalt = MakeTag('c', 'a', 'l', 't')

+ var TagCcmp = MakeTag('c', 'c', 'm', 'p')

+ var TagClig = MakeTag('c', 'l', 'i', 'g')

+ var TagCmap = MakeTag('c', 'm', 'a', 'p')

+ var TagCvt = MakeTag('c', 'v', 't', ' ')

+ var TagDlig = MakeTag('d', 'l', 'i', 'g')

+ var TagFpgm = MakeTag('f', 'p', 'g', 'm')

+ var TagGDEF = MakeTag('G', 'D', 'E', 'F')

+ var TagGPOS = MakeTag('G', 'P', 'O', 'S')

+ var TagGSUB = MakeTag('G', 'S', 'U', 'B')

+ var TagGasp = MakeTag('g', 'a', 's', 'p')

+ var TagGlyf = MakeTag('g', 'l', 'y', 'f')

+ var TagHead = MakeTag('h', 'e', 'a', 'd')

+ var TagHhea = MakeTag('h', 'h', 'e', 'a')

+ var TagHlig = MakeTag('h', 'l', 'i', 'g')

+ var TagHmtx = MakeTag('h', 'm', 't', 'x')

+ var TagKern = MakeTag('k', 'e', 'r', 'n')

+ var TagLiga = MakeTag('l', 'i', 'g', 'a')

+ var TagLoca = MakeTag('l', 'o', 'c', 'a')

+ var TagLocl = MakeTag('l', 'o', 'c', 'l')

+ var TagMark = MakeTag('m', 'a', 'r', 'k')

+ var TagMaxp = MakeTag('m', 'a', 'x', 'p')

+ var TagMkmk = MakeTag('m', 'k', 'm', 'k')

+ var TagName = MakeTag('n', 'a', 'm', 'e')

+ var TagOS2 = MakeTag('O', 'S', '/', '2')

+ var TagPost = MakeTag('p', 'o', 's', 't')

+ var TagPrep = MakeTag('p', 'r', 'e', 'p')

+ var TagRlig = MakeTag('r', 'l', 'i', 'g')

+ var TagSmcp = MakeTag('s', 'm', 'c', 'p')

+ func BuildLoca(offsets []uint32, useShort bool) []byte

+ func ClearShaperCache()

+ func GetGlyphName(glyph GlyphID) string

+ func RemapCharString(cs []byte, globalMap, localMap map[int]int, ...) []byte

+ func RemapComposite(data []byte, glyphMap map[GlyphID]GlyphID) []byte

+ func Shape(font *Font, buf *Buffer, features []Feature) error

+ type AlternateSubst struct

+ func (a *AlternateSubst) Apply(ctx *GSUBContext) int

+ func (a *AlternateSubst) ApplyWithIndex(ctx *GSUBContext, altIndex int) int

+ func (a *AlternateSubst) GetAlternates(glyph GlyphID) []GlyphID

+ func (a *AlternateSubst) Mapping() map[GlyphID][]GlyphID

+ type Anchor struct

+ AnchorPoint uint16

+ Format uint16

+ X int16

+ Y int16

+ type AttachList struct

+ type BaseArray struct

+ Anchors [][]*Anchor

+ ClassCount int

+ Rows int

+ func (ba *BaseArray) GetAnchor(baseIndex, markClass int) *Anchor

+ type Buffer struct

+ Direction Direction

+ Flags BufferFlags

+ Info []GlyphInfo

+ Language Tag

+ Pos []GlyphPos

+ Script Tag

+ func NewBuffer() *Buffer

+ func (b *Buffer) AddCodepoints(codepoints []Codepoint)

+ func (b *Buffer) AddString(s string)

+ func (b *Buffer) Clear()

+ func (b *Buffer) GlyphIDs() []GlyphID

+ func (b *Buffer) GuessSegmentProperties()

+ func (b *Buffer) Len() int

+ func (b *Buffer) Reset()

+ func (b *Buffer) SetDirection(dir Direction)

+ type BufferFlags uint32

+ const BufferFlagBOT

+ const BufferFlagDefault

+ const BufferFlagDoNotInsertDottedCircle

+ const BufferFlagEOT

+ const BufferFlagPreserveDefaultIgnorables

+ const BufferFlagRemoveDefaultIgnorables

+ type CFF struct

+ CharStrings [][]byte

+ Charset []GlyphID

+ FDArray []FontDict

+ FDSelect []byte

+ GlobalSubrs [][]byte

+ IsCID bool

+ LocalSubrs [][]byte

+ Name string

+ PrivateDict PrivateDict

+ Strings []string

+ TopDict TopDict

+ func ParseCFF(data []byte) (*CFF, error)

+ func (c *CFF) GetString(sid int) string

+ func (c *CFF) NumGlyphs() int

+ type CaretValue struct

+ func (cv *CaretValue) Coordinate() int16

+ func (cv *CaretValue) Format() uint16

+ func (cv *CaretValue) PointIndex() uint16

+ type ChainContextPos struct

+ func (ccp *ChainContextPos) Apply(ctx *GPOSContext) bool

+ type ChainContextSubst struct

+ func (ccs *ChainContextSubst) Apply(ctx *GSUBContext) int

+ type ChainRule struct

+ Backtrack []GlyphID

+ Input []GlyphID

+ Lookahead []GlyphID

+ LookupRecords []LookupRecord

+ type CharStringInterpreter struct

+ UsedGlobalSubrs map[int]bool

+ UsedLocalSubrs map[int]bool

+ func NewCharStringInterpreter(globalSubrs, localSubrs [][]byte) *CharStringInterpreter

+ func (i *CharStringInterpreter) FindUsedSubroutines(charstring []byte) error

+ type ClassDef struct

+ func ParseClassDef(data []byte, offset int) (*ClassDef, error)

+ func (cd *ClassDef) GetClass(glyph GlyphID) int

+ func (cd *ClassDef) Mapping() map[GlyphID]uint16

+ type Cmap struct

+ func ParseCmap(data []byte) (*Cmap, error)

+ func (c *Cmap) Iter() CmapIter

+ func (c *Cmap) Lookup(cp Codepoint) (GlyphID, bool)

+ func (c *Cmap) LookupVariation(cp Codepoint, vs Codepoint) (GlyphID, bool)

+ type CmapIter interface

+ Char func() (rune, GlyphID)

+ Next func() bool

+ type Codepoint = uint32

+ type CompositeComponent struct

+ Arg1 int16

+ Arg2 int16

+ Flags uint16

+ GlyphID GlyphID

+ Scale float32

+ Scale01 float32

+ Scale10 float32

+ ScaleX float32

+ ScaleY float32

+ type ContextPos struct

+ func (cp *ContextPos) Apply(ctx *GPOSContext) bool

+ type ContextRule struct

+ Input []GlyphID

+ LookupRecords []LookupRecord

+ type ContextSubst struct

+ func (cs *ContextSubst) Apply(ctx *GSUBContext) int

+ type Coverage struct

+ func ParseCoverage(data []byte, offset int) (*Coverage, error)

+ func (c *Coverage) GetCoverage(glyph GlyphID) uint32

+ func (c *Coverage) Glyphs() []GlyphID

+ type CursivePos struct

+ func (cp *CursivePos) Apply(ctx *GPOSContext) bool

+ func (cp *CursivePos) Coverage() *Coverage

+ func (cp *CursivePos) EntryExitRecords() []EntryExitRecord

+ type Direction int

+ const DirectionBTT

+ const DirectionInvalid

+ const DirectionLTR

+ const DirectionRTL

+ const DirectionTTB

+ func GuessDirection(s string) Direction

+ func (d Direction) IsHorizontal() bool

+ type EntryExitRecord struct

+ EntryAnchor *Anchor

+ ExitAnchor *Anchor

+ type Face struct

+ Font *Font

+ func LoadFace(r io.Reader, index int) (*Face, error)

+ func LoadFaceFromData(data []byte, index int) (*Face, error)

+ func NewFace(font *Font) (*Face, error)

+ func (f *Face) Ascender() int16

+ func (f *Face) BBox() (xMin, yMin, xMax, yMax int16)

+ func (f *Face) CapHeight() int16

+ func (f *Face) Cmap() *Cmap

+ func (f *Face) Descender() int16

+ func (f *Face) FamilyName() string

+ func (f *Face) GetHExtents() FontExtents

+ func (f *Face) HorizontalAdvance(glyph GlyphID) float32

+ func (f *Face) IsCFF() bool

+ func (f *Face) IsFixedPitch() bool

+ func (f *Face) IsItalic() bool

+ func (f *Face) ItalicAngle() int32

+ func (f *Face) LineGap() int16

+ func (f *Face) PostscriptName() string

+ func (f *Face) Upem() uint16

+ func (f *Face) WeightClass() uint16

+ func (f *Face) XHeight() int16

+ type Feature struct

+ End uint

+ Start uint

+ Tag Tag

+ Value uint32

+ func DefaultFeatures() []Feature

+ func FeatureFromString(s string) (Feature, bool)

+ func NewFeature(tag Tag, value uint32) Feature

+ func NewFeatureOff(tag Tag) Feature

+ func NewFeatureOn(tag Tag) Feature

+ func ParseFeatures(s string) []Feature

+ func (f Feature) IsGlobal() bool

+ func (f Feature) String() string

+ type FeatureList struct

+ func (f *FeatureList) Count() int

+ func (f *FeatureList) FindFeature(tag Tag) []uint16

+ func (f *FeatureList) GetFeature(index int) (*FeatureRecord, error)

+ type FeatureRecord struct

+ Lookups []uint16

+ Tag Tag

+ type Font struct

+ func ParseFont(data []byte, index int) (*Font, error)

+ func (f *Font) HasTable(tag Tag) bool

+ func (f *Font) NumGlyphs() int

+ func (f *Font) TableData(tag Tag) ([]byte, error)

+ func (f *Font) TableParser(tag Tag) (*Parser, error)

+ type FontDict struct

+ Private [2]int

+ type FontExtents struct

+ Ascender int16

+ Descender int16

+ LineGap int16

+ type GDEF struct

+ func ParseGDEF(data []byte) (*GDEF, error)

+ func (g *GDEF) GetAttachPoints(glyph GlyphID) []uint16

+ func (g *GDEF) GetGlyphClass(glyph GlyphID) int

+ func (g *GDEF) GetLigCaretCount(glyph GlyphID) int

+ func (g *GDEF) GetLigCarets(glyph GlyphID) []CaretValue

+ func (g *GDEF) GetMarkAttachClass(glyph GlyphID) int

+ func (g *GDEF) HasAttachList() bool

+ func (g *GDEF) HasGlyphClasses() bool

+ func (g *GDEF) HasLigCaretList() bool

+ func (g *GDEF) HasMarkAttachClasses() bool

+ func (g *GDEF) HasMarkGlyphSets() bool

+ func (g *GDEF) IsBaseGlyph(glyph GlyphID) bool

+ func (g *GDEF) IsComponentGlyph(glyph GlyphID) bool

+ func (g *GDEF) IsInMarkGlyphSet(glyph GlyphID, setIndex int) bool

+ func (g *GDEF) IsLigatureGlyph(glyph GlyphID) bool

+ func (g *GDEF) IsMarkGlyph(glyph GlyphID) bool

+ func (g *GDEF) MarkGlyphSetCount() int

+ func (g *GDEF) Version() (uint16, uint16)

+ type GPOS struct

+ func ParseGPOS(data []byte) (*GPOS, error)

+ func (g *GPOS) ApplyKerning(glyphs []GlyphID) []GlyphPosition

+ func (g *GPOS) ApplyKerningWithGDEF(glyphs []GlyphID, gdef *GDEF) []GlyphPosition

+ func (g *GPOS) ApplyLookup(lookupIndex int, glyphs []GlyphID, positions []GlyphPosition)

+ func (g *GPOS) ApplyLookupWithDirection(lookupIndex int, glyphs []GlyphID, positions []GlyphPosition, ...)

+ func (g *GPOS) ApplyLookupWithGDEF(lookupIndex int, glyphs []GlyphID, positions []GlyphPosition, ...)

+ func (g *GPOS) GetLookup(index int) *GPOSLookup

+ func (g *GPOS) NumLookups() int

+ func (g *GPOS) ParseFeatureList() (*FeatureList, error)

+ type GPOSChainRule struct

+ Backtrack []GlyphID

+ Input []GlyphID

+ Lookahead []GlyphID

+ LookupRecords []GPOSLookupRecord

+ type GPOSContext struct

+ Direction Direction

+ GDEF *GDEF

+ Glyphs []GlyphID

+ Index int

+ LookupFlag uint16

+ MarkFilteringSet int

+ Positions []GlyphPosition

+ func (ctx *GPOSContext) AdjustPosition(index int, vr *ValueRecord)

+ func (ctx *GPOSContext) NextGlyph(startIndex int) int

+ func (ctx *GPOSContext) PrevGlyph(startIndex int) int

+ func (ctx *GPOSContext) ShouldSkipGlyph(index int) bool

+ type GPOSContextRule struct

+ Input []GlyphID

+ LookupRecords []GPOSLookupRecord

+ type GPOSLookup struct

+ Flag uint16

+ MarkFilter uint16

+ Type uint16

+ func (l *GPOSLookup) Subtables() []GPOSSubtable

+ type GPOSLookupRecord struct

+ LookupIndex uint16

+ SequenceIndex uint16

+ type GPOSSubtable interface

+ Apply func(ctx *GPOSContext) bool

+ type GSUB struct

+ func ParseGSUB(data []byte) (*GSUB, error)

+ func (g *GSUB) ApplyFeature(tag Tag, glyphs []GlyphID) []GlyphID

+ func (g *GSUB) ApplyFeatureWithGDEF(tag Tag, glyphs []GlyphID, gdef *GDEF) []GlyphID

+ func (g *GSUB) ApplyLookup(lookupIndex int, glyphs []GlyphID) []GlyphID

+ func (g *GSUB) ApplyLookupReverse(lookupIndex int, glyphs []GlyphID) []GlyphID

+ func (g *GSUB) ApplyLookupReverseWithGDEF(lookupIndex int, glyphs []GlyphID, gdef *GDEF) []GlyphID

+ func (g *GSUB) ApplyLookupWithGDEF(lookupIndex int, glyphs []GlyphID, gdef *GDEF) []GlyphID

+ func (g *GSUB) GetLookup(index int) *GSUBLookup

+ func (g *GSUB) NumLookups() int

+ func (g *GSUB) ParseFeatureList() (*FeatureList, error)

+ type GSUBContext struct

+ GDEF *GDEF

+ Glyphs []GlyphID

+ Index int

+ LookupFlag uint16

+ MarkFilteringSet int

+ OnDelete func(index int)

+ OnLigate func(index int, ligGlyph GlyphID, numGlyphs int)

+ OnReplace func(index int, newGlyph GlyphID)

+ OnReplaces func(index int, newGlyphs []GlyphID)

+ func (ctx *GSUBContext) DeleteGlyph()

+ func (ctx *GSUBContext) Ligate(ligGlyph GlyphID, numGlyphs int)

+ func (ctx *GSUBContext) NextGlyph(startIndex int) int

+ func (ctx *GSUBContext) PrevGlyph(startIndex int) int

+ func (ctx *GSUBContext) ReplaceGlyph(newGlyph GlyphID)

+ func (ctx *GSUBContext) ReplaceGlyphs(newGlyphs []GlyphID)

+ func (ctx *GSUBContext) ShouldSkipGlyph(index int) bool

+ type GSUBLookup struct

+ Flag uint16

+ MarkFilter uint16

+ Type uint16

+ func (l *GSUBLookup) Subtables() []GSUBSubtable

+ type GSUBSubtable interface

+ Apply func(ctx *GSUBContext) int

+ type Glyf struct

+ func ParseGlyf(data []byte, loca *Loca) (*Glyf, error)

+ func ParseGlyfFromFont(font *Font) (*Glyf, error)

+ func (g *Glyf) GetComponents(gid GlyphID) []GlyphID

+ func (g *Glyf) GetGlyph(gid GlyphID) *GlyphData

+ func (g *Glyf) GetGlyphBytes(gid GlyphID) []byte

+ type GlyphData struct

+ Data []byte

+ NumberOfContours int16

+ func (gd *GlyphData) IsComposite() bool

+ type GlyphExtents struct

+ Height int16

+ Width int16

+ XBearing int16

+ YBearing int16

+ type GlyphID = uint16

+ type GlyphInfo struct

+ Cluster int

+ Codepoint Codepoint

+ GlyphClass int

+ GlyphID GlyphID

+ type GlyphPos struct

+ XAdvance int16

+ XOffset int16

+ YAdvance int16

+ YOffset int16

+ type GlyphPosition struct

+ AttachChain int16

+ AttachType uint8

+ XAdvance int16

+ XOffset int16

+ XPlacement int16

+ YAdvance int16

+ YOffset int16

+ YPlacement int16

+ type Head struct

+ CheckSumAdjustment uint32

+ Created int64

+ Flags uint16

+ FontDirectionHint int16

+ FontRevision uint32

+ GlyphDataFormat int16

+ IndexToLocFormat int16

+ LowestRecPPEM uint16

+ MacStyle uint16

+ MagicNumber uint32

+ Modified int64

+ UnitsPerEm uint16

+ Version uint32

+ XMax int16

+ XMin int16

+ YMax int16

+ YMin int16

+ func ParseHead(data []byte) (*Head, error)

+ type Hhea struct

+ AdvanceWidthMax uint16

+ Ascender int16

+ CaretOffset int16

+ CaretSlopeRise int16

+ CaretSlopeRun int16

+ Descender int16

+ LineGap int16

+ MetricDataFormat int16

+ MinLeftSideBearing int16

+ MinRightSideBearing int16

+ NumberOfHMetrics uint16

+ Version uint32

+ XMaxExtent int16

+ func ParseHhea(data []byte) (*Hhea, error)

+ type Hmtx struct

+ func ParseHmtx(data []byte, numberOfHMetrics, numGlyphs int) (*Hmtx, error)

+ func ParseHmtxFromFont(font *Font) (*Hmtx, error)

+ func (h *Hmtx) GetAdvanceWidth(glyph GlyphID) uint16

+ func (h *Hmtx) GetLsb(glyph GlyphID) int16

+ func (h *Hmtx) GetMetrics(glyph GlyphID) (advanceWidth uint16, lsb int16)

+ type LigCaretList struct

+ type LigGlyph struct

+ type Ligature struct

+ Components []GlyphID

+ LigGlyph GlyphID

+ type LigatureArray struct

+ Attachments []*LigatureAttach

+ type LigatureAttach struct

+ Anchors [][]*Anchor

+ ClassCount int

+ ComponentCount int

+ func (la *LigatureAttach) GetAnchor(componentIndex, markClass int) *Anchor

+ type LigatureSubst struct

+ func (l *LigatureSubst) Apply(ctx *GSUBContext) int

+ func (l *LigatureSubst) Coverage() *Coverage

+ func (l *LigatureSubst) LigatureSets() [][]Ligature

+ type Loca struct

+ func ParseLoca(data []byte, numGlyphs int, indexToLocFormat int16) (*Loca, error)

+ func (l *Loca) GetOffset(gid GlyphID) (uint32, uint32, bool)

+ func (l *Loca) IsShort() bool

+ func (l *Loca) NumGlyphs() int

+ type LongHorMetric struct

+ AdvanceWidth uint16

+ Lsb int16

+ type LookupRecord struct

+ LookupIndex uint16

+ SequenceIndex uint16

+ type MarkArray struct

+ Records []MarkRecord

+ type MarkBasePos struct

+ func (m *MarkBasePos) Apply(ctx *GPOSContext) bool

+ func (m *MarkBasePos) BaseArray() *BaseArray

+ func (m *MarkBasePos) BaseCoverage() *Coverage

+ func (m *MarkBasePos) ClassCount() uint16

+ func (m *MarkBasePos) MarkArray() *MarkArray

+ func (m *MarkBasePos) MarkCoverage() *Coverage

+ type MarkGlyphSetsDef struct

+ type MarkLigPos struct

+ func (m *MarkLigPos) Apply(ctx *GPOSContext) bool

+ func (m *MarkLigPos) ApplyWithComponent(ctx *GPOSContext, componentIndex int) bool

+ func (m *MarkLigPos) ClassCount() uint16

+ func (m *MarkLigPos) LigatureArray() *LigatureArray

+ func (m *MarkLigPos) LigatureCoverage() *Coverage

+ func (m *MarkLigPos) MarkArray() *MarkArray

+ func (m *MarkLigPos) MarkCoverage() *Coverage

+ type MarkMarkPos struct

+ func (m *MarkMarkPos) Apply(ctx *GPOSContext) bool

+ func (m *MarkMarkPos) ClassCount() uint16

+ func (m *MarkMarkPos) Mark1Array() *MarkArray

+ func (m *MarkMarkPos) Mark1Coverage() *Coverage

+ func (m *MarkMarkPos) Mark2Array() *BaseArray

+ func (m *MarkMarkPos) Mark2Coverage() *Coverage

+ type MarkRecord struct

+ Anchor *Anchor

+ Class uint16

+ type MultipleSubst struct

+ func (m *MultipleSubst) Apply(ctx *GSUBContext) int

+ func (m *MultipleSubst) Mapping() map[GlyphID][]GlyphID

+ type Name struct

+ func ParseName(data []byte) (*Name, error)

+ func (n *Name) FamilyName() string

+ func (n *Name) FullName() string

+ func (n *Name) Get(nameID uint16) string

+ func (n *Name) PostScriptName() string

+ type OS2 struct

+ AchVendID [4]byte

+ FsSelection uint16

+ FsType uint16

+ Panose [10]byte

+ SCapHeight int16

+ SFamilyClass int16

+ STypoAscender int16

+ STypoDescender int16

+ STypoLineGap int16

+ SxHeight int16

+ UlCodePageRange1 uint32

+ UlCodePageRange2 uint32

+ UlUnicodeRange1 uint32

+ UlUnicodeRange2 uint32

+ UlUnicodeRange3 uint32

+ UlUnicodeRange4 uint32

+ UsBreakChar uint16

+ UsDefaultChar uint16

+ UsFirstCharIndex uint16

+ UsLastCharIndex uint16

+ UsMaxContext uint16

+ UsWeightClass uint16

+ UsWidthClass uint16

+ UsWinAscent uint16

+ UsWinDescent uint16

+ Version uint16

+ XAvgCharWidth int16

+ YStrikeoutPosition int16

+ YStrikeoutSize int16

+ YSubscriptXOffset int16

+ YSubscriptXSize int16

+ YSubscriptYOffset int16

+ YSubscriptYSize int16

+ YSuperscriptXOffset int16

+ YSuperscriptXSize int16

+ YSuperscriptYOffset int16

+ YSuperscriptYSize int16

+ func ParseOS2(data []byte) (*OS2, error)

+ type PairClassRecord struct

+ Value1 ValueRecord

+ Value2 ValueRecord

+ type PairPos struct

+ func (pp *PairPos) Apply(ctx *GPOSContext) bool

+ func (pp *PairPos) Class1Count() uint16

+ func (pp *PairPos) Class2Count() uint16

+ func (pp *PairPos) ClassDef1() *ClassDef

+ func (pp *PairPos) ClassDef2() *ClassDef

+ func (pp *PairPos) ClassMatrix() [][]PairClassRecord

+ func (pp *PairPos) Coverage() *Coverage

+ func (pp *PairPos) Format() uint16

+ func (pp *PairPos) PairSets() [][]PairValueRecord

+ func (pp *PairPos) ValueFormat1() uint16

+ func (pp *PairPos) ValueFormat2() uint16

+ type PairValueRecord struct

+ SecondGlyph GlyphID

+ Value1 ValueRecord

+ Value2 ValueRecord

+ type Parser struct

+ func NewParser(data []byte) *Parser

+ func (p *Parser) Bytes(n int) ([]byte, error)

+ func (p *Parser) Data() []byte

+ func (p *Parser) I16() (int16, error)

+ func (p *Parser) I16At(off int) (int16, error)

+ func (p *Parser) I32() (int32, error)

+ func (p *Parser) Offset() int

+ func (p *Parser) Remaining() int

+ func (p *Parser) SetOffset(off int) error

+ func (p *Parser) Skip(n int) error

+ func (p *Parser) SubParser(off, length int) (*Parser, error)

+ func (p *Parser) SubParserFromOffset(off int) (*Parser, error)

+ func (p *Parser) Tag() (Tag, error)

+ func (p *Parser) U16() (uint16, error)

+ func (p *Parser) U16At(off int) (uint16, error)

+ func (p *Parser) U32() (uint32, error)

+ func (p *Parser) U32At(off int) (uint32, error)

+ func (p *Parser) U8() (uint8, error)

+ type Post struct

+ IsFixedPitch uint32

+ ItalicAngle int32

+ UnderlinePosition int16

+ UnderlineThickness int16

+ Version uint32

+ func ParsePost(data []byte) (*Post, error)

+ func (p *Post) ItalicAngleDegrees() float64

+ type PrivateDict struct

+ BlueFuzz int

+ BlueScale float64

+ BlueShift int

+ BlueValues []int

+ DefaultWidthX int

+ FamilyBlues []int

+ FamilyOtherBlues []int

+ NominalWidthX int

+ OtherBlues []int

+ StdHW int

+ StdVW int

+ Subrs int

+ type ReverseChainSingleSubst struct

+ func (r *ReverseChainSingleSubst) Apply(ctx *GSUBContext) int

+ type Shaper struct

+ func NewShaper(font *Font) (*Shaper, error)

+ func (s *Shaper) Font() *Font

+ func (s *Shaper) GDEF() *GDEF

+ func (s *Shaper) GetDefaultFeatures() []Feature

+ func (s *Shaper) HasGDEF() bool

+ func (s *Shaper) HasGPOS() bool

+ func (s *Shaper) HasGSUB() bool

+ func (s *Shaper) HasHmtx() bool

+ func (s *Shaper) SetDefaultFeatures(features []Feature)

+ func (s *Shaper) Shape(buf *Buffer, features []Feature)

+ func (s *Shaper) ShapeString(text string) ([]GlyphID, []GlyphPos)

+ type SinglePos struct

+ func (sp *SinglePos) Apply(ctx *GPOSContext) bool

+ func (sp *SinglePos) Coverage() *Coverage

+ func (sp *SinglePos) Format() uint16

+ func (sp *SinglePos) ValueFormat() uint16

+ func (sp *SinglePos) ValueRecord() ValueRecord

+ func (sp *SinglePos) ValueRecords() []ValueRecord

+ type SingleSubst struct

+ func (s *SingleSubst) Apply(ctx *GSUBContext) int

+ func (s *SingleSubst) Mapping() map[GlyphID]GlyphID

+ type Tag uint32

+ func MakeTag(a, b, c, d byte) Tag

+ func (t Tag) String() string

+ type TopDict struct

+ CharStrings int

+ Charset int

+ Encoding int

+ FDArray int

+ FDSelect int

+ FamilyName int

+ FontBBox [4]int

+ FullName int

+ IsCID bool

+ Notice int

+ Private [2]int

+ ROS [3]int

+ Version int

+ Weight int

+ type ValueRecord struct

+ XAdvance int16

+ XPlacement int16

+ YAdvance int16

+ YPlacement int16

+ func (vr *ValueRecord) IsZero() bool

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL