HTMLParsers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object NoSuccess

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

val any: TextParser

Consumes any kind of input, always succeeds.

def anyBut(chars: Char*): TextParser

Consumes any number of consecutive characters that are not one of the specified characters.

def anyIn(ranges: Traversable[Char]*): TextParser

Consumes any number of consecutive characters that are in one of the specified character ranges.

def anyOf(chars: Char*): TextParser

Consumes any number of consecutive occurrences of the specified characters.

def anyUntil(until: ⇒ Parser[Any]): TextParser

Consumes any number of characters for which the specified parser fails on the corresponding offset.

def anyUntil(chars: Char*): TextParser

Consumes any number of consecutive characters that are not one of the specified characters.

def anyWhile(p: (Char) ⇒ Boolean): TextParser

Consumes any number of consecutive characters which satisfy the specified predicate.

final def asInstanceOf[T0]: T0

val atStart: Parser[Parser[Unit]]

Succeeds at the start of the input.

lazy val atxHeader: Parser[Header]

Parses an ATX header, a line that starts with 1 to 6 '#' characters, with the number of hash characters corresponding to the level of the header.

val blankLine: Parser[String]

Parses a blank line from the current input offset (which may not be at the start of the line).

val blankLines: Parser[List[String]]

Parses one or more blanklines, producing a list of empty strings corresponding to the number of blank lines consumed.

def block(firstLinePrefix: Parser[Any], linePrefix: ⇒ Parser[Any], nextBlockPrefix: ⇒ Parser[Any]): Parser[List[String]]

Parses a full block based on the specified helper parsers.

def blockList(p: ⇒ Parser[Block]): Parser[List[Block]]

Builds a parser for a list of blocks based on the parser for a single block.

def bulletList: Parser[BulletList]

Parses a bullet list, called "unordered list" in the Markdown syntax description.

val bulletListItemStart: Parser[String]

Parses the start of a bullet list item.

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

implicit def charToTraversalble(char: Char): Traversable[Char]

Implicit conversion that allows to pass a single character to the range-based anyIn parser.

def clone(): AnyRef

def commit[T](p: ⇒ Parser[T]): Parser[T]

def config(path: Path): Parser[Either[InvalidBlock, Config]]

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

def em(char: Char): Parser[Emphasized]

Parses a span of emphasized text enclosed by one occurrence of the specified character.

def enclosedByDoubleChar(char: Char): Parser[List[Span]]

Parses a span enclosed by two consecutive occurrences of the specified character.

def enclosedBySingleChar(char: Char): Parser[List[Span]]

Parses a span enclosed by a single occurrence of the specified character.

def enumList: Parser[EnumList]

Parses an enumerated list, called "ordered list" in the Markdown syntax description.

val enumListItemStart: Parser[String]

Parses the start of an enumerated list item.

def eof: Parser[String]

Succeeds at the end of the input.

def eol: Parser[String]

Succeeds at the end of a line, including the end of the input.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

def escapedChar: TextParser

Parses a single escaped character, only recognizing the characters the Markdown syntax document specifies as escapable.

def escapedUntil(char: Char): Parser[String]

Parses a span of text until the specified character is seen, while also processing escaped characters, but no other nested spans.

def failure(msg: String): Parser[Nothing]

def finalize(): Unit

final def getClass(): Class[_]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

val htmlAttribute: Parser[HTMLAttribute]

Parses a single attribute, consisting of the name and (optional) equals sign and value.

val htmlAttributeName: TextParser

val htmlAttributeValue: Parser[(List[Span with TextContainer], Option[Char])]

Parses quoted and unquoted attribute values.

def htmlBlock: Parser[HTMLBlock]

Parses a full HTML block, with the root element being a block-level HTML element and without parsing any standard Markdown markup.

val htmlBlockElements: Set[String]

Elements that the HTML specification does not define as "Phrasing Content".

def htmlBlockStart: Parser[HTMLStartTag]

Parses the start tag of an HTML block, only matches when the tag name is an actual block-level HTML tag.

def htmlCharReference: Parser[HTMLCharacterReference]

Parses a numeric or named character reference without the leading '&'.

val htmlComment: Parser[HTMLComment]

Parses an HTML comment without the leading '<'.

def htmlDecReference: TextParser

def htmlElement(nested: Map[Char, Parser[Span]]): Parser[HTMLElement]

Parses an HTML element without the leading '<', but including all the nested HTML and Text elements.

val htmlEmptyElement: Parser[HTMLEmptyElement]

Parses an empty HTML element without the leading '<'.

def htmlEndTag(tagName: String): Parser[String]

Parses an HTML end tag if it matches the specified tag name.

val htmlEndTag: Parser[HTMLEndTag]

Parses an HTML end tag without the leading '<'.

def htmlHexReference: Parser[String]

def htmlNamedReference: TextParser

def htmlNumericReference: Parser[String]

Parses a numeric character reference (decimal or hexadecimal) without the leading '&'.

lazy val htmlParsers: Map[Char, Parser[Span]]

The mapping of start characters to their corresponding HTML span parsers.

def htmlQuotedAttributeValue(char: Char): Parser[(List[Span with TextContainer], Some[Char])]

Parses an attribute value enclosed by the specified character.

lazy val htmlSpan: Parser[HTMLSpan]

Parses any of the HTML span elements supported by this trait, but no standard markdown inside HTML elements.

lazy val htmlSpanWithNestedMarkdown: Parser[HTMLSpan]

Parses any of the HTML span elements supported by this trait, plus standard markdown inside HTML elements.

val htmlStartTag: Parser[HTMLStartTag]

Parses an HTML start tag without the leading '<'.

val htmlTagContent: Parser[~[String, List[HTMLAttribute]]]

Parses an HTML tag without the enclosing '<' and '>' characters.

val htmlTagName: Parser[String]

val htmlUnquotedAttributeValue: Parser[(List[Span with TextContainer], None.type)]

val htmlWS: TextParser

Parses and consumes optional whitespace, always succeeds.

def image: Parser[Span]

Parses an inline image.

def indentedBlock(minIndent: Int = 1, linePredicate: ⇒ Parser[Any] = success(), endsOnBlankLine: Boolean = false, firstLineIndented: Boolean = false, maxIndent: Int = Int.MaxValue): Parser[IndentedBlock]

Parses a full block based on the specified helper parsers, expecting an indentation for all lines except the first.

def inline[Elem, To](text: ⇒ TextParser, nested: ⇒ Map[Char, Parser[Elem]], resultBuilder: ⇒ ResultBuilder[Elem, To]): Parser[To]

Generic base parser that parses inline elements based on the specified helper parsers.

val insignificantSpaces: Parser[String]

Parses up to 3 space characters.

final def isInstanceOf[T0]: Boolean

def lineBreak: Parser[LineBreak]

Parses an explicit hard line break.

def linesToString(lines: List[String]): String

Merges the specified list of lines into a single string, while looking for lines ending with double spaces which stand for a hard line break in Markdown.

def link: Parser[Span]

Parses a link, including nested spans in the link text.

def linkTarget: Parser[ExternalLinkDefinition]

Parses a link definition in the form [id]: <url> "title".

def list[T <: Block, I <: ListItem](itemStart: Parser[String], newList: (List[ListItem]) ⇒ T, newItem: (Int, List[Block]) ⇒ I): Parser[T]

Parses a list based on the specified helper parsers.

def listItem[I <: ListItem](itemStart: Parser[String]): Parser[List[Block]]

Parses a single list item.

implicit def literal(s: String): Parser[String]

val literalBlock: Parser[LiteralBlock]

Parses a literal block, text indented by a tab or 4 spaces.

def literalEnclosedByDoubleChar: Parser[Literal]

Parses a literal span enclosed by double backticks.

def literalEnclosedBySingleChar: Parser[Literal]

Parses a literal span enclosed by a single backtick.

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def lookBehind[T](offset: Int, parser: ⇒ Parser[T]): Parser[T]

Applies the specified parser at the specified offset behind the current position.

val maxNestLevel: Int

The maximum level of block nesting.

def mdBlock(firstLinePrefix: Parser[Any], linePrefix: Parser[Any], nextBlockPrefix: Parser[Any]): Parser[List[String]]

Parses a single Markdown block.

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

final def ne(arg0: AnyRef): Boolean

def nestLevel(reader: Input): Int

Returns the current nest level from the specified input or 0 if it cannot be determined.

final lazy val nestedBlock: Parser[Block]

Parses any kind of nested block supported by a concrete markup language.

def nestedParagraph: Parser[Block]

Parses a single paragraph nested inside another block.

def nonRecursiveBlock: Parser[Block]

Parses reStructuredText blocks, except for blocks that allow nesting of blocks.

def not[T](p: ⇒ Parser[T]): Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

val optSpace: Parser[String]

Parses 0 or 1 space character, always succeeds.

def optimizedCharLookup(chars: Char*): (Char) ⇒ Boolean

Returns an optimized, Array-based lookup function for the specified characters.

def optimizedRangeLookup(ranges: Traversable[Char]*): (Char) ⇒ Boolean

Returns an optimized, Array-based lookup function for the specified ranges of characters.

def paragraph: Parser[Paragraph]

Parses a single paragraph.

def parse[T](p: Parser[T], in: Reader): ParseResult[T]

def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseConfigAndRoot(reader: Reader[Char], path: Path): (Config, RootElement)

Fully parses the input from the specified reader and returns the configuration and root element.

def parseDocument(reader: Reader[Char], path: Path): Document

Fully parses the input from the specified reader and returns the document tree.

def parseInline(source: String): List[Span]

Fully parses the input string and produces a list of spans, using the default span parsers returned by the spanParsers method.

def parseInline(source: String, spanParsers: Map[Char, Parser[Span]]): List[Span]

Fully parses the input string and produces a list of spans.

def parseMarkup[T](parser: Parser[T], reader: Reader[Char]): T

Fully parses the input from the specified reader and returns the result.

def parseMarkup[T](parser: Parser[T], source: String): T

Fully parses the specified input string and returns the result.

def parseNestedBlocks(block: IndentedBlock): List[Block]

Parses all nested blocks inside the specified indented block.

def parseNestedBlocks(input: String, nestLevel: Int): List[Block]

Parses all nested blocks for the specified input and nest level.

def parseNestedBlocks(lines: List[String], nestLevel: Int): List[Block]

Parses all nested blocks for the specified input and nest level.

def parseParagraph(lines: List[String]): Paragraph

def phrase[T](p: Parser[T]): Parser[T]

def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

def prepareBlockParsers(nested: Boolean): List[Parser[Block]]

Extension hook for assembling the block parsers for a particular markup format.

def prepareSpanParsers: Map[Char, Parser[Span]]

Creates a new mapping from the start character of an inline span to the corresponding parser.

def quotedBlock: Parser[QuotedBlock]

Parses a quoted block, a paragraph starting with a '>' character, with subsequent lines optionally starting with a '>', too.

implicit def regex(r: Regex): Parser[String]

def rep[T](first: ⇒ Parser[T], next: (T) ⇒ Parser[T]): Parser[List[T]]

A parser generator for repetitions where all subsequent parsers after the first depend on the result of the previous.

def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def repMax[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Uses the parser for at most the specified number of repetitions, always succeeds.

def repMin[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Uses the parser for at least the specified number of repetitions or otherwise fails.

def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def resource(inline: (String, String, Option[String]) ⇒ Span, ref: (String, String, String) ⇒ Span): Parser[Span]

Helper function that abstracts the common parser logic of links and images.

def restOfLine: Parser[String]

Parses the rest of the line from the current input offset no matter whether it consist of whitespace only or some text.

def root: Parser[RootElement]

Parses a full document, delegating most of the work to the topLevelBlock parser.

lazy val rule: Parser[Block]

Parses a horizontal rule, a line only decorated with three or more '*', '-' or '_' characters with optional spaces between them

lazy val setextHeader: Parser[Header]

Parses a 1st or 2nd level Setext header.

def simpleLink: Parser[ExternalLink]

Parses a simple inline link in the form of <http://someURL/>

def skipWhitespace: Boolean

def span(start: Parser[Any], end: Parser[Any]): Parser[List[Span]]

Creates a parser for an inline span based on the specified parsers that represent the start and end condition.

final lazy val spanParsers: Map[Char, Parser[Span]]

The mapping of markup start characters to their corresponding span parsers.

def spans(parser: ⇒ TextParser, spanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

Parses a list of spans based on the specified helper parsers.

def standardMarkdownBlock: Parser[Block]

Parses all of the standard Markdown blocks, except normal paragraphs and those blocks that deal with verbatim HTML.

def strong(char: Char): Parser[Strong]

Parses a span of strong text enclosed by two consecutive occurrences of the specified character.

def success[T](v: T): Parser[T]

final def synchronized[T0](arg0: ⇒ T0): T0

val tabOrSpace: Parser[Any]

Parses a single tab or space character.

def text(parser: ⇒ TextParser, nested: ⇒ Map[Char, Parser[String]]): Parser[String]

Parses text based on the specified helper parsers.

val textLine: Parser[String]

Parses a single text line from the current input offset (which may not be at the start of the line.

implicit def toParserOps[A](parser: Parser[A]): ParserOps[A]

def toString(): String

final lazy val topLevelBlock: Parser[Block]

Parses any kind of top-level block supported by a concrete markup language.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val whiteSpace: Regex

def withNestLevel[T](p: ⇒ Parser[T]): Parser[(Int, T)]

Creates a new parser that produces a tuple containing the current nest level as well as the result from the specified parser.

def ws: TextParser

Parses horizontal whitespace (space and tab).

def lastNoSuccess: NoSuccess

def lastNoSuccess_=(x: NoSuccess): Unit