Arrangement = ref object
  lines*: seq[(int, int)]    ## The (start, stop) of the lines of text.
  spans*: seq[(int, int)]    ## The (start, stop) of the spans in the text.
  fonts*: seq[Font]          ## The font for each span.
  runes*: seq[Rune]          ## The runes of the text.
  positions*: seq[Vec2]      ## The positions of the glyphs for each rune.
  selectionRects*: seq[Rect] ## The selection rects for each glyph.
  

Font = ref object
  typeface*: Typeface
  size*: float32             ## Font size in pixels.
  lineHeight*: float32       ## The line height in pixels or autoLineHeight for the font's default line height.
  paints*: seq[Paint]
  textCase*: TextCase
  underline*: bool           ## Apply an underline.
  strikethrough*: bool       ## Apply a strikethrough.
  noKerningAdjustments*: bool ## Optionally disable kerning pair adjustments
  

HorizontalAlignment = enum
  LeftAlign, CenterAlign, RightAlign

Span = ref object
  text*: string
  font*: Font

TextCase = enum
  NormalCase, UpperCase, LowerCase, TitleCase

Typeface = ref object
  opentype: OpenType
  svgFont: SvgFont
  filePath*: string
  fallbacks*: seq[Typeface]

VerticalAlignment = enum
  TopAlign, MiddleAlign, BottomAlign

autoLineHeight: float32 = -1.0

proc ascent(typeface: Typeface): float32 {....raises: [], tags: [].}

proc computeBounds(arrangement: Arrangement; transform = mat3()): Rect {.
    ...raises: [PixieError], tags: [RootEffect].}

proc copy(font: Font): Font {....raises: [], tags: [].}

proc defaultLineHeight(font: Font): float32 {.inline, ...raises: [], tags: [].}

proc descent(typeface: Typeface): float32 {....raises: [], tags: [].}

proc fallbackTypeface(typeface: Typeface; rune: Rune): Typeface {....raises: [],
    tags: [].}

proc fillText(target: Image; arrangement: Arrangement; transform = mat3()) {.
    inline, ...raises: [PixieError], tags: [RootEffect].}

proc fillText(target: Image; font: Font; text: string; transform = mat3();
              bounds = vec2(0, 0); hAlign = LeftAlign; vAlign = TopAlign) {.
    inline, ...raises: [PixieError], tags: [RootEffect].}

proc getAdvance(typeface: Typeface; rune: Rune): float32 {.inline, ...raises: [],
    tags: [].}

proc getGlyphPath(typeface: Typeface; rune: Rune): Path {.inline,
    ...raises: [PixieError], tags: [RootEffect].}

proc getKerningAdjustment(typeface: Typeface; left, right: Rune): float32 {.
    inline, ...raises: [], tags: [].}

proc hasGlyph(typeface: Typeface; rune: Rune): bool {.inline, ...raises: [],
    tags: [].}

proc layoutBounds(arrangement: Arrangement): Vec2 {....raises: [], tags: [].}

proc layoutBounds(font: Font; text: string): Vec2 {.inline, ...raises: [], tags: [].}

proc layoutBounds(spans: seq[Span]): Vec2 {.inline, ...raises: [], tags: [].}

proc lineGap(typeface: Typeface): float32 {....raises: [], tags: [].}

proc lineHeight(typeface: Typeface): float32 {.inline, ...raises: [], tags: [].}

proc name(typeface: Typeface): string {....raises: [], tags: [].}

proc newFont(typeface: Typeface): Font {....raises: [], tags: [].}

proc newSpan(text: string; font: Font): Span {....raises: [], tags: [].}

proc paint(font: Font): Paint {.inline, ...raises: [], tags: [].}

proc paint=(font: Font; paint: Paint) {.inline, ...raises: [], tags: [].}

proc parseOtf(buf: string): Typeface {....raises: [PixieError], tags: [].}

proc parseSvgFont(buf: string): Typeface {....raises: [PixieError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect].}

proc parseTtf(buf: string): Typeface {....raises: [PixieError], tags: [].}

proc readFont(filePath: string): Font {....raises: [PixieError], tags: [
    ReadIOEffect, RootEffect, WriteIOEffect].}

proc readTypeface(filePath: string): Typeface {....raises: [PixieError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect].}

proc readTypefaces(filePath: string): seq[Typeface] {....raises: [PixieError],
    tags: [ReadIOEffect].}

proc scale(font: Font): float32 {.inline, ...raises: [], tags: [].}

proc scale(typeface: Typeface): float32 {.inline, ...raises: [], tags: [].}

proc strokeText(target: Image; arrangement: Arrangement; transform = mat3();
                strokeWidth: float32 = 1.0; lineCap = ButtCap;
                lineJoin = MiterJoin; miterLimit = defaultMiterLimit;
                dashes: seq[float32] = @[]) {.inline, ...raises: [PixieError],
    tags: [RootEffect].}

proc strokeText(target: Image; font: Font; text: string; transform = mat3();
                strokeWidth: float32 = 1.0; bounds = vec2(0, 0);
                hAlign = LeftAlign; vAlign = TopAlign; lineCap = ButtCap;
                lineJoin = MiterJoin; miterLimit = defaultMiterLimit;
                dashes: seq[float32] = @[]) {.inline, ...raises: [PixieError],
    tags: [RootEffect].}

proc typeset(font: Font; text: string; bounds = vec2(0, 0); hAlign = LeftAlign;
             vAlign = TopAlign; wrap = true): Arrangement {.inline, ...raises: [],
    tags: [].}

proc typeset(spans: seq[Span]; bounds = vec2(0, 0); hAlign = LeftAlign;
             vAlign = TopAlign; wrap = true): Arrangement {....raises: [], tags: [].}