<h2>Editing File: /usr/local/sitepad/editor/site-data/plugins/pagelayer/lib/pquery/gan_node_html.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 * @author Niels A.D.
 * @author Todd Burry &lt;todd@vanillaforums.com&gt;
 * @copyright 2010 Niels A.D., 2014 Todd Burry
 * @license http://opensource.org/licenses/LGPL-2.1 LGPL-2.1
 * @package pQuery
 */

namespace pagelayerQuery;

/**
 * Holds (x)html/xml tag information like tag name, attributes,
 * parent, children, self close, etc.
 *
 */
class DomNode implements IQuery {

	/**
	 * Element Node, used for regular elements
	 */
	const NODE_ELEMENT = 0;
	/**
	 * Text Node
	 */
	const NODE_TEXT = 1;
	/**
	 * Comment Node
	 */
	const NODE_COMMENT = 2;
	/**
	 * Conditional Node (&lt;![if]&gt; &lt;![endif])
	 */
	const NODE_CONDITIONAL = 3;
	/**
	 * CDATA Node (&lt;![CDATA[]]&gt;
	 */
	const NODE_CDATA = 4;
	/**
	 * Doctype Node
	 */
	const NODE_DOCTYPE = 5;
	/**
	 * XML Node, used for tags that start with ?, like &lt;?xml and &lt;?php
	 */
	const NODE_XML = 6;
	/**
	 * ASP Node
	 */
	const NODE_ASP = 7;

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_ELEMENT;
	#php4e
	#php5
	/**
	 * Node type of class
	 */
	const NODE_TYPE = self::NODE_ELEMENT;
	#php5e


	/**
	 * Name of the selector class
	 * @var string
	 * @see select()
	 */
	var $selectClass = 'pagelayerQuery\\HtmlSelector';
	/**
	 * Name of the parser class
	 * @var string
	 * @see setOuterText()
	 * @see setInnerText()
	 */
	var $parserClass = 'pagelayerQuery\\Html5Parser';

	/**
	 * Name of the class used for {@link addChild()}
	 * @var string
	 */
	var $childClass = __CLASS__;
	/**
	 * Name of the class used for {@link addText()}
	 * @var string
	 */
	var $childClass_Text = 'pagelayerQuery\\TextNode';
	/**
	 * Name of the class used for {@link addComment()}
	 * @var string
	 */
	var $childClass_Comment = 'pagelayerQuery\\CommentNode';
	/**
	 * Name of the class used for {@link addContional()}
	 * @var string
	 */
	var $childClass_Conditional = 'pagelayerQuery\\ConditionalTagNode';
	/**
	 * Name of the class used for {@link addCDATA()}
	 * @var string
	 */
	var $childClass_CDATA = 'pagelayerQuery\\CdataNode';
	/**
	 * Name of the class used for {@link addDoctype()}
	 * @var string
	 */
	var $childClass_Doctype = 'pagelayerQuery\\DoctypeNode';
	/**
	 * Name of the class used for {@link addXML()}
	 * @var string
	 */
	var $childClass_XML = 'pagelayerQuery\\XmlNode';
	/**
	 * Name of the class used for {@link addASP()}
	 * @var string
	 */
	var $childClass_ASP = 'pagelayerQuery\\AspEmbeddedNode';

	/**
	 * Parent node, null if none
	 * @var DomNode
	 * @see changeParent()
	 */
	var $parent = null;

	/**
	 * Attributes of node
	 * @var array
	 * @internal array('attribute' =&gt; 'value')
	 * @internal Public for faster access!
	 * @see getAttribute()
	 * @see setAttribute()
	 * @access private
	 */
	var $attributes = array();

	/**
	 * Namespace info for attributes
	 * @var array
	 * @internal array('tag' =&gt; array(array('ns', 'tag', 'ns:tag', index)))
	 * @internal Public for easy outside modifications!
	 * @see findAttribute()
	 * @access private
	 */
	var $attributes_ns = null;

	/**
	 * Array of child nodes
	 * @var array
	 * @internal Public for faster access!
	 * @see childCount()
	 * @see getChild()
	 * @see addChild()
	 * @see deleteChild()
	 * @access private
	 */
	var $children = array();

	/**
	 * Full tag name (including namespace)
	 * @var string
	 * @see getTagName()
	 * @see getNamespace()
	 */
	var $tag = '';

	/**
	 * Namespace info for tag
	 * @var array
	 * @internal array('namespace', 'tag')
	 * @internal Public for easy outside modifications!
	 * @access private
	 */
	var $tag_ns = null;

	/**
	 * Is node a self closing node? No closing tag if true.
	 * @var bool
	 */
	var $self_close = false;

	/**
	 * If self close, then this will be used to close the tag
	 * @var string
	 * @see $self_close
	 */
	var $self_close_str = ' /';

	/**
	 * Use short tags for attributes? If true, then attributes
	 * with values equal to the attribute name will not output
	 * the value, e.g. selected=&quot;selected&quot; will be selected.
	 * @var bool
	 */
	var $attribute_shorttag = false;

	/**
	 * Function map used for the selector filter
	 * @var array
	 * @internal array('root' =&gt; 'filter_root') will cause the
	 * selector to call $this-&gt;filter_root at :root
	 * @access private
	 */
	var $filter_map = array(
		'root' =&gt; 'filter_root',
		'nth-child' =&gt; 'filter_nchild',
		'eq' =&gt; 'filter_nchild', //jquery (naming) compatibility
		'gt' =&gt; 'filter_gt',
		'lt' =&gt; 'filter_lt',
		'nth-last-child' =&gt; 'filter_nlastchild',
		'nth-of-type' =&gt; 'filter_ntype',
		'nth-last-of-type' =&gt; 'filter_nlastype',
		'odd' =&gt; 'filter_odd',
		'even' =&gt; 'filter_even',
		'every' =&gt; 'filter_every',
		'first-child' =&gt; 'filter_first',
		'last-child' =&gt; 'filter_last',
		'first-of-type' =&gt; 'filter_firsttype',
		'last-of-type' =&gt; 'filter_lasttype',
		'only-child' =&gt; 'filter_onlychild',
		'only-of-type' =&gt; 'filter_onlytype',
		'empty' =&gt; 'filter_empty',
		'not-empty' =&gt; 'filter_notempty',
		'has-text' =&gt; 'filter_hastext',
		'no-text' =&gt; 'filter_notext',
		'lang' =&gt; 'filter_lang',
		'contains' =&gt; 'filter_contains',
		'has' =&gt; 'filter_has',
		'not' =&gt; 'filter_not',
		'element' =&gt; 'filter_element',
		'text' =&gt; 'filter_text',
		'comment' =&gt; 'filter_comment',
        'checked' =&gt; 'filter_checked',
        'selected' =&gt; 'filter_selected',
	);

	/**
	 * Class constructor
	 * @param string|array $tag Name of the tag, or array with taginfo (array(
	 *	'tag_name' =&gt; 'tag',
	 *	'self_close' =&gt; false,
	 *	'attributes' =&gt; array('attribute' =&gt; 'value')))
	 * @param DomNode $parent Parent of node, null if none
	 */
	function __construct($tag, $parent) {
		$this-&gt;parent = $parent;

		if (is_string($tag)) {
			$this-&gt;tag = $tag;
		} else {
			$this-&gt;tag = $tag['tag_name'];
			$this-&gt;self_close = $tag['self_close'];
			$this-&gt;attributes = $tag['attributes'];
		}
	}

	#php4 PHP4 class constructor compatibility
	#function DomNode($tag, $parent) {return $this-&gt;__construct($tag, $parent);}
	#php4e

	/**
	 * Class destructor
	 * @access private
	 */
	function __destruct() {
		$this-&gt;delete();
	}

	/**
	 * Class toString, outputs {@link $tag}
	 * @return string
	 * @access private
	 */
	function __toString() {
		return (($this-&gt;tag === '~root~') ? $this-&gt;toString(true, true, 1) : $this-&gt;tag);
	}

	/**
	 * Class magic get method, outputs {@link getAttribute()}
	 * @return string
	 * @access private
	 */
	function __get($attribute) {
		return $this-&gt;getAttribute($attribute);
	}

	/**
	 * Class magic set method, performs {@link setAttribute()}
	 * @access private
	 */
	function __set($attribute, $value) {
		$this-&gt;setAttribute($attribute, $value);
	}

	/**
	 * Class magic isset method, returns {@link hasAttribute()}
	 * @return bool
	 * @access private
	 */
	function __isset($attribute) {
		return $this-&gt;hasAttribute($attribute);
	}

	/**
	 * Class magic unset method, performs {@link deleteAttribute()}
	 * @access private
	 */
	function __unset($attribute) {
		return $this-&gt;deleteAttribute($attribute);
	}

	/**
	 * Class magic invoke method, performs {@link query()}.
     * @param string $query The css query to run on the nodes.
	 * @return \pQuery
	 */
	function __invoke($query = '*') {
		return $this-&gt;query($query);
	}

	/**
	 * Returns place in document
	 * @return string
	 */
	 function dumpLocation() {
		return (($this-&gt;parent) ? (($p = $this-&gt;parent-&gt;dumpLocation()) ? $p.' &gt; ' : '').$this-&gt;tag.'('.$this-&gt;typeIndex().')' : '');
	 }

	/**
	 * Returns all the attributes and their values
	 * @return string
	 * @access private
	 */
	protected function toString_attributes() {
		$s = '';
		foreach($this-&gt;attributes as $a =&gt; $v) {
			$s .= ' '.$a;
			if ((!$this-&gt;attribute_shorttag) || ($v !== $a)) {
				$quote = '&quot;';//(strpos($v, '&quot;') === false) ? '&quot;' : &quot;'&quot;;
				$v = str_replace('&quot;', '&amp;quot;', $v);
				$s .= '='.$quote.$v.$quote;
			}
		}
		return $s;
	}

	/**
	 * Returns the content of the node (child tags and text)
	 * @param bool $attributes Print attributes of child tags
	 * @param bool|int $recursive How many sublevels of childtags to print. True for all.
	 * @param bool $content_only Only print text, false will print tags too.
	 * @return string
	 * @access private
	 */
	protected function toString_content($attributes = true, $recursive = true, $content_only = false) {
		$s = '';
		foreach($this-&gt;children as $c) {
			$s .= $c-&gt;toString($attributes, $recursive, $content_only);
		}
		return $s;
	}

	/**
	 * Returns the node as string
	 * @param bool $attributes Print attributes (of child tags)
	 * @param bool|int $recursive How many sub-levels of child tags to print. True for all.
	 * @param bool|int $content_only Only print text, false will print tags too.
	 * @return string
	 */
	function toString($attributes = true, $recursive = true, $content_only = false) {
		if ($content_only) {
			if (is_int($content_only)) {
				--$content_only;
			}
			return $this-&gt;toString_content($attributes, $recursive, $content_only);
		}

		$s = '&lt;'.$this-&gt;tag;
		if ($attributes) {
			$s .= $this-&gt;toString_attributes();
		}
		if ($this-&gt;self_close) {
			$s .= $this-&gt;self_close_str.'&gt;';
		} else {
			$s .= '&gt;';
			if($recursive) {
				$s .= $this-&gt;toString_content($attributes);
			}
			$s .= '&lt;/'.$this-&gt;tag.'&gt;';
		}
		return $s;
	}

	/**
	 * Similar to JavaScript outerText, will return full (html formatted) node
	 * @return string
	 */
	function getOuterText() {
		return $this-&gt;toString();
	}

	/**
	 * Similar to JavaScript outerText, will replace node (and child nodes) with new text
	 * @param string $text
	 * @param HtmlParserBase $parser Null to auto create instance
	 * @return bool|array True on succeed, array with errors on failure
	 */
	function setOuterText($text, $parser = null) {
		if (trim($text)) {
			$index = $this-&gt;index();
			if ($parser === null) {
				$parser = new $this-&gt;parserClass();
			}
			$parser-&gt;setDoc($text);
			$parser-&gt;parse_all();
			$parser-&gt;root-&gt;moveChildren($this-&gt;parent, $index);
		}
		$this-&gt;delete();
		return (($parser &amp;&amp; $parser-&gt;errors) ? $parser-&gt;errors : true);
	}

	/**
	 * Return html code of node
	 * @internal jquery (naming) compatibility
     * @param string|null $value The value to set or null to get the value.
	 * @see toString()
	 * @return string
	 */
	function html($value = null) {
      if ($value !== null) {
         $this-&gt;setInnerText($value);
      }
		return $this-&gt;getInnerText();
	}

	/**
	 * Similar to JavaScript innerText, will return (html formatted) content
	 * @return string
	 */
	function getInnerText() {
		return $this-&gt;toString(true, true, 1);
	}

	/**
	 * Similar to JavaScript innerText, will replace child nodes with new text
	 * @param string $text
	 * @param HtmlParserBase $parser Null to auto create instance
	 * @return bool|array True on succeed, array with errors on failure
	 */
	function setInnerText($text, $parser = null) {
		$this-&gt;clear();
		if (trim($text)) {
			if ($parser === null) {
				$parser = new $this-&gt;parserClass();
			}
			$parser-&gt;root =&amp; $this;
			$parser-&gt;setDoc($text);
			$parser-&gt;parse_all();
		}
		return (($parser &amp;&amp; $parser-&gt;errors) ? $parser-&gt;errors : true);
	}

	/**
	 * Similar to JavaScript plainText, will return text in node (and subnodes)
	 * @return string
	 */
	function getPlainText() {
		return preg_replace('`\s+`', ' ', $this-&gt;toString(true, true, true));
	}

	/**
	 * Return plaintext taking document encoding into account
	 * @return string
	 */
	function getPlainTextUTF8() {
		$txt = $this-&gt;toString(true, true, true);
		$enc = $this-&gt;getEncoding();
		if ($enc !== false) {
			$txt = mb_convert_encoding($txt, 'UTF-8', $enc);
		}
		return preg_replace('`\s+`', ' ', $txt);
	}

	/**
	 * Similar to JavaScript plainText, will replace child nodes with new text (literal)
	 * @param string $text
	 */
	function setPlainText($text) {
		$this-&gt;clear();
		if (trim($text)) {
			$this-&gt;addText($text);
		}
	}

	/**
	 * Delete node from parent and clear node
	 */
	function delete() {
		if (($p = $this-&gt;parent) !== null) {
			$this-&gt;parent = null;
			$p-&gt;deleteChild($this);
		} else {
			$this-&gt;clear();
		}
	}

	/**
	 * Detach node from parent
	 * @param bool $move_children_up Only detach current node and replace it with child nodes
	 * @internal jquery (naming) compatibility
	 * @see delete()
	 */
	function detach($move_children_up = false) {
		if (($p = $this-&gt;parent) !== null) {
			$index = $this-&gt;index();
			$this-&gt;parent = null;

			if ($move_children_up) {
				$this-&gt;moveChildren($p, $index);
			}
			$p-&gt;deleteChild($this, true);
		}
	}

	/**
	 * Deletes all child nodes from node
	 */
	function clear() {
		foreach($this-&gt;children as $c) {
			$c-&gt;parent = null;
			$c-&gt;delete();
		}
		$this-&gt;children = array();
	}

	/**
	 * Get top parent
	 * @return DomNode Root, null if node has no parent
	 */
	function getRoot() {
		$r = $this-&gt;parent;
		$n = ($r === null) ? null : $r-&gt;parent;
		while ($n !== null) {
			$r = $n;
			$n = $r-&gt;parent;
		}

		return $r;
	}

	/**
	 * Change parent
	 * @param null|DomNode $to New parent, null if none
	 * @param false|int $index Add child to parent if not present at index, false to not add, negative to count from end, null to append
	 */
	#php4
	#function changeParent($to, &amp;$index) {
	#php4e
	#php5
	function changeParent($to, &amp;$index = null) {
	#php5e
		if ($this-&gt;parent !== null) {
			$this-&gt;parent-&gt;deleteChild($this, true);
		}
		$this-&gt;parent = $to;
		if ($index !== false) {
			$new_index = $this-&gt;index();
			if (!(is_int($new_index) &amp;&amp; ($new_index &gt;= 0))) {
				$this-&gt;parent-&gt;addChild($this, $index);
			}
		}
	}

	/**
	 * Find out if node has (a certain) parent
	 * @param DomNode|string $tag Match against parent, string to match tag, object to fully match node, null to return if node has parent
	 * @param bool $recursive
	 * @return bool
	 */
	function hasParent($tag = null, $recursive = false) {
		if ($this-&gt;parent !== null) {
			if ($tag === null) {
				return true;
			} elseif (is_string($tag)) {
				return (($this-&gt;parent-&gt;tag === $tag) || ($recursive &amp;&amp; $this-&gt;parent-&gt;hasParent($tag)));
			} elseif (is_object($tag)) {
				return (($this-&gt;parent === $tag) || ($recursive &amp;&amp; $this-&gt;parent-&gt;hasParent($tag)));
			}
		}

		return false;
	}

	/**
	 * Find out if node is parent of a certain tag
	 * @param DomNode|string $tag Match against parent, string to match tag, object to fully match node
	 * @param bool $recursive
	 * @return bool
	 * @see hasParent()
	 */
	function isParent($tag, $recursive = false) {
		return ($this-&gt;hasParent($tag, $recursive) === ($tag !== null));
	}

	/**
	 * Find out if node is text
	 * @return bool
	 */
	function isText() {
		return false;
	}

	/**
	 * Find out if node is comment
	 * @return bool
	 */
	function isComment() {
		return false;
	}

	/**
	 * Find out if node is text or comment node
	 * @return bool
	 */
	function isTextOrComment() {
		return false;
	}

	/**
	 * Move node to other node
	 * @param DomNode $to New parent, null if none
	 * @param int $new_index Add child to parent at index if not present, null to not add, negative to count from end
	 * @internal Performs {@link changeParent()}
	 */
	#php4
	#function move($to, &amp;$new_index) {
	#php4e
	#php5
	function move($to, &amp;$new_index = -1) {
	#php5e
		$this-&gt;changeParent($to, $new_index);
	}

	/**
	 * Move child nodes to other node
	 * @param DomNode $to New parent, null if none
	 * @param int $new_index Add child to new node at index if not present, null to not add, negative to count from end
	 * @param int $start Index from child node where to start wrapping, 0 for first element
	 * @param int $end Index from child node where to end wrapping, -1 for last element
	 */
	#php4
	#function moveChildren($to, &amp;$new_index, $start = 0, $end = -1) {
	#php4e
	#php5
	function moveChildren($to, &amp;$new_index = -1, $start = 0, $end = -1) {
	#php5e
		if ($end &lt; 0) {
			$end += count($this-&gt;children);
		}
		for ($i = $start; $i &lt;= $end; $i++) {
			$this-&gt;children[$start]-&gt;changeParent($to, $new_index);
		}
	}

	/**
	 * Index of node in parent
	 * @param bool $count_all True to count all tags, false to ignore text and comments
	 * @return int -1 if not found
	 */
	function index($count_all = true) {
		if (!$this-&gt;parent) {
			return -1;
		} elseif ($count_all) {
			return $this-&gt;parent-&gt;findChild($this);
		} else{
			$index = -1;
			//foreach($this-&gt;parent-&gt;children as &amp;$c) {
			//	if (!$c-&gt;isTextOrComment()) {
			//		++$index;
			//	}
			//	if ($c === $this) {
			//		return $index;
			//	}
			//}

			foreach(array_keys($this-&gt;parent-&gt;children) as $k) {
				if (!$this-&gt;parent-&gt;children[$k]-&gt;isTextOrComment()) {
					++$index;
				}
				if ($this-&gt;parent-&gt;children[$k] === $this) {
					return $index;
				}
			}
			return -1;
		}
	}

	/**
	 * Change index of node in parent
	 * @param int $index New index
	 */
	function setIndex($index) {
		if ($this-&gt;parent) {
			if ($index &gt; $this-&gt;index()) {
				--$index;
			}
			$this-&gt;delete();
			$this-&gt;parent-&gt;addChild($this, $index);
		}
	}

	/**
	 * Index of all similar nodes in parent
	 * @return int -1 if not found
	 */
	function typeIndex() {
		if (!$this-&gt;parent) {
			return -1;
		} else {
			$index = -1;
			//foreach($this-&gt;parent-&gt;children as &amp;$c) {
			//	if (strcasecmp($this-&gt;tag, $c-&gt;tag) === 0) {
			//		++$index;
			//	}
			//	if ($c === $this) {
			//		return $index;
			//	}
			//}

			foreach(array_keys($this-&gt;parent-&gt;children) as $k) {
				if (strcasecmp($this-&gt;tag, $this-&gt;parent-&gt;children[$k]-&gt;tag) === 0) {
					++$index;
				}
				if ($this-&gt;parent-&gt;children[$k] === $this) {
					return $index;
				}
			}
			return -1;
		}
	}

	/**
	 * Calculate indent of node (number of parent tags - 1)
	 * @return int
	 */
	function indent() {
		return (($this-&gt;parent) ? $this-&gt;parent-&gt;indent() + 1 : -1);
	}

	/**
	 * Get sibling node
	 * @param int $offset Offset from current node
	 * @return DomNode Null if not found
	 */
	function getSibling($offset = 1) {
		$index = $this-&gt;index() + $offset;
		if (($index &gt;= 0) &amp;&amp; ($index &lt; $this-&gt;parent-&gt;childCount())) {
			return $this-&gt;parent-&gt;getChild($index);
		} else {
			return null;
		}
	}

	/**
	 * Get node next to current
	 * @param bool $skip_text_comments
	 * @return DomNode Null if not found
	 * @see getSibling()
	 * @see getPreviousSibling()
	 */
	function getNextSibling($skip_text_comments = true) {
		$offset = 1;
		while (($n = $this-&gt;getSibling($offset)) !== null) {
			if ($skip_text_comments &amp;&amp; ($n-&gt;tag[0] === '~')) {
				++$offset;
			} else {
				break;
			}
		}

		return $n;
	}

	/**
	 * Get node previous to current
	 * @param bool $skip_text_comments
	 * @return DomNode Null if not found
	 * @see getSibling()
	 * @see getNextSibling()
	 */
	function getPreviousSibling($skip_text_comments = true) {
		$offset = -1;
		while (($n = $this-&gt;getSibling($offset)) !== null) {
			if ($skip_text_comments &amp;&amp; ($n-&gt;tag[0] === '~')) {
				--$offset;
			} else {
				break;
			}
		}

		return $n;
	}

	/**
	 * Get namespace of node
	 * @return string
	 * @see setNamespace()
	 */
	function getNamespace() {
		if ($this-&gt;tag_ns === null) {
			$a = explode(':', $this-&gt;tag, 2);
			if (empty($a[1])) {
				$this-&gt;tag_ns = array('', $a[0]);
			} else {
				$this-&gt;tag_ns = array($a[0], $a[1]);
			}
		}

		return $this-&gt;tag_ns[0];
	}

	/**
	 * Set namespace of node
	 * @param string $ns
	 * @see getNamespace()
	 */
	function setNamespace($ns) {
		if ($this-&gt;getNamespace() !== $ns) {
			$this-&gt;tag_ns[0] = $ns;
			$this-&gt;tag = $ns.':'.$this-&gt;tag_ns[1];
		}
	}

	/**
	 * Get tagname of node (without namespace)
	 * @return string
	 * @see setTag()
	 */
	function getTag() {
		if ($this-&gt;tag_ns === null) {
			$this-&gt;getNamespace();
		}

		return $this-&gt;tag_ns[1];
	}

	/**
	 * Set tag (with or without namespace)
	 * @param string $tag
	 * @param bool $with_ns Does $tag include namespace?
	 * @see getTag()
	 */
	function setTag($tag, $with_ns = false) {
		$with_ns = $with_ns || (strpos($tag, ':') !== false);
		if ($with_ns) {
			$this-&gt;tag = $tag;
			$this-&gt;tag_ns = null;
		} elseif ($this-&gt;getTag() !== $tag) {
			$this-&gt;tag_ns[1] = $tag;
			$this-&gt;tag = (($this-&gt;tag_ns[0]) ? $this-&gt;tag_ns[0].':' : '').$tag;
		}
	}

	/**
	 * Try to determine the encoding of the current tag
	 * @return string|bool False if encoding could not be found
	 */
	function getEncoding() {
		$root = $this-&gt;getRoot();
		if ($root !== null) {
			if ($enc = $root-&gt;select('meta[charset]', 0, true, true)) {
				return $enc-&gt;getAttribute(&quot;charset&quot;);
			} elseif ($enc = $root-&gt;select('&quot;?xml&quot;[encoding]', 0, true, true)) {
				return $enc-&gt;getAttribute(&quot;encoding&quot;);
			} elseif ($enc = $root-&gt;select('meta[content*=&quot;charset=&quot;]', 0, true, true)) {
				$enc = $enc-&gt;getAttribute(&quot;content&quot;);
				return substr($enc, strpos($enc, &quot;charset=&quot;)+8);
			}
		}

		return false;
	}

	/**
	 * Number of children in node
	 * @param bool $ignore_text_comments Ignore text/comments with calculation
	 * @return int
	 */
	function childCount($ignore_text_comments = false) {
		if (!$ignore_text_comments) {
			return count($this-&gt;children);
		} else{
			$count = 0;
			//foreach($this-&gt;children as &amp;$c) {
			//	if (!$c-&gt;isTextOrComment()) {
			//		++$count;
			//	}
			//}

			foreach(array_keys($this-&gt;children) as $k) {
				if (!$this-&gt;children[$k]-&gt;isTextOrComment()) {
					++$count;
				}
			}
			return $count;
		}
	}

	/**
	 * Find node in children
	 * @param DomNode $child
	 * @return int False if not found
	 */
	function findChild($child) {
		return array_search($child, $this-&gt;children, true);
	}

	/**
	 * Checks if node has another node as child
	 * @param DomNode $child
	 * @return bool
	 */
	function hasChild($child) {
		return ((bool) findChild($child));
	}

	/**
	 * Get childnode
	 * @param int|DomNode $child Index, negative to count from end
	 * @param bool $ignore_text_comments Ignore text/comments with index calculation
	 * @return DomNode
	 */
	function &amp;getChild($child, $ignore_text_comments = false) {
		if (!is_int($child)) {
			$child = $this-&gt;findChild($child);
		} elseif ($child &lt; 0) {
			$child += $this-&gt;childCount($ignore_text_comments);
		}

		if ($ignore_text_comments) {
			$count = 0;
			$last = null;
			//foreach($this-&gt;children as &amp;$c) {
			//	if (!$c-&gt;isTextOrComment()) {
			//		if ($count++ === $child) {
			//			return $c;
			//		}
			//		$last = $c;
			//	}
			//}

			foreach(array_keys($this-&gt;children) as $k) {
				if (!$this-&gt;children[$k]-&gt;isTextOrComment()) {
					if ($count++ === $child) {
						return $this-&gt;children[$k];
					}
					$last = $this-&gt;children[$k];
				}
			}
			return (($child &gt; $count) ? $last : null);
		} else {
			return $this-&gt;children[$child];
		}
	}

	/**
	 * Add child node
	 * @param string|DomNode $tag Tag name or object
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 */
	#php4
	#function &amp;addChild($tag, &amp;$offset) {
	#php4e
	#php5
	function &amp;addChild($tag, &amp;$offset = null) {
	#php5e
        if (is_array($tag)) {
            $tag = new $this-&gt;childClass($tag, $this);
        } elseif (is_string($tag)) {
            $nodes = $this-&gt;createNodes($tag);
            $tag = array_shift($nodes);

            if ($tag &amp;&amp; $tag-&gt;parent !== $this) {
                $index = false;
                $tag-&gt;changeParent($this, $index);
            }
		} elseif (is_object($tag) &amp;&amp; $tag-&gt;parent !== $this) {
			$index = false; //Needs to be passed by ref
			$tag-&gt;changeParent($this, $index);
		}

		if (is_int($offset) &amp;&amp; ($offset &lt; count($this-&gt;children)) &amp;&amp; ($offset !== -1)) {
			if ($offset &lt; 0) {
				$offset += count($this-&gt;children);
			}
			array_splice($this-&gt;children, $offset++, 0, array(&amp;$tag));
		} else {
			$this-&gt;children[] =&amp; $tag;
		}

		return $tag;
	}

	/**
	 * First child node
	 * @param bool $ignore_text_comments Ignore text/comments with index calculation
	 * @return DomNode
	 */
	function &amp;firstChild($ignore_text_comments = false) {
		return $this-&gt;getChild(0, $ignore_text_comments);
	}

	/**
	 * Last child node
	 * @param bool $ignore_text_comments Ignore text/comments with index calculation
	 * @return DomNode
	 */
	function &amp;lastChild($ignore_text_comments = false) {
		return $this-&gt;getChild(-1, $ignore_text_comments);
	}

	/**
	 * Insert childnode
	 * @param string|DomNode $tag Tagname or object
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	function &amp;insertChild($tag, $index) {
		return $this-&gt;addChild($tag, $index);
	}

	/**
	 * Add text node
	 * @param string $text
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addText($text, &amp;$offset) {
	#php4e
	#php5
	function &amp;addText($text, &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_Text($this, $text), $offset);
	}

	/**
	 * Add comment node
	 * @param string $text
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addComment($text, &amp;$offset) {
	#php4e
	#php5
	function &amp;addComment($text, &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_Comment($this, $text), $offset);
	}

	/**
	 * Add conditional node
	 * @param string $condition
	 * @param bool True for &lt;!--[if, false for &lt;![if
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addConditional($condition, $hidden = true, &amp;$offset) {
	#php4e
	#php5
	function &amp;addConditional($condition, $hidden = true, &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_Conditional($this, $condition, $hidden), $offset);
	}

	/**
	 * Add CDATA node
	 * @param string $text
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addCDATA($text, &amp;$offset) {
	#php4e
	#php5
	function &amp;addCDATA($text, &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_CDATA($this, $text), $offset);
	}

	/**
	 * Add doctype node
	 * @param string $dtd
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addDoctype($dtd, &amp;$offset) {
	#php4e
	#php5
	function &amp;addDoctype($dtd, &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_Doctype($this, $dtd), $offset);
	}

	/**
	 * Add xml node
	 * @param string $tag Tag name after &quot;?&quot;, e.g. &quot;php&quot; or &quot;xml&quot;
	 * @param string $text
	 * @param array $attributes Array of attributes (array('attribute' =&gt; 'value'))
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addXML($tag = 'xml', $text = '', $attributes = array(), &amp;$offset) {
	#php4e
	#php5
	function &amp;addXML($tag = 'xml', $text = '', $attributes = array(), &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_XML($this, $tag, $text, $attributes), $offset);
	}

	/**
	 * Add ASP node
	 * @param string $tag Tag name after &quot;%&quot;
	 * @param string $text
	 * @param array $attributes Array of attributes (array('attribute' =&gt; 'value'))
	 * @param int $offset Position to insert node, negative to count from end, null to append
	 * @return DomNode Added node
	 * @see addChild();
	 */
	#php4
	#function &amp;addASP($tag = '', $text = '', $attributes = array(), &amp;$offset) {
	#php4e
	#php5
	function &amp;addASP($tag = '', $text = '', $attributes = array(), &amp;$offset = null) {
	#php5e
		return $this-&gt;addChild(new $this-&gt;childClass_ASP($this, $tag, $text, $attributes), $offset);
	}

	/**
	 * Delete a child node
	 * @param int|DomNode $child Child(index) to delete, negative to count from end
	 * @param bool $soft_delete False to call {@link delete()} from child
	 */
	function deleteChild($child, $soft_delete = false) {
		if (is_object($child)) {
			$child = $this-&gt;findChild($child);
		} elseif ($child &lt; 0) {
			$child += count($this-&gt;children);
		}

		if (!$soft_delete) {
			$this-&gt;children[$child]-&gt;delete();
		}
		unset($this-&gt;children[$child]);

		//Rebuild indices
		$tmp = array();

		//foreach($this-&gt;children as &amp;$c) {
		//	$tmp[] =&amp; $c;
		//}
		foreach(array_keys($this-&gt;children) as $k) {
			$tmp[] =&amp; $this-&gt;children[$k];
		}
		$this-&gt;children = $tmp;
	}

	/**
	 * Wrap node
	 * @param string|DomNode $node Wrapping node, string to create new element node
	 * @param int $wrap_index Index to insert current node in wrapping node, -1 to append
	 * @param int $node_index Index to insert wrapping node, null to keep at same position
	 * @return DomNode Wrapping node
	 */
	function wrap($node, $wrap_index = -1, $node_index = null) {
		if ($node_index === null) {
			$node_index = $this-&gt;index();
		}

		if (!is_object($node)) {
			$node = $this-&gt;parent-&gt;addChild($node, $node_index);
		} elseif ($node-&gt;parent !== $this-&gt;parent) {
			$node-&gt;changeParent($this-&gt;parent, $node_index);
		}

		$this-&gt;changeParent($node, $wrap_index);
		return $node;
	}

	/**
	 * Wrap child nodes
	 * @param string|DomNode $node Wrapping node, string to create new element node
	 * @param int $start Index from child node where to start wrapping, 0 for first element
	 * @param int $end Index from child node where to end wrapping, -1 for last element
	 * @param int $wrap_index Index to insert in wrapping node, -1 to append
	 * @param int $node_index Index to insert current node, null to keep at same position
	 * @return DomNode Wrapping node
	 */
	function wrapInner($node, $start = 0, $end = -1, $wrap_index = -1, $node_index = null) {
		if ($end &lt; 0) {
			$end += count($this-&gt;children);
		}
		if ($node_index === null) {
			$node_index = $end + 1;
		}

		if (!is_object($node)) {
			$node = $this-&gt;addChild($node, $node_index);
		} elseif ($node-&gt;parent !== $this) {
			$node-&gt;changeParent($this-&gt;parent, $node_index);
		}

		$this-&gt;moveChildren($node, $wrap_index, $start, $end);
		return $node;
	}

	/**
	 * Number of attributes
	 * @return int
	 */
	function attributeCount() {
		return count($this-&gt;attributes);
	}

	/**
	 * Find attribute using namespace, name or both
	 * @param string|int $attr Negative int to count from end
	 * @param string $compare &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 * @return array array('ns', 'attr', 'ns:attr', index)
	 * @access private
	 */
	protected function findAttribute($attr, $compare = 'total', $case_sensitive = false) {
		if (is_int($attr)) {
			if ($attr &lt; 0) {
				$attr += count($this-&gt;attributes);
			}
			$keys = array_keys($this-&gt;attributes);
			return $this-&gt;findAttribute($keys[$attr], 'total', true);
		} else if ($compare === 'total') {
			$b = explode(':', $attr, 2);
			if ($case_sensitive) {
				$t =&amp; $this-&gt;attributes;
			} else {
				$t = array_change_key_case($this-&gt;attributes);
				$attr = strtolower($attr);
			}

			if (isset($t[$attr])) {
				$index = 0;
				foreach($this-&gt;attributes as $a =&gt; $v) {
					if (($v === $t[$attr]) &amp;&amp; (strcasecmp($a, $attr) === 0)) {
						$attr = $a;
						$b = explode(':', $attr, 2);
						break;
					}
					++$index;
				}

				if (empty($b[1])) {
					return array(array('', $b[0], $attr, $index));
				} else {
					return array(array($b[0], $b[1], $attr, $index));
				}
			} else {
				return false;
			}
		} else {
			if ($this-&gt;attributes_ns === null) {
				$index = 0;
				foreach($this-&gt;attributes as $a =&gt; $v) {
					$b = explode(':', $a, 2);
					if (empty($b[1])) {
						$this-&gt;attributes_ns[$b[0]][] = array('', $b[0], $a, $index);
					} else {
						$this-&gt;attributes_ns[$b[1]][] = array($b[0], $b[1], $a, $index);
					}
					++$index;
				}
			}

			if ($case_sensitive) {
				$t =&amp; $this-&gt;attributes_ns;
			} else {
				$t = array_change_key_case($this-&gt;attributes_ns);
				$attr = strtolower($attr);
			}

			if ($compare === 'namespace') {
				$res = array();
				foreach($t as $ar) {
					foreach($ar as $a) {
						if ($a[0] === $attr) {
							$res[] = $a;
						}
					}
				}
				return $res;
			} elseif ($compare === 'name') {
				return ((isset($t[$attr])) ? $t[$attr] : false);
			} else {
				trigger_error('Unknown comparison mode');
			}
		}
	}

	/**
	 * Checks if node has attribute
	 * @param string|int$attr Negative int to count from end
	 * @param string $compare Find node using &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 * @return bool
	 */
	function hasAttribute($attr, $compare = 'total', $case_sensitive = false) {
		return ((bool) $this-&gt;findAttribute($attr, $compare, $case_sensitive));
	}

	/**
	 * Gets namespace of attribute(s)
	 * @param string|int $attr Negative int to count from end
	 * @param string $compare Find node using &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 * @return string|array False if not found
	 */
	function getAttributeNS($attr, $compare = 'name', $case_sensitive = false) {
		$f = $this-&gt;findAttribute($attr, $compare, $case_sensitive);
		if (is_array($f) &amp;&amp; $f) {
			if (count($f) === 1) {
				return $this-&gt;attributes[$f[0][0]];
			} else {
				$res = array();
				foreach($f as $a) {
					$res[] = $a[0];
				}
				return $res;
			}
		} else {
			return false;
		}
	}

	/**
	 * Sets namespace of attribute(s)
	 * @param string|int $attr Negative int to count from end
	 * @param string $namespace
	 * @param string $compare Find node using &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 * @return bool
	 */
	function setAttributeNS($attr, $namespace, $compare = 'name', $case_sensitive = false) {
		$f = $this-&gt;findAttribute($attr, $compare, $case_sensitive);
		if (is_array($f) &amp;&amp; $f) {
			if ($namespace) {
				$namespace .= ':';
			}
			foreach($f as $a) {
				$val = $this-&gt;attributes[$a[2]];
				unset($this-&gt;attributes[$a[2]]);
				$this-&gt;attributes[$namespace.$a[1]] = $val;
			}
			$this-&gt;attributes_ns = null;
			return true;
		} else {
			return false;
		}
	}

	/**
	 * Gets value(s) of attribute(s)
	 * @param string|int $attr Negative int to count from end
	 * @param string $compare Find node using &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 * @return string|array
	 */
	function getAttribute($attr, $compare = 'total', $case_sensitive = false) {
		$f = $this-&gt;findAttribute($attr, $compare, $case_sensitive);
		if (is_array($f) &amp;&amp; $f){
			if (count($f) === 1) {
				return $this-&gt;attributes[$f[0][2]];
			} else {
				$res = array();
				foreach($f as $a) {
					$res[] = $this-&gt;attributes[$a[2]];
				}
				return $res;
			}
		} else {
			return null;
		}
	}

	/**
	 * Sets value(s) of attribute(s)
	 * @param string|int $attr Negative int to count from end
	 * @param string $compare Find node using &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 */
	function setAttribute($attr, $val, $compare = 'total', $case_sensitive = false) {
		if ($val === null) {
			return $this-&gt;deleteAttribute($attr, $compare, $case_sensitive);
		}

		$f = $this-&gt;findAttribute($attr, $compare, $case_sensitive);
		if (is_array($f) &amp;&amp; $f) {
			foreach($f as $a) {
				$this-&gt;attributes[$a[2]] = (string) $val;
			}
		} else {
			$this-&gt;attributes[$attr] = (string) $val;
		}
	}

	/**
	 * Add new attribute
	 * @param string $attr
	 * @param string $val
	 */
	function addAttribute($attr, $val) {
		$this-&gt;setAttribute($attr, $val, 'total', true);
	}

	/**
	 * Delete attribute(s)
	 * @param string|int $attr Negative int to count from end
	 * @param string $compare Find node using &quot;namespace&quot;, &quot;name&quot; or &quot;total&quot;
	 * @param bool $case_sensitive Compare with case sensitivity
	 */
	function deleteAttribute($attr, $compare = 'total', $case_sensitive = false) {
		$f = $this-&gt;findAttribute($attr, $compare, $case_sensitive);
		if (is_array($f) &amp;&amp; $f) {
			foreach($f as $a) {
				unset($this-&gt;attributes[$a[2]]);
				if ($this-&gt;attributes_ns !== null) {
					unset($this-&gt;attributes_ns[$a[1]]);
				}
			}
		}
	}

	/**
	 * Determine if node has a certain class
	 * @param string $className
	 * @return bool
	 */
	function hasClass($className) {
		return ($className &amp;&amp; preg_match('`\b'.preg_quote($className).'\b`si', $this-&gt;class));
	}

	/**
	 * Add new class(es)
	 * @param string|array $className
	 */
	function addClass($className) {
		if (!is_array($className)) {
			$className = array($className);
		}
		$class = isset($this-&gt;class) ? $this-&gt;class : '';
		foreach ($className as $c) {
			if (!(preg_match('`\b'.preg_quote($c).'\b`si', $class) &gt; 0)) {
				$class .= ' '.$c;
			}
		}
		 $this-&gt;class = trim($class);
	}

	/**
	 * Remove clas(ses)
	 * @param string|array $className
	 */
	function removeClass($className) {
		if (!is_array($className)) {
			$className = array($className);
		}
		$class = $this-&gt;class;
		foreach ($className as $c) {
			$class = preg_replace('`\b'.preg_quote($c).'\b`si', '', $class);
		}
		if ($class) {
			$this-&gt;class = $class;
		} else {
			unset($this-&gt;class);
		}
	}

	/**
	 * Finds children using a callback function
	 * @param callable $callback Function($node) that returns a bool
	 * @param bool|int $recursive Check recursively
	 * @param bool $check_self Include this node in search?
	 * @return array
	 */
	function getChildrenByCallback($callback, $recursive = true, $check_self = false) {
		$count = $this-&gt;childCount();
		if ($check_self &amp;&amp; $callback($this)) {
			$res = array($this);
		} else {
			$res = array();
		}

		if ($count &gt; 0) {
			if (is_int($recursive)) {
				$recursive = (($recursive &gt; 1) ? $recursive - 1 : false);
			}

			for ($i = 0; $i &lt; $count; $i++) {
				if ($callback($this-&gt;children[$i])) {
					$res[] = $this-&gt;children[$i];
				}
				if ($recursive) {
					$res = array_merge($res, $this-&gt;children[$i]-&gt;getChildrenByCallback($callback, $recursive));
				}
			}
		}

		return $res;
	}

	/**
	 * Finds children using the {$link match()} function
	 * @param $conditions See {$link match()}
	 * @param $custom_filters See {$link match()}
	 * @param bool|int $recursive Check recursively
	 * @param bool $check_self Include this node in search?
	 * @return array
	 */
	function getChildrenByMatch($conditions, $recursive = true, $check_self = false, $custom_filters = array()) {
		$count = $this-&gt;childCount();
		if ($check_self &amp;&amp; $this-&gt;match($conditions, true, $custom_filters)) {
			$res = array($this);
		} else {
			$res = array();
		}

		if ($count &gt; 0) {
			if (is_int($recursive)) {
				$recursive = (($recursive &gt; 1) ? $recursive - 1 : false);
			}

			for ($i = 0; $i &lt; $count; $i++) {
				if ($this-&gt;children[$i]-&gt;match($conditions, true, $custom_filters)) {
					$res[] = $this-&gt;children[$i];
				}
				if ($recursive) {
					$res = array_merge($res, $this-&gt;children[$i]-&gt;getChildrenByMatch($conditions, $recursive, false, $custom_filters));
				}
			}
		}

		return $res;
	}

	/**
	 * Checks if tag matches certain conditions
	 * @param array $tags array('tag1', 'tag2') or array(array(
	 *	'tag' =&gt; 'tag1',
	 *	'operator' =&gt; 'or'/'and',
	 *	'compare' =&gt; 'total'/'namespace'/'name',
	 * 	'case_sensitive' =&gt; true))
	 * @return bool
	 * @internal Used by selector class
	 * @see match()
	 * @access private
	 */
	protected function match_tags($tags) {
		$res = false;

		foreach($tags as $tag =&gt; $match) {
			if (!is_array($match)) {
				$match = array(
					'match' =&gt; $match,
					'operator' =&gt; 'or',
					'compare' =&gt; 'total',
					'case_sensitive' =&gt; false
				);
			} else {
				if (is_int($tag)) {
					$tag = $match['tag'];
				}
				if (!isset($match['match'])) {
					$match['match'] = true;
				}
				if (!isset($match['operator'])) {
					$match['operator'] = 'or';
				}
				if (!isset($match['compare'])) {
					$match['compare'] = 'total';
				}
				if (!isset($match['case_sensitive'])) {
					$match['case_sensitive'] = false;
				}
			}

			if (($match['operator'] === 'and') &amp;&amp; (!$res)) {
				return false;
			} elseif (!($res &amp;&amp; ($match['operator'] === 'or'))) {
				if ($match['compare'] === 'total') {
					$a = $this-&gt;tag;
				} elseif ($match['compare'] === 'namespace') {
					$a = $this-&gt;getNamespace();
				} elseif ($match['compare'] === 'name') {
					$a = $this-&gt;getTag();
				}

				if ($match['case_sensitive']) {
					$res = (($a === $tag) === $match['match']);
				} else {
					$res = ((strcasecmp($a, $tag) === 0) === $match['match']);
				}
			}
		}

		return $res;
	}

	/**
	 * Checks if attributes match certain conditions
	 * @param array $attributes array('attr' =&gt; 'val') or array(array(
	 *	'operator_value' =&gt; 'equals'/'='/'contains_regex'/etc
	 *	'attribute' =&gt; 'attr',
	 *	'value' =&gt; 'val',
	 *	'match' =&gt; true,
	 *	'operator_result' =&gt; 'or'/'and',
	 *	'compare' =&gt; 'total'/'namespace'/'name',
	 *	'case_sensitive' =&gt; true))
	 * @return bool
	 * @internal Used by selector class
	 * @see match()
	 * @access private
	 */
	protected function match_attributes($attributes) {
		$res = false;

		foreach($attributes as $attribute =&gt; $match) {
			if (!is_array($match)) {
				$match = array(
					'operator_value' =&gt; 'equals',
					'value' =&gt; $match,
					'match' =&gt; true,
					'operator_result' =&gt; 'or',
					'compare' =&gt; 'total',
					'case_sensitive' =&gt; false
				);
			} else {
				if (is_int($attribute)) {
					$attribute = $match['attribute'];
				}
				if (!isset($match['match'])) {
					$match['match'] = true;
				}
				if (!isset($match['operator_result'])) {
					$match['operator_result'] = 'or';
				}
				if (!isset($match['compare'])) {
					$match['compare'] = 'total';
				}
				if (!isset($match['case_sensitive'])) {
					$match['case_sensitive'] = false;
				}
			}

			if (is_string($match['value']) &amp;&amp; (!$match['case_sensitive'])) {
				$match['value'] = strtolower($match['value']);
			}

			if (($match['operator_result'] === 'and') &amp;&amp; (!$res)) {
				return false;
			} elseif (!($res &amp;&amp; ($match['operator_result'] === 'or'))) {
				$possibles = $this-&gt;findAttribute($attribute, $match['compare'], $match['case_sensitive']);

				$has = (is_array($possibles) &amp;&amp; $possibles);
				$res = (($match['value'] === $has) || (($match['match'] === false) &amp;&amp; ($has === $match['match'])));

				if ((!$res) &amp;&amp; $has &amp;&amp; is_string($match['value'])) {
					foreach($possibles as $a) {
						$val = $this-&gt;attributes[$a[2]];
						if (is_string($val) &amp;&amp; (!$match['case_sensitive'])) {
							$val = strtolower($val);
						}

						switch($match['operator_value']) {
							case '%=':
							case 'contains_regex':
								$res = ((preg_match('`'.$match['value'].'`s', $val) &gt; 0) === $match['match']);
								if ($res) break 1; else break 2;

							case '|=':
							case 'contains_prefix':
								$res = ((preg_match('`\b'.preg_quote($match['value']).'[\-\s]`s', $val) &gt; 0) === $match['match']);
								if ($res) break 1; else break 2;

							case '~=':
							case 'contains_word':
								$res = ((preg_match('`\s'.preg_quote($match['value']).'\s`s', &quot; $val &quot;) &gt; 0) === $match['match']);
								if ($res) break 1; else break 2;

							case '*=':
							case 'contains':
								$res = ((strpos($val, $match['value']) !== false) === $match['match']);
								if ($res) break 1; else break 2;

							case '$=':
							case 'ends_with':
								$res = ((substr($val, -strlen($match['value'])) === $match['value']) === $match['match']);
								if ($res) break 1; else break 2;

							case '^=':
							case 'starts_with':
								$res = ((substr($val, 0, strlen($match['value'])) === $match['value']) === $match['match']);
								if ($res) break 1; else break 2;

							case '!=':
							case 'not_equal':
								$res = (($val !== $match['value']) === $match['match']);
								if ($res) break 1; else break 2;

							case '=':
							case 'equals':
								$res = (($val === $match['value']) === $match['match']);
								if ($res) break 1; else break 2;

							case '&gt;=':
							case 'bigger_than':
								$res = (($val &gt;= $match['value']) === $match['match']);
								if ($res) break 1; else break 2;

							case '&lt;=':
							case 'smaller_than':
								$res = (($val &gt;= $match['value']) === $match['match']);
								if ($res) break 1; else break 2;

							default:
								trigger_error('Unknown operator &quot;'.$match['operator_value'].'&quot; to match attributes!');
								return false;
						}
					}
				}
			}
		}

		return $res;
	}

	/**
	 * Checks if node matches certain filters
	 * @param array $tags array(array(
	 *	'filter' =&gt; 'last-child',
	 *	'params' =&gt; '123'))
	 * @param array $custom_filters Custom map next to {@link $filter_map}
	 * @return bool
	 * @internal Used by selector class
	 * @see match()
	 * @access private
	 */
	protected function match_filters($conditions, $custom_filters = array()) {
		foreach($conditions as $c) {
			$c['filter'] = strtolower($c['filter']);
			if (isset($this-&gt;filter_map[$c['filter']])) {
				if (!$this-&gt;{$this-&gt;filter_map[$c['filter']]}($c['params'])) {
					return false;
				}
			} elseif (isset($custom_filters[$c['filter']])) {
				if (!call_user_func($custom_filters[$c['filter']], $this, $c['params'])) {
					return false;
				}
			} else {
				trigger_error('Unknown filter &quot;'.$c['filter'].'&quot;!');
				return false;
			}
		}

		return true;
	}

	/**
	 * Checks if node matches certain conditions
	 * @param array $tags array('tags' =&gt; array(tag_conditions), 'attributes' =&gt; array(attr_conditions), 'filters' =&gt; array(filter_conditions))
	 * @param array $match Should conditions evaluate to true?
	 * @param array $custom_filters Custom map next to {@link $filter_map}
	 * @return bool
	 * @internal Used by selector class
	 * @see match_tags();
	 * @see match_attributes();
	 * @see match_filters();
	 * @access private
	 */
	function match($conditions, $match = true, $custom_filters = array()) {
		$t = isset($conditions['tags']);
		$a = isset($conditions['attributes']);
		$f = isset($conditions['filters']);

		if (!($t || $a || $f)) {
			if (is_array($conditions) &amp;&amp; $conditions) {
				foreach($conditions as $c) {
					if ($this-&gt;match($c, $match)) {
						return true;
					}
				}
			}

			return false;
		} else {
			if (($t &amp;&amp; (!$this-&gt;match_tags($conditions['tags']))) === $match) {
				return false;
			}

			if (($a &amp;&amp; (!$this-&gt;match_attributes($conditions['attributes']))) === $match) {
				return false;
			}

			if (($f &amp;&amp; (!$this-&gt;match_filters($conditions['filters'], $custom_filters))) === $match) {
				return false;
			}

			return true;
		}
	}

	/**
	 * Finds children that match a certain attribute
	 * @param string $attribute
	 * @param string $value
	 * @param string $mode Compare mode, &quot;equals&quot;, &quot;|=&quot;, &quot;contains_regex&quot;, etc.
	 * @param string $compare &quot;total&quot;/&quot;namespace&quot;/&quot;name&quot;
	 * @param bool|int $recursive
	 * @return array
	 */
	function getChildrenByAttribute($attribute, $value, $mode = 'equals', $compare = 'total', $recursive = true) {
		if ($this-&gt;childCount() &lt; 1) {
			return array();
		}

		$mode = explode(' ', strtolower($mode));
		$match = ((isset($mode[1]) &amp;&amp; ($mode[1] === 'not')) ? 'false' : 'true');

		return $this-&gt;getChildrenByMatch(
			array(
				'attributes' =&gt; array(
					$attribute =&gt; array(
						'operator_value' =&gt; $mode[0],
						'value' =&gt; $value,
						'match' =&gt; $match,
						'compare' =&gt; $compare
					)
				)
			),
			$recursive
		);
	}

	/**
	 * Finds children that match a certain tag
	 * @param string $tag
	 * @param string $compare &quot;total&quot;/&quot;namespace&quot;/&quot;name&quot;
	 * @param bool|int $recursive
	 * @return array
	 */
	function getChildrenByTag($tag, $compare = 'total', $recursive = true) {
		if ($this-&gt;childCount() &lt; 1) {
			return array();
		}

		$tag = explode(' ', strtolower($tag));
		$match = ((isset($tag[1]) &amp;&amp; ($tag[1] === 'not')) ? 'false' : 'true');

		return $this-&gt;getChildrenByMatch(
			array(
				'tags' =&gt; array(
					$tag[0] =&gt; array(
						'match' =&gt; $match,
						'compare' =&gt; $compare
					)
				)
			),
			$recursive
		);
	}

	/**
	 * Finds all children using ID attribute
	 * @param string $id
	 * @param bool|int $recursive
	 * @return array
	 */
	function getChildrenByID($id, $recursive = true) {
		return $this-&gt;getChildrenByAttribute('id', $id, 'equals', 'total', $recursive);
	}

	/**
	 * Finds all children using class attribute
	 * @param string $class
	 * @param bool|int $recursive
	 * @return array
	 */
	function getChildrenByClass($class, $recursive = true) {
		return $this-&gt;getChildrenByAttribute('class', $class, 'equals', 'total', $recursive);
	}

	/**
	 * Finds all children using name attribute
	 * @param string $name
	 * @param bool|int $recursive
	 * @return array
	 */
	function getChildrenByName($name, $recursive = true) {
		return $this-&gt;getChildrenByAttribute('name', $name, 'equals', 'total', $recursive);
	}

    /**
     * Performs a css query on the node.
     * @param string $query
     * @return IQuery Returns the matching nodes from the query.
     */
    public function query($query = '*') {
        $select = $this-&gt;select($query);
        $result = new \pagelayerQuery((array)$select);
        return $result;
    }

	/**
	 * Performs css query on node
	 * @param string $query
	 * @param int|bool $index True to return node instead of array if only 1 match,
	 * false to return array, int to return match at index, negative int to count from end
	 * @param bool|int $recursive
	 * @param bool $check_self Include this node in search or only search child nodes
	 * @return DomNode[]|DomNode Returns an array of matching {@link DomNode} objects
     *  or a single {@link DomNode} if `$index` is not false.
	 */
	function select($query = '*', $index = false, $recursive = true, $check_self = false) {
		$s = new $this-&gt;selectClass($this, $query, $check_self, $recursive);
		$res = $s-&gt;result;
		unset($s);
		if (is_array($res) &amp;&amp; ($index === true) &amp;&amp; (count($res) === 1)) {
			return $res[0];
		} elseif (is_int($index) &amp;&amp; is_array($res)) {
			if ($index &lt; 0) {
				$index += count($res);
			}
			return ($index &lt; count($res)) ? $res[$index] : null;
        } else {
			return $res;
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:root&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_root() {
		return (strtolower($this-&gt;tag) === 'html');
	}

	/**
	 * Checks if node matches css query filter &quot;:nth-child(n)&quot;
	 * @param string $n 1-based index
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_nchild($n) {
		return ($this-&gt;index(false)+1 === (int) $n);
	}

	/**
	 * Checks if node matches css query filter &quot;:gt(n)&quot;
	 * @param string $n 0-based index
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_gt($n) {
		return ($this-&gt;index(false) &gt; (int) $n);
	}

	/**
	 * Checks if node matches css query filter &quot;:lt(n)&quot;
	 * @param string $n 0-based index
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_lt($n) {
		return ($this-&gt;index(false) &lt; (int) $n);
	}

	/**
	 * Checks if node matches css query filter &quot;:nth-last-child(n)&quot;
	 * @param string $n 1-based index
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_nlastchild($n) {
		if ($this-&gt;parent === null) {
			return false;
		} else {
			return ($this-&gt;parent-&gt;childCount(true) - $this-&gt;index(false) === (int) $n);
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:nth-of-type(n)&quot;
	 * @param string $n 1-based index
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_ntype($n) {
		return ($this-&gt;typeIndex()+1 === (int) $n);
	}

	/**
	 * Checks if node matches css query filter &quot;:nth-last-of-type(n)&quot;
	 * @param string $n 1-based index
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_nlastype($n) {
		if ($this-&gt;parent === null) {
			return false;
		} else {
			return (count($this-&gt;parent-&gt;getChildrenByTag($this-&gt;tag, 'total', false)) - $this-&gt;typeIndex() === (int) $n);
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:odd&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_odd() {
		return (($this-&gt;index(false) &amp; 1) === 1);
	}

	/**
	 * Checks if node matches css query filter &quot;:even&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_even() {
		return (($this-&gt;index(false) &amp; 1) === 0);
	}

	/**
	 * Checks if node matches css query filter &quot;:every(n)&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_every($n) {
		return (($this-&gt;index(false) % (int) $n) === 0);
	}

	/**
	 * Checks if node matches css query filter &quot;:first&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_first() {
		return ($this-&gt;index(false) === 0);
	}

	/**
	 * Checks if node matches css query filter &quot;:last&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_last() {
		if ($this-&gt;parent === null) {
			return false;
		} else {
			return ($this-&gt;parent-&gt;childCount(true) - 1 === $this-&gt;index(false));
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:first-of-type&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_firsttype() {
		return ($this-&gt;typeIndex() === 0);
	}

	/**
	 * Checks if node matches css query filter &quot;:last-of-type&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_lasttype() {
		if ($this-&gt;parent === null) {
			return false;
		} else {
			return (count($this-&gt;parent-&gt;getChildrenByTag($this-&gt;tag, 'total', false)) - 1 === $this-&gt;typeIndex());
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:only-child&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_onlychild() {
		if ($this-&gt;parent === null) {
			return false;
		} else {
			return ($this-&gt;parent-&gt;childCount(true) === 1);
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:only-of-type&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_onlytype() {
		if ($this-&gt;parent === null) {
			return false;
		} else {
			return (count($this-&gt;parent-&gt;getChildrenByTag($this-&gt;tag, 'total', false)) === 1);
		}
	}

	/**
	 * Checks if node matches css query filter &quot;:empty&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_empty() {
		return ($this-&gt;childCount() === 0);
	}

	/**
	 * Checks if node matches css query filter &quot;:not-empty&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_notempty() {
		return ($this-&gt;childCount() !== 0);
	}

	/**
	 * Checks if node matches css query filter &quot;:has-text&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_hastext() {
		return ($this-&gt;getPlainText() !== '');
	}

	/**
	 * Checks if node matches css query filter &quot;:no-text&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_notext() {
		return ($this-&gt;getPlainText() === '');
	}

	/**
	 * Checks if node matches css query filter &quot;:lang(s)&quot;
	 * @param string $lang
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_lang($lang) {
		return ($this-&gt;lang === $lang);
	}

	/**
	 * Checks if node matches css query filter &quot;:contains(s)&quot;
	 * @param string $text
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_contains($text) {
		return (strpos($this-&gt;getPlainTextUTF8(), $text) !== false);
	}

	/**
	 * Checks if node matches css query filter &quot;:has(s)&quot;
	 * @param string $selector
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_has($selector) {
		$s = $this-&gt;select((string) $selector, false);
		return (is_array($s) &amp;&amp; (count($s) &gt; 0));
	}

	/**
	 * Checks if node matches css query filter &quot;:not(s)&quot;
	 * @param string $selector
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_not($selector) {
		$s = $this-&gt;select((string) $selector, false, true, true);
		return ((!is_array($s)) || (array_search($this, $s, true) === false));
	}

	/**
	 * Checks if node matches css query filter &quot;:element&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_element() {
		return true;
	}

	/**
	 * Checks if node matches css query filter &quot;:text&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_text() {
		return false;
	}

    /**
     * Checks if a node matches css query filter &quot;:checked&quot;
     * @return bool
     * @see match()
     */
    protected function filter_checked() {
        $attr = $this-&gt;getAttribute('checked');
        if (is_array($attr))
            $attr = reset($attr);
        return strcasecmp($attr, 'checked') === 0;
    }

	/**
	 * Checks if node matches css query filter &quot;:comment&quot;
	 * @return bool
	 * @see match()
	 * @access private
	 */
	protected function filter_comment() {
		return false;
	}

    /**
     * Checks if a node matches css query filter &quot;:selected&quot;
     * @return bool
     * @see match()
     */
    protected function filter_selected() {
        $attr = $this-&gt;getAttribute('selected');
        if (is_array($attr))
            $attr = reset($attr);

        return strcasecmp($attr, 'selected') === 0;
    }

    public function after($content) {
        $offset = $this-&gt;index() + 1;
        $parent = $this-&gt;parent;
        $nodes = $this-&gt;createNodes($content);

        foreach ($nodes as $node) {
            $node-&gt;changeParent($parent, $offset);
        }
        return $this;
    }


    /**
     * Create a {@link DomNode} from its string representation.
     * @param string|DomNode $content
     * @return DomNode
     */
    protected function createNode($content) {
        $nodes = $this-&gt;createNodes($content);
        return reset($nodes);
    }

    /**
     * Create an array of {@link DomNode} objects from their string representation.
     * @param string|DomNode $content
     * @return DomNode[]
     */
    protected function createNodes($content) {
        if (is_string($content)) {
            if (strpos($content, ' ') === false) {
                $nodes = array(new $this-&gt;childClass($content, $this));
            } else {
                $node = new $this-&gt;parserClass($content);
                $nodes = $node-&gt;root-&gt;children;
            }
        } else {
            $nodes = (array)$content;
        }
        return $nodes;
    }

    public function append($content) {
        $nodes = $this-&gt;createNodes($content);
        foreach ($nodes as $node) {
            $node-&gt;changeParent($this);
        }
        return $this;
    }

    public function attr($name, $value = null) {
        if ($value === null)
            return $this-&gt;getAttribute($name);

        $this-&gt;setAttribute($name, $value);
        return $this;
    }

   public function before($content) {
      $offset = $this-&gt;index();
      $parent = $this-&gt;parent;
      $nodes = $this-&gt;createNodes($content);

      foreach ($nodes as $node) {
          $node-&gt;changeParent($parent, $offset);
      }

      return $this;
   }

   #[\ReturnTypeWillChange]
   public function count() {
       return 1;
   }

//   public function css($name, $value = null) {
//
//   }

   public function prepend($content = null) {
      $offset = 0;
      $parent = $this;
      $nodes = $this-&gt;createNodes($content);

      foreach ($nodes as $node) {
          $node-&gt;changeParent($parent, $offset);
      }

      return $this;
   }

    public function prop($name, $value = null) {
        switch (strtolower($name)) {
            case 'checked':
            case 'disabled':
            case 'selected':
                if ($value !== null) {
                    if ($value) {
                        $this-&gt;attr($name, $name);
                    } else {
                        $this-&gt;removeAttr($name);
                    }
                    return $this;
                }
                return $this-&gt;attr($name) == $name;
            case 'tagname':
                return $this-&gt;tagName($value);
        }
        // The property is not supported, degrade gracefully
        if ($value === null)
            return $this;
        else
            return null;
    }

   public function remove($selector = null) {
      if ($selector == null) {
         $this-&gt;delete();
      } else {
         $nodes = (array)$this-&gt;select($selector);
         foreach ($nodes as $node) {
            $node-&gt;delete();
         }
      }
   }

   public function removeAttr($name) {
      $this-&gt;deleteAttribute($name);

      return $this;
   }

   function replaceWith($content) {
        $node_index = $this-&gt;index();

        // Add the new node.
        $node = $this-&gt;createNode($content);
        $node-&gt;changeParent($this-&gt;parent, $node_index);

        // Remove this node.
        $this-&gt;remove();

		return $node;
	}

    /**
     * @param type $value
     * @return string|DomNode
     */
    public function tagName($value = null) {
        if ($value !== null) {
            $this-&gt;setTag($value);
            return $this;
        }
        return $this-&gt;getTag();
    }

   public function text($value = null) {
      if ($value === null)
         return $this-&gt;getPlainText();

      $this-&gt;setPlainText($value);
      return $this;
   }

   public function toggleClass($classname, $switch = null) {
      if ($switch === true) {
         $this-&gt;addClass($classname);
      } elseif ($switch === false) {
         $this-&gt;removeClass($classname);
      } else {
         if ($this-&gt;hasClass($classname))
            $this-&gt;removeClass($classname);
         else
            $this-&gt;addClass($classname);
      }
      return $this;
   }

   public function unwrap() {
      $this-&gt;parent-&gt;detach(true);
      return $this;
   }

    public function val($value = null) {
        switch (strtolower($this-&gt;tag)) {
            case 'select':
                if ($value === null) {
                    // Return the value of a selected child.
                    return $this-&gt;query('option:selected')-&gt;attr('value');
                } else {
                    // Select the option with the right value and deselect the others.
                    foreach ($this-&gt;query('option') as $option) {
                        if ($option-&gt;attr('value') == $value) {
                            $option-&gt;attr('selected', 'selected');
                        } else {
                            $option-&gt;removeAttr('selected');
                        }
                    }
                    return $this;
                }
            case 'textarea':
                if ($value === null) {
                    // Return the contents of the textarea.
                    return $this-&gt;getInnerText();
                } else {
                    // Set the contents of the textarea.
                    $this-&gt;setInnerText($value);
                    return $this;
                }
            case 'input':
                switch (strtolower($this-&gt;getAttribute('type'))) {
                    case 'checkbox':
                        if ($value === null)
                            return $this-&gt;prop('checked') ? $this-&gt;getAttribute('value') : null;
                        else {
                            if (!$value) {
                                $this-&gt;deleteAttribute('checked');
                            } else {
                                $this-&gt;setAttribute('value', $value);
                                $this-&gt;setAttribute('checked', 'checked');
                            }
                            return $this;
                        }
                }
        }

        // Other node types can just get/set the value attribute.
        if ($value !== null) {
           $this-&gt;setAttribute('value', $value);
           return $this;
        }
        return $this-&gt;getAttribute('value');
    }

}

/**
 * Node subclass for text
 */
class TextNode extends DomNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_TEXT;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_TEXT;
	#php5e
	var $tag = '~text~';

	/**
	 * @var string
	 */
	var $text = '';

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $text
	 */
	function __construct($parent, $text = '') {
		$this-&gt;parent = $parent;
		$this-&gt;text = $text;
	}

	#php4 PHP4 class constructor compatibility
	#function TextNode($parent, $text = '') {return $this-&gt;__construct($parent, $text);}
	#php4e

	function isText() {return true;}
	function isTextOrComment() {return true;}
	protected function filter_element() {return false;}
	protected function filter_text() {return true;}
	function toString_attributes() {return '';}
	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this-&gt;text;}
	function toString($attributes = true, $recursive = true, $content_only = false) {return $this-&gt;text;}

    /**
     * {@inheritdoc}
     */
    public function text($value = null) {
        if ($value !== null) {
            $this-&gt;text = $value;
            return $this;
        }
        return $this-&gt;text;
    }

    /**
     * {@inheritdoc}
     */
    public function html($value = null) {
        if ($value !== null) {
            $this-&gt;text = $value;
            return $this;
        }
        return $this-&gt;text;
    }
}

/**
 * Node subclass for comments
 */
class CommentNode extends DomNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_COMMENT;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_COMMENT;
	#php5e
	var $tag = '~comment~';

	/**
	 * @var string
	 */
	var $text = '';

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $text
	 */
	function __construct($parent, $text = '') {
		$this-&gt;parent = $parent;
		$this-&gt;text = $text;
	}

	#php4 PHP4 class constructor compatibility
	#function CommentNode($parent, $text = '') {return $this-&gt;__construct($parent, $text);}
	#php4e

	function isComment() {return true;}
	function isTextOrComment() {return true;}
	protected function filter_element() {return false;}
	protected function filter_comment() {return true;}
	function toString_attributes() {return '';}
	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this-&gt;text;}
	function toString($attributes = true, $recursive = true, $content_only = false) {return '&lt;!--'.$this-&gt;text.'--&gt;';}
}

/**
 * Node subclass for conditional tags
 */
class ConditionalTagNode extends DomNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_CONDITIONAL;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_CONDITIONAL;
	#php5e
	var $tag = '~conditional~';

	/**
	 * @var string
	 */
	var $condition = '';

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $condition e.g. &quot;if IE&quot;
	 * @param bool $hidden &lt;!--[if if true, &lt;![if if false
	 */
	function __construct($parent, $condition = '', $hidden = true) {
		$this-&gt;parent = $parent;
		$this-&gt;hidden = $hidden;
		$this-&gt;condition = $condition;
	}

	#php4 PHP4 class constructor compatibility
	#function ConditionalTagNode($parent, $condition = '', $hidden = true) {return $this-&gt;__construct($parent, $condition, $hidden);}
	#php4e

	protected function filter_element() {return false;}
	function toString_attributes() {return '';}
	function toString($attributes = true, $recursive = true, $content_only = false) {
		if ($content_only) {
			if (is_int($content_only)) {
				--$content_only;
			}
			return $this-&gt;toString_content($attributes, $recursive, $content_only);
		}

		$s = '&lt;!'.(($this-&gt;hidden) ? '--' : '').'['.$this-&gt;condition.']&gt;';
		if($recursive) {
			$s .= $this-&gt;toString_content($attributes);
		}
		$s .= '&lt;![endif]'.(($this-&gt;hidden) ? '--' : '').'&gt;';
		return $s;
	}
}

/**
 * Node subclass for CDATA tags
 */
class CdataNode extends DomNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_CDATA;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_CDATA;
	#php5e
	var $tag = '~cdata~';

	/**
	 * @var string
	 */
	var $text = '';

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $text
	 */
	function __construct($parent, $text = '') {
		$this-&gt;parent = $parent;
		$this-&gt;text = $text;
	}

	#php4 PHP4 class constructor compatibility
	#function CdataNode($parent, $text = '') {return $this-&gt;__construct($parent, $text);}
	#php4e

	protected function filter_element() {return false;}
	function toString_attributes() {return '';}
	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this-&gt;text;}
	function toString($attributes = true, $recursive = true, $content_only = false) {return '&lt;![CDATA['.$this-&gt;text.']]&gt;';}
}

/**
 * Node subclass for doctype tags
 */
class DoctypeNode extends DomNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_DOCTYPE;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_DOCTYPE;
	#php5e
	var $tag = '!DOCTYPE';

	/**
	 * @var string
	 */
	var $dtd = '';

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $dtd
	 */
	function __construct($parent, $dtd = '') {
		$this-&gt;parent = $parent;
		$this-&gt;dtd = $dtd;
	}

	#php4 PHP4 class constructor compatibility
	#function DoctypeNode($parent, $dtd = '') {return $this-&gt;__construct($parent, $dtd);}
	#php4e

	protected function filter_element() {return false;}
	function toString_attributes() {return '';}
	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this-&gt;text;}
	function toString($attributes = true, $recursive = true, $content_only = false) {return '&lt;'.$this-&gt;tag.' '.$this-&gt;dtd.'&gt;';}
}

/**
 * Node subclass for embedded tags like xml, php and asp
 */
class EmbeddedNode extends DomNode {

	/**
	 * @var string
	 * @internal specific char for tags, like ? for php and % for asp
	 * @access private
	 */
	var $tag_char = '';

	/**
	 * @var string
	 */
	var $text = '';

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $tag_char {@link $tag_char}
	 * @param string $tag {@link $tag}
	 * @param string $text
	 * @param array $attributes array('attr' =&gt; 'val')
	 */
	function __construct($parent, $tag_char = '', $tag = '', $text = '', $attributes = array()) {
		$this-&gt;parent = $parent;
		$this-&gt;tag_char = $tag_char;
		if ($tag[0] !== $this-&gt;tag_char) {
			$tag = $this-&gt;tag_char.$tag;
		}
		$this-&gt;tag = $tag;
		$this-&gt;text = $text;
		$this-&gt;attributes = $attributes;
		$this-&gt;self_close_str = $tag_char;
	}

	#php4 PHP4 class constructor compatibility
	#function EmbeddedNode($parent, $tag_char = '', $tag = '', $text = '', $attributes = array()) {return $this-&gt;__construct($parent, $tag_char, $tag, $text, $attributes);}
	#php4e

	protected function filter_element() {return false;}
	function toString($attributes = true, $recursive = true, $content_only = false) {
		$s = '&lt;'.$this-&gt;tag;
		if ($attributes) {
			$s .= $this-&gt;toString_attributes();
		}
		$s .= $this-&gt;text.$this-&gt;self_close_str.'&gt;';
		return $s;
	}
}

/**
 * Node subclass for &quot;?&quot; tags, like php and xml
 */
class XmlNode extends EmbeddedNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_XML;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_XML;
	#php5e

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $tag {@link $tag}
	 * @param string $text
	 * @param array $attributes array('attr' =&gt; 'val')
	 */
	function __construct($parent, $tag = 'xml', $text = '', $attributes = array()) {
		return parent::__construct($parent, '?', $tag, $text, $attributes);
	}

	#php4 PHP4 class constructor compatibility
	#function XmlNode($parent, $tag = 'xml', $text = '', $attributes = array()) {return $this-&gt;__construct($parent, $tag, $text, $attributes);}
	#php4e
}

/**
 * Node subclass for asp tags
 */
class AspEmbeddedNode extends EmbeddedNode {
	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool
	#static $NODE_TYPE = self::NODE_ASP;
	#php4e
	#php5
	const NODE_TYPE = self::NODE_ASP;
	#php5e

	/**
	 * Class constructor
	 * @param DomNode $parent
	 * @param string $tag {@link $tag}
	 * @param string $text
	 * @param array $attributes array('attr' =&gt; 'val')
	 */
	function __construct($parent, $tag = '', $text = '', $attributes = array()) {
		return parent::__construct($parent, '%', $tag, $text, $attributes);
	}

	#php4 PHP4 class constructor compatibility
	#function AspEmbeddedNode($parent, $tag = '', $text = '', $attributes = array()) {return $this-&gt;__construct($parent, $tag, $text, $attributes);}
	#php4e
}

?&gt;</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fsitepad%2Feditor%2Fsite-data%2Fplugins%2Fpagelayer%2Flib%2Fpquery'>Back to Directory</a>