Layout = ref object
  elements: seq[LayoutElement]

LytAlignDirection = enum
  lAlignLeft, lAlignRight, lAlignCenter

LytBlock = ref object
  layoutCache: Table[Option[LytSolution], Option[LytSolution]]
  isBreaking* {.requiresInit.}: bool ## Whether or not this block should end the line
  breakMult* {.requiresInit.}: int ## Local line break cost change
  id {.requiresInit.}: int
  case kind*: LytBlockKind
  of bkVerb:
      textLines*: seq[LytStrSpan] ## Multiple lines of text
      firstNl*: bool         ## Insert newline at the block start
    
  of bkText:
      text*: LytStrSpan      ## A single line of text, free of carriage
                             ## returs etc.
    
  of bkWrap:
      prefix*: Option[LytStr]
      sep*: LytStr           ## Separator for block wraps
      wrapElements*: seq[LytBlock]

  of bkStack, bkChoice, bkLine:
      elements*: seq[LytBlock]

  of bkEmpty:
      nil

  

LytBlockKind = enum
  bkText,                   ## A layout consisting of a single line of unbroken text.
  bkLine,                   ## Horizontally stacked lines
  bkChoice,                 ## Several alternating layouts
  bkStack,                  ## Vertically stacked layouts
  bkWrap,                   ## Mulitple blocks wrapped to create lowerst-cost layout
  bkVerb,                   ## Multiple lines verbatim
  bkEmpty                    ## Empty layout block - ignored by `add` etc.

LytEvent = object
  case kind*: LytEventKind
  of layEvStr:
      str*: LytStr

  of layEvSpaces:
      spaces*: int

  of layEvNewline:
      nil

  

LytEventKind = enum
  layEvStr, layEvNewline, layEvSpaces

LytOptions = object
  leftMargin*: int           ## position of the first right margin. Expected `0`
  rightMargin*: int          ## position of the second right margin. Set for `80`
                             ## to wrap on default column limit.
  leftMarginCost*: float     ## cost (per character) beyond margin 0.
                             ## Expected value `~0.05`
  rightMarginCost*: float    ## cost (per character) beyond margin 1. Should
                             ## be much higher than `c0`. Expected value
                             ## `~100`
  linebreakCost*: int        ## cost per line-break
  indentSpaces*: int         ## spaces per indent
  cpack*: float              ## cost (per element) for packing justified layouts.
                             ## Expected value `~0.001`
  formatPolicy*: LytFormatPolicy

LytStr = object
  id*: LytStrId              ## Id of the original piece of text
  len*: int ## It's lengh in units (units are specified - can be ASCII or
            ## unicode or anything else)
  

LytStrId = distinct uint64

LytStrIdMask {.inject.} = distinct uint64

LytStrSpan = object
  strs: seq[LytStr]
  len: int

OutConsole = object
  leftMargin: int
  rightMargin: int
  hPos: int                  ## Horizontal position on the output console
  margins: seq[int]

EmptyLytStr = (id: 0'u64, len: 0)

EmptyLytStrId = 0'u64

LytSpacesId = 9223372036854775687'u64

proc `$`(blc: LytBlock): string {....raises: [ValueError], tags: [].}

func `$`(id: LytStrId): string {....raises: [], tags: [].}

func `$`(le: LayoutElement): string {....raises: [ValueError], tags: [].}

proc `$`(sln: LytSolution): string {....raises: [ValueError, CatchableError],
                                     tags: [].}

proc `$`(sln: Option[LytSolution]): string {.
    ...raises: [ValueError, CatchableError], tags: [].}

func `==`(i1, i2: LytStrId): bool {....raises: [], tags: [].}

func `==`(m1`gensym3, m2`gensym3: LytStrIdMask): bool {.inject, ...raises: [],
    tags: [].}

func `[]`(blc: LytBlock; idx: int): LytBlock {....raises: [], tags: [].}

func `[]`(blc: var LytBlock; idx: int): var LytBlock {....raises: [], tags: [].}

proc add(target: var LytBlock; other: varargs[LytBlock]) {....raises: [], tags: [].}

proc alignLeft(span: sink LytStrSpan; target: int): LytStrSpan {....raises: [],
    tags: [].}

proc convertBlock(bk: LytBlock; newKind: LytBlockKind): LytBlock {....raises: [],
    tags: [].}

proc doOptLayout(self: var LytBlock; rest: var Option[LytSolution];
                 opts: LytOptions): Option[LytSolution] {.
    ...raises: [ValueError, CatchableError, Exception, KeyError],
    tags: [RootEffect].}

proc expectValid(bl: LytBlock; msg: string = "") {....raises: [], tags: [].}

func filterEmpty(blocks: openArray[LytBlock]): seq[LytBlock] {....raises: [],
    tags: [].}

func flatten(bl: LytBlock; kind: set[LytBlockKind]): LytBlock {....raises: [],
    tags: [].}

func getMask(id`gensym3: LytStrId): LytStrIdMask {.inject, ...raises: [], tags: [].}

proc initAlignedGrid(blocks: seq[seq[LytBlock]]; aligns: openArray[
    tuple[leftPad, rightPad: int, direction: LytAlignDirection]]): LytBlock {.
    ...raises: [], tags: [].}

proc initAlignedGrid(blocks: seq[seq[LytBlock]];
                     aligns: openArray[LytAlignDirection]): LytBlock {.
    ...raises: [], tags: [].}

proc initBlock(kind: LytBlockKind; breakMult: int = 1): LytBlock {....raises: [],
    tags: [].}

proc initChoiceBlock(elems: openArray[LytBlock]; breakMult: int = 1): LytBlock {.
    ...raises: [], tags: [].}

func initEmptyBlock(): LytBlock {....raises: [], tags: [].}

proc initHSeparated(blocks: seq[LytBlock]; sep: LytBlock): LytBlock {.
    ...raises: [], tags: [].}

proc initIndentBlock(blc: LytBlock; indent: int; breakMult: int = 1): LytBlock {.
    ...raises: [], tags: [].}

proc initLineBlock(elems: openArray[LytBlock]; breakMult: int = 1): LytBlock {.
    ...raises: [], tags: [].}

proc initLytOptions(): LytOptions {....raises: [], tags: [].}

proc initSeparated(blocks: seq[LytBlock]; vertical: bool; sep: LytBlock): LytBlock {.
    ...raises: [], tags: [].}

proc initStackBlock(elems: openArray[LytBlock]; breakMult: int = 1): LytBlock {.
    ...raises: [], tags: [].}

proc initTextBlock(text: LytStr; breakMult: int = 1; breaking: bool = false): LytBlock {.
    ...raises: [], tags: [].}

proc initTextBlock(text: LytStrSpan; breakMult: int = 1; breaking: bool = false): LytBlock {.
    ...raises: [], tags: [].}

proc initVerbBlock(textLines: openArray[LytStrSpan]; breaking: bool = true;
                   firstNl: bool = false; breakMult: int = 1): LytBlock {.
    ...raises: [], tags: [].}

proc initVSeparated(blocks: seq[LytBlock]; sep: LytBlock): LytBlock {.
    ...raises: [], tags: [].}

proc initWrapBlock(elems: openArray[LytBlock]; sep: LytStr; breakMult: int = 1): LytBlock {.
    ...raises: [], tags: [].}

func isEmpty(bl: LytBlock): bool {.inline, ...raises: [], tags: [].}

func isEmpty(s: LytStr): bool {....raises: [], tags: [].}

func isNil(i: LytStrId): bool {....raises: [], tags: [].}

func isSpaces(s: LytStr): bool {....raises: [], tags: [].}

proc join(blocks: LytBlock; sep: LytBlock; vertLines: bool = true): LytBlock {.
    ...raises: [], tags: [].}

proc join(blocks: seq[LytBlock]; sep: LytBlock; direction: LytBlockKind): LytBlock {.
    ...raises: [], tags: [].}

func len(blc: LytBlock): int {....raises: [], tags: [].}

proc lytSpaces(count: int = 1): LytStr {....raises: [], tags: [].}

func lytStrIdx(idx: int; len: int): LytStr {....raises: [], tags: [].}

func lytStrSpan(str: LytStr): LytStrSpan {....raises: [], tags: [].}

func lytStrSpan(strs: openArray[LytStr]): LytStrSpan {....raises: [], tags: [].}

func popMask(id`gensym3: LytStrId): LytStrId {.inject, ...raises: [], tags: [].}

func setMask(id`gensym3: var LytStrId; mask`gensym3: LytStrIdMask) {.inject,
    ...raises: [], tags: [].}

func toIndex(id: LytStrId): int {....raises: [], tags: [].}

proc toLayout(bl: LytBlock; opts: LytOptions): Layout {.
    ...raises: [ValueError, CatchableError, Exception, KeyError],
    tags: [RootEffect].}

proc toLayouts(bl: LytBlock; opts: LytOptions): seq[Layout] {.
    ...raises: [ValueError, CatchableError, Exception, KeyError],
    tags: [RootEffect].}

func toLytStrId(idx: int): LytStrId {....raises: [], tags: [].}

proc treeRepr(inBl: LytBlock; getStr: proc (str: LytStr): string = nil): string {.
    ...raises: [ValueError, Exception], tags: [RootEffect].}

func treeRepr(self: Layout; getStr: proc (s: LytStr): string = nil;
              level: int = 0): string {....raises: [ValueError, Exception],
                                        tags: [RootEffect].}

func treeRepr(self: LytSolution; getStr: proc (s: LytStr): string = nil;
              level: int = 0): string {....raises: [ValueError, Exception],
                                        tags: [RootEffect].}

iterator formatEvents(lyt: Layout): LytEvent {....raises: [], tags: [].}

iterator items(blc: LytBlock): LytBlock {....raises: [], tags: [].}

iterator mitems(blc: var LytBlock): var LytBlock {....raises: [], tags: [].}

iterator mpairs(blc: var LytBlock): (int, var LytBlock) {....raises: [], tags: [].}

iterator pairs(blc: LytBlock): (int, LytBlock) {....raises: [], tags: [].}

iterator rmpairs[T](s: var seq[T]): (int, var T)

iterator zip[T1, T2, T3, T4, T5](s1: seq[T1]; s2: seq[T2]; s3: seq[T3];
                                 s4: seq[T4]; s5: seq[T5]): tuple[v1: T1,
    v2: T2, v3: T3, v4: T4, v5: T5]

template addItBlock(res: LytBlock; item: typed; expr: untyped; join: LytBlock): untyped

template findSingle(elems: typed; targetKind: typed): untyped

template initBlockFormatDSL() {.dirty.}

template joinItBlock(direction: LytBlockKind; item: typed; expr: untyped;
                     join: LytBlock): untyped

template joinItLine(item: typed; expr: untyped; join: LytBlock): untyped