Parser

Constructor

Serializer

Returns the properties that need to persist through serialization.

NOTE: using __sleep() is preferable to implementing Serializable because it leaves the choice of the serializer to the user (e.g. igbinary)

Unserializer

Reset the parser for a new parsing

Set a tag's option

This method ensures that the tag's config is a value and not a reference, to prevent potential side-effects. References contained inside the tag's config are left untouched

Disable a tag

Enable a tag

Get this parser's Logger instance

Return the last text parsed

This method returns the normalized text, which may be slightly different from the original text in that EOLs are normalized to LF and other control codes are stripped. This method is meant to be used in support of processing log entries, which contain offsets based on the normalized text

Parse a text

Change a tag's tagLimit

NOTE: the default tagLimit should generally be set during configuration instead

Change a tag's nestingLimit

NOTE: the default nestingLimit should generally be set during configuration instead

Finalize the output by appending the rest of the unprocessed text and create the root node

Append a tag to the output

Output the text between the cursor's position (included) and given position (not included)

Output a linebreak tag

Output an ignore tag

Start a paragraph between current position and given position, if applicable

Close current paragraph at current position if applicable

Output the content of a verbatim tag

Skip as much whitespace after current position as possible

Disable a plugin

Enable a plugin

Execute given plugin

Execute all the plugins

Execute given regexp and returns as many matches as given limit

Get the cached callback for given plugin's parser

Register a parser

Can be used to add a new parser with no plugin config, or pre-generate a parser for an existing plugin

Apply closeAncestor rules associated with given tag

Apply closeParent rules associated with given tag

Apply the createChild rules associated with given tag

Apply fosterParent rules associated with given tag

NOTE: this rule has the potential for creating an unbounded loop, either if a tag tries to foster itself or two or more tags try to foster each other in a loop. We mitigate the risk by preventing a tag from creating a child of itself (the parent still gets closed) and by checking and increasing the currentFixingCost so that a loop of multiple tags do not run indefinitely. The default tagLimit and nestingLimit also serve to prevent the loop from running indefinitely

Apply requireAncestor rules associated with given tag

Create and add a copy of a tag as a child of a given tag

Create and add an end tag for given start tag at given position

Compute the position of a magic end tag, adjusted for whitespace

Compute the position and priority of a magic start tag, adjusted for whitespace

Test whether given start tag is immediately followed by a closing tag

Process all tags in the stack

Process current tag

Process given start tag (including self-closing tags) at current position

Process given end tag at current position

Update counters and replace current context with its parent context

Update counters and replace current context with a new context based on given tag

If given tag is a self-closing tag, the context won't change

Return whether given tag is allowed in current context

Add a start tag

Add an end tag

Add a self-closing tag

Add a 0-width "br" tag to force a line break at given position

Add an "ignore" tag

Add a paragraph break at given position

Uses a zero-width tag that is actually never output in the result

Add a copy of given tag at given position and length

Add a tag

Test whether given text span is outside text boundaries or an invalid UTF sequence

Insert given tag in the tag stack

Add a pair of tags

Add a tag that represents a verbatim copy of the original text

Sort tags by position and precedence

Generate a key for given tag that can be used to compare its position using lexical comparisons

Tags are sorted by position first, then by priority, then by whether they consume any text, then by length, and finally in order of their creation.

The stack's array is in reverse order. Therefore, tags that appear at the start of the text are at the end of the array.