two`.
* - HTML with unexpected tag closers, e.g. `
Closed by `.
* - Elements containing text that looks like other tags but isn't, e.g. `The <img> is plaintext `.
* - SCRIPT and STYLE tags containing text that looks like HTML but isn't, e.g. ``.
* - SCRIPT content which has been escaped, e.g. ``.
*
* ### Unsupported Features
*
* This parser does not report parse errors.
*
* Normally, when additional HTML or BODY tags are encountered in a document, if there
* are any additional attributes on them that aren't found on the previous elements,
* the existing HTML and BODY elements adopt those missing attribute values. This
* parser does not add those additional attributes.
*
* In certain situations, elements are moved to a different part of the document in
* a process called "adoption" and "fostering." Because the nodes move to a location
* in the document that the parser had already processed, this parser does not support
* these situations and will bail.
*
* @since 6.4.0
*
* @see WP_HTML_Tag_Processor
* @see https://html.spec.whatwg.org/
*/
class WP_HTML_Processor extends WP_HTML_Tag_Processor {
/**
* The maximum number of bookmarks allowed to exist at any given time.
*
* HTML processing requires more bookmarks than basic tag processing,
* so this class constant from the Tag Processor is overwritten.
*
* @since 6.4.0
*
* @var int
*/
const MAX_BOOKMARKS = 100;
/**
* Holds the working state of the parser, including the stack of
* open elements and the stack of active formatting elements.
*
* Initialized in the constructor.
*
* @since 6.4.0
*
* @var WP_HTML_Processor_State
*/
private $state;
/**
* Used to create unique bookmark names.
*
* This class sets a bookmark for every tag in the HTML document that it encounters.
* The bookmark name is auto-generated and increments, starting with `1`. These are
* internal bookmarks and are automatically released when the referring WP_HTML_Token
* goes out of scope and is garbage-collected.
*
* @since 6.4.0
*
* @see WP_HTML_Processor::$release_internal_bookmark_on_destruct
*
* @var int
*/
private $bookmark_counter = 0;
/**
* Stores an explanation for why something failed, if it did.
*
* @see self::get_last_error
*
* @since 6.4.0
*
* @var string|null
*/
private $last_error = null;
/**
* Stores context for why the parser bailed on unsupported HTML, if it did.
*
* @see self::get_unsupported_exception
*
* @since 6.7.0
*
* @var WP_HTML_Unsupported_Exception|null
*/
private $unsupported_exception = null;
/**
* Releases a bookmark when PHP garbage-collects its wrapping WP_HTML_Token instance.
*
* This function is created inside the class constructor so that it can be passed to
* the stack of open elements and the stack of active formatting elements without
* exposing it as a public method on the class.
*
* @since 6.4.0
*
* @var Closure|null
*/
private $release_internal_bookmark_on_destruct = null;
/**
* Stores stack events which arise during parsing of the
* HTML document, which will then supply the "match" events.
*
* @since 6.6.0
*
* @var WP_HTML_Stack_Event[]
*/
private $element_queue = array();
/**
* Stores the current breadcrumbs.
*
* @since 6.7.0
*
* @var string[]
*/
private $breadcrumbs = array();
/**
* Current stack event, if set, representing a matched token.
*
* Because the parser may internally point to a place further along in a document
* than the nodes which have already been processed (some "virtual" nodes may have
* appeared while scanning the HTML document), this will point at the "current" node
* being processed. It comes from the front of the element queue.
*
* @since 6.6.0
*
* @var WP_HTML_Stack_Event|null
*/
private $current_element = null;
/**
* Context node if created as a fragment parser.
*
* @var WP_HTML_Token|null
*/
private $context_node = null;
/*
* Public Interface Functions
*/
/**
* Creates an HTML processor in the fragment parsing mode.
*
* Use this for cases where you are processing chunks of HTML that
* will be found within a bigger HTML document, such as rendered
* block output that exists within a post, `the_content` inside a
* rendered site layout.
*
* Fragment parsing occurs within a context, which is an HTML element
* that the document will eventually be placed in. It becomes important
* when special elements have different rules than others, such as inside
* a TEXTAREA or a TITLE tag where things that look like tags are text,
* or inside a SCRIPT tag where things that look like HTML syntax are JS.
*
* The context value should be a representation of the tag into which the
* HTML is found. For most cases this will be the body element. The HTML
* form is provided because a context element may have attributes that
* impact the parse, such as with a SCRIPT tag and its `type` attribute.
*
* ## Current HTML Support
*
* - The only supported context is ``, which is the default value.
* - The only supported document encoding is `UTF-8`, which is the default value.
*
* @since 6.4.0
* @since 6.6.0 Returns `static` instead of `self` so it can create subclass instances.
*
* @param string $html Input HTML fragment to process.
* @param string $context Context element for the fragment, must be default of ``.
* @param string $encoding Text encoding of the document; must be default of 'UTF-8'.
* @return static|null The created processor if successful, otherwise null.
*/
public static function create_fragment( $html, $context = '', $encoding = 'UTF-8' ) {
if ( '' !== $context || 'UTF-8' !== $encoding ) {
return null;
}
if ( ! is_string( $html ) ) {
_doing_it_wrong(
__METHOD__,
__( 'The HTML parameter must be a string.' ),
'6.9.0'
);
return null;
}
$context_processor = static::create_full_parser( "{$context}", $encoding );
if ( null === $context_processor ) {
return null;
}
while ( $context_processor->next_tag() ) {
if ( ! $context_processor->is_virtual() ) {
$context_processor->set_bookmark( 'final_node' );
}
}
if (
! $context_processor->has_bookmark( 'final_node' ) ||
! $context_processor->seek( 'final_node' )
) {
_doing_it_wrong( __METHOD__, __( 'No valid context element was detected.' ), '6.8.0' );
return null;
}
return $context_processor->create_fragment_at_current_node( $html );
}
/**
* Creates an HTML processor in the full parsing mode.
*
* It's likely that a fragment parser is more appropriate, unless sending an
* entire HTML document from start to finish. Consider a fragment parser with
* a context node of ``.
*
* UTF-8 is the only allowed encoding. If working with a document that
* isn't UTF-8, first convert the document to UTF-8, then pass in the
* converted HTML.
*
* @param string $html Input HTML document to process.
* @param string|null $known_definite_encoding Optional. If provided, specifies the charset used
* in the input byte stream. Currently must be UTF-8.
* @return static|null The created processor if successful, otherwise null.
*/
public static function create_full_parser( $html, $known_definite_encoding = 'UTF-8' ) {
if ( 'UTF-8' !== $known_definite_encoding ) {
return null;
}
if ( ! is_string( $html ) ) {
_doing_it_wrong(
__METHOD__,
__( 'The HTML parameter must be a string.' ),
'6.9.0'
);
return null;
}
$processor = new static( $html, self::CONSTRUCTOR_UNLOCK_CODE );
$processor->state->encoding = $known_definite_encoding;
$processor->state->encoding_confidence = 'certain';
return $processor;
}
/**
* Constructor.
*
* Do not use this method. Use the static creator methods instead.
*
* @access private
*
* @since 6.4.0
*
* @see WP_HTML_Processor::create_fragment()
*
* @param string $html HTML to process.
* @param string|null $use_the_static_create_methods_instead This constructor should not be called manually.
*/
public function __construct( $html, $use_the_static_create_methods_instead = null ) {
parent::__construct( $html );
if ( self::CONSTRUCTOR_UNLOCK_CODE !== $use_the_static_create_methods_instead ) {
_doing_it_wrong(
__METHOD__,
sprintf(
/* translators: %s: WP_HTML_Processor::create_fragment(). */
__( 'Call %s to create an HTML Processor instead of calling the constructor directly.' ),
'WP_HTML_Processor::create_fragment()'
),
'6.4.0'
);
}
$this->state = new WP_HTML_Processor_State();
$this->state->stack_of_open_elements->set_push_handler(
function ( WP_HTML_Token $token ): void {
$is_virtual = ! isset( $this->state->current_token ) || $this->is_tag_closer();
$same_node = isset( $this->state->current_token ) && $token->node_name === $this->state->current_token->node_name;
$provenance = ( ! $same_node || $is_virtual ) ? 'virtual' : 'real';
$this->element_queue[] = new WP_HTML_Stack_Event( $token, WP_HTML_Stack_Event::PUSH, $provenance );
$this->change_parsing_namespace( $token->integration_node_type ? 'html' : $token->namespace );
}
);
$this->state->stack_of_open_elements->set_pop_handler(
function ( WP_HTML_Token $token ): void {
$is_virtual = ! isset( $this->state->current_token ) || ! $this->is_tag_closer();
$same_node = isset( $this->state->current_token ) && $token->node_name === $this->state->current_token->node_name;
$provenance = ( ! $same_node || $is_virtual ) ? 'virtual' : 'real';
$this->element_queue[] = new WP_HTML_Stack_Event( $token, WP_HTML_Stack_Event::POP, $provenance );
$adjusted_current_node = $this->get_adjusted_current_node();
if ( $adjusted_current_node ) {
$this->change_parsing_namespace( $adjusted_current_node->integration_node_type ? 'html' : $adjusted_current_node->namespace );
} else {
$this->change_parsing_namespace( 'html' );
}
}
);
/*
* Create this wrapper so that it's possible to pass
* a private method into WP_HTML_Token classes without
* exposing it to any public API.
*/
$this->release_internal_bookmark_on_destruct = function ( string $name ): void {
parent::release_bookmark( $name );
};
}
/**
* Creates a fragment processor at the current node.
*
* HTML Fragment parsing always happens with a context node. HTML Fragment Processors can be
* instantiated with a `BODY` context node via `WP_HTML_Processor::create_fragment( $html )`.
*
* The context node may impact how a fragment of HTML is parsed. For example, consider the HTML
* fragment `` tags are completely ignored.
*
* Compare that with an SVG context node that produces the following tree:
*
* ├─svg:td
* └─#text Inside TD?
*
* Here, a `td` node in the `svg` namespace is created, and its self-closing flag is respected.
* This is a peculiarity of parsing HTML in foreign content like SVG.
*
* Finally, consider the tree produced with a TABLE context node:
*
* └─TBODY
* └─TR
* └─TD
* └─#text Inside TD?
*
* These examples demonstrate how important the context node may be when processing an HTML
* fragment. Special care must be taken when processing fragments that are expected to appear
* in specific contexts. SVG and TABLE are good examples, but there are others.
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#html-fragment-parsing-algorithm
*
* @since 6.8.0
*
* @param string $html Input HTML fragment to process.
* @return static|null The created processor if successful, otherwise null.
*/
private function create_fragment_at_current_node( string $html ) {
if ( $this->get_token_type() !== '#tag' || $this->is_tag_closer() ) {
_doing_it_wrong(
__METHOD__,
__( 'The context element must be a start tag.' ),
'6.8.0'
);
return null;
}
$tag_name = $this->current_element->token->node_name;
$namespace = $this->current_element->token->namespace;
if ( 'html' === $namespace && self::is_void( $tag_name ) ) {
_doing_it_wrong(
__METHOD__,
sprintf(
// translators: %s: A tag name like INPUT or BR.
__( 'The context element cannot be a void element, found "%s".' ),
$tag_name
),
'6.8.0'
);
return null;
}
/*
* Prevent creating fragments at nodes that require a special tokenizer state.
* This is unsupported by the HTML Processor.
*/
if (
'html' === $namespace &&
in_array( $tag_name, array( 'IFRAME', 'NOEMBED', 'NOFRAMES', 'SCRIPT', 'STYLE', 'TEXTAREA', 'TITLE', 'XMP', 'PLAINTEXT' ), true )
) {
_doing_it_wrong(
__METHOD__,
sprintf(
// translators: %s: A tag name like IFRAME or TEXTAREA.
__( 'The context element "%s" is not supported.' ),
$tag_name
),
'6.8.0'
);
return null;
}
$fragment_processor = new static( $html, self::CONSTRUCTOR_UNLOCK_CODE );
$fragment_processor->compat_mode = $this->compat_mode;
// @todo Create "fake" bookmarks for non-existent but implied nodes.
$fragment_processor->bookmarks['root-node'] = new WP_HTML_Span( 0, 0 );
$root_node = new WP_HTML_Token(
'root-node',
'HTML',
false
);
$fragment_processor->state->stack_of_open_elements->push( $root_node );
$fragment_processor->bookmarks['context-node'] = new WP_HTML_Span( 0, 0 );
$fragment_processor->context_node = clone $this->current_element->token;
$fragment_processor->context_node->bookmark_name = 'context-node';
$fragment_processor->context_node->on_destroy = null;
$fragment_processor->breadcrumbs = array( 'HTML', $fragment_processor->context_node->node_name );
if ( 'TEMPLATE' === $fragment_processor->context_node->node_name ) {
$fragment_processor->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
}
$fragment_processor->reset_insertion_mode_appropriately();
/*
* > Set the parser's form element pointer to the nearest node to the context element that
* > is a form element (going straight up the ancestor chain, and including the element
* > itself, if it is a form element), if any. (If there is no such form element, the
* > form element pointer keeps its initial value, null.)
*/
foreach ( $this->state->stack_of_open_elements->walk_up() as $element ) {
if ( 'FORM' === $element->node_name && 'html' === $element->namespace ) {
$fragment_processor->state->form_element = clone $element;
$fragment_processor->state->form_element->bookmark_name = null;
$fragment_processor->state->form_element->on_destroy = null;
break;
}
}
$fragment_processor->state->encoding_confidence = 'irrelevant';
/*
* Update the parsing namespace near the end of the process.
* This is important so that any push/pop from the stack of open
* elements does not change the parsing namespace.
*/
$fragment_processor->change_parsing_namespace(
$this->current_element->token->integration_node_type ? 'html' : $namespace
);
return $fragment_processor;
}
/**
* Stops the parser and terminates its execution when encountering unsupported markup.
*
* @throws WP_HTML_Unsupported_Exception Halts execution of the parser.
*
* @since 6.7.0
*
* @param string $message Explains support is missing in order to parse the current node.
*/
private function bail( string $message ) {
$here = $this->bookmarks[ $this->state->current_token->bookmark_name ];
$token = substr( $this->html, $here->start, $here->length );
$open_elements = array();
foreach ( $this->state->stack_of_open_elements->stack as $item ) {
$open_elements[] = $item->node_name;
}
$active_formats = array();
foreach ( $this->state->active_formatting_elements->walk_down() as $item ) {
$active_formats[] = $item->node_name;
}
$this->last_error = self::ERROR_UNSUPPORTED;
$this->unsupported_exception = new WP_HTML_Unsupported_Exception(
$message,
$this->state->current_token->node_name,
$here->start,
$token,
$open_elements,
$active_formats
);
throw $this->unsupported_exception;
}
/**
* Returns the last error, if any.
*
* Various situations lead to parsing failure but this class will
* return `false` in all those cases. To determine why something
* failed it's possible to request the last error. This can be
* helpful to know to distinguish whether a given tag couldn't
* be found or if content in the document caused the processor
* to give up and abort processing.
*
* Example
*
* $processor = WP_HTML_Processor::create_fragment( '' );
* false === $processor->next_tag();
* WP_HTML_Processor::ERROR_UNSUPPORTED === $processor->get_last_error();
*
* @since 6.4.0
*
* @see self::ERROR_UNSUPPORTED
* @see self::ERROR_EXCEEDED_MAX_BOOKMARKS
*
* @return string|null The last error, if one exists, otherwise null.
*/
public function get_last_error(): ?string {
return $this->last_error;
}
/**
* Returns context for why the parser aborted due to unsupported HTML, if it did.
*
* This is meant for debugging purposes, not for production use.
*
* @since 6.7.0
*
* @see self::$unsupported_exception
*
* @return WP_HTML_Unsupported_Exception|null
*/
public function get_unsupported_exception() {
return $this->unsupported_exception;
}
/**
* Finds the next tag matching the $query.
*
* @todo Support matching the class name and tag name.
*
* @since 6.4.0
* @since 6.6.0 Visits all tokens, including virtual ones.
*
* @throws Exception When unable to allocate a bookmark for the next token in the input HTML document.
*
* @param array|string|null $query {
* Optional. Which tag name to find, having which class, etc. Default is to find any tag.
*
* @type string|null $tag_name Which tag to find, or `null` for "any tag."
* @type string $tag_closers 'visit' to pause at tag closers, 'skip' or unset to only visit openers.
* @type int|null $match_offset Find the Nth tag matching all search criteria.
* 1 for "first" tag, 3 for "third," etc.
* Defaults to first tag.
* @type string|null $class_name Tag must contain this whole class name to match.
* @type string[] $breadcrumbs DOM sub-path at which element is found, e.g. `array( 'FIGURE', 'IMG' )`.
* May also contain the wildcard `*` which matches a single element, e.g. `array( 'SECTION', '*' )`.
* }
* @return bool Whether a tag was matched.
*/
public function next_tag( $query = null ): bool {
$visit_closers = isset( $query['tag_closers'] ) && 'visit' === $query['tag_closers'];
if ( null === $query ) {
while ( $this->next_token() ) {
if ( '#tag' !== $this->get_token_type() ) {
continue;
}
if ( ! $this->is_tag_closer() || $visit_closers ) {
return true;
}
}
return false;
}
if ( is_string( $query ) ) {
$query = array( 'breadcrumbs' => array( $query ) );
}
if ( ! is_array( $query ) ) {
_doing_it_wrong(
__METHOD__,
__( 'Please pass a query array to this function.' ),
'6.4.0'
);
return false;
}
if ( isset( $query['tag_name'] ) ) {
$query['tag_name'] = strtoupper( $query['tag_name'] );
}
$needs_class = ( isset( $query['class_name'] ) && is_string( $query['class_name'] ) )
? $query['class_name']
: null;
if ( ! ( array_key_exists( 'breadcrumbs', $query ) && is_array( $query['breadcrumbs'] ) ) ) {
while ( $this->next_token() ) {
if ( '#tag' !== $this->get_token_type() ) {
continue;
}
if ( isset( $query['tag_name'] ) && $query['tag_name'] !== $this->get_token_name() ) {
continue;
}
if ( isset( $needs_class ) && ! $this->has_class( $needs_class ) ) {
continue;
}
if ( ! $this->is_tag_closer() || $visit_closers ) {
return true;
}
}
return false;
}
$breadcrumbs = $query['breadcrumbs'];
$match_offset = isset( $query['match_offset'] ) ? (int) $query['match_offset'] : 1;
while ( $match_offset > 0 && $this->next_token() ) {
if ( '#tag' !== $this->get_token_type() || $this->is_tag_closer() ) {
continue;
}
if ( isset( $needs_class ) && ! $this->has_class( $needs_class ) ) {
continue;
}
if ( $this->matches_breadcrumbs( $breadcrumbs ) && 0 === --$match_offset ) {
return true;
}
}
return false;
}
/**
* Finds the next token in the HTML document.
*
* This doesn't currently have a way to represent non-tags and doesn't process
* semantic rules for text nodes. For access to the raw tokens consider using
* WP_HTML_Tag_Processor instead.
*
* @since 6.5.0 Added for internal support; do not use.
* @since 6.7.2 Refactored so subclasses may extend.
*
* @return bool Whether a token was parsed.
*/
public function next_token(): bool {
return $this->next_visitable_token();
}
/**
* Ensures internal accounting is maintained for HTML semantic rules while
* the underlying Tag Processor class is seeking to a bookmark.
*
* This doesn't currently have a way to represent non-tags and doesn't process
* semantic rules for text nodes. For access to the raw tokens consider using
* WP_HTML_Tag_Processor instead.
*
* Note that this method may call itself recursively. This is why it is not
* implemented as {@see WP_HTML_Processor::next_token()}, which instead calls
* this method similarly to how {@see WP_HTML_Tag_Processor::next_token()}
* calls the {@see WP_HTML_Tag_Processor::base_class_next_token()} method.
*
* @since 6.7.2 Added for internal support.
*
* @access private
*
* @return bool
*/
private function next_visitable_token(): bool {
$this->current_element = null;
if ( isset( $this->last_error ) ) {
return false;
}
/*
* Prime the events if there are none.
*
* @todo In some cases, probably related to the adoption agency
* algorithm, this call to step() doesn't create any new
* events. Calling it again creates them. Figure out why
* this is and if it's inherent or if it's a bug. Looping
* until there are events or until there are no more
* tokens works in the meantime and isn't obviously wrong.
*/
if ( empty( $this->element_queue ) && $this->step() ) {
return $this->next_visitable_token();
}
// Process the next event on the queue.
$this->current_element = array_shift( $this->element_queue );
if ( ! isset( $this->current_element ) ) {
// There are no tokens left, so close all remaining open elements.
while ( $this->state->stack_of_open_elements->pop() ) {
continue;
}
return empty( $this->element_queue ) ? false : $this->next_visitable_token();
}
$is_pop = WP_HTML_Stack_Event::POP === $this->current_element->operation;
/*
* The root node only exists in the fragment parser, and closing it
* indicates that the parse is complete. Stop before popping it from
* the breadcrumbs.
*/
if ( 'root-node' === $this->current_element->token->bookmark_name ) {
return $this->next_visitable_token();
}
// Adjust the breadcrumbs for this event.
if ( $is_pop ) {
array_pop( $this->breadcrumbs );
} else {
$this->breadcrumbs[] = $this->current_element->token->node_name;
}
// Avoid sending close events for elements which don't expect a closing.
if ( $is_pop && ! $this->expects_closer( $this->current_element->token ) ) {
return $this->next_visitable_token();
}
return true;
}
/**
* Indicates if the current tag token is a tag closer.
*
* Example:
*
* $p = WP_HTML_Processor::create_fragment( '
' );
* $p->next_tag( array( 'tag_name' => 'div', 'tag_closers' => 'visit' ) );
* $p->is_tag_closer() === false;
*
* $p->next_tag( array( 'tag_name' => 'div', 'tag_closers' => 'visit' ) );
* $p->is_tag_closer() === true;
*
* @since 6.6.0 Subclassed for HTML Processor.
*
* @return bool Whether the current tag is a tag closer.
*/
public function is_tag_closer(): bool {
return $this->is_virtual()
? ( WP_HTML_Stack_Event::POP === $this->current_element->operation && '#tag' === $this->get_token_type() )
: parent::is_tag_closer();
}
/**
* Indicates if the currently-matched token is virtual, created by a stack operation
* while processing HTML, rather than a token found in the HTML text itself.
*
* @since 6.6.0
*
* @return bool Whether the current token is virtual.
*/
private function is_virtual(): bool {
return (
isset( $this->current_element->provenance ) &&
'virtual' === $this->current_element->provenance
);
}
/**
* Indicates if the currently-matched tag matches the given breadcrumbs.
*
* A "*" represents a single tag wildcard, where any tag matches, but not no tags.
*
* At some point this function _may_ support a `**` syntax for matching any number
* of unspecified tags in the breadcrumb stack. This has been intentionally left
* out, however, to keep this function simple and to avoid introducing backtracking,
* which could open up surprising performance breakdowns.
*
* Example:
*
* $processor = WP_HTML_Processor::create_fragment( '' );
* $processor->next_tag( 'img' );
* true === $processor->matches_breadcrumbs( array( 'figure', 'img' ) );
* true === $processor->matches_breadcrumbs( array( 'span', 'figure', 'img' ) );
* false === $processor->matches_breadcrumbs( array( 'span', 'img' ) );
* true === $processor->matches_breadcrumbs( array( 'span', '*', 'img' ) );
*
* @since 6.4.0
*
* @param string[] $breadcrumbs DOM sub-path at which element is found, e.g. `array( 'FIGURE', 'IMG' )`.
* May also contain the wildcard `*` which matches a single element, e.g. `array( 'SECTION', '*' )`.
* @return bool Whether the currently-matched tag is found at the given nested structure.
*/
public function matches_breadcrumbs( $breadcrumbs ): bool {
// Everything matches when there are zero constraints.
if ( 0 === count( $breadcrumbs ) ) {
return true;
}
// Start at the last crumb.
$crumb = end( $breadcrumbs );
if ( '*' !== $crumb && $this->get_tag() !== strtoupper( $crumb ) ) {
return false;
}
for ( $i = count( $this->breadcrumbs ) - 1; $i >= 0; $i-- ) {
$node = $this->breadcrumbs[ $i ];
$crumb = strtoupper( current( $breadcrumbs ) );
if ( '*' !== $crumb && $node !== $crumb ) {
return false;
}
if ( false === prev( $breadcrumbs ) ) {
return true;
}
}
return false;
}
/**
* Indicates if the currently-matched node expects a closing
* token, or if it will self-close on the next step.
*
* Most HTML elements expect a closer, such as a P element or
* a DIV element. Others, like an IMG element are void and don't
* have a closing tag. Special elements, such as SCRIPT and STYLE,
* are treated just like void tags. Text nodes and self-closing
* foreign content will also act just like a void tag, immediately
* closing as soon as the processor advances to the next token.
*
* @since 6.6.0
*
* @param WP_HTML_Token|null $node Optional. Node to examine, if provided.
* Default is to examine current node.
* @return bool|null Whether to expect a closer for the currently-matched node,
* or `null` if not matched on any token.
*/
public function expects_closer( ?WP_HTML_Token $node = null ): ?bool {
$token_name = $node->node_name ?? $this->get_token_name();
if ( ! isset( $token_name ) ) {
return null;
}
$token_namespace = $node->namespace ?? $this->get_namespace();
$token_has_self_closing = $node->has_self_closing_flag ?? $this->has_self_closing_flag();
return ! (
// Comments, text nodes, and other atomic tokens.
'#' === $token_name[0] ||
// Doctype declarations.
'html' === $token_name ||
// Void elements.
( 'html' === $token_namespace && self::is_void( $token_name ) ) ||
// Special atomic elements.
( 'html' === $token_namespace && in_array( $token_name, array( 'IFRAME', 'NOEMBED', 'NOFRAMES', 'SCRIPT', 'STYLE', 'TEXTAREA', 'TITLE', 'XMP' ), true ) ) ||
// Self-closing elements in foreign content.
( 'html' !== $token_namespace && $token_has_self_closing )
);
}
/**
* Steps through the HTML document and stop at the next tag, if any.
*
* @since 6.4.0
*
* @throws Exception When unable to allocate a bookmark for the next token in the input HTML document.
*
* @see self::PROCESS_NEXT_NODE
* @see self::REPROCESS_CURRENT_NODE
*
* @param string $node_to_process Whether to parse the next node or reprocess the current node.
* @return bool Whether a tag was matched.
*/
public function step( $node_to_process = self::PROCESS_NEXT_NODE ): bool {
// Refuse to proceed if there was a previous error.
if ( null !== $this->last_error ) {
return false;
}
if ( self::REPROCESS_CURRENT_NODE !== $node_to_process ) {
/*
* Void elements still hop onto the stack of open elements even though
* there's no corresponding closing tag. This is important for managing
* stack-based operations such as "navigate to parent node" or checking
* on an element's breadcrumbs.
*
* When moving on to the next node, therefore, if the bottom-most element
* on the stack is a void element, it must be closed.
*/
$top_node = $this->state->stack_of_open_elements->current_node();
if ( isset( $top_node ) && ! $this->expects_closer( $top_node ) ) {
$this->state->stack_of_open_elements->pop();
}
}
if ( self::PROCESS_NEXT_NODE === $node_to_process ) {
parent::next_token();
if ( WP_HTML_Tag_Processor::STATE_TEXT_NODE === $this->parser_state ) {
parent::subdivide_text_appropriately();
}
}
// Finish stepping when there are no more tokens in the document.
if (
WP_HTML_Tag_Processor::STATE_INCOMPLETE_INPUT === $this->parser_state ||
WP_HTML_Tag_Processor::STATE_COMPLETE === $this->parser_state
) {
return false;
}
$adjusted_current_node = $this->get_adjusted_current_node();
$is_closer = $this->is_tag_closer();
$is_start_tag = WP_HTML_Tag_Processor::STATE_MATCHED_TAG === $this->parser_state && ! $is_closer;
$token_name = $this->get_token_name();
if ( self::REPROCESS_CURRENT_NODE !== $node_to_process ) {
$this->state->current_token = new WP_HTML_Token(
$this->bookmark_token(),
$token_name,
$this->has_self_closing_flag(),
$this->release_internal_bookmark_on_destruct
);
}
$parse_in_current_insertion_mode = (
0 === $this->state->stack_of_open_elements->count() ||
'html' === $adjusted_current_node->namespace ||
(
'math' === $adjusted_current_node->integration_node_type &&
(
( $is_start_tag && ! in_array( $token_name, array( 'MGLYPH', 'MALIGNMARK' ), true ) ) ||
'#text' === $token_name
)
) ||
(
'math' === $adjusted_current_node->namespace &&
'ANNOTATION-XML' === $adjusted_current_node->node_name &&
$is_start_tag && 'SVG' === $token_name
) ||
(
'html' === $adjusted_current_node->integration_node_type &&
( $is_start_tag || '#text' === $token_name )
)
);
try {
if ( ! $parse_in_current_insertion_mode ) {
return $this->step_in_foreign_content();
}
switch ( $this->state->insertion_mode ) {
case WP_HTML_Processor_State::INSERTION_MODE_INITIAL:
return $this->step_initial();
case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML:
return $this->step_before_html();
case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD:
return $this->step_before_head();
case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD:
return $this->step_in_head();
case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD_NOSCRIPT:
return $this->step_in_head_noscript();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD:
return $this->step_after_head();
case WP_HTML_Processor_State::INSERTION_MODE_IN_BODY:
return $this->step_in_body();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE:
return $this->step_in_table();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_TEXT:
return $this->step_in_table_text();
case WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION:
return $this->step_in_caption();
case WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP:
return $this->step_in_column_group();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY:
return $this->step_in_table_body();
case WP_HTML_Processor_State::INSERTION_MODE_IN_ROW:
return $this->step_in_row();
case WP_HTML_Processor_State::INSERTION_MODE_IN_CELL:
return $this->step_in_cell();
case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT:
return $this->step_in_select();
case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE:
return $this->step_in_select_in_table();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE:
return $this->step_in_template();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY:
return $this->step_after_body();
case WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET:
return $this->step_in_frameset();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_FRAMESET:
return $this->step_after_frameset();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_BODY:
return $this->step_after_after_body();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_FRAMESET:
return $this->step_after_after_frameset();
// This should be unreachable but PHP doesn't have total type checking on switch.
default:
$this->bail( "Unaware of the requested parsing mode: '{$this->state->insertion_mode}'." );
}
} catch ( WP_HTML_Unsupported_Exception $e ) {
/*
* Exceptions are used in this class to escape deep call stacks that
* otherwise might involve messier calling and return conventions.
*/
return false;
}
}
/**
* Computes the HTML breadcrumbs for the currently-matched node, if matched.
*
* Breadcrumbs start at the outermost parent and descend toward the matched element.
* They always include the entire path from the root HTML node to the matched element.
*
* Example:
*
* $processor = WP_HTML_Processor::create_fragment( '
' );
* $processor->next_tag( 'IMG' );
* $processor->get_breadcrumbs() === array( 'HTML', 'BODY', 'P', 'STRONG', 'EM', 'IMG' );
*
* @since 6.4.0
*
* @return string[] Array of tag names representing path to matched node.
*/
public function get_breadcrumbs(): array {
return $this->breadcrumbs;
}
/**
* Returns the nesting depth of the current location in the document.
*
* Example:
*
* $processor = WP_HTML_Processor::create_fragment( '' );
* // The processor starts in the BODY context, meaning it has depth from the start: HTML > BODY.
* 2 === $processor->get_current_depth();
*
* // Opening the DIV element increases the depth.
* $processor->next_token();
* 3 === $processor->get_current_depth();
*
* // Opening the P element increases the depth.
* $processor->next_token();
* 4 === $processor->get_current_depth();
*
* // The P element is closed during `next_token()` so the depth is decreased to reflect that.
* $processor->next_token();
* 3 === $processor->get_current_depth();
*
* @since 6.6.0
*
* @return int Nesting-depth of current location in the document.
*/
public function get_current_depth(): int {
return count( $this->breadcrumbs );
}
/**
* Normalizes an HTML fragment by serializing it.
*
* This method assumes that the given HTML snippet is found in BODY context.
* For normalizing full documents or fragments found in other contexts, create
* a new processor using {@see WP_HTML_Processor::create_fragment} or
* {@see WP_HTML_Processor::create_full_parser} and call {@see WP_HTML_Processor::serialize}
* on the created instances.
*
* Many aspects of an input HTML fragment may be changed during normalization.
*
* - Attribute values will be double-quoted.
* - Duplicate attributes will be removed.
* - Omitted tags will be added.
* - Tag and attribute name casing will be lower-cased,
* except for specific SVG and MathML tags or attributes.
* - Text will be re-encoded, null bytes handled,
* and invalid UTF-8 replaced with U+FFFD.
* - Any incomplete syntax trailing at the end will be omitted,
* for example, an unclosed comment opener will be removed.
*
* Example:
*
* echo WP_HTML_Processor::normalize( 'One syntax < <> "oddities"
*
* @since 6.7.0
*
* @param string $html Input HTML to normalize.
*
* @return string|null Normalized output, or `null` if unable to normalize.
*/
public static function normalize( string $html ): ?string {
return static::create_fragment( $html )->serialize();
}
/**
* Returns normalized HTML for a fragment by serializing it.
*
* This differs from {@see WP_HTML_Processor::normalize} in that it starts with
* a specific HTML Processor, which _must_ not have already started scanning;
* it must be in the initial ready state and will be in the completed state once
* serialization is complete.
*
* Many aspects of an input HTML fragment may be changed during normalization.
*
* - Attribute values will be double-quoted.
* - Duplicate attributes will be removed.
* - Omitted tags will be added.
* - Tag and attribute name casing will be lower-cased,
* except for specific SVG and MathML tags or attributes.
* - Text will be re-encoded, null bytes handled,
* and invalid UTF-8 replaced with U+FFFD.
* - Any incomplete syntax trailing at the end will be omitted,
* for example, an unclosed comment opener will be removed.
*
* Example:
*
* $processor = WP_HTML_Processor::create_fragment( 'One syntax < <> "oddities"
*
* @since 6.7.0
*
* @return string|null Normalized HTML markup represented by processor,
* or `null` if unable to generate serialization.
*/
public function serialize(): ?string {
if ( WP_HTML_Tag_Processor::STATE_READY !== $this->parser_state ) {
wp_trigger_error(
__METHOD__,
'An HTML Processor which has already started processing cannot serialize its contents. Serialize immediately after creating the instance.',
E_USER_WARNING
);
return null;
}
$html = '';
while ( $this->next_token() ) {
$html .= $this->serialize_token();
}
if ( null !== $this->get_last_error() ) {
wp_trigger_error(
__METHOD__,
"Cannot serialize HTML Processor with parsing error: {$this->get_last_error()}.",
E_USER_WARNING
);
return null;
}
return $html;
}
/**
* Serializes the currently-matched token.
*
* This method produces a fully-normative HTML string for the currently-matched token,
* if able. If not matched at any token or if the token doesn't correspond to any HTML
* it will return an empty string (for example, presumptuous end tags are ignored).
*
* @see static::serialize()
*
* @since 6.7.0
* @since 6.9.0 Converted from protected to public method.
*
* @return string Serialization of token, or empty string if no serialization exists.
*/
public function serialize_token(): string {
$html = '';
$token_type = $this->get_token_type();
switch ( $token_type ) {
case '#doctype':
$doctype = $this->get_doctype_info();
if ( null === $doctype ) {
break;
}
$html .= 'name ) {
$html .= " {$doctype->name}";
}
if ( null !== $doctype->public_identifier ) {
$quote = str_contains( $doctype->public_identifier, '"' ) ? "'" : '"';
$html .= " PUBLIC {$quote}{$doctype->public_identifier}{$quote}";
}
if ( null !== $doctype->system_identifier ) {
if ( null === $doctype->public_identifier ) {
$html .= ' SYSTEM';
}
$quote = str_contains( $doctype->system_identifier, '"' ) ? "'" : '"';
$html .= " {$quote}{$doctype->system_identifier}{$quote}";
}
$html .= '>';
break;
case '#text':
$html .= htmlspecialchars( $this->get_modifiable_text(), ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5, 'UTF-8' );
break;
// Unlike the `<>` which is interpreted as plaintext, this is ignored entirely.
case '#presumptuous-tag':
break;
case '#funky-comment':
case '#comment':
$html .= "";
break;
case '#cdata-section':
$html .= "get_modifiable_text()}]]>";
break;
}
if ( '#tag' !== $token_type ) {
return $html;
}
$tag_name = str_replace( "\x00", "\u{FFFD}", $this->get_tag() );
$in_html = 'html' === $this->get_namespace();
$qualified_name = $in_html ? strtolower( $tag_name ) : $this->get_qualified_tag_name();
if ( $this->is_tag_closer() ) {
$html .= "";
return $html;
}
$attribute_names = $this->get_attribute_names_with_prefix( '' );
if ( ! isset( $attribute_names ) ) {
$html .= "<{$qualified_name}>";
return $html;
}
$html .= "<{$qualified_name}";
foreach ( $attribute_names as $attribute_name ) {
$html .= " {$this->get_qualified_attribute_name( $attribute_name )}";
$value = $this->get_attribute( $attribute_name );
if ( is_string( $value ) ) {
$html .= '="' . htmlspecialchars( $value, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5 ) . '"';
}
$html = str_replace( "\x00", "\u{FFFD}", $html );
}
if ( ! $in_html && $this->has_self_closing_flag() ) {
$html .= ' /';
}
$html .= '>';
// Flush out self-contained elements.
if ( $in_html && in_array( $tag_name, array( 'IFRAME', 'NOEMBED', 'NOFRAMES', 'SCRIPT', 'STYLE', 'TEXTAREA', 'TITLE', 'XMP' ), true ) ) {
$text = $this->get_modifiable_text();
switch ( $tag_name ) {
case 'IFRAME':
case 'NOEMBED':
case 'NOFRAMES':
$text = '';
break;
case 'SCRIPT':
case 'STYLE':
break;
default:
$text = htmlspecialchars( $text, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5, 'UTF-8' );
}
$html .= "{$text}";
}
return $html;
}
/**
* Parses next element in the 'initial' insertion mode.
*
* This internal function performs the 'initial' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#the-initial-insertion-mode
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_initial(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( parent::is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION,
* > U+000A LINE FEED (LF), U+000C FORM FEED (FF),
* > U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*
* Parse error: ignore the token.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step();
}
goto initial_anything_else;
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
$doctype = $this->get_doctype_info();
if ( null !== $doctype && 'quirks' === $doctype->indicated_compatibility_mode ) {
$this->compat_mode = WP_HTML_Tag_Processor::QUIRKS_MODE;
}
/*
* > Then, switch the insertion mode to "before html".
*/
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML;
$this->insert_html_element( $this->state->current_token );
return true;
}
/*
* > Anything else
*/
initial_anything_else:
$this->compat_mode = WP_HTML_Tag_Processor::QUIRKS_MODE;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'before html' insertion mode.
*
* This internal function performs the 'before html' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#the-before-html-insertion-mode
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_before_html(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$is_closer = parent::is_tag_closer();
$op_sigil = '#tag' === $token_type ? ( $is_closer ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A character token that is one of U+0009 CHARACTER TABULATION,
* > U+000A LINE FEED (LF), U+000C FORM FEED (FF),
* > U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*
* Parse error: ignore the token.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step();
}
goto before_html_anything_else;
break;
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD;
return true;
/*
* > An end tag whose tag name is one of: "head", "body", "html", "br"
*
* Closing BR tags are always reported by the Tag Processor as opening tags.
*/
case '-HEAD':
case '-BODY':
case '-HTML':
/*
* > Act as described in the "anything else" entry below.
*/
goto before_html_anything_else;
break;
}
/*
* > Any other end tag
*/
if ( $is_closer ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else.
*
* > Create an html element whose node document is the Document object.
* > Append it to the Document object. Put this element in the stack of open elements.
* > Switch the insertion mode to "before head", then reprocess the token.
*/
before_html_anything_else:
$this->insert_virtual_node( 'HTML' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'before head' insertion mode.
*
* This internal function performs the 'before head' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#the-before-head-insertion-mode
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_before_head(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$is_closer = parent::is_tag_closer();
$op_sigil = '#tag' === $token_type ? ( $is_closer ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION,
* > U+000A LINE FEED (LF), U+000C FORM FEED (FF),
* > U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*
* Parse error: ignore the token.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step();
}
goto before_head_anything_else;
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > A start tag whose tag name is "head"
*/
case '+HEAD':
$this->insert_html_element( $this->state->current_token );
$this->state->head_element = $this->state->current_token;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
return true;
/*
* > An end tag whose tag name is one of: "head", "body", "html", "br"
* > Act as described in the "anything else" entry below.
*
* Closing BR tags are always reported by the Tag Processor as opening tags.
*/
case '-HEAD':
case '-BODY':
case '-HTML':
goto before_head_anything_else;
break;
}
if ( $is_closer ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else
*
* > Insert an HTML element for a "head" start tag token with no attributes.
*/
before_head_anything_else:
$this->state->head_element = $this->insert_virtual_node( 'HEAD' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'in head' insertion mode.
*
* This internal function performs the 'in head' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inhead
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_head(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$is_closer = parent::is_tag_closer();
$op_sigil = '#tag' === $token_type ? ( $is_closer ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
case '#text':
/*
* > A character token that is one of U+0009 CHARACTER TABULATION,
* > U+000A LINE FEED (LF), U+000C FORM FEED (FF),
* > U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*/
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
// Insert the character.
$this->insert_html_element( $this->state->current_token );
return true;
}
goto in_head_anything_else;
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > A start tag whose tag name is one of: "base", "basefont", "bgsound", "link"
*/
case '+BASE':
case '+BASEFONT':
case '+BGSOUND':
case '+LINK':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "meta"
*/
case '+META':
$this->insert_html_element( $this->state->current_token );
// All following conditions depend on "tentative" encoding confidence.
if ( 'tentative' !== $this->state->encoding_confidence ) {
return true;
}
/*
* > If the active speculative HTML parser is null, then:
* > - If the element has a charset attribute, and getting an encoding from
* > its value results in an encoding, and the confidence is currently
* > tentative, then change the encoding to the resulting encoding.
*/
$charset = $this->get_attribute( 'charset' );
if ( is_string( $charset ) ) {
$this->bail( 'Cannot yet process META tags with charset to determine encoding.' );
}
/*
* > - Otherwise, if the element has an http-equiv attribute whose value is
* > an ASCII case-insensitive match for the string "Content-Type", and
* > the element has a content attribute, and applying the algorithm for
* > extracting a character encoding from a meta element to that attribute's
* > value returns an encoding, and the confidence is currently tentative,
* > then change the encoding to the extracted encoding.
*/
$http_equiv = $this->get_attribute( 'http-equiv' );
$content = $this->get_attribute( 'content' );
if (
is_string( $http_equiv ) &&
is_string( $content ) &&
0 === strcasecmp( $http_equiv, 'Content-Type' )
) {
$this->bail( 'Cannot yet process META tags with http-equiv Content-Type to determine encoding.' );
}
return true;
/*
* > A start tag whose tag name is "title"
*/
case '+TITLE':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "noscript", if the scripting flag is enabled
* > A start tag whose tag name is one of: "noframes", "style"
*
* The scripting flag is never enabled in this parser.
*/
case '+NOFRAMES':
case '+STYLE':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "noscript", if the scripting flag is disabled
*/
case '+NOSCRIPT':
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD_NOSCRIPT;
return true;
/*
* > A start tag whose tag name is "script"
*
* @todo Could the adjusted insertion location be anything other than the current location?
*/
case '+SCRIPT':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > An end tag whose tag name is "head"
*/
case '-HEAD':
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD;
return true;
/*
* > An end tag whose tag name is one of: "body", "html", "br"
*
* BR tags are always reported by the Tag Processor as opening tags.
*/
case '-BODY':
case '-HTML':
/*
* > Act as described in the "anything else" entry below.
*/
goto in_head_anything_else;
break;
/*
* > A start tag whose tag name is "template"
*
* @todo Could the adjusted insertion location be anything other than the current location?
*/
case '+TEMPLATE':
$this->state->active_formatting_elements->insert_marker();
$this->state->frameset_ok = false;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > An end tag whose tag name is "template"
*/
case '-TEMPLATE':
if ( ! $this->state->stack_of_open_elements->contains( 'TEMPLATE' ) ) {
// @todo Indicate a parse error once it's possible.
return $this->step();
}
$this->generate_implied_end_tags_thoroughly();
if ( ! $this->state->stack_of_open_elements->current_node_is( 'TEMPLATE' ) ) {
// @todo Indicate a parse error once it's possible.
}
$this->state->stack_of_open_elements->pop_until( 'TEMPLATE' );
$this->state->active_formatting_elements->clear_up_to_last_marker();
array_pop( $this->state->stack_of_template_insertion_modes );
$this->reset_insertion_mode_appropriately();
return true;
}
/*
* > A start tag whose tag name is "head"
* > Any other end tag
*/
if ( '+HEAD' === $op || $is_closer ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else
*/
in_head_anything_else:
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'in head noscript' insertion mode.
*
* This internal function performs the 'in head noscript' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-inheadnoscript
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_head_noscript(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$is_closer = parent::is_tag_closer();
$op_sigil = '#tag' === $token_type ? ( $is_closer ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION,
* > U+000A LINE FEED (LF), U+000C FORM FEED (FF),
* > U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*
* Parse error: ignore the token.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step_in_head();
}
goto in_head_noscript_anything_else;
break;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > An end tag whose tag name is "noscript"
*/
case '-NOSCRIPT':
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
return true;
/*
* > A comment token
* >
* > A start tag whose tag name is one of: "basefont", "bgsound",
* > "link", "meta", "noframes", "style"
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
case '+BASEFONT':
case '+BGSOUND':
case '+LINK':
case '+META':
case '+NOFRAMES':
case '+STYLE':
return $this->step_in_head();
/*
* > An end tag whose tag name is "br"
*
* This should never happen, as the Tag Processor prevents showing a BR closing tag.
*/
}
/*
* > A start tag whose tag name is one of: "head", "noscript"
* > Any other end tag
*/
if ( '+HEAD' === $op || '+NOSCRIPT' === $op || $is_closer ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else
*
* Anything here is a parse error.
*/
in_head_noscript_anything_else:
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'after head' insertion mode.
*
* This internal function performs the 'after head' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#the-after-head-insertion-mode
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_after_head(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$is_closer = parent::is_tag_closer();
$op_sigil = '#tag' === $token_type ? ( $is_closer ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION,
* > U+000A LINE FEED (LF), U+000C FORM FEED (FF),
* > U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
// Insert the character.
$this->insert_html_element( $this->state->current_token );
return true;
}
goto after_head_anything_else;
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > A start tag whose tag name is "body"
*/
case '+BODY':
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
return true;
/*
* > A start tag whose tag name is "frameset"
*/
case '+FRAMESET':
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET;
return true;
/*
* > A start tag whose tag name is one of: "base", "basefont", "bgsound",
* > "link", "meta", "noframes", "script", "style", "template", "title"
*
* Anything here is a parse error.
*/
case '+BASE':
case '+BASEFONT':
case '+BGSOUND':
case '+LINK':
case '+META':
case '+NOFRAMES':
case '+SCRIPT':
case '+STYLE':
case '+TEMPLATE':
case '+TITLE':
/*
* > Push the node pointed to by the head element pointer onto the stack of open elements.
* > Process the token using the rules for the "in head" insertion mode.
* > Remove the node pointed to by the head element pointer from the stack of open elements. (It might not be the current node at this point.)
*/
$this->bail( 'Cannot process elements after HEAD which reopen the HEAD element.' );
/*
* Do not leave this break in when adding support; it's here to prevent
* WPCS from getting confused at the switch structure without a return,
* because it doesn't know that `bail()` always throws.
*/
break;
/*
* > An end tag whose tag name is "template"
*/
case '-TEMPLATE':
return $this->step_in_head();
/*
* > An end tag whose tag name is one of: "body", "html", "br"
*
* Closing BR tags are always reported by the Tag Processor as opening tags.
*/
case '-BODY':
case '-HTML':
/*
* > Act as described in the "anything else" entry below.
*/
goto after_head_anything_else;
break;
}
/*
* > A start tag whose tag name is "head"
* > Any other end tag
*/
if ( '+HEAD' === $op || $is_closer ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else
* > Insert an HTML element for a "body" start tag token with no attributes.
*/
after_head_anything_else:
$this->insert_virtual_node( 'BODY' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'in body' insertion mode.
*
* This internal function performs the 'in body' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.4.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-inbody
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_body(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( parent::is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
case '#text':
/*
* > A character token that is U+0000 NULL
*
* Any successive sequence of NULL bytes is ignored and won't
* trigger active format reconstruction. Therefore, if the text
* only comprises NULL bytes then the token should be ignored
* here, but if there are any other characters in the stream
* the active formats should be reconstructed.
*/
if ( parent::TEXT_IS_NULL_SEQUENCE === $this->text_node_classification ) {
// Parse error: ignore the token.
return $this->step();
}
$this->reconstruct_active_formatting_elements();
/*
* Whitespace-only text does not affect the frameset-ok flag.
* It is probably inter-element whitespace, but it may also
* contain character references which decode only to whitespace.
*/
if ( parent::TEXT_IS_GENERIC === $this->text_node_classification ) {
$this->state->frameset_ok = false;
}
$this->insert_html_element( $this->state->current_token );
return true;
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
* > Parse error. Ignore the token.
*/
case 'html':
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
if ( ! $this->state->stack_of_open_elements->contains( 'TEMPLATE' ) ) {
/*
* > Otherwise, for each attribute on the token, check to see if the attribute
* > is already present on the top element of the stack of open elements. If
* > it is not, add the attribute and its corresponding value to that element.
*
* This parser does not currently support this behavior: ignore the token.
*/
}
// Ignore the token.
return $this->step();
/*
* > A start tag whose tag name is one of: "base", "basefont", "bgsound", "link",
* > "meta", "noframes", "script", "style", "template", "title"
* >
* > An end tag whose tag name is "template"
*/
case '+BASE':
case '+BASEFONT':
case '+BGSOUND':
case '+LINK':
case '+META':
case '+NOFRAMES':
case '+SCRIPT':
case '+STYLE':
case '+TEMPLATE':
case '+TITLE':
case '-TEMPLATE':
return $this->step_in_head();
/*
* > A start tag whose tag name is "body"
*
* This tag in the IN BODY insertion mode is a parse error.
*/
case '+BODY':
if (
1 === $this->state->stack_of_open_elements->count() ||
'BODY' !== ( $this->state->stack_of_open_elements->at( 2 )->node_name ?? null ) ||
$this->state->stack_of_open_elements->contains( 'TEMPLATE' )
) {
// Ignore the token.
return $this->step();
}
/*
* > Otherwise, set the frameset-ok flag to "not ok"; then, for each attribute
* > on the token, check to see if the attribute is already present on the body
* > element (the second element) on the stack of open elements, and if it is
* > not, add the attribute and its corresponding value to that element.
*
* This parser does not currently support this behavior: ignore the token.
*/
$this->state->frameset_ok = false;
return $this->step();
/*
* > A start tag whose tag name is "frameset"
*
* This tag in the IN BODY insertion mode is a parse error.
*/
case '+FRAMESET':
if (
1 === $this->state->stack_of_open_elements->count() ||
'BODY' !== ( $this->state->stack_of_open_elements->at( 2 )->node_name ?? null ) ||
false === $this->state->frameset_ok
) {
// Ignore the token.
return $this->step();
}
/*
* > Otherwise, run the following steps:
*/
$this->bail( 'Cannot process non-ignored FRAMESET tags.' );
break;
/*
* > An end tag whose tag name is "body"
*/
case '-BODY':
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( 'BODY' ) ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Otherwise, if there is a node in the stack of open elements that is not either a
* > dd element, a dt element, an li element, an optgroup element, an option element,
* > a p element, an rb element, an rp element, an rt element, an rtc element, a tbody
* > element, a td element, a tfoot element, a th element, a thread element, a tr
* > element, the body element, or the html element, then this is a parse error.
*
* There is nothing to do for this parse error, so don't check for it.
*/
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY;
/*
* The BODY element is not removed from the stack of open elements.
* Only internal state has changed, this does not qualify as a "step"
* in terms of advancing through the document to another token.
* Nothing has been pushed or popped.
* Proceed to parse the next item.
*/
return $this->step();
/*
* > An end tag whose tag name is "html"
*/
case '-HTML':
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( 'BODY' ) ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > Otherwise, if there is a node in the stack of open elements that is not either a
* > dd element, a dt element, an li element, an optgroup element, an option element,
* > a p element, an rb element, an rp element, an rt element, an rtc element, a tbody
* > element, a td element, a tfoot element, a th element, a thread element, a tr
* > element, the body element, or the html element, then this is a parse error.
*
* There is nothing to do for this parse error, so don't check for it.
*/
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is one of: "address", "article", "aside",
* > "blockquote", "center", "details", "dialog", "dir", "div", "dl",
* > "fieldset", "figcaption", "figure", "footer", "header", "hgroup",
* > "main", "menu", "nav", "ol", "p", "search", "section", "summary", "ul"
*/
case '+ADDRESS':
case '+ARTICLE':
case '+ASIDE':
case '+BLOCKQUOTE':
case '+CENTER':
case '+DETAILS':
case '+DIALOG':
case '+DIR':
case '+DIV':
case '+DL':
case '+FIELDSET':
case '+FIGCAPTION':
case '+FIGURE':
case '+FOOTER':
case '+HEADER':
case '+HGROUP':
case '+MAIN':
case '+MENU':
case '+NAV':
case '+OL':
case '+P':
case '+SEARCH':
case '+SECTION':
case '+SUMMARY':
case '+UL':
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is one of: "h1", "h2", "h3", "h4", "h5", "h6"
*/
case '+H1':
case '+H2':
case '+H3':
case '+H4':
case '+H5':
case '+H6':
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
if (
in_array(
$this->state->stack_of_open_elements->current_node()->node_name,
array( 'H1', 'H2', 'H3', 'H4', 'H5', 'H6' ),
true
)
) {
// @todo Indicate a parse error once it's possible.
$this->state->stack_of_open_elements->pop();
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is one of: "pre", "listing"
*/
case '+PRE':
case '+LISTING':
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
/*
* > If the next token is a U+000A LINE FEED (LF) character token,
* > then ignore that token and move on to the next one. (Newlines
* > at the start of pre blocks are ignored as an authoring convenience.)
*
* This is handled in `get_modifiable_text()`.
*/
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
return true;
/*
* > A start tag whose tag name is "form"
*/
case '+FORM':
$stack_contains_template = $this->state->stack_of_open_elements->contains( 'TEMPLATE' );
if ( isset( $this->state->form_element ) && ! $stack_contains_template ) {
// Parse error: ignore the token.
return $this->step();
}
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
$this->insert_html_element( $this->state->current_token );
if ( ! $stack_contains_template ) {
$this->state->form_element = $this->state->current_token;
}
return true;
/*
* > A start tag whose tag name is "li"
* > A start tag whose tag name is one of: "dd", "dt"
*/
case '+DD':
case '+DT':
case '+LI':
$this->state->frameset_ok = false;
$node = $this->state->stack_of_open_elements->current_node();
$is_li = 'LI' === $token_name;
in_body_list_loop:
/*
* The logic for LI and DT/DD is the same except for one point: LI elements _only_
* close other LI elements, but a DT or DD element closes _any_ open DT or DD element.
*/
if ( $is_li ? 'LI' === $node->node_name : ( 'DD' === $node->node_name || 'DT' === $node->node_name ) ) {
$node_name = $is_li ? 'LI' : $node->node_name;
$this->generate_implied_end_tags( $node_name );
if ( ! $this->state->stack_of_open_elements->current_node_is( $node_name ) ) {
// @todo Indicate a parse error once it's possible. This error does not impact the logic here.
}
$this->state->stack_of_open_elements->pop_until( $node_name );
goto in_body_list_done;
}
if (
'ADDRESS' !== $node->node_name &&
'DIV' !== $node->node_name &&
'P' !== $node->node_name &&
self::is_special( $node )
) {
/*
* > If node is in the special category, but is not an address, div,
* > or p element, then jump to the step labeled done below.
*/
goto in_body_list_done;
} else {
/*
* > Otherwise, set node to the previous entry in the stack of open elements
* > and return to the step labeled loop.
*/
foreach ( $this->state->stack_of_open_elements->walk_up( $node ) as $item ) {
$node = $item;
break;
}
goto in_body_list_loop;
}
in_body_list_done:
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
$this->insert_html_element( $this->state->current_token );
return true;
case '+PLAINTEXT':
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
/*
* @todo This may need to be handled in the Tag Processor and turn into
* a single self-contained tag like TEXTAREA, whose modifiable text
* is the rest of the input document as plaintext.
*/
$this->bail( 'Cannot process PLAINTEXT elements.' );
break;
/*
* > A start tag whose tag name is "button"
*/
case '+BUTTON':
if ( $this->state->stack_of_open_elements->has_element_in_scope( 'BUTTON' ) ) {
// @todo Indicate a parse error once it's possible. This error does not impact the logic here.
$this->generate_implied_end_tags();
$this->state->stack_of_open_elements->pop_until( 'BUTTON' );
}
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
return true;
/*
* > An end tag whose tag name is one of: "address", "article", "aside", "blockquote",
* > "button", "center", "details", "dialog", "dir", "div", "dl", "fieldset",
* > "figcaption", "figure", "footer", "header", "hgroup", "listing", "main",
* > "menu", "nav", "ol", "pre", "search", "section", "summary", "ul"
*/
case '-ADDRESS':
case '-ARTICLE':
case '-ASIDE':
case '-BLOCKQUOTE':
case '-BUTTON':
case '-CENTER':
case '-DETAILS':
case '-DIALOG':
case '-DIR':
case '-DIV':
case '-DL':
case '-FIELDSET':
case '-FIGCAPTION':
case '-FIGURE':
case '-FOOTER':
case '-HEADER':
case '-HGROUP':
case '-LISTING':
case '-MAIN':
case '-MENU':
case '-NAV':
case '-OL':
case '-PRE':
case '-SEARCH':
case '-SECTION':
case '-SUMMARY':
case '-UL':
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( $token_name ) ) {
// @todo Report parse error.
// Ignore the token.
return $this->step();
}
$this->generate_implied_end_tags();
if ( ! $this->state->stack_of_open_elements->current_node_is( $token_name ) ) {
// @todo Record parse error: this error doesn't impact parsing.
}
$this->state->stack_of_open_elements->pop_until( $token_name );
return true;
/*
* > An end tag whose tag name is "form"
*/
case '-FORM':
if ( ! $this->state->stack_of_open_elements->contains( 'TEMPLATE' ) ) {
$node = $this->state->form_element;
$this->state->form_element = null;
/*
* > If node is null or if the stack of open elements does not have node
* > in scope, then this is a parse error; return and ignore the token.
*
* @todo It's necessary to check if the form token itself is in scope, not
* simply whether any FORM is in scope.
*/
if (
null === $node ||
! $this->state->stack_of_open_elements->has_element_in_scope( 'FORM' )
) {
// Parse error: ignore the token.
return $this->step();
}
$this->generate_implied_end_tags();
if ( $node !== $this->state->stack_of_open_elements->current_node() ) {
// @todo Indicate a parse error once it's possible. This error does not impact the logic here.
$this->bail( 'Cannot close a FORM when other elements remain open as this would throw off the breadcrumbs for the following tokens.' );
}
$this->state->stack_of_open_elements->remove_node( $node );
return true;
} else {
/*
* > If the stack of open elements does not have a form element in scope,
* > then this is a parse error; return and ignore the token.
*
* Note that unlike in the clause above, this is checking for any FORM in scope.
*/
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( 'FORM' ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->generate_implied_end_tags();
if ( ! $this->state->stack_of_open_elements->current_node_is( 'FORM' ) ) {
// @todo Indicate a parse error once it's possible. This error does not impact the logic here.
}
$this->state->stack_of_open_elements->pop_until( 'FORM' );
return true;
}
break;
/*
* > An end tag whose tag name is "p"
*/
case '-P':
if ( ! $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->insert_html_element( $this->state->current_token );
}
$this->close_a_p_element();
return true;
/*
* > An end tag whose tag name is "li"
* > An end tag whose tag name is one of: "dd", "dt"
*/
case '-DD':
case '-DT':
case '-LI':
if (
/*
* An end tag whose tag name is "li":
* If the stack of open elements does not have an li element in list item scope,
* then this is a parse error; ignore the token.
*/
(
'LI' === $token_name &&
! $this->state->stack_of_open_elements->has_element_in_list_item_scope( 'LI' )
) ||
/*
* An end tag whose tag name is one of: "dd", "dt":
* If the stack of open elements does not have an element in scope that is an
* HTML element with the same tag name as that of the token, then this is a
* parse error; ignore the token.
*/
(
'LI' !== $token_name &&
! $this->state->stack_of_open_elements->has_element_in_scope( $token_name )
)
) {
/*
* This is a parse error, ignore the token.
*
* @todo Indicate a parse error once it's possible.
*/
return $this->step();
}
$this->generate_implied_end_tags( $token_name );
if ( ! $this->state->stack_of_open_elements->current_node_is( $token_name ) ) {
// @todo Indicate a parse error once it's possible. This error does not impact the logic here.
}
$this->state->stack_of_open_elements->pop_until( $token_name );
return true;
/*
* > An end tag whose tag name is one of: "h1", "h2", "h3", "h4", "h5", "h6"
*/
case '-H1':
case '-H2':
case '-H3':
case '-H4':
case '-H5':
case '-H6':
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( '(internal: H1 through H6 - do not use)' ) ) {
/*
* This is a parse error; ignore the token.
*
* @todo Indicate a parse error once it's possible.
*/
return $this->step();
}
$this->generate_implied_end_tags();
if ( ! $this->state->stack_of_open_elements->current_node_is( $token_name ) ) {
// @todo Record parse error: this error doesn't impact parsing.
}
$this->state->stack_of_open_elements->pop_until( '(internal: H1 through H6 - do not use)' );
return true;
/*
* > A start tag whose tag name is "a"
*/
case '+A':
foreach ( $this->state->active_formatting_elements->walk_up() as $item ) {
switch ( $item->node_name ) {
case 'marker':
break 2;
case 'A':
$this->run_adoption_agency_algorithm();
$this->state->active_formatting_elements->remove_node( $item );
$this->state->stack_of_open_elements->remove_node( $item );
break 2;
}
}
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
$this->state->active_formatting_elements->push( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is one of: "b", "big", "code", "em", "font", "i",
* > "s", "small", "strike", "strong", "tt", "u"
*/
case '+B':
case '+BIG':
case '+CODE':
case '+EM':
case '+FONT':
case '+I':
case '+S':
case '+SMALL':
case '+STRIKE':
case '+STRONG':
case '+TT':
case '+U':
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
$this->state->active_formatting_elements->push( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "nobr"
*/
case '+NOBR':
$this->reconstruct_active_formatting_elements();
if ( $this->state->stack_of_open_elements->has_element_in_scope( 'NOBR' ) ) {
// Parse error.
$this->run_adoption_agency_algorithm();
$this->reconstruct_active_formatting_elements();
}
$this->insert_html_element( $this->state->current_token );
$this->state->active_formatting_elements->push( $this->state->current_token );
return true;
/*
* > An end tag whose tag name is one of: "a", "b", "big", "code", "em", "font", "i",
* > "nobr", "s", "small", "strike", "strong", "tt", "u"
*/
case '-A':
case '-B':
case '-BIG':
case '-CODE':
case '-EM':
case '-FONT':
case '-I':
case '-NOBR':
case '-S':
case '-SMALL':
case '-STRIKE':
case '-STRONG':
case '-TT':
case '-U':
$this->run_adoption_agency_algorithm();
return true;
/*
* > A start tag whose tag name is one of: "applet", "marquee", "object"
*/
case '+APPLET':
case '+MARQUEE':
case '+OBJECT':
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
$this->state->active_formatting_elements->insert_marker();
$this->state->frameset_ok = false;
return true;
/*
* > A end tag token whose tag name is one of: "applet", "marquee", "object"
*/
case '-APPLET':
case '-MARQUEE':
case '-OBJECT':
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( $token_name ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->generate_implied_end_tags();
if ( ! $this->state->stack_of_open_elements->current_node_is( $token_name ) ) {
// This is a parse error.
}
$this->state->stack_of_open_elements->pop_until( $token_name );
$this->state->active_formatting_elements->clear_up_to_last_marker();
return true;
/*
* > A start tag whose tag name is "table"
*/
case '+TABLE':
/*
* > If the Document is not set to quirks mode, and the stack of open elements
* > has a p element in button scope, then close a p element.
*/
if (
WP_HTML_Tag_Processor::QUIRKS_MODE !== $this->compat_mode &&
$this->state->stack_of_open_elements->has_p_in_button_scope()
) {
$this->close_a_p_element();
}
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return true;
/*
* > An end tag whose tag name is "br"
*
* This is prevented from happening because the Tag Processor
* reports all closing BR tags as if they were opening tags.
*/
/*
* > A start tag whose tag name is one of: "area", "br", "embed", "img", "keygen", "wbr"
*/
case '+AREA':
case '+BR':
case '+EMBED':
case '+IMG':
case '+KEYGEN':
case '+WBR':
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
return true;
/*
* > A start tag whose tag name is "input"
*/
case '+INPUT':
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
/*
* > If the token does not have an attribute with the name "type", or if it does,
* > but that attribute's value is not an ASCII case-insensitive match for the
* > string "hidden", then: set the frameset-ok flag to "not ok".
*/
$type_attribute = $this->get_attribute( 'type' );
if ( ! is_string( $type_attribute ) || 'hidden' !== strtolower( $type_attribute ) ) {
$this->state->frameset_ok = false;
}
return true;
/*
* > A start tag whose tag name is one of: "param", "source", "track"
*/
case '+PARAM':
case '+SOURCE':
case '+TRACK':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "hr"
*/
case '+HR':
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
return true;
/*
* > A start tag whose tag name is "image"
*/
case '+IMAGE':
/*
* > Parse error. Change the token's tag name to "img" and reprocess it. (Don't ask.)
*
* Note that this is handled elsewhere, so it should not be possible to reach this code.
*/
$this->bail( "Cannot process an IMAGE tag. (Don't ask.)" );
break;
/*
* > A start tag whose tag name is "textarea"
*/
case '+TEXTAREA':
$this->insert_html_element( $this->state->current_token );
/*
* > If the next token is a U+000A LINE FEED (LF) character token, then ignore
* > that token and move on to the next one. (Newlines at the start of
* > textarea elements are ignored as an authoring convenience.)
*
* This is handled in `get_modifiable_text()`.
*/
$this->state->frameset_ok = false;
/*
* > Switch the insertion mode to "text".
*
* As a self-contained node, this behavior is handled in the Tag Processor.
*/
return true;
/*
* > A start tag whose tag name is "xmp"
*/
case '+XMP':
if ( $this->state->stack_of_open_elements->has_p_in_button_scope() ) {
$this->close_a_p_element();
}
$this->reconstruct_active_formatting_elements();
$this->state->frameset_ok = false;
/*
* > Follow the generic raw text element parsing algorithm.
*
* As a self-contained node, this behavior is handled in the Tag Processor.
*/
$this->insert_html_element( $this->state->current_token );
return true;
/*
* A start tag whose tag name is "iframe"
*/
case '+IFRAME':
$this->state->frameset_ok = false;
/*
* > Follow the generic raw text element parsing algorithm.
*
* As a self-contained node, this behavior is handled in the Tag Processor.
*/
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "noembed"
* > A start tag whose tag name is "noscript", if the scripting flag is enabled
*
* The scripting flag is never enabled in this parser.
*/
case '+NOEMBED':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "select"
*/
case '+SELECT':
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
$this->state->frameset_ok = false;
switch ( $this->state->insertion_mode ) {
/*
* > If the insertion mode is one of "in table", "in caption", "in table body", "in row",
* > or "in cell", then switch the insertion mode to "in select in table".
*/
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE:
case WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION:
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY:
case WP_HTML_Processor_State::INSERTION_MODE_IN_ROW:
case WP_HTML_Processor_State::INSERTION_MODE_IN_CELL:
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE;
break;
/*
* > Otherwise, switch the insertion mode to "in select".
*/
default:
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT;
break;
}
return true;
/*
* > A start tag whose tag name is one of: "optgroup", "option"
*/
case '+OPTGROUP':
case '+OPTION':
if ( $this->state->stack_of_open_elements->current_node_is( 'OPTION' ) ) {
$this->state->stack_of_open_elements->pop();
}
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is one of: "rb", "rtc"
*/
case '+RB':
case '+RTC':
if ( $this->state->stack_of_open_elements->has_element_in_scope( 'RUBY' ) ) {
$this->generate_implied_end_tags();
if ( $this->state->stack_of_open_elements->current_node_is( 'RUBY' ) ) {
// @todo Indicate a parse error once it's possible.
}
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is one of: "rp", "rt"
*/
case '+RP':
case '+RT':
if ( $this->state->stack_of_open_elements->has_element_in_scope( 'RUBY' ) ) {
$this->generate_implied_end_tags( 'RTC' );
$current_node_name = $this->state->stack_of_open_elements->current_node()->node_name;
if ( 'RTC' === $current_node_name || 'RUBY' === $current_node_name ) {
// @todo Indicate a parse error once it's possible.
}
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "math"
*/
case '+MATH':
$this->reconstruct_active_formatting_elements();
/*
* @todo Adjust MathML attributes for the token. (This fixes the case of MathML attributes that are not all lowercase.)
* @todo Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink.)
*
* These ought to be handled in the attribute methods.
*/
$this->state->current_token->namespace = 'math';
$this->insert_html_element( $this->state->current_token );
if ( $this->state->current_token->has_self_closing_flag ) {
$this->state->stack_of_open_elements->pop();
}
return true;
/*
* > A start tag whose tag name is "svg"
*/
case '+SVG':
$this->reconstruct_active_formatting_elements();
/*
* @todo Adjust SVG attributes for the token. (This fixes the case of SVG attributes that are not all lowercase.)
* @todo Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink in SVG.)
*
* These ought to be handled in the attribute methods.
*/
$this->state->current_token->namespace = 'svg';
$this->insert_html_element( $this->state->current_token );
if ( $this->state->current_token->has_self_closing_flag ) {
$this->state->stack_of_open_elements->pop();
}
return true;
/*
* > A start tag whose tag name is one of: "caption", "col", "colgroup",
* > "frame", "head", "tbody", "td", "tfoot", "th", "thead", "tr"
*/
case '+CAPTION':
case '+COL':
case '+COLGROUP':
case '+FRAME':
case '+HEAD':
case '+TBODY':
case '+TD':
case '+TFOOT':
case '+TH':
case '+THEAD':
case '+TR':
// Parse error. Ignore the token.
return $this->step();
}
if ( ! parent::is_tag_closer() ) {
/*
* > Any other start tag
*/
$this->reconstruct_active_formatting_elements();
$this->insert_html_element( $this->state->current_token );
return true;
} else {
/*
* > Any other end tag
*/
/*
* Find the corresponding tag opener in the stack of open elements, if
* it exists before reaching a special element, which provides a kind
* of boundary in the stack. For example, a `` should not
* close anything beyond its containing `P` or `DIV` element.
*/
foreach ( $this->state->stack_of_open_elements->walk_up() as $node ) {
if ( 'html' === $node->namespace && $token_name === $node->node_name ) {
break;
}
if ( self::is_special( $node ) ) {
// This is a parse error, ignore the token.
return $this->step();
}
}
$this->generate_implied_end_tags( $token_name );
if ( $node !== $this->state->stack_of_open_elements->current_node() ) {
// @todo Record parse error: this error doesn't impact parsing.
}
foreach ( $this->state->stack_of_open_elements->walk_up() as $item ) {
$this->state->stack_of_open_elements->pop();
if ( $node === $item ) {
return true;
}
}
}
$this->bail( 'Should not have been able to reach end of IN BODY processing. Check HTML API code.' );
// This unnecessary return prevents tools from inaccurately reporting type errors.
return false;
}
/**
* Parses next element in the 'in table' insertion mode.
*
* This internal function performs the 'in table' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-intable
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_table(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( parent::is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token, if the current node is table,
* > tbody, template, tfoot, thead, or tr element
*/
case '#text':
$current_node = $this->state->stack_of_open_elements->current_node();
$current_node_name = $current_node ? $current_node->node_name : null;
if (
$current_node_name && (
'TABLE' === $current_node_name ||
'TBODY' === $current_node_name ||
'TEMPLATE' === $current_node_name ||
'TFOOT' === $current_node_name ||
'THEAD' === $current_node_name ||
'TR' === $current_node_name
)
) {
/*
* If the text is empty after processing HTML entities and stripping
* U+0000 NULL bytes then ignore the token.
*/
if ( parent::TEXT_IS_NULL_SEQUENCE === $this->text_node_classification ) {
return $this->step();
}
/*
* This follows the rules for "in table text" insertion mode.
*
* Whitespace-only text nodes are inserted in-place. Otherwise
* foster parenting is enabled and the nodes would be
* inserted out-of-place.
*
* > If any of the tokens in the pending table character tokens
* > list are character tokens that are not ASCII whitespace,
* > then this is a parse error: reprocess the character tokens
* > in the pending table character tokens list using the rules
* > given in the "anything else" entry in the "in table"
* > insertion mode.
* >
* > Otherwise, insert the characters given by the pending table
* > character tokens list.
*
* @see https://html.spec.whatwg.org/#parsing-main-intabletext
*/
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
$this->insert_html_element( $this->state->current_token );
return true;
}
// Non-whitespace would trigger fostering, unsupported at this time.
$this->bail( 'Foster parenting is not supported.' );
break;
}
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "caption"
*/
case '+CAPTION':
$this->state->stack_of_open_elements->clear_to_table_context();
$this->state->active_formatting_elements->insert_marker();
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION;
return true;
/*
* > A start tag whose tag name is "colgroup"
*/
case '+COLGROUP':
$this->state->stack_of_open_elements->clear_to_table_context();
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
return true;
/*
* > A start tag whose tag name is "col"
*/
case '+COL':
$this->state->stack_of_open_elements->clear_to_table_context();
/*
* > Insert an HTML element for a "colgroup" start tag token with no attributes,
* > then switch the insertion mode to "in column group".
*/
$this->insert_virtual_node( 'COLGROUP' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is one of: "tbody", "tfoot", "thead"
*/
case '+TBODY':
case '+TFOOT':
case '+THEAD':
$this->state->stack_of_open_elements->clear_to_table_context();
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return true;
/*
* > A start tag whose tag name is one of: "td", "th", "tr"
*/
case '+TD':
case '+TH':
case '+TR':
$this->state->stack_of_open_elements->clear_to_table_context();
/*
* > Insert an HTML element for a "tbody" start tag token with no attributes,
* > then switch the insertion mode to "in table body".
*/
$this->insert_virtual_node( 'TBODY' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is "table"
*
* This tag in the IN TABLE insertion mode is a parse error.
*/
case '+TABLE':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TABLE' ) ) {
return $this->step();
}
$this->state->stack_of_open_elements->pop_until( 'TABLE' );
$this->reset_insertion_mode_appropriately();
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is "table"
*/
case '-TABLE':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TABLE' ) ) {
// @todo Indicate a parse error once it's possible.
return $this->step();
}
$this->state->stack_of_open_elements->pop_until( 'TABLE' );
$this->reset_insertion_mode_appropriately();
return true;
/*
* > An end tag whose tag name is one of: "body", "caption", "col", "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr"
*/
case '-BODY':
case '-CAPTION':
case '-COL':
case '-COLGROUP':
case '-HTML':
case '-TBODY':
case '-TD':
case '-TFOOT':
case '-TH':
case '-THEAD':
case '-TR':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is one of: "style", "script", "template"
* > An end tag whose tag name is "template"
*/
case '+STYLE':
case '+SCRIPT':
case '+TEMPLATE':
case '-TEMPLATE':
/*
* > Process the token using the rules for the "in head" insertion mode.
*/
return $this->step_in_head();
/*
* > A start tag whose tag name is "input"
*
* > If the token does not have an attribute with the name "type", or if it does, but
* > that attribute's value is not an ASCII case-insensitive match for the string
* > "hidden", then: act as described in the "anything else" entry below.
*/
case '+INPUT':
$type_attribute = $this->get_attribute( 'type' );
if ( ! is_string( $type_attribute ) || 'hidden' !== strtolower( $type_attribute ) ) {
goto anything_else;
}
// @todo Indicate a parse error once it's possible.
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "form"
*
* This tag in the IN TABLE insertion mode is a parse error.
*/
case '+FORM':
if (
$this->state->stack_of_open_elements->has_element_in_scope( 'TEMPLATE' ) ||
isset( $this->state->form_element )
) {
return $this->step();
}
// This FORM is special because it immediately closes and cannot have other children.
$this->insert_html_element( $this->state->current_token );
$this->state->form_element = $this->state->current_token;
$this->state->stack_of_open_elements->pop();
return true;
}
/*
* > Anything else
* > Parse error. Enable foster parenting, process the token using the rules for the
* > "in body" insertion mode, and then disable foster parenting.
*
* @todo Indicate a parse error once it's possible.
*/
anything_else:
$this->bail( 'Foster parenting is not supported.' );
}
/**
* Parses next element in the 'in table text' insertion mode.
*
* This internal function performs the 'in table text' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-intabletext
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_table_text(): bool {
$this->bail( 'No support for parsing in the ' . WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_TEXT . ' state.' );
}
/**
* Parses next element in the 'in caption' insertion mode.
*
* This internal function performs the 'in caption' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-incaption
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_caption(): bool {
$tag_name = $this->get_tag();
$op_sigil = $this->is_tag_closer() ? '-' : '+';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > An end tag whose tag name is "caption"
* > A start tag whose tag name is one of: "caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"
* > An end tag whose tag name is "table"
*
* These tag handling rules are identical except for the final instruction.
* Handle them in a single block.
*/
case '-CAPTION':
case '+CAPTION':
case '+COL':
case '+COLGROUP':
case '+TBODY':
case '+TD':
case '+TFOOT':
case '+TH':
case '+THEAD':
case '+TR':
case '-TABLE':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( 'CAPTION' ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->generate_implied_end_tags();
if ( ! $this->state->stack_of_open_elements->current_node_is( 'CAPTION' ) ) {
// @todo Indicate a parse error once it's possible.
}
$this->state->stack_of_open_elements->pop_until( 'CAPTION' );
$this->state->active_formatting_elements->clear_up_to_last_marker();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
// If this is not a CAPTION end tag, the token should be reprocessed.
if ( '-CAPTION' === $op ) {
return true;
}
return $this->step( self::REPROCESS_CURRENT_NODE );
/**
* > An end tag whose tag name is one of: "body", "col", "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr"
*/
case '-BODY':
case '-COL':
case '-COLGROUP':
case '-HTML':
case '-TBODY':
case '-TD':
case '-TFOOT':
case '-TH':
case '-THEAD':
case '-TR':
// Parse error: ignore the token.
return $this->step();
}
/**
* > Anything else
* > Process the token using the rules for the "in body" insertion mode.
*/
return $this->step_in_body();
}
/**
* Parses next element in the 'in column group' insertion mode.
*
* This internal function performs the 'in column group' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-incolgroup
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_column_group(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( parent::is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
* > U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
// Insert the character.
$this->insert_html_element( $this->state->current_token );
return true;
}
goto in_column_group_anything_else;
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// @todo Indicate a parse error once it's possible.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > A start tag whose tag name is "col"
*/
case '+COL':
$this->insert_html_element( $this->state->current_token );
$this->state->stack_of_open_elements->pop();
return true;
/*
* > An end tag whose tag name is "colgroup"
*/
case '-COLGROUP':
if ( ! $this->state->stack_of_open_elements->current_node_is( 'COLGROUP' ) ) {
// @todo Indicate a parse error once it's possible.
return $this->step();
}
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return true;
/*
* > An end tag whose tag name is "col"
*/
case '-COL':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "template"
* > An end tag whose tag name is "template"
*/
case '+TEMPLATE':
case '-TEMPLATE':
return $this->step_in_head();
}
in_column_group_anything_else:
/*
* > Anything else
*/
if ( ! $this->state->stack_of_open_elements->current_node_is( 'COLGROUP' ) ) {
// @todo Indicate a parse error once it's possible.
return $this->step();
}
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'in table body' insertion mode.
*
* This internal function performs the 'in table body' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-intbody
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_table_body(): bool {
$tag_name = $this->get_tag();
$op_sigil = $this->is_tag_closer() ? '-' : '+';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A start tag whose tag name is "tr"
*/
case '+TR':
$this->state->stack_of_open_elements->clear_to_table_body_context();
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
return true;
/*
* > A start tag whose tag name is one of: "th", "td"
*/
case '+TH':
case '+TD':
// @todo Indicate a parse error once it's possible.
$this->state->stack_of_open_elements->clear_to_table_body_context();
$this->insert_virtual_node( 'TR' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is one of: "tbody", "tfoot", "thead"
*/
case '-TBODY':
case '-TFOOT':
case '-THEAD':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( $tag_name ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->clear_to_table_body_context();
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return true;
/*
* > A start tag whose tag name is one of: "caption", "col", "colgroup", "tbody", "tfoot", "thead"
* > An end tag whose tag name is "table"
*/
case '+CAPTION':
case '+COL':
case '+COLGROUP':
case '+TBODY':
case '+TFOOT':
case '+THEAD':
case '-TABLE':
if (
! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TBODY' ) &&
! $this->state->stack_of_open_elements->has_element_in_table_scope( 'THEAD' ) &&
! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TFOOT' )
) {
// Parse error: ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->clear_to_table_body_context();
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is one of: "body", "caption", "col", "colgroup", "html", "td", "th", "tr"
*/
case '-BODY':
case '-CAPTION':
case '-COL':
case '-COLGROUP':
case '-HTML':
case '-TD':
case '-TH':
case '-TR':
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else
* > Process the token using the rules for the "in table" insertion mode.
*/
return $this->step_in_table();
}
/**
* Parses next element in the 'in row' insertion mode.
*
* This internal function performs the 'in row' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-intr
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_row(): bool {
$tag_name = $this->get_tag();
$op_sigil = $this->is_tag_closer() ? '-' : '+';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A start tag whose tag name is one of: "th", "td"
*/
case '+TH':
case '+TD':
$this->state->stack_of_open_elements->clear_to_table_row_context();
$this->insert_html_element( $this->state->current_token );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CELL;
$this->state->active_formatting_elements->insert_marker();
return true;
/*
* > An end tag whose tag name is "tr"
*/
case '-TR':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TR' ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->clear_to_table_row_context();
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return true;
/*
* > A start tag whose tag name is one of: "caption", "col", "colgroup", "tbody", "tfoot", "thead", "tr"
* > An end tag whose tag name is "table"
*/
case '+CAPTION':
case '+COL':
case '+COLGROUP':
case '+TBODY':
case '+TFOOT':
case '+THEAD':
case '+TR':
case '-TABLE':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TR' ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->clear_to_table_row_context();
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is one of: "tbody", "tfoot", "thead"
*/
case '-TBODY':
case '-TFOOT':
case '-THEAD':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( $tag_name ) ) {
// Parse error: ignore the token.
return $this->step();
}
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( 'TR' ) ) {
// Ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->clear_to_table_row_context();
$this->state->stack_of_open_elements->pop();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is one of: "body", "caption", "col", "colgroup", "html", "td", "th"
*/
case '-BODY':
case '-CAPTION':
case '-COL':
case '-COLGROUP':
case '-HTML':
case '-TD':
case '-TH':
// Parse error: ignore the token.
return $this->step();
}
/*
* > Anything else
* > Process the token using the rules for the "in table" insertion mode.
*/
return $this->step_in_table();
}
/**
* Parses next element in the 'in cell' insertion mode.
*
* This internal function performs the 'in cell' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-intd
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_cell(): bool {
$tag_name = $this->get_tag();
$op_sigil = $this->is_tag_closer() ? '-' : '+';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > An end tag whose tag name is one of: "td", "th"
*/
case '-TD':
case '-TH':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( $tag_name ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->generate_implied_end_tags();
/*
* @todo This needs to check if the current node is an HTML element, meaning that
* when SVG and MathML support is added, this needs to differentiate between an
* HTML element of the given name, such as ``, and a foreign element of
* the same given name.
*/
if ( ! $this->state->stack_of_open_elements->current_node_is( $tag_name ) ) {
// @todo Indicate a parse error once it's possible.
}
$this->state->stack_of_open_elements->pop_until( $tag_name );
$this->state->active_formatting_elements->clear_up_to_last_marker();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
return true;
/*
* > A start tag whose tag name is one of: "caption", "col", "colgroup", "tbody", "td",
* > "tfoot", "th", "thead", "tr"
*/
case '+CAPTION':
case '+COL':
case '+COLGROUP':
case '+TBODY':
case '+TD':
case '+TFOOT':
case '+TH':
case '+THEAD':
case '+TR':
/*
* > Assert: The stack of open elements has a td or th element in table scope.
*
* Nothing to do here, except to verify in tests that this never appears.
*/
$this->close_cell();
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is one of: "body", "caption", "col", "colgroup", "html"
*/
case '-BODY':
case '-CAPTION':
case '-COL':
case '-COLGROUP':
case '-HTML':
// Parse error: ignore the token.
return $this->step();
/*
* > An end tag whose tag name is one of: "table", "tbody", "tfoot", "thead", "tr"
*/
case '-TABLE':
case '-TBODY':
case '-TFOOT':
case '-THEAD':
case '-TR':
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( $tag_name ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->close_cell();
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/*
* > Anything else
* > Process the token using the rules for the "in body" insertion mode.
*/
return $this->step_in_body();
}
/**
* Parses next element in the 'in select' insertion mode.
*
* This internal function performs the 'in select' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselect
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_select(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( parent::is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > Any other character token
*/
case '#text':
/*
* > A character token that is U+0000 NULL
*
* If a text node only comprises null bytes then it should be
* entirely ignored and should not return to calling code.
*/
if ( parent::TEXT_IS_NULL_SEQUENCE === $this->text_node_classification ) {
// Parse error: ignore the token.
return $this->step();
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > A start tag whose tag name is "option"
*/
case '+OPTION':
if ( $this->state->stack_of_open_elements->current_node_is( 'OPTION' ) ) {
$this->state->stack_of_open_elements->pop();
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A start tag whose tag name is "optgroup"
* > A start tag whose tag name is "hr"
*
* These rules are identical except for the treatment of the self-closing flag and
* the subsequent pop of the HR void element, all of which is handled elsewhere in the processor.
*/
case '+OPTGROUP':
case '+HR':
if ( $this->state->stack_of_open_elements->current_node_is( 'OPTION' ) ) {
$this->state->stack_of_open_elements->pop();
}
if ( $this->state->stack_of_open_elements->current_node_is( 'OPTGROUP' ) ) {
$this->state->stack_of_open_elements->pop();
}
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > An end tag whose tag name is "optgroup"
*/
case '-OPTGROUP':
$current_node = $this->state->stack_of_open_elements->current_node();
if ( $current_node && 'OPTION' === $current_node->node_name ) {
foreach ( $this->state->stack_of_open_elements->walk_up( $current_node ) as $parent ) {
break;
}
if ( $parent && 'OPTGROUP' === $parent->node_name ) {
$this->state->stack_of_open_elements->pop();
}
}
if ( $this->state->stack_of_open_elements->current_node_is( 'OPTGROUP' ) ) {
$this->state->stack_of_open_elements->pop();
return true;
}
// Parse error: ignore the token.
return $this->step();
/*
* > An end tag whose tag name is "option"
*/
case '-OPTION':
if ( $this->state->stack_of_open_elements->current_node_is( 'OPTION' ) ) {
$this->state->stack_of_open_elements->pop();
return true;
}
// Parse error: ignore the token.
return $this->step();
/*
* > An end tag whose tag name is "select"
* > A start tag whose tag name is "select"
*
* > It just gets treated like an end tag.
*/
case '-SELECT':
case '+SELECT':
if ( ! $this->state->stack_of_open_elements->has_element_in_select_scope( 'SELECT' ) ) {
// Parse error: ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->pop_until( 'SELECT' );
$this->reset_insertion_mode_appropriately();
return true;
/*
* > A start tag whose tag name is one of: "input", "keygen", "textarea"
*
* All three of these tags are considered a parse error when found in this insertion mode.
*/
case '+INPUT':
case '+KEYGEN':
case '+TEXTAREA':
if ( ! $this->state->stack_of_open_elements->has_element_in_select_scope( 'SELECT' ) ) {
// Ignore the token.
return $this->step();
}
$this->state->stack_of_open_elements->pop_until( 'SELECT' );
$this->reset_insertion_mode_appropriately();
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is one of: "script", "template"
* > An end tag whose tag name is "template"
*/
case '+SCRIPT':
case '+TEMPLATE':
case '-TEMPLATE':
return $this->step_in_head();
}
/*
* > Anything else
* > Parse error: ignore the token.
*/
return $this->step();
}
/**
* Parses next element in the 'in select in table' insertion mode.
*
* This internal function performs the 'in select in table' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-inselectintable
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_select_in_table(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( parent::is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A start tag whose tag name is one of: "caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th"
*/
case '+CAPTION':
case '+TABLE':
case '+TBODY':
case '+TFOOT':
case '+THEAD':
case '+TR':
case '+TD':
case '+TH':
// @todo Indicate a parse error once it's possible.
$this->state->stack_of_open_elements->pop_until( 'SELECT' );
$this->reset_insertion_mode_appropriately();
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > An end tag whose tag name is one of: "caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th"
*/
case '-CAPTION':
case '-TABLE':
case '-TBODY':
case '-TFOOT':
case '-THEAD':
case '-TR':
case '-TD':
case '-TH':
// @todo Indicate a parse error once it's possible.
if ( ! $this->state->stack_of_open_elements->has_element_in_table_scope( $token_name ) ) {
return $this->step();
}
$this->state->stack_of_open_elements->pop_until( 'SELECT' );
$this->reset_insertion_mode_appropriately();
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/*
* > Anything else
*/
return $this->step_in_select();
}
/**
* Parses next element in the 'in template' insertion mode.
*
* This internal function performs the 'in template' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-intemplate
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_template(): bool {
$token_name = $this->get_token_name();
$token_type = $this->get_token_type();
$is_closer = $this->is_tag_closer();
$op_sigil = '#tag' === $token_type ? ( $is_closer ? '-' : '+' ) : '';
$op = "{$op_sigil}{$token_name}";
switch ( $op ) {
/*
* > A character token
* > A comment token
* > A DOCTYPE token
*/
case '#text':
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
case 'html':
return $this->step_in_body();
/*
* > A start tag whose tag name is one of: "base", "basefont", "bgsound", "link",
* > "meta", "noframes", "script", "style", "template", "title"
* > An end tag whose tag name is "template"
*/
case '+BASE':
case '+BASEFONT':
case '+BGSOUND':
case '+LINK':
case '+META':
case '+NOFRAMES':
case '+SCRIPT':
case '+STYLE':
case '+TEMPLATE':
case '+TITLE':
case '-TEMPLATE':
return $this->step_in_head();
/*
* > A start tag whose tag name is one of: "caption", "colgroup", "tbody", "tfoot", "thead"
*/
case '+CAPTION':
case '+COLGROUP':
case '+TBODY':
case '+TFOOT':
case '+THEAD':
array_pop( $this->state->stack_of_template_insertion_modes );
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is "col"
*/
case '+COL':
array_pop( $this->state->stack_of_template_insertion_modes );
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is "tr"
*/
case '+TR':
array_pop( $this->state->stack_of_template_insertion_modes );
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
/*
* > A start tag whose tag name is one of: "td", "th"
*/
case '+TD':
case '+TH':
array_pop( $this->state->stack_of_template_insertion_modes );
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/*
* > Any other start tag
*/
if ( ! $is_closer ) {
array_pop( $this->state->stack_of_template_insertion_modes );
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/*
* > Any other end tag
*/
if ( $is_closer ) {
// Parse error: ignore the token.
return $this->step();
}
/*
* > An end-of-file token
*/
if ( ! $this->state->stack_of_open_elements->contains( 'TEMPLATE' ) ) {
// Stop parsing.
return false;
}
// @todo Indicate a parse error once it's possible.
$this->state->stack_of_open_elements->pop_until( 'TEMPLATE' );
$this->state->active_formatting_elements->clear_up_to_last_marker();
array_pop( $this->state->stack_of_template_insertion_modes );
$this->reset_insertion_mode_appropriately();
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'after body' insertion mode.
*
* This internal function performs the 'after body' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-afterbody
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_after_body(): bool {
$tag_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( $this->is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
* > U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
*
* > Process the token using the rules for the "in body" insertion mode.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step_in_body();
}
goto after_body_anything_else;
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->bail( 'Content outside of BODY is unsupported.' );
break;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > An end tag whose tag name is "html"
*
* > If the parser was created as part of the HTML fragment parsing algorithm,
* > this is a parse error; ignore the token. (fragment case)
* >
* > Otherwise, switch the insertion mode to "after after body".
*/
case '-HTML':
if ( isset( $this->context_node ) ) {
return $this->step();
}
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_BODY;
/*
* The HTML element is not removed from the stack of open elements.
* Only internal state has changed, this does not qualify as a "step"
* in terms of advancing through the document to another token.
* Nothing has been pushed or popped.
* Proceed to parse the next item.
*/
return $this->step();
}
/*
* > Parse error. Switch the insertion mode to "in body" and reprocess the token.
*/
after_body_anything_else:
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'in frameset' insertion mode.
*
* This internal function performs the 'in frameset' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-inframeset
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_frameset(): bool {
$tag_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( $this->is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
* > U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
* >
* > Insert the character.
*
* This algorithm effectively strips non-whitespace characters from text and inserts
* them under HTML. This is not supported at this time.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step_in_body();
}
$this->bail( 'Non-whitespace characters cannot be handled in frameset.' );
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > A start tag whose tag name is "frameset"
*/
case '+FRAMESET':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > An end tag whose tag name is "frameset"
*/
case '-FRAMESET':
/*
* > If the current node is the root html element, then this is a parse error;
* > ignore the token. (fragment case)
*/
if ( $this->state->stack_of_open_elements->current_node_is( 'HTML' ) ) {
return $this->step();
}
/*
* > Otherwise, pop the current node from the stack of open elements.
*/
$this->state->stack_of_open_elements->pop();
/*
* > If the parser was not created as part of the HTML fragment parsing algorithm
* > (fragment case), and the current node is no longer a frameset element, then
* > switch the insertion mode to "after frameset".
*/
if ( ! isset( $this->context_node ) && ! $this->state->stack_of_open_elements->current_node_is( 'FRAMESET' ) ) {
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_FRAMESET;
}
return true;
/*
* > A start tag whose tag name is "frame"
*
* > Insert an HTML element for the token. Immediately pop the
* > current node off the stack of open elements.
* >
* > Acknowledge the token's self-closing flag, if it is set.
*/
case '+FRAME':
$this->insert_html_element( $this->state->current_token );
$this->state->stack_of_open_elements->pop();
return true;
/*
* > A start tag whose tag name is "noframes"
*/
case '+NOFRAMES':
return $this->step_in_head();
}
// Parse error: ignore the token.
return $this->step();
}
/**
* Parses next element in the 'after frameset' insertion mode.
*
* This internal function performs the 'after frameset' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-afterframeset
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_after_frameset(): bool {
$tag_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( $this->is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
* > U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
* >
* > Insert the character.
*
* This algorithm effectively strips non-whitespace characters from text and inserts
* them under HTML. This is not supported at this time.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step_in_body();
}
$this->bail( 'Non-whitespace characters cannot be handled in after frameset' );
break;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_html_element( $this->state->current_token );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "html"
*/
case '+HTML':
return $this->step_in_body();
/*
* > An end tag whose tag name is "html"
*/
case '-HTML':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_FRAMESET;
/*
* The HTML element is not removed from the stack of open elements.
* Only internal state has changed, this does not qualify as a "step"
* in terms of advancing through the document to another token.
* Nothing has been pushed or popped.
* Proceed to parse the next item.
*/
return $this->step();
/*
* > A start tag whose tag name is "noframes"
*/
case '+NOFRAMES':
return $this->step_in_head();
}
// Parse error: ignore the token.
return $this->step();
}
/**
* Parses next element in the 'after after body' insertion mode.
*
* This internal function performs the 'after after body' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#the-after-after-body-insertion-mode
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_after_after_body(): bool {
$tag_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( $this->is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->bail( 'Content outside of HTML is unsupported.' );
break;
/*
* > A DOCTYPE token
* > A start tag whose tag name is "html"
*
* > Process the token using the rules for the "in body" insertion mode.
*/
case 'html':
case '+HTML':
return $this->step_in_body();
/*
* > A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
* > U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
* >
* > Process the token using the rules for the "in body" insertion mode.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step_in_body();
}
goto after_after_body_anything_else;
break;
}
/*
* > Parse error. Switch the insertion mode to "in body" and reprocess the token.
*/
after_after_body_anything_else:
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
return $this->step( self::REPROCESS_CURRENT_NODE );
}
/**
* Parses next element in the 'after after frameset' insertion mode.
*
* This internal function performs the 'after after frameset' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#the-after-after-frameset-insertion-mode
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_after_after_frameset(): bool {
$tag_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( $this->is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$tag_name}";
switch ( $op ) {
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->bail( 'Content outside of HTML is unsupported.' );
break;
/*
* > A DOCTYPE token
* > A start tag whose tag name is "html"
*
* > Process the token using the rules for the "in body" insertion mode.
*/
case 'html':
case '+HTML':
return $this->step_in_body();
/*
* > A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
* > U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
* >
* > Process the token using the rules for the "in body" insertion mode.
*
* This algorithm effectively strips non-whitespace characters from text and inserts
* them under HTML. This is not supported at this time.
*/
case '#text':
if ( parent::TEXT_IS_WHITESPACE === $this->text_node_classification ) {
return $this->step_in_body();
}
$this->bail( 'Non-whitespace characters cannot be handled in after after frameset.' );
break;
/*
* > A start tag whose tag name is "noframes"
*/
case '+NOFRAMES':
return $this->step_in_head();
}
// Parse error: ignore the token.
return $this->step();
}
/**
* Parses next element in the 'in foreign content' insertion mode.
*
* This internal function performs the 'in foreign content' insertion mode
* logic for the generalized WP_HTML_Processor::step() function.
*
* @since 6.7.0 Stub implementation.
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#parsing-main-inforeign
* @see WP_HTML_Processor::step
*
* @return bool Whether an element was found.
*/
private function step_in_foreign_content(): bool {
$tag_name = $this->get_token_name();
$token_type = $this->get_token_type();
$op_sigil = '#tag' === $token_type ? ( $this->is_tag_closer() ? '-' : '+' ) : '';
$op = "{$op_sigil}{$tag_name}";
/*
* > A start tag whose name is "font", if the token has any attributes named "color", "face", or "size"
*
* This section drawn out above the switch to more easily incorporate
* the additional rules based on the presence of the attributes.
*/
if (
'+FONT' === $op &&
(
null !== $this->get_attribute( 'color' ) ||
null !== $this->get_attribute( 'face' ) ||
null !== $this->get_attribute( 'size' )
)
) {
$op = '+FONT with attributes';
}
switch ( $op ) {
case '#text':
/*
* > A character token that is U+0000 NULL
*
* This is handled by `get_modifiable_text()`.
*/
/*
* Whitespace-only text does not affect the frameset-ok flag.
* It is probably inter-element whitespace, but it may also
* contain character references which decode only to whitespace.
*/
if ( parent::TEXT_IS_GENERIC === $this->text_node_classification ) {
$this->state->frameset_ok = false;
}
$this->insert_foreign_element( $this->state->current_token, false );
return true;
/*
* CDATA sections are alternate wrappers for text content and therefore
* ought to follow the same rules as text nodes.
*/
case '#cdata-section':
/*
* NULL bytes and whitespace do not change the frameset-ok flag.
*/
$current_token = $this->bookmarks[ $this->state->current_token->bookmark_name ];
$cdata_content_start = $current_token->start + 9;
$cdata_content_length = $current_token->length - 12;
if ( strspn( $this->html, "\0 \t\n\f\r", $cdata_content_start, $cdata_content_length ) !== $cdata_content_length ) {
$this->state->frameset_ok = false;
}
$this->insert_foreign_element( $this->state->current_token, false );
return true;
/*
* > A comment token
*/
case '#comment':
case '#funky-comment':
case '#presumptuous-tag':
$this->insert_foreign_element( $this->state->current_token, false );
return true;
/*
* > A DOCTYPE token
*/
case 'html':
// Parse error: ignore the token.
return $this->step();
/*
* > A start tag whose tag name is "b", "big", "blockquote", "body", "br", "center",
* > "code", "dd", "div", "dl", "dt", "em", "embed", "h1", "h2", "h3", "h4", "h5",
* > "h6", "head", "hr", "i", "img", "li", "listing", "menu", "meta", "nobr", "ol",
* > "p", "pre", "ruby", "s", "small", "span", "strong", "strike", "sub", "sup",
* > "table", "tt", "u", "ul", "var"
*
* > A start tag whose name is "font", if the token has any attributes named "color", "face", or "size"
*
* > An end tag whose tag name is "br", "p"
*
* Closing BR tags are always reported by the Tag Processor as opening tags.
*/
case '+B':
case '+BIG':
case '+BLOCKQUOTE':
case '+BODY':
case '+BR':
case '+CENTER':
case '+CODE':
case '+DD':
case '+DIV':
case '+DL':
case '+DT':
case '+EM':
case '+EMBED':
case '+H1':
case '+H2':
case '+H3':
case '+H4':
case '+H5':
case '+H6':
case '+HEAD':
case '+HR':
case '+I':
case '+IMG':
case '+LI':
case '+LISTING':
case '+MENU':
case '+META':
case '+NOBR':
case '+OL':
case '+P':
case '+PRE':
case '+RUBY':
case '+S':
case '+SMALL':
case '+SPAN':
case '+STRONG':
case '+STRIKE':
case '+SUB':
case '+SUP':
case '+TABLE':
case '+TT':
case '+U':
case '+UL':
case '+VAR':
case '+FONT with attributes':
case '-BR':
case '-P':
// @todo Indicate a parse error once it's possible.
foreach ( $this->state->stack_of_open_elements->walk_up() as $current_node ) {
if (
'math' === $current_node->integration_node_type ||
'html' === $current_node->integration_node_type ||
'html' === $current_node->namespace
) {
break;
}
$this->state->stack_of_open_elements->pop();
}
goto in_foreign_content_process_in_current_insertion_mode;
}
/*
* > Any other start tag
*/
if ( ! $this->is_tag_closer() ) {
$this->insert_foreign_element( $this->state->current_token, false );
/*
* > If the token has its self-closing flag set, then run
* > the appropriate steps from the following list:
* >
* > ↪ the token's tag name is "script", and the new current node is in the SVG namespace
* > Acknowledge the token's self-closing flag, and then act as
* > described in the steps for a "script" end tag below.
* >
* > ↪ Otherwise
* > Pop the current node off the stack of open elements and
* > acknowledge the token's self-closing flag.
*
* Since the rules for SCRIPT below indicate to pop the element off of the stack of
* open elements, which is the same for the Otherwise condition, there's no need to
* separate these checks. The difference comes when a parser operates with the scripting
* flag enabled, and executes the script, which this parser does not support.
*/
if ( $this->state->current_token->has_self_closing_flag ) {
$this->state->stack_of_open_elements->pop();
}
return true;
}
/*
* > An end tag whose name is "script", if the current node is an SVG script element.
*/
if ( $this->is_tag_closer() && 'SCRIPT' === $this->state->current_token->node_name && 'svg' === $this->state->current_token->namespace ) {
$this->state->stack_of_open_elements->pop();
return true;
}
/*
* > Any other end tag
*/
if ( $this->is_tag_closer() ) {
$node = $this->state->stack_of_open_elements->current_node();
if ( $tag_name !== $node->node_name ) {
// @todo Indicate a parse error once it's possible.
}
in_foreign_content_end_tag_loop:
if ( $node === $this->state->stack_of_open_elements->at( 1 ) ) {
return true;
}
/*
* > If node's tag name, converted to ASCII lowercase, is the same as the tag name
* > of the token, pop elements from the stack of open elements until node has
* > been popped from the stack, and then return.
*/
if ( 0 === strcasecmp( $node->node_name, $tag_name ) ) {
foreach ( $this->state->stack_of_open_elements->walk_up() as $item ) {
$this->state->stack_of_open_elements->pop();
if ( $node === $item ) {
return true;
}
}
}
foreach ( $this->state->stack_of_open_elements->walk_up( $node ) as $item ) {
$node = $item;
break;
}
if ( 'html' !== $node->namespace ) {
goto in_foreign_content_end_tag_loop;
}
in_foreign_content_process_in_current_insertion_mode:
switch ( $this->state->insertion_mode ) {
case WP_HTML_Processor_State::INSERTION_MODE_INITIAL:
return $this->step_initial();
case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML:
return $this->step_before_html();
case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD:
return $this->step_before_head();
case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD:
return $this->step_in_head();
case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD_NOSCRIPT:
return $this->step_in_head_noscript();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD:
return $this->step_after_head();
case WP_HTML_Processor_State::INSERTION_MODE_IN_BODY:
return $this->step_in_body();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE:
return $this->step_in_table();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_TEXT:
return $this->step_in_table_text();
case WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION:
return $this->step_in_caption();
case WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP:
return $this->step_in_column_group();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY:
return $this->step_in_table_body();
case WP_HTML_Processor_State::INSERTION_MODE_IN_ROW:
return $this->step_in_row();
case WP_HTML_Processor_State::INSERTION_MODE_IN_CELL:
return $this->step_in_cell();
case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT:
return $this->step_in_select();
case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE:
return $this->step_in_select_in_table();
case WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE:
return $this->step_in_template();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY:
return $this->step_after_body();
case WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET:
return $this->step_in_frameset();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_FRAMESET:
return $this->step_after_frameset();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_BODY:
return $this->step_after_after_body();
case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_FRAMESET:
return $this->step_after_after_frameset();
// This should be unreachable but PHP doesn't have total type checking on switch.
default:
$this->bail( "Unaware of the requested parsing mode: '{$this->state->insertion_mode}'." );
}
}
$this->bail( 'Should not have been able to reach end of IN FOREIGN CONTENT processing. Check HTML API code.' );
// This unnecessary return prevents tools from inaccurately reporting type errors.
return false;
}
/*
* Internal helpers
*/
/**
* Creates a new bookmark for the currently-matched token and returns the generated name.
*
* @since 6.4.0
* @since 6.5.0 Renamed from bookmark_tag() to bookmark_token().
*
* @throws Exception When unable to allocate requested bookmark.
*
* @return string|false Name of created bookmark, or false if unable to create.
*/
private function bookmark_token() {
if ( ! parent::set_bookmark( ++$this->bookmark_counter ) ) {
$this->last_error = self::ERROR_EXCEEDED_MAX_BOOKMARKS;
throw new Exception( 'could not allocate bookmark' );
}
return "{$this->bookmark_counter}";
}
/*
* HTML semantic overrides for Tag Processor
*/
/**
* Indicates the namespace of the current token, or "html" if there is none.
*
* @return string One of "html", "math", or "svg".
*/
public function get_namespace(): string {
if ( ! isset( $this->current_element ) ) {
return parent::get_namespace();
}
return $this->current_element->token->namespace;
}
/**
* Returns the uppercase name of the matched tag.
*
* The semantic rules for HTML specify that certain tags be reprocessed
* with a different tag name. Because of this, the tag name presented
* by the HTML Processor may differ from the one reported by the HTML
* Tag Processor, which doesn't apply these semantic rules.
*
* Example:
*
* $processor = new WP_HTML_Tag_Processor( 'Test
' );
* $processor->next_tag() === true;
* $processor->get_tag() === 'DIV';
*
* $processor->next_tag() === false;
* $processor->get_tag() === null;
*
* @since 6.4.0
*
* @return string|null Name of currently matched tag in input HTML, or `null` if none found.
*/
public function get_tag(): ?string {
if ( null !== $this->last_error ) {
return null;
}
if ( $this->is_virtual() ) {
return $this->current_element->token->node_name;
}
$tag_name = parent::get_tag();
/*
* > A start tag whose tag name is "image"
* > Change the token's tag name to "img" and reprocess it. (Don't ask.)
*/
return ( 'IMAGE' === $tag_name && 'html' === $this->get_namespace() )
? 'IMG'
: $tag_name;
}
/**
* Indicates if the currently matched tag contains the self-closing flag.
*
* No HTML elements ought to have the self-closing flag and for those, the self-closing
* flag will be ignored. For void elements this is benign because they "self close"
* automatically. For non-void HTML elements though problems will appear if someone
* intends to use a self-closing element in place of that element with an empty body.
* For HTML foreign elements and custom elements the self-closing flag determines if
* they self-close or not.
*
* This function does not determine if a tag is self-closing,
* but only if the self-closing flag is present in the syntax.
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @return bool Whether the currently matched tag contains the self-closing flag.
*/
public function has_self_closing_flag(): bool {
return $this->is_virtual() ? false : parent::has_self_closing_flag();
}
/**
* Returns the node name represented by the token.
*
* This matches the DOM API value `nodeName`. Some values
* are static, such as `#text` for a text node, while others
* are dynamically generated from the token itself.
*
* Dynamic names:
* - Uppercase tag name for tag matches.
* - `html` for DOCTYPE declarations.
*
* Note that if the Tag Processor is not matched on a token
* then this function will return `null`, either because it
* hasn't yet found a token or because it reached the end
* of the document without matching a token.
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @return string|null Name of the matched token.
*/
public function get_token_name(): ?string {
return $this->is_virtual()
? $this->current_element->token->node_name
: parent::get_token_name();
}
/**
* Indicates the kind of matched token, if any.
*
* This differs from `get_token_name()` in that it always
* returns a static string indicating the type, whereas
* `get_token_name()` may return values derived from the
* token itself, such as a tag name or processing
* instruction tag.
*
* Possible values:
* - `#tag` when matched on a tag.
* - `#text` when matched on a text node.
* - `#cdata-section` when matched on a CDATA node.
* - `#comment` when matched on a comment.
* - `#doctype` when matched on a DOCTYPE declaration.
* - `#presumptuous-tag` when matched on an empty tag closer.
* - `#funky-comment` when matched on a funky comment.
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @return string|null What kind of token is matched, or null.
*/
public function get_token_type(): ?string {
if ( $this->is_virtual() ) {
/*
* This logic comes from the Tag Processor.
*
* @todo It would be ideal not to repeat this here, but it's not clearly
* better to allow passing a token name to `get_token_type()`.
*/
$node_name = $this->current_element->token->node_name;
$starting_char = $node_name[0];
if ( 'A' <= $starting_char && 'Z' >= $starting_char ) {
return '#tag';
}
if ( 'html' === $node_name ) {
return '#doctype';
}
return $node_name;
}
return parent::get_token_type();
}
/**
* Returns the value of a requested attribute from a matched tag opener if that attribute exists.
*
* Example:
*
* $p = WP_HTML_Processor::create_fragment( 'Test
' );
* $p->next_token() === true;
* $p->get_attribute( 'data-test-id' ) === '14';
* $p->get_attribute( 'enabled' ) === true;
* $p->get_attribute( 'aria-label' ) === null;
*
* $p->next_tag() === false;
* $p->get_attribute( 'class' ) === null;
*
* @since 6.6.0 Subclassed for HTML Processor.
*
* @param string $name Name of attribute whose value is requested.
* @return string|true|null Value of attribute or `null` if not available. Boolean attributes return `true`.
*/
public function get_attribute( $name ) {
return $this->is_virtual() ? null : parent::get_attribute( $name );
}
/**
* Updates or creates a new attribute on the currently matched tag with the passed value.
*
* This function handles all necessary HTML encoding. Provide normal, unescaped string values.
* The HTML API will encode the strings appropriately so that the browser will interpret them
* as the intended value.
*
* Example:
*
* // Renders “Eggs & Milk†in a browser, encoded as ``.
* $processor->set_attribute( 'title', 'Eggs & Milk' );
*
* // Renders “Eggs & Milk†in a browser, encoded as ``.
* $processor->set_attribute( 'title', 'Eggs & Milk' );
*
* // Renders `true` as ``.
* $processor->set_attribute( 'title', true );
*
* // Renders without the attribute for `false` as ``.
* $processor->set_attribute( 'title', false );
*
* Special handling is provided for boolean attribute values:
* - When `true` is passed as the value, then only the attribute name is added to the tag.
* - When `false` is passed, the attribute gets removed if it existed before.
*
* @since 6.6.0 Subclassed for the HTML Processor.
* @since 6.9.0 Escapes all character references instead of trying to avoid double-escaping.
*
* @param string $name The attribute name to target.
* @param string|bool $value The new attribute value.
* @return bool Whether an attribute value was set.
*/
public function set_attribute( $name, $value ): bool {
return $this->is_virtual() ? false : parent::set_attribute( $name, $value );
}
/**
* Remove an attribute from the currently-matched tag.
*
* @since 6.6.0 Subclassed for HTML Processor.
*
* @param string $name The attribute name to remove.
* @return bool Whether an attribute was removed.
*/
public function remove_attribute( $name ): bool {
return $this->is_virtual() ? false : parent::remove_attribute( $name );
}
/**
* Gets lowercase names of all attributes matching a given prefix in the current tag.
*
* Note that matching is case-insensitive. This is in accordance with the spec:
*
* > There must never be two or more attributes on
* > the same start tag whose names are an ASCII
* > case-insensitive match for each other.
* - HTML 5 spec
*
* Example:
*
* $p = new WP_HTML_Tag_Processor( 'Test
' );
* $p->next_tag( array( 'class_name' => 'test' ) ) === true;
* $p->get_attribute_names_with_prefix( 'data-' ) === array( 'data-enabled', 'data-test-id' );
*
* $p->next_tag() === false;
* $p->get_attribute_names_with_prefix( 'data-' ) === null;
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @see https://html.spec.whatwg.org/multipage/syntax.html#attributes-2:ascii-case-insensitive
*
* @param string $prefix Prefix of requested attribute names.
* @return array|null List of attribute names, or `null` when no tag opener is matched.
*/
public function get_attribute_names_with_prefix( $prefix ): ?array {
return $this->is_virtual() ? null : parent::get_attribute_names_with_prefix( $prefix );
}
/**
* Adds a new class name to the currently matched tag.
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @param string $class_name The class name to add.
* @return bool Whether the class was set to be added.
*/
public function add_class( $class_name ): bool {
return $this->is_virtual() ? false : parent::add_class( $class_name );
}
/**
* Removes a class name from the currently matched tag.
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @param string $class_name The class name to remove.
* @return bool Whether the class was set to be removed.
*/
public function remove_class( $class_name ): bool {
return $this->is_virtual() ? false : parent::remove_class( $class_name );
}
/**
* Returns if a matched tag contains the given ASCII case-insensitive class name.
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @todo When reconstructing active formatting elements with attributes, find a way
* to indicate if the virtually-reconstructed formatting elements contain the
* wanted class name.
*
* @param string $wanted_class Look for this CSS class name, ASCII case-insensitive.
* @return bool|null Whether the matched tag contains the given class name, or null if not matched.
*/
public function has_class( $wanted_class ): ?bool {
return $this->is_virtual() ? null : parent::has_class( $wanted_class );
}
/**
* Generator for a foreach loop to step through each class name for the matched tag.
*
* This generator function is designed to be used inside a "foreach" loop.
*
* Example:
*
* $p = WP_HTML_Processor::create_fragment( "" );
* $p->next_tag();
* foreach ( $p->class_list() as $class_name ) {
* echo "{$class_name} ";
* }
* // Outputs: "free
lang-en "
*
* @since 6.6.0 Subclassed for the HTML Processor.
*/
public function class_list() {
return $this->is_virtual() ? null : parent::class_list();
}
/**
* Returns the modifiable text for a matched token, or an empty string.
*
* Modifiable text is text content that may be read and changed without
* changing the HTML structure of the document around it. This includes
* the contents of `#text` nodes in the HTML as well as the inner
* contents of HTML comments, Processing Instructions, and others, even
* though these nodes aren't part of a parsed DOM tree. They also contain
* the contents of SCRIPT and STYLE tags, of TEXTAREA tags, and of any
* other section in an HTML document which cannot contain HTML markup (DATA).
*
* If a token has no modifiable text then an empty string is returned to
* avoid needless crashing or type errors. An empty string does not mean
* that a token has modifiable text, and a token with modifiable text may
* have an empty string (e.g. a comment with no contents).
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @return string
*/
public function get_modifiable_text(): string {
return $this->is_virtual() ? '' : parent::get_modifiable_text();
}
/**
* Indicates what kind of comment produced the comment node.
*
* Because there are different kinds of HTML syntax which produce
* comments, the Tag Processor tracks and exposes this as a type
* for the comment. Nominally only regular HTML comments exist as
* they are commonly known, but a number of unrelated syntax errors
* also produce comments.
*
* @see self::COMMENT_AS_ABRUPTLY_CLOSED_COMMENT
* @see self::COMMENT_AS_CDATA_LOOKALIKE
* @see self::COMMENT_AS_INVALID_HTML
* @see self::COMMENT_AS_HTML_COMMENT
* @see self::COMMENT_AS_PI_NODE_LOOKALIKE
*
* @since 6.6.0 Subclassed for the HTML Processor.
*
* @return string|null
*/
public function get_comment_type(): ?string {
return $this->is_virtual() ? null : parent::get_comment_type();
}
/**
* Removes a bookmark that is no longer needed.
*
* Releasing a bookmark frees up the small
* performance overhead it requires.
*
* @since 6.4.0
*
* @param string $bookmark_name Name of the bookmark to remove.
* @return bool Whether the bookmark already existed before removal.
*/
public function release_bookmark( $bookmark_name ): bool {
return parent::release_bookmark( "_{$bookmark_name}" );
}
/**
* Moves the internal cursor in the HTML Processor to a given bookmark's location.
*
* Be careful! Seeking backwards to a previous location resets the parser to the
* start of the document and reparses the entire contents up until it finds the
* sought-after bookmarked location.
*
* In order to prevent accidental infinite loops, there's a
* maximum limit on the number of times seek() can be called.
*
* @throws Exception When unable to allocate a bookmark for the next token in the input HTML document.
*
* @since 6.4.0
*
* @param string $bookmark_name Jump to the place in the document identified by this bookmark name.
* @return bool Whether the internal cursor was successfully moved to the bookmark's location.
*/
public function seek( $bookmark_name ): bool {
// Flush any pending updates to the document before beginning.
$this->get_updated_html();
$actual_bookmark_name = "_{$bookmark_name}";
$processor_started_at = $this->state->current_token
? $this->bookmarks[ $this->state->current_token->bookmark_name ]->start
: 0;
$bookmark_starts_at = $this->bookmarks[ $actual_bookmark_name ]->start;
$direction = $bookmark_starts_at > $processor_started_at ? 'forward' : 'backward';
/*
* If seeking backwards, it's possible that the sought-after bookmark exists within an element
* which has been closed before the current cursor; in other words, it has already been removed
* from the stack of open elements. This means that it's insufficient to simply pop off elements
* from the stack of open elements which appear after the bookmarked location and then jump to
* that location, as the elements which were open before won't be re-opened.
*
* In order to maintain consistency, the HTML Processor rewinds to the start of the document
* and reparses everything until it finds the sought-after bookmark.
*
* There are potentially better ways to do this: cache the parser state for each bookmark and
* restore it when seeking; store an immutable and idempotent register of where elements open
* and close.
*
* If caching the parser state it will be essential to properly maintain the cached stack of
* open elements and active formatting elements when modifying the document. This could be a
* tedious and time-consuming process as well, and so for now will not be performed.
*
* It may be possible to track bookmarks for where elements open and close, and in doing so
* be able to quickly recalculate breadcrumbs for any element in the document. It may even
* be possible to remove the stack of open elements and compute it on the fly this way.
* If doing this, the parser would need to track the opening and closing locations for all
* tokens in the breadcrumb path for any and all bookmarks. By utilizing bookmarks themselves
* this list could be automatically maintained while modifying the document. Finding the
* breadcrumbs would then amount to traversing that list from the start until the token
* being inspected. Once an element closes, if there are no bookmarks pointing to locations
* within that element, then all of these locations may be forgotten to save on memory use
* and computation time.
*/
if ( 'backward' === $direction ) {
/*
* When moving backward, stateful stacks should be cleared.
*/
foreach ( $this->state->stack_of_open_elements->walk_up() as $item ) {
$this->state->stack_of_open_elements->remove_node( $item );
}
foreach ( $this->state->active_formatting_elements->walk_up() as $item ) {
$this->state->active_formatting_elements->remove_node( $item );
}
/*
* **After** clearing stacks, more processor state can be reset.
* This must be done after clearing the stack because those stacks generate events that
* would appear on a subsequent call to `next_token()`.
*/
$this->state->frameset_ok = true;
$this->state->stack_of_template_insertion_modes = array();
$this->state->head_element = null;
$this->state->form_element = null;
$this->state->current_token = null;
$this->current_element = null;
$this->element_queue = array();
/*
* The absence of a context node indicates a full parse.
* The presence of a context node indicates a fragment parser.
*/
if ( null === $this->context_node ) {
$this->change_parsing_namespace( 'html' );
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_INITIAL;
$this->breadcrumbs = array();
$this->bookmarks['initial'] = new WP_HTML_Span( 0, 0 );
parent::seek( 'initial' );
unset( $this->bookmarks['initial'] );
} else {
/*
* Push the root-node (HTML) back onto the stack of open elements.
*
* Fragment parsers require this extra bit of setup.
* It's handled in full parsers by advancing the processor state.
*/
$this->state->stack_of_open_elements->push(
new WP_HTML_Token(
'root-node',
'HTML',
false
)
);
$this->change_parsing_namespace(
$this->context_node->integration_node_type
? 'html'
: $this->context_node->namespace
);
if ( 'TEMPLATE' === $this->context_node->node_name ) {
$this->state->stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
}
$this->reset_insertion_mode_appropriately();
$this->breadcrumbs = array_slice( $this->breadcrumbs, 0, 2 );
parent::seek( $this->context_node->bookmark_name );
}
}
/*
* Here, the processor moves forward through the document until it matches the bookmark.
* do-while is used here because the processor is expected to already be stopped on
* a token than may match the bookmarked location.
*/
do {
/*
* The processor will stop on virtual tokens, but bookmarks may not be set on them.
* They should not be matched when seeking a bookmark, skip them.
*/
if ( $this->is_virtual() ) {
continue;
}
if ( $bookmark_starts_at === $this->bookmarks[ $this->state->current_token->bookmark_name ]->start ) {
return true;
}
} while ( $this->next_token() );
return false;
}
/**
* Sets a bookmark in the HTML document.
*
* Bookmarks represent specific places or tokens in the HTML
* document, such as a tag opener or closer. When applying
* edits to a document, such as setting an attribute, the
* text offsets of that token may shift; the bookmark is
* kept updated with those shifts and remains stable unless
* the entire span of text in which the token sits is removed.
*
* Release bookmarks when they are no longer needed.
*
* Example:
*
* Surprising fact you may not know! Surprising fact you may no…
* ^ ^
* \-|-- it shifts with edits
*
* Bookmarks provide the ability to seek to a previously-scanned
* place in the HTML document. This avoids the need to re-scan
* the entire document.
*
* Example:
*
*
* ^^^^
* want to note this last item
*
* $p = new WP_HTML_Tag_Processor( $html );
* $in_list = false;
* while ( $p->next_tag( array( 'tag_closers' => $in_list ? 'visit' : 'skip' ) ) ) {
* if ( 'UL' === $p->get_tag() ) {
* if ( $p->is_tag_closer() ) {
* $in_list = false;
* $p->set_bookmark( 'resume' );
* if ( $p->seek( 'last-li' ) ) {
* $p->add_class( 'last-li' );
* }
* $p->seek( 'resume' );
* $p->release_bookmark( 'last-li' );
* $p->release_bookmark( 'resume' );
* } else {
* $in_list = true;
* }
* }
*
* if ( 'LI' === $p->get_tag() ) {
* $p->set_bookmark( 'last-li' );
* }
* }
*
* Bookmarks intentionally hide the internal string offsets
* to which they refer. They are maintained internally as
* updates are applied to the HTML document and therefore
* retain their "position" - the location to which they
* originally pointed. The inability to use bookmarks with
* functions like `substr` is therefore intentional to guard
* against accidentally breaking the HTML.
*
* Because bookmarks allocate memory and require processing
* for every applied update, they are limited and require
* a name. They should not be created with programmatically-made
* names, such as "li_{$index}" with some loop. As a general
* rule they should only be created with string-literal names
* like "start-of-section" or "last-paragraph".
*
* Bookmarks are a powerful tool to enable complicated behavior.
* Consider double-checking that you need this tool if you are
* reaching for it, as inappropriate use could lead to broken
* HTML structure or unwanted processing overhead.
*
* Bookmarks cannot be set on tokens that do no appear in the original
* HTML text. For example, the HTML ` ` stops at tags `TABLE`,
* `TBODY`, `TR`, and `TD`. The `TBODY` and `TR` tags do not appear in
* the original HTML and cannot be used as bookmarks.
*
* @since 6.4.0
*
* @param string $bookmark_name Identifies this particular bookmark.
* @return bool Whether the bookmark was successfully created.
*/
public function set_bookmark( $bookmark_name ): bool {
if ( $this->is_virtual() ) {
_doing_it_wrong(
__METHOD__,
__( 'Cannot set bookmarks on tokens that do no appear in the original HTML text.' ),
'6.8.0'
);
return false;
}
return parent::set_bookmark( "_{$bookmark_name}" );
}
/**
* Checks whether a bookmark with the given name exists.
*
* @since 6.5.0
*
* @param string $bookmark_name Name to identify a bookmark that potentially exists.
* @return bool Whether that bookmark exists.
*/
public function has_bookmark( $bookmark_name ): bool {
return parent::has_bookmark( "_{$bookmark_name}" );
}
/*
* HTML Parsing Algorithms
*/
/**
* Closes a P element.
*
* @since 6.4.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#close-a-p-element
*/
private function close_a_p_element(): void {
$this->generate_implied_end_tags( 'P' );
$this->state->stack_of_open_elements->pop_until( 'P' );
}
/**
* Closes elements that have implied end tags.
*
* @since 6.4.0
* @since 6.7.0 Full spec support.
*
* @see https://html.spec.whatwg.org/#generate-implied-end-tags
*
* @param string|null $except_for_this_element Perform as if this element doesn't exist in the stack of open elements.
*/
private function generate_implied_end_tags( ?string $except_for_this_element = null ): void {
$elements_with_implied_end_tags = array(
'DD',
'DT',
'LI',
'OPTGROUP',
'OPTION',
'P',
'RB',
'RP',
'RT',
'RTC',
);
$no_exclusions = ! isset( $except_for_this_element );
while (
( $no_exclusions || ! $this->state->stack_of_open_elements->current_node_is( $except_for_this_element ) ) &&
in_array( $this->state->stack_of_open_elements->current_node()->node_name, $elements_with_implied_end_tags, true )
) {
$this->state->stack_of_open_elements->pop();
}
}
/**
* Closes elements that have implied end tags, thoroughly.
*
* See the HTML specification for an explanation why this is
* different from generating end tags in the normal sense.
*
* @since 6.4.0
* @since 6.7.0 Full spec support.
*
* @see WP_HTML_Processor::generate_implied_end_tags
* @see https://html.spec.whatwg.org/#generate-implied-end-tags
*/
private function generate_implied_end_tags_thoroughly(): void {
$elements_with_implied_end_tags = array(
'CAPTION',
'COLGROUP',
'DD',
'DT',
'LI',
'OPTGROUP',
'OPTION',
'P',
'RB',
'RP',
'RT',
'RTC',
'TBODY',
'TD',
'TFOOT',
'TH',
'THEAD',
'TR',
);
while ( in_array( $this->state->stack_of_open_elements->current_node()->node_name, $elements_with_implied_end_tags, true ) ) {
$this->state->stack_of_open_elements->pop();
}
}
/**
* Returns the adjusted current node.
*
* > The adjusted current node is the context element if the parser was created as
* > part of the HTML fragment parsing algorithm and the stack of open elements
* > has only one element in it (fragment case); otherwise, the adjusted current
* > node is the current node.
*
* @see https://html.spec.whatwg.org/#adjusted-current-node
*
* @since 6.7.0
*
* @return WP_HTML_Token|null The adjusted current node.
*/
private function get_adjusted_current_node(): ?WP_HTML_Token {
if ( isset( $this->context_node ) && 1 === $this->state->stack_of_open_elements->count() ) {
return $this->context_node;
}
return $this->state->stack_of_open_elements->current_node();
}
/**
* Reconstructs the active formatting elements.
*
* > This has the effect of reopening all the formatting elements that were opened
* > in the current body, cell, or caption (whichever is youngest) that haven't
* > been explicitly closed.
*
* @since 6.4.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#reconstruct-the-active-formatting-elements
*
* @return bool Whether any formatting elements needed to be reconstructed.
*/
private function reconstruct_active_formatting_elements(): bool {
/*
* > If there are no entries in the list of active formatting elements, then there is nothing
* > to reconstruct; stop this algorithm.
*/
if ( 0 === $this->state->active_formatting_elements->count() ) {
return false;
}
$last_entry = $this->state->active_formatting_elements->current_node();
if (
/*
* > If the last (most recently added) entry in the list of active formatting elements is a marker;
* > stop this algorithm.
*/
'marker' === $last_entry->node_name ||
/*
* > If the last (most recently added) entry in the list of active formatting elements is an
* > element that is in the stack of open elements, then there is nothing to reconstruct;
* > stop this algorithm.
*/
$this->state->stack_of_open_elements->contains_node( $last_entry )
) {
return false;
}
$this->bail( 'Cannot reconstruct active formatting elements when advancing and rewinding is required.' );
}
/**
* Runs the reset the insertion mode appropriately algorithm.
*
* @since 6.7.0
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#reset-the-insertion-mode-appropriately
*/
private function reset_insertion_mode_appropriately(): void {
// Set the first node.
$first_node = null;
foreach ( $this->state->stack_of_open_elements->walk_down() as $first_node ) {
break;
}
/*
* > 1. Let _last_ be false.
*/
$last = false;
foreach ( $this->state->stack_of_open_elements->walk_up() as $node ) {
/*
* > 2. Let _node_ be the last node in the stack of open elements.
* > 3. _Loop_: If _node_ is the first node in the stack of open elements, then set _last_
* > to true, and, if the parser was created as part of the HTML fragment parsing
* > algorithm (fragment case), set node to the context element passed to
* > that algorithm.
* > …
*/
if ( $node === $first_node ) {
$last = true;
if ( isset( $this->context_node ) ) {
$node = $this->context_node;
}
}
// All of the following rules are for matching HTML elements.
if ( 'html' !== $node->namespace ) {
continue;
}
switch ( $node->node_name ) {
/*
* > 4. If node is a `select` element, run these substeps:
* > 1. If _last_ is true, jump to the step below labeled done.
* > 2. Let _ancestor_ be _node_.
* > 3. _Loop_: If _ancestor_ is the first node in the stack of open elements,
* > jump to the step below labeled done.
* > 4. Let ancestor be the node before ancestor in the stack of open elements.
* > …
* > 7. Jump back to the step labeled _loop_.
* > 8. _Done_: Switch the insertion mode to "in select" and return.
*/
case 'SELECT':
if ( ! $last ) {
foreach ( $this->state->stack_of_open_elements->walk_up( $node ) as $ancestor ) {
if ( 'html' !== $ancestor->namespace ) {
continue;
}
switch ( $ancestor->node_name ) {
/*
* > 5. If _ancestor_ is a `template` node, jump to the step below
* > labeled _done_.
*/
case 'TEMPLATE':
break 2;
/*
* > 6. If _ancestor_ is a `table` node, switch the insertion mode to
* > "in select in table" and return.
*/
case 'TABLE':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE;
return;
}
}
}
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT;
return;
/*
* > 5. If _node_ is a `td` or `th` element and _last_ is false, then switch the
* > insertion mode to "in cell" and return.
*/
case 'TD':
case 'TH':
if ( ! $last ) {
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CELL;
return;
}
break;
/*
* > 6. If _node_ is a `tr` element, then switch the insertion mode to "in row"
* > and return.
*/
case 'TR':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
return;
/*
* > 7. If _node_ is a `tbody`, `thead`, or `tfoot` element, then switch the
* > insertion mode to "in table body" and return.
*/
case 'TBODY':
case 'THEAD':
case 'TFOOT':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
return;
/*
* > 8. If _node_ is a `caption` element, then switch the insertion mode to
* > "in caption" and return.
*/
case 'CAPTION':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION;
return;
/*
* > 9. If _node_ is a `colgroup` element, then switch the insertion mode to
* > "in column group" and return.
*/
case 'COLGROUP':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
return;
/*
* > 10. If _node_ is a `table` element, then switch the insertion mode to
* > "in table" and return.
*/
case 'TABLE':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
return;
/*
* > 11. If _node_ is a `template` element, then switch the insertion mode to the
* > current template insertion mode and return.
*/
case 'TEMPLATE':
$this->state->insertion_mode = end( $this->state->stack_of_template_insertion_modes );
return;
/*
* > 12. If _node_ is a `head` element and _last_ is false, then switch the
* > insertion mode to "in head" and return.
*/
case 'HEAD':
if ( ! $last ) {
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
return;
}
break;
/*
* > 13. If _node_ is a `body` element, then switch the insertion mode to "in body"
* > and return.
*/
case 'BODY':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
return;
/*
* > 14. If _node_ is a `frameset` element, then switch the insertion mode to
* > "in frameset" and return. (fragment case)
*/
case 'FRAMESET':
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET;
return;
/*
* > 15. If _node_ is an `html` element, run these substeps:
* > 1. If the head element pointer is null, switch the insertion mode to
* > "before head" and return. (fragment case)
* > 2. Otherwise, the head element pointer is not null, switch the insertion
* > mode to "after head" and return.
*/
case 'HTML':
$this->state->insertion_mode = isset( $this->state->head_element )
? WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD
: WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD;
return;
}
}
/*
* > 16. If _last_ is true, then switch the insertion mode to "in body"
* > and return. (fragment case)
*
* This is only reachable if `$last` is true, as per the fragment parsing case.
*/
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
}
/**
* Runs the adoption agency algorithm.
*
* @since 6.4.0
*
* @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
*
* @see https://html.spec.whatwg.org/#adoption-agency-algorithm
*/
private function run_adoption_agency_algorithm(): void {
$budget = 1000;
$subject = $this->get_tag();
$current_node = $this->state->stack_of_open_elements->current_node();
if (
// > If the current node is an HTML element whose tag name is subject
$current_node && $subject === $current_node->node_name &&
// > the current node is not in the list of active formatting elements
! $this->state->active_formatting_elements->contains_node( $current_node )
) {
$this->state->stack_of_open_elements->pop();
return;
}
$outer_loop_counter = 0;
while ( $budget-- > 0 ) {
if ( $outer_loop_counter++ >= 8 ) {
return;
}
/*
* > Let formatting element be the last element in the list of active formatting elements that:
* > - is between the end of the list and the last marker in the list,
* > if any, or the start of the list otherwise,
* > - and has the tag name subject.
*/
$formatting_element = null;
foreach ( $this->state->active_formatting_elements->walk_up() as $item ) {
if ( 'marker' === $item->node_name ) {
break;
}
if ( $subject === $item->node_name ) {
$formatting_element = $item;
break;
}
}
// > If there is no such element, then return and instead act as described in the "any other end tag" entry above.
if ( null === $formatting_element ) {
$this->bail( 'Cannot run adoption agency when "any other end tag" is required.' );
}
// > If formatting element is not in the stack of open elements, then this is a parse error; remove the element from the list, and return.
if ( ! $this->state->stack_of_open_elements->contains_node( $formatting_element ) ) {
$this->state->active_formatting_elements->remove_node( $formatting_element );
return;
}
// > If formatting element is in the stack of open elements, but the element is not in scope, then this is a parse error; return.
if ( ! $this->state->stack_of_open_elements->has_element_in_scope( $formatting_element->node_name ) ) {
return;
}
/*
* > Let furthest block be the topmost node in the stack of open elements that is lower in the stack
* > than formatting element, and is an element in the special category. There might not be one.
*/
$is_above_formatting_element = true;
$furthest_block = null;
foreach ( $this->state->stack_of_open_elements->walk_down() as $item ) {
if ( $is_above_formatting_element && $formatting_element->bookmark_name !== $item->bookmark_name ) {
continue;
}
if ( $is_above_formatting_element ) {
$is_above_formatting_element = false;
continue;
}
if ( self::is_special( $item ) ) {
$furthest_block = $item;
break;
}
}
/*
* > If there is no furthest block, then the UA must first pop all the nodes from the bottom of the
* > stack of open elements, from the current node up to and including formatting element, then
* > remove formatting element from the list of active formatting elements, and finally return.
*/
if ( null === $furthest_block ) {
foreach ( $this->state->stack_of_open_elements->walk_up() as $item ) {
$this->state->stack_of_open_elements->pop();
if ( $formatting_element->bookmark_name === $item->bookmark_name ) {
$this->state->active_formatting_elements->remove_node( $formatting_element );
return;
}
}
}
$this->bail( 'Cannot extract common ancestor in adoption agency algorithm.' );
}
$this->bail( 'Cannot run adoption agency when looping required.' );
}
/**
* Runs the "close the cell" algorithm.
*
* > Where the steps above say to close the cell, they mean to run the following algorithm:
* > 1. Generate implied end tags.
* > 2. If the current node is not now a td element or a th element, then this is a parse error.
* > 3. Pop elements from the stack of open elements stack until a td element or a th element has been popped from the stack.
* > 4. Clear the list of active formatting elements up to the last marker.
* > 5. Switch the insertion mode to "in row".
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#close-the-cell
*
* @since 6.7.0
*/
private function close_cell(): void {
$this->generate_implied_end_tags();
// @todo Parse error if the current node is a "td" or "th" element.
foreach ( $this->state->stack_of_open_elements->walk_up() as $element ) {
$this->state->stack_of_open_elements->pop();
if ( 'TD' === $element->node_name || 'TH' === $element->node_name ) {
break;
}
}
$this->state->active_formatting_elements->clear_up_to_last_marker();
$this->state->insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
}
/**
* Inserts an HTML element on the stack of open elements.
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#insert-a-foreign-element
*
* @param WP_HTML_Token $token Name of bookmark pointing to element in original input HTML.
*/
private function insert_html_element( WP_HTML_Token $token ): void {
$this->state->stack_of_open_elements->push( $token );
}
/**
* Inserts a foreign element on to the stack of open elements.
*
* @since 6.7.0
*
* @see https://html.spec.whatwg.org/#insert-a-foreign-element
*
* @param WP_HTML_Token $token Insert this token. The token's namespace and
* insertion point will be updated correctly.
* @param bool $only_add_to_element_stack Whether to skip the "insert an element at the adjusted
* insertion location" algorithm when adding this element.
*/
private function insert_foreign_element( WP_HTML_Token $token, bool $only_add_to_element_stack ): void {
$adjusted_current_node = $this->get_adjusted_current_node();
$token->namespace = $adjusted_current_node ? $adjusted_current_node->namespace : 'html';
if ( $this->is_mathml_integration_point() ) {
$token->integration_node_type = 'math';
} elseif ( $this->is_html_integration_point() ) {
$token->integration_node_type = 'html';
}
if ( false === $only_add_to_element_stack ) {
/*
* @todo Implement the "appropriate place for inserting a node" and the
* "insert an element at the adjusted insertion location" algorithms.
*
* These algorithms mostly impacts DOM tree construction and not the HTML API.
* Here, there's no DOM node onto which the element will be appended, so the
* parser will skip this step.
*
* @see https://html.spec.whatwg.org/#insert-an-element-at-the-adjusted-insertion-location
*/
}
$this->insert_html_element( $token );
}
/**
* Inserts a virtual element on the stack of open elements.
*
* @since 6.7.0
*
* @param string $token_name Name of token to create and insert into the stack of open elements.
* @param string|null $bookmark_name Optional. Name to give bookmark for created virtual node.
* Defaults to auto-creating a bookmark name.
* @return WP_HTML_Token Newly-created virtual token.
*/
private function insert_virtual_node( $token_name, $bookmark_name = null ): WP_HTML_Token {
$here = $this->bookmarks[ $this->state->current_token->bookmark_name ];
$name = $bookmark_name ?? $this->bookmark_token();
$this->bookmarks[ $name ] = new WP_HTML_Span( $here->start, 0 );
$token = new WP_HTML_Token( $name, $token_name, false );
$this->insert_html_element( $token );
return $token;
}
/*
* HTML Specification Helpers
*/
/**
* Indicates if the current token is a MathML integration point.
*
* @since 6.7.0
*
* @see https://html.spec.whatwg.org/#mathml-text-integration-point
*
* @return bool Whether the current token is a MathML integration point.
*/
private function is_mathml_integration_point(): bool {
$current_token = $this->state->current_token;
if ( ! isset( $current_token ) ) {
return false;
}
if ( 'math' !== $current_token->namespace || 'M' !== $current_token->node_name[0] ) {
return false;
}
$tag_name = $current_token->node_name;
return (
'MI' === $tag_name ||
'MO' === $tag_name ||
'MN' === $tag_name ||
'MS' === $tag_name ||
'MTEXT' === $tag_name
);
}
/**
* Indicates if the current token is an HTML integration point.
*
* Note that this method must be an instance method with access
* to the current token, since it needs to examine the attributes
* of the currently-matched tag, if it's in the MathML namespace.
* Otherwise it would be required to scan the HTML and ensure that
* no other accounting is overlooked.
*
* @since 6.7.0
*
* @see https://html.spec.whatwg.org/#html-integration-point
*
* @return bool Whether the current token is an HTML integration point.
*/
private function is_html_integration_point(): bool {
$current_token = $this->state->current_token;
if ( ! isset( $current_token ) ) {
return false;
}
if ( 'html' === $current_token->namespace ) {
return false;
}
$tag_name = $current_token->node_name;
if ( 'svg' === $current_token->namespace ) {
return (
'DESC' === $tag_name ||
'FOREIGNOBJECT' === $tag_name ||
'TITLE' === $tag_name
);
}
if ( 'math' === $current_token->namespace ) {
if ( 'ANNOTATION-XML' !== $tag_name ) {
return false;
}
$encoding = $this->get_attribute( 'encoding' );
return (
is_string( $encoding ) &&
(
0 === strcasecmp( $encoding, 'application/xhtml+xml' ) ||
0 === strcasecmp( $encoding, 'text/html' )
)
);
}
$this->bail( 'Should not have reached end of HTML Integration Point detection: check HTML API code.' );
// This unnecessary return prevents tools from inaccurately reporting type errors.
return false;
}
/**
* Returns whether an element of a given name is in the HTML special category.
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#special
*
* @param WP_HTML_Token|string $tag_name Node to check, or only its name if in the HTML namespace.
* @return bool Whether the element of the given name is in the special category.
*/
public static function is_special( $tag_name ): bool {
if ( is_string( $tag_name ) ) {
$tag_name = strtoupper( $tag_name );
} else {
$tag_name = 'html' === $tag_name->namespace
? strtoupper( $tag_name->node_name )
: "{$tag_name->namespace} {$tag_name->node_name}";
}
return (
'ADDRESS' === $tag_name ||
'APPLET' === $tag_name ||
'AREA' === $tag_name ||
'ARTICLE' === $tag_name ||
'ASIDE' === $tag_name ||
'BASE' === $tag_name ||
'BASEFONT' === $tag_name ||
'BGSOUND' === $tag_name ||
'BLOCKQUOTE' === $tag_name ||
'BODY' === $tag_name ||
'BR' === $tag_name ||
'BUTTON' === $tag_name ||
'CAPTION' === $tag_name ||
'CENTER' === $tag_name ||
'COL' === $tag_name ||
'COLGROUP' === $tag_name ||
'DD' === $tag_name ||
'DETAILS' === $tag_name ||
'DIR' === $tag_name ||
'DIV' === $tag_name ||
'DL' === $tag_name ||
'DT' === $tag_name ||
'EMBED' === $tag_name ||
'FIELDSET' === $tag_name ||
'FIGCAPTION' === $tag_name ||
'FIGURE' === $tag_name ||
'FOOTER' === $tag_name ||
'FORM' === $tag_name ||
'FRAME' === $tag_name ||
'FRAMESET' === $tag_name ||
'H1' === $tag_name ||
'H2' === $tag_name ||
'H3' === $tag_name ||
'H4' === $tag_name ||
'H5' === $tag_name ||
'H6' === $tag_name ||
'HEAD' === $tag_name ||
'HEADER' === $tag_name ||
'HGROUP' === $tag_name ||
'HR' === $tag_name ||
'HTML' === $tag_name ||
'IFRAME' === $tag_name ||
'IMG' === $tag_name ||
'INPUT' === $tag_name ||
'KEYGEN' === $tag_name ||
'LI' === $tag_name ||
'LINK' === $tag_name ||
'LISTING' === $tag_name ||
'MAIN' === $tag_name ||
'MARQUEE' === $tag_name ||
'MENU' === $tag_name ||
'META' === $tag_name ||
'NAV' === $tag_name ||
'NOEMBED' === $tag_name ||
'NOFRAMES' === $tag_name ||
'NOSCRIPT' === $tag_name ||
'OBJECT' === $tag_name ||
'OL' === $tag_name ||
'P' === $tag_name ||
'PARAM' === $tag_name ||
'PLAINTEXT' === $tag_name ||
'PRE' === $tag_name ||
'SCRIPT' === $tag_name ||
'SEARCH' === $tag_name ||
'SECTION' === $tag_name ||
'SELECT' === $tag_name ||
'SOURCE' === $tag_name ||
'STYLE' === $tag_name ||
'SUMMARY' === $tag_name ||
'TABLE' === $tag_name ||
'TBODY' === $tag_name ||
'TD' === $tag_name ||
'TEMPLATE' === $tag_name ||
'TEXTAREA' === $tag_name ||
'TFOOT' === $tag_name ||
'TH' === $tag_name ||
'THEAD' === $tag_name ||
'TITLE' === $tag_name ||
'TR' === $tag_name ||
'TRACK' === $tag_name ||
'UL' === $tag_name ||
'WBR' === $tag_name ||
'XMP' === $tag_name ||
// MathML.
'math MI' === $tag_name ||
'math MO' === $tag_name ||
'math MN' === $tag_name ||
'math MS' === $tag_name ||
'math MTEXT' === $tag_name ||
'math ANNOTATION-XML' === $tag_name ||
// SVG.
'svg DESC' === $tag_name ||
'svg FOREIGNOBJECT' === $tag_name ||
'svg TITLE' === $tag_name
);
}
/**
* Returns whether a given element is an HTML Void Element
*
* > area, base, br, col, embed, hr, img, input, link, meta, source, track, wbr
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#void-elements
*
* @param string $tag_name Name of HTML tag to check.
* @return bool Whether the given tag is an HTML Void Element.
*/
public static function is_void( $tag_name ): bool {
$tag_name = strtoupper( $tag_name );
return (
'AREA' === $tag_name ||
'BASE' === $tag_name ||
'BASEFONT' === $tag_name || // Obsolete but still treated as void.
'BGSOUND' === $tag_name || // Obsolete but still treated as void.
'BR' === $tag_name ||
'COL' === $tag_name ||
'EMBED' === $tag_name ||
'FRAME' === $tag_name ||
'HR' === $tag_name ||
'IMG' === $tag_name ||
'INPUT' === $tag_name ||
'KEYGEN' === $tag_name || // Obsolete but still treated as void.
'LINK' === $tag_name ||
'META' === $tag_name ||
'PARAM' === $tag_name || // Obsolete but still treated as void.
'SOURCE' === $tag_name ||
'TRACK' === $tag_name ||
'WBR' === $tag_name
);
}
/**
* Gets an encoding from a given string.
*
* This is an algorithm defined in the WHAT-WG specification.
*
* Example:
*
* 'UTF-8' === self::get_encoding( 'utf8' );
* 'UTF-8' === self::get_encoding( " \tUTF-8 " );
* null === self::get_encoding( 'UTF-7' );
* null === self::get_encoding( 'utf8; charset=' );
*
* @see https://encoding.spec.whatwg.org/#concept-encoding-get
*
* @todo As this parser only supports UTF-8, only the UTF-8
* encodings are detected. Add more as desired, but the
* parser will bail on non-UTF-8 encodings.
*
* @since 6.7.0
*
* @param string $label A string which may specify a known encoding.
* @return string|null Known encoding if matched, otherwise null.
*/
protected static function get_encoding( string $label ): ?string {
/*
* > Remove any leading and trailing ASCII whitespace from label.
*/
$label = trim( $label, " \t\f\r\n" );
/*
* > If label is an ASCII case-insensitive match for any of the labels listed in the
* > table below, then return the corresponding encoding; otherwise return failure.
*/
switch ( strtolower( $label ) ) {
case 'unicode-1-1-utf-8':
case 'unicode11utf8':
case 'unicode20utf8':
case 'utf-8':
case 'utf8':
case 'x-unicode20utf8':
return 'UTF-8';
default:
return null;
}
}
/*
* Constants that would pollute the top of the class if they were found there.
*/
/**
* Indicates that the next HTML token should be parsed and processed.
*
* @since 6.4.0
*
* @var string
*/
const PROCESS_NEXT_NODE = 'process-next-node';
/**
* Indicates that the current HTML token should be reprocessed in the newly-selected insertion mode.
*
* @since 6.4.0
*
* @var string
*/
const REPROCESS_CURRENT_NODE = 'reprocess-current-node';
/**
* Indicates that the current HTML token should be processed without advancing the parser.
*
* @since 6.5.0
*
* @var string
*/
const PROCESS_CURRENT_NODE = 'process-current-node';
/**
* Indicates that the parser encountered unsupported markup and has bailed.
*
* @since 6.4.0
*
* @var string
*/
const ERROR_UNSUPPORTED = 'unsupported';
/**
* Indicates that the parser encountered more HTML tokens than it
* was able to process and has bailed.
*
* @since 6.4.0
*
* @var string
*/
const ERROR_EXCEEDED_MAX_BOOKMARKS = 'exceeded-max-bookmarks';
/**
* Unlock code that must be passed into the constructor to create this class.
*
* This class extends the WP_HTML_Tag_Processor, which has a public class
* constructor. Therefore, it's not possible to have a private constructor here.
*
* This unlock code is used to ensure that anyone calling the constructor is
* doing so with a full understanding that it's intended to be a private API.
*
* @access private
*/
const CONSTRUCTOR_UNLOCK_CODE = 'Use WP_HTML_Processor::create_fragment() instead of calling the class constructor directly.';
}
PK ÷L\¢†lRG, G, ! class-wp-html-processor-state.phpnu „[µü¤
*/
public $stack_of_template_insertion_modes = array();
/**
* Tracks open elements while scanning HTML.
*
* This property is initialized in the constructor and never null.
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#stack-of-open-elements
*
* @var WP_HTML_Open_Elements
*/
public $stack_of_open_elements;
/**
* Tracks open formatting elements, used to handle mis-nested formatting element tags.
*
* This property is initialized in the constructor and never null.
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#list-of-active-formatting-elements
*
* @var WP_HTML_Active_Formatting_Elements
*/
public $active_formatting_elements;
/**
* Refers to the currently-matched tag, if any.
*
* @since 6.4.0
*
* @var WP_HTML_Token|null
*/
public $current_token = null;
/**
* Tree construction insertion mode.
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#insertion-mode
*
* @var string
*/
public $insertion_mode = self::INSERTION_MODE_INITIAL;
/**
* Context node initializing fragment parser, if created as a fragment parser.
*
* @since 6.4.0
* @deprecated 6.8.0 WP_HTML_Processor tracks the context_node internally.
*
* @var null
*/
public $context_node = null;
/**
* The recognized encoding of the input byte stream.
*
* > The stream of code points that comprises the input to the tokenization
* > stage will be initially seen by the user agent as a stream of bytes
* > (typically coming over the network or from the local file system).
* > The bytes encode the actual characters according to a particular character
* > encoding, which the user agent uses to decode the bytes into characters.
*
* @since 6.7.0
*
* @var string|null
*/
public $encoding = null;
/**
* The parser's confidence in the input encoding.
*
* > When the HTML parser is decoding an input byte stream, it uses a character
* > encoding and a confidence. The confidence is either tentative, certain, or
* > irrelevant. The encoding used, and whether the confidence in that encoding
* > is tentative or certain, is used during the parsing to determine whether to
* > change the encoding. If no encoding is necessary, e.g. because the parser is
* > operating on a Unicode stream and doesn't have to use a character encoding
* > at all, then the confidence is irrelevant.
*
* @since 6.7.0
*
* @var string
*/
public $encoding_confidence = 'tentative';
/**
* HEAD element pointer.
*
* @since 6.7.0
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#head-element-pointer
*
* @var WP_HTML_Token|null
*/
public $head_element = null;
/**
* FORM element pointer.
*
* > points to the last form element that was opened and whose end tag has
* > not yet been seen. It is used to make form controls associate with
* > forms in the face of dramatically bad markup, for historical reasons.
* > It is ignored inside template elements.
*
* @todo This may be invalidated by a seek operation.
*
* @see https://html.spec.whatwg.org/#form-element-pointer
*
* @since 6.7.0
*
* @var WP_HTML_Token|null
*/
public $form_element = null;
/**
* The frameset-ok flag indicates if a `FRAMESET` element is allowed in the current state.
*
* > The frameset-ok flag is set to "ok" when the parser is created. It is set to "not ok" after certain tokens are seen.
*
* @since 6.4.0
*
* @see https://html.spec.whatwg.org/#frameset-ok-flag
*
* @var bool
*/
public $frameset_ok = true;
/**
* Constructor - creates a new and empty state value.
*
* @since 6.4.0
*
* @see WP_HTML_Processor
*/
public function __construct() {
$this->stack_of_open_elements = new WP_HTML_Open_Elements();
$this->active_formatting_elements = new WP_HTML_Active_Formatting_Elements();
}
}
PK ÷L\_Yï€XN XN class-wp-html-tag-processor.phpnu „[µü¤ "c" not " c".
* This would increase the size of the changes for some operations but leave more
* natural-looking output HTML.
*
* @package WordPress
* @subpackage HTML-API
* @since 6.2.0
*/
/**
* Core class used to modify attributes in an HTML document for tags matching a query.
*
* ## Usage
*
* Use of this class requires three steps:
*
* 1. Create a new class instance with your input HTML document.
* 2. Find the tag(s) you are looking for.
* 3. Request changes to the attributes in those tag(s).
*
* Example:
*
* $tags = new WP_HTML_Tag_Processor( $html );
* if ( $tags->next_tag( 'option' ) ) {
* $tags->set_attribute( 'selected', true );
* }
*
* ### Finding tags
*
* The `next_tag()` function moves the internal cursor through
* your input HTML document until it finds a tag meeting any of
* the supplied restrictions in the optional query argument. If
* no argument is provided then it will find the next HTML tag,
* regardless of what kind it is.
*
* If you want to _find whatever the next tag is_:
*
* $tags->next_tag();
*
* | Goal | Query |
* |-----------------------------------------------------------|---------------------------------------------------------------------------------|
* | Find any tag. | `$tags->next_tag();` |
* | Find next image tag. | `$tags->next_tag( array( 'tag_name' => 'img' ) );` |
* | Find next image tag (without passing the array). | `$tags->next_tag( 'img' );` |
* | Find next tag containing the `fullwidth` CSS class. | `$tags->next_tag( array( 'class_name' => 'fullwidth' ) );` |
* | Find next image tag containing the `fullwidth` CSS class. | `$tags->next_tag( array( 'tag_name' => 'img', 'class_name' => 'fullwidth' ) );` |
*
* If a tag was found meeting your criteria then `next_tag()`
* will return `true` and you can proceed to modify it. If it
* returns `false`, however, it failed to find the tag and
* moved the cursor to the end of the file.
*
* Once the cursor reaches the end of the file the processor
* is done and if you want to reach an earlier tag you will
* need to recreate the processor and start over, as it's
* unable to back up or move in reverse.
*
* See the section on bookmarks for an exception to this
* no-backing-up rule.
*
* #### Custom queries
*
* Sometimes it's necessary to further inspect an HTML tag than
* the query syntax here permits. In these cases one may further
* inspect the search results using the read-only functions
* provided by the processor or external state or variables.
*
* Example:
*
* // Paint up to the first five DIV or SPAN tags marked with the "jazzy" style.
* $remaining_count = 5;
* while ( $remaining_count > 0 && $tags->next_tag() ) {
* if (
* ( 'DIV' === $tags->get_tag() || 'SPAN' === $tags->get_tag() ) &&
* 'jazzy' === $tags->get_attribute( 'data-style' )
* ) {
* $tags->add_class( 'theme-style-everest-jazz' );
* $remaining_count--;
* }
* }
*
* `get_attribute()` will return `null` if the attribute wasn't present
* on the tag when it was called. It may return `""` (the empty string)
* in cases where the attribute was present but its value was empty.
* For boolean attributes, those whose name is present but no value is
* given, it will return `true` (the only way to set `false` for an
* attribute is to remove it).
*
* #### When matching fails
*
* When `next_tag()` returns `false` it could mean different things:
*
* - The requested tag wasn't found in the input document.
* - The input document ended in the middle of an HTML syntax element.
*
* When a document ends in the middle of a syntax element it will pause
* the processor. This is to make it possible in the future to extend the
* input document and proceed - an important requirement for chunked
* streaming parsing of a document.
*
* Example:
*
* $processor = new WP_HTML_Tag_Processor( 'This ` inside an HTML comment.
* - STYLE content is raw text.
* - TITLE content is plain text but character references are decoded.
* - TEXTAREA content is plain text but character references are decoded.
* - XMP (deprecated) content is raw text.
*
* ### Modifying HTML attributes for a found tag
*
* Once you've found the start of an opening tag you can modify
* any number of the attributes on that tag. You can set a new
* value for an attribute, remove the entire attribute, or do
* nothing and move on to the next opening tag.
*
* Example:
*
* if ( $tags->next_tag( array( 'class_name' => 'wp-group-block' ) ) ) {
* $tags->set_attribute( 'title', 'This groups the contained content.' );
* $tags->remove_attribute( 'data-test-id' );
* }
*
* If `set_attribute()` is called for an existing attribute it will
* overwrite the existing value. Similarly, calling `remove_attribute()`
* for a non-existing attribute has no effect on the document. Both
* of these methods are safe to call without knowing if a given attribute
* exists beforehand.
*
* ### Modifying CSS classes for a found tag
*
* The tag processor treats the `class` attribute as a special case.
* Because it's a common operation to add or remove CSS classes, this
* interface adds helper methods to make that easier.
*
* As with attribute values, adding or removing CSS classes is a safe
* operation that doesn't require checking if the attribute or class
* exists before making changes. If removing the only class then the
* entire `class` attribute will be removed.
*
* Example:
*
* // from `
Yippee! `
* // to `
Yippee! `
* $tags->add_class( 'is-active' );
*
* // from `
Yippee! `
* // to `
Yippee! `
* $tags->add_class( 'is-active' );
*
* // from `
Yippee! `
* // to `
Yippee! `
* $tags->add_class( 'is-active' );
*
* // from `
`
* // to `
* $tags->remove_class( 'rugby' );
*
* // from `
`
* // to `
* $tags->remove_class( 'rugby' );
*
* // from `
`
* // to `
* $tags->remove_class( 'rugby' );
*
* When class changes are enqueued but a direct change to `class` is made via
* `set_attribute` then the changes to `set_attribute` (or `remove_attribute`)
* will take precedence over those made through `add_class` and `remove_class`.
*
* ### Bookmarks
*
* While scanning through the input HTMl document it's possible to set
* a named bookmark when a particular tag is found. Later on, after
* continuing to scan other tags, it's possible to `seek` to one of
* the set bookmarks and then proceed again from that point forward.
*
* Because bookmarks create processing overhead one should avoid
* creating too many of them. As a rule, create only bookmarks
* of known string literal names; avoid creating "mark_{$index}"
* and so on. It's fine from a performance standpoint to create a
* bookmark and update it frequently, such as within a loop.
*
* $total_todos = 0;
* while ( $p->next_tag( array( 'tag_name' => 'UL', 'class_name' => 'todo' ) ) ) {
* $p->set_bookmark( 'list-start' );
* while ( $p->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
* if ( 'UL' === $p->get_tag() && $p->is_tag_closer() ) {
* $p->set_bookmark( 'list-end' );
* $p->seek( 'list-start' );
* $p->set_attribute( 'data-contained-todos', (string) $total_todos );
* $total_todos = 0;
* $p->seek( 'list-end' );
* break;
* }
*
* if ( 'LI' === $p->get_tag() && ! $p->is_tag_closer() ) {
* $total_todos++;
* }
* }
* }
*
* ## Tokens and finer-grained processing.
*
* It's possible to scan through every lexical token in the
* HTML document using the `next_token()` function. This
* alternative form takes no argument and provides no built-in
* query syntax.
*
* Example:
*
* $title = '(untitled)';
* $text = '';
* while ( $processor->next_token() ) {
* switch ( $processor->get_token_name() ) {
* case '#text':
* $text .= $processor->get_modifiable_text();
* break;
*
* case 'BR':
* $text .= "\n";
* break;
*
* case 'TITLE':
* $title = $processor->get_modifiable_text();
* break;
* }
* }
* return trim( "# {$title}\n\n{$text}" );
*
* ### Tokens and _modifiable text_.
*
* #### Special "atomic" HTML elements.
*
* Not all HTML elements are able to contain other elements inside of them.
* For instance, the contents inside a TITLE element are plaintext (except
* that character references like & will be decoded). This means that
* if the string `
` appears inside a TITLE element, then it's not an
* image tag, but rather it's text describing an image tag. Likewise, the
* contents of a SCRIPT or STYLE element are handled entirely separately in
* a browser than the contents of other elements because they represent a
* different language than HTML.
*
* For these elements the Tag Processor treats the entire sequence as one,
* from the opening tag, including its contents, through its closing tag.
* This means that the it's not possible to match the closing tag for a
* SCRIPT element unless it's unexpected; the Tag Processor already matched
* it when it found the opening tag.
*
* The inner contents of these elements are that element's _modifiable text_.
*
* The special elements are:
* - `SCRIPT` whose contents are treated as raw plaintext but supports a legacy
* style of including JavaScript inside of HTML comments to avoid accidentally
* closing the SCRIPT from inside a JavaScript string. E.g. `console.log( '' )`.
* - `TITLE` and `TEXTAREA` whose contents are treated as plaintext and then any
* character references are decoded. E.g. `1 < 2 < 3` becomes `1 < 2 < 3`.
* - `IFRAME`, `NOSCRIPT`, `NOEMBED`, `NOFRAME`, `STYLE` whose contents are treated as
* raw plaintext and left as-is. E.g. `1 < 2 < 3` remains `1 < 2 < 3`.
*
* #### Other tokens with modifiable text.
*
* There are also non-elements which are void/self-closing in nature and contain
* modifiable text that is part of that individual syntax token itself.
*
* - `#text` nodes, whose entire token _is_ the modifiable text.
* - HTML comments and tokens that become comments due to some syntax error. The
* text for these tokens is the portion of the comment inside of the syntax.
* E.g. for `` the text is `" comment "` (note the spaces are included).
* - `CDATA` sections, whose text is the content inside of the section itself. E.g. for
* `` the text is `"some content"` (with restrictions [1]).
* - "Funky comments," which are a special case of invalid closing tags whose name is
* invalid. The text for these nodes is the text that a browser would transform into
* an HTML comment when parsing. E.g. for `` the text is `%post_author`.
* - `DOCTYPE` declarations like `
` which have no closing tag.
* - XML Processing instruction nodes like `` (with restrictions [2]).
* - The empty end tag `` which is ignored in the browser and DOM.
*
* [1]: There are no CDATA sections in HTML. When encountering `` becomes a bogus HTML comment, meaning there can be no CDATA
* section in an HTML document containing `>`. The Tag Processor will first find
* all valid and bogus HTML comments, and then if the comment _would_ have been a
* CDATA section _were they to exist_, it will indicate this as the type of comment.
*
* [2]: XML allows a broader range of characters in a processing instruction's target name
* and disallows "xml" as a name, since it's special. The Tag Processor only recognizes
* target names with an ASCII-representable subset of characters. It also exhibits the
* same constraint as with CDATA sections, in that `>` cannot exist within the token
* since Processing Instructions do no exist within HTML and their syntax transforms
* into a bogus comment in the DOM.
*
* ## Design and limitations
*
* The Tag Processor is designed to linearly scan HTML documents and tokenize
* HTML tags and their attributes. It's designed to do this as efficiently as
* possible without compromising parsing integrity. Therefore it will be
* slower than some methods of modifying HTML, such as those incorporating
* over-simplified PCRE patterns, but will not introduce the defects and
* failures that those methods bring in, which lead to broken page renders
* and often to security vulnerabilities. On the other hand, it will be faster
* than full-blown HTML parsers such as DOMDocument and use considerably
* less memory. It requires a negligible memory overhead, enough to consider
* it a zero-overhead system.
*
* The performance characteristics are maintained by avoiding tree construction
* and semantic cleanups which are specified in HTML5. Because of this, for
* example, it's not possible for the Tag Processor to associate any given
* opening tag with its corresponding closing tag, or to return the inner markup
* inside an element. Systems may be built on top of the Tag Processor to do
* this, but the Tag Processor is and should be constrained so it can remain an
* efficient, low-level, and reliable HTML scanner.
*
* The Tag Processor's design incorporates a "garbage-in-garbage-out" philosophy.
* HTML5 specifies that certain invalid content be transformed into different forms
* for display, such as removing null bytes from an input document and replacing
* invalid characters with the Unicode replacement character `U+FFFD` (visually "�").
* Where errors or transformations exist within the HTML5 specification, the Tag Processor
* leaves those invalid inputs untouched, passing them through to the final browser
* to handle. While this implies that certain operations will be non-spec-compliant,
* such as reading the value of an attribute with invalid content, it also preserves a
* simplicity and efficiency for handling those error cases.
*
* Most operations within the Tag Processor are designed to minimize the difference
* between an input and output document for any given change. For example, the
* `add_class` and `remove_class` methods preserve whitespace and the class ordering
* within the `class` attribute; and when encountering tags with duplicated attributes,
* the Tag Processor will leave those invalid duplicate attributes where they are but
* update the proper attribute which the browser will read for parsing its value. An
* exception to this rule is that all attribute updates store their values as
* double-quoted strings, meaning that attributes on input with single-quoted or
* unquoted values will appear in the output with double-quotes.
*
* ### Scripting Flag
*
* The Tag Processor parses HTML with the "scripting flag" disabled. This means
* that it doesn't run any scripts while parsing the page. In a browser with
* JavaScript enabled, for example, the script can change the parse of the
* document as it loads. On the server, however, evaluating JavaScript is not
* only impractical, but also unwanted.
*
* Practically this means that the Tag Processor will descend into NOSCRIPT
* elements and process its child tags. Were the scripting flag enabled, such
* as in a typical browser, the contents of NOSCRIPT are skipped entirely.
*
* This allows the HTML API to process the content that will be presented in
* a browser when scripting is disabled, but it offers a different view of a
* page than most browser sessions will experience. E.g. the tags inside the
* NOSCRIPT disappear.
*
* ### Text Encoding
*
* The Tag Processor assumes that the input HTML document is encoded with a
* text encoding compatible with 7-bit ASCII's '<', '>', '&', ';', '/', '=',
* "'", '"', 'a' - 'z', 'A' - 'Z', and the whitespace characters ' ', tab,
* carriage-return, newline, and form-feed.
*
* In practice, this includes almost every single-byte encoding as well as
* UTF-8. Notably, however, it does not include UTF-16. If providing input
* that's incompatible, then convert the encoding beforehand.
*
* @since 6.2.0
* @since 6.2.1 Fix: Support for various invalid comments; attribute updates are case-insensitive.
* @since 6.3.2 Fix: Skip HTML-like content inside rawtext elements such as STYLE.
* @since 6.5.0 Pauses processor when input ends in an incomplete syntax token.
* Introduces "special" elements which act like void elements, e.g. TITLE, STYLE.
* Allows scanning through all tokens and processing modifiable text, where applicable.
*/
class WP_HTML_Tag_Processor {
/**
* The maximum number of bookmarks allowed to exist at
* any given time.
*
* @since 6.2.0
* @var int
*
* @see WP_HTML_Tag_Processor::set_bookmark()
*/
const MAX_BOOKMARKS = 10;
/**
* Maximum number of times seek() can be called.
* Prevents accidental infinite loops.
*
* @since 6.2.0
* @var int
*
* @see WP_HTML_Tag_Processor::seek()
*/
const MAX_SEEK_OPS = 1000;
/**
* The HTML document to parse.
*
* @since 6.2.0
* @var string
*/
protected $html;
/**
* The last query passed to next_tag().
*
* @since 6.2.0
* @var array|null
*/
private $last_query;
/**
* The tag name this processor currently scans for.
*
* @since 6.2.0
* @var string|null
*/
private $sought_tag_name;
/**
* The CSS class name this processor currently scans for.
*
* @since 6.2.0
* @var string|null
*/
private $sought_class_name;
/**
* The match offset this processor currently scans for.
*
* @since 6.2.0
* @var int|null
*/
private $sought_match_offset;
/**
* Whether to visit tag closers, e.g. ` implicitly closes any open `P` element.
*
* - In `QUIRKS_MODE`:
* - CSS class and ID selectors match match in an ASCII case-insensitive manner.
* - A TABLE start tag `` opens a `TABLE` element as a child of a `P`
* element if one is open.
*
* Quirks and no-quirks mode are thus mostly about styling, but have an impact when
* tables are found inside paragraph elements.
*
* @see self::QUIRKS_MODE
* @see self::NO_QUIRKS_MODE
*
* @since 6.7.0
*
* @var string
*/
protected $compat_mode = self::NO_QUIRKS_MODE;
/**
* Indicates whether the parser is inside foreign content,
* e.g. inside an SVG or MathML element.
*
* One of 'html', 'svg', or 'math'.
*
* Several parsing rules change based on whether the parser
* is inside foreign content, including whether CDATA sections
* are allowed and whether a self-closing flag indicates that
* an element has no content.
*
* @since 6.7.0
*
* @var string
*/
private $parsing_namespace = 'html';
/**
* What kind of syntax token became an HTML comment.
*
* Since there are many ways in which HTML syntax can create an HTML comment,
* this indicates which of those caused it. This allows the Tag Processor to
* represent more from the original input document than would appear in the DOM.
*
* @since 6.5.0
*
* @var string|null
*/
protected $comment_type = null;
/**
* What kind of text the matched text node represents, if it was subdivided.
*
* @see self::TEXT_IS_NULL_SEQUENCE
* @see self::TEXT_IS_WHITESPACE
* @see self::TEXT_IS_GENERIC
* @see self::subdivide_text_appropriately
*
* @since 6.7.0
*
* @var string
*/
protected $text_node_classification = self::TEXT_IS_GENERIC;
/**
* How many bytes from the original HTML document have been read and parsed.
*
* This value points to the latest byte offset in the input document which
* has been already parsed. It is the internal cursor for the Tag Processor
* and updates while scanning through the HTML tokens.
*
* @since 6.2.0
* @var int
*/
private $bytes_already_parsed = 0;
/**
* Byte offset in input document where current token starts.
*
* Example:
*
* ...
* 01234
* - token starts at 0
*
* @since 6.5.0
*
* @var int|null
*/
private $token_starts_at;
/**
* Byte length of current token.
*
* Example:
*
*
...
* 012345678901234
* - token length is 14 - 0 = 14
*
* a is a token.
* 0123456789 123456789 123456789
* - token length is 17 - 2 = 15
*
* @since 6.5.0
*
* @var int|null
*/
private $token_length;
/**
* Byte offset in input document where current tag name starts.
*
* Example:
*
*
...
* 01234
* - tag name starts at 1
*
* @since 6.2.0
*
* @var int|null
*/
private $tag_name_starts_at;
/**
* Byte length of current tag name.
*
* Example:
*
*
...
* 01234
* --- tag name length is 3
*
* @since 6.2.0
*
* @var int|null
*/
private $tag_name_length;
/**
* Byte offset into input document where current modifiable text starts.
*
* @since 6.5.0
*
* @var int
*/
private $text_starts_at;
/**
* Byte length of modifiable text.
*
* @since 6.5.0
*
* @var int
*/
private $text_length;
/**
* Whether the current tag is an opening tag, e.g.
, or a closing tag, e.g.
.
*
* @var bool
*/
private $is_closing_tag;
/**
* Lazily-built index of attributes found within an HTML tag, keyed by the attribute name.
*
* Example:
*
* // Supposing the parser is working through this content
* // and stops after recognizing the `id` attribute.
* //
* // ^ parsing will continue from this point.
* $this->attributes = array(
* 'id' => new WP_HTML_Attribute_Token( 'id', 9, 6, 5, 11, false )
* );
*
* // When picking up parsing again, or when asking to find the
* // `class` attribute we will continue and add to this array.
* $this->attributes = array(
* 'id' => new WP_HTML_Attribute_Token( 'id', 9, 6, 5, 11, false ),
* 'class' => new WP_HTML_Attribute_Token( 'class', 23, 7, 17, 13, false )
* );
*
* // Note that only the `class` attribute value is stored in the index.
* // That's because it is the only value used by this class at the moment.
*
* @since 6.2.0
* @var WP_HTML_Attribute_Token[]
*/
private $attributes = array();
/**
* Tracks spans of duplicate attributes on a given tag, used for removing
* all copies of an attribute when calling `remove_attribute()`.
*
* @since 6.3.2
*
* @var (WP_HTML_Span[])[]|null
*/
private $duplicate_attributes = null;
/**
* Which class names to add or remove from a tag.
*
* These are tracked separately from attribute updates because they are
* semantically distinct, whereas this interface exists for the common
* case of adding and removing class names while other attributes are
* generally modified as with DOM `setAttribute` calls.
*
* When modifying an HTML document these will eventually be collapsed
* into a single `set_attribute( 'class', $changes )` call.
*
* Example:
*
* // Add the `wp-block-group` class, remove the `wp-group` class.
* $classname_updates = array(
* // Indexed by a comparable class name.
* 'wp-block-group' => WP_HTML_Tag_Processor::ADD_CLASS,
* 'wp-group' => WP_HTML_Tag_Processor::REMOVE_CLASS
* );
*
* @since 6.2.0
* @var bool[]
*/
private $classname_updates = array();
/**
* Tracks a semantic location in the original HTML which
* shifts with updates as they are applied to the document.
*
* @since 6.2.0
* @var WP_HTML_Span[]
*/
protected $bookmarks = array();
const ADD_CLASS = true;
const REMOVE_CLASS = false;
const SKIP_CLASS = null;
/**
* Lexical replacements to apply to input HTML document.
*
* "Lexical" in this class refers to the part of this class which
* operates on pure text _as text_ and not as HTML. There's a line
* between the public interface, with HTML-semantic methods like
* `set_attribute` and `add_class`, and an internal state that tracks
* text offsets in the input document.
*
* When higher-level HTML methods are called, those have to transform their
* operations (such as setting an attribute's value) into text diffing
* operations (such as replacing the sub-string from indices A to B with
* some given new string). These text-diffing operations are the lexical
* updates.
*
* As new higher-level methods are added they need to collapse their
* operations into these lower-level lexical updates since that's the
* Tag Processor's internal language of change. Any code which creates
* these lexical updates must ensure that they do not cross HTML syntax
* boundaries, however, so these should never be exposed outside of this
* class or any classes which intentionally expand its functionality.
*
* These are enqueued while editing the document instead of being immediately
* applied to avoid processing overhead, string allocations, and string
* copies when applying many updates to a single document.
*
* Example:
*
* // Replace an attribute stored with a new value, indices
* // sourced from the lazily-parsed HTML recognizer.
* $start = $attributes['src']->start;
* $length = $attributes['src']->length;
* $modifications[] = new WP_HTML_Text_Replacement( $start, $length, $new_value );
*
* // Correspondingly, something like this will appear in this array.
* $lexical_updates = array(
* WP_HTML_Text_Replacement( 14, 28, 'https://my-site.my-domain/wp-content/uploads/2014/08/kittens.jpg' )
* );
*
* @since 6.2.0
* @var WP_HTML_Text_Replacement[]
*/
protected $lexical_updates = array();
/**
* Tracks and limits `seek()` calls to prevent accidental infinite loops.
*
* @since 6.2.0
* @var int
*
* @see WP_HTML_Tag_Processor::seek()
*/
protected $seek_count = 0;
/**
* Whether the parser should skip over an immediately-following linefeed
* character, as is the case with LISTING, PRE, and TEXTAREA.
*
* > If the next token is a U+000A LINE FEED (LF) character token, then
* > ignore that token and move on to the next one. (Newlines at the start
* > of [these] elements are ignored as an authoring convenience.)
*
* @since 6.7.0
*
* @var int|null
*/
private $skip_newline_at = null;
/**
* Constructor.
*
* @since 6.2.0
*
* @param string $html HTML to process.
*/
public function __construct( $html ) {
if ( ! is_string( $html ) ) {
_doing_it_wrong(
__METHOD__,
__( 'The HTML parameter must be a string.' ),
'6.9.0'
);
$html = '';
}
$this->html = $html;
}
/**
* Switches parsing mode into a new namespace, such as when
* encountering an SVG tag and entering foreign content.
*
* @since 6.7.0
*
* @param string $new_namespace One of 'html', 'svg', or 'math' indicating into what
* namespace the next tokens will be processed.
* @return bool Whether the namespace was valid and changed.
*/
public function change_parsing_namespace( string $new_namespace ): bool {
if ( ! in_array( $new_namespace, array( 'html', 'math', 'svg' ), true ) ) {
return false;
}
$this->parsing_namespace = $new_namespace;
return true;
}
/**
* Finds the next tag matching the $query.
*
* @since 6.2.0
* @since 6.5.0 No longer processes incomplete tokens at end of document; pauses the processor at start of token.
*
* @param array|string|null $query {
* Optional. Which tag name to find, having which class, etc. Default is to find any tag.
*
* @type string|null $tag_name Which tag to find, or `null` for "any tag."
* @type int|null $match_offset Find the Nth tag matching all search criteria.
* 1 for "first" tag, 3 for "third," etc.
* Defaults to first tag.
* @type string|null $class_name Tag must contain this whole class name to match.
* @type string|null $tag_closers "visit" or "skip": whether to stop on tag closers, e.g.
.
* }
* @return bool Whether a tag was matched.
*/
public function next_tag( $query = null ): bool {
$this->parse_query( $query );
$already_found = 0;
do {
if ( false === $this->next_token() ) {
return false;
}
if ( self::STATE_MATCHED_TAG !== $this->parser_state ) {
continue;
}
if ( $this->matches() ) {
++$already_found;
}
} while ( $already_found < $this->sought_match_offset );
return true;
}
/**
* Finds the next token in the HTML document.
*
* An HTML document can be viewed as a stream of tokens,
* where tokens are things like HTML tags, HTML comments,
* text nodes, etc. This method finds the next token in
* the HTML document and returns whether it found one.
*
* If it starts parsing a token and reaches the end of the
* document then it will seek to the start of the last
* token and pause, returning `false` to indicate that it
* failed to find a complete token.
*
* Possible token types, based on the HTML specification:
*
* - an HTML tag, whether opening, closing, or void.
* - a text node - the plaintext inside tags.
* - an HTML comment.
* - a DOCTYPE declaration.
* - a processing instruction, e.g. ``.
*
* The Tag Processor currently only supports the tag token.
*
* @since 6.5.0
* @since 6.7.0 Recognizes CDATA sections within foreign content.
*
* @return bool Whether a token was parsed.
*/
public function next_token(): bool {
return $this->base_class_next_token();
}
/**
* Internal method which finds the next token in the HTML document.
*
* This method is a protected internal function which implements the logic for
* finding the next token in a document. It exists so that the parser can update
* its state without affecting the location of the cursor in the document and
* without triggering subclass methods for things like `next_token()`, e.g. when
* applying patches before searching for the next token.
*
* @since 6.5.0
*
* @access private
*
* @return bool Whether a token was parsed.
*/
private function base_class_next_token(): bool {
$was_at = $this->bytes_already_parsed;
$this->after_tag();
// Don't proceed if there's nothing more to scan.
if (
self::STATE_COMPLETE === $this->parser_state ||
self::STATE_INCOMPLETE_INPUT === $this->parser_state
) {
return false;
}
/*
* The next step in the parsing loop determines the parsing state;
* clear it so that state doesn't linger from the previous step.
*/
$this->parser_state = self::STATE_READY;
if ( $this->bytes_already_parsed >= strlen( $this->html ) ) {
$this->parser_state = self::STATE_COMPLETE;
return false;
}
// Find the next tag if it exists.
if ( false === $this->parse_next_tag() ) {
if ( self::STATE_INCOMPLETE_INPUT === $this->parser_state ) {
$this->bytes_already_parsed = $was_at;
}
return false;
}
/*
* For legacy reasons the rest of this function handles tags and their
* attributes. If the processor has reached the end of the document
* or if it matched any other token then it should return here to avoid
* attempting to process tag-specific syntax.
*/
if (
self::STATE_INCOMPLETE_INPUT !== $this->parser_state &&
self::STATE_COMPLETE !== $this->parser_state &&
self::STATE_MATCHED_TAG !== $this->parser_state
) {
return true;
}
// Parse all of its attributes.
while ( $this->parse_next_attribute() ) {
continue;
}
// Ensure that the tag closes before the end of the document.
if (
self::STATE_INCOMPLETE_INPUT === $this->parser_state ||
$this->bytes_already_parsed >= strlen( $this->html )
) {
// Does this appropriately clear state (parsed attributes)?
$this->parser_state = self::STATE_INCOMPLETE_INPUT;
$this->bytes_already_parsed = $was_at;
return false;
}
$tag_ends_at = strpos( $this->html, '>', $this->bytes_already_parsed );
if ( false === $tag_ends_at ) {
$this->parser_state = self::STATE_INCOMPLETE_INPUT;
$this->bytes_already_parsed = $was_at;
return false;
}
$this->parser_state = self::STATE_MATCHED_TAG;
$this->bytes_already_parsed = $tag_ends_at + 1;
$this->token_length = $this->bytes_already_parsed - $this->token_starts_at;
/*
* Certain tags require additional processing. The first-letter pre-check
* avoids unnecessary string allocation when comparing the tag names.
*
* - IFRAME
* - LISTING (deprecated)
* - NOEMBED (deprecated)
* - NOFRAMES (deprecated)
* - PRE
* - SCRIPT
* - STYLE
* - TEXTAREA
* - TITLE
* - XMP (deprecated)
*/
if (
$this->is_closing_tag ||
'html' !== $this->parsing_namespace ||
1 !== strspn( $this->html, 'iIlLnNpPsStTxX', $this->tag_name_starts_at, 1 )
) {
return true;
}
$tag_name = $this->get_tag();
/*
* For LISTING, PRE, and TEXTAREA, the first linefeed of an immediately-following
* text node is ignored as an authoring convenience.
*
* @see static::skip_newline_at
*/
if ( 'LISTING' === $tag_name || 'PRE' === $tag_name ) {
$this->skip_newline_at = $this->bytes_already_parsed;
return true;
}
/*
* There are certain elements whose children are not DATA but are instead
* RCDATA or RAWTEXT. These cannot contain other elements, and the contents
* are parsed as plaintext, with character references decoded in RCDATA but
* not in RAWTEXT.
*
* These elements are described here as "self-contained" or special atomic
* elements whose end tag is consumed with the opening tag, and they will
* contain modifiable text inside of them.
*
* Preserve the opening tag pointers, as these will be overwritten
* when finding the closing tag. They will be reset after finding
* the closing to tag to point to the opening of the special atomic
* tag sequence.
*/
$tag_name_starts_at = $this->tag_name_starts_at;
$tag_name_length = $this->tag_name_length;
$tag_ends_at = $this->token_starts_at + $this->token_length;
$attributes = $this->attributes;
$duplicate_attributes = $this->duplicate_attributes;
// Find the closing tag if necessary.
switch ( $tag_name ) {
case 'SCRIPT':
$found_closer = $this->skip_script_data();
break;
case 'TEXTAREA':
case 'TITLE':
$found_closer = $this->skip_rcdata( $tag_name );
break;
/*
* In the browser this list would include the NOSCRIPT element,
* but the Tag Processor is an environment with the scripting
* flag disabled, meaning that it needs to descend into the
* NOSCRIPT element to be able to properly process what will be
* sent to a browser.
*
* Note that this rule makes HTML5 syntax incompatible with XML,
* because the parsing of this token depends on client application.
* The NOSCRIPT element cannot be represented in the XHTML syntax.
*/
case 'IFRAME':
case 'NOEMBED':
case 'NOFRAMES':
case 'STYLE':
case 'XMP':
$found_closer = $this->skip_rawtext( $tag_name );
break;
// No other tags should be treated in their entirety here.
default:
return true;
}
if ( ! $found_closer ) {
$this->parser_state = self::STATE_INCOMPLETE_INPUT;
$this->bytes_already_parsed = $was_at;
return false;
}
/*
* The values here look like they reference the opening tag but they reference
* the closing tag instead. This is why the opening tag values were stored
* above in a variable. It reads confusingly here, but that's because the
* functions that skip the contents have moved all the internal cursors past
* the inner content of the tag.
*/
$this->token_starts_at = $was_at;
$this->token_length = $this->bytes_already_parsed - $this->token_starts_at;
$this->text_starts_at = $tag_ends_at;
$this->text_length = $this->tag_name_starts_at - $this->text_starts_at;
$this->tag_name_starts_at = $tag_name_starts_at;
$this->tag_name_length = $tag_name_length;
$this->attributes = $attributes;
$this->duplicate_attributes = $duplicate_attributes;
return true;
}
/**
* Whether the processor paused because the input HTML document ended
* in the middle of a syntax element, such as in the middle of a tag.
*
* Example:
*
* $processor = new WP_HTML_Tag_Processor( '
" );
* $p->next_tag();
* foreach ( $p->class_list() as $class_name ) {
* echo "{$class_name} ";
* }
* // Outputs: "free
lang-en "
*
* @since 6.4.0
*/
public function class_list() {
if ( self::STATE_MATCHED_TAG !== $this->parser_state ) {
return;
}
/** @var string $class contains the string value of the class attribute, with character references decoded. */
$class = $this->get_attribute( 'class' );
if ( ! is_string( $class ) ) {
return;
}
$seen = array();
$is_quirks = self::QUIRKS_MODE === $this->compat_mode;
$at = 0;
while ( $at < strlen( $class ) ) {
// Skip past any initial boundary characters.
$at += strspn( $class, " \t\f\r\n", $at );
if ( $at >= strlen( $class ) ) {
return;
}
// Find the byte length until the next boundary.
$length = strcspn( $class, " \t\f\r\n", $at );
if ( 0 === $length ) {
return;
}
$name = str_replace( "\x00", "\u{FFFD}", substr( $class, $at, $length ) );
if ( $is_quirks ) {
$name = strtolower( $name );
}
$at += $length;
/*
* It's expected that the number of class names for a given tag is relatively small.
* Given this, it is probably faster overall to scan an array for a value rather
* than to use the class name as a key and check if it's a key of $seen.
*/
if ( in_array( $name, $seen, true ) ) {
continue;
}
$seen[] = $name;
yield $name;
}
}
/**
* Returns if a matched tag contains the given ASCII case-insensitive class name.
*
* @since 6.4.0
*
* @param string $wanted_class Look for this CSS class name, ASCII case-insensitive.
* @return bool|null Whether the matched tag contains the given class name, or null if not matched.
*/
public function has_class( $wanted_class ): ?bool {
if ( self::STATE_MATCHED_TAG !== $this->parser_state ) {
return null;
}
$case_insensitive = self::QUIRKS_MODE === $this->compat_mode;
$wanted_length = strlen( $wanted_class );
foreach ( $this->class_list() as $class_name ) {
if (
strlen( $class_name ) === $wanted_length &&
0 === substr_compare( $class_name, $wanted_class, 0, strlen( $wanted_class ), $case_insensitive )
) {
return true;
}
}
return false;
}
/**
* Sets a bookmark in the HTML document.
*
* Bookmarks represent specific places or tokens in the HTML
* document, such as a tag opener or closer. When applying
* edits to a document, such as setting an attribute, the
* text offsets of that token may shift; the bookmark is
* kept updated with those shifts and remains stable unless
* the entire span of text in which the token sits is removed.
*
* Release bookmarks when they are no longer needed.
*
* Example:
*
* Surprising fact you may not know! Surprising fact you may no…
* ^ ^
* \-|-- it shifts with edits
*
* Bookmarks provide the ability to seek to a previously-scanned
* place in the HTML document. This avoids the need to re-scan
* the entire document.
*
* Example:
*
*
* ^^^^
* want to note this last item
*
* $p = new WP_HTML_Tag_Processor( $html );
* $in_list = false;
* while ( $p->next_tag( array( 'tag_closers' => $in_list ? 'visit' : 'skip' ) ) ) {
* if ( 'UL' === $p->get_tag() ) {
* if ( $p->is_tag_closer() ) {
* $in_list = false;
* $p->set_bookmark( 'resume' );
* if ( $p->seek( 'last-li' ) ) {
* $p->add_class( 'last-li' );
* }
* $p->seek( 'resume' );
* $p->release_bookmark( 'last-li' );
* $p->release_bookmark( 'resume' );
* } else {
* $in_list = true;
* }
* }
*
* if ( 'LI' === $p->get_tag() ) {
* $p->set_bookmark( 'last-li' );
* }
* }
*
* Bookmarks intentionally hide the internal string offsets
* to which they refer. They are maintained internally as
* updates are applied to the HTML document and therefore
* retain their "position" - the location to which they
* originally pointed. The inability to use bookmarks with
* functions like `substr` is therefore intentional to guard
* against accidentally breaking the HTML.
*
* Because bookmarks allocate memory and require processing
* for every applied update, they are limited and require
* a name. They should not be created with programmatically-made
* names, such as "li_{$index}" with some loop. As a general
* rule they should only be created with string-literal names
* like "start-of-section" or "last-paragraph".
*
* Bookmarks are a powerful tool to enable complicated behavior.
* Consider double-checking that you need this tool if you are
* reaching for it, as inappropriate use could lead to broken
* HTML structure or unwanted processing overhead.
*
* @since 6.2.0
*
* @param string $name Identifies this particular bookmark.
* @return bool Whether the bookmark was successfully created.
*/
public function set_bookmark( $name ): bool {
// It only makes sense to set a bookmark if the parser has paused on a concrete token.
if (
self::STATE_COMPLETE === $this->parser_state ||
self::STATE_INCOMPLETE_INPUT === $this->parser_state
) {
return false;
}
if ( ! array_key_exists( $name, $this->bookmarks ) && count( $this->bookmarks ) >= static::MAX_BOOKMARKS ) {
_doing_it_wrong(
__METHOD__,
__( 'Too many bookmarks: cannot create any more.' ),
'6.2.0'
);
return false;
}
$this->bookmarks[ $name ] = new WP_HTML_Span( $this->token_starts_at, $this->token_length );
return true;
}
/**
* Removes a bookmark that is no longer needed.
*
* Releasing a bookmark frees up the small
* performance overhead it requires.
*
* @param string $name Name of the bookmark to remove.
* @return bool Whether the bookmark already existed before removal.
*/
public function release_bookmark( $name ): bool {
if ( ! array_key_exists( $name, $this->bookmarks ) ) {
return false;
}
unset( $this->bookmarks[ $name ] );
return true;
}
/**
* Skips contents of generic rawtext elements.
*
* @since 6.3.2
*
* @see https://html.spec.whatwg.org/#generic-raw-text-element-parsing-algorithm
*
* @param string $tag_name The uppercase tag name which will close the RAWTEXT region.
* @return bool Whether an end to the RAWTEXT region was found before the end of the document.
*/
private function skip_rawtext( string $tag_name ): bool {
/*
* These two functions distinguish themselves on whether character references are
* decoded, and since functionality to read the inner markup isn't supported, it's
* not necessary to implement these two functions separately.
*/
return $this->skip_rcdata( $tag_name );
}
/**
* Skips contents of RCDATA elements, namely title and textarea tags.
*
* @since 6.2.0
*
* @see https://html.spec.whatwg.org/multipage/parsing.html#rcdata-state
*
* @param string $tag_name The uppercase tag name which will close the RCDATA region.
* @return bool Whether an end to the RCDATA region was found before the end of the document.
*/
private function skip_rcdata( string $tag_name ): bool {
$html = $this->html;
$doc_length = strlen( $html );
$tag_length = strlen( $tag_name );
$at = $this->bytes_already_parsed;
while ( false !== $at && $at < $doc_length ) {
$at = strpos( $this->html, 'tag_name_starts_at = $at;
// Fail if there is no possible tag closer.
if ( false === $at || ( $at + $tag_length ) >= $doc_length ) {
return false;
}
$at += 2;
/*
* Find a case-insensitive match to the tag name.
*
* Because tag names are limited to US-ASCII there is no
* need to perform any kind of Unicode normalization when
* comparing; any character which could be impacted by such
* normalization could not be part of a tag name.
*/
for ( $i = 0; $i < $tag_length; $i++ ) {
$tag_char = $tag_name[ $i ];
$html_char = $html[ $at + $i ];
if ( $html_char !== $tag_char && strtoupper( $html_char ) !== $tag_char ) {
$at += $i;
continue 2;
}
}
$at += $tag_length;
$this->bytes_already_parsed = $at;
if ( $at >= strlen( $html ) ) {
return false;
}
/*
* Ensure that the tag name terminates to avoid matching on
* substrings of a longer tag name. For example, the sequence
* "' !== $c ) {
continue;
}
while ( $this->parse_next_attribute() ) {
continue;
}
$at = $this->bytes_already_parsed;
if ( $at >= strlen( $this->html ) ) {
return false;
}
if ( '>' === $html[ $at ] ) {
$this->bytes_already_parsed = $at + 1;
return true;
}
if ( $at + 1 >= strlen( $this->html ) ) {
return false;
}
if ( '/' === $html[ $at ] && '>' === $html[ $at + 1 ] ) {
$this->bytes_already_parsed = $at + 2;
return true;
}
}
return false;
}
/**
* Skips contents of script tags.
*
* @since 6.2.0
*
* @return bool Whether the script tag was closed before the end of the document.
*/
private function skip_script_data(): bool {
$state = 'unescaped';
$html = $this->html;
$doc_length = strlen( $html );
$at = $this->bytes_already_parsed;
while ( false !== $at && $at < $doc_length ) {
$at += strcspn( $html, '-<', $at );
/*
* Optimization: Terminating a complete script element requires at least eight
* additional bytes in the document. Some checks below may cause local escaped
* state transitions when processing shorter strings, but those transitions are
* irrelevant if the script tag is incomplete and the function must return false.
*
* This may need updating if those transitions become significant or exported from
* this function in some way, such as when building safe methods to embed JavaScript
* or data inside a SCRIPT element.
*
* $at may be here.
* ↓
* ...
* ╰──┬───╯
* $at + 8 additional bytes are required for a non-false return value.
*
* This single check eliminates the need to check lengths for the shorter spans:
*
* $at may be here.
* ↓
*
* ├╯
* $at + 2 additional characters does not require a length check.
*
* The transition from "escaped" to "unescaped" is not relevant if the document ends:
*
* $at may be here.
* ↓
* `. A SCRIPT element could be prevented from
* closing by contents like `
*
*
* @since 6.5.0
*/
const COMMENT_AS_ABRUPTLY_CLOSED_COMMENT = 'COMMENT_AS_ABRUPTLY_CLOSED_COMMENT';
/**
* Indicates that a comment would be parsed as a CDATA node,
* were HTML to allow CDATA nodes outside of foreign content.
*
* Example:
*
*
*
* This is an HTML comment, but it looks like a CDATA node.
*
* @since 6.5.0
*/
const COMMENT_AS_CDATA_LOOKALIKE = 'COMMENT_AS_CDATA_LOOKALIKE';
/**
* Indicates that a comment was created when encountering
* normative HTML comment syntax.
*
* Example:
*
*
*
* @since 6.5.0
*/
const COMMENT_AS_HTML_COMMENT = 'COMMENT_AS_HTML_COMMENT';
/**
* Indicates that a comment would be parsed as a Processing
* Instruction node, were they to exist within HTML.
*
* Example:
*
*
*
* This is an HTML comment, but it looks like a CDATA node.
*
* @since 6.5.0
*/
const COMMENT_AS_PI_NODE_LOOKALIKE = 'COMMENT_AS_PI_NODE_LOOKALIKE';
/**
* Indicates that a comment was created when encountering invalid
* HTML input, a so-called "bogus comment."
*
* Example:
*
*
*
*
* @since 6.5.0
*/
const COMMENT_AS_INVALID_HTML = 'COMMENT_AS_INVALID_HTML';
/**
* No-quirks mode document compatibility mode.
*
* > In no-quirks mode, the behavior is (hopefully) the desired behavior
* > described by the modern HTML and CSS specifications.
*
* @see self::$compat_mode
* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Mode
*
* @since 6.7.0
*
* @var string
*/
const NO_QUIRKS_MODE = 'no-quirks-mode';
/**
* Quirks mode document compatibility mode.
*
* > In quirks mode, layout emulates behavior in Navigator 4 and Internet
* > Explorer 5. This is essential in order to support websites that were
* > built before the widespread adoption of web standards.
*
* @see self::$compat_mode
* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Mode
*
* @since 6.7.0
*
* @var string
*/
const QUIRKS_MODE = 'quirks-mode';
/**
* Indicates that a span of text may contain any combination of significant
* kinds of characters: NULL bytes, whitespace, and others.
*
* @see self::$text_node_classification
* @see self::subdivide_text_appropriately
*
* @since 6.7.0
*/
const TEXT_IS_GENERIC = 'TEXT_IS_GENERIC';
/**
* Indicates that a span of text comprises a sequence only of NULL bytes.
*
* @see self::$text_node_classification
* @see self::subdivide_text_appropriately
*
* @since 6.7.0
*/
const TEXT_IS_NULL_SEQUENCE = 'TEXT_IS_NULL_SEQUENCE';
/**
* Indicates that a span of decoded text comprises only whitespace.
*
* @see self::$text_node_classification
* @see self::subdivide_text_appropriately
*
* @since 6.7.0
*/
const TEXT_IS_WHITESPACE = 'TEXT_IS_WHITESPACE';
}
PK ÷L\ׯ¥¥#9 #9 $ html5-named-character-references.phpnu „[µü¤ "6.6.0-trunk",
"key_length" => 2,
"groups" => "AE\x00AM\x00Aa\x00Ab\x00Ac\x00Af\x00Ag\x00Al\x00Am\x00An\x00Ao\x00Ap\x00Ar\x00As\x00At\x00Au\x00Ba\x00Bc\x00Be\x00Bf\x00Bo\x00Br\x00Bs\x00Bu\x00CH\x00CO\x00Ca\x00Cc\x00Cd\x00Ce\x00Cf\x00Ch\x00Ci\x00Cl\x00Co\x00Cr\x00Cs\x00Cu\x00DD\x00DJ\x00DS\x00DZ\x00Da\x00Dc\x00De\x00Df\x00Di\x00Do\x00Ds\x00EN\x00ET\x00Ea\x00Ec\x00Ed\x00Ef\x00Eg\x00El\x00Em\x00Eo\x00Ep\x00Eq\x00Es\x00Et\x00Eu\x00Ex\x00Fc\x00Ff\x00Fi\x00Fo\x00Fs\x00GJ\x00GT\x00Ga\x00Gb\x00Gc\x00Gd\x00Gf\x00Gg\x00Go\x00Gr\x00Gs\x00Gt\x00HA\x00Ha\x00Hc\x00Hf\x00Hi\x00Ho\x00Hs\x00Hu\x00IE\x00IJ\x00IO\x00Ia\x00Ic\x00Id\x00If\x00Ig\x00Im\x00In\x00Io\x00Is\x00It\x00Iu\x00Jc\x00Jf\x00Jo\x00Js\x00Ju\x00KH\x00KJ\x00Ka\x00Kc\x00Kf\x00Ko\x00Ks\x00LJ\x00LT\x00La\x00Lc\x00Le\x00Lf\x00Ll\x00Lm\x00Lo\x00Ls\x00Lt\x00Ma\x00Mc\x00Me\x00Mf\x00Mi\x00Mo\x00Ms\x00Mu\x00NJ\x00Na\x00Nc\x00Ne\x00Nf\x00No\x00Ns\x00Nt\x00Nu\x00OE\x00Oa\x00Oc\x00Od\x00Of\x00Og\x00Om\x00Oo\x00Op\x00Or\x00Os\x00Ot\x00Ou\x00Ov\x00Pa\x00Pc\x00Pf\x00Ph\x00Pi\x00Pl\x00Po\x00Pr\x00Ps\x00QU\x00Qf\x00Qo\x00Qs\x00RB\x00RE\x00Ra\x00Rc\x00Re\x00Rf\x00Rh\x00Ri\x00Ro\x00Rr\x00Rs\x00Ru\x00SH\x00SO\x00Sa\x00Sc\x00Sf\x00Sh\x00Si\x00Sm\x00So\x00Sq\x00Ss\x00St\x00Su\x00TH\x00TR\x00TS\x00Ta\x00Tc\x00Tf\x00Th\x00Ti\x00To\x00Tr\x00Ts\x00Ua\x00Ub\x00Uc\x00Ud\x00Uf\x00Ug\x00Um\x00Un\x00Uo\x00Up\x00Ur\x00Us\x00Ut\x00Uu\x00VD\x00Vb\x00Vc\x00Vd\x00Ve\x00Vf\x00Vo\x00Vs\x00Vv\x00Wc\x00We\x00Wf\x00Wo\x00Ws\x00Xf\x00Xi\x00Xo\x00Xs\x00YA\x00YI\x00YU\x00Ya\x00Yc\x00Yf\x00Yo\x00Ys\x00Yu\x00ZH\x00Za\x00Zc\x00Zd\x00Ze\x00Zf\x00Zo\x00Zs\x00aa\x00ab\x00ac\x00ae\x00af\x00ag\x00al\x00am\x00an\x00ao\x00ap\x00ar\x00as\x00at\x00au\x00aw\x00bN\x00ba\x00bb\x00bc\x00bd\x00be\x00bf\x00bi\x00bk\x00bl\x00bn\x00bo\x00bp\x00br\x00bs\x00bu\x00ca\x00cc\x00cd\x00ce\x00cf\x00ch\x00ci\x00cl\x00co\x00cr\x00cs\x00ct\x00cu\x00cw\x00cy\x00dA\x00dH\x00da\x00db\x00dc\x00dd\x00de\x00df\x00dh\x00di\x00dj\x00dl\x00do\x00dr\x00ds\x00dt\x00du\x00dw\x00dz\x00eD\x00ea\x00ec\x00ed\x00ee\x00ef\x00eg\x00el\x00em\x00en\x00eo\x00ep\x00eq\x00er\x00es\x00et\x00eu\x00ex\x00fa\x00fc\x00fe\x00ff\x00fi\x00fj\x00fl\x00fn\x00fo\x00fp\x00fr\x00fs\x00gE\x00ga\x00gb\x00gc\x00gd\x00ge\x00gf\x00gg\x00gi\x00gj\x00gl\x00gn\x00go\x00gr\x00gs\x00gt\x00gv\x00hA\x00ha\x00hb\x00hc\x00he\x00hf\x00hk\x00ho\x00hs\x00hy\x00ia\x00ic\x00ie\x00if\x00ig\x00ii\x00ij\x00im\x00in\x00io\x00ip\x00iq\x00is\x00it\x00iu\x00jc\x00jf\x00jm\x00jo\x00js\x00ju\x00ka\x00kc\x00kf\x00kg\x00kh\x00kj\x00ko\x00ks\x00lA\x00lB\x00lE\x00lH\x00la\x00lb\x00lc\x00ld\x00le\x00lf\x00lg\x00lh\x00lj\x00ll\x00lm\x00ln\x00lo\x00lp\x00lr\x00ls\x00lt\x00lu\x00lv\x00mD\x00ma\x00mc\x00md\x00me\x00mf\x00mh\x00mi\x00ml\x00mn\x00mo\x00mp\x00ms\x00mu\x00nG\x00nL\x00nR\x00nV\x00na\x00nb\x00nc\x00nd\x00ne\x00nf\x00ng\x00nh\x00ni\x00nj\x00nl\x00nm\x00no\x00np\x00nr\x00ns\x00nt\x00nu\x00nv\x00nw\x00oS\x00oa\x00oc\x00od\x00oe\x00of\x00og\x00oh\x00oi\x00ol\x00om\x00oo\x00op\x00or\x00os\x00ot\x00ou\x00ov\x00pa\x00pc\x00pe\x00pf\x00ph\x00pi\x00pl\x00pm\x00po\x00pr\x00ps\x00pu\x00qf\x00qi\x00qo\x00qp\x00qs\x00qu\x00rA\x00rB\x00rH\x00ra\x00rb\x00rc\x00rd\x00re\x00rf\x00rh\x00ri\x00rl\x00rm\x00rn\x00ro\x00rp\x00rr\x00rs\x00rt\x00ru\x00rx\x00sa\x00sb\x00sc\x00sd\x00se\x00sf\x00sh\x00si\x00sl\x00sm\x00so\x00sp\x00sq\x00sr\x00ss\x00st\x00su\x00sw\x00sz\x00ta\x00tb\x00tc\x00td\x00te\x00tf\x00th\x00ti\x00to\x00tp\x00tr\x00ts\x00tw\x00uA\x00uH\x00ua\x00ub\x00uc\x00ud\x00uf\x00ug\x00uh\x00ul\x00um\x00uo\x00up\x00ur\x00us\x00ut\x00uu\x00uw\x00vA\x00vB\x00vD\x00va\x00vc\x00vd\x00ve\x00vf\x00vl\x00vn\x00vo\x00vp\x00vr\x00vs\x00vz\x00wc\x00we\x00wf\x00wo\x00wp\x00wr\x00ws\x00xc\x00xd\x00xf\x00xh\x00xi\x00xl\x00xm\x00xn\x00xo\x00xr\x00xs\x00xu\x00xv\x00xw\x00ya\x00yc\x00ye\x00yf\x00yi\x00yo\x00ys\x00yu\x00za\x00zc\x00zd\x00ze\x00zf\x00zh\x00zi\x00zo\x00zs\x00zw\x00",
"large_words" => array(
// AElig;[Æ] AElig[Æ].
"\x04lig;\x02Æ\x03lig\x02Æ",
// AMP;[&] AMP[&].
"\x02P;\x01&\x01P\x01&",
// Aacute;[Ã] Aacute[Ã].
"\x05cute;\x02Ã\x04cute\x02Ã",
// Abreve;[Ä‚].
"\x05reve;\x02Ä‚",
// Acirc;[Â] Acirc[Â] Acy;[Ð].
"\x04irc;\x02Â\x03irc\x02Â\x02y;\x02Ð",
// Afr;[ð”„].
"\x02r;\x04ð”„",
// Agrave;[À] Agrave[À].
"\x05rave;\x02À\x04rave\x02À",
// Alpha;[Α].
"\x04pha;\x02Α",
// Amacr;[Ä€].
"\x04acr;\x02Ä€",
// And;[â©“].
"\x02d;\x03â©“",
// Aogon;[Ä„] Aopf;[ð”¸].
"\x04gon;\x02Ä„\x03pf;\x04ð”¸",
// ApplyFunction;[â¡].
"\x0cplyFunction;\x03â¡",
// Aring;[Ã…] Aring[Ã…].
"\x04ing;\x02Ã…\x03ing\x02Ã…",
// Assign;[≔] Ascr;[ð’œ].
"\x05sign;\x03≔\x03cr;\x04ð’œ",
// Atilde;[Ã] Atilde[Ã].
"\x05ilde;\x02Ã\x04ilde\x02Ã",
// Auml;[Ä] Auml[Ä].
"\x03ml;\x02Ä\x02ml\x02Ä",
// Backslash;[∖] Barwed;[⌆] Barv;[⫧].
"\x08ckslash;\x03∖\x05rwed;\x03⌆\x03rv;\x03⫧",
// Bcy;[Б].
"\x02y;\x02Б",
// Bernoullis;[ℬ] Because;[∵] Beta;[Β].
"\x09rnoullis;\x03ℬ\x06cause;\x03∵\x03ta;\x02Β",
// Bfr;[ð”…].
"\x02r;\x04ð”…",
// Bopf;[ð”¹].
"\x03pf;\x04ð”¹",
// Breve;[˘].
"\x04eve;\x02˘",
// Bscr;[ℬ].
"\x03cr;\x03ℬ",
// Bumpeq;[≎].
"\x05mpeq;\x03≎",
// CHcy;[Ч].
"\x03cy;\x02Ч",
// COPY;[©] COPY[©].
"\x03PY;\x02©\x02PY\x02©",
// CapitalDifferentialD;[â……] Cayleys;[â„] Cacute;[Ć] Cap;[â‹’].
"\x13pitalDifferentialD;\x03â……\x06yleys;\x03â„\x05cute;\x02Ć\x02p;\x03â‹’",
// Cconint;[∰] Ccaron;[Č] Ccedil;[Ç] Ccedil[Ç] Ccirc;[Ĉ].
"\x06onint;\x03∰\x05aron;\x02Č\x05edil;\x02Ç\x04edil\x02Ç\x04irc;\x02Ĉ",
// Cdot;[ÄŠ].
"\x03ot;\x02ÄŠ",
// CenterDot;[·] Cedilla;[¸].
"\x08nterDot;\x02·\x06dilla;\x02¸",
// Cfr;[â„].
"\x02r;\x03â„",
// Chi;[Χ].
"\x02i;\x02Χ",
// CircleMinus;[⊖] CircleTimes;[⊗] CirclePlus;[⊕] CircleDot;[⊙].
"\x0arcleMinus;\x03⊖\x0arcleTimes;\x03⊗\x09rclePlus;\x03⊕\x08rcleDot;\x03⊙",
// ClockwiseContourIntegral;[∲] CloseCurlyDoubleQuote;[â€] CloseCurlyQuote;[’].
"\x17ockwiseContourIntegral;\x03∲\x14oseCurlyDoubleQuote;\x03â€\x0eoseCurlyQuote;\x03’",
// CounterClockwiseContourIntegral;[∳] ContourIntegral;[∮] Congruent;[≡] Coproduct;[âˆ] Colone;[â©´] Conint;[∯] Colon;[∷] Copf;[â„‚].
"\x1eunterClockwiseContourIntegral;\x03∳\x0entourIntegral;\x03∮\x08ngruent;\x03≡\x08product;\x03âˆ\x05lone;\x03â©´\x05nint;\x03∯\x04lon;\x03∷\x03pf;\x03â„‚",
// Cross;[⨯].
"\x04oss;\x03⨯",
// Cscr;[ð’ž].
"\x03cr;\x04ð’ž",
// CupCap;[â‰] Cup;[â‹“].
"\x05pCap;\x03â‰\x02p;\x03â‹“",
// DDotrahd;[⤑] DD;[ⅅ].
"\x07otrahd;\x03⤑\x01;\x03ⅅ",
// DJcy;[Ђ].
"\x03cy;\x02Ђ",
// DScy;[Ð…].
"\x03cy;\x02Ð…",
// DZcy;[Ð].
"\x03cy;\x02Ð",
// Dagger;[‡] Dashv;[⫤] Darr;[↡].
"\x05gger;\x03‡\x04shv;\x03⫤\x03rr;\x03↡",
// Dcaron;[Ď] Dcy;[Д].
"\x05aron;\x02Ď\x02y;\x02Д",
// Delta;[Δ] Del;[∇].
"\x04lta;\x02Δ\x02l;\x03∇",
// Dfr;[ð”‡].
"\x02r;\x04ð”‡",
// DiacriticalDoubleAcute;[Ë] DiacriticalAcute;[´] DiacriticalGrave;[`] DiacriticalTilde;[Ëœ] DiacriticalDot;[Ë™] DifferentialD;[â…†] Diamond;[â‹„].
"\x15acriticalDoubleAcute;\x02Ë\x0facriticalAcute;\x02´\x0facriticalGrave;\x01`\x0facriticalTilde;\x02Ëœ\x0dacriticalDot;\x02Ë™\x0cfferentialD;\x03â…†\x06amond;\x03â‹„",
// DoubleLongLeftRightArrow;[⟺] DoubleContourIntegral;[∯] DoubleLeftRightArrow;[⇔] DoubleLongRightArrow;[⟹] DoubleLongLeftArrow;[⟸] DownLeftRightVector;[â¥] DownRightTeeVector;[⥟] DownRightVectorBar;[⥗] DoubleUpDownArrow;[⇕] DoubleVerticalBar;[∥] DownLeftTeeVector;[⥞] DownLeftVectorBar;[⥖] DoubleRightArrow;[⇒] DownArrowUpArrow;[⇵] DoubleDownArrow;[⇓] DoubleLeftArrow;[â‡] DownRightVector;[â‡] DoubleRightTee;[⊨] DownLeftVector;[↽] DoubleLeftTee;[⫤] DoubleUpArrow;[⇑] DownArrowBar;[⤓] DownTeeArrow;[↧] DoubleDot;[¨] DownArrow;[↓] DownBreve;[Ì‘] Downarrow;[⇓] DotEqual;[â‰] DownTee;[⊤] DotDot;[⃜] Dopf;[ð”»] Dot;[¨].
"\x17ubleLongLeftRightArrow;\x03⟺\x14ubleContourIntegral;\x03∯\x13ubleLeftRightArrow;\x03⇔\x13ubleLongRightArrow;\x03⟹\x12ubleLongLeftArrow;\x03⟸\x12wnLeftRightVector;\x03â¥\x11wnRightTeeVector;\x03⥟\x11wnRightVectorBar;\x03⥗\x10ubleUpDownArrow;\x03⇕\x10ubleVerticalBar;\x03∥\x10wnLeftTeeVector;\x03⥞\x10wnLeftVectorBar;\x03⥖\x0fubleRightArrow;\x03⇒\x0fwnArrowUpArrow;\x03⇵\x0eubleDownArrow;\x03⇓\x0eubleLeftArrow;\x03â‡\x0ewnRightVector;\x03â‡\x0dubleRightTee;\x03⊨\x0dwnLeftVector;\x03↽\x0cubleLeftTee;\x03⫤\x0cubleUpArrow;\x03⇑\x0bwnArrowBar;\x03⤓\x0bwnTeeArrow;\x03↧\x08ubleDot;\x02¨\x08wnArrow;\x03↓\x08wnBreve;\x02Ì‘\x08wnarrow;\x03⇓\x07tEqual;\x03â‰\x06wnTee;\x03⊤\x05tDot;\x03⃜\x03pf;\x04ð”»\x02t;\x02¨",
// Dstrok;[Ä] Dscr;[ð’Ÿ].
"\x05trok;\x02Ä\x03cr;\x04ð’Ÿ",
// ENG;[ÅŠ].
"\x02G;\x02ÅŠ",
// ETH;[Ã] ETH[Ã].
"\x02H;\x02Ã\x01H\x02Ã",
// Eacute;[É] Eacute[É].
"\x05cute;\x02É\x04cute\x02É",
// Ecaron;[Äš] Ecirc;[Ê] Ecirc[Ê] Ecy;[Ð].
"\x05aron;\x02Äš\x04irc;\x02Ê\x03irc\x02Ê\x02y;\x02Ð",
// Edot;[Ä–].
"\x03ot;\x02Ä–",
// Efr;[ð”ˆ].
"\x02r;\x04ð”ˆ",
// Egrave;[È] Egrave[È].
"\x05rave;\x02È\x04rave\x02È",
// Element;[∈].
"\x06ement;\x03∈",
// EmptyVerySmallSquare;[â–«] EmptySmallSquare;[â—»] Emacr;[Ä’].
"\x13ptyVerySmallSquare;\x03â–«\x0fptySmallSquare;\x03â—»\x04acr;\x02Ä’",
// Eogon;[Ę] Eopf;[ð”¼].
"\x04gon;\x02Ę\x03pf;\x04ð”¼",
// Epsilon;[Ε].
"\x06silon;\x02Ε",
// Equilibrium;[⇌] EqualTilde;[≂] Equal;[⩵].
"\x0auilibrium;\x03⇌\x09ualTilde;\x03≂\x04ual;\x03⩵",
// Escr;[ℰ] Esim;[⩳].
"\x03cr;\x03ℰ\x03im;\x03⩳",
// Eta;[Η].
"\x02a;\x02Η",
// Euml;[Ë] Euml[Ë].
"\x03ml;\x02Ë\x02ml\x02Ë",
// ExponentialE;[ⅇ] Exists;[∃].
"\x0bponentialE;\x03ⅇ\x05ists;\x03∃",
// Fcy;[Ф].
"\x02y;\x02Ф",
// Ffr;[ð”‰].
"\x02r;\x04ð”‰",
// FilledVerySmallSquare;[â–ª] FilledSmallSquare;[â—¼].
"\x14lledVerySmallSquare;\x03â–ª\x10lledSmallSquare;\x03â—¼",
// Fouriertrf;[ℱ] ForAll;[∀] Fopf;[ð”½].
"\x09uriertrf;\x03ℱ\x05rAll;\x03∀\x03pf;\x04ð”½",
// Fscr;[ℱ].
"\x03cr;\x03ℱ",
// GJcy;[Ѓ].
"\x03cy;\x02Ѓ",
// GT;[>].
"\x01;\x01>",
// Gammad;[Ϝ] Gamma;[Γ].
"\x05mmad;\x02Ϝ\x04mma;\x02Γ",
// Gbreve;[Äž].
"\x05reve;\x02Äž",
// Gcedil;[Ģ] Gcirc;[Ĝ] Gcy;[Г].
"\x05edil;\x02Ģ\x04irc;\x02Ĝ\x02y;\x02Г",
// Gdot;[Ä ].
"\x03ot;\x02Ä ",
// Gfr;[ð”Š].
"\x02r;\x04ð”Š",
// Gg;[â‹™].
"\x01;\x03â‹™",
// Gopf;[ð”¾].
"\x03pf;\x04ð”¾",
// GreaterSlantEqual;[⩾] GreaterEqualLess;[⋛] GreaterFullEqual;[≧] GreaterGreater;[⪢] GreaterEqual;[≥] GreaterTilde;[≳] GreaterLess;[≷].
"\x10eaterSlantEqual;\x03⩾\x0featerEqualLess;\x03⋛\x0featerFullEqual;\x03≧\x0deaterGreater;\x03⪢\x0beaterEqual;\x03≥\x0beaterTilde;\x03≳\x0aeaterLess;\x03≷",
// Gscr;[ð’¢].
"\x03cr;\x04ð’¢",
// Gt;[≫].
"\x01;\x03≫",
// HARDcy;[Ъ].
"\x05RDcy;\x02Ъ",
// Hacek;[ˇ] Hat;[^].
"\x04cek;\x02ˇ\x02t;\x01^",
// Hcirc;[Ĥ].
"\x04irc;\x02Ĥ",
// Hfr;[ℌ].
"\x02r;\x03ℌ",
// HilbertSpace;[â„‹].
"\x0blbertSpace;\x03â„‹",
// HorizontalLine;[─] Hopf;[â„].
"\x0drizontalLine;\x03─\x03pf;\x03â„",
// Hstrok;[Ħ] Hscr;[ℋ].
"\x05trok;\x02Ħ\x03cr;\x03ℋ",
// HumpDownHump;[≎] HumpEqual;[â‰].
"\x0bmpDownHump;\x03≎\x08mpEqual;\x03â‰",
// IEcy;[Е].
"\x03cy;\x02Е",
// IJlig;[IJ].
"\x04lig;\x02IJ",
// IOcy;[Ð].
"\x03cy;\x02Ð",
// Iacute;[Ã] Iacute[Ã].
"\x05cute;\x02Ã\x04cute\x02Ã",
// Icirc;[Î] Icirc[Î] Icy;[И].
"\x04irc;\x02Î\x03irc\x02Î\x02y;\x02И",
// Idot;[Ä°].
"\x03ot;\x02Ä°",
// Ifr;[â„‘].
"\x02r;\x03â„‘",
// Igrave;[Ì] Igrave[Ì].
"\x05rave;\x02Ì\x04rave\x02Ì",
// ImaginaryI;[ⅈ] Implies;[⇒] Imacr;[Ī] Im;[ℑ].
"\x09aginaryI;\x03ⅈ\x06plies;\x03⇒\x04acr;\x02Ī\x01;\x03ℑ",
// InvisibleComma;[â£] InvisibleTimes;[â¢] Intersection;[â‹‚] Integral;[∫] Int;[∬].
"\x0dvisibleComma;\x03â£\x0dvisibleTimes;\x03â¢\x0btersection;\x03â‹‚\x07tegral;\x03∫\x02t;\x03∬",
// Iogon;[Ä®] Iopf;[ð•€] Iota;[Ι].
"\x04gon;\x02Ä®\x03pf;\x04ð•€\x03ta;\x02Ι",
// Iscr;[â„].
"\x03cr;\x03â„",
// Itilde;[Ĩ].
"\x05ilde;\x02Ĩ",
// Iukcy;[І] Iuml;[Ã] Iuml[Ã].
"\x04kcy;\x02І\x03ml;\x02Ã\x02ml\x02Ã",
// Jcirc;[Ĵ] Jcy;[Й].
"\x04irc;\x02Ĵ\x02y;\x02Й",
// Jfr;[ð”].
"\x02r;\x04ð”",
// Jopf;[ð•].
"\x03pf;\x04ð•",
// Jsercy;[Ј] Jscr;[ð’¥].
"\x05ercy;\x02Ј\x03cr;\x04ð’¥",
// Jukcy;[Є].
"\x04kcy;\x02Є",
// KHcy;[Ð¥].
"\x03cy;\x02Ð¥",
// KJcy;[Ќ].
"\x03cy;\x02Ќ",
// Kappa;[Κ].
"\x04ppa;\x02Κ",
// Kcedil;[Ķ] Kcy;[К].
"\x05edil;\x02Ķ\x02y;\x02К",
// Kfr;[ð”Ž].
"\x02r;\x04ð”Ž",
// Kopf;[ð•‚].
"\x03pf;\x04ð•‚",
// Kscr;[ð’¦].
"\x03cr;\x04ð’¦",
// LJcy;[Љ].
"\x03cy;\x02Љ",
// LT;[<].
"\x01;\x01<",
// Laplacetrf;[ℒ] Lacute;[Ĺ] Lambda;[Λ] Lang;[⟪] Larr;[↞].
"\x09placetrf;\x03ℒ\x05cute;\x02Ĺ\x05mbda;\x02Λ\x03ng;\x03⟪\x03rr;\x03↞",
// Lcaron;[Ľ] Lcedil;[Ļ] Lcy;[Л].
"\x05aron;\x02Ľ\x05edil;\x02Ļ\x02y;\x02Л",
// LeftArrowRightArrow;[⇆] LeftDoubleBracket;[⟦] LeftDownTeeVector;[⥡] LeftDownVectorBar;[⥙] LeftTriangleEqual;[⊴] LeftAngleBracket;[⟨] LeftUpDownVector;[⥑] LessEqualGreater;[â‹š] LeftRightVector;[⥎] LeftTriangleBar;[â§] LeftUpTeeVector;[⥠] LeftUpVectorBar;[⥘] LeftDownVector;[⇃] LeftRightArrow;[↔] Leftrightarrow;[⇔] LessSlantEqual;[⩽] LeftTeeVector;[⥚] LeftVectorBar;[⥒] LessFullEqual;[≦] LeftArrowBar;[⇤] LeftTeeArrow;[↤] LeftTriangle;[⊲] LeftUpVector;[↿] LeftCeiling;[⌈] LessGreater;[≶] LeftVector;[↼] LeftArrow;[â†] LeftFloor;[⌊] Leftarrow;[â‡] LessTilde;[≲] LessLess;[⪡] LeftTee;[⊣].
"\x12ftArrowRightArrow;\x03⇆\x10ftDoubleBracket;\x03⟦\x10ftDownTeeVector;\x03⥡\x10ftDownVectorBar;\x03⥙\x10ftTriangleEqual;\x03⊴\x0fftAngleBracket;\x03⟨\x0fftUpDownVector;\x03⥑\x0fssEqualGreater;\x03â‹š\x0eftRightVector;\x03⥎\x0eftTriangleBar;\x03â§\x0eftUpTeeVector;\x03⥠\x0eftUpVectorBar;\x03⥘\x0dftDownVector;\x03⇃\x0dftRightArrow;\x03↔\x0dftrightarrow;\x03⇔\x0dssSlantEqual;\x03⩽\x0cftTeeVector;\x03⥚\x0cftVectorBar;\x03⥒\x0cssFullEqual;\x03≦\x0bftArrowBar;\x03⇤\x0bftTeeArrow;\x03↤\x0bftTriangle;\x03⊲\x0bftUpVector;\x03↿\x0aftCeiling;\x03⌈\x0assGreater;\x03≶\x09ftVector;\x03↼\x08ftArrow;\x03â†\x08ftFloor;\x03⌊\x08ftarrow;\x03â‡\x08ssTilde;\x03≲\x07ssLess;\x03⪡\x06ftTee;\x03⊣",
// Lfr;[ð”].
"\x02r;\x04ð”",
// Lleftarrow;[⇚] Ll;[⋘].
"\x09eftarrow;\x03⇚\x01;\x03⋘",
// Lmidot;[Ä¿].
"\x05idot;\x02Ä¿",
// LongLeftRightArrow;[⟷] Longleftrightarrow;[⟺] LowerRightArrow;[↘] LongRightArrow;[⟶] Longrightarrow;[⟹] LowerLeftArrow;[↙] LongLeftArrow;[⟵] Longleftarrow;[⟸] Lopf;[ð•ƒ].
"\x11ngLeftRightArrow;\x03⟷\x11ngleftrightarrow;\x03⟺\x0ewerRightArrow;\x03↘\x0dngRightArrow;\x03⟶\x0dngrightarrow;\x03⟹\x0dwerLeftArrow;\x03↙\x0cngLeftArrow;\x03⟵\x0cngleftarrow;\x03⟸\x03pf;\x04ð•ƒ",
// Lstrok;[Å] Lscr;[â„’] Lsh;[↰].
"\x05trok;\x02Å\x03cr;\x03â„’\x02h;\x03↰",
// Lt;[≪].
"\x01;\x03≪",
// Map;[⤅].
"\x02p;\x03⤅",
// Mcy;[М].
"\x02y;\x02М",
// MediumSpace;[âŸ] Mellintrf;[ℳ].
"\x0adiumSpace;\x03âŸ\x08llintrf;\x03ℳ",
// Mfr;[ð”].
"\x02r;\x04ð”",
// MinusPlus;[∓].
"\x08nusPlus;\x03∓",
// Mopf;[ð•„].
"\x03pf;\x04ð•„",
// Mscr;[ℳ].
"\x03cr;\x03ℳ",
// Mu;[Μ].
"\x01;\x02Μ",
// NJcy;[Њ].
"\x03cy;\x02Њ",
// Nacute;[Ń].
"\x05cute;\x02Ń",
// Ncaron;[Ň] Ncedil;[Å…] Ncy;[Ð].
"\x05aron;\x02Ň\x05edil;\x02Å…\x02y;\x02Ð",
// NegativeVeryThinSpace;[​] NestedGreaterGreater;[≫] NegativeMediumSpace;[​] NegativeThickSpace;[​] NegativeThinSpace;[​] NestedLessLess;[≪] NewLine;[\xa].
"\x14gativeVeryThinSpace;\x03​\x13stedGreaterGreater;\x03≫\x12gativeMediumSpace;\x03​\x11gativeThickSpace;\x03​\x10gativeThinSpace;\x03​\x0dstedLessLess;\x03≪\x06wLine;\x01\xa",
// Nfr;[ð”‘].
"\x02r;\x04ð”‘",
// NotNestedGreaterGreater;[⪢̸] NotSquareSupersetEqual;[â‹£] NotPrecedesSlantEqual;[â‹ ] NotRightTriangleEqual;[â‹] NotSucceedsSlantEqual;[â‹¡] NotDoubleVerticalBar;[∦] NotGreaterSlantEqual;[⩾̸] NotLeftTriangleEqual;[⋬] NotSquareSubsetEqual;[â‹¢] NotGreaterFullEqual;[≧̸] NotRightTriangleBar;[â§Ì¸] NotLeftTriangleBar;[â§Ì¸] NotGreaterGreater;[≫̸] NotLessSlantEqual;[⩽̸] NotNestedLessLess;[⪡̸] NotReverseElement;[∌] NotSquareSuperset;[âŠÌ¸] NotTildeFullEqual;[≇] NonBreakingSpace;[ ] NotPrecedesEqual;[⪯̸] NotRightTriangle;[â‹«] NotSucceedsEqual;[⪰̸] NotSucceedsTilde;[≿̸] NotSupersetEqual;[⊉] NotGreaterEqual;[≱] NotGreaterTilde;[≵] NotHumpDownHump;[≎̸] NotLeftTriangle;[⋪] NotSquareSubset;[âŠÌ¸] NotGreaterLess;[≹] NotLessGreater;[≸] NotSubsetEqual;[⊈] NotVerticalBar;[∤] NotEqualTilde;[≂̸] NotTildeEqual;[≄] NotTildeTilde;[≉] NotCongruent;[≢] NotHumpEqual;[â‰Ì¸] NotLessEqual;[≰] NotLessTilde;[≴] NotLessLess;[≪̸] NotPrecedes;[⊀] NotSucceeds;[âŠ] NotSuperset;[⊃⃒] NotElement;[∉] NotGreater;[≯] NotCupCap;[â‰] NotExists;[∄] NotSubset;[⊂⃒] NotEqual;[≠] NotTilde;[â‰] NoBreak;[â ] NotLess;[≮] Nopf;[â„•] Not;[⫬].
"\x16tNestedGreaterGreater;\x05⪢̸\x15tSquareSupersetEqual;\x03â‹£\x14tPrecedesSlantEqual;\x03â‹ \x14tRightTriangleEqual;\x03â‹\x14tSucceedsSlantEqual;\x03â‹¡\x13tDoubleVerticalBar;\x03∦\x13tGreaterSlantEqual;\x05⩾̸\x13tLeftTriangleEqual;\x03⋬\x13tSquareSubsetEqual;\x03â‹¢\x12tGreaterFullEqual;\x05≧̸\x12tRightTriangleBar;\x05â§Ì¸\x11tLeftTriangleBar;\x05â§Ì¸\x10tGreaterGreater;\x05≫̸\x10tLessSlantEqual;\x05⩽̸\x10tNestedLessLess;\x05⪡̸\x10tReverseElement;\x03∌\x10tSquareSuperset;\x05âŠÌ¸\x10tTildeFullEqual;\x03≇\x0fnBreakingSpace;\x02 \x0ftPrecedesEqual;\x05⪯̸\x0ftRightTriangle;\x03â‹«\x0ftSucceedsEqual;\x05⪰̸\x0ftSucceedsTilde;\x05≿̸\x0ftSupersetEqual;\x03⊉\x0etGreaterEqual;\x03≱\x0etGreaterTilde;\x03≵\x0etHumpDownHump;\x05≎̸\x0etLeftTriangle;\x03⋪\x0etSquareSubset;\x05âŠÌ¸\x0dtGreaterLess;\x03≹\x0dtLessGreater;\x03≸\x0dtSubsetEqual;\x03⊈\x0dtVerticalBar;\x03∤\x0ctEqualTilde;\x05≂̸\x0ctTildeEqual;\x03≄\x0ctTildeTilde;\x03≉\x0btCongruent;\x03≢\x0btHumpEqual;\x05â‰Ì¸\x0btLessEqual;\x03≰\x0btLessTilde;\x03≴\x0atLessLess;\x05≪̸\x0atPrecedes;\x03⊀\x0atSucceeds;\x03âŠ\x0atSuperset;\x06⊃⃒\x09tElement;\x03∉\x09tGreater;\x03≯\x08tCupCap;\x03â‰\x08tExists;\x03∄\x08tSubset;\x06⊂⃒\x07tEqual;\x03≠\x07tTilde;\x03â‰\x06Break;\x03â \x06tLess;\x03≮\x03pf;\x03â„•\x02t;\x03⫬",
// Nscr;[ð’©].
"\x03cr;\x04ð’©",
// Ntilde;[Ñ] Ntilde[Ñ].
"\x05ilde;\x02Ñ\x04ilde\x02Ñ",
// Nu;[Î].
"\x01;\x02Î",
// OElig;[Å’].
"\x04lig;\x02Å’",
// Oacute;[Ó] Oacute[Ó].
"\x05cute;\x02Ó\x04cute\x02Ó",
// Ocirc;[Ô] Ocirc[Ô] Ocy;[О].
"\x04irc;\x02Ô\x03irc\x02Ô\x02y;\x02О",
// Odblac;[Å].
"\x05blac;\x02Å",
// Ofr;[ð”’].
"\x02r;\x04ð”’",
// Ograve;[Ã’] Ograve[Ã’].
"\x05rave;\x02Ã’\x04rave\x02Ã’",
// Omicron;[Ο] Omacr;[Ō] Omega;[Ω].
"\x06icron;\x02Ο\x04acr;\x02Ō\x04ega;\x02Ω",
// Oopf;[ð•†].
"\x03pf;\x04ð•†",
// OpenCurlyDoubleQuote;[“] OpenCurlyQuote;[‘].
"\x13enCurlyDoubleQuote;\x03“\x0denCurlyQuote;\x03‘",
// Or;[â©”].
"\x01;\x03â©”",
// Oslash;[Ø] Oslash[Ø] Oscr;[ð’ª].
"\x05lash;\x02Ø\x04lash\x02Ø\x03cr;\x04ð’ª",
// Otilde;[Õ] Otimes;[⨷] Otilde[Õ].
"\x05ilde;\x02Õ\x05imes;\x03⨷\x04ilde\x02Õ",
// Ouml;[Ö] Ouml[Ö].
"\x03ml;\x02Ö\x02ml\x02Ö",
// OverParenthesis;[âœ] OverBracket;[⎴] OverBrace;[âž] OverBar;[‾].
"\x0eerParenthesis;\x03âœ\x0aerBracket;\x03⎴\x08erBrace;\x03âž\x06erBar;\x03‾",
// PartialD;[∂].
"\x07rtialD;\x03∂",
// Pcy;[П].
"\x02y;\x02П",
// Pfr;[ð”“].
"\x02r;\x04ð”“",
// Phi;[Φ].
"\x02i;\x02Φ",
// Pi;[Î ].
"\x01;\x02Î ",
// PlusMinus;[±].
"\x08usMinus;\x02±",
// Poincareplane;[ℌ] Popf;[ℙ].
"\x0cincareplane;\x03ℌ\x03pf;\x03ℙ",
// PrecedesSlantEqual;[≼] PrecedesEqual;[⪯] PrecedesTilde;[≾] Proportional;[âˆ] Proportion;[∷] Precedes;[≺] Product;[âˆ] Prime;[″] Pr;[⪻].
"\x11ecedesSlantEqual;\x03≼\x0cecedesEqual;\x03⪯\x0cecedesTilde;\x03≾\x0boportional;\x03âˆ\x09oportion;\x03∷\x07ecedes;\x03≺\x06oduct;\x03âˆ\x04ime;\x03″\x01;\x03⪻",
// Pscr;[ð’«] Psi;[Ψ].
"\x03cr;\x04ð’«\x02i;\x02Ψ",
// QUOT;[\"] QUOT[\"].
"\x03OT;\x01\"\x02OT\x01\"",
// Qfr;[ð””].
"\x02r;\x04ð””",
// Qopf;[â„š].
"\x03pf;\x03â„š",
// Qscr;[ð’¬].
"\x03cr;\x04ð’¬",
// RBarr;[â¤].
"\x04arr;\x03â¤",
// REG;[®] REG[®].
"\x02G;\x02®\x01G\x02®",
// Racute;[Ŕ] Rarrtl;[⤖] Rang;[⟫] Rarr;[↠].
"\x05cute;\x02Ŕ\x05rrtl;\x03⤖\x03ng;\x03⟫\x03rr;\x03↠",
// Rcaron;[Ř] Rcedil;[Ŗ] Rcy;[Р].
"\x05aron;\x02Ř\x05edil;\x02Ŗ\x02y;\x02Р",
// ReverseUpEquilibrium;[⥯] ReverseEquilibrium;[⇋] ReverseElement;[∋] Re;[ℜ].
"\x13verseUpEquilibrium;\x03⥯\x11verseEquilibrium;\x03⇋\x0dverseElement;\x03∋\x01;\x03ℜ",
// Rfr;[ℜ].
"\x02r;\x03ℜ",
// Rho;[Ρ].
"\x02o;\x02Ρ",
// RightArrowLeftArrow;[⇄] RightDoubleBracket;[⟧] RightDownTeeVector;[â¥] RightDownVectorBar;[⥕] RightTriangleEqual;[⊵] RightAngleBracket;[⟩] RightUpDownVector;[â¥] RightTriangleBar;[â§] RightUpTeeVector;[⥜] RightUpVectorBar;[⥔] RightDownVector;[⇂] RightTeeVector;[⥛] RightVectorBar;[⥓] RightArrowBar;[⇥] RightTeeArrow;[↦] RightTriangle;[⊳] RightUpVector;[↾] RightCeiling;[⌉] RightVector;[⇀] RightArrow;[→] RightFloor;[⌋] Rightarrow;[⇒] RightTee;[⊢].
"\x12ghtArrowLeftArrow;\x03⇄\x11ghtDoubleBracket;\x03⟧\x11ghtDownTeeVector;\x03â¥\x11ghtDownVectorBar;\x03⥕\x11ghtTriangleEqual;\x03⊵\x10ghtAngleBracket;\x03⟩\x10ghtUpDownVector;\x03â¥\x0fghtTriangleBar;\x03â§\x0fghtUpTeeVector;\x03⥜\x0fghtUpVectorBar;\x03⥔\x0eghtDownVector;\x03⇂\x0dghtTeeVector;\x03⥛\x0dghtVectorBar;\x03⥓\x0cghtArrowBar;\x03⇥\x0cghtTeeArrow;\x03↦\x0cghtTriangle;\x03⊳\x0cghtUpVector;\x03↾\x0bghtCeiling;\x03⌉\x0aghtVector;\x03⇀\x09ghtArrow;\x03→\x09ghtFloor;\x03⌋\x09ghtarrow;\x03⇒\x07ghtTee;\x03⊢",
// RoundImplies;[⥰] Ropf;[â„].
"\x0bundImplies;\x03⥰\x03pf;\x03â„",
// Rrightarrow;[⇛].
"\x0aightarrow;\x03⇛",
// Rscr;[ℛ] Rsh;[↱].
"\x03cr;\x03ℛ\x02h;\x03↱",
// RuleDelayed;[⧴].
"\x0aleDelayed;\x03⧴",
// SHCHcy;[Щ] SHcy;[Ш].
"\x05CHcy;\x02Щ\x03cy;\x02Ш",
// SOFTcy;[Ь].
"\x05FTcy;\x02Ь",
// Sacute;[Åš].
"\x05cute;\x02Åš",
// Scaron;[Š] Scedil;[Ş] Scirc;[Ŝ] Scy;[С] Sc;[⪼].
"\x05aron;\x02Š\x05edil;\x02Ş\x04irc;\x02Ŝ\x02y;\x02С\x01;\x03⪼",
// Sfr;[ð”–].
"\x02r;\x04ð”–",
// ShortRightArrow;[→] ShortDownArrow;[↓] ShortLeftArrow;[â†] ShortUpArrow;[↑].
"\x0eortRightArrow;\x03→\x0dortDownArrow;\x03↓\x0dortLeftArrow;\x03â†\x0bortUpArrow;\x03↑",
// Sigma;[Σ].
"\x04gma;\x02Σ",
// SmallCircle;[∘].
"\x0aallCircle;\x03∘",
// Sopf;[ð•Š].
"\x03pf;\x04ð•Š",
// SquareSupersetEqual;[⊒] SquareIntersection;[⊓] SquareSubsetEqual;[⊑] SquareSuperset;[âŠ] SquareSubset;[âŠ] SquareUnion;[⊔] Square;[â–¡] Sqrt;[√].
"\x12uareSupersetEqual;\x03⊒\x11uareIntersection;\x03⊓\x10uareSubsetEqual;\x03⊑\x0duareSuperset;\x03âŠ\x0buareSubset;\x03âŠ\x0auareUnion;\x03⊔\x05uare;\x03â–¡\x03rt;\x03√",
// Sscr;[ð’®].
"\x03cr;\x04ð’®",
// Star;[⋆].
"\x03ar;\x03⋆",
// SucceedsSlantEqual;[≽] SucceedsEqual;[⪰] SucceedsTilde;[≿] SupersetEqual;[⊇] SubsetEqual;[⊆] Succeeds;[≻] SuchThat;[∋] Superset;[⊃] Subset;[â‹] Supset;[â‹‘] Sub;[â‹] Sum;[∑] Sup;[â‹‘].
"\x11cceedsSlantEqual;\x03≽\x0ccceedsEqual;\x03⪰\x0ccceedsTilde;\x03≿\x0cpersetEqual;\x03⊇\x0absetEqual;\x03⊆\x07cceeds;\x03≻\x07chThat;\x03∋\x07perset;\x03⊃\x05bset;\x03â‹\x05pset;\x03â‹‘\x02b;\x03â‹\x02m;\x03∑\x02p;\x03â‹‘",
// THORN;[Þ] THORN[Þ].
"\x04ORN;\x02Þ\x03ORN\x02Þ",
// TRADE;[â„¢].
"\x04ADE;\x03â„¢",
// TSHcy;[Ћ] TScy;[Ц].
"\x04Hcy;\x02Ћ\x03cy;\x02Ц",
// Tab;[\x9] Tau;[Τ].
"\x02b;\x01\x9\x02u;\x02Τ",
// Tcaron;[Ť] Tcedil;[Ţ] Tcy;[Т].
"\x05aron;\x02Ť\x05edil;\x02Ţ\x02y;\x02Т",
// Tfr;[ð”—].
"\x02r;\x04ð”—",
// ThickSpace;[âŸâ€Š] Therefore;[∴] ThinSpace;[ ] Theta;[Θ].
"\x09ickSpace;\x06âŸâ€Š\x08erefore;\x03∴\x08inSpace;\x03 \x04eta;\x02Θ",
// TildeFullEqual;[≅] TildeEqual;[≃] TildeTilde;[≈] Tilde;[∼].
"\x0dldeFullEqual;\x03≅\x09ldeEqual;\x03≃\x09ldeTilde;\x03≈\x04lde;\x03∼",
// Topf;[ð•‹].
"\x03pf;\x04ð•‹",
// TripleDot;[⃛].
"\x08ipleDot;\x03⃛",
// Tstrok;[Ŧ] Tscr;[ð’¯].
"\x05trok;\x02Ŧ\x03cr;\x04ð’¯",
// Uarrocir;[⥉] Uacute;[Ú] Uacute[Ú] Uarr;[↟].
"\x07rrocir;\x03⥉\x05cute;\x02Ú\x04cute\x02Ú\x03rr;\x03↟",
// Ubreve;[Ŭ] Ubrcy;[Ў].
"\x05reve;\x02Ŭ\x04rcy;\x02Ў",
// Ucirc;[Û] Ucirc[Û] Ucy;[У].
"\x04irc;\x02Û\x03irc\x02Û\x02y;\x02У",
// Udblac;[Å°].
"\x05blac;\x02Å°",
// Ufr;[ð”˜].
"\x02r;\x04ð”˜",
// Ugrave;[Ù] Ugrave[Ù].
"\x05rave;\x02Ù\x04rave\x02Ù",
// Umacr;[Ū].
"\x04acr;\x02Ū",
// UnderParenthesis;[â] UnderBracket;[⎵] UnderBrace;[âŸ] UnionPlus;[⊎] UnderBar;[_] Union;[⋃].
"\x0fderParenthesis;\x03â\x0bderBracket;\x03⎵\x09derBrace;\x03âŸ\x08ionPlus;\x03⊎\x07derBar;\x01_\x04ion;\x03⋃",
// Uogon;[Ų] Uopf;[ð•Œ].
"\x04gon;\x02Ų\x03pf;\x04ð•Œ",
// UpArrowDownArrow;[⇅] UpperRightArrow;[↗] UpperLeftArrow;[↖] UpEquilibrium;[⥮] UpDownArrow;[↕] Updownarrow;[⇕] UpArrowBar;[⤒] UpTeeArrow;[↥] UpArrow;[↑] Uparrow;[⇑] Upsilon;[Υ] UpTee;[⊥] Upsi;[ϒ].
"\x0fArrowDownArrow;\x03⇅\x0eperRightArrow;\x03↗\x0dperLeftArrow;\x03↖\x0cEquilibrium;\x03⥮\x0aDownArrow;\x03↕\x0adownarrow;\x03⇕\x09ArrowBar;\x03⤒\x09TeeArrow;\x03↥\x06Arrow;\x03↑\x06arrow;\x03⇑\x06silon;\x02Υ\x04Tee;\x03⊥\x03si;\x02ϒ",
// Uring;[Å®].
"\x04ing;\x02Å®",
// Uscr;[ð’°].
"\x03cr;\x04ð’°",
// Utilde;[Ũ].
"\x05ilde;\x02Ũ",
// Uuml;[Ü] Uuml[Ü].
"\x03ml;\x02Ü\x02ml\x02Ü",
// VDash;[⊫].
"\x04ash;\x03⊫",
// Vbar;[â««].
"\x03ar;\x03â««",
// Vcy;[Ð’].
"\x02y;\x02Ð’",
// Vdashl;[⫦] Vdash;[⊩].
"\x05ashl;\x03⫦\x04ash;\x03⊩",
// VerticalSeparator;[â˜] VerticalTilde;[≀] VeryThinSpace;[ ] VerticalLine;[|] VerticalBar;[∣] Verbar;[‖] Vert;[‖] Vee;[â‹].
"\x10rticalSeparator;\x03â˜\x0crticalTilde;\x03≀\x0cryThinSpace;\x03 \x0brticalLine;\x01|\x0articalBar;\x03∣\x05rbar;\x03‖\x03rt;\x03‖\x02e;\x03â‹",
// Vfr;[ð”™].
"\x02r;\x04ð”™",
// Vopf;[ð•].
"\x03pf;\x04ð•",
// Vscr;[ð’±].
"\x03cr;\x04ð’±",
// Vvdash;[⊪].
"\x05dash;\x03⊪",
// Wcirc;[Å´].
"\x04irc;\x02Å´",
// Wedge;[â‹€].
"\x04dge;\x03â‹€",
// Wfr;[ð”š].
"\x02r;\x04ð”š",
// Wopf;[ð•Ž].
"\x03pf;\x04ð•Ž",
// Wscr;[ð’²].
"\x03cr;\x04ð’²",
// Xfr;[ð”›].
"\x02r;\x04ð”›",
// Xi;[Ξ].
"\x01;\x02Ξ",
// Xopf;[ð•].
"\x03pf;\x04ð•",
// Xscr;[ð’³].
"\x03cr;\x04ð’³",
// YAcy;[Я].
"\x03cy;\x02Я",
// YIcy;[Ї].
"\x03cy;\x02Ї",
// YUcy;[Ю].
"\x03cy;\x02Ю",
// Yacute;[Ã] Yacute[Ã].
"\x05cute;\x02Ã\x04cute\x02Ã",
// Ycirc;[Ŷ] Ycy;[Ы].
"\x04irc;\x02Ŷ\x02y;\x02Ы",
// Yfr;[ð”œ].
"\x02r;\x04ð”œ",
// Yopf;[ð•].
"\x03pf;\x04ð•",
// Yscr;[ð’´].
"\x03cr;\x04ð’´",
// Yuml;[Ÿ].
"\x03ml;\x02Ÿ",
// ZHcy;[Ж].
"\x03cy;\x02Ж",
// Zacute;[Ź].
"\x05cute;\x02Ź",
// Zcaron;[Ž] Zcy;[З].
"\x05aron;\x02Ž\x02y;\x02З",
// Zdot;[Å»].
"\x03ot;\x02Å»",
// ZeroWidthSpace;[​] Zeta;[Ζ].
"\x0droWidthSpace;\x03​\x03ta;\x02Ζ",
// Zfr;[ℨ].
"\x02r;\x03ℨ",
// Zopf;[ℤ].
"\x03pf;\x03ℤ",
// Zscr;[ð’µ].
"\x03cr;\x04ð’µ",
// aacute;[á] aacute[á].
"\x05cute;\x02á\x04cute\x02á",
// abreve;[ă].
"\x05reve;\x02ă",
// acirc;[â] acute;[´] acirc[â] acute[´] acE;[∾̳] acd;[∿] acy;[а] ac;[∾].
"\x04irc;\x02â\x04ute;\x02´\x03irc\x02â\x03ute\x02´\x02E;\x05∾̳\x02d;\x03∿\x02y;\x02а\x01;\x03∾",
// aelig;[æ] aelig[æ].
"\x04lig;\x02æ\x03lig\x02æ",
// afr;[ð”ž] af;[â¡].
"\x02r;\x04ð”ž\x01;\x03â¡",
// agrave;[Ã ] agrave[Ã ].
"\x05rave;\x02Ã \x04rave\x02Ã ",
// alefsym;[ℵ] aleph;[ℵ] alpha;[α].
"\x06efsym;\x03ℵ\x04eph;\x03ℵ\x04pha;\x02α",
// amacr;[Ä] amalg;[⨿] amp;[&] amp[&].
"\x04acr;\x02Ä\x04alg;\x03⨿\x02p;\x01&\x01p\x01&",
// andslope;[⩘] angmsdaa;[⦨] angmsdab;[⦩] angmsdac;[⦪] angmsdad;[⦫] angmsdae;[⦬] angmsdaf;[â¦] angmsdag;[⦮] angmsdah;[⦯] angrtvbd;[â¦] angrtvb;[⊾] angzarr;[â¼] andand;[â©•] angmsd;[∡] angsph;[∢] angle;[∠] angrt;[∟] angst;[Ã…] andd;[â©œ] andv;[â©š] ange;[⦤] and;[∧] ang;[∠].
"\x07dslope;\x03⩘\x07gmsdaa;\x03⦨\x07gmsdab;\x03⦩\x07gmsdac;\x03⦪\x07gmsdad;\x03⦫\x07gmsdae;\x03⦬\x07gmsdaf;\x03â¦\x07gmsdag;\x03⦮\x07gmsdah;\x03⦯\x07grtvbd;\x03â¦\x06grtvb;\x03⊾\x06gzarr;\x03â¼\x05dand;\x03â©•\x05gmsd;\x03∡\x05gsph;\x03∢\x04gle;\x03∠\x04grt;\x03∟\x04gst;\x02Ã…\x03dd;\x03â©œ\x03dv;\x03â©š\x03ge;\x03⦤\x02d;\x03∧\x02g;\x03∠",
// aogon;[Ä…] aopf;[ð•’].
"\x04gon;\x02Ä…\x03pf;\x04ð•’",
// approxeq;[≊] apacir;[⩯] approx;[≈] apid;[≋] apos;['] apE;[⩰] ape;[≊] ap;[≈].
"\x07proxeq;\x03≊\x05acir;\x03⩯\x05prox;\x03≈\x03id;\x03≋\x03os;\x01'\x02E;\x03⩰\x02e;\x03≊\x01;\x03≈",
// aring;[Ã¥] aring[Ã¥].
"\x04ing;\x02Ã¥\x03ing\x02Ã¥",
// asympeq;[â‰] asymp;[≈] ascr;[ð’¶] ast;[*].
"\x06ympeq;\x03â‰\x04ymp;\x03≈\x03cr;\x04ð’¶\x02t;\x01*",
// atilde;[ã] atilde[ã].
"\x05ilde;\x02ã\x04ilde\x02ã",
// auml;[ä] auml[ä].
"\x03ml;\x02ä\x02ml\x02ä",
// awconint;[∳] awint;[⨑].
"\x07conint;\x03∳\x04int;\x03⨑",
// bNot;[â«].
"\x03ot;\x03â«",
// backepsilon;[϶] backprime;[‵] backsimeq;[â‹] backcong;[≌] barwedge;[⌅] backsim;[∽] barvee;[⊽] barwed;[⌅].
"\x0ackepsilon;\x02϶\x08ckprime;\x03‵\x08cksimeq;\x03â‹\x07ckcong;\x03≌\x07rwedge;\x03⌅\x06cksim;\x03∽\x05rvee;\x03⊽\x05rwed;\x03⌅",
// bbrktbrk;[⎶] bbrk;[⎵].
"\x07rktbrk;\x03⎶\x03rk;\x03⎵",
// bcong;[≌] bcy;[б].
"\x04ong;\x03≌\x02y;\x02б",
// bdquo;[„].
"\x04quo;\x03„",
// because;[∵] bemptyv;[⦰] between;[≬] becaus;[∵] bernou;[ℬ] bepsi;[϶] beta;[β] beth;[ℶ].
"\x06cause;\x03∵\x06mptyv;\x03⦰\x06tween;\x03≬\x05caus;\x03∵\x05rnou;\x03ℬ\x04psi;\x02϶\x03ta;\x02β\x03th;\x03ℶ",
// bfr;[ð”Ÿ].
"\x02r;\x04ð”Ÿ",
// bigtriangledown;[â–½] bigtriangleup;[â–³] bigotimes;[⨂] bigoplus;[â¨] bigsqcup;[⨆] biguplus;[⨄] bigwedge;[â‹€] bigcirc;[â—¯] bigodot;[⨀] bigstar;[★] bigcap;[â‹‚] bigcup;[⋃] bigvee;[â‹].
"\x0egtriangledown;\x03â–½\x0cgtriangleup;\x03â–³\x08gotimes;\x03⨂\x07goplus;\x03â¨\x07gsqcup;\x03⨆\x07guplus;\x03⨄\x07gwedge;\x03â‹€\x06gcirc;\x03â—¯\x06godot;\x03⨀\x06gstar;\x03★\x05gcap;\x03â‹‚\x05gcup;\x03⋃\x05gvee;\x03â‹",
// bkarow;[â¤].
"\x05arow;\x03â¤",
// blacktriangleright;[â–¸] blacktriangledown;[â–¾] blacktriangleleft;[â—‚] blacktriangle;[â–´] blacklozenge;[⧫] blacksquare;[â–ª] blank;[â£] blk12;[â–’] blk14;[â–‘] blk34;[â–“] block;[â–ˆ].
"\x11acktriangleright;\x03â–¸\x10acktriangledown;\x03â–¾\x10acktriangleleft;\x03â—‚\x0cacktriangle;\x03â–´\x0backlozenge;\x03⧫\x0aacksquare;\x03â–ª\x04ank;\x03â£\x04k12;\x03â–’\x04k14;\x03â–‘\x04k34;\x03â–“\x04ock;\x03â–ˆ",
// bnequiv;[≡⃥] bnot;[âŒ] bne;[=⃥].
"\x06equiv;\x06≡⃥\x03ot;\x03âŒ\x02e;\x04=⃥",
// boxminus;[⊟] boxtimes;[⊠] boxplus;[⊞] bottom;[⊥] bowtie;[⋈] boxbox;[⧉] boxDL;[â•—] boxDR;[â•”] boxDl;[â•–] boxDr;[â•“] boxHD;[╦] boxHU;[â•©] boxHd;[╤] boxHu;[╧] boxUL;[â•] boxUR;[â•š] boxUl;[â•œ] boxUr;[â•™] boxVH;[╬] boxVL;[â•£] boxVR;[â• ] boxVh;[â•«] boxVl;[â•¢] boxVr;[â•Ÿ] boxdL;[â••] boxdR;[â•’] boxdl;[â”] boxdr;[┌] boxhD;[â•¥] boxhU;[╨] boxhd;[┬] boxhu;[â”´] boxuL;[â•›] boxuR;[╘] boxul;[┘] boxur;[â””] boxvH;[╪] boxvL;[â•¡] boxvR;[â•ž] boxvh;[┼] boxvl;[┤] boxvr;[├] bopf;[ð•“] boxH;[â•] boxV;[â•‘] boxh;[─] boxv;[│] bot;[⊥].
"\x07xminus;\x03⊟\x07xtimes;\x03⊠\x06xplus;\x03⊞\x05ttom;\x03⊥\x05wtie;\x03⋈\x05xbox;\x03⧉\x04xDL;\x03â•—\x04xDR;\x03â•”\x04xDl;\x03â•–\x04xDr;\x03â•“\x04xHD;\x03╦\x04xHU;\x03â•©\x04xHd;\x03╤\x04xHu;\x03╧\x04xUL;\x03â•\x04xUR;\x03â•š\x04xUl;\x03â•œ\x04xUr;\x03â•™\x04xVH;\x03╬\x04xVL;\x03â•£\x04xVR;\x03â• \x04xVh;\x03â•«\x04xVl;\x03â•¢\x04xVr;\x03â•Ÿ\x04xdL;\x03â••\x04xdR;\x03â•’\x04xdl;\x03â”\x04xdr;\x03┌\x04xhD;\x03â•¥\x04xhU;\x03╨\x04xhd;\x03┬\x04xhu;\x03â”´\x04xuL;\x03â•›\x04xuR;\x03╘\x04xul;\x03┘\x04xur;\x03â””\x04xvH;\x03╪\x04xvL;\x03â•¡\x04xvR;\x03â•ž\x04xvh;\x03┼\x04xvl;\x03┤\x04xvr;\x03├\x03pf;\x04ð•“\x03xH;\x03â•\x03xV;\x03â•‘\x03xh;\x03─\x03xv;\x03│\x02t;\x03⊥",
// bprime;[‵].
"\x05rime;\x03‵",
// brvbar;[¦] breve;[˘] brvbar[¦].
"\x05vbar;\x02¦\x04eve;\x02˘\x04vbar\x02¦",
// bsolhsub;[⟈] bsemi;[â] bsime;[â‹] bsolb;[⧅] bscr;[ð’·] bsim;[∽] bsol;[\\].
"\x07olhsub;\x03⟈\x04emi;\x03â\x04ime;\x03â‹\x04olb;\x03⧅\x03cr;\x04ð’·\x03im;\x03∽\x03ol;\x01\\",
// bullet;[•] bumpeq;[â‰] bumpE;[⪮] bumpe;[â‰] bull;[•] bump;[≎].
"\x05llet;\x03•\x05mpeq;\x03â‰\x04mpE;\x03⪮\x04mpe;\x03â‰\x03ll;\x03•\x03mp;\x03≎",
// capbrcup;[⩉] cacute;[ć] capand;[â©„] capcap;[â©‹] capcup;[⩇] capdot;[â©€] caret;[â] caron;[ˇ] caps;[∩︀] cap;[∩].
"\x07pbrcup;\x03⩉\x05cute;\x02ć\x05pand;\x03â©„\x05pcap;\x03â©‹\x05pcup;\x03⩇\x05pdot;\x03â©€\x04ret;\x03â\x04ron;\x02ˇ\x03ps;\x06∩︀\x02p;\x03∩",
// ccupssm;[â©] ccaron;[Ä] ccedil;[ç] ccaps;[â©] ccedil[ç] ccirc;[ĉ] ccups;[â©Œ].
"\x06upssm;\x03â©\x05aron;\x02Ä\x05edil;\x02ç\x04aps;\x03â©\x04edil\x02ç\x04irc;\x02ĉ\x04ups;\x03â©Œ",
// cdot;[Ä‹].
"\x03ot;\x02Ä‹",
// centerdot;[·] cemptyv;[⦲] cedil;[¸] cedil[¸] cent;[¢] cent[¢].
"\x08nterdot;\x02·\x06mptyv;\x03⦲\x04dil;\x02¸\x03dil\x02¸\x03nt;\x02¢\x02nt\x02¢",
// cfr;[ð” ].
"\x02r;\x04ð” ",
// checkmark;[✓] check;[✓] chcy;[ч] chi;[χ].
"\x08eckmark;\x03✓\x04eck;\x03✓\x03cy;\x02ч\x02i;\x02χ",
// circlearrowright;[↻] circlearrowleft;[↺] circledcirc;[⊚] circleddash;[âŠ] circledast;[⊛] circledR;[®] circledS;[Ⓢ] cirfnint;[â¨] cirscir;[⧂] circeq;[≗] cirmid;[⫯] cirE;[⧃] circ;[ˆ] cire;[≗] cir;[â—‹].
"\x0frclearrowright;\x03↻\x0erclearrowleft;\x03↺\x0arcledcirc;\x03⊚\x0arcleddash;\x03âŠ\x09rcledast;\x03⊛\x07rcledR;\x02®\x07rcledS;\x03Ⓢ\x07rfnint;\x03â¨\x06rscir;\x03⧂\x05rceq;\x03≗\x05rmid;\x03⫯\x03rE;\x03⧃\x03rc;\x02ˆ\x03re;\x03≗\x02r;\x03â—‹",
// clubsuit;[♣] clubs;[♣].
"\x07ubsuit;\x03♣\x04ubs;\x03♣",
// complement;[âˆ] complexes;[â„‚] coloneq;[≔] congdot;[â©] colone;[≔] commat;[@] compfn;[∘] conint;[∮] coprod;[âˆ] copysr;[â„—] colon;[:] comma;[,] comp;[âˆ] cong;[≅] copf;[ð•”] copy;[©] copy[©].
"\x09mplement;\x03âˆ\x08mplexes;\x03â„‚\x06loneq;\x03≔\x06ngdot;\x03â©\x05lone;\x03≔\x05mmat;\x01@\x05mpfn;\x03∘\x05nint;\x03∮\x05prod;\x03âˆ\x05pysr;\x03â„—\x04lon;\x01:\x04mma;\x01,\x03mp;\x03âˆ\x03ng;\x03≅\x03pf;\x04ð•”\x03py;\x02©\x02py\x02©",
// crarr;[↵] cross;[✗].
"\x04arr;\x03↵\x04oss;\x03✗",
// csube;[â«‘] csupe;[â«’] cscr;[ð’¸] csub;[â«] csup;[â«].
"\x04ube;\x03â«‘\x04upe;\x03â«’\x03cr;\x04ð’¸\x03ub;\x03â«\x03up;\x03â«",
// ctdot;[⋯].
"\x04dot;\x03⋯",
// curvearrowright;[↷] curvearrowleft;[↶] curlyeqprec;[â‹ž] curlyeqsucc;[â‹Ÿ] curlywedge;[â‹] cupbrcap;[⩈] curlyvee;[â‹Ž] cudarrl;[⤸] cudarrr;[⤵] cularrp;[⤽] curarrm;[⤼] cularr;[↶] cupcap;[⩆] cupcup;[â©Š] cupdot;[âŠ] curarr;[↷] curren;[¤] cuepr;[â‹ž] cuesc;[â‹Ÿ] cupor;[â©…] curren[¤] cuvee;[â‹Ž] cuwed;[â‹] cups;[∪︀] cup;[∪].
"\x0ervearrowright;\x03↷\x0drvearrowleft;\x03↶\x0arlyeqprec;\x03â‹ž\x0arlyeqsucc;\x03â‹Ÿ\x09rlywedge;\x03â‹\x07pbrcap;\x03⩈\x07rlyvee;\x03â‹Ž\x06darrl;\x03⤸\x06darrr;\x03⤵\x06larrp;\x03⤽\x06rarrm;\x03⤼\x05larr;\x03↶\x05pcap;\x03⩆\x05pcup;\x03â©Š\x05pdot;\x03âŠ\x05rarr;\x03↷\x05rren;\x02¤\x04epr;\x03â‹ž\x04esc;\x03â‹Ÿ\x04por;\x03â©…\x04rren\x02¤\x04vee;\x03â‹Ž\x04wed;\x03â‹\x03ps;\x06∪︀\x02p;\x03∪",
// cwconint;[∲] cwint;[∱].
"\x07conint;\x03∲\x04int;\x03∱",
// cylcty;[âŒ].
"\x05lcty;\x03âŒ",
// dArr;[⇓].
"\x03rr;\x03⇓",
// dHar;[⥥].
"\x03ar;\x03⥥",
// dagger;[†] daleth;[ℸ] dashv;[⊣] darr;[↓] dash;[â€].
"\x05gger;\x03†\x05leth;\x03ℸ\x04shv;\x03⊣\x03rr;\x03↓\x03sh;\x03â€",
// dbkarow;[â¤] dblac;[Ë].
"\x06karow;\x03â¤\x04lac;\x02Ë",
// dcaron;[Ä] dcy;[д].
"\x05aron;\x02Ä\x02y;\x02д",
// ddagger;[‡] ddotseq;[⩷] ddarr;[⇊] dd;[ⅆ].
"\x06agger;\x03‡\x06otseq;\x03⩷\x04arr;\x03⇊\x01;\x03ⅆ",
// demptyv;[⦱] delta;[δ] deg;[°] deg[°].
"\x06mptyv;\x03⦱\x04lta;\x02δ\x02g;\x02°\x01g\x02°",
// dfisht;[⥿] dfr;[ð”¡].
"\x05isht;\x03⥿\x02r;\x04ð”¡",
// dharl;[⇃] dharr;[⇂].
"\x04arl;\x03⇃\x04arr;\x03⇂",
// divideontimes;[⋇] diamondsuit;[♦] diamond;[â‹„] digamma;[Ï] divide;[÷] divonx;[⋇] diams;[♦] disin;[⋲] divide[÷] diam;[â‹„] die;[¨] div;[÷].
"\x0cvideontimes;\x03⋇\x0aamondsuit;\x03♦\x06amond;\x03â‹„\x06gamma;\x02Ï\x05vide;\x02÷\x05vonx;\x03⋇\x04ams;\x03♦\x04sin;\x03⋲\x04vide\x02÷\x03am;\x03â‹„\x02e;\x02¨\x02v;\x02÷",
// djcy;[Ñ’].
"\x03cy;\x02Ñ’",
// dlcorn;[⌞] dlcrop;[âŒ].
"\x05corn;\x03⌞\x05crop;\x03âŒ",
// downharpoonright;[⇂] downharpoonleft;[⇃] doublebarwedge;[⌆] downdownarrows;[⇊] dotsquare;[⊡] downarrow;[↓] doteqdot;[≑] dotminus;[∸] dotplus;[∔] dollar;[$] doteq;[â‰] dopf;[ð••] dot;[Ë™].
"\x0fwnharpoonright;\x03⇂\x0ewnharpoonleft;\x03⇃\x0dublebarwedge;\x03⌆\x0dwndownarrows;\x03⇊\x08tsquare;\x03⊡\x08wnarrow;\x03↓\x07teqdot;\x03≑\x07tminus;\x03∸\x06tplus;\x03∔\x05llar;\x01$\x04teq;\x03â‰\x03pf;\x04ð••\x02t;\x02Ë™",
// drbkarow;[â¤] drcorn;[⌟] drcrop;[⌌].
"\x07bkarow;\x03â¤\x05corn;\x03⌟\x05crop;\x03⌌",
// dstrok;[Ä‘] dscr;[ð’¹] dscy;[Ñ•] dsol;[⧶].
"\x05trok;\x02Ä‘\x03cr;\x04ð’¹\x03cy;\x02Ñ•\x03ol;\x03⧶",
// dtdot;[⋱] dtrif;[▾] dtri;[▿].
"\x04dot;\x03⋱\x04rif;\x03▾\x03ri;\x03▿",
// duarr;[⇵] duhar;[⥯].
"\x04arr;\x03⇵\x04har;\x03⥯",
// dwangle;[⦦].
"\x06angle;\x03⦦",
// dzigrarr;[⟿] dzcy;[џ].
"\x07igrarr;\x03⟿\x03cy;\x02џ",
// eDDot;[⩷] eDot;[≑].
"\x04Dot;\x03⩷\x03ot;\x03≑",
// eacute;[é] easter;[⩮] eacute[é].
"\x05cute;\x02é\x05ster;\x03⩮\x04cute\x02é",
// ecaron;[Ä›] ecolon;[≕] ecirc;[ê] ecir;[≖] ecirc[ê] ecy;[Ñ].
"\x05aron;\x02Ä›\x05olon;\x03≕\x04irc;\x02ê\x03ir;\x03≖\x03irc\x02ê\x02y;\x02Ñ",
// edot;[Ä—].
"\x03ot;\x02Ä—",
// ee;[â…‡].
"\x01;\x03â…‡",
// efDot;[≒] efr;[ð”¢].
"\x04Dot;\x03≒\x02r;\x04ð”¢",
// egrave;[è] egsdot;[⪘] egrave[è] egs;[⪖] eg;[⪚].
"\x05rave;\x02è\x05sdot;\x03⪘\x04rave\x02è\x02s;\x03⪖\x01;\x03⪚",
// elinters;[â§] elsdot;[⪗] ell;[â„“] els;[⪕] el;[⪙].
"\x07inters;\x03â§\x05sdot;\x03⪗\x02l;\x03â„“\x02s;\x03⪕\x01;\x03⪙",
// emptyset;[∅] emptyv;[∅] emsp13;[ ] emsp14;[ ] emacr;[ē] empty;[∅] emsp;[ ].
"\x07ptyset;\x03∅\x05ptyv;\x03∅\x05sp13;\x03 \x05sp14;\x03 \x04acr;\x02ē\x04pty;\x03∅\x03sp;\x03 ",
// ensp;[ ] eng;[ŋ].
"\x03sp;\x03 \x02g;\x02ŋ",
// eogon;[Ä™] eopf;[ð•–].
"\x04gon;\x02Ä™\x03pf;\x04ð•–",
// epsilon;[ε] eparsl;[⧣] eplus;[⩱] epsiv;[ϵ] epar;[⋕] epsi;[ε].
"\x06silon;\x02ε\x05arsl;\x03⧣\x04lus;\x03⩱\x04siv;\x02ϵ\x03ar;\x03⋕\x03si;\x02ε",
// eqslantless;[⪕] eqslantgtr;[⪖] eqvparsl;[⧥] eqcolon;[≕] equivDD;[⩸] eqcirc;[≖] equals;[=] equest;[≟] eqsim;[≂] equiv;[≡].
"\x0aslantless;\x03⪕\x09slantgtr;\x03⪖\x07vparsl;\x03⧥\x06colon;\x03≕\x06uivDD;\x03⩸\x05circ;\x03≖\x05uals;\x01=\x05uest;\x03≟\x04sim;\x03≂\x04uiv;\x03≡",
// erDot;[≓] erarr;[⥱].
"\x04Dot;\x03≓\x04arr;\x03⥱",
// esdot;[â‰] escr;[ℯ] esim;[≂].
"\x04dot;\x03â‰\x03cr;\x03ℯ\x03im;\x03≂",
// eta;[η] eth;[ð] eth[ð].
"\x02a;\x02η\x02h;\x02ð\x01h\x02ð",
// euml;[ë] euro;[€] euml[ë].
"\x03ml;\x02ë\x03ro;\x03€\x02ml\x02ë",
// exponentiale;[ⅇ] expectation;[ℰ] exist;[∃] excl;[!].
"\x0bponentiale;\x03ⅇ\x0apectation;\x03ℰ\x04ist;\x03∃\x03cl;\x01!",
// fallingdotseq;[≒].
"\x0cllingdotseq;\x03≒",
// fcy;[Ñ„].
"\x02y;\x02Ñ„",
// female;[♀].
"\x05male;\x03♀",
// ffilig;[ffi] ffllig;[ffl] fflig;[ff] ffr;[ð”£].
"\x05ilig;\x03ffi\x05llig;\x03ffl\x04lig;\x03ff\x02r;\x04ð”£",
// filig;[ï¬].
"\x04lig;\x03ï¬",
// fjlig;[fj].
"\x04lig;\x02fj",
// fllig;[fl] fltns;[â–±] flat;[â™].
"\x04lig;\x03fl\x04tns;\x03â–±\x03at;\x03â™",
// fnof;[Æ’].
"\x03of;\x02Æ’",
// forall;[∀] forkv;[â«™] fopf;[ð•—] fork;[â‹”].
"\x05rall;\x03∀\x04rkv;\x03â«™\x03pf;\x04ð•—\x03rk;\x03â‹”",
// fpartint;[â¨].
"\x07artint;\x03â¨",
// frac12;[½] frac13;[â…“] frac14;[¼] frac15;[â…•] frac16;[â…™] frac18;[â…›] frac23;[â…”] frac25;[â…–] frac34;[¾] frac35;[â…—] frac38;[â…œ] frac45;[â…˜] frac56;[â…š] frac58;[â…] frac78;[â…ž] frac12[½] frac14[¼] frac34[¾] frasl;[â„] frown;[⌢].
"\x05ac12;\x02½\x05ac13;\x03â…“\x05ac14;\x02¼\x05ac15;\x03â…•\x05ac16;\x03â…™\x05ac18;\x03â…›\x05ac23;\x03â…”\x05ac25;\x03â…–\x05ac34;\x02¾\x05ac35;\x03â…—\x05ac38;\x03â…œ\x05ac45;\x03â…˜\x05ac56;\x03â…š\x05ac58;\x03â…\x05ac78;\x03â…ž\x04ac12\x02½\x04ac14\x02¼\x04ac34\x02¾\x04asl;\x03â„\x04own;\x03⌢",
// fscr;[ð’»].
"\x03cr;\x04ð’»",
// gEl;[⪌] gE;[≧].
"\x02l;\x03⪌\x01;\x03≧",
// gacute;[ǵ] gammad;[Ï] gamma;[γ] gap;[⪆].
"\x05cute;\x02ǵ\x05mmad;\x02Ï\x04mma;\x02γ\x02p;\x03⪆",
// gbreve;[ÄŸ].
"\x05reve;\x02ÄŸ",
// gcirc;[Ä] gcy;[г].
"\x04irc;\x02Ä\x02y;\x02г",
// gdot;[Ä¡].
"\x03ot;\x02Ä¡",
// geqslant;[⩾] gesdotol;[⪄] gesdoto;[⪂] gesdot;[⪀] gesles;[⪔] gescc;[⪩] geqq;[≧] gesl;[⋛︀] gel;[⋛] geq;[≥] ges;[⩾] ge;[≥].
"\x07qslant;\x03⩾\x07sdotol;\x03⪄\x06sdoto;\x03⪂\x05sdot;\x03⪀\x05sles;\x03⪔\x04scc;\x03⪩\x03qq;\x03≧\x03sl;\x06⋛︀\x02l;\x03⋛\x02q;\x03≥\x02s;\x03⩾\x01;\x03≥",
// gfr;[ð”¤].
"\x02r;\x04ð”¤",
// ggg;[⋙] gg;[≫].
"\x02g;\x03⋙\x01;\x03≫",
// gimel;[â„·].
"\x04mel;\x03â„·",
// gjcy;[Ñ“].
"\x03cy;\x02Ñ“",
// glE;[⪒] gla;[⪥] glj;[⪤] gl;[≷].
"\x02E;\x03⪒\x02a;\x03⪥\x02j;\x03⪤\x01;\x03≷",
// gnapprox;[⪊] gneqq;[≩] gnsim;[⋧] gnap;[⪊] gneq;[⪈] gnE;[≩] gne;[⪈].
"\x07approx;\x03⪊\x04eqq;\x03≩\x04sim;\x03⋧\x03ap;\x03⪊\x03eq;\x03⪈\x02E;\x03≩\x02e;\x03⪈",
// gopf;[ð•˜].
"\x03pf;\x04ð•˜",
// grave;[`].
"\x04ave;\x01`",
// gsime;[⪎] gsiml;[âª] gscr;[â„Š] gsim;[≳].
"\x04ime;\x03⪎\x04iml;\x03âª\x03cr;\x03â„Š\x03im;\x03≳",
// gtreqqless;[⪌] gtrapprox;[⪆] gtreqless;[⋛] gtquest;[⩼] gtrless;[≷] gtlPar;[⦕] gtrarr;[⥸] gtrdot;[⋗] gtrsim;[≳] gtcir;[⩺] gtdot;[⋗] gtcc;[⪧] gt;[>].
"\x09reqqless;\x03⪌\x08rapprox;\x03⪆\x08reqless;\x03⋛\x06quest;\x03⩼\x06rless;\x03≷\x05lPar;\x03⦕\x05rarr;\x03⥸\x05rdot;\x03⋗\x05rsim;\x03≳\x04cir;\x03⩺\x04dot;\x03⋗\x03cc;\x03⪧\x01;\x01>",
// gvertneqq;[≩︀] gvnE;[≩︀].
"\x08ertneqq;\x06≩︀\x03nE;\x06≩︀",
// hArr;[⇔].
"\x03rr;\x03⇔",
// harrcir;[⥈] hairsp;[ ] hamilt;[â„‹] hardcy;[ÑŠ] harrw;[â†] half;[½] harr;[↔].
"\x06rrcir;\x03⥈\x05irsp;\x03 \x05milt;\x03â„‹\x05rdcy;\x02ÑŠ\x04rrw;\x03â†\x03lf;\x02½\x03rr;\x03↔",
// hbar;[â„].
"\x03ar;\x03â„",
// hcirc;[Ä¥].
"\x04irc;\x02Ä¥",
// heartsuit;[♥] hearts;[♥] hellip;[…] hercon;[⊹].
"\x08artsuit;\x03♥\x05arts;\x03♥\x05llip;\x03…\x05rcon;\x03⊹",
// hfr;[ð”¥].
"\x02r;\x04ð”¥",
// hksearow;[⤥] hkswarow;[⤦].
"\x07searow;\x03⤥\x07swarow;\x03⤦",
// hookrightarrow;[↪] hookleftarrow;[↩] homtht;[∻] horbar;[―] hoarr;[⇿] hopf;[ð•™].
"\x0dokrightarrow;\x03↪\x0cokleftarrow;\x03↩\x05mtht;\x03∻\x05rbar;\x03―\x04arr;\x03⇿\x03pf;\x04ð•™",
// hslash;[â„] hstrok;[ħ] hscr;[ð’½].
"\x05lash;\x03â„\x05trok;\x02ħ\x03cr;\x04ð’½",
// hybull;[âƒ] hyphen;[â€].
"\x05bull;\x03âƒ\x05phen;\x03â€",
// iacute;[Ã] iacute[Ã].
"\x05cute;\x02Ã\x04cute\x02Ã",
// icirc;[î] icirc[î] icy;[и] ic;[â£].
"\x04irc;\x02î\x03irc\x02î\x02y;\x02и\x01;\x03â£",
// iexcl;[¡] iecy;[е] iexcl[¡].
"\x04xcl;\x02¡\x03cy;\x02е\x03xcl\x02¡",
// iff;[⇔] ifr;[ð”¦].
"\x02f;\x03⇔\x02r;\x04ð”¦",
// igrave;[ì] igrave[ì].
"\x05rave;\x02ì\x04rave\x02ì",
// iiiint;[⨌] iinfin;[⧜] iiint;[âˆ] iiota;[â„©] ii;[â…ˆ].
"\x05iint;\x03⨌\x05nfin;\x03⧜\x04int;\x03âˆ\x04ota;\x03â„©\x01;\x03â…ˆ",
// ijlig;[ij].
"\x04lig;\x02ij",
// imagline;[â„] imagpart;[â„‘] imacr;[Ä«] image;[â„‘] imath;[ı] imped;[Ƶ] imof;[⊷].
"\x07agline;\x03â„\x07agpart;\x03â„‘\x04acr;\x02Ä«\x04age;\x03â„‘\x04ath;\x02ı\x04ped;\x02Ƶ\x03of;\x03⊷",
// infintie;[â§] integers;[ℤ] intercal;[⊺] intlarhk;[⨗] intprod;[⨼] incare;[â„…] inodot;[ı] intcal;[⊺] infin;[∞] int;[∫] in;[∈].
"\x07fintie;\x03â§\x07tegers;\x03ℤ\x07tercal;\x03⊺\x07tlarhk;\x03⨗\x06tprod;\x03⨼\x05care;\x03â„…\x05odot;\x02ı\x05tcal;\x03⊺\x04fin;\x03∞\x02t;\x03∫\x01;\x03∈",
// iogon;[į] iocy;[Ñ‘] iopf;[ð•š] iota;[ι].
"\x04gon;\x02į\x03cy;\x02Ñ‘\x03pf;\x04ð•š\x03ta;\x02ι",
// iprod;[⨼].
"\x04rod;\x03⨼",
// iquest;[¿] iquest[¿].
"\x05uest;\x02¿\x04uest\x02¿",
// isindot;[⋵] isinsv;[⋳] isinE;[⋹] isins;[â‹´] isinv;[∈] iscr;[ð’¾] isin;[∈].
"\x06indot;\x03⋵\x05insv;\x03⋳\x04inE;\x03⋹\x04ins;\x03â‹´\x04inv;\x03∈\x03cr;\x04ð’¾\x03in;\x03∈",
// itilde;[Ä©] it;[â¢].
"\x05ilde;\x02Ä©\x01;\x03â¢",
// iukcy;[і] iuml;[ï] iuml[ï].
"\x04kcy;\x02і\x03ml;\x02ï\x02ml\x02ï",
// jcirc;[ĵ] jcy;[й].
"\x04irc;\x02ĵ\x02y;\x02й",
// jfr;[ð”§].
"\x02r;\x04ð”§",
// jmath;[È·].
"\x04ath;\x02È·",
// jopf;[ð•›].
"\x03pf;\x04ð•›",
// jsercy;[ј] jscr;[ð’¿].
"\x05ercy;\x02ј\x03cr;\x04ð’¿",
// jukcy;[Ñ”].
"\x04kcy;\x02Ñ”",
// kappav;[ϰ] kappa;[κ].
"\x05ppav;\x02ϰ\x04ppa;\x02κ",
// kcedil;[ķ] kcy;[к].
"\x05edil;\x02ķ\x02y;\x02к",
// kfr;[ð”¨].
"\x02r;\x04ð”¨",
// kgreen;[ĸ].
"\x05reen;\x02ĸ",
// khcy;[Ñ…].
"\x03cy;\x02Ñ…",
// kjcy;[ќ].
"\x03cy;\x02ќ",
// kopf;[ð•œ].
"\x03pf;\x04ð•œ",
// kscr;[ð“€].
"\x03cr;\x04ð“€",
// lAtail;[⤛] lAarr;[⇚] lArr;[â‡].
"\x05tail;\x03⤛\x04arr;\x03⇚\x03rr;\x03â‡",
// lBarr;[⤎].
"\x04arr;\x03⤎",
// lEg;[⪋] lE;[≦].
"\x02g;\x03⪋\x01;\x03≦",
// lHar;[⥢].
"\x03ar;\x03⥢",
// laemptyv;[⦴] larrbfs;[⤟] larrsim;[⥳] lacute;[ĺ] lagran;[â„’] lambda;[λ] langle;[⟨] larrfs;[â¤] larrhk;[↩] larrlp;[↫] larrpl;[⤹] larrtl;[↢] latail;[⤙] langd;[⦑] laquo;[«] larrb;[⇤] lates;[âªï¸€] lang;[⟨] laquo[«] larr;[â†] late;[âª] lap;[⪅] lat;[⪫].
"\x07emptyv;\x03⦴\x06rrbfs;\x03⤟\x06rrsim;\x03⥳\x05cute;\x02ĺ\x05gran;\x03â„’\x05mbda;\x02λ\x05ngle;\x03⟨\x05rrfs;\x03â¤\x05rrhk;\x03↩\x05rrlp;\x03↫\x05rrpl;\x03⤹\x05rrtl;\x03↢\x05tail;\x03⤙\x04ngd;\x03⦑\x04quo;\x02«\x04rrb;\x03⇤\x04tes;\x06âªï¸€\x03ng;\x03⟨\x03quo\x02«\x03rr;\x03â†\x03te;\x03âª\x02p;\x03⪅\x02t;\x03⪫",
// lbrksld;[â¦] lbrkslu;[â¦] lbrace;[{] lbrack;[[] lbarr;[⤌] lbbrk;[â²] lbrke;[⦋].
"\x06rksld;\x03â¦\x06rkslu;\x03â¦\x05race;\x01{\x05rack;\x01[\x04arr;\x03⤌\x04brk;\x03â²\x04rke;\x03⦋",
// lcaron;[ľ] lcedil;[ļ] lceil;[⌈] lcub;[{] lcy;[л].
"\x05aron;\x02ľ\x05edil;\x02ļ\x04eil;\x03⌈\x03ub;\x01{\x02y;\x02л",
// ldrushar;[⥋] ldrdhar;[⥧] ldquor;[„] ldquo;[“] ldca;[⤶] ldsh;[↲].
"\x07rushar;\x03⥋\x06rdhar;\x03⥧\x05quor;\x03„\x04quo;\x03“\x03ca;\x03⤶\x03sh;\x03↲",
// leftrightsquigarrow;[â†] leftrightharpoons;[⇋] leftharpoondown;[↽] leftrightarrows;[⇆] leftleftarrows;[⇇] leftrightarrow;[↔] leftthreetimes;[â‹‹] leftarrowtail;[↢] leftharpoonup;[↼] lessapprox;[⪅] lesseqqgtr;[⪋] leftarrow;[â†] lesseqgtr;[â‹š] leqslant;[⩽] lesdotor;[⪃] lesdoto;[âª] lessdot;[â‹–] lessgtr;[≶] lesssim;[≲] lesdot;[â©¿] lesges;[⪓] lescc;[⪨] leqq;[≦] lesg;[⋚︀] leg;[â‹š] leq;[≤] les;[⩽] le;[≤].
"\x12ftrightsquigarrow;\x03â†\x10ftrightharpoons;\x03⇋\x0eftharpoondown;\x03↽\x0eftrightarrows;\x03⇆\x0dftleftarrows;\x03⇇\x0dftrightarrow;\x03↔\x0dftthreetimes;\x03â‹‹\x0cftarrowtail;\x03↢\x0cftharpoonup;\x03↼\x09ssapprox;\x03⪅\x09sseqqgtr;\x03⪋\x08ftarrow;\x03â†\x08sseqgtr;\x03â‹š\x07qslant;\x03⩽\x07sdotor;\x03⪃\x06sdoto;\x03âª\x06ssdot;\x03â‹–\x06ssgtr;\x03≶\x06sssim;\x03≲\x05sdot;\x03â©¿\x05sges;\x03⪓\x04scc;\x03⪨\x03qq;\x03≦\x03sg;\x06⋚︀\x02g;\x03â‹š\x02q;\x03≤\x02s;\x03⩽\x01;\x03≤",
// lfisht;[⥼] lfloor;[⌊] lfr;[ð”©].
"\x05isht;\x03⥼\x05loor;\x03⌊\x02r;\x04ð”©",
// lgE;[⪑] lg;[≶].
"\x02E;\x03⪑\x01;\x03≶",
// lharul;[⥪] lhard;[↽] lharu;[↼] lhblk;[▄].
"\x05arul;\x03⥪\x04ard;\x03↽\x04aru;\x03↼\x04blk;\x03▄",
// ljcy;[Ñ™].
"\x03cy;\x02Ñ™",
// llcorner;[⌞] llhard;[⥫] llarr;[⇇] lltri;[◺] ll;[≪].
"\x07corner;\x03⌞\x05hard;\x03⥫\x04arr;\x03⇇\x04tri;\x03◺\x01;\x03≪",
// lmoustache;[⎰] lmidot;[ŀ] lmoust;[⎰].
"\x09oustache;\x03⎰\x05idot;\x02ŀ\x05oust;\x03⎰",
// lnapprox;[⪉] lneqq;[≨] lnsim;[⋦] lnap;[⪉] lneq;[⪇] lnE;[≨] lne;[⪇].
"\x07approx;\x03⪉\x04eqq;\x03≨\x04sim;\x03⋦\x03ap;\x03⪉\x03eq;\x03⪇\x02E;\x03≨\x02e;\x03⪇",
// longleftrightarrow;[⟷] longrightarrow;[⟶] looparrowright;[↬] longleftarrow;[⟵] looparrowleft;[↫] longmapsto;[⟼] lotimes;[⨴] lozenge;[â—Š] loplus;[â¨] lowast;[∗] lowbar;[_] loang;[⟬] loarr;[⇽] lobrk;[⟦] lopar;[⦅] lopf;[ð•] lozf;[⧫] loz;[â—Š].
"\x11ngleftrightarrow;\x03⟷\x0dngrightarrow;\x03⟶\x0doparrowright;\x03↬\x0cngleftarrow;\x03⟵\x0coparrowleft;\x03↫\x09ngmapsto;\x03⟼\x06times;\x03⨴\x06zenge;\x03â—Š\x05plus;\x03â¨\x05wast;\x03∗\x05wbar;\x01_\x04ang;\x03⟬\x04arr;\x03⇽\x04brk;\x03⟦\x04par;\x03⦅\x03pf;\x04ð•\x03zf;\x03⧫\x02z;\x03â—Š",
// lparlt;[⦓] lpar;[(].
"\x05arlt;\x03⦓\x03ar;\x01(",
// lrcorner;[⌟] lrhard;[â¥] lrarr;[⇆] lrhar;[⇋] lrtri;[⊿] lrm;[‎].
"\x07corner;\x03⌟\x05hard;\x03â¥\x04arr;\x03⇆\x04har;\x03⇋\x04tri;\x03⊿\x02m;\x03‎",
// lsaquo;[‹] lsquor;[‚] lstrok;[Å‚] lsime;[âª] lsimg;[âª] lsquo;[‘] lscr;[ð“] lsim;[≲] lsqb;[[] lsh;[↰].
"\x05aquo;\x03‹\x05quor;\x03‚\x05trok;\x02Å‚\x04ime;\x03âª\x04img;\x03âª\x04quo;\x03‘\x03cr;\x04ð“\x03im;\x03≲\x03qb;\x01[\x02h;\x03↰",
// ltquest;[⩻] lthree;[⋋] ltimes;[⋉] ltlarr;[⥶] ltrPar;[⦖] ltcir;[⩹] ltdot;[⋖] ltrie;[⊴] ltrif;[◂] ltcc;[⪦] ltri;[◃] lt;[<].
"\x06quest;\x03⩻\x05hree;\x03⋋\x05imes;\x03⋉\x05larr;\x03⥶\x05rPar;\x03⦖\x04cir;\x03⩹\x04dot;\x03⋖\x04rie;\x03⊴\x04rif;\x03◂\x03cc;\x03⪦\x03ri;\x03◃\x01;\x01<",
// lurdshar;[⥊] luruhar;[⥦].
"\x07rdshar;\x03⥊\x06ruhar;\x03⥦",
// lvertneqq;[≨︀] lvnE;[≨︀].
"\x08ertneqq;\x06≨︀\x03nE;\x06≨︀",
// mDDot;[∺].
"\x04Dot;\x03∺",
// mapstodown;[↧] mapstoleft;[↤] mapstoup;[↥] maltese;[✠] mapsto;[↦] marker;[▮] macr;[¯] male;[♂] malt;[✠] macr[¯] map;[↦].
"\x09pstodown;\x03↧\x09pstoleft;\x03↤\x07pstoup;\x03↥\x06ltese;\x03✠\x05psto;\x03↦\x05rker;\x03▮\x03cr;\x02¯\x03le;\x03♂\x03lt;\x03✠\x02cr\x02¯\x02p;\x03↦",
// mcomma;[⨩] mcy;[м].
"\x05omma;\x03⨩\x02y;\x02м",
// mdash;[—].
"\x04ash;\x03—",
// measuredangle;[∡].
"\x0casuredangle;\x03∡",
// mfr;[ð”ª].
"\x02r;\x04ð”ª",
// mho;[℧].
"\x02o;\x03℧",
// minusdu;[⨪] midast;[*] midcir;[⫰] middot;[·] minusb;[⊟] minusd;[∸] micro;[µ] middot[·] minus;[−] micro[µ] mid;[∣].
"\x06nusdu;\x03⨪\x05dast;\x01*\x05dcir;\x03⫰\x05ddot;\x02·\x05nusb;\x03⊟\x05nusd;\x03∸\x04cro;\x02µ\x04ddot\x02·\x04nus;\x03−\x03cro\x02µ\x02d;\x03∣",
// mlcp;[⫛] mldr;[…].
"\x03cp;\x03⫛\x03dr;\x03…",
// mnplus;[∓].
"\x05plus;\x03∓",
// models;[⊧] mopf;[ð•ž].
"\x05dels;\x03⊧\x03pf;\x04ð•ž",
// mp;[∓].
"\x01;\x03∓",
// mstpos;[∾] mscr;[ð“‚].
"\x05tpos;\x03∾\x03cr;\x04ð“‚",
// multimap;[⊸] mumap;[⊸] mu;[μ].
"\x07ltimap;\x03⊸\x04map;\x03⊸\x01;\x02μ",
// nGtv;[≫̸] nGg;[⋙̸] nGt;[≫⃒].
"\x03tv;\x05≫̸\x02g;\x05⋙̸\x02t;\x06≫⃒",
// nLeftrightarrow;[⇎] nLeftarrow;[â‡] nLtv;[≪̸] nLl;[⋘̸] nLt;[≪⃒].
"\x0eeftrightarrow;\x03⇎\x09eftarrow;\x03â‡\x03tv;\x05≪̸\x02l;\x05⋘̸\x02t;\x06≪⃒",
// nRightarrow;[â‡].
"\x0aightarrow;\x03â‡",
// nVDash;[⊯] nVdash;[⊮].
"\x05Dash;\x03⊯\x05dash;\x03⊮",
// naturals;[ℕ] napprox;[≉] natural;[♮] nacute;[ń] nabla;[∇] napid;[≋̸] napos;[ʼn] natur;[♮] nang;[∠⃒] napE;[⩰̸] nap;[≉].
"\x07turals;\x03ℕ\x06pprox;\x03≉\x06tural;\x03♮\x05cute;\x02ń\x04bla;\x03∇\x04pid;\x05≋̸\x04pos;\x02ʼn\x04tur;\x03♮\x03ng;\x06∠⃒\x03pE;\x05⩰̸\x02p;\x03≉",
// nbumpe;[â‰Ì¸] nbump;[≎̸] nbsp;[ ] nbsp[ ].
"\x05umpe;\x05â‰Ì¸\x04ump;\x05≎̸\x03sp;\x02 \x02sp\x02 ",
// ncongdot;[â©Ì¸] ncaron;[ň] ncedil;[ņ] ncong;[≇] ncap;[⩃] ncup;[â©‚] ncy;[н].
"\x07ongdot;\x05â©Ì¸\x05aron;\x02ň\x05edil;\x02ņ\x04ong;\x03≇\x03ap;\x03⩃\x03up;\x03â©‚\x02y;\x02н",
// ndash;[–].
"\x04ash;\x03–",
// nearrow;[↗] nexists;[∄] nearhk;[⤤] nequiv;[≢] nesear;[⤨] nexist;[∄] neArr;[⇗] nearr;[↗] nedot;[â‰Ì¸] nesim;[≂̸] ne;[≠].
"\x06arrow;\x03↗\x06xists;\x03∄\x05arhk;\x03⤤\x05quiv;\x03≢\x05sear;\x03⤨\x05xist;\x03∄\x04Arr;\x03⇗\x04arr;\x03↗\x04dot;\x05â‰Ì¸\x04sim;\x05≂̸\x01;\x03≠",
// nfr;[ð”«].
"\x02r;\x04ð”«",
// ngeqslant;[⩾̸] ngeqq;[≧̸] ngsim;[≵] ngeq;[≱] nges;[⩾̸] ngtr;[≯] ngE;[≧̸] nge;[≱] ngt;[≯].
"\x08eqslant;\x05⩾̸\x04eqq;\x05≧̸\x04sim;\x03≵\x03eq;\x03≱\x03es;\x05⩾̸\x03tr;\x03≯\x02E;\x05≧̸\x02e;\x03≱\x02t;\x03≯",
// nhArr;[⇎] nharr;[↮] nhpar;[⫲].
"\x04Arr;\x03⇎\x04arr;\x03↮\x04par;\x03⫲",
// nisd;[⋺] nis;[⋼] niv;[∋] ni;[∋].
"\x03sd;\x03⋺\x02s;\x03⋼\x02v;\x03∋\x01;\x03∋",
// njcy;[Ñš].
"\x03cy;\x02Ñš",
// nleftrightarrow;[↮] nleftarrow;[↚] nleqslant;[⩽̸] nltrie;[⋬] nlArr;[â‡] nlarr;[↚] nleqq;[≦̸] nless;[≮] nlsim;[≴] nltri;[⋪] nldr;[‥] nleq;[≰] nles;[⩽̸] nlE;[≦̸] nle;[≰] nlt;[≮].
"\x0eeftrightarrow;\x03↮\x09eftarrow;\x03↚\x08eqslant;\x05⩽̸\x05trie;\x03⋬\x04Arr;\x03â‡\x04arr;\x03↚\x04eqq;\x05≦̸\x04ess;\x03≮\x04sim;\x03≴\x04tri;\x03⋪\x03dr;\x03‥\x03eq;\x03≰\x03es;\x05⩽̸\x02E;\x05≦̸\x02e;\x03≰\x02t;\x03≮",
// nmid;[∤].
"\x03id;\x03∤",
// notindot;[⋵̸] notinva;[∉] notinvb;[â‹·] notinvc;[⋶] notniva;[∌] notnivb;[⋾] notnivc;[⋽] notinE;[⋹̸] notin;[∉] notni;[∌] nopf;[ð•Ÿ] not;[¬] not[¬].
"\x07tindot;\x05⋵̸\x06tinva;\x03∉\x06tinvb;\x03â‹·\x06tinvc;\x03⋶\x06tniva;\x03∌\x06tnivb;\x03⋾\x06tnivc;\x03⋽\x05tinE;\x05⋹̸\x04tin;\x03∉\x04tni;\x03∌\x03pf;\x04ð•Ÿ\x02t;\x02¬\x01t\x02¬",
// nparallel;[∦] npolint;[⨔] npreceq;[⪯̸] nparsl;[⫽⃥] nprcue;[⋠] npart;[∂̸] nprec;[⊀] npar;[∦] npre;[⪯̸] npr;[⊀].
"\x08arallel;\x03∦\x06olint;\x03⨔\x06receq;\x05⪯̸\x05arsl;\x06⫽⃥\x05rcue;\x03⋠\x04art;\x05∂̸\x04rec;\x03⊀\x03ar;\x03∦\x03re;\x05⪯̸\x02r;\x03⊀",
// nrightarrow;[↛] nrarrc;[⤳̸] nrarrw;[â†Ì¸] nrtrie;[â‹] nrArr;[â‡] nrarr;[↛] nrtri;[â‹«].
"\x0aightarrow;\x03↛\x05arrc;\x05⤳̸\x05arrw;\x05â†Ì¸\x05trie;\x03â‹\x04Arr;\x03â‡\x04arr;\x03↛\x04tri;\x03â‹«",
// nshortparallel;[∦] nsubseteqq;[⫅̸] nsupseteqq;[⫆̸] nshortmid;[∤] nsubseteq;[⊈] nsupseteq;[⊉] nsqsube;[â‹¢] nsqsupe;[â‹£] nsubset;[⊂⃒] nsucceq;[⪰̸] nsupset;[⊃⃒] nsccue;[â‹¡] nsimeq;[≄] nsime;[≄] nsmid;[∤] nspar;[∦] nsubE;[⫅̸] nsube;[⊈] nsucc;[âŠ] nsupE;[⫆̸] nsupe;[⊉] nsce;[⪰̸] nscr;[ð“ƒ] nsim;[â‰] nsub;[⊄] nsup;[⊅] nsc;[âŠ].
"\x0dhortparallel;\x03∦\x09ubseteqq;\x05⫅̸\x09upseteqq;\x05⫆̸\x08hortmid;\x03∤\x08ubseteq;\x03⊈\x08upseteq;\x03⊉\x06qsube;\x03â‹¢\x06qsupe;\x03â‹£\x06ubset;\x06⊂⃒\x06ucceq;\x05⪰̸\x06upset;\x06⊃⃒\x05ccue;\x03â‹¡\x05imeq;\x03≄\x04ime;\x03≄\x04mid;\x03∤\x04par;\x03∦\x04ubE;\x05⫅̸\x04ube;\x03⊈\x04ucc;\x03âŠ\x04upE;\x05⫆̸\x04upe;\x03⊉\x03ce;\x05⪰̸\x03cr;\x04ð“ƒ\x03im;\x03â‰\x03ub;\x03⊄\x03up;\x03⊅\x02c;\x03âŠ",
// ntrianglerighteq;[â‹] ntrianglelefteq;[⋬] ntriangleright;[â‹«] ntriangleleft;[⋪] ntilde;[ñ] ntilde[ñ] ntgl;[≹] ntlg;[≸].
"\x0frianglerighteq;\x03â‹\x0erianglelefteq;\x03⋬\x0driangleright;\x03â‹«\x0criangleleft;\x03⋪\x05ilde;\x02ñ\x04ilde\x02ñ\x03gl;\x03≹\x03lg;\x03≸",
// numero;[№] numsp;[ ] num;[#] nu;[ν].
"\x05mero;\x03№\x04msp;\x03 \x02m;\x01#\x01;\x02ν",
// nvinfin;[⧞] nvltrie;[⊴⃒] nvrtrie;[⊵⃒] nvDash;[âŠ] nvHarr;[⤄] nvdash;[⊬] nvlArr;[⤂] nvrArr;[⤃] nvsim;[∼⃒] nvap;[â‰âƒ’] nvge;[≥⃒] nvgt;[>⃒] nvle;[≤⃒] nvlt;[<⃒].
"\x06infin;\x03⧞\x06ltrie;\x06⊴⃒\x06rtrie;\x06⊵⃒\x05Dash;\x03âŠ\x05Harr;\x03⤄\x05dash;\x03⊬\x05lArr;\x03⤂\x05rArr;\x03⤃\x04sim;\x06∼⃒\x03ap;\x06â‰âƒ’\x03ge;\x06≥⃒\x03gt;\x04>⃒\x03le;\x06≤⃒\x03lt;\x04<⃒",
// nwarrow;[↖] nwarhk;[⤣] nwnear;[⤧] nwArr;[⇖] nwarr;[↖].
"\x06arrow;\x03↖\x05arhk;\x03⤣\x05near;\x03⤧\x04Arr;\x03⇖\x04arr;\x03↖",
// oS;[Ⓢ].
"\x01;\x03Ⓢ",
// oacute;[ó] oacute[ó] oast;[⊛].
"\x05cute;\x02ó\x04cute\x02ó\x03st;\x03⊛",
// ocirc;[ô] ocir;[⊚] ocirc[ô] ocy;[о].
"\x04irc;\x02ô\x03ir;\x03⊚\x03irc\x02ô\x02y;\x02о",
// odblac;[Å‘] odsold;[⦼] odash;[âŠ] odiv;[⨸] odot;[⊙].
"\x05blac;\x02Å‘\x05sold;\x03⦼\x04ash;\x03âŠ\x03iv;\x03⨸\x03ot;\x03⊙",
// oelig;[Å“].
"\x04lig;\x02Å“",
// ofcir;[⦿] ofr;[ð”¬].
"\x04cir;\x03⦿\x02r;\x04ð”¬",
// ograve;[ò] ograve[ò] ogon;[Ë›] ogt;[â§].
"\x05rave;\x02ò\x04rave\x02ò\x03on;\x02Ë›\x02t;\x03â§",
// ohbar;[⦵] ohm;[Ω].
"\x04bar;\x03⦵\x02m;\x02Ω",
// oint;[∮].
"\x03nt;\x03∮",
// olcross;[⦻] olarr;[↺] olcir;[⦾] oline;[‾] olt;[⧀].
"\x06cross;\x03⦻\x04arr;\x03↺\x04cir;\x03⦾\x04ine;\x03‾\x02t;\x03⧀",
// omicron;[ο] ominus;[⊖] omacr;[Å] omega;[ω] omid;[⦶].
"\x06icron;\x02ο\x05inus;\x03⊖\x04acr;\x02Å\x04ega;\x02ω\x03id;\x03⦶",
// oopf;[ð• ].
"\x03pf;\x04ð• ",
// operp;[⦹] oplus;[⊕] opar;[⦷].
"\x04erp;\x03⦹\x04lus;\x03⊕\x03ar;\x03⦷",
// orderof;[â„´] orslope;[â©—] origof;[⊶] orarr;[↻] order;[â„´] ordf;[ª] ordm;[º] oror;[â©–] ord;[â©] ordf[ª] ordm[º] orv;[â©›] or;[∨].
"\x06derof;\x03â„´\x06slope;\x03â©—\x05igof;\x03⊶\x04arr;\x03↻\x04der;\x03â„´\x03df;\x02ª\x03dm;\x02º\x03or;\x03â©–\x02d;\x03â©\x02df\x02ª\x02dm\x02º\x02v;\x03â©›\x01;\x03∨",
// oslash;[ø] oslash[ø] oscr;[ℴ] osol;[⊘].
"\x05lash;\x02ø\x04lash\x02ø\x03cr;\x03ℴ\x03ol;\x03⊘",
// otimesas;[⨶] otilde;[õ] otimes;[⊗] otilde[õ].
"\x07imesas;\x03⨶\x05ilde;\x02õ\x05imes;\x03⊗\x04ilde\x02õ",
// ouml;[ö] ouml[ö].
"\x03ml;\x02ö\x02ml\x02ö",
// ovbar;[⌽].
"\x04bar;\x03⌽",
// parallel;[∥] parsim;[⫳] parsl;[⫽] para;[¶] part;[∂] par;[∥] para[¶].
"\x07rallel;\x03∥\x05rsim;\x03⫳\x04rsl;\x03⫽\x03ra;\x02¶\x03rt;\x03∂\x02r;\x03∥\x02ra\x02¶",
// pcy;[п].
"\x02y;\x02п",
// pertenk;[‱] percnt;[%] period;[.] permil;[‰] perp;[⊥].
"\x06rtenk;\x03‱\x05rcnt;\x01%\x05riod;\x01.\x05rmil;\x03‰\x03rp;\x03⊥",
// pfr;[ð”].
"\x02r;\x04ð”",
// phmmat;[ℳ] phone;[☎] phiv;[ϕ] phi;[φ].
"\x05mmat;\x03ℳ\x04one;\x03☎\x03iv;\x02ϕ\x02i;\x02φ",
// pitchfork;[â‹”] piv;[Ï–] pi;[Ï€].
"\x08tchfork;\x03â‹”\x02v;\x02Ï–\x01;\x02Ï€",
// plusacir;[⨣] planckh;[â„Ž] pluscir;[⨢] plussim;[⨦] plustwo;[⨧] planck;[â„] plankv;[â„] plusdo;[∔] plusdu;[⨥] plusmn;[±] plusb;[⊞] pluse;[⩲] plusmn[±] plus;[+].
"\x07usacir;\x03⨣\x06anckh;\x03â„Ž\x06uscir;\x03⨢\x06ussim;\x03⨦\x06ustwo;\x03⨧\x05anck;\x03â„\x05ankv;\x03â„\x05usdo;\x03∔\x05usdu;\x03⨥\x05usmn;\x02±\x04usb;\x03⊞\x04use;\x03⩲\x04usmn\x02±\x03us;\x01+",
// pm;[±].
"\x01;\x02±",
// pointint;[⨕] pound;[£] popf;[ð•¡] pound[£].
"\x07intint;\x03⨕\x04und;\x02£\x03pf;\x04ð•¡\x03und\x02£",
// preccurlyeq;[≼] precnapprox;[⪹] precapprox;[⪷] precneqq;[⪵] precnsim;[⋨] profalar;[⌮] profline;[⌒] profsurf;[⌓] precsim;[≾] preceq;[⪯] primes;[â„™] prnsim;[⋨] propto;[âˆ] prurel;[⊰] prcue;[≼] prime;[′] prnap;[⪹] prsim;[≾] prap;[⪷] prec;[≺] prnE;[⪵] prod;[âˆ] prop;[âˆ] prE;[⪳] pre;[⪯] pr;[≺].
"\x0aeccurlyeq;\x03≼\x0aecnapprox;\x03⪹\x09ecapprox;\x03⪷\x07ecneqq;\x03⪵\x07ecnsim;\x03⋨\x07ofalar;\x03⌮\x07ofline;\x03⌒\x07ofsurf;\x03⌓\x06ecsim;\x03≾\x05eceq;\x03⪯\x05imes;\x03â„™\x05nsim;\x03⋨\x05opto;\x03âˆ\x05urel;\x03⊰\x04cue;\x03≼\x04ime;\x03′\x04nap;\x03⪹\x04sim;\x03≾\x03ap;\x03⪷\x03ec;\x03≺\x03nE;\x03⪵\x03od;\x03âˆ\x03op;\x03âˆ\x02E;\x03⪳\x02e;\x03⪯\x01;\x03≺",
// pscr;[ð“…] psi;[ψ].
"\x03cr;\x04ð“…\x02i;\x02ψ",
// puncsp;[ ].
"\x05ncsp;\x03 ",
// qfr;[ð”®].
"\x02r;\x04ð”®",
// qint;[⨌].
"\x03nt;\x03⨌",
// qopf;[ð•¢].
"\x03pf;\x04ð•¢",
// qprime;[â—].
"\x05rime;\x03â—",
// qscr;[ð“†].
"\x03cr;\x04ð“†",
// quaternions;[â„] quatint;[⨖] questeq;[≟] quest;[?] quot;[\"] quot[\"].
"\x0aaternions;\x03â„\x06atint;\x03⨖\x06esteq;\x03≟\x04est;\x01?\x03ot;\x01\"\x02ot\x01\"",
// rAtail;[⤜] rAarr;[⇛] rArr;[⇒].
"\x05tail;\x03⤜\x04arr;\x03⇛\x03rr;\x03⇒",
// rBarr;[â¤].
"\x04arr;\x03â¤",
// rHar;[⥤].
"\x03ar;\x03⥤",
// rationals;[â„š] raemptyv;[⦳] rarrbfs;[⤠] rarrsim;[⥴] racute;[Å•] rangle;[⟩] rarrap;[⥵] rarrfs;[⤞] rarrhk;[↪] rarrlp;[↬] rarrpl;[⥅] rarrtl;[↣] ratail;[⤚] radic;[√] rangd;[⦒] range;[⦥] raquo;[»] rarrb;[⇥] rarrc;[⤳] rarrw;[â†] ratio;[∶] race;[∽̱] rang;[⟩] raquo[»] rarr;[→].
"\x08tionals;\x03â„š\x07emptyv;\x03⦳\x06rrbfs;\x03⤠\x06rrsim;\x03⥴\x05cute;\x02Å•\x05ngle;\x03⟩\x05rrap;\x03⥵\x05rrfs;\x03⤞\x05rrhk;\x03↪\x05rrlp;\x03↬\x05rrpl;\x03⥅\x05rrtl;\x03↣\x05tail;\x03⤚\x04dic;\x03√\x04ngd;\x03⦒\x04nge;\x03⦥\x04quo;\x02»\x04rrb;\x03⇥\x04rrc;\x03⤳\x04rrw;\x03â†\x04tio;\x03∶\x03ce;\x05∽̱\x03ng;\x03⟩\x03quo\x02»\x03rr;\x03→",
// rbrksld;[⦎] rbrkslu;[â¦] rbrace;[}] rbrack;[]] rbarr;[â¤] rbbrk;[â³] rbrke;[⦌].
"\x06rksld;\x03⦎\x06rkslu;\x03â¦\x05race;\x01}\x05rack;\x01]\x04arr;\x03â¤\x04brk;\x03â³\x04rke;\x03⦌",
// rcaron;[ř] rcedil;[ŗ] rceil;[⌉] rcub;[}] rcy;[р].
"\x05aron;\x02ř\x05edil;\x02ŗ\x04eil;\x03⌉\x03ub;\x01}\x02y;\x02р",
// rdldhar;[⥩] rdquor;[â€] rdquo;[â€] rdca;[⤷] rdsh;[↳].
"\x06ldhar;\x03⥩\x05quor;\x03â€\x04quo;\x03â€\x03ca;\x03⤷\x03sh;\x03↳",
// realpart;[â„œ] realine;[â„›] reals;[â„] real;[â„œ] rect;[â–] reg;[®] reg[®].
"\x07alpart;\x03â„œ\x06aline;\x03â„›\x04als;\x03â„\x03al;\x03â„œ\x03ct;\x03â–\x02g;\x02®\x01g\x02®",
// rfisht;[⥽] rfloor;[⌋] rfr;[ð”¯].
"\x05isht;\x03⥽\x05loor;\x03⌋\x02r;\x04ð”¯",
// rharul;[⥬] rhard;[â‡] rharu;[⇀] rhov;[ϱ] rho;[Ï].
"\x05arul;\x03⥬\x04ard;\x03â‡\x04aru;\x03⇀\x03ov;\x02ϱ\x02o;\x02Ï",
// rightleftharpoons;[⇌] rightharpoondown;[â‡] rightrightarrows;[⇉] rightleftarrows;[⇄] rightsquigarrow;[â†] rightthreetimes;[â‹Œ] rightarrowtail;[↣] rightharpoonup;[⇀] risingdotseq;[≓] rightarrow;[→] ring;[Ëš].
"\x10ghtleftharpoons;\x03⇌\x0fghtharpoondown;\x03â‡\x0fghtrightarrows;\x03⇉\x0eghtleftarrows;\x03⇄\x0eghtsquigarrow;\x03â†\x0eghtthreetimes;\x03â‹Œ\x0dghtarrowtail;\x03↣\x0dghtharpoonup;\x03⇀\x0bsingdotseq;\x03≓\x09ghtarrow;\x03→\x03ng;\x02Ëš",
// rlarr;[⇄] rlhar;[⇌] rlm;[â€].
"\x04arr;\x03⇄\x04har;\x03⇌\x02m;\x03â€",
// rmoustache;[⎱] rmoust;[⎱].
"\x09oustache;\x03⎱\x05oust;\x03⎱",
// rnmid;[â«®].
"\x04mid;\x03â«®",
// rotimes;[⨵] roplus;[⨮] roang;[âŸ] roarr;[⇾] robrk;[⟧] ropar;[⦆] ropf;[ð•£].
"\x06times;\x03⨵\x05plus;\x03⨮\x04ang;\x03âŸ\x04arr;\x03⇾\x04brk;\x03⟧\x04par;\x03⦆\x03pf;\x04ð•£",
// rppolint;[⨒] rpargt;[⦔] rpar;[)].
"\x07polint;\x03⨒\x05argt;\x03⦔\x03ar;\x01)",
// rrarr;[⇉].
"\x04arr;\x03⇉",
// rsaquo;[›] rsquor;[’] rsquo;[’] rscr;[ð“‡] rsqb;[]] rsh;[↱].
"\x05aquo;\x03›\x05quor;\x03’\x04quo;\x03’\x03cr;\x04ð“‡\x03qb;\x01]\x02h;\x03↱",
// rtriltri;[⧎] rthree;[⋌] rtimes;[⋊] rtrie;[⊵] rtrif;[▸] rtri;[▹].
"\x07riltri;\x03⧎\x05hree;\x03⋌\x05imes;\x03⋊\x04rie;\x03⊵\x04rif;\x03▸\x03ri;\x03▹",
// ruluhar;[⥨].
"\x06luhar;\x03⥨",
// rx;[â„ž].
"\x01;\x03â„ž",
// sacute;[Å›].
"\x05cute;\x02Å›",
// sbquo;[‚].
"\x04quo;\x03‚",
// scpolint;[⨓] scaron;[Å¡] scedil;[ÅŸ] scnsim;[â‹©] sccue;[≽] scirc;[Å] scnap;[⪺] scsim;[≿] scap;[⪸] scnE;[⪶] scE;[⪴] sce;[⪰] scy;[Ñ] sc;[≻].
"\x07polint;\x03⨓\x05aron;\x02Å¡\x05edil;\x02ÅŸ\x05nsim;\x03â‹©\x04cue;\x03≽\x04irc;\x02Å\x04nap;\x03⪺\x04sim;\x03≿\x03ap;\x03⪸\x03nE;\x03⪶\x02E;\x03⪴\x02e;\x03⪰\x02y;\x02Ñ\x01;\x03≻",
// sdotb;[⊡] sdote;[⩦] sdot;[⋅].
"\x04otb;\x03⊡\x04ote;\x03⩦\x03ot;\x03⋅",
// setminus;[∖] searrow;[↘] searhk;[⤥] seswar;[⤩] seArr;[⇘] searr;[↘] setmn;[∖] sect;[§] semi;[;] sext;[✶] sect[§].
"\x07tminus;\x03∖\x06arrow;\x03↘\x05arhk;\x03⤥\x05swar;\x03⤩\x04Arr;\x03⇘\x04arr;\x03↘\x04tmn;\x03∖\x03ct;\x02§\x03mi;\x01;\x03xt;\x03✶\x02ct\x02§",
// sfrown;[⌢] sfr;[ð”°].
"\x05rown;\x03⌢\x02r;\x04ð”°",
// shortparallel;[∥] shortmid;[∣] shchcy;[щ] sharp;[♯] shcy;[ш] shy;[Â] shy[Â].
"\x0cortparallel;\x03∥\x07ortmid;\x03∣\x05chcy;\x02щ\x04arp;\x03♯\x03cy;\x02ш\x02y;\x02Â\x01y\x02Â",
// simplus;[⨤] simrarr;[⥲] sigmaf;[Ï‚] sigmav;[Ï‚] simdot;[⩪] sigma;[σ] simeq;[≃] simgE;[⪠] simlE;[⪟] simne;[≆] sime;[≃] simg;[⪞] siml;[âª] sim;[∼].
"\x06mplus;\x03⨤\x06mrarr;\x03⥲\x05gmaf;\x02Ï‚\x05gmav;\x02Ï‚\x05mdot;\x03⩪\x04gma;\x02σ\x04meq;\x03≃\x04mgE;\x03⪠\x04mlE;\x03⪟\x04mne;\x03≆\x03me;\x03≃\x03mg;\x03⪞\x03ml;\x03âª\x02m;\x03∼",
// slarr;[â†].
"\x04arr;\x03â†",
// smallsetminus;[∖] smeparsl;[⧤] smashp;[⨳] smile;[⌣] smtes;[⪬︀] smid;[∣] smte;[⪬] smt;[⪪].
"\x0callsetminus;\x03∖\x07eparsl;\x03⧤\x05ashp;\x03⨳\x04ile;\x03⌣\x04tes;\x06⪬︀\x03id;\x03∣\x03te;\x03⪬\x02t;\x03⪪",
// softcy;[ÑŒ] solbar;[⌿] solb;[⧄] sopf;[ð•¤] sol;[/].
"\x05ftcy;\x02ÑŒ\x05lbar;\x03⌿\x03lb;\x03⧄\x03pf;\x04ð•¤\x02l;\x01/",
// spadesuit;[♠] spades;[♠] spar;[∥].
"\x08adesuit;\x03♠\x05ades;\x03♠\x03ar;\x03∥",
// sqsubseteq;[⊑] sqsupseteq;[⊒] sqsubset;[âŠ] sqsupset;[âŠ] sqcaps;[⊓︀] sqcups;[⊔︀] sqsube;[⊑] sqsupe;[⊒] square;[â–¡] squarf;[â–ª] sqcap;[⊓] sqcup;[⊔] sqsub;[âŠ] sqsup;[âŠ] squf;[â–ª] squ;[â–¡].
"\x09subseteq;\x03⊑\x09supseteq;\x03⊒\x07subset;\x03âŠ\x07supset;\x03âŠ\x05caps;\x06⊓︀\x05cups;\x06⊔︀\x05sube;\x03⊑\x05supe;\x03⊒\x05uare;\x03â–¡\x05uarf;\x03â–ª\x04cap;\x03⊓\x04cup;\x03⊔\x04sub;\x03âŠ\x04sup;\x03âŠ\x03uf;\x03â–ª\x02u;\x03â–¡",
// srarr;[→].
"\x04arr;\x03→",
// ssetmn;[∖] ssmile;[⌣] sstarf;[⋆] sscr;[ð“ˆ].
"\x05etmn;\x03∖\x05mile;\x03⌣\x05tarf;\x03⋆\x03cr;\x04ð“ˆ",
// straightepsilon;[ϵ] straightphi;[ϕ] starf;[★] strns;[¯] star;[☆].
"\x0eraightepsilon;\x02ϵ\x0araightphi;\x02ϕ\x04arf;\x03★\x04rns;\x02¯\x03ar;\x03☆",
// succcurlyeq;[≽] succnapprox;[⪺] subsetneqq;[â«‹] succapprox;[⪸] supsetneqq;[â«Œ] subseteqq;[â«…] subsetneq;[⊊] supseteqq;[⫆] supsetneq;[⊋] subseteq;[⊆] succneqq;[⪶] succnsim;[â‹©] supseteq;[⊇] subedot;[⫃] submult;[â«] subplus;[⪿] subrarr;[⥹] succsim;[≿] supdsub;[⫘] supedot;[â«„] suphsol;[⟉] suphsub;[â«—] suplarr;[⥻] supmult;[â«‚] supplus;[â«€] subdot;[⪽] subset;[⊂] subsim;[⫇] subsub;[â«•] subsup;[â«“] succeq;[⪰] supdot;[⪾] supset;[⊃] supsim;[⫈] supsub;[â«”] supsup;[â«–] subnE;[â«‹] subne;[⊊] supnE;[â«Œ] supne;[⊋] subE;[â«…] sube;[⊆] succ;[≻] sung;[♪] sup1;[¹] sup2;[²] sup3;[³] supE;[⫆] supe;[⊇] sub;[⊂] sum;[∑] sup1[¹] sup2[²] sup3[³] sup;[⊃].
"\x0acccurlyeq;\x03≽\x0accnapprox;\x03⪺\x09bsetneqq;\x03â«‹\x09ccapprox;\x03⪸\x09psetneqq;\x03â«Œ\x08bseteqq;\x03â«…\x08bsetneq;\x03⊊\x08pseteqq;\x03⫆\x08psetneq;\x03⊋\x07bseteq;\x03⊆\x07ccneqq;\x03⪶\x07ccnsim;\x03â‹©\x07pseteq;\x03⊇\x06bedot;\x03⫃\x06bmult;\x03â«\x06bplus;\x03⪿\x06brarr;\x03⥹\x06ccsim;\x03≿\x06pdsub;\x03⫘\x06pedot;\x03â«„\x06phsol;\x03⟉\x06phsub;\x03â«—\x06plarr;\x03⥻\x06pmult;\x03â«‚\x06pplus;\x03â«€\x05bdot;\x03⪽\x05bset;\x03⊂\x05bsim;\x03⫇\x05bsub;\x03â«•\x05bsup;\x03â«“\x05cceq;\x03⪰\x05pdot;\x03⪾\x05pset;\x03⊃\x05psim;\x03⫈\x05psub;\x03â«”\x05psup;\x03â«–\x04bnE;\x03â«‹\x04bne;\x03⊊\x04pnE;\x03â«Œ\x04pne;\x03⊋\x03bE;\x03â«…\x03be;\x03⊆\x03cc;\x03≻\x03ng;\x03♪\x03p1;\x02¹\x03p2;\x02²\x03p3;\x02³\x03pE;\x03⫆\x03pe;\x03⊇\x02b;\x03⊂\x02m;\x03∑\x02p1\x02¹\x02p2\x02²\x02p3\x02³\x02p;\x03⊃",
// swarrow;[↙] swarhk;[⤦] swnwar;[⤪] swArr;[⇙] swarr;[↙].
"\x06arrow;\x03↙\x05arhk;\x03⤦\x05nwar;\x03⤪\x04Arr;\x03⇙\x04arr;\x03↙",
// szlig;[ß] szlig[ß].
"\x04lig;\x02ß\x03lig\x02ß",
// target;[⌖] tau;[τ].
"\x05rget;\x03⌖\x02u;\x02τ",
// tbrk;[⎴].
"\x03rk;\x03⎴",
// tcaron;[Å¥] tcedil;[Å£] tcy;[Ñ‚].
"\x05aron;\x02Å¥\x05edil;\x02Å£\x02y;\x02Ñ‚",
// tdot;[⃛].
"\x03ot;\x03⃛",
// telrec;[⌕].
"\x05lrec;\x03⌕",
// tfr;[ð”±].
"\x02r;\x04ð”±",
// thickapprox;[≈] therefore;[∴] thetasym;[ϑ] thicksim;[∼] there4;[∴] thetav;[ϑ] thinsp;[ ] thksim;[∼] theta;[θ] thkap;[≈] thorn;[þ] thorn[þ].
"\x0aickapprox;\x03≈\x08erefore;\x03∴\x07etasym;\x02ϑ\x07icksim;\x03∼\x05ere4;\x03∴\x05etav;\x02ϑ\x05insp;\x03 \x05ksim;\x03∼\x04eta;\x02θ\x04kap;\x03≈\x04orn;\x02þ\x03orn\x02þ",
// timesbar;[⨱] timesb;[⊠] timesd;[⨰] tilde;[Ëœ] times;[×] times[×] tint;[âˆ].
"\x07mesbar;\x03⨱\x05mesb;\x03⊠\x05mesd;\x03⨰\x04lde;\x02Ëœ\x04mes;\x02×\x03mes\x02×\x03nt;\x03âˆ",
// topfork;[â«š] topbot;[⌶] topcir;[⫱] toea;[⤨] topf;[ð•¥] tosa;[⤩] top;[⊤].
"\x06pfork;\x03â«š\x05pbot;\x03⌶\x05pcir;\x03⫱\x03ea;\x03⤨\x03pf;\x04ð•¥\x03sa;\x03⤩\x02p;\x03⊤",
// tprime;[‴].
"\x05rime;\x03‴",
// trianglerighteq;[⊵] trianglelefteq;[⊴] triangleright;[â–¹] triangledown;[â–¿] triangleleft;[â—ƒ] triangleq;[≜] triangle;[â–µ] triminus;[⨺] trpezium;[â¢] triplus;[⨹] tritime;[⨻] tridot;[â—¬] trade;[â„¢] trisb;[â§] trie;[≜].
"\x0eianglerighteq;\x03⊵\x0dianglelefteq;\x03⊴\x0ciangleright;\x03â–¹\x0biangledown;\x03â–¿\x0biangleleft;\x03â—ƒ\x08iangleq;\x03≜\x07iangle;\x03â–µ\x07iminus;\x03⨺\x07pezium;\x03â¢\x06iplus;\x03⨹\x06itime;\x03⨻\x05idot;\x03â—¬\x04ade;\x03â„¢\x04isb;\x03â§\x03ie;\x03≜",
// tstrok;[ŧ] tshcy;[Ñ›] tscr;[ð“‰] tscy;[ц].
"\x05trok;\x02ŧ\x04hcy;\x02Ñ›\x03cr;\x04ð“‰\x03cy;\x02ц",
// twoheadrightarrow;[↠] twoheadleftarrow;[↞] twixt;[≬].
"\x10oheadrightarrow;\x03↠\x0foheadleftarrow;\x03↞\x04ixt;\x03≬",
// uArr;[⇑].
"\x03rr;\x03⇑",
// uHar;[⥣].
"\x03ar;\x03⥣",
// uacute;[ú] uacute[ú] uarr;[↑].
"\x05cute;\x02ú\x04cute\x02ú\x03rr;\x03↑",
// ubreve;[Å] ubrcy;[Ñž].
"\x05reve;\x02Å\x04rcy;\x02Ñž",
// ucirc;[û] ucirc[û] ucy;[у].
"\x04irc;\x02û\x03irc\x02û\x02y;\x02у",
// udblac;[ű] udarr;[⇅] udhar;[⥮].
"\x05blac;\x02ű\x04arr;\x03⇅\x04har;\x03⥮",
// ufisht;[⥾] ufr;[ð”²].
"\x05isht;\x03⥾\x02r;\x04ð”²",
// ugrave;[ù] ugrave[ù].
"\x05rave;\x02ù\x04rave\x02ù",
// uharl;[↿] uharr;[↾] uhblk;[▀].
"\x04arl;\x03↿\x04arr;\x03↾\x04blk;\x03▀",
// ulcorner;[⌜] ulcorn;[⌜] ulcrop;[âŒ] ultri;[â—¸].
"\x07corner;\x03⌜\x05corn;\x03⌜\x05crop;\x03âŒ\x04tri;\x03â—¸",
// umacr;[ū] uml;[¨] uml[¨].
"\x04acr;\x02ū\x02l;\x02¨\x01l\x02¨",
// uogon;[ų] uopf;[ð•¦].
"\x04gon;\x02ų\x03pf;\x04ð•¦",
// upharpoonright;[↾] upharpoonleft;[↿] updownarrow;[↕] upuparrows;[⇈] uparrow;[↑] upsilon;[υ] uplus;[⊎] upsih;[ϒ] upsi;[υ].
"\x0dharpoonright;\x03↾\x0charpoonleft;\x03↿\x0adownarrow;\x03↕\x09uparrows;\x03⇈\x06arrow;\x03↑\x06silon;\x02υ\x04lus;\x03⊎\x04sih;\x02ϒ\x03si;\x02υ",
// urcorner;[âŒ] urcorn;[âŒ] urcrop;[⌎] uring;[ů] urtri;[â—¹].
"\x07corner;\x03âŒ\x05corn;\x03âŒ\x05crop;\x03⌎\x04ing;\x02ů\x04tri;\x03â—¹",
// uscr;[ð“Š].
"\x03cr;\x04ð“Š",
// utilde;[Å©] utdot;[â‹°] utrif;[â–´] utri;[â–µ].
"\x05ilde;\x02Å©\x04dot;\x03â‹°\x04rif;\x03â–´\x03ri;\x03â–µ",
// uuarr;[⇈] uuml;[ü] uuml[ü].
"\x04arr;\x03⇈\x03ml;\x02ü\x02ml\x02ü",
// uwangle;[⦧].
"\x06angle;\x03⦧",
// vArr;[⇕].
"\x03rr;\x03⇕",
// vBarv;[⫩] vBar;[⫨].
"\x04arv;\x03⫩\x03ar;\x03⫨",
// vDash;[⊨].
"\x04ash;\x03⊨",
// vartriangleright;[⊳] vartriangleleft;[⊲] varsubsetneqq;[⫋︀] varsupsetneqq;[⫌︀] varsubsetneq;[⊊︀] varsupsetneq;[⊋︀] varepsilon;[ϵ] varnothing;[∅] varpropto;[âˆ] varkappa;[Ï°] varsigma;[Ï‚] vartheta;[Ï‘] vangrt;[⦜] varphi;[Ï•] varrho;[ϱ] varpi;[Ï–] varr;[↕].
"\x0frtriangleright;\x03⊳\x0ertriangleleft;\x03⊲\x0crsubsetneqq;\x06⫋︀\x0crsupsetneqq;\x06⫌︀\x0brsubsetneq;\x06⊊︀\x0brsupsetneq;\x06⊋︀\x09repsilon;\x02ϵ\x09rnothing;\x03∅\x08rpropto;\x03âˆ\x07rkappa;\x02Ï°\x07rsigma;\x02Ï‚\x07rtheta;\x02Ï‘\x05ngrt;\x03⦜\x05rphi;\x02Ï•\x05rrho;\x02ϱ\x04rpi;\x02Ï–\x03rr;\x03↕",
// vcy;[в].
"\x02y;\x02в",
// vdash;[⊢].
"\x04ash;\x03⊢",
// veebar;[⊻] vellip;[⋮] verbar;[|] veeeq;[≚] vert;[|] vee;[∨].
"\x05ebar;\x03⊻\x05llip;\x03⋮\x05rbar;\x01|\x04eeq;\x03≚\x03rt;\x01|\x02e;\x03∨",
// vfr;[ð”³].
"\x02r;\x04ð”³",
// vltri;[⊲].
"\x04tri;\x03⊲",
// vnsub;[⊂⃒] vnsup;[⊃⃒].
"\x04sub;\x06⊂⃒\x04sup;\x06⊃⃒",
// vopf;[ð•§].
"\x03pf;\x04ð•§",
// vprop;[âˆ].
"\x04rop;\x03âˆ",
// vrtri;[⊳].
"\x04tri;\x03⊳",
// vsubnE;[⫋︀] vsubne;[⊊︀] vsupnE;[⫌︀] vsupne;[⊋︀] vscr;[ð“‹].
"\x05ubnE;\x06⫋︀\x05ubne;\x06⊊︀\x05upnE;\x06⫌︀\x05upne;\x06⊋︀\x03cr;\x04ð“‹",
// vzigzag;[⦚].
"\x06igzag;\x03⦚",
// wcirc;[ŵ].
"\x04irc;\x02ŵ",
// wedbar;[⩟] wedgeq;[≙] weierp;[℘] wedge;[∧].
"\x05dbar;\x03⩟\x05dgeq;\x03≙\x05ierp;\x03℘\x04dge;\x03∧",
// wfr;[ð”´].
"\x02r;\x04ð”´",
// wopf;[ð•¨].
"\x03pf;\x04ð•¨",
// wp;[℘].
"\x01;\x03℘",
// wreath;[≀] wr;[≀].
"\x05eath;\x03≀\x01;\x03≀",
// wscr;[ð“Œ].
"\x03cr;\x04ð“Œ",
// xcirc;[◯] xcap;[⋂] xcup;[⋃].
"\x04irc;\x03◯\x03ap;\x03⋂\x03up;\x03⋃",
// xdtri;[â–½].
"\x04tri;\x03â–½",
// xfr;[ð”µ].
"\x02r;\x04ð”µ",
// xhArr;[⟺] xharr;[⟷].
"\x04Arr;\x03⟺\x04arr;\x03⟷",
// xi;[ξ].
"\x01;\x02ξ",
// xlArr;[⟸] xlarr;[⟵].
"\x04Arr;\x03⟸\x04arr;\x03⟵",
// xmap;[⟼].
"\x03ap;\x03⟼",
// xnis;[â‹»].
"\x03is;\x03â‹»",
// xoplus;[â¨] xotime;[⨂] xodot;[⨀] xopf;[ð•©].
"\x05plus;\x03â¨\x05time;\x03⨂\x04dot;\x03⨀\x03pf;\x04ð•©",
// xrArr;[⟹] xrarr;[⟶].
"\x04Arr;\x03⟹\x04arr;\x03⟶",
// xsqcup;[⨆] xscr;[ð“].
"\x05qcup;\x03⨆\x03cr;\x04ð“",
// xuplus;[⨄] xutri;[△].
"\x05plus;\x03⨄\x04tri;\x03△",
// xvee;[â‹].
"\x03ee;\x03â‹",
// xwedge;[â‹€].
"\x05edge;\x03â‹€",
// yacute;[ý] yacute[ý] yacy;[Ñ].
"\x05cute;\x02ý\x04cute\x02ý\x03cy;\x02Ñ",
// ycirc;[Å·] ycy;[Ñ‹].
"\x04irc;\x02Å·\x02y;\x02Ñ‹",
// yen;[Â¥] yen[Â¥].
"\x02n;\x02Â¥\x01n\x02Â¥",
// yfr;[ð”¶].
"\x02r;\x04ð”¶",
// yicy;[Ñ—].
"\x03cy;\x02Ñ—",
// yopf;[ð•ª].
"\x03pf;\x04ð•ª",
// yscr;[ð“Ž].
"\x03cr;\x04ð“Ž",
// yucy;[ю] yuml;[ÿ] yuml[ÿ].
"\x03cy;\x02ю\x03ml;\x02ÿ\x02ml\x02ÿ",
// zacute;[ź].
"\x05cute;\x02ź",
// zcaron;[ž] zcy;[з].
"\x05aron;\x02ž\x02y;\x02з",
// zdot;[ż].
"\x03ot;\x02ż",
// zeetrf;[ℨ] zeta;[ζ].
"\x05etrf;\x03ℨ\x03ta;\x02ζ",
// zfr;[ð”·].
"\x02r;\x04ð”·",
// zhcy;[ж].
"\x03cy;\x02ж",
// zigrarr;[â‡].
"\x06grarr;\x03â‡",
// zopf;[ð•«].
"\x03pf;\x04ð•«",
// zscr;[ð“].
"\x03cr;\x04ð“",
// zwnj;[‌] zwj;[â€].
"\x03nj;\x03‌\x02j;\x03â€",
),
"small_words" => "GT\x00LT\x00gt\x00lt\x00",
"small_mappings" => array(
">",
"<",
">",
"<",
)
)
);
PK ÷L\ÄÔ|K K class-wp-html-span.phpnu „[µü¤ start = $start;
$this->length = $length;
}
}
PK ÷L\$gh " class-wp-html-text-replacement.phpnu „[µü¤ PK ÷L\.„ª²4A 4A Ó class-wp-html-decoder.phpnu „[µü¤ PK ÷L\ûw5H×
×
! PG class-wp-html-attribute-token.phpnu „[µü¤ PK ÷L\y
&c &c xR class-wp-html-doctype-info.phpnu „[µü¤ PK ÷L\ 2W ' ìµ class-wp-html-unsupported-exception.phpnu „[µü¤ PK ÷L\A›g ÎW ÎW YÄ class-wp-html-open-elements.phpnu „[µü¤ PK ÷L\ãdÔ±` ` , v class-wp-html-active-formatting-elements.phpnu „[µü¤ PK ÷L\º³
Fg g 29 class-wp-html-stack-event.phpnu „[µü¤ PK ÷L\Ù‰ÄR
R
æ? class-wp-html-token.phpnu „[µü¤ PK ÷L\ŠŠ_3¿A ¿A M class-wp-html-processor.phpnu „[µü¤ PK ÷L\¢†lRG, G, ! ‰ class-wp-html-processor-state.phpnu „[µü¤ PK ÷L\_Yï€XN XN !¼ class-wp-html-tag-processor.phpnu „[µü¤ PK ÷L\ׯ¥¥#9 #9 $ È
html5-named-character-references.phpnu „[µü¤ PK ÷L\ÄÔ|K K ?D class-wp-html-span.phpnu „[µü¤ PK 5 ÐH