🥮 mooncakes.io

moon_swash

moon add Milky2018/moon_swash@0.1.10
Download zip
Author
Version
0.1.10
License
Apache-2.0
Repository
Last updated
2 months ago
Downloads
32K

Dependencies

README

#Milky2018/moon_swash

MoonBit port of the Rust swash reference implementation.

This repo provides:
  • Font metadata APIs (FontRef, attributes, localized strings, variation axes/instances, metrics, palettes, strikes).
  • Text shaping (Milky2018/moon_swash/shape).
  • Scaling and rendering (Milky2018/moon_swash/scale).

#Install

Add dependencies in your moon.pkg.json:

{
  "import": [
    { "path": "Milky2018/moon_swash", "alias": "swash" },
    { "path": "Milky2018/moon_swash/shape", "alias": "swash_shape" },
    { "path": "Milky2018/moon_swash/scale", "alias": "swash_scale" },

    // Optional: API parity with upstream swash module paths
    { "path": "Milky2018/moon_swash/iter", "alias": "swash_iter" },
    { "path": "Milky2018/moon_swash/proxy", "alias": "swash_proxy" }
  ]
}

#Quickstart

Load a font:

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

Shape a string:

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

#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).

#API Compatibility Notes

  • Milky2018/moon_swash/iter and Milky2018/moon_swash/proxy exist for API parity with upstream swash module paths.
  • They currently provide stable type aliases (so downstream import paths match), while the underlying implementations live in the main packages.

#Verify It Works

Basic:

moon test
moon check

Diff against an external reference dumper (requires wasmtime):

python3 tools/verify_reference.py \
  --font /path/to/font.ttf \
  --text "abc" \
  --size 14 \
  --ref-cmd /path/to/reference_dump_json

Matrix mode (repeatable --font, --text, --size):

python3 tools/verify_reference.py \
  --font /path/to/font-a.ttf \
  --font /path/to/font-b.ttf \
  --text "abc" \
  --text "Hello, world!" \
  --size 12 \
  --size 14 \
  --ref-cmd /path/to/reference_dump_json

Case-file mode (.json / .jsonl entries like {"font":"...","text":"...","size":14}):

python3 tools/verify_reference.py \
  --case-file /path/to/cases.jsonl \
  --ref-cmd /path/to/reference_dump_json

Notes:
  • The verifier uses a numeric tolerance (default --tol 0.02) because outline floats may differ slightly between MoonBit and Rust.
  • For emoji/math-heavy fonts, use --tol 0.05 to avoid small outline-bound jitter.
  • For strict schema checks, add --strict-keys (default mode allows extra MoonBit-only keys).

#Development

  • moon check - lint/type-check
  • moon test - run tests
  • moon fmt - format
  • moon info - regenerate .mbti interface files

Standard workflow before committing:

moon info && moon fmt
moon test
moon check

#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 {
  properties(Self) -> Properties
  opening_bracket(Self) -> Char?
  closing_bracket(Self) -> Char?
  mirror(Self) -> Char?
  bracket_type(Self) -> BracketType
  decompose(Self) -> Iter[Char]
  decompose_compatible(Self) -> Iter[Char]
}

impl Codepoint for Char

#
TableProvider

source
pub(open) trait TableProvider {
  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::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::new

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

#
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::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::new

source
fn CacheKey::new() -> 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::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::new

source

#
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::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::new

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

#
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::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::new

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

#
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::get

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

#
FontCache::new

source
fn[T] FontCache::new(max_entries : Int) -> FontCache[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::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

#
FontDataRef::new

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

#
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_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::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::new

source
fn Parser::new(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::mark

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

#
SeenFeatures::new

source

#
Setting

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

#
Setting::new

source
fn[T] Setting::new(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::end

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

#
SourceRange::new

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

#
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::condensed

source
fn Stretch::condensed() -> Stretch

#
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::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::from_degrees

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

#
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::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::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::new

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

#
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::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::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