<h2>Editing File: /home/xaimptsg/almasupplies.store/wp-includes/html-api/class-wp-html-open-elements.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 * HTML API: WP_HTML_Open_Elements class
 *
 * @package WordPress
 * @subpackage HTML-API
 * @since 6.4.0
 */

/**
 * Core class used by the HTML processor during HTML parsing
 * for managing the stack of open elements.
 *
 * This class is designed for internal use by the HTML processor.
 *
 * &gt; Initially, the stack of open elements is empty. The stack grows
 * &gt; downwards; the topmost node on the stack is the first one added
 * &gt; to the stack, and the bottommost node of the stack is the most
 * &gt; recently added node in the stack (notwithstanding when the stack
 * &gt; is manipulated in a random access fashion as part of the handling
 * &gt; for misnested tags).
 *
 * @since 6.4.0
 *
 * @access private
 *
 * @see https://html.spec.whatwg.org/#stack-of-open-elements
 * @see WP_HTML_Processor
 */
class WP_HTML_Open_Elements {
	/**
	 * Holds the stack of open element references.
	 *
	 * @since 6.4.0
	 *
	 * @var WP_HTML_Token[]
	 */
	public $stack = array();

	/**
	 * Whether a P element is in button scope currently.
	 *
	 * This class optimizes scope lookup by pre-calculating
	 * this value when elements are added and removed to the
	 * stack of open elements which might change its value.
	 * This avoids frequent iteration over the stack.
	 *
	 * @since 6.4.0
	 *
	 * @var bool
	 */
	private $has_p_in_button_scope = false;

	/**
	 * A function that will be called when an item is popped off the stack of open elements.
	 *
	 * The function will be called with the popped item as its argument.
	 *
	 * @since 6.6.0
	 *
	 * @var Closure|null
	 */
	private $pop_handler = null;

	/**
	 * A function that will be called when an item is pushed onto the stack of open elements.
	 *
	 * The function will be called with the pushed item as its argument.
	 *
	 * @since 6.6.0
	 *
	 * @var Closure|null
	 */
	private $push_handler = null;

	/**
	 * Sets a pop handler that will be called when an item is popped off the stack of
	 * open elements.
	 *
	 * The function will be called with the pushed item as its argument.
	 *
	 * @since 6.6.0
	 *
	 * @param Closure $handler The handler function.
	 */
	public function set_pop_handler( Closure $handler ): void {
		$this-&gt;pop_handler = $handler;
	}

	/**
	 * Sets a push handler that will be called when an item is pushed onto the stack of
	 * open elements.
	 *
	 * The function will be called with the pushed item as its argument.
	 *
	 * @since 6.6.0
	 *
	 * @param Closure $handler The handler function.
	 */
	public function set_push_handler( Closure $handler ): void {
		$this-&gt;push_handler = $handler;
	}

	/**
	 * Returns the name of the node at the nth position on the stack
	 * of open elements, or `null` if no such position exists.
	 *
	 * Note that this uses a 1-based index, which represents the
	 * &quot;nth item&quot; on the stack, counting from the top, where the
	 * top-most element is the 1st, the second is the 2nd, etc...
	 *
	 * @since 6.7.0
	 *
	 * @param int $nth Retrieve the nth item on the stack, with 1 being
	 *                 the top element, 2 being the second, etc...
	 * @return WP_HTML_Token|null Name of the node on the stack at the given location,
	 *                            or `null` if the location isn't on the stack.
	 */
	public function at( int $nth ): ?WP_HTML_Token {
		foreach ( $this-&gt;walk_down() as $item ) {
			if ( 0 === --$nth ) {
				return $item;
			}
		}

		return null;
	}

	/**
	 * Reports if a node of a given name is in the stack of open elements.
	 *
	 * @since 6.7.0
	 *
	 * @param string $node_name Name of node for which to check.
	 * @return bool Whether a node of the given name is in the stack of open elements.
	 */
	public function contains( string $node_name ): bool {
		foreach ( $this-&gt;walk_up() as $item ) {
			if ( $node_name === $item-&gt;node_name ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Reports if a specific node is in the stack of open elements.
	 *
	 * @since 6.4.0
	 *
	 * @param WP_HTML_Token $token Look for this node in the stack.
	 * @return bool Whether the referenced node is in the stack of open elements.
	 */
	public function contains_node( WP_HTML_Token $token ): bool {
		foreach ( $this-&gt;walk_up() as $item ) {
			if ( $token === $item ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Returns how many nodes are currently in the stack of open elements.
	 *
	 * @since 6.4.0
	 *
	 * @return int How many node are in the stack of open elements.
	 */
	public function count(): int {
		return count( $this-&gt;stack );
	}

	/**
	 * Returns the node at the end of the stack of open elements,
	 * if one exists. If the stack is empty, returns null.
	 *
	 * @since 6.4.0
	 *
	 * @return WP_HTML_Token|null Last node in the stack of open elements, if one exists, otherwise null.
	 */
	public function current_node(): ?WP_HTML_Token {
		$current_node = end( $this-&gt;stack );

		return $current_node ? $current_node : null;
	}

	/**
	 * Indicates if the current node is of a given type or name.
	 *
	 * It's possible to pass either a node type or a node name to this function.
	 * In the case there is no current element it will always return `false`.
	 *
	 * Example:
	 *
	 *     // Is the current node a text node?
	 *     $stack-&gt;current_node_is( '#text' );
	 *
	 *     // Is the current node a DIV element?
	 *     $stack-&gt;current_node_is( 'DIV' );
	 *
	 *     // Is the current node any element/tag?
	 *     $stack-&gt;current_node_is( '#tag' );
	 *
	 * @see WP_HTML_Tag_Processor::get_token_type
	 * @see WP_HTML_Tag_Processor::get_token_name
	 *
	 * @since 6.7.0
	 *
	 * @access private
	 *
	 * @param string $identity Check if the current node has this name or type (depending on what is provided).
	 * @return bool Whether there is a current element that matches the given identity, whether a token name or type.
	 */
	public function current_node_is( string $identity ): bool {
		$current_node = end( $this-&gt;stack );
		if ( false === $current_node ) {
			return false;
		}

		$current_node_name = $current_node-&gt;node_name;

		return (
			$current_node_name === $identity ||
			( '#doctype' === $identity &amp;&amp; 'html' === $current_node_name ) ||
			( '#tag' === $identity &amp;&amp; ctype_upper( $current_node_name ) )
		);
	}

	/**
	 * Returns whether an element is in a specific scope.
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-the-specific-scope
	 *
	 * @param string   $tag_name         Name of tag check.
	 * @param string[] $termination_list List of elements that terminate the search.
	 * @return bool Whether the element was found in a specific scope.
	 */
	public function has_element_in_specific_scope( string $tag_name, $termination_list ): bool {
		foreach ( $this-&gt;walk_up() as $node ) {
			$namespaced_name = 'html' === $node-&gt;namespace
				? $node-&gt;node_name
				: &quot;{$node-&gt;namespace} {$node-&gt;node_name}&quot;;

			if ( $namespaced_name === $tag_name ) {
				return true;
			}

			if (
				'(internal: H1 through H6 - do not use)' === $tag_name &amp;&amp;
				in_array( $namespaced_name, array( 'H1', 'H2', 'H3', 'H4', 'H5', 'H6' ), true )
			) {
				return true;
			}

			if ( in_array( $namespaced_name, $termination_list, true ) ) {
				return false;
			}
		}

		return false;
	}

	/**
	 * Returns whether a particular element is in scope.
	 *
	 * &gt; The stack of open elements is said to have a particular element in
	 * &gt; scope when it has that element in the specific scope consisting of
	 * &gt; the following element types:
	 * &gt;
	 * &gt;   - applet
	 * &gt;   - caption
	 * &gt;   - html
	 * &gt;   - table
	 * &gt;   - td
	 * &gt;   - th
	 * &gt;   - marquee
	 * &gt;   - object
	 * &gt;   - template
	 * &gt;   - MathML mi
	 * &gt;   - MathML mo
	 * &gt;   - MathML mn
	 * &gt;   - MathML ms
	 * &gt;   - MathML mtext
	 * &gt;   - MathML annotation-xml
	 * &gt;   - SVG foreignObject
	 * &gt;   - SVG desc
	 * &gt;   - SVG title
	 *
	 * @since 6.4.0
	 * @since 6.7.0 Full support.
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-scope
	 *
	 * @param string $tag_name Name of tag to check.
	 * @return bool Whether given element is in scope.
	 */
	public function has_element_in_scope( string $tag_name ): bool {
		return $this-&gt;has_element_in_specific_scope(
			$tag_name,
			array(
				'APPLET',
				'CAPTION',
				'HTML',
				'TABLE',
				'TD',
				'TH',
				'MARQUEE',
				'OBJECT',
				'TEMPLATE',

				'math MI',
				'math MO',
				'math MN',
				'math MS',
				'math MTEXT',
				'math ANNOTATION-XML',

				'svg FOREIGNOBJECT',
				'svg DESC',
				'svg TITLE',
			)
		);
	}

	/**
	 * Returns whether a particular element is in list item scope.
	 *
	 * &gt; The stack of open elements is said to have a particular element
	 * &gt; in list item scope when it has that element in the specific scope
	 * &gt; consisting of the following element types:
	 * &gt;
	 * &gt;   - All the element types listed above for the has an element in scope algorithm.
	 * &gt;   - ol in the HTML namespace
	 * &gt;   - ul in the HTML namespace
	 *
	 * @since 6.4.0
	 * @since 6.5.0 Implemented: no longer throws on every invocation.
	 * @since 6.7.0 Supports all required HTML elements.
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-list-item-scope
	 *
	 * @param string $tag_name Name of tag to check.
	 * @return bool Whether given element is in scope.
	 */
	public function has_element_in_list_item_scope( string $tag_name ): bool {
		return $this-&gt;has_element_in_specific_scope(
			$tag_name,
			array(
				'APPLET',
				'BUTTON',
				'CAPTION',
				'HTML',
				'TABLE',
				'TD',
				'TH',
				'MARQUEE',
				'OBJECT',
				'OL',
				'TEMPLATE',
				'UL',

				'math MI',
				'math MO',
				'math MN',
				'math MS',
				'math MTEXT',
				'math ANNOTATION-XML',

				'svg FOREIGNOBJECT',
				'svg DESC',
				'svg TITLE',
			)
		);
	}

	/**
	 * Returns whether a particular element is in button scope.
	 *
	 * &gt; The stack of open elements is said to have a particular element
	 * &gt; in button scope when it has that element in the specific scope
	 * &gt; consisting of the following element types:
	 * &gt;
	 * &gt;   - All the element types listed above for the has an element in scope algorithm.
	 * &gt;   - button in the HTML namespace
	 *
	 * @since 6.4.0
	 * @since 6.7.0 Supports all required HTML elements.
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-button-scope
	 *
	 * @param string $tag_name Name of tag to check.
	 * @return bool Whether given element is in scope.
	 */
	public function has_element_in_button_scope( string $tag_name ): bool {
		return $this-&gt;has_element_in_specific_scope(
			$tag_name,
			array(
				'APPLET',
				'BUTTON',
				'CAPTION',
				'HTML',
				'TABLE',
				'TD',
				'TH',
				'MARQUEE',
				'OBJECT',
				'TEMPLATE',

				'math MI',
				'math MO',
				'math MN',
				'math MS',
				'math MTEXT',
				'math ANNOTATION-XML',

				'svg FOREIGNOBJECT',
				'svg DESC',
				'svg TITLE',
			)
		);
	}

	/**
	 * Returns whether a particular element is in table scope.
	 *
	 * &gt; The stack of open elements is said to have a particular element
	 * &gt; in table scope when it has that element in the specific scope
	 * &gt; consisting of the following element types:
	 * &gt;
	 * &gt;   - html in the HTML namespace
	 * &gt;   - table in the HTML namespace
	 * &gt;   - template in the HTML namespace
	 *
	 * @since 6.4.0
	 * @since 6.7.0 Full implementation.
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-table-scope
	 *
	 * @param string $tag_name Name of tag to check.
	 * @return bool Whether given element is in scope.
	 */
	public function has_element_in_table_scope( string $tag_name ): bool {
		return $this-&gt;has_element_in_specific_scope(
			$tag_name,
			array(
				'HTML',
				'TABLE',
				'TEMPLATE',
			)
		);
	}

	/**
	 * Returns whether a particular element is in select scope.
	 *
	 * This test differs from the others like it, in that its rules are inverted.
	 * Instead of arriving at a match when one of any tag in a termination group
	 * is reached, this one terminates if any other tag is reached.
	 *
	 * &gt; The stack of open elements is said to have a particular element in select scope when it has
	 * &gt; that element in the specific scope consisting of all element types except the following:
	 * &gt;   - optgroup in the HTML namespace
	 * &gt;   - option in the HTML namespace
	 *
	 * @since 6.4.0 Stub implementation (throws).
	 * @since 6.7.0 Full implementation.
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-select-scope
	 *
	 * @param string $tag_name Name of tag to check.
	 * @return bool Whether the given element is in SELECT scope.
	 */
	public function has_element_in_select_scope( string $tag_name ): bool {
		foreach ( $this-&gt;walk_up() as $node ) {
			if ( $node-&gt;node_name === $tag_name ) {
				return true;
			}

			if (
				'OPTION' !== $node-&gt;node_name &amp;&amp;
				'OPTGROUP' !== $node-&gt;node_name
			) {
				return false;
			}
		}

		return false;
	}

	/**
	 * Returns whether a P is in BUTTON scope.
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#has-an-element-in-button-scope
	 *
	 * @return bool Whether a P is in BUTTON scope.
	 */
	public function has_p_in_button_scope(): bool {
		return $this-&gt;has_p_in_button_scope;
	}

	/**
	 * Pops a node off of the stack of open elements.
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#stack-of-open-elements
	 *
	 * @return bool Whether a node was popped off of the stack.
	 */
	public function pop(): bool {
		$item = array_pop( $this-&gt;stack );
		if ( null === $item ) {
			return false;
		}

		$this-&gt;after_element_pop( $item );
		return true;
	}

	/**
	 * Pops nodes off of the stack of open elements until an HTML tag with the given name has been popped.
	 *
	 * @since 6.4.0
	 *
	 * @see WP_HTML_Open_Elements::pop
	 *
	 * @param string $html_tag_name Name of tag that needs to be popped off of the stack of open elements.
	 * @return bool Whether a tag of the given name was found and popped off of the stack of open elements.
	 */
	public function pop_until( string $html_tag_name ): bool {
		foreach ( $this-&gt;walk_up() as $item ) {
			$this-&gt;pop();

			if ( 'html' !== $item-&gt;namespace ) {
				continue;
			}

			if (
				'(internal: H1 through H6 - do not use)' === $html_tag_name &amp;&amp;
				in_array( $item-&gt;node_name, array( 'H1', 'H2', 'H3', 'H4', 'H5', 'H6' ), true )
			) {
				return true;
			}

			if ( $html_tag_name === $item-&gt;node_name ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Pushes a node onto the stack of open elements.
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#stack-of-open-elements
	 *
	 * @param WP_HTML_Token $stack_item Item to add onto stack.
	 */
	public function push( WP_HTML_Token $stack_item ): void {
		$this-&gt;stack[] = $stack_item;
		$this-&gt;after_element_push( $stack_item );
	}

	/**
	 * Removes a specific node from the stack of open elements.
	 *
	 * @since 6.4.0
	 *
	 * @param WP_HTML_Token $token The node to remove from the stack of open elements.
	 * @return bool Whether the node was found and removed from the stack of open elements.
	 */
	public function remove_node( WP_HTML_Token $token ): bool {
		foreach ( $this-&gt;walk_up() as $position_from_end =&gt; $item ) {
			if ( $token-&gt;bookmark_name !== $item-&gt;bookmark_name ) {
				continue;
			}

			$position_from_start = $this-&gt;count() - $position_from_end - 1;
			array_splice( $this-&gt;stack, $position_from_start, 1 );
			$this-&gt;after_element_pop( $item );
			return true;
		}

		return false;
	}


	/**
	 * Steps through the stack of open elements, starting with the top element
	 * (added first) and walking downwards to the one added last.
	 *
	 * This generator function is designed to be used inside a &quot;foreach&quot; loop.
	 *
	 * Example:
	 *
	 *     $html = '&lt;em&gt;&lt;strong&gt;&lt;a&gt;We are here';
	 *     foreach ( $stack-&gt;walk_down() as $node ) {
	 *         echo &quot;{$node-&gt;node_name} -&gt; &quot;;
	 *     }
	 *     &gt; EM -&gt; STRONG -&gt; A -&gt;
	 *
	 * To start with the most-recently added element and walk towards the top,
	 * see WP_HTML_Open_Elements::walk_up().
	 *
	 * @since 6.4.0
	 */
	public function walk_down() {
		$count = count( $this-&gt;stack );

		for ( $i = 0; $i &lt; $count; $i++ ) {
			yield $this-&gt;stack[ $i ];
		}
	}

	/**
	 * Steps through the stack of open elements, starting with the bottom element
	 * (added last) and walking upwards to the one added first.
	 *
	 * This generator function is designed to be used inside a &quot;foreach&quot; loop.
	 *
	 * Example:
	 *
	 *     $html = '&lt;em&gt;&lt;strong&gt;&lt;a&gt;We are here';
	 *     foreach ( $stack-&gt;walk_up() as $node ) {
	 *         echo &quot;{$node-&gt;node_name} -&gt; &quot;;
	 *     }
	 *     &gt; A -&gt; STRONG -&gt; EM -&gt;
	 *
	 * To start with the first added element and walk towards the bottom,
	 * see WP_HTML_Open_Elements::walk_down().
	 *
	 * @since 6.4.0
	 * @since 6.5.0 Accepts $above_this_node to start traversal above a given node, if it exists.
	 *
	 * @param WP_HTML_Token|null $above_this_node Optional. Start traversing above this node,
	 *                                            if provided and if the node exists.
	 */
	public function walk_up( ?WP_HTML_Token $above_this_node = null ) {
		$has_found_node = null === $above_this_node;

		for ( $i = count( $this-&gt;stack ) - 1; $i &gt;= 0; $i-- ) {
			$node = $this-&gt;stack[ $i ];

			if ( ! $has_found_node ) {
				$has_found_node = $node === $above_this_node;
				continue;
			}

			yield $node;
		}
	}

	/*
	 * Internal helpers.
	 */

	/**
	 * Updates internal flags after adding an element.
	 *
	 * Certain conditions (such as &quot;has_p_in_button_scope&quot;) are maintained here as
	 * flags that are only modified when adding and removing elements. This allows
	 * the HTML Processor to quickly check for these conditions instead of iterating
	 * over the open stack elements upon each new tag it encounters. These flags,
	 * however, need to be maintained as items are added and removed from the stack.
	 *
	 * @since 6.4.0
	 *
	 * @param WP_HTML_Token $item Element that was added to the stack of open elements.
	 */
	public function after_element_push( WP_HTML_Token $item ): void {
		$namespaced_name = 'html' === $item-&gt;namespace
			? $item-&gt;node_name
			: &quot;{$item-&gt;namespace} {$item-&gt;node_name}&quot;;

		/*
		 * When adding support for new elements, expand this switch to trap
		 * cases where the precalculated value needs to change.
		 */
		switch ( $namespaced_name ) {
			case 'APPLET':
			case 'BUTTON':
			case 'CAPTION':
			case 'HTML':
			case 'TABLE':
			case 'TD':
			case 'TH':
			case 'MARQUEE':
			case 'OBJECT':
			case 'TEMPLATE':
			case 'math MI':
			case 'math MO':
			case 'math MN':
			case 'math MS':
			case 'math MTEXT':
			case 'math ANNOTATION-XML':
			case 'svg FOREIGNOBJECT':
			case 'svg DESC':
			case 'svg TITLE':
				$this-&gt;has_p_in_button_scope = false;
				break;

			case 'P':
				$this-&gt;has_p_in_button_scope = true;
				break;
		}

		if ( null !== $this-&gt;push_handler ) {
			( $this-&gt;push_handler )( $item );
		}
	}

	/**
	 * Updates internal flags after removing an element.
	 *
	 * Certain conditions (such as &quot;has_p_in_button_scope&quot;) are maintained here as
	 * flags that are only modified when adding and removing elements. This allows
	 * the HTML Processor to quickly check for these conditions instead of iterating
	 * over the open stack elements upon each new tag it encounters. These flags,
	 * however, need to be maintained as items are added and removed from the stack.
	 *
	 * @since 6.4.0
	 *
	 * @param WP_HTML_Token $item Element that was removed from the stack of open elements.
	 */
	public function after_element_pop( WP_HTML_Token $item ): void {
		/*
		 * When adding support for new elements, expand this switch to trap
		 * cases where the precalculated value needs to change.
		 */
		switch ( $item-&gt;node_name ) {
			case 'APPLET':
			case 'BUTTON':
			case 'CAPTION':
			case 'HTML':
			case 'P':
			case 'TABLE':
			case 'TD':
			case 'TH':
			case 'MARQUEE':
			case 'OBJECT':
			case 'TEMPLATE':
			case 'math MI':
			case 'math MO':
			case 'math MN':
			case 'math MS':
			case 'math MTEXT':
			case 'math ANNOTATION-XML':
			case 'svg FOREIGNOBJECT':
			case 'svg DESC':
			case 'svg TITLE':
				$this-&gt;has_p_in_button_scope = $this-&gt;has_element_in_button_scope( 'P' );
				break;
		}

		if ( null !== $this-&gt;pop_handler ) {
			( $this-&gt;pop_handler )( $item );
		}
	}

	/**
	 * Clear the stack back to a table context.
	 *
	 * &gt; When the steps above require the UA to clear the stack back to a table context, it means
	 * &gt; that the UA must, while the current node is not a table, template, or html element, pop
	 * &gt; elements from the stack of open elements.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-stack-back-to-a-table-context
	 *
	 * @since 6.7.0
	 */
	public function clear_to_table_context(): void {
		foreach ( $this-&gt;walk_up() as $item ) {
			if (
				'TABLE' === $item-&gt;node_name ||
				'TEMPLATE' === $item-&gt;node_name ||
				'HTML' === $item-&gt;node_name
			) {
				break;
			}
			$this-&gt;pop();
		}
	}

	/**
	 * Clear the stack back to a table body context.
	 *
	 * &gt; When the steps above require the UA to clear the stack back to a table body context, it
	 * &gt; means that the UA must, while the current node is not a tbody, tfoot, thead, template, or
	 * &gt; html element, pop elements from the stack of open elements.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-stack-back-to-a-table-body-context
	 *
	 * @since 6.7.0
	 */
	public function clear_to_table_body_context(): void {
		foreach ( $this-&gt;walk_up() as $item ) {
			if (
				'TBODY' === $item-&gt;node_name ||
				'TFOOT' === $item-&gt;node_name ||
				'THEAD' === $item-&gt;node_name ||
				'TEMPLATE' === $item-&gt;node_name ||
				'HTML' === $item-&gt;node_name
			) {
				break;
			}
			$this-&gt;pop();
		}
	}

	/**
	 * Clear the stack back to a table row context.
	 *
	 * &gt; When the steps above require the UA to clear the stack back to a table row context, it
	 * &gt; means that the UA must, while the current node is not a tr, template, or html element, pop
	 * &gt; elements from the stack of open elements.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-stack-back-to-a-table-row-context
	 *
	 * @since 6.7.0
	 */
	public function clear_to_table_row_context(): void {
		foreach ( $this-&gt;walk_up() as $item ) {
			if (
				'TR' === $item-&gt;node_name ||
				'TEMPLATE' === $item-&gt;node_name ||
				'HTML' === $item-&gt;node_name
			) {
				break;
			}
			$this-&gt;pop();
		}
	}

	/**
	 * Wakeup magic method.
	 *
	 * @since 6.6.0
	 */
	public function __wakeup() {
		throw new \LogicException( __CLASS__ . ' should never be unserialized' );
	}
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fxaimptsg%2Falmasupplies.store%2Fwp-includes%2Fhtml-api'>Back to Directory</a>