🥮 mooncakes.io

    moon_swash

    Download zip
    Author
    Version
    0.1.12
    License
    Apache-2.0
    Repository
    Last updated
    57 minutes ago
    Downloads
    41K

    Dependencies

    #Milky2018/moon_swash

    MoonBit port of Rust swash for font metadata, text shaping, and glyph scaling/rendering.

    #Install

    Add imports in your moon.pkg:

    import {
  "Milky2018/moon_swash" @swash,
  "Milky2018/moon_swash/shape" @swash_shape,
  "Milky2018/moon_swash/scale" @swash_scale,
}

    Optional modules:

    import {
  "Milky2018/moon_swash/iter" @swash_iter,
  "Milky2018/moon_swash/proxy" @swash_proxy,
}

    #Quickstart

    #Load a Font

    let data : Bytes = ...
    let font = @swash.FontRef::from_offset(data, 0).unwrap()

    #Shape Text

    let cx = @swash_shape.ShapeContext::new()
    let shaper = cx.builder(font).size(14.0).build()
    shaper.add_str("Hello, world!")
    shaper.shape_with(fn(cluster) {
      // cluster.glyphs() / cluster.source() ...
      cluster |> ignore
    })

    #Scale and Render a Glyph

    let gid = font.charmap().map(('Q').to_int().reinterpret_as_uint())
    let scx = @swash_scale.ScaleContext::new()
    let scaler = scx.builder(font).size(14.0).hint(true).build()

    let render = @swash_scale.Render::new([@swash_scale.Source::Outline])
    let img = render.render(scaler, gid).unwrap()

    // Zero-copy pixel access:
    let pixels = img.data_view()
    pixels |> ignore

    // GPU-friendly RGBA8 (premultiplied):
    let white = [(255).to_byte(), (255).to_byte(), (255).to_byte(), (255).to_byte()]
    img.to_rgba8(white) |> ignore
    let rgba8 = img.data_view()
    rgba8 |> ignore

    #Modules

    • Milky2018/moon_swash: core font APIs (FontRef, attributes, metrics, variations, palettes, strikes).
    • Milky2018/moon_swash/shape: OpenType/AAT shaping and glyph clustering.
    • Milky2018/moon_swash/scale: outline/bitmap scaling and rendering.

    #SubpixelMask Notes

    • Content::SubpixelMask stores per-channel coverage in RGB; the alpha channel is unused by the rasterizer.
    • Image::to_rgba8(base_color) converts Mask / SubpixelMask into premultiplied RGBA8 and sets alpha to max(r, g, b) coverage (modulated by base_color[3]).
    • Use premultiplied-alpha blending when compositing (src = 1, dst = 1 - srcA).

    #License

    Apache-2.0.

    Decompose

    source
    type Decompose = Iter[Char]

    External iterator type. Iterator[X] is a mutable type: iterators internally maintain mutable state to advance iteration. All read operations on Iterator will advance the iterator, and would give different result when called multiple times.

    FeatureSetting

    source
    type FeatureSetting = Setting[UInt16]

    Feature setting (Setting<u16> in swash).

    GlyphId

    source
    type GlyphId = UInt16

    Glyph identifier.

    NormalizedCoord

    source
    type NormalizedCoord = Int

    Normalized variation coordinate in 2.14 fixed point format.

    Port note: swash uses i16; we use Int in MoonBit and keep the value in the same 2.14 fixed-point bit representation.

    Tag

    source
    type Tag = UInt

    Ported from swash/src/tag.rs (swash is dual-licensed Apache-2.0 OR MIT).

    UserData

    source
    type UserData = UInt

    Arbitrary user data that can be associated with a character throughout the shaping pipeline.

    VariationSetting

    source
    type VariationSetting = Setting[Double]

    Variation setting (Setting<f32> in swash; we use Double).

    Codepoint

    source
    pub(open) trait Codepoint {
      fn properties(Self) -> Properties
      fn opening_bracket(Self) -> Char?
      fn closing_bracket(Self) -> Char?
      fn mirror(Self) -> Char?
      fn bracket_type(Self) -> BracketType
      fn decompose(Self) -> Iter[Char]
      fn decompose_compatible(Self) -> Iter[Char]
    }

    impl Codepoint for Char

    TableProvider

    source
    pub(open) trait TableProvider {
      fn table_by_tag(Self, tag : UInt) -> BytesView?
    }

    Source that can provide table data by tag.

    Action

    source
    pub(all) enum Action {
      Substitution
      Attachment
      Adjustment
    }

    Modification performed by a feature.

    Analyze

    source
    pub struct Analyze {
      chars : CharStream
      state : BoundaryState
    }

    Iterator that yields Unicode properties and boundary analysis. This iterator is created by the [analyze] function.

    Analyze::iter

    source
    fn Analyze::iter(self : Analyze) -> Iter[(Properties, Boundary)]

    Analyze::needs_bidi_resolution

    source
    fn Analyze::needs_bidi_resolution(self : Analyze) -> Bool

    Analyze::next

    source
    fn Analyze::next(self : Analyze) -> (Properties, Boundary)?

    Analyze::set_break_strength

    source
    fn Analyze::set_break_strength(self : Analyze, strength : WordBreakStrength) -> Unit

    Sets the word breaking strength that will be used to analyze the next character.

    Attributes

    source
    pub struct Attributes {
      value : UInt
    }

    Primary attributes for font classification: stretch, weight and style.

    This struct is created by the attributes() method on FontRef.
    impl Eq for Attributes
    impl Show for Attributes

    Attributes::Attributes

    source
    fn Attributes::Attributes(stretch : Stretch, weight : Weight, style : Style) -> Attributes

    Attributes::equal

    source
    fn Attributes::equal(self : Attributes, other : Attributes) -> Bool

    Attributes::from_font

    source
    fn Attributes::from_font(font : FontRef) -> Attributes

    Extracts the attributes from the specified font.

    Attributes::has_italic_variation

    source
    fn Attributes::has_italic_variation(self : Attributes) -> Bool

    Attributes::has_oblique_variation

    source
    fn Attributes::has_oblique_variation(self : Attributes) -> Bool

    Attributes::has_stretch_variation

    source
    fn Attributes::has_stretch_variation(self : Attributes) -> Bool

    Attributes::has_variations

    source
    fn Attributes::has_variations(self : Attributes) -> Bool

    Attributes::has_weight_variation

    source
    fn Attributes::has_weight_variation(self : Attributes) -> Bool

    Attributes::not_equal

    source
    fn Attributes::not_equal(x : Attributes, y : Attributes) -> Bool

    Attributes::output

    source
    fn Attributes::output(self : Attributes, logger : &Logger) -> Unit

    Attributes::parts

    source
    fn Attributes::parts(self : Attributes) -> (Stretch, Weight, Style)

    Attributes::stretch

    source
    fn Attributes::stretch(self : Attributes) -> Stretch

    Attributes::style

    source
    fn Attributes::style(self : Attributes) -> Style

    Attributes::synthesize

    source
    fn Attributes::synthesize(self : Attributes, requested : Attributes) -> Synthesis

    Returns a synthesis analysis based on the requested attributes with respect to this set of attributes.

    Attributes::to_string

    source
    fn Attributes::to_string(self : Attributes) -> String

    Attributes::weight

    source
    fn Attributes::weight(self : Attributes) -> Weight

    BidiClass

    source
    pub(all) enum BidiClass {
      AL
      AN
      B
      BN
      CS
      EN
      ES
      ET
      FSI
      L
      LRE
      LRI
      LRO
      NSM
      ON
      PDF
      PDI
      R
      RLE
      RLI
      RLO
      S
      WS
    }

    BidiClass::needs_resolution

    source
    fn BidiClass::needs_resolution(self : BidiClass) -> Bool

    BitmapStrike

    source
    pub struct BitmapStrike {
      b : 
    BeBytes
      bitmap_data : BytesView
      offset : Int
      upem : UInt
      is_sbix : Bool
      is_apple : Bool
    }

    Collection of bitmaps of a specific size and format.

    BitmapStrike::bit_depth

    source
    fn BitmapStrike::bit_depth(self : BitmapStrike) -> Byte

    Returns the bit depth of the strike.

    BitmapStrike::contains

    source
    fn BitmapStrike::contains(self : BitmapStrike, glyph_id : UInt16) -> Bool

    Returns true if the specified glyph is covered by the strike.

    BitmapStrike::ppem

    source
    fn BitmapStrike::ppem(self : BitmapStrike) -> UInt16

    Returns the size of the strike in pixels per em.

    BitmapStrike::ppi

    source
    fn BitmapStrike::ppi(self : BitmapStrike) -> UInt16

    Returns the device pixel density for which the strike was designed.

    BitmapStrikes

    source
    pub struct BitmapStrikes {
      b : 
    BeBytes
      bitmap_data : BytesView
      is_sbix : Bool
      is_apple : Bool
      upem : UInt
      len : Int
    }

    Collection of bitmap strikes.

    BitmapStrikes::find_by_exact_ppem

    source
    fn BitmapStrikes::find_by_exact_ppem(self : BitmapStrikes, ppem : UInt16, glyph_id : UInt16) -> BitmapStrike?

    current state of the iterator.

    BitmapStrikes::find_by_largest_ppem

    source
    fn BitmapStrikes::find_by_largest_ppem(self : BitmapStrikes, glyph_id : UInt16) -> BitmapStrike?

    current state of the iterator.

    BitmapStrikes::find_by_nearest_ppem

    source
    fn BitmapStrikes::find_by_nearest_ppem(self : BitmapStrikes, ppem : UInt16, glyph_id : UInt16) -> BitmapStrike?

    current state of the iterator.

    BitmapStrikes::iter

    source

    Returns an iterator over the strikes.

    BitmapStrikes::len

    source
    fn BitmapStrikes::len(self : BitmapStrikes) -> Int

    Returns the number of strikes in the collection.

    BitmapStrikesProxy

    source
    pub struct BitmapStrikesProxy {
      bitmaps : (UInt, UInt)
      color_bitmaps : (UInt, UInt)
      upem : UInt
      is_apple : Bool
    }

    Proxy for rematerializing strike collections.

    BitmapStrikesProxy::from_font

    source

    BitmapStrikesProxy::has_alpha

    source
    fn BitmapStrikesProxy::has_alpha(self : BitmapStrikesProxy) -> Bool

    Returns true if the font has alpha bitmap strikes.

    BitmapStrikesProxy::has_color

    source
    fn BitmapStrikesProxy::has_color(self : BitmapStrikesProxy) -> Bool

    Returns true if the font has color bitmap strikes.

    BitmapStrikesProxy::materialize_alpha

    source
    fn BitmapStrikesProxy::materialize_alpha(self : BitmapStrikesProxy, font : FontRef) -> BitmapStrikes

    must have been created from the same font.

    BitmapStrikesProxy::materialize_color

    source
    fn BitmapStrikesProxy::materialize_color(self : BitmapStrikesProxy, font : FontRef) -> BitmapStrikes

    must have been created from the same font.

    Block

    source
    pub(all) enum Block {
      Adlam
      AegeanNumbers
      Ahom
      AlchemicalSymbols
      AlphabeticPresentationForms
      AnatolianHieroglyphs
      AncientGreekMusicalNotation
      AncientGreekNumbers
      AncientSymbols
      Arabic
      ArabicExtendedA
      ArabicMathematicalAlphabeticSymbols
      ArabicPresentationFormsA
      ArabicPresentationFormsB
      ArabicSupplement
      Armenian
      Arrows
      BasicLatin
      Avestan
      Balinese
      Bamum
      BamumSupplement
      BassaVah
      Batak
      Bengali
      Bhaiksuki
      BlockElements
      Bopomofo
      BopomofoExtended
      BoxDrawing
      Brahmi
      BraillePatterns
      Buginese
      Buhid
      ByzantineMusicalSymbols
      Carian
      CaucasianAlbanian
      Chakma
      Cham
      Cherokee
      CherokeeSupplement
      ChessSymbols
      Chorasmian
      CJKUnifiedIdeographs
      CJKCompatibility
      CJKCompatibilityForms
      CJKCompatibilityIdeographs
      CJKCompatibilityIdeographsSupplement
      CJKUnifiedIdeographsExtensionA
      CJKUnifiedIdeographsExtensionB
      CJKUnifiedIdeographsExtensionC
      CJKUnifiedIdeographsExtensionD
      CJKUnifiedIdeographsExtensionE
      CJKUnifiedIdeographsExtensionF
      CJKUnifiedIdeographsExtensionG
      CJKRadicalsSupplement
      CJKStrokes
      HangulCompatibilityJamo
      ControlPictures
      Coptic
      CopticEpactNumbers
      CountingRodNumerals
      Cuneiform
      CurrencySymbols
      CypriotSyllabary
      Cyrillic
      CyrillicExtendedA
      CyrillicExtendedB
      CyrillicExtendedC
      CyrillicSupplement
      Deseret
      Devanagari
      DevanagariExtended
      CombiningDiacriticalMarks
      CombiningDiacriticalMarksExtended
      CombiningDiacriticalMarksSupplement
      Dingbats
      DivesAkuru
      Dogra
      DominoTiles
      Duployan
      EarlyDynasticCuneiform
      EgyptianHieroglyphFormatControls
      EgyptianHieroglyphs
      Elbasan
      Elymaic
      Emoticons
      EnclosedAlphanumerics
      EnclosedAlphanumericSupplement
      EnclosedIdeographicSupplement
      Ethiopic
      EthiopicExtended
      EthiopicExtendedA
      EthiopicSupplement
      GeometricShapes
      GeometricShapesExtended
      Georgian
      GeorgianExtended
      GeorgianSupplement
      Glagolitic
      GlagoliticSupplement
      Gothic
      Grantha
      GreekExtended
      Gujarati
      GunjalaGondi
      Gurmukhi
      CombiningHalfMarks
      HangulSyllables
      HanifiRohingya
      Hanunoo
      Hatran
      Hebrew
      HighPrivateUseSurrogates
      HighSurrogates
      Hiragana
      IdeographicDescriptionCharacters
      ImperialAramaic
      CommonIndicNumberForms
      IndicSiyaqNumbers
      InscriptionalPahlavi
      InscriptionalParthian
      IPAExtensions
      HangulJamo
      HangulJamoExtendedA
      HangulJamoExtendedB
      Javanese
      Kaithi
      KanaExtendedA
      KanaSupplement
      Kanbun
      KangxiRadicals
      Kannada
      Katakana
      KatakanaPhoneticExtensions
      KayahLi
      Kharoshthi
      KhitanSmallScript
      Khmer
      KhmerSymbols
      Khojki
      Khudawadi
      Lao
      Latin1Supplement
      LatinExtendedA
      LatinExtendedAdditional
      LatinExtendedB
      LatinExtendedC
      LatinExtendedD
      LatinExtendedE
      Lepcha
      LetterlikeSymbols
      Limbu
      LinearA
      LinearBIdeograms
      LinearBSyllabary
      Lisu
      LisuSupplement
      LowSurrogates
      Lycian
      Lydian
      Mahajani
      MahjongTiles
      Makasar
      Malayalam
      Mandaic
      Manichaean
      Marchen
      MasaramGondi
      MathematicalAlphanumericSymbols
      MathematicalOperators
      MayanNumerals
      Medefaidrin
      MeeteiMayek
      MeeteiMayekExtensions
      MendeKikakui
      MeroiticCursive
      MeroiticHieroglyphs
      Miao
      MiscellaneousMathematicalSymbolsA
      MiscellaneousMathematicalSymbolsB
      MiscellaneousSymbols
      MiscellaneousTechnical
      Modi
      SpacingModifierLetters
      ModifierToneLetters
      Mongolian
      MongolianSupplement
      Mro
      Multani
      MusicalSymbols
      Myanmar
      MyanmarExtendedA
      MyanmarExtendedB
      Nabataean
      Nandinagari
      NoBlock
      NewTaiLue
      Newa
      NKo
      NumberForms
      Nushu
      NyiakengPuachueHmong
      OpticalCharacterRecognition
      Ogham
      OlChiki
      OldHungarian
      OldItalic
      OldNorthArabian
      OldPermic
      OldPersian
      OldSogdian
      OldSouthArabian
      OldTurkic
      Oriya
      OrnamentalDingbats
      Osage
      Osmanya
      OttomanSiyaqNumbers
      PahawhHmong
      Palmyrene
      PauCinHau
      PhaistosDisc
      Phoenician
      PhoneticExtensions
      PhoneticExtensionsSupplement
      PlayingCards
      PsalterPahlavi
      PrivateUseArea
      GeneralPunctuation
      Rejang
      RumiNumeralSymbols
      Runic
      Samaritan
      Saurashtra
      Sharada
      Shavian
      ShorthandFormatControls
      Siddham
      Sinhala
      SinhalaArchaicNumbers
      SmallFormVariants
      SmallKanaExtension
      Sogdian
      SoraSompeng
      Soyombo
      Specials
      Sundanese
      SundaneseSupplement
      SupplementalArrowsA
      SupplementalArrowsB
      SupplementalArrowsC
      SupplementalMathematicalOperators
      SupplementaryPrivateUseAreaA
      SupplementaryPrivateUseAreaB
      SupplementalPunctuation
      SuttonSignWriting
      SylotiNagri
      Syriac
      SyriacSupplement
      Tagalog
      Tagbanwa
      Tags
      TaiLe
      TaiTham
      TaiViet
      TaiXuanJingSymbols
      Takri
      Tamil
      TamilSupplement
      Tangut
      TangutComponents
      TangutSupplement
      Telugu
      Thaana
      Thai
      Tibetan
      Tifinagh
      Tirhuta
      UnifiedCanadianAboriginalSyllabics
      UnifiedCanadianAboriginalSyllabicsExtended
      Ugaritic
      Vai
      VedicExtensions
      VerticalForms
      VariationSelectors
      VariationSelectorsSupplement
      Wancho
      WarangCiti
      Yezidi
      YiRadicals
      YiSyllables
      YijingHexagramSymbols
      ZanabazarSquare
      GreekandCoptic
      SuperscriptsandSubscripts
      CombiningDiacriticalMarksforSymbols
      MiscellaneousSymbolsandArrows
      CJKSymbolsandPunctuation
      EnclosedCJKLettersandMonths
      Phagspa
      HalfwidthandFullwidthForms
      CuneiformNumbersandPunctuation
      IdeographicSymbolsandPunctuation
      MiscellaneousSymbolsandPictographs
      TransportandMapSymbols
      SupplementalSymbolsandPictographs
      SymbolsandPictographsExtendedA
      SymbolsforLegacyComputing
    }

    Boundary

    source
    pub(all) enum Boundary {
      None
      Word
      Line
      Mandatory
    }

    Boundary type of a character or cluster.

    BoundaryState

    source
    type BoundaryState

    BracketType

    source
    pub(all) enum BracketType {
      None
      Open(Char)
      Close(Char)
    }

    CacheKey

    source
    pub struct CacheKey {
      value : UInt64
    }

    Uniquely generated value for identifying and caching fonts.

    CacheKey::CacheKey

    source
    fn CacheKey::CacheKey() -> CacheKey

    CacheKey::value

    source
    fn CacheKey::value(self : CacheKey) -> UInt64

    Category

    source
    pub(all) enum Category {
      Other
      Control
      Format
      Unassigned
      PrivateUse
      Surrogate
      Letter
      CasedLetter
      LowercaseLetter
      ModifierLetter
      OtherLetter
      TitlecaseLetter
      UppercaseLetter
      Mark
      SpacingMark
      EnclosingMark
      NonspacingMark
      Number
      DecimalNumber
      LetterNumber
      OtherNumber
      Punctuation
      ConnectorPunctuation
      DashPunctuation
      ClosePunctuation
      FinalPunctuation
      InitialPunctuation
      OtherPunctuation
      OpenPunctuation
      Symbol
      CurrencySymbol
      ModifierSymbol
      MathSymbol
      OtherSymbol
      Separator
      LineSeparator
      ParagraphSeparator
      SpaceSeparator
    }

    CharCluster

    source
    type CharCluster

    Character cluster; output from the parser and input to the shaper.

    CharCluster::CharCluster

    source
    fn CharCluster::CharCluster() -> CharCluster

    CharCluster::chars

    source

    CharCluster::clear

    source
    fn CharCluster::clear(self : CharCluster) -> Unit

    CharCluster::info

    source
    fn CharCluster::info(self : CharCluster) -> ClusterInfo

    CharCluster::is_empty

    source
    fn CharCluster::is_empty(self : CharCluster) -> Bool

    CharCluster::map

    source
    fn CharCluster::map(self : CharCluster, f : (Char) -> UInt16) -> Status

    CharCluster::mapped_chars

    source
    fn CharCluster::mapped_chars(self : CharCluster) -> ArrayView[ClusterChar]

    CharCluster::range

    source
    fn CharCluster::range(self : CharCluster) -> SourceRange

    CharCluster::user_data

    source
    fn CharCluster::user_data(self : CharCluster) -> UInt

    CharInfo

    source
    type CharInfo

    Information about a character including unicode properties and boundary analysis.

    CharInfo::CharInfo

    source
    fn CharInfo::CharInfo(properties : Properties, boundary : Boundary) -> CharInfo

    CharInfo::boundary

    source
    fn CharInfo::boundary(self : CharInfo) -> Boundary

    CharInfo::category

    source
    fn CharInfo::category(self : CharInfo) -> Category

    CharInfo::cluster_break

    source
    fn CharInfo::cluster_break(self : CharInfo) -> ClusterBreak

    CharInfo::cluster_class

    source
    fn CharInfo::cluster_class(self : CharInfo) -> (ClusterBreak, Bool)

    CharInfo::contributes_to_shaping

    source
    fn CharInfo::contributes_to_shaping(self : CharInfo) -> Bool

    CharInfo::default

    source
    fn CharInfo::default() -> CharInfo

    CharInfo::from_char

    source
    fn CharInfo::from_char(ch : Char) -> CharInfo

    CharInfo::is_ignorable

    source
    fn CharInfo::is_ignorable(self : CharInfo) -> Bool

    CharInfo::is_variation_selector

    source
    fn CharInfo::is_variation_selector(self : CharInfo) -> Bool

    CharInfo::joining_type

    source
    fn CharInfo::joining_type(self : CharInfo) -> JoiningType

    CharInfo::myanmar_class

    source
    fn CharInfo::myanmar_class(self : CharInfo) -> (MyanmarClass, Bool)

    CharInfo::properties

    source
    fn CharInfo::properties(self : CharInfo) -> Properties

    CharInfo::use_class

    source
    fn CharInfo::use_class(self : CharInfo) -> (UseClass, Bool, Bool)

    CharStream

    source
    type CharStream

    Charmap

    source
    pub struct Charmap {
      data : Bytes
      proxy : CharmapProxy
    }

    Maps characters to nominal glyph identifiers.

    Charmap::enumerate

    source
    fn Charmap::enumerate(self : Charmap, f : (UInt, UInt16) -> Unit) -> Unit

    Charmap::from_font

    source
    fn Charmap::from_font(font : FontRef) -> Charmap

    Charmap::map

    source
    fn Charmap::map(self : Charmap, codepoint : UInt) -> UInt16

    Charmap::proxy

    source
    fn Charmap::proxy(self : Charmap) -> CharmapProxy

    CharmapProxy

    source
    pub struct CharmapProxy {
      offset : UInt
      format : UInt
      symbol : Bool
    }

    Proxy for rematerializing a character map.

    CharmapProxy::from_font

    source
    fn CharmapProxy::from_font(font : FontRef) -> CharmapProxy

    CharmapProxy::materialize

    source
    fn CharmapProxy::materialize(self : CharmapProxy, font : FontRef) -> Charmap

    Materializes a character map from the specified font. This proxy must have been created from the same font.

    Cjk

    source
    pub(all) enum Cjk {
      None
      Traditional
      Simplified
      Japanese
      Korean
    }

    Chinese, Japanese and Korean languages.

    ClusterBreak

    source
    pub(all) enum ClusterBreak {
      CN
      CR
      EX
      L
      LF
      LV
      LVT
      PP
      RI
      SM
      T
      V
      XX
      ZWJ
    }

    ClusterChar

    source
    type ClusterChar

    Character output from the cluster parser.

    ClusterChar::ClusterChar

    source
    fn ClusterChar::ClusterChar(ch : Char, offset : UInt, shape_class : ShapeClass, joining_type : JoiningType, ignorable : Bool, contributes_to_shaping : Bool, glyph_id : UInt16, data : UInt) -> ClusterChar

    ClusterChar::ch

    source
    fn ClusterChar::ch(self : ClusterChar) -> Char

    ClusterChar::contributes_to_shaping

    source
    fn ClusterChar::contributes_to_shaping(self : ClusterChar) -> Bool

    ClusterChar::data

    source
    fn ClusterChar::data(self : ClusterChar) -> UInt

    ClusterChar::glyph_id

    source
    fn ClusterChar::glyph_id(self : ClusterChar) -> UInt16

    ClusterChar::is_ignorable

    source
    fn ClusterChar::is_ignorable(self : ClusterChar) -> Bool

    ClusterChar::joining_type

    source
    fn ClusterChar::joining_type(self : ClusterChar) -> JoiningType

    ClusterChar::offset

    source
    fn ClusterChar::offset(self : ClusterChar) -> UInt

    ClusterChar::shape_class

    source
    fn ClusterChar::shape_class(self : ClusterChar) -> ShapeClass

    ClusterInfo

    source
    type ClusterInfo

    Information about a cluster including content properties and boundary analysis.

    ClusterInfo::boundary

    source
    fn ClusterInfo::boundary(self : ClusterInfo) -> Boundary

    ClusterInfo::emoji

    source
    fn ClusterInfo::emoji(self : ClusterInfo) -> Emoji

    ClusterInfo::is_boundary

    source
    fn ClusterInfo::is_boundary(self : ClusterInfo) -> Bool

    ClusterInfo::is_broken

    source
    fn ClusterInfo::is_broken(self : ClusterInfo) -> Bool

    ClusterInfo::is_emoji

    source
    fn ClusterInfo::is_emoji(self : ClusterInfo) -> Bool

    ClusterInfo::is_whitespace

    source
    fn ClusterInfo::is_whitespace(self : ClusterInfo) -> Bool

    ClusterInfo::whitespace

    source
    fn ClusterInfo::whitespace(self : ClusterInfo) -> Whitespace

    ColorPalette

    source
    pub struct ColorPalette {
      font : FontRef
      b : 
    BeBytes
      version : UInt16
      index : UInt16
      num_entries : UInt16
      offset : Int
    }

    Collection of colors.

    ColorPalette::get

    source
    fn ColorPalette::get(self : ColorPalette, index : UInt16) -> (Byte, Byte, Byte, Byte)

    Returns the color for the specified entry in RGBA order.

    ColorPalette::index

    source
    fn ColorPalette::index(self : ColorPalette) -> UInt16

    ColorPalette::is_empty

    source
    fn ColorPalette::is_empty(self : ColorPalette) -> Bool

    ColorPalette::len

    source
    fn ColorPalette::len(self : ColorPalette) -> UInt16

    ColorPalette::name

    source
    fn ColorPalette::name(self : ColorPalette, language : String?) -> LocalizedString?

    ColorPalette::name_id

    source
    fn ColorPalette::name_id(self : ColorPalette) -> StringId?

    ColorPalette::usability

    source
    fn ColorPalette::usability(self : ColorPalette) -> Usability?

    ColorPalettes

    source
    pub struct ColorPalettes {
      font : FontRef
      b : 
    BeBytes
      len : Int
    }

    Iterator over a collection of color palettes.

    ColorPalettes::from_font

    source
    fn ColorPalettes::from_font(font : FontRef) -> ColorPalettes

    ColorPalettes::iter

    source

    ColorPalettes::len

    source
    fn ColorPalettes::len(self : ColorPalettes) -> Int

    CombiningClass

    source
    pub(all) enum CombiningClass {
      NotReordered
      Overlay
      HanReading
      Nukta
      KanaVoicing
      Virama
      Ccc10
      Ccc11
      Ccc12
      Ccc13
      Ccc14
      Ccc15
      Ccc16
      Ccc17
      Ccc18
      Ccc19
      Ccc20
      Ccc21
      Ccc22
      Ccc23
      Ccc24
      Ccc25
      Ccc26
      Ccc27
      Ccc28
      Ccc29
      Ccc30
      Ccc31
      Ccc32
      Ccc33
      Ccc34
      Ccc35
      Ccc36
      Ccc84
      Ccc91
      Ccc103
      Ccc107
      Ccc118
      Ccc122
      Ccc129
      Ccc130
      Ccc132
      Ccc133
      AttachedBelowLeft
      AttachedBelow
      AttachedAbove
      AttachedAboveRight
      BelowLeft
      Below
      BelowRight
      Left
      Right
      AboveLeft
      Above
      AboveRight
      DoubleBelow
      DoubleAbove
      IotaSubscript
    }

    Emoji

    source
    pub(all) enum Emoji {
      None
      Default
      Text
      Color
    }

    Presentation mode for an emoji cluster.

    Encoding

    source
    pub(all) enum Encoding {
      Unicode
      MacRoman
      Other(UInt16, UInt16)
    }

    Encoding of a localized string.

    Fonts can contain a variety of platform specific and legacy encodings. Only the ones we decode are listed here.

    Encoding::is_decodable

    source
    fn Encoding::is_decodable(self : Encoding) -> Bool

    Entry

    source
    type Entry[T]

    Feature

    source
    type Feature

    Typographic rule that produces modifications to a sequence of glyphs.

    Feature::action

    source
    fn Feature::action(self : Feature) -> Action

    Returns the action of the feature.

    Feature::name

    source
    fn Feature::name(self : Feature) -> String?

    Returns the name of the feature, if available.

    Feature::tag

    source
    fn Feature::tag(self : Feature) -> UInt

    Returns the feature tag.

    Features

    source
    type Features

    Iterator over a collection of typographic features.

    Features::from_font

    source
    fn Features::from_font(font : FontRef) -> Features

    Features::iter

    source
    fn Features::iter(self : Features) -> Iter[Feature]

    FontCache

    source
    pub struct FontCache[T] {
      entries : Array[Entry[T]]
      max_entries : Int
      epoch : UInt64
    }

    Simple LRU cache keyed by a custom font identifier.

    Ported from swash/src/cache.rs (FontCache<T>).

    FontCache::FontCache

    source
    fn[T] FontCache::FontCache(max_entries : Int) -> FontCache[T]

    FontCache::get

    source
    fn[T] FontCache::get(self : FontCache[T], font : FontRef, id_override : (UInt64, UInt64)?, f : (FontRef) -> T) -> ((UInt64, UInt64), 
    Ref    [T])

    FontDataRef

    source
    pub struct FontDataRef {
      data : Bytes
      len : Int
    }

    Reference to the content of a font file.

    FontDataRef::data

    source
    fn FontDataRef::data(self : FontDataRef) -> Bytes

    FontDataRef::fonts

    source
    fn FontDataRef::fonts(self : FontDataRef) -> Iter[FontRef]

    FontDataRef::from_data

    source
    fn FontDataRef::from_data(data : Bytes) -> FontDataRef?

    FontDataRef::get

    source
    fn FontDataRef::get(self : FontDataRef, index : Int) -> FontRef?

    FontDataRef::is_collection

    source
    fn FontDataRef::is_collection(self : FontDataRef) -> Bool

    FontDataRef::is_empty

    source
    fn FontDataRef::is_empty(self : FontDataRef) -> Bool

    FontDataRef::len

    source
    fn FontDataRef::len(self : FontDataRef) -> Int

    FontRef

    source
    pub struct FontRef {
      data : Bytes
      offset : Int
      key : CacheKey
    }

    Reference to a font.
    impl RawFont for FontRef

    FontRef::alpha_strikes

    source
    fn FontRef::alpha_strikes(self : FontRef) -> BitmapStrikes

    Returns an iterator over the alpha bitmap strikes for the font.

    FontRef::attributes

    source
    fn FontRef::attributes(self : FontRef) -> Attributes

    FontRef::color_palettes

    source
    fn FontRef::color_palettes(self : FontRef) -> ColorPalettes

    FontRef::color_strikes

    source
    fn FontRef::color_strikes(self : FontRef) -> BitmapStrikes

    Returns an iterator over the color bitmap strikes for the font.

    FontRef::data

    source
    fn FontRef::data(self : FontRef) -> Bytes

    FontRef::features

    source
    fn FontRef::features(self : FontRef) -> Features

    FontRef::from_index

    source
    fn FontRef::from_index(data : Bytes, index : Int) -> FontRef?

    FontRef::from_offset

    source
    fn FontRef::from_offset(data : Bytes, offset : Int) -> FontRef?

    FontRef::glyph_metrics

    source
    fn FontRef::glyph_metrics(self : FontRef, coords : ArrayView[Int]) -> GlyphMetrics

    Returns glyph metrics for the font and the specified normalized variation coordinates.

    FontRef::glyph_name

    source
    fn FontRef::glyph_name(self : FontRef, glyph_id : UInt16) -> String?

    Returns the name for the specified glyph identifier.

    Note: upstream marks this API as unstable and uses it for testing only.

    FontRef::head

    source

    FontRef::hhea

    source

    FontRef::instances

    source
    fn FontRef::instances(self : FontRef) -> Instances

    FontRef::key

    source
    fn FontRef::key(self : FontRef) -> CacheKey

    FontRef::localized_strings

    source
    fn FontRef::localized_strings(self : FontRef) -> LocalizedStrings

    FontRef::maxp

    source

    FontRef::metrics

    source
    fn FontRef::metrics(self : FontRef, coords : ArrayView[Int]) -> Metrics

    Returns metrics for the font and the specified normalized variation coordinates.

    FontRef::offset

    source
    fn FontRef::offset(self : FontRef) -> Int

    FontRef::os2

    source

    FontRef::post

    source

    FontRef::table_by_tag

    source
    fn FontRef::table_by_tag(self : FontRef, tag : UInt) -> BytesView?

    FontRef::table_data

    source
    fn FontRef::table_data(self : FontRef, tag : UInt) -> BytesView?

    FontRef::table_offset

    source
    fn FontRef::table_offset(self : FontRef, tag : UInt) -> UInt

    Returns the byte offset of the table with the specified tag.

    FontRef::variations

    source
    fn FontRef::variations(self : FontRef) -> Variations

    FontRef::vhea

    source

    FontRef::writing_systems

    source
    fn FontRef::writing_systems(self : FontRef) -> WritingSystems

    GlyphMetrics

    source
    type GlyphMetrics

    Glyph advances, side bearings and vertical origins.

    GlyphMetrics::advance_height

    source
    fn GlyphMetrics::advance_height(self : GlyphMetrics, glyph_id : UInt16) -> Double

    Returns the vertical advance for the specified glyph.

    GlyphMetrics::advance_width

    source
    fn GlyphMetrics::advance_width(self : GlyphMetrics, glyph_id : UInt16) -> Double

    Returns the horizontal advance for the specified glyph.

    GlyphMetrics::glyph_count

    source
    fn GlyphMetrics::glyph_count(self : GlyphMetrics) -> UInt16

    GlyphMetrics::has_variations

    source
    fn GlyphMetrics::has_variations(self : GlyphMetrics) -> Bool

    Returns true if variations are supported.

    GlyphMetrics::has_vertical_metrics

    source
    fn GlyphMetrics::has_vertical_metrics(self : GlyphMetrics) -> Bool

    Returns true if the font provides canonical vertical glyph metrics.

    GlyphMetrics::linear_scale

    source
    fn GlyphMetrics::linear_scale(self : GlyphMetrics, scale : Double) -> GlyphMetrics

    Creates a new set of metrics scaled by the specified factor.

    GlyphMetrics::lsb

    source
    fn GlyphMetrics::lsb(self : GlyphMetrics, glyph_id : UInt16) -> Double

    Returns the left side bearing for the specified glyph.

    GlyphMetrics::scale

    source
    fn GlyphMetrics::scale(self : GlyphMetrics, ppem : Double) -> GlyphMetrics

    Creates a new set of metrics scaled for the specified pixels per em unit.

    GlyphMetrics::tsb

    source
    fn GlyphMetrics::tsb(self : GlyphMetrics, glyph_id : UInt16) -> Double

    Returns the top side bearing for the specified glyph.

    GlyphMetrics::units_per_em

    source
    fn GlyphMetrics::units_per_em(self : GlyphMetrics) -> UInt16

    GlyphMetrics::vertical_origin

    source
    fn GlyphMetrics::vertical_origin(self : GlyphMetrics, glyph_id : UInt16) -> Double

    Returns the vertical origin for the specified glyph id.

    Instance

    source
    type Instance

    Instance::index

    source
    fn Instance::index(self : Instance) -> Int

    Instance::name

    source
    fn Instance::name(self : Instance, language : String?) -> LocalizedString?

    Instance::name_id

    source
    fn Instance::name_id(self : Instance) -> StringId

    Instance::normalized_coords

    source
    fn Instance::normalized_coords(self : Instance) -> ArrayView[Int]

    Instance::postscript_name

    source
    fn Instance::postscript_name(self : Instance, language : String?) -> LocalizedString?

    Instance::postscript_name_id

    source
    fn Instance::postscript_name_id(self : Instance) -> StringId?

    Instance::values

    source
    fn Instance::values(self : Instance) -> ArrayView[Double]

    Instances

    source
    type Instances

    Instances::find_by_name

    source
    fn Instances::find_by_name(self : Instances, name : String) -> Instance?

    Instances::find_by_postscript_name

    source
    fn Instances::find_by_postscript_name(self : Instances, name : String) -> Instance?

    Instances::iter

    source
    fn Instances::iter(self : Instances) -> Iter[Instance]

    Instances::next

    source
    fn Instances::next(self : Instances) -> Instance?

    JoiningType

    source
    pub(all) enum JoiningType {
      U
      L
      R
      D
      Alaph
      DalathRish
      T
    }

    Language

    source
    pub struct Language {
      language : Array[Byte]
      script : Array[Byte]
      region : Array[Byte]
      lang_len : Int
      script_len : Int
      region_len : Int
      cjk : Cjk
      name_index : Int
      tag : UInt?
    }

    Representation of a language and its associated script and region.
    impl Show for Language

    Language::cjk

    source
    fn Language::cjk(self : Language) -> Cjk

    Returns the CJK language.

    Language::from_opentype

    source
    fn Language::from_opentype(tag : UInt) -> Language?

    Returns the language associated with the specified OpenType language tag.

    Language::language

    source
    fn Language::language(self : Language) -> String

    Returns the language component.

    Language::name

    source
    fn Language::name(self : Language) -> String?

    Returns the name of the language.

    Language::output

    source
    fn Language::output(self : Language, logger : &Logger) -> Unit

    Language::parse

    source
    fn Language::parse(tag : String) -> Language?

    Parses a language tag.

    Language::region

    source
    fn Language::region(self : Language) -> String?

    Returns the region component.

    Language::script

    source
    fn Language::script(self : Language) -> String?

    Returns the script component.

    Language::to_opentype

    source
    fn Language::to_opentype(self : Language) -> UInt?

    Returns the associated OpenType language tag.

    Language::to_string

    source
    fn Language::to_string(self : Language) -> String

    LineBreak

    source
    pub(all) enum LineBreak {
      AI
      AL
      B2
      BA
      BB
      BK
      CB
      CJ
      CL
      CM
      CP
      CR
      EB
      EM
      EX
      GL
      H2
      H3
      HL
      HY
      ID
      IN
      IS
      JL
      JT
      JV
      LF
      NL
      NS
      NU
      OP
      PO
      PR
      QU
      RI
      SA
      SG
      SP
      SY
      WJ
      XX
      ZW
      ZWJ
    }

    LocalizedString

    source
    pub struct LocalizedString {
      b : 
    BeBytes
      storage : Int
      offset : Int
    }

    Represents a single localized string in a font.

    LocalizedString::chars

    source
    fn LocalizedString::chars(self : LocalizedString) -> Iter[Char]

    LocalizedString::id

    source

    LocalizedString::is_decodable

    source
    fn LocalizedString::is_decodable(self : LocalizedString) -> Bool

    LocalizedString::is_unicode

    source
    fn LocalizedString::is_unicode(self : LocalizedString) -> Bool

    LocalizedString::language

    source
    fn LocalizedString::language(self : LocalizedString) -> String

    LocalizedString::to_string

    source
    fn LocalizedString::to_string(self : LocalizedString) -> String

    LocalizedStrings

    source
    pub struct LocalizedStrings {
      b : 
    BeBytes
      len : Int
      storage : Int
    }

    Iterator over a collection of localized strings.

    LocalizedStrings::find_by_id

    source
    fn LocalizedStrings::find_by_id(self : LocalizedStrings, id : StringId, language : String?) -> LocalizedString?

    Searches for a string with the specified identifier, and if specified, language.

    This function searches the entire string collection without regard for the current state of the iterator.

    LocalizedStrings::iter

    source

    LocalizedStrings::len

    source
    fn LocalizedStrings::len(self : LocalizedStrings) -> Int

    Metrics

    source
    pub struct Metrics {
      units_per_em : UInt16
      glyph_count : UInt16
      is_monospace : Bool
      has_vertical_metrics : Bool
      ascent : Double
      descent : Double
      leading : Double
      vertical_ascent : Double
      vertical_descent : Double
      vertical_leading : Double
      cap_height : Double
      x_height : Double
      average_width : Double
      max_width : Double
      underline_offset : Double
      strikeout_offset : Double
      stroke_size : Double
    }

    Global font metrics.

    Metrics::linear_scale

    source
    fn Metrics::linear_scale(self : Metrics, s : Double) -> Metrics

    Creates a new set of metrics scaled by the specified factor.

    Metrics::scale

    source
    fn Metrics::scale(self : Metrics, ppem : Double) -> Metrics

    Creates a new set of metrics scaled for the specified pixels per em unit.

    MetricsProxy

    source
    type MetricsProxy

    Proxy for rematerializing metrics.

    MetricsProxy::from_font

    source
    fn MetricsProxy::from_font(font : FontRef) -> MetricsProxy

    MetricsProxy::glyph_count

    source
    fn MetricsProxy::glyph_count(self : MetricsProxy) -> UInt16

    MetricsProxy::materialize_glyph_metrics

    source
    fn MetricsProxy::materialize_glyph_metrics(self : MetricsProxy, font : FontRef, coords : ArrayView[Int]) -> GlyphMetrics

    Materializes glyph metrics for the specified font and normalized variation coordinates. This proxy must have been created from the same font.

    MetricsProxy::materialize_metrics

    source
    fn MetricsProxy::materialize_metrics(self : MetricsProxy, font : FontRef, coords : ArrayView[Int]) -> Metrics

    Materializes font metrics for the specified font and normalized variation coordinates. This proxy must have been created from the same font.

    MetricsProxy::units_per_em

    source
    fn MetricsProxy::units_per_em(self : MetricsProxy) -> UInt16

    MyanmarClass

    source
    pub(all) enum MyanmarClass {
      A
      As
      C
      D
      D0
      DB
      GB
      H
      IV
      J
      K
      MH
      MR
      MW
      MY
      O
      P
      PT
      R
      S
      V
      VAbv
      VBlw
      VPre
      VPst
      VS
      WJ
    }

    ObliqueAngle

    source
    pub struct ObliqueAngle {
      value : UInt16
    }

    Angle of an oblique style in degrees from -90 to 90.

    ObliqueAngle::from_degrees

    source
    fn ObliqueAngle::from_degrees(degrees : Double) -> ObliqueAngle

    ObliqueAngle::from_gradians

    source
    fn ObliqueAngle::from_gradians(gradians : Double) -> ObliqueAngle

    ObliqueAngle::from_radians

    source
    fn ObliqueAngle::from_radians(radians : Double) -> ObliqueAngle

    ObliqueAngle::from_turns

    source
    fn ObliqueAngle::from_turns(turns : Double) -> ObliqueAngle

    ObliqueAngle::to_degrees

    source
    fn ObliqueAngle::to_degrees(self : ObliqueAngle) -> Double

    Parser

    source
    type Parser

    Parser that accepts a sequence of characters and outputs character clusters.

    Parser::Parser

    source
    fn Parser::Parser(script : Script, tokens : Iter[Token]) -> Parser

    Parser::next

    source
    fn Parser::next(self : Parser, cluster : CharCluster) -> Bool

    Properties

    source
    pub struct Properties {
      bits : UInt
    }

    Compact reference to Unicode properties for a character.

    Properties::bidi_class

    source
    fn Properties::bidi_class(self : Properties) -> BidiClass

    Properties::block

    source
    fn Properties::block(self : Properties) -> Block

    Properties::boundary

    source
    fn Properties::boundary(self : Properties) -> UInt

    Properties::category

    source
    fn Properties::category(self : Properties) -> Category

    Properties::cluster_break

    source
    fn Properties::cluster_break(self : Properties) -> ClusterBreak

    Properties::cluster_class

    source
    fn Properties::cluster_class(self : Properties) -> (ClusterBreak, Bool)

    Properties::combining_class

    source
    fn Properties::combining_class(self : Properties) -> UInt

    Properties::contributes_to_shaping

    source
    fn Properties::contributes_to_shaping(self : Properties) -> Bool

    Properties::is_close_bracket

    source
    fn Properties::is_close_bracket(self : Properties) -> Bool

    Properties::is_emoji

    source
    fn Properties::is_emoji(self : Properties) -> Bool

    Properties::is_extended_pictographic

    source
    fn Properties::is_extended_pictographic(self : Properties) -> Bool

    Properties::is_ignorable

    source
    fn Properties::is_ignorable(self : Properties) -> Bool

    Properties::is_open_bracket

    source
    fn Properties::is_open_bracket(self : Properties) -> Bool

    Properties::is_variation_selector

    source
    fn Properties::is_variation_selector(self : Properties) -> Bool

    Properties::joining_type

    source
    fn Properties::joining_type(self : Properties) -> JoiningType

    Properties::line_break

    source
    fn Properties::line_break(self : Properties) -> LineBreak

    Properties::myanmar_class

    source
    fn Properties::myanmar_class(self : Properties) -> (MyanmarClass, Bool)

    Properties::script

    source
    fn Properties::script(self : Properties) -> Script

    Properties::use_class

    source
    fn Properties::use_class(self : Properties) -> (UseClass, Bool, Bool)

    Properties::with_boundary

    source
    fn Properties::with_boundary(self : Properties, boundary : UInt) -> Properties

    Properties::word_break

    source
    fn Properties::word_break(self : Properties) -> WordBreak

    Script

    source
    pub(all) enum Script {
      Adlam
      CaucasianAlbanian
      Ahom
      Arabic
      ImperialAramaic
      Armenian
      Avestan
      Balinese
      Bamum
      BassaVah
      Batak
      Bengali
      Bhaiksuki
      Bopomofo
      Brahmi
      Braille
      Buginese
      Buhid
      Chakma
      CanadianAboriginal
      Carian
      Cham
      Cherokee
      Chorasmian
      Coptic
      Cypriot
      Cyrillic
      Devanagari
      DivesAkuru
      Dogra
      Deseret
      Duployan
      EgyptianHieroglyphs
      Elbasan
      Elymaic
      Ethiopic
      Georgian
      Glagolitic
      GunjalaGondi
      MasaramGondi
      Gothic
      Grantha
      Greek
      Gujarati
      Gurmukhi
      Hangul
      Han
      Hanunoo
      Hatran
      Hebrew
      Hiragana
      AnatolianHieroglyphs
      PahawhHmong
      NyiakengPuachueHmong
      OldHungarian
      OldItalic
      Javanese
      KayahLi
      Katakana
      Kharoshthi
      Khmer
      Khojki
      KhitanSmallScript
      Kannada
      Kaithi
      TaiTham
      Lao
      Latin
      Lepcha
      Limbu
      LinearA
      LinearB
      Lisu
      Lycian
      Lydian
      Mahajani
      Makasar
      Mandaic
      Manichaean
      Marchen
      Medefaidrin
      MendeKikakui
      MeroiticCursive
      MeroiticHieroglyphs
      Malayalam
      Modi
      Mongolian
      Mro
      MeeteiMayek
      Multani
      Myanmar
      Nandinagari
      OldNorthArabian
      Nabataean
      Newa
      Nko
      Nushu
      Ogham
      OlChiki
      OldTurkic
      Oriya
      Osage
      Osmanya
      Palmyrene
      PauCinHau
      OldPermic
      PhagsPa
      InscriptionalPahlavi
      PsalterPahlavi
      Phoenician
      Miao
      InscriptionalParthian
      Rejang
      HanifiRohingya
      Runic
      Samaritan
      OldSouthArabian
      Saurashtra
      SignWriting
      Shavian
      Sharada
      Siddham
      Khudawadi
      Sinhala
      Sogdian
      OldSogdian
      SoraSompeng
      Soyombo
      Sundanese
      SylotiNagri
      Syriac
      Tagbanwa
      Takri
      TaiLe
      NewTaiLue
      Tamil
      Tangut
      TaiViet
      Telugu
      Tifinagh
      Tagalog
      Thaana
      Thai
      Tibetan
      Tirhuta
      Ugaritic
      Vai
      WarangCiti
      Wancho
      OldPersian
      Cuneiform
      Yezidi
      Yi
      ZanabazarSquare
      Inherited
      Common
      Unknown
    }

    Unicode script.

    Script::from_opentype

    source
    fn Script::from_opentype(tag : UInt) -> Script?

    Returns the script associated with the specified OpenType script tag.

    Script::is_complex

    source
    fn Script::is_complex(self : Script) -> Bool

    Returns true if the script requires complex shaping.

    Script::is_joined

    source
    fn Script::is_joined(self : Script) -> Bool

    Returns true if the script has cursive joining.

    Script::name

    source
    fn Script::name(self : Script) -> String

    Returns the name of the script.

    Script::to_opentype

    source
    fn Script::to_opentype(self : Script) -> UInt

    Returns the script as an OpenType tag.

    SeenFeatures

    source
    pub struct SeenFeatures {
      bits : Array[UInt]
    }

    Bitset for feature de-duplication.

    SeenFeatures::SeenFeatures

    source
    fn SeenFeatures::SeenFeatures() -> SeenFeatures

    SeenFeatures::mark

    source
    fn SeenFeatures::mark(self : SeenFeatures, feature_index : Int) -> Bool

    Setting

    source
    pub struct Setting[T] {
      tag : UInt
      value : T
    }

    Setting::Setting

    source
    fn[T] Setting::Setting(tag : UInt, value : T) -> Setting[T]

    Setting::parse_feature

    source
    fn Setting::parse_feature(s : String) -> Setting[UInt16]?

    Setting::parse_feature_list

    source
    fn Setting::parse_feature_list(s : String) -> Iter[Setting[UInt16]]

    Setting::parse_variation

    source
    fn Setting::parse_variation(s : String) -> Setting[Double]?

    Setting::parse_variation_list

    source
    fn Setting::parse_variation_list(s : String) -> Iter[Setting[Double]]

    ShapeClass

    source
    pub(all) enum ShapeClass {
      Reph
      Pref
      Kinzi
      Base
      Mark
      Halant
      MedialRa
      VMPre
      VPre
      VBlw
      Anusvara
      Zwj
      Zwnj
      Control
      Vs
      Other
    }

    Shaping class of a character.

    SourceRange

    source
    type SourceRange

    Source range of a cluster in code units.

    SourceRange::SourceRange

    source
    fn SourceRange::SourceRange(start : UInt, end : UInt) -> SourceRange

    SourceRange::end

    source
    fn SourceRange::end(self : SourceRange) -> UInt

    SourceRange::start

    source
    fn SourceRange::start(self : SourceRange) -> UInt

    Status

    source
    pub(all) enum Status {
      Discard
      Keep
      Complete
    }

    Iterative status of mapping a character cluster to nominal glyph identifiers.

    Stretch

    source
    pub struct Stretch {
      value : UInt16
    }

    Visual width of a font-- a relative change from the normal aspect ratio.
    impl Compare for Stretch
    impl Eq for Stretch
    impl Show for Stretch

    Stretch::compare

    source
    fn Stretch::compare(self : Stretch, other : Stretch) -> Int

    Stretch::condensed

    source
    fn Stretch::condensed() -> Stretch

    Stretch::equal

    source
    fn Stretch::equal(self : Stretch, other : Stretch) -> Bool

    Stretch::expanded

    source
    fn Stretch::expanded() -> Stretch

    Stretch::extra_condensed

    source
    fn Stretch::extra_condensed() -> Stretch

    Stretch::extra_expanded

    source
    fn Stretch::extra_expanded() -> Stretch

    Stretch::from_percentage

    source
    fn Stretch::from_percentage(percentage : Double) -> Stretch

    Stretch::is_condensed

    source
    fn Stretch::is_condensed(self : Stretch) -> Bool

    Stretch::is_expanded

    source
    fn Stretch::is_expanded(self : Stretch) -> Bool

    Stretch::is_normal

    source
    fn Stretch::is_normal(self : Stretch) -> Bool

    Stretch::normal

    source
    fn Stretch::normal() -> Stretch

    Stretch::not_equal

    source
    fn Stretch::not_equal(x : Stretch, y : Stretch) -> Bool

    Stretch::op_ge

    source
    fn Stretch::op_ge(x : Stretch, y : Stretch) -> Bool

    Stretch::op_gt

    source
    fn Stretch::op_gt(x : Stretch, y : Stretch) -> Bool

    Stretch::op_le

    source
    fn Stretch::op_le(x : Stretch, y : Stretch) -> Bool

    Stretch::op_lt

    source
    fn Stretch::op_lt(x : Stretch, y : Stretch) -> Bool

    Stretch::output

    source
    fn Stretch::output(self : Stretch, logger : &Logger) -> Unit

    Stretch::parse

    source
    fn Stretch::parse(s0 : String) -> Stretch?

    Stretch::raw

    source
    fn Stretch::raw(self : Stretch) -> UInt16

    Stretch::semi_condensed

    source
    fn Stretch::semi_condensed() -> Stretch

    Stretch::semi_expanded

    source
    fn Stretch::semi_expanded() -> Stretch

    Stretch::to_percentage

    source
    fn Stretch::to_percentage(self : Stretch) -> Double

    Stretch::to_string

    source
    fn Stretch::to_string(self : Stretch) -> String

    Stretch::ultra_condensed

    source
    fn Stretch::ultra_condensed() -> Stretch

    Stretch::ultra_expanded

    source
    fn Stretch::ultra_expanded() -> Stretch

    StringId

    source
    pub(all) enum StringId {
      Copyright
      Family
      SubFamily
      UniqueId
      Full
      Version
      PostScript
      Trademark
      Manufacturer
      Designer
      Description
      VendorUrl
      DesignerUrl
      License
      LicenseUrl
      TypographicFamily
      TypographicSubFamily
      CompatibleFull
      SampleText
      PostScriptCid
      WwsFamily
      WwsSubFamily
      LightBackgroundPalette
      DarkBackgroundPalette
      VariationsPostScriptNamePrefix
      Other(UInt16)
    }

    Identifier for well-known localized strings in a font.

    StringId::from_raw

    source
    fn StringId::from_raw(value : UInt16) -> StringId

    StringId::to_raw

    source
    fn StringId::to_raw(self : StringId) -> UInt16

    Style

    source
    pub(all) enum Style {
      Normal
      Italic
      Oblique(ObliqueAngle)
    }

    Visual style or 'slope' of a font.
    impl Eq for Style
    impl Show for Style

    Style::equal

    source
    fn Style::equal(self : Style, other : Style) -> Bool

    Style::from_degrees

    source
    fn Style::from_degrees(degrees : Double) -> Style

    Style::not_equal

    source
    fn Style::not_equal(x : Style, y : Style) -> Bool

    Style::output

    source
    fn Style::output(self : Style, logger : &Logger) -> Unit

    Style::parse

    source
    fn Style::parse(s0 : String) -> Style?

    Style::to_degrees

    source
    fn Style::to_degrees(self : Style) -> Double

    Style::to_string

    source
    fn Style::to_string(self : Style) -> String

    Synthesis

    source
    pub struct Synthesis {
      vars : Array[Setting[Double]]
      embolden : Bool
      skew : Int
    }

    Synthesis suggestions for mismatched font attributes.

    This is generated by Attributes::synthesize.
    impl Eq for Synthesis

    Synthesis::any

    source
    fn Synthesis::any(self : Synthesis) -> Bool

    Synthesis::embolden

    source
    fn Synthesis::embolden(self : Synthesis) -> Bool

    Synthesis::equal

    source
    fn Synthesis::equal(self : Synthesis, other : Synthesis) -> Bool

    Synthesis::not_equal

    source
    fn Synthesis::not_equal(x : Synthesis, y : Synthesis) -> Bool

    Synthesis::skew

    source
    fn Synthesis::skew(self : Synthesis) -> Double?

    Synthesis::variations

    source
    fn Synthesis::variations(self : Synthesis) -> ArrayView[Setting[Double]]

    Token

    source
    type Token

    Character input to the cluster parser.

    Token::Token

    source
    fn Token::Token(ch : Char, offset : UInt, len : UInt, info : CharInfo, data : UInt) -> Token

    Token::ch

    source
    fn Token::ch(self : Token) -> Char

    Token::data

    source
    fn Token::data(self : Token) -> UInt

    Token::default

    source
    fn Token::default() -> Token

    Token::info

    source
    fn Token::info(self : Token) -> CharInfo

    Token::len

    source
    fn Token::len(self : Token) -> UInt

    Token::offset

    source
    fn Token::offset(self : Token) -> UInt

    Usability

    source
    pub(all) enum Usability {
      Light
      Dark
      Both
    }

    Theme of a palette with respect to background color.

    UseClass

    source
    pub(all) enum UseClass {
      B
      CGJ
      CMAbv
      CMBlw
      CS
      FAbv
      FBlw
      FPst
      FM
      GB
      H
      HN
      IND
      MAbv
      MBlw
      MPre
      MPst
      N
      O
      R
      Rsv
      S
      SMAbv
      SMBlw
      SUB
      VAbv
      VBlw
      VPre
      VPst
      VMAbv
      VMBlw
      VMPre
      VMPst
      VS
      WJ
      ZWJ
      ZWNJ
    }

    Variation

    source
    type Variation

    Variation::default_value

    source
    fn Variation::default_value(self : Variation) -> Double

    Variation::index

    source
    fn Variation::index(self : Variation) -> Int

    Variation::is_hidden

    source
    fn Variation::is_hidden(self : Variation) -> Bool

    Variation::max_value

    source
    fn Variation::max_value(self : Variation) -> Double

    Variation::min_value

    source
    fn Variation::min_value(self : Variation) -> Double

    Variation::name

    source
    fn Variation::name(self : Variation, language : String?) -> LocalizedString?

    Variation::name_id

    source
    fn Variation::name_id(self : Variation) -> StringId

    Variation::normalize

    source
    fn Variation::normalize(self : Variation, value : Double) -> Int

    Variation::tag

    source
    fn Variation::tag(self : Variation) -> UInt

    Variations

    source
    type Variations

    Variations::find_by_tag

    source
    fn Variations::find_by_tag(self : Variations, tag : UInt) -> Variation?

    Variations::iter

    source
    fn Variations::iter(self : Variations) -> Iter[Variation]

    Variations::len

    source
    fn Variations::len(self : Variations) -> Int

    Variations::next

    source
    fn Variations::next(self : Variations) -> Variation?

    Variations::normalized_coords

    source
    fn Variations::normalized_coords(self : Variations, settings : Iter[Setting[Double]]) -> Iter[Int]

    VariationsProxy

    source
    type VariationsProxy

    VariationsProxy::from_font

    source
    fn VariationsProxy::from_font(font : FontRef) -> VariationsProxy

    VariationsProxy::materialize

    source
    fn VariationsProxy::materialize(self : VariationsProxy, font : FontRef) -> Variations

    Weight

    source
    pub struct Weight {
      value : UInt16
    }

    Visual weight class of a font on a scale from 1 to 1000.
    impl Compare for Weight
    impl Eq for Weight
    impl Show for Weight

    Weight::black

    source
    fn Weight::black() -> Weight

    Weight::bold

    source
    fn Weight::bold() -> Weight

    Weight::compare

    source
    fn Weight::compare(self : Weight, other : Weight) -> Int

    Weight::equal

    source
    fn Weight::equal(self : Weight, other : Weight) -> Bool

    Weight::extra_bold

    source
    fn Weight::extra_bold() -> Weight

    Weight::extra_light

    source
    fn Weight::extra_light() -> Weight

    Weight::light

    source
    fn Weight::light() -> Weight

    Weight::medium

    source
    fn Weight::medium() -> Weight

    Weight::normal

    source
    fn Weight::normal() -> Weight

    Weight::not_equal

    source
    fn Weight::not_equal(x : Weight, y : Weight) -> Bool

    Weight::op_ge

    source
    fn Weight::op_ge(x : Weight, y : Weight) -> Bool

    Weight::op_gt

    source
    fn Weight::op_gt(x : Weight, y : Weight) -> Bool

    Weight::op_le

    source
    fn Weight::op_le(x : Weight, y : Weight) -> Bool

    Weight::op_lt

    source
    fn Weight::op_lt(x : Weight, y : Weight) -> Bool

    Weight::output

    source
    fn Weight::output(self : Weight, logger : &Logger) -> Unit

    Weight::parse

    source
    fn Weight::parse(s0 : String) -> Weight?

    Weight::semi_bold

    source
    fn Weight::semi_bold() -> Weight

    Weight::thin

    source
    fn Weight::thin() -> Weight

    Weight::to_string

    source
    fn Weight::to_string(self : Weight) -> String

    Whitespace

    source
    pub(all) enum Whitespace {
      None
      Space
      NoBreakSpace
      Tab
      Newline
      Other
    }

    Whitespace content of a cluster.

    Whitespace::is_space_or_nbsp

    source
    fn Whitespace::is_space_or_nbsp(self : Whitespace) -> Bool

    WordBreak

    source
    pub(all) enum WordBreak {
      CR
      DQ
      EX
      Extend
      FO
      HL
      KA
      LE
      LF
      MB
      ML
      MN
      NL
      NU
      RI
      SQ
      WSegSpace
      XX
      ZWJ
    }

    WordBreakStrength

    source
    pub(all) enum WordBreakStrength {
      Normal
      BreakAll
      KeepAll
    }

    Word breaking strength (corresponds to https://drafts.csswg.org/css-text/#word-break-property).

    Ported from swash/src/text/analyze.rs (swash is dual-licensed Apache-2.0 OR MIT).

    WritingSystem

    source
    type WritingSystem

    Script, language and associated typographic features available in a font.

    WritingSystem::features

    source
    fn WritingSystem::features(self : WritingSystem) -> Features

    Returns an iterator over the features provided by the writing system.

    WritingSystem::language

    source
    fn WritingSystem::language(self : WritingSystem) -> Language?

    Returns the language for the writing system.

    WritingSystem::language_tag

    source
    fn WritingSystem::language_tag(self : WritingSystem) -> UInt

    Returns the OpenType language tag for the writing system.

    WritingSystem::script

    source
    fn WritingSystem::script(self : WritingSystem) -> Script?

    Returns the script for the writing system.

    WritingSystem::script_tag

    source
    fn WritingSystem::script_tag(self : WritingSystem) -> UInt

    Returns the OpenType script tag for the writing system.

    WritingSystems

    source
    type WritingSystems

    Iterator over a collection of writing systems.

    WritingSystems::from_font

    source
    fn WritingSystems::from_font(font : FontRef) -> WritingSystems

    WritingSystems::iter

    source

    COMPOSE1_COUNT

    source
    let COMPOSE1_COUNT : Int

    MAX_CLUSTER_SIZE

    source
    let MAX_CLUSTER_SIZE : Int

    The maximum number of characters in a single cluster.

    UNICODE_VERSION_MAJOR

    source
    let UNICODE_VERSION_MAJOR : Int

    The version of the Unicode Character Database used to generate properties.

    UNICODE_VERSION_MINOR

    source
    let UNICODE_VERSION_MINOR : Int

    UNICODE_VERSION_PATCH

    source
    let UNICODE_VERSION_PATCH : Int

    analyze

    source
    fn analyze(chars : Iter[Char]) -> Analyze

    Returns an iterator yielding unicode properties and boundary analysis for each character in the specified sequence.

    compose_pair

    source
    fn compose_pair(a : Char, b : Char) -> Char?

    decompose

    source
    fn decompose(c : Char) -> Iter[Char]

    decompose_compat

    source
    fn decompose_compat(c : Char) -> Iter[Char]

    desc_from_aat

    source
    fn desc_from_aat(feature : UInt16, selector : UInt16) -> (Int, UInt, String)?

    Returns a feature tag and description from an AAT feature and selector.

    desc_from_at

    source
    fn desc_from_at(tag : UInt) -> (Int, String)?

    Returns a feature description for the specified tag.

    tag_from_bytes

    source
    fn tag_from_bytes(bytes : Bytes) -> UInt?

    tag_from_str_lossy

    source
    fn tag_from_str_lossy(s : String) -> UInt

    unicode_version

    source
    fn unicode_version() -> (Int, Int, Int)

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io