ot

package

Go to main page

Versions in this module

v0

v0.0.10

Mar 30, 2026

v0.0.9

Mar 17, 2026

v0.0.8

Mar 10, 2026

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