pQuery\DomNode

Complexity

Total Complexity

444

Size/Duplication

Total Lines	2503
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

55.93%

Importance

Changes	11
Bugs	3	Features	4

133 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	__destruct()	0	3	1
A	__toString()	0	3	2
A	__get()	0	3	1
A	__set()	0	3	1
A	__isset()	0	3	1
A	__unset()	0	3	1
A	__invoke()	0	3	1
A	dumpLocation()	0	3	3
B	toString_attributes()	0	11	5
A	toString_content()	0	7	2
B	toString()	0	23	6
A	getOuterText()	0	3	1
B	setOuterText()	0	13	5
A	html()	0	6	2
A	getInnerText()	0	3	1
B	setInnerText()	0	12	5
A	getPlainText()	0	3	1
A	getPlainTextUTF8()	0	8	2
A	setPlainText()	0	6	2
A	delete()	0	8	2
A	detach()	0	11	3
A	clear()	0	7	2
A	getRoot()	0	10	3
B	changeParent()	0	13	5
B	hasParent()	0	13	9
A	isParent()	0	3	1
A	isText()	0	3	1
A	isComment()	0	3	1
A	isTextOrComment()	0	3	1
A	move()	0	4	1
A	moveChildren()	0	9	3
B	index()	0	27	6
A	setIndex()	0	9	3
B	typeIndex()	0	25	5
A	indent()	0	3	2
A	getSibling()	0	8	3
A	getNextSibling()	0	12	4
A	getPreviousSibling()	0	12	4
A	getNamespace()	0	12	3
A	setNamespace()	0	6	2
A	getTag()	0	7	2
B	setTag()	0	10	5
B	getEncoding()	0	15	5
A	childCount()	0	19	4
A	findChild()	0	3	1
A	hasChild()	0	3	1
C	getChild()	0	32	8
C	addChild()	0	28	11
A	firstChild()	0	3	1
A	lastChild()	0	3	1
A	insertChild()	0	3	1
A	addText()	0	4	1
A	addComment()	0	4	1
A	addConditional()	0	4	1
A	addCDATA()	0	4	1
A	addDoctype()	0	4	1
A	addXML()	0	4	1
A	addASP()	0	4	1
B	deleteChild()	0	23	5
A	wrap()	0	14	4
B	wrapInner()	0	17	5
A	attributeCount()	0	3	1
C	findAttribute()	0	73	20
A	hasAttribute()	0	3	1
B	getAttributeNS()	0	16	5
B	setAttributeNS()	0	17	5
B	getAttribute()	0	16	5
B	setAttribute()	0	14	5
A	addAttribute()	0	3	1
B	deleteAttribute()	0	11	5
A	hasClass()	0	3	2
A	addClass()	0	12	4
A	removeClass()	0	14	4
D	getChildrenByCallback()	0	25	9
D	getChildrenByMatch()	0	25	9
D	match_tags()	0	50	16
F	match_attributes()	0	112	53
B	match_filters()	0	19	6
C	match()	0	31	14
B	getChildrenByAttribute()	0	22	4
A	getChildrenByTag()	0	20	4
A	getChildrenByID()	0	3	1
A	getChildrenByClass()	0	3	1
A	getChildrenByName()	0	3	1
A	query()	0	5	1
B	select()	0	15	8
A	filter_root()	0	3	1
A	filter_nchild()	0	3	1
A	filter_gt()	0	3	1
A	filter_lt()	0	3	1
A	filter_nlastchild()	0	7	2
A	filter_ntype()	0	3	1
A	filter_nlastype()	0	7	2
A	filter_odd()	0	3	1
A	filter_even()	0	3	1
A	filter_every()	0	3	1
A	filter_first()	0	3	1
A	filter_last()	0	7	2
A	filter_firsttype()	0	3	1
A	filter_lasttype()	0	7	2
A	filter_onlychild()	0	7	2
A	filter_onlytype()	0	7	2
A	filter_empty()	0	3	1
A	filter_notempty()	0	3	1
A	filter_hastext()	0	3	1
A	filter_notext()	0	3	1
A	filter_lang()	0	3	1
A	filter_contains()	0	3	1
A	filter_has()	0	4	2
A	filter_not()	0	4	2
A	filter_element()	0	3	1
A	filter_text()	0	3	1
A	filter_checked()	0	6	2
A	filter_comment()	0	3	1
A	filter_selected()	0	7	2
A	after()	0	10	2
A	createNode()	0	4	1
A	createNodes()	0	13	3
A	append()	0	7	2
A	attr()	0	7	2
A	before()	0	11	2
A	count()	0	3	1
A	prepend()	0	11	2
C	prop()	0	23	8
A	remove()	0	10	3
A	removeAttr()	0	5	1
A	replaceWith()	0	12	1
A	tagName()	0	7	2
A	text()	0	7	2
A	toggleClass()	0	13	4
A	unwrap()	0	4	1
C	val()	0	50	13

<?php

/**

 * @author Niels A.D.

 * @author Todd Burry <todd@vanillaforums.com>

 * @copyright 2010 Niels A.D., 2014 Todd Burry

 * @license http://opensource.org/licenses/LGPL-2.1 LGPL-2.1

 * @package pQuery

 */


namespace pQuery;


/**

 * 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 (<![if]> <![endif])

	 */

	const NODE_CONDITIONAL = 3;

	/**

	 * CDATA Node (<![CDATA[]]>

	 */

	const NODE_CDATA = 4;

	/**

	 * Doctype Node

	 */

	const NODE_DOCTYPE = 5;

	/**

	 * XML Node, used for tags that start with ?, like <?xml and <?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;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	/**

	 * Node type of class

	 */

	const NODE_TYPE = self::NODE_ELEMENT;

	#php5e



	/**

	 * Name of the selector class

	 * @var string

	 * @see select()

	 */

	var $selectClass = 'pQuery\\HtmlSelector';

The visibility should be declared for property $selectClass.

	/**

	 * Name of the parser class

	 * @var string

	 * @see setOuterText()

	 * @see setInnerText()

	 */

	var $parserClass = 'pQuery\\Html5Parser';

The visibility should be declared for property $parserClass.

	/**

	 * Name of the class used for {@link addChild()}

	 * @var string

	 */

	var $childClass = __CLASS__;

The visibility should be declared for property $childClass.

	/**

	 * Name of the class used for {@link addText()}

	 * @var string

	 */

	var $childClass_Text = 'pQuery\\TextNode';

The visibility should be declared for property $childClass_Text.

	/**

	 * Name of the class used for {@link addComment()}

	 * @var string

	 */

	var $childClass_Comment = 'pQuery\\CommentNode';

The visibility should be declared for property $childClass_Comment.

	/**

	 * Name of the class used for {@link addContional()}

	 * @var string

	 */

	var $childClass_Conditional = 'pQuery\\ConditionalTagNode';

The visibility should be declared for property $childClass_Conditional.

	/**

	 * Name of the class used for {@link addCDATA()}

	 * @var string

	 */

	var $childClass_CDATA = 'pQuery\\CdataNode';

The visibility should be declared for property $childClass_CDATA.

	/**

	 * Name of the class used for {@link addDoctype()}

	 * @var string

	 */

	var $childClass_Doctype = 'pQuery\\DoctypeNode';

The visibility should be declared for property $childClass_Doctype.

	/**

	 * Name of the class used for {@link addXML()}

	 * @var string

	 */

	var $childClass_XML = 'pQuery\\XmlNode';

The visibility should be declared for property $childClass_XML.

	/**

	 * Name of the class used for {@link addASP()}

	 * @var string

	 */

	var $childClass_ASP = 'pQuery\\AspEmbeddedNode';

The visibility should be declared for property $childClass_ASP.

	/**

	 * Parent node, null if none

	 * @var DomNode

	 * @see changeParent()

	 */

	var $parent = null;

The visibility should be declared for property $parent.

	/**

	 * Attributes of node

	 * @var array

	 * @internal array('attribute' => 'value')

	 * @internal Public for faster access!

	 * @see getAttribute()

	 * @see setAttribute()

	 * @access private

	 */

	var $attributes = array();

The visibility should be declared for property $attributes.

	/**

	 * Namespace info for attributes

	 * @var array

	 * @internal array('tag' => array(array('ns', 'tag', 'ns:tag', index)))

	 * @internal Public for easy outside modifications!

	 * @see findAttribute()

	 * @access private

	 */

	var $attributes_ns = null;

The visibility should be declared for property $attributes_ns.

	/**

	 * Array of child nodes

	 * @var array

	 * @internal Public for faster access!

	 * @see childCount()

	 * @see getChild()

	 * @see addChild()

	 * @see deleteChild()

	 * @access private

	 */

	var $children = array();

The visibility should be declared for property $children.

	/**

	 * Full tag name (including namespace)

	 * @var string

	 * @see getTagName()

	 * @see getNamespace()

	 */

	var $tag = '';

The visibility should be declared for property $tag.

	/**

	 * Namespace info for tag

	 * @var array

	 * @internal array('namespace', 'tag')

	 * @internal Public for easy outside modifications!

	 * @access private

	 */

	var $tag_ns = null;

The visibility should be declared for property $tag_ns.

	/**

	 * Is node a self closing node? No closing tag if true.

	 * @var bool

	 */

	var $self_close = false;

The visibility should be declared for property $self_close.

	/**

	 * If self close, then this will be used to close the tag

	 * @var string

	 * @see $self_close

	 */

	var $self_close_str = ' /';

The visibility should be declared for property $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="selected" will be selected.

	 * @var bool

	 */

	var $attribute_shorttag = true;

The visibility should be declared for property $attribute_shorttag.

	/**

	 * Function map used for the selector filter

	 * @var array

	 * @internal array('root' => 'filter_root') will cause the

	 * selector to call $this->filter_root at :root

	 * @access private

	 */

	var $filter_map = array(

The visibility should be declared for property $filter_map.

		'root' => 'filter_root',

		'nth-child' => 'filter_nchild',

		'eq' => 'filter_nchild', //jquery (naming) compatibility

		'gt' => 'filter_gt',

		'lt' => 'filter_lt',

		'nth-last-child' => 'filter_nlastchild',

		'nth-of-type' => 'filter_ntype',

		'nth-last-of-type' => 'filter_nlastype',

		'odd' => 'filter_odd',

		'even' => 'filter_even',

		'every' => 'filter_every',

		'first-child' => 'filter_first',

		'last-child' => 'filter_last',

		'first-of-type' => 'filter_firsttype',

		'last-of-type' => 'filter_lasttype',

		'only-child' => 'filter_onlychild',

		'only-of-type' => 'filter_onlytype',

		'empty' => 'filter_empty',

		'not-empty' => 'filter_notempty',

		'has-text' => 'filter_hastext',

		'no-text' => 'filter_notext',

		'lang' => 'filter_lang',

		'contains' => 'filter_contains',

		'has' => 'filter_has',

		'not' => 'filter_not',

		'element' => 'filter_element',

		'text' => 'filter_text',

		'comment' => 'filter_comment',

        'checked' => 'filter_checked',

        'selected' => 'filter_selected',

	);


	/**

	 * Class constructor

	 * @param string|array $tag Name of the tag, or array with taginfo (array(

	 *	'tag_name' => 'tag',

	 *	'self_close' => false,

	 *	'attributes' => array('attribute' => 'value')))

	 * @param DomNode $parent Parent of node, null if none

	 */

	function __construct($tag, $parent) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;


		if (is_string($tag)) {

			$this->tag = $tag;

		} else {

			$this->tag = $tag['tag_name'];

			$this->self_close = $tag['self_close'];

			$this->attributes = $tag['attributes'];

		}

	}


	#php4 PHP4 class constructor compatibility

	#function DomNode($tag, $parent) {return $this->__construct($tag, $parent);}

71% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	/**

	 * Class destructor

	 * @access private

	 */

	function __destruct() {

It is generally recommended to explicitly declare the visibility for methods.

		$this->delete();

	}


	/**

	 * Class toString, outputs {@link $tag}

	 * @return string

	 * @access private

	 */

	function __toString() {

It is generally recommended to explicitly declare the visibility for methods.

		return (($this->tag === '~root~') ? $this->toString(true, true, 1) : $this->tag);

	}


	/**

	 * Class magic get method, outputs {@link getAttribute()}

	 * @return string

	 * @access private

	 */

	function __get($attribute) {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->getAttribute($attribute);

	}


	/**

	 * Class magic set method, performs {@link setAttribute()}

	 * @access private

	 */

	function __set($attribute, $value) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->setAttribute($attribute, $value);

	}


	/**

	 * Class magic isset method, returns {@link hasAttribute()}

	 * @return bool

	 * @access private

	 */

	function __isset($attribute) {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->hasAttribute($attribute);

	}


	/**

	 * Class magic unset method, performs {@link deleteAttribute()}

	 * @access private

	 */

	function __unset($attribute) {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->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 = '*') {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->query($query);

	}


	/**

	 * Returns place in document

	 * @return string

	 */

	 function dumpLocation() {

It is generally recommended to explicitly declare the visibility for methods.

		return (($this->parent) ? (($p = $this->parent->dumpLocation()) ? $p.' > ' : '').$this->tag.'('.$this->typeIndex().')' : '');

	 }


	/**

	 * Returns all the attributes and their values

	 * @return string

	 * @access private

	 */

	protected function toString_attributes() {

		$s = '';

		foreach($this->attributes as $a => $v) {

			$s .= ' '.$a;

			if ((!$this->attribute_shorttag) || ($v !== $a)) {

				$quote = (strpos($v, '"') === false) ? '"' : "'";

				$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->children as $c) {

			$s .= $c->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($content_only) {

			if (is_int($content_only)) {

				--$content_only;

			}

			return $this->toString_content($attributes, $recursive, $content_only);

It seems like $content_only can also be of type integer; however, pQuery\DomNode::toString_content() does only seem to accept boolean, maybe add an additional type check?

		}


		$s = '<'.$this->tag;

		if ($attributes) {

			$s .= $this->toString_attributes();

		}

		if ($this->self_close) {

			$s .= $this->self_close_str.'>';

		} else {

			$s .= '>';

			if($recursive) {

				$s .= $this->toString_content($attributes);

			}

			$s .= '</'.$this->tag.'>';

		}

		return $s;

	}


	/**

	 * Similar to JavaScript outerText, will return full (html formatted) node

	 * @return string

	 */

	function getOuterText() {

It is generally recommended to explicitly declare the visibility for methods.

		return html_entity_decode($this->toString(), ENT_QUOTES);

	}


	/**

	 * 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) {

It is generally recommended to explicitly declare the visibility for methods.

		if (trim($text)) {

			$index = $this->index();

			if ($parser === null) {

				$parser = new $this->parserClass();

			}

			$parser->setDoc($text);

			$parser->parse_all();

			$parser->root->moveChildren($this->parent, $index);

		}

		$this->delete();

		return (($parser && $parser->errors) ? $parser->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) {

It is generally recommended to explicitly declare the visibility for methods.

      if ($value !== null) {

         $this->setInnerText($value);

      }

		return $this->getInnerText();

	}


	/**

	 * Similar to JavaScript innerText, will return (html formatted) content

	 * @return string

	 */

	function getInnerText() {

It is generally recommended to explicitly declare the visibility for methods.

		return html_entity_decode($this->toString(true, true, 1), ENT_QUOTES);

	}


	/**

	 * 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) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->clear();

		if (trim($text)) {

			if ($parser === null) {

				$parser = new $this->parserClass();

			}

			$parser->root =& $this;

			$parser->setDoc($text);

			$parser->parse_all();

		}

		return (($parser && $parser->errors) ? $parser->errors : true);

	}


	/**

	 * Similar to JavaScript plainText, will return text in node (and subnodes)

	 * @return string

	 */

	function getPlainText() {

It is generally recommended to explicitly declare the visibility for methods.

		return preg_replace('`\s+`', ' ', html_entity_decode($this->toString(true, true, true), ENT_QUOTES));

	}


	/**

	 * Return plaintext taking document encoding into account

	 * @return string

	 */

	function getPlainTextUTF8() {

It is generally recommended to explicitly declare the visibility for methods.

		$txt = $this->toString(true, true, true);

		$enc = $this->getEncoding();

		if ($enc !== false) {

			$txt = mb_convert_encoding($txt, 'UTF-8', $enc);

		}

		return preg_replace('`\s+`', ' ', html_entity_decode($txt, ENT_QUOTES, 'UTF-8'));

	}


	/**

	 * Similar to JavaScript plainText, will replace child nodes with new text (literal)

	 * @param string $text

	 */

	function setPlainText($text) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->clear();

		if (trim($text)) {

			$this->addText(htmlentities($text, ENT_QUOTES));

		}

	}


	/**

	 * Delete node from parent and clear node

	 */

	function delete() {

It is generally recommended to explicitly declare the visibility for methods.

		if (($p = $this->parent) !== null) {

			$this->parent = null;

			$p->deleteChild($this);

		} else {

			$this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if (($p = $this->parent) !== null) {

			$index = $this->index();

			$this->parent = null;


			if ($move_children_up) {

				$this->moveChildren($p, $index);

			}

			$p->deleteChild($this, true);

		}

	}


	/**

	 * Deletes all child nodes from node

	 */

	function clear() {

It is generally recommended to explicitly declare the visibility for methods.

		foreach($this->children as $c) {

			$c->parent = null;

			$c->delete();

		}

		$this->children = array();

	}


	/**

	 * Get top parent

	 * @return DomNode Root, null if node has no parent

	 */

	function getRoot() {

It is generally recommended to explicitly declare the visibility for methods.

		$r = $this->parent;

		$n = ($r === null) ? null : $r->parent;

		while ($n !== null) {

			$r = $n;

			$n = $r->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, &$index) {

67% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function changeParent($to, &$index = null) {

It is generally recommended to explicitly declare the visibility for methods.

	#php5e

		if ($this->parent !== null) {

			$this->parent->deleteChild($this, true);

		}

		$this->parent = $to;

		if ($index !== false) {

			$new_index = $this->index();

			if (!(is_int($new_index) && ($new_index >= 0))) {

				$this->parent->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->parent !== null) {

			if ($tag === null) {

				return true;

			} elseif (is_string($tag)) {

				return (($this->parent->tag === $tag) || ($recursive && $this->parent->hasParent($tag)));

			} elseif (is_object($tag)) {

				return (($this->parent === $tag) || ($recursive && $this->parent->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) {

It is generally recommended to explicitly declare the visibility for methods.

		return ($this->hasParent($tag, $recursive) === ($tag !== null));

	}


	/**

	 * Find out if node is text

	 * @return bool

	 */

	function isText() {

It is generally recommended to explicitly declare the visibility for methods.

		return false;

	}


	/**

	 * Find out if node is comment

	 * @return bool

	 */

	function isComment() {

It is generally recommended to explicitly declare the visibility for methods.

		return false;

	}


	/**

	 * Find out if node is text or comment node

	 * @return bool

	 */

	function isTextOrComment() {

It is generally recommended to explicitly declare the visibility for methods.

		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, &$new_index) {

67% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function move($to, &$new_index = -1) {

It is generally recommended to explicitly declare the visibility for methods.

	#php5e

		$this->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, &$new_index, $start = 0, $end = -1) {

52% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function moveChildren($to, &$new_index = -1, $start = 0, $end = -1) {

It is generally recommended to explicitly declare the visibility for methods.

	#php5e

		if ($end < 0) {

			$end += count($this->children);

		}

		for ($i = $start; $i <= $end; $i++) {

			$this->children[$start]->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if (!$this->parent) {

			return -1;

		} elseif ($count_all) {

			return $this->parent->findChild($this);

		} else{

			$index = -1;

			//foreach($this->parent->children as &$c) {

67% of this comment could be valid code. Did you maybe forget this after debugging?

			//	if (!$c->isTextOrComment()) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

			//		++$index;

			//	}

			//	if ($c === $this) {

50% of this comment could be valid code. Did you maybe forget this after debugging?

			//		return $index;

			//	}

			//}


			foreach(array_keys($this->parent->children) as $k) {

				if (!$this->parent->children[$k]->isTextOrComment()) {

					++$index;

				}

				if ($this->parent->children[$k] === $this) {

					return $index;

				}

			}

			return -1;

		}

	}


	/**

	 * Change index of node in parent

	 * @param int $index New index

	 */

	function setIndex($index) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->parent) {

			if ($index > $this->index()) {

				--$index;

			}

			$this->delete();

			$this->parent->addChild($this, $index);

		}

	}


	/**

	 * Index of all similar nodes in parent

	 * @return int -1 if not found

	 */

	function typeIndex() {

It is generally recommended to explicitly declare the visibility for methods.

		if (!$this->parent) {

			return -1;

		} else {

			$index = -1;

			//foreach($this->parent->children as &$c) {

67% of this comment could be valid code. Did you maybe forget this after debugging?

			//	if (strcasecmp($this->tag, $c->tag) === 0) {

55% of this comment could be valid code. Did you maybe forget this after debugging?

			//		++$index;

			//	}

			//	if ($c === $this) {

50% of this comment could be valid code. Did you maybe forget this after debugging?

			//		return $index;

			//	}

			//}


			foreach(array_keys($this->parent->children) as $k) {

				if (strcasecmp($this->tag, $this->parent->children[$k]->tag) === 0) {

					++$index;

				}

				if ($this->parent->children[$k] === $this) {

					return $index;

				}

			}

			return -1;

		}

	}


	/**

	 * Calculate indent of node (number of parent tags - 1)

	 * @return int

	 */

	function indent() {

It is generally recommended to explicitly declare the visibility for methods.

		return (($this->parent) ? $this->parent->indent() + 1 : -1);

	}


	/**

	 * Get sibling node

	 * @param int $offset Offset from current node

	 * @return DomNode Null if not found

	 */

	function getSibling($offset = 1) {

It is generally recommended to explicitly declare the visibility for methods.

		$index = $this->index() + $offset;

		if (($index >= 0) && ($index < $this->parent->childCount())) {

			return $this->parent->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) {

It is generally recommended to explicitly declare the visibility for methods.

		$offset = 1;

		while (($n = $this->getSibling($offset)) !== null) {

			if ($skip_text_comments && ($n->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) {

It is generally recommended to explicitly declare the visibility for methods.

		$offset = -1;

		while (($n = $this->getSibling($offset)) !== null) {

			if ($skip_text_comments && ($n->tag[0] === '~')) {

				--$offset;

			} else {

				break;

			}

		}


		return $n;

	}


	/**

	 * Get namespace of node

	 * @return string

	 * @see setNamespace()

	 */

	function getNamespace() {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->tag_ns === null) {

			$a = explode(':', $this->tag, 2);

			if (empty($a[1])) {

				$this->tag_ns = array('', $a[0]);

			} else {

				$this->tag_ns = array($a[0], $a[1]);

			}

		}


		return $this->tag_ns[0];

	}


	/**

	 * Set namespace of node

	 * @param string $ns

	 * @see getNamespace()

	 */

	function setNamespace($ns) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->getNamespace() !== $ns) {

			$this->tag_ns[0] = $ns;

			$this->tag = $ns.':'.$this->tag_ns[1];

		}

	}


	/**

	 * Get tagname of node (without namespace)

	 * @return string

	 * @see setTag()

	 */

	function getTag() {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->tag_ns === null) {

			$this->getNamespace();

		}


		return $this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		$with_ns = $with_ns || (strpos($tag, ':') !== false);

		if ($with_ns) {

			$this->tag = $tag;

			$this->tag_ns = null;

It seems like null of type null is incompatible with the declared type array of property $tag_ns.

		} elseif ($this->getTag() !== $tag) {

			$this->tag_ns[1] = $tag;

			$this->tag = (($this->tag_ns[0]) ? $this->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() {

It is generally recommended to explicitly declare the visibility for methods.

		$root = $this->getRoot();

		if ($root !== null) {

			if ($enc = $root->select('meta[charset]', 0, true, true)) {

				return $enc->getAttribute("charset");

			} elseif ($enc = $root->select('"?xml"[encoding]', 0, true, true)) {

				return $enc->getAttribute("encoding");

The method getAttribute cannot be called on $enc (of type array<integer,object<pQuery\DomNode>>).

			} elseif ($enc = $root->select('meta[content*="charset="]', 0, true, true)) {

				$enc = $enc->getAttribute("content");

The method getAttribute cannot be called on $enc (of type array<integer,object<pQuery\DomNode>>).

				return substr($enc, strpos($enc, "charset=")+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) {

It is generally recommended to explicitly declare the visibility for methods.

		if (!$ignore_text_comments) {

			return count($this->children);

		} else{

			$count = 0;

			//foreach($this->children as &$c) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

			//	if (!$c->isTextOrComment()) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

			//		++$count;

			//	}

			//}


			foreach(array_keys($this->children) as $k) {

				if (!$this->children[$k]->isTextOrComment()) {

					++$count;

				}

			}

			return $count;

		}

	}


	/**

	 * Find node in children

	 * @param DomNode $child

	 * @return int False if not found

	 */

	function findChild($child) {

It is generally recommended to explicitly declare the visibility for methods.

		return array_search($child, $this->children, true);

	}


	/**

	 * Checks if node has another node as child

	 * @param DomNode $child

	 * @return bool

	 */

	function hasChild($child) {

It is generally recommended to explicitly declare the visibility for methods.

		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 &getChild($child, $ignore_text_comments = false) {

		if (!is_int($child)) {

			$child = $this->findChild($child);

		} elseif ($child < 0) {

			$child += $this->childCount($ignore_text_comments);

		}


		if ($ignore_text_comments) {

			$count = 0;

			$last = null;

			//foreach($this->children as &$c) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

			//	if (!$c->isTextOrComment()) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

			//		if ($count++ === $child) {

54% of this comment could be valid code. Did you maybe forget this after debugging?

			//			return $c;

			//		}

			//		$last = $c;

43% of this comment could be valid code. Did you maybe forget this after debugging?

			//	}

			//}


			foreach(array_keys($this->children) as $k) {

				if (!$this->children[$k]->isTextOrComment()) {

					if ($count++ === $child) {

						return $this->children[$k];

					}

					$last = $this->children[$k];

				}

			}

			return (($child > $count) ? $last : null);

		} else {

			return $this->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 &addChild($tag, &$offset) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addChild($tag, &$offset = null) {

	#php5e

        if (is_array($tag)) {

            $tag = new $this->childClass($tag, $this);

        } elseif (is_string($tag)) {

            $nodes = $this->createNodes($tag);

            $tag = array_shift($nodes);


            if ($tag && $tag->parent !== $this) {

                $index = false;

                $tag->changeParent($this, $index);

            }

		} elseif (is_object($tag) && $tag->parent !== $this) {

			$index = false; //Needs to be passed by ref

			$tag->changeParent($this, $index);

		}


		if (is_int($offset) && ($offset < count($this->children)) && ($offset !== -1)) {

			if ($offset < 0) {

				$offset += count($this->children);

			}

			array_splice($this->children, $offset++, 0, array(&$tag));

		} else {

			$this->children[] =& $tag;

		}


		return $tag;

	}


	/**

	 * First child node

	 * @param bool $ignore_text_comments Ignore text/comments with index calculation

	 * @return DomNode

	 */

	function &firstChild($ignore_text_comments = false) {

		return $this->getChild(0, $ignore_text_comments);

	}


	/**

	 * Last child node

	 * @param bool $ignore_text_comments Ignore text/comments with index calculation

	 * @return DomNode

	 */

	function &lastChild($ignore_text_comments = false) {

		return $this->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

There is no parameter named $offset. Was it maybe removed?

	 * @return DomNode Added node

	 * @see addChild();

	 */

	function &insertChild($tag, $index) {

		return $this->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 &addText($text, &$offset) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addText($text, &$offset = null) {

	#php5e

		return $this->addChild(new $this->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 &addComment($text, &$offset) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addComment($text, &$offset = null) {

	#php5e

		return $this->addChild(new $this->childClass_Comment($this, $text), $offset);

	}


	/**

	 * Add conditional node

	 * @param string $condition

	 * @param bool True for <!--[if, false for <![if

	 * @param int $offset Position to insert node, negative to count from end, null to append

	 * @return DomNode Added node

	 * @see addChild();

	 */

	#php4

	#function &addConditional($condition, $hidden = true, &$offset) {

60% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addConditional($condition, $hidden = true, &$offset = null) {

	#php5e

		return $this->addChild(new $this->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 &addCDATA($text, &$offset) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addCDATA($text, &$offset = null) {

	#php5e

		return $this->addChild(new $this->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 &addDoctype($dtd, &$offset) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addDoctype($dtd, &$offset = null) {

	#php5e

		return $this->addChild(new $this->childClass_Doctype($this, $dtd), $offset);

	}


	/**

	 * Add xml node

	 * @param string $tag Tag name after "?", e.g. "php" or "xml"

	 * @param string $text

	 * @param array $attributes Array of attributes (array('attribute' => 'value'))

	 * @param int $offset Position to insert node, negative to count from end, null to append

	 * @return DomNode Added node

	 * @see addChild();

	 */

	#php4

	#function &addXML($tag = 'xml', $text = '', $attributes = array(), &$offset) {

55% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addXML($tag = 'xml', $text = '', $attributes = array(), &$offset = null) {

	#php5e

		return $this->addChild(new $this->childClass_XML($this, $tag, $text, $attributes), $offset);

	}


	/**

	 * Add ASP node

	 * @param string $tag Tag name after "%"

	 * @param string $text

	 * @param array $attributes Array of attributes (array('attribute' => 'value'))

	 * @param int $offset Position to insert node, negative to count from end, null to append

	 * @return DomNode Added node

	 * @see addChild();

	 */

	#php4

	#function &addASP($tag = '', $text = '', $attributes = array(), &$offset) {

55% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	function &addASP($tag = '', $text = '', $attributes = array(), &$offset = null) {

	#php5e

		return $this->addChild(new $this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if (is_object($child)) {

			$child = $this->findChild($child);

		} elseif ($child < 0) {

			$child += count($this->children);

		}


		if (!$soft_delete) {

			$this->children[$child]->delete();

		}

		unset($this->children[$child]);


		//Rebuild indices

		$tmp = array();


		//foreach($this->children as &$c) {

70% of this comment could be valid code. Did you maybe forget this after debugging?

		//	$tmp[] =& $c;

60% of this comment could be valid code. Did you maybe forget this after debugging?

		//}

		foreach(array_keys($this->children) as $k) {

			$tmp[] =& $this->children[$k];

		}

		$this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($node_index === null) {

			$node_index = $this->index();

		}


		if (!is_object($node)) {

			$node = $this->parent->addChild($node, $node_index);

		} elseif ($node->parent !== $this->parent) {

			$node->changeParent($this->parent, $node_index);

		}


		$this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($end < 0) {

			$end += count($this->children);

		}

		if ($node_index === null) {

			$node_index = $end + 1;

		}


		if (!is_object($node)) {

			$node = $this->addChild($node, $node_index);

		} elseif ($node->parent !== $this) {

			$node->changeParent($this->parent, $node_index);

		}


		$this->moveChildren($node, $wrap_index, $start, $end);

		return $node;

	}


	/**

	 * Number of attributes

	 * @return int

	 */

	function attributeCount() {

It is generally recommended to explicitly declare the visibility for methods.

		return count($this->attributes);

	}


	/**

	 * Find attribute using namespace, name or both

	 * @param string|int $attr Negative int to count from end

	 * @param string $compare "namespace", "name" or "total"

	 * @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 < 0) {

				$attr += count($this->attributes);

			}

			$keys = array_keys($this->attributes);

			return $this->findAttribute($keys[$attr], 'total', true);

		} else if ($compare === 'total') {

			$b = explode(':', $attr, 2);

			if ($case_sensitive) {

				$t =& $this->attributes;

			} else {

				$t = array_change_key_case($this->attributes);

				$attr = strtolower($attr);

			}


			if (isset($t[$attr])) {

				$index = 0;

				foreach($this->attributes as $a => $v) {

					if (($v === $t[$attr]) && (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;

The return type of return false; (false) is incompatible with the return type documented by pQuery\DomNode::findAttribute of type array.

			}

		} else {

			if ($this->attributes_ns === null) {

				$index = 0;

				foreach($this->attributes as $a => $v) {

					$b = explode(':', $a, 2);

					if (empty($b[1])) {

						$this->attributes_ns[$b[0]][] = array('', $b[0], $a, $index);

					} else {

						$this->attributes_ns[$b[1]][] = array($b[0], $b[1], $a, $index);

					}

					++$index;

				}

			}


			if ($case_sensitive) {

				$t =& $this->attributes_ns;

			} else {

				$t = array_change_key_case($this->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 "namespace", "name" or "total"

	 * @param bool $case_sensitive Compare with case sensitivity

	 * @return bool

	 */

	function hasAttribute($attr, $compare = 'total', $case_sensitive = false) {

It is generally recommended to explicitly declare the visibility for methods.

		return ((bool) $this->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 "namespace", "name" or "total"

	 * @param bool $case_sensitive Compare with case sensitivity

	 * @return string|array False if not found

	 */

	function getAttributeNS($attr, $compare = 'name', $case_sensitive = false) {

It is generally recommended to explicitly declare the visibility for methods.

		$f = $this->findAttribute($attr, $compare, $case_sensitive);

		if (is_array($f) && $f) {

The expression $f of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			if (count($f) === 1) {

				return $this->attributes[$f[0][0]];

			} else {

				$res = array();

				foreach($f as $a) {

					$res[] = $a[0];

				}

				return $res;

			}

		} else {

			return false;

The return type of return false; (false) is incompatible with the return type documented by pQuery\DomNode::getAttributeNS of type string|array.

		}

	}


	/**

	 * Sets namespace of attribute(s)

	 * @param string|int $attr Negative int to count from end

	 * @param string $namespace

	 * @param string $compare Find node using "namespace", "name" or "total"

	 * @param bool $case_sensitive Compare with case sensitivity

	 * @return bool

	 */

	function setAttributeNS($attr, $namespace, $compare = 'name', $case_sensitive = false) {

It is generally recommended to explicitly declare the visibility for methods.

		$f = $this->findAttribute($attr, $compare, $case_sensitive);

		if (is_array($f) && $f) {

The expression $f of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			if ($namespace) {

				$namespace .= ':';

			}

			foreach($f as $a) {

				$val = $this->attributes[$a[2]];

				unset($this->attributes[$a[2]]);

				$this->attributes[$namespace.$a[1]] = $val;

			}

			$this->attributes_ns = null;

It seems like null of type null is incompatible with the declared type array of property $attributes_ns.

			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 "namespace", "name" or "total"

	 * @param bool $case_sensitive Compare with case sensitivity

	 * @return string|array

	 */

	function getAttribute($attr, $compare = 'total', $case_sensitive = false) {

It is generally recommended to explicitly declare the visibility for methods.

		$f = $this->findAttribute($attr, $compare, $case_sensitive);

		if (is_array($f) && $f){

The expression $f of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			if (count($f) === 1) {

				return $this->attributes[$f[0][2]];

			} else {

				$res = array();

				foreach($f as $a) {

					$res[] = $this->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 "namespace", "name" or "total"

	 * @param bool $case_sensitive Compare with case sensitivity

	 */

	function setAttribute($attr, $val, $compare = 'total', $case_sensitive = false) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($val === null) {

			return $this->deleteAttribute($attr, $compare, $case_sensitive);

		}


		$f = $this->findAttribute($attr, $compare, $case_sensitive);

		if (is_array($f) && $f) {

The expression $f of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			foreach($f as $a) {

				$this->attributes[$a[2]] = (string) $val;

			}

		} else {

			$this->attributes[$attr] = (string) $val;

		}

	}


	/**

	 * Add new attribute

	 * @param string $attr

	 * @param string $val

	 */

	function addAttribute($attr, $val) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->setAttribute($attr, $val, 'total', true);

	}


	/**

	 * Delete attribute(s)

	 * @param string|int $attr Negative int to count from end

	 * @param string $compare Find node using "namespace", "name" or "total"

	 * @param bool $case_sensitive Compare with case sensitivity

	 */

	function deleteAttribute($attr, $compare = 'total', $case_sensitive = false) {

It is generally recommended to explicitly declare the visibility for methods.

		$f = $this->findAttribute($attr, $compare, $case_sensitive);

		if (is_array($f) && $f) {

The expression $f of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			foreach($f as $a) {

				unset($this->attributes[$a[2]]);

				if ($this->attributes_ns !== null) {

					unset($this->attributes_ns[$a[1]]);

				}

			}

		}

	}


	/**

	 * Determine if node has a certain class

	 * @param string $className

	 * @return bool

	 */

	function hasClass($className) {

It is generally recommended to explicitly declare the visibility for methods.

		return ($className && preg_match('`\b'.preg_quote($className).'\b`si', $this->class));

The property class does not exist on object<pQuery\DomNode>. Since you implemented __get, maybe consider adding a @property annotation.

	}


	/**

	 * Add new class(es)

	 * @param string|array $className

	 */

	function addClass($className) {

It is generally recommended to explicitly declare the visibility for methods.

		if (!is_array($className)) {

			$className = array($className);

		}

		$class = $this->class;

The property class does not exist on object<pQuery\DomNode>. Since you implemented __set, maybe consider adding a @property annotation.

		foreach ($className as $c) {

			if (!(preg_match('`\b'.preg_quote($c).'\b`si', $class) > 0)) {

				$class .= ' '.$c;

			}

		}

		 $this->class = trim($class);

The property class does not exist on object<pQuery\DomNode>. Since you implemented __set, maybe consider adding a @property annotation.

	}


	/**

	 * Remove clas(ses)

	 * @param string|array $className

	 */

	function removeClass($className) {

It is generally recommended to explicitly declare the visibility for methods.

		if (!is_array($className)) {

			$className = array($className);

		}

		$class = $this->class;

The property class does not exist on object<pQuery\DomNode>. Since you implemented __set, maybe consider adding a @property annotation.

		foreach ($className as $c) {

			$class = preg_replace('`\b'.preg_quote($c).'\b`si', '', $class);

		}

		if ($class) {

			$this->class = $class;

The property class does not exist on object<pQuery\DomNode>. Since you implemented __set, maybe consider adding a @property annotation.

		} else {

			unset($this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		$count = $this->childCount();

		if ($check_self && $callback($this)) {

			$res = array($this);

		} else {

			$res = array();

		}


		if ($count > 0) {

			if (is_int($recursive)) {

				$recursive = (($recursive > 1) ? $recursive - 1 : false);

			}


			for ($i = 0; $i < $count; $i++) {

				if ($callback($this->children[$i])) {

					$res[] = $this->children[$i];

				}

				if ($recursive) {

					$res = array_merge($res, $this->children[$i]->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()) {

It is generally recommended to explicitly declare the visibility for methods.

		$count = $this->childCount();

		if ($check_self && $this->match($conditions, true, $custom_filters)) {

			$res = array($this);

		} else {

			$res = array();

		}


		if ($count > 0) {

			if (is_int($recursive)) {

				$recursive = (($recursive > 1) ? $recursive - 1 : false);

			}


			for ($i = 0; $i < $count; $i++) {

				if ($this->children[$i]->match($conditions, true, $custom_filters)) {

					$res[] = $this->children[$i];

				}

				if ($recursive) {

					$res = array_merge($res, $this->children[$i]->getChildrenByMatch($conditions, $recursive, false, $custom_filters));

				}

			}

		}


		return $res;

	}


	/**

	 * Checks if tag matches certain conditions

	 * @param array $tags array('tag1', 'tag2') or array(array(

	 *	'tag' => 'tag1',

	 *	'operator' => 'or'/'and',

	 *	'compare' => 'total'/'namespace'/'name',

	 * 	'case_sensitive' => true))

	 * @return bool

	 * @internal Used by selector class

	 * @see match()

	 * @access private

	 */

	protected function match_tags($tags) {

		$res = false;


		foreach($tags as $tag => $match) {

			if (!is_array($match)) {

				$match = array(

					'match' => $match,

					'operator' => 'or',

					'compare' => 'total',

					'case_sensitive' => 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') && (!$res)) {

				return false;

			} elseif (!($res && ($match['operator'] === 'or'))) {

				if ($match['compare'] === 'total') {

					$a = $this->tag;

				} elseif ($match['compare'] === 'namespace') {

					$a = $this->getNamespace();

				} elseif ($match['compare'] === 'name') {

					$a = $this->getTag();

				}


				if ($match['case_sensitive']) {

					$res = (($a === $tag) === $match['match']);

The variable $a does not seem to be defined for all execution paths leading up to this point.

				} else {

					$res = ((strcasecmp($a, $tag) === 0) === $match['match']);

				}

			}

		}


		return $res;

	}


	/**

	 * Checks if attributes match certain conditions

	 * @param array $attributes array('attr' => 'val') or array(array(

	 *	'operator_value' => 'equals'/'='/'contains_regex'/etc

	 *	'attribute' => 'attr',

	 *	'value' => 'val',

	 *	'match' => true,

	 *	'operator_result' => 'or'/'and',

	 *	'compare' => 'total'/'namespace'/'name',

	 *	'case_sensitive' => true))

	 * @return bool

	 * @internal Used by selector class

	 * @see match()

	 * @access private

	 */

	protected function match_attributes($attributes) {

		$res = false;


		foreach($attributes as $attribute => $match) {

			if (!is_array($match)) {

				$match = array(

					'operator_value' => 'equals',

					'value' => $match,

					'match' => true,

					'operator_result' => 'or',

					'compare' => 'total',

					'case_sensitive' => 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']) && (!$match['case_sensitive'])) {

				$match['value'] = strtolower($match['value']);

			}


			if (($match['operator_result'] === 'and') && (!$res)) {

				return false;

			} elseif (!($res && ($match['operator_result'] === 'or'))) {

				$possibles = $this->findAttribute($attribute, $match['compare'], $match['case_sensitive']);


				$has = (is_array($possibles) && $possibles);

The expression $possibles of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

				$res = (($match['value'] === $has) || (($match['match'] === false) && ($has === $match['match'])));


				if ((!$res) && $has && is_string($match['value'])) {

					foreach($possibles as $a) {

						$val = $this->attributes[$a[2]];

						if (is_string($val) && (!$match['case_sensitive'])) {

							$val = strtolower($val);

						}


						switch($match['operator_value']) {

							case '%=':

							case 'contains_regex':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = ((preg_match('`'.$match['value'].'`s', $val) > 0) === $match['match']);

								if ($res) break 1; else break 2;


							case '|=':

							case 'contains_prefix':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = ((preg_match('`\b'.preg_quote($match['value']).'[\-\s]`s', $val) > 0) === $match['match']);

								if ($res) break 1; else break 2;


							case '~=':

							case 'contains_word':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = ((preg_match('`\s'.preg_quote($match['value']).'\s`s', " $val ") > 0) === $match['match']);

								if ($res) break 1; else break 2;


							case '*=':

							case 'contains':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = ((strpos($val, $match['value']) !== false) === $match['match']);

								if ($res) break 1; else break 2;


							case '$=':

							case 'ends_with':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = ((substr($val, -strlen($match['value'])) === $match['value']) === $match['match']);

								if ($res) break 1; else break 2;


							case '^=':

							case 'starts_with':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = ((substr($val, 0, strlen($match['value'])) === $match['value']) === $match['match']);

								if ($res) break 1; else break 2;


							case '!=':

							case 'not_equal':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = (($val !== $match['value']) === $match['match']);

								if ($res) break 1; else break 2;


							case '=':

							case 'equals':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = (($val === $match['value']) === $match['match']);

								if ($res) break 1; else break 2;


							case '>=':

							case 'bigger_than':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = (($val >= $match['value']) === $match['match']);

								if ($res) break 1; else break 2;


							case '<=':

							case 'smaller_than':

There must be a comment when fall-through is intentional in a non-empty case body

								$res = (($val >= $match['value']) === $match['match']);

								if ($res) break 1; else break 2;


							default:

								trigger_error('Unknown operator "'.$match['operator_value'].'" to match attributes!');

								return false;

						}

					}

				}

			}

		}


		return $res;

	}


	/**

	 * Checks if node matches certain filters

	 * @param array $tags array(array(

There is no parameter named $tags. Was it maybe removed?

	 *	'filter' => 'last-child',

	 *	'params' => '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->filter_map[$c['filter']])) {

				if (!$this->{$this->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 "'.$c['filter'].'"!');

				return false;

			}

		}


		return true;

	}


	/**

	 * Checks if node matches certain conditions

	 * @param array $tags array('tags' => array(tag_conditions), 'attributes' => array(attr_conditions), 'filters' => array(filter_conditions))

There is no parameter named $tags. Was it maybe removed?

	 * @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()) {

It is generally recommended to explicitly declare the visibility for methods.

		$t = isset($conditions['tags']);

		$a = isset($conditions['attributes']);

		$f = isset($conditions['filters']);


		if (!($t || $a || $f)) {

			if (is_array($conditions) && $conditions) {

The expression $conditions of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

				foreach($conditions as $c) {

					if ($this->match($c, $match)) {

						return true;

					}

				}

			}


			return false;

		} else {

			if (($t && (!$this->match_tags($conditions['tags']))) === $match) {

				return false;

			}


			if (($a && (!$this->match_attributes($conditions['attributes']))) === $match) {

				return false;

			}


			if (($f && (!$this->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, "equals", "|=", "contains_regex", etc.

	 * @param string $compare "total"/"namespace"/"name"

	 * @param bool|int $recursive

	 * @return array

	 */

	function getChildrenByAttribute($attribute, $value, $mode = 'equals', $compare = 'total', $recursive = true) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->childCount() < 1) {

			return array();

		}


		$mode = explode(' ', strtolower($mode));

		$match = ((isset($mode[1]) && ($mode[1] === 'not')) ? 'false' : 'true');


		return $this->getChildrenByMatch(

			array(

				'attributes' => array(

					$attribute => array(

						'operator_value' => $mode[0],

						'value' => $value,

						'match' => $match,

						'compare' => $compare

					)

				)

			),

			$recursive

		);

	}


	/**

	 * Finds children that match a certain tag

	 * @param string $tag

	 * @param string $compare "total"/"namespace"/"name"

	 * @param bool|int $recursive

	 * @return array

	 */

	function getChildrenByTag($tag, $compare = 'total', $recursive = true) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($this->childCount() < 1) {

			return array();

		}


		$tag = explode(' ', strtolower($tag));

		$match = ((isset($tag[1]) && ($tag[1] === 'not')) ? 'false' : 'true');


		return $this->getChildrenByMatch(

			array(

				'tags' => array(

					$tag[0] => array(

						'match' => $match,

						'compare' => $compare

					)

				)

			),

			$recursive

		);

	}


	/**

	 * Finds all children using ID attribute

	 * @param string $id

	 * @param bool|int $recursive

	 * @return array

	 */

	function getChildrenByID($id, $recursive = true) {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->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) {

It is generally recommended to explicitly declare the visibility for methods.

		return $this->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->select($query);

        $result = new \pQuery((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) {

It is generally recommended to explicitly declare the visibility for methods.

		$s = new $this->selectClass($this, $query, $check_self, $recursive);

		$res = $s->result;

		unset($s);

		if (is_array($res) && ($index === true) && (count($res) === 1)) {

			return $res[0];

		} elseif (is_int($index) && is_array($res)) {

			if ($index < 0) {

				$index += count($res);

			}

			return ($index < count($res)) ? $res[$index] : null;

        } else {

			return $res;

		}

	}


	/**

	 * Checks if node matches css query filter ":root"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_root() {

		return (strtolower($this->tag) === 'html');

	}


	/**

	 * Checks if node matches css query filter ":nth-child(n)"

	 * @param string $n 1-based index

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_nchild($n) {

		return ($this->index(false)+1 === (int) $n);

	}


	/**

	 * Checks if node matches css query filter ":gt(n)"

	 * @param string $n 0-based index

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_gt($n) {

		return ($this->index(false) > (int) $n);

	}


	/**

	 * Checks if node matches css query filter ":lt(n)"

	 * @param string $n 0-based index

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_lt($n) {

		return ($this->index(false) < (int) $n);

	}


	/**

	 * Checks if node matches css query filter ":nth-last-child(n)"

	 * @param string $n 1-based index

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_nlastchild($n) {

		if ($this->parent === null) {

			return false;

		} else {

			return ($this->parent->childCount(true) - $this->index(false) === (int) $n);

		}

	}


	/**

	 * Checks if node matches css query filter ":nth-of-type(n)"

	 * @param string $n 1-based index

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_ntype($n) {

		return ($this->typeIndex()+1 === (int) $n);

	}


	/**

	 * Checks if node matches css query filter ":nth-last-of-type(n)"

	 * @param string $n 1-based index

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_nlastype($n) {

		if ($this->parent === null) {

			return false;

		} else {

			return (count($this->parent->getChildrenByTag($this->tag, 'total', false)) - $this->typeIndex() === (int) $n);

		}

	}


	/**

	 * Checks if node matches css query filter ":odd"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_odd() {

		return (($this->index(false) & 1) === 1);

	}


	/**

	 * Checks if node matches css query filter ":even"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_even() {

		return (($this->index(false) & 1) === 0);

	}


	/**

	 * Checks if node matches css query filter ":every(n)"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_every($n) {

		return (($this->index(false) % (int) $n) === 0);

	}


	/**

	 * Checks if node matches css query filter ":first"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_first() {

		return ($this->index(false) === 0);

	}


	/**

	 * Checks if node matches css query filter ":last"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_last() {

		if ($this->parent === null) {

			return false;

		} else {

			return ($this->parent->childCount(true) - 1 === $this->index(false));

		}

	}


	/**

	 * Checks if node matches css query filter ":first-of-type"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_firsttype() {

		return ($this->typeIndex() === 0);

	}


	/**

	 * Checks if node matches css query filter ":last-of-type"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_lasttype() {

		if ($this->parent === null) {

			return false;

		} else {

			return (count($this->parent->getChildrenByTag($this->tag, 'total', false)) - 1 === $this->typeIndex());

		}

	}


	/**

	 * Checks if node matches css query filter ":only-child"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_onlychild() {

		if ($this->parent === null) {

			return false;

		} else {

			return ($this->parent->childCount(true) === 1);

		}

	}


	/**

	 * Checks if node matches css query filter ":only-of-type"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_onlytype() {

		if ($this->parent === null) {

			return false;

		} else {

			return (count($this->parent->getChildrenByTag($this->tag, 'total', false)) === 1);

		}

	}


	/**

	 * Checks if node matches css query filter ":empty"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_empty() {

		return ($this->childCount() === 0);

	}


	/**

	 * Checks if node matches css query filter ":not-empty"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_notempty() {

		return ($this->childCount() !== 0);

	}


	/**

	 * Checks if node matches css query filter ":has-text"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_hastext() {

		return ($this->getPlainText() !== '');

	}


	/**

	 * Checks if node matches css query filter ":no-text"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_notext() {

		return ($this->getPlainText() === '');

	}


	/**

	 * Checks if node matches css query filter ":lang(s)"

	 * @param string $lang

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_lang($lang) {

		return ($this->lang === $lang);

The property lang does not exist on object<pQuery\DomNode>. Since you implemented __get, maybe consider adding a @property annotation.

	}


	/**

	 * Checks if node matches css query filter ":contains(s)"

	 * @param string $text

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_contains($text) {

		return (strpos($this->getPlainTextUTF8(), $text) !== false);

	}


	/**

	 * Checks if node matches css query filter ":has(s)"

	 * @param string $selector

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_has($selector) {

		$s = $this->select((string) $selector, false);

		return (is_array($s) && (count($s) > 0));

	}


	/**

	 * Checks if node matches css query filter ":not(s)"

	 * @param string $selector

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_not($selector) {

		$s = $this->select((string) $selector, false, true, true);

		return ((!is_array($s)) || (array_search($this, $s, true) === false));

	}


	/**

	 * Checks if node matches css query filter ":element"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_element() {

		return true;

	}


	/**

	 * Checks if node matches css query filter ":text"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_text() {

		return false;

	}


    /**

     * Checks if a node matches css query filter ":checked"

     * @return bool

     * @see match()

     */

    protected function filter_checked() {

        $attr = $this->getAttribute('checked');

        if (is_array($attr))

            $attr = reset($attr);

        return strcasecmp($attr, 'checked') === 0;

    }


	/**

	 * Checks if node matches css query filter ":comment"

	 * @return bool

	 * @see match()

	 * @access private

	 */

	protected function filter_comment() {

		return false;

	}


    /**

     * Checks if a node matches css query filter ":selected"

     * @return bool

     * @see match()

     */

    protected function filter_selected() {

        $attr = $this->getAttribute('selected');

        if (is_array($attr))

            $attr = reset($attr);


        return strcasecmp($attr, 'selected') === 0;

    }


    public function after($content) {

        $offset = $this->index() + 1;

        $parent = $this->parent;

        $nodes = $this->createNodes($content);


        foreach ($nodes as $node) {

            $node->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->createNodes($content);

        return reset($nodes);

The expression reset($nodes); of type pQuery\DomNode|false adds false to the return on line 2305 which is incompatible with the return type documented by pQuery\DomNode::createNode of type pQuery\DomNode. It seems like you forgot to handle an error condition.

    }


    /**

     * 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->childClass($content, $this));

            } else {

                $node = new $this->parserClass($content);

                $nodes = $node->root->children;

            }

        } else {

            $nodes = (array)$content;

        }

        return $nodes;

    }


    public function append($content) {

        $nodes = $this->createNodes($content);

        foreach ($nodes as $node) {

            $node->changeParent($this);

        }

        return $this;

    }


    public function attr($name, $value = null) {

        if ($value === null)

            return $this->getAttribute($name);

The expression $this->getAttribute($name); of type string|array adds the type array to the return on line 2337 which is incompatible with the return type declared by the interface pQuery\IQuery::attr of type string|pQuery\IQuery.

        $this->setAttribute($name, $value);

        return $this;

    }


   public function before($content) {

      $offset = $this->index();

      $parent = $this->parent;

      $nodes = $this->createNodes($content);


      foreach ($nodes as $node) {

          $node->changeParent($parent, $offset);

      }


      return $this;

   }


   public function count() {

       return 1;

   }


//   public function css($name, $value = null) {

46% of this comment could be valid code. Did you maybe forget this after debugging?

//

//   }


   public function prepend($content = null) {

      $offset = 0;

      $parent = $this;

      $nodes = $this->createNodes($content);


      foreach ($nodes as $node) {

          $node->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->attr($name, $name);

                    } else {

                        $this->removeAttr($name);

                    }

                    return $this;

                }

                return $this->attr($name) == $name;

            case 'tagname':

                return $this->tagName($value);

It seems like $value defined by parameter $value on line 2375 can also be of type string; however, pQuery\DomNode::tagName() does only seem to accept object<pQuery\type>|null, maybe add an additional type check?

        }

        // The property is not supported, degrade gracefully

        if ($value === null)

            return $this;

        else

            return null;

    }


   public function remove($selector = null) {

      if ($selector == null) {

It seems like you are loosely comparing $selector of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

         $this->delete();

      } else {

         $nodes = (array)$this->select($selector);

         foreach ($nodes as $node) {

            $node->delete();

         }

      }

   }


   public function removeAttr($name) {

      $this->deleteAttribute($name);


      return $this;

   }


   function replaceWith($content) {

It is generally recommended to explicitly declare the visibility for methods.

        $node_index = $this->index();


        // Add the new node.

        $node = $this->createNode($content);

        $node->changeParent($this->parent, $node_index);


        // Remove this node.

        $this->remove();


		return $node;

	}


    /**

     * @param type $value

     * @return string|DomNode

     */

    public function tagName($value = null) {

        if ($value !== null) {

            $this->setTag($value);

            return $this;

        }

        return $this->getTag();

    }


   public function text($value = null) {

      if ($value === null)

         return $this->getPlainText();


      $this->setPlainText($value);

      return $this;

   }


   public function toggleClass($classname, $switch = null) {

      if ($switch === true) {

         $this->addClass($classname);

      } elseif ($switch === false) {

         $this->removeClass($classname);

      } else {

         if ($this->hasClass($classname))

            $this->removeClass($classname);

         else

            $this->addClass($classname);

      }

      return $this;

   }


   public function unwrap() {

      $this->parent->detach(true);

      return $this;

   }


    public function val($value = null) {

        switch (strtolower($this->tag)) {

            case 'select':

There must be a comment when fall-through is intentional in a non-empty case body

                if ($value === null) {

                    // Return the value of a selected child.

                    return $this->query('option:selected')->attr('value');

                } else {

                    // Select the option with the right value and deselect the others.

                    foreach ($this->query('option') as $option) {

                        if ($option->attr('value') == $value) {

                            $option->attr('selected', 'selected');

                        } else {

                            $option->removeAttr('selected');

                        }

                    }

                    return $this;

                }

            case 'textarea':

There must be a comment when fall-through is intentional in a non-empty case body

                if ($value === null) {

                    // Return the contents of the textarea.

                    return $this->getInnerText();

                } else {

                    // Set the contents of the textarea.

                    $this->setInnerText($value);

                    return $this;

                }

            case 'input':

                switch (strtolower($this->getAttribute('type'))) {

                    case 'checkbox':

                        if ($value === null)

                            return $this->prop('checked') ? $this->getAttribute('value') : null;

                        else {

                            if (!$value) {

                                $this->deleteAttribute('checked');

                            } else {

                                $this->setAttribute('value', $value);

                                $this->setAttribute('checked', 'checked');

                            }

                            return $this;

                        }

                }

        }


        // Other node types can just get/set the value attribute.

        if ($value !== null) {

           $this->setAttribute('value', $value);

           return $this;

        }

        return $this->getAttribute('value');

    }


}


/**

 * Node subclass for text

 */

class TextNode extends DomNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_TEXT;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	const NODE_TYPE = self::NODE_TEXT;

	#php5e

	var $tag = '~text~';

The visibility should be declared for property $tag.

	/**

	 * @var string

	 */

	var $text = '';

The visibility should be declared for property $text.

	/**

	 * Class constructor

	 * @param DomNode $parent

	 * @param string $text

	 */

	function __construct($parent, $text = '') {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;

The property $parent is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->text = $text;

	}


	#php4 PHP4 class constructor compatibility

	#function TextNode($parent, $text = '') {return $this->__construct($parent, $text);}

65% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	function isText() {return true;}

It is generally recommended to explicitly declare the visibility for methods.

	function isTextOrComment() {return true;}

It is generally recommended to explicitly declare the visibility for methods.

	protected function filter_element() {return false;}

	protected function filter_text() {return true;}

	function toString_attributes() {return '';}

It is generally recommended to explicitly declare the visibility for methods.

	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this->text;}

It is generally recommended to explicitly declare the visibility for methods.

	function toString($attributes = true, $recursive = true, $content_only = false) {return $this->text;}

It is generally recommended to explicitly declare the visibility for methods.

    /**

     * {@inheritdoc}

     */

    public function text($value = null) {

        if ($value !== null) {

            $this->text = $value;

            return $this;

        }

        return $this->text;

    }


    /**

     * {@inheritdoc}

     */

    public function html($value = null) {

        if ($value !== null) {

            $this->text = $value;

            return $this;

        }

        return $this->text;

    }

}


/**

 * Node subclass for comments

 */

class CommentNode extends DomNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_COMMENT;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	const NODE_TYPE = self::NODE_COMMENT;

	#php5e

	var $tag = '~comment~';

The visibility should be declared for property $tag.

	/**

	 * @var string

	 */

	var $text = '';

The visibility should be declared for property $text.

	/**

	 * Class constructor

	 * @param DomNode $parent

	 * @param string $text

	 */

	function __construct($parent, $text = '') {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;

The property $parent is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->text = $text;

	}


	#php4 PHP4 class constructor compatibility

	#function CommentNode($parent, $text = '') {return $this->__construct($parent, $text);}

65% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	function isComment() {return true;}

It is generally recommended to explicitly declare the visibility for methods.

	function isTextOrComment() {return true;}

It is generally recommended to explicitly declare the visibility for methods.

	protected function filter_element() {return false;}

	protected function filter_comment() {return true;}

	function toString_attributes() {return '';}

It is generally recommended to explicitly declare the visibility for methods.

	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this->text;}

It is generally recommended to explicitly declare the visibility for methods.

	function toString($attributes = true, $recursive = true, $content_only = false) {return '<!--'.$this->text.'-->';}

It is generally recommended to explicitly declare the visibility for methods.

}


/**

 * Node subclass for conditional tags

 */

class ConditionalTagNode extends DomNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_CONDITIONAL;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	const NODE_TYPE = self::NODE_CONDITIONAL;

	#php5e

	var $tag = '~conditional~';

The visibility should be declared for property $tag.

	/**

	 * @var string

	 */

	var $condition = '';

The visibility should be declared for property $condition.

	/**

	 * Class constructor

	 * @param DomNode $parent

	 * @param string $condition e.g. "if IE"

	 * @param bool $hidden <!--[if if true, <![if if false

	 */

	function __construct($parent, $condition = '', $hidden = true) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;

The property $parent is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->hidden = $hidden;

The property hidden does not exist on object<pQuery\ConditionalTagNode>. Since you implemented __set, maybe consider adding a @property annotation.

		$this->condition = $condition;

	}


	#php4 PHP4 class constructor compatibility

	#function ConditionalTagNode($parent, $condition = '', $hidden = true) {return $this->__construct($parent, $condition, $hidden);}

61% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	protected function filter_element() {return false;}

	function toString_attributes() {return '';}

It is generally recommended to explicitly declare the visibility for methods.

	function toString($attributes = true, $recursive = true, $content_only = false) {

It is generally recommended to explicitly declare the visibility for methods.

		if ($content_only) {

			if (is_int($content_only)) {

				--$content_only;

			}

			return $this->toString_content($attributes, $recursive, $content_only);

It seems like $content_only defined by --$content_only on line 2661 can also be of type integer; however, pQuery\DomNode::toString_content() does only seem to accept boolean, maybe add an additional type check?

		}


		$s = '<!'.(($this->hidden) ? '--' : '').'['.$this->condition.']>';

The property hidden does not exist on object<pQuery\ConditionalTagNode>. Since you implemented __get, maybe consider adding a @property annotation.

		if($recursive) {

			$s .= $this->toString_content($attributes);

		}

		$s .= '<![endif]'.(($this->hidden) ? '--' : '').'>';

The property hidden does not exist on object<pQuery\ConditionalTagNode>. Since you implemented __get, maybe consider adding a @property annotation.

		return $s;

	}

}


/**

 * Node subclass for CDATA tags

 */

class CdataNode extends DomNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_CDATA;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	const NODE_TYPE = self::NODE_CDATA;

	#php5e

	var $tag = '~cdata~';

The visibility should be declared for property $tag.

	/**

	 * @var string

	 */

	var $text = '';

The visibility should be declared for property $text.

	/**

	 * Class constructor

	 * @param DomNode $parent

	 * @param string $text

	 */

	function __construct($parent, $text = '') {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;

The property $parent is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->text = $text;

	}


	#php4 PHP4 class constructor compatibility

	#function CdataNode($parent, $text = '') {return $this->__construct($parent, $text);}

65% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	protected function filter_element() {return false;}

	function toString_attributes() {return '';}

It is generally recommended to explicitly declare the visibility for methods.

	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this->text;}

It is generally recommended to explicitly declare the visibility for methods.

	function toString($attributes = true, $recursive = true, $content_only = false) {return '<![CDATA['.$this->text.']]>';}

It is generally recommended to explicitly declare the visibility for methods.

}


/**

 * Node subclass for doctype tags

 */

class DoctypeNode extends DomNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_DOCTYPE;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

	#php5

	const NODE_TYPE = self::NODE_DOCTYPE;

	#php5e

	var $tag = '!DOCTYPE';

The visibility should be declared for property $tag.

	/**

	 * @var string

	 */

	var $dtd = '';

The visibility should be declared for property $dtd.

	/**

	 * Class constructor

	 * @param DomNode $parent

	 * @param string $dtd

	 */

	function __construct($parent, $dtd = '') {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;

The property $parent is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->dtd = $dtd;

	}


	#php4 PHP4 class constructor compatibility

	#function DoctypeNode($parent, $dtd = '') {return $this->__construct($parent, $dtd);}

65% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	protected function filter_element() {return false;}

	function toString_attributes() {return '';}

It is generally recommended to explicitly declare the visibility for methods.

	function toString_content($attributes = true, $recursive = true, $content_only = false) {return $this->text;}

The property text does not exist on object<pQuery\DoctypeNode>. Since you implemented __get, maybe consider adding a @property annotation.

It is generally recommended to explicitly declare the visibility for methods.

	function toString($attributes = true, $recursive = true, $content_only = false) {return '<'.$this->tag.' '.$this->dtd.'>';}

It is generally recommended to explicitly declare the visibility for methods.

}


/**

 * Node subclass for embedded tags like xml, php and asp

 */

class EmbeddedNode extends DomNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	/**

	 * @var string

	 * @internal specific char for tags, like ? for php and % for asp

	 * @access private

	 */

	var $tag_char = '';

The visibility should be declared for property $tag_char.

	/**

	 * @var string

	 */

	var $text = '';

The visibility should be declared for property $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' => 'val')

	 */

	function __construct($parent, $tag_char = '', $tag = '', $text = '', $attributes = array()) {

It is generally recommended to explicitly declare the visibility for methods.

		$this->parent = $parent;

The property $parent is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->tag_char = $tag_char;

		if ($tag[0] !== $this->tag_char) {

			$tag = $this->tag_char.$tag;

		}

		$this->tag = $tag;

The property $tag is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->text = $text;

		$this->attributes = $attributes;

The property $attributes is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

		$this->self_close_str = $tag_char;

The property $self_close_str is declared private in pQuery\DomNode. Since you implemented __set(), maybe consider adding a @property or @property-write annotation. This makes it easier for IDEs to provide auto-completion.

	}


	#php4 PHP4 class constructor compatibility

	#function EmbeddedNode($parent, $tag_char = '', $tag = '', $text = '', $attributes = array()) {return $this->__construct($parent, $tag_char, $tag, $text, $attributes);}

59% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e


	protected function filter_element() {return false;}

	function toString($attributes = true, $recursive = true, $content_only = false) {

It is generally recommended to explicitly declare the visibility for methods.

		$s = '<'.$this->tag;

The property $tag is declared private in pQuery\DomNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

		if ($attributes) {

			$s .= $this->toString_attributes();

		}

		$s .= $this->text.$this->self_close_str.'>';

The property $self_close_str is declared private in pQuery\DomNode. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

		return $s;

	}

}


/**

 * Node subclass for "?" tags, like php and xml

 */

class XmlNode extends EmbeddedNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_XML;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#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' => 'val')

	 */

	function __construct($parent, $tag = 'xml', $text = '', $attributes = array()) {

It is generally recommended to explicitly declare the visibility for methods.

		return parent::__construct($parent, '?', $tag, $text, $attributes);

Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct?

	}


	#php4 PHP4 class constructor compatibility

	#function XmlNode($parent, $tag = 'xml', $text = '', $attributes = array()) {return $this->__construct($parent, $tag, $text, $attributes);}

60% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

}


/**

 * Node subclass for asp tags

 */

class AspEmbeddedNode extends EmbeddedNode {

PSR1 recommends that each class should be in its own file to aid autoloaders.

	#php4 Compatibility with PHP4, this gets changed to a regular var in release tool

	#static $NODE_TYPE = self::NODE_ASP;

50% of this comment could be valid code. Did you maybe forget this after debugging?

	#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' => 'val')

	 */

	function __construct($parent, $tag = '', $text = '', $attributes = array()) {

It is generally recommended to explicitly declare the visibility for methods.

		return parent::__construct($parent, '%', $tag, $text, $attributes);

Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct?

	}


	#php4 PHP4 class constructor compatibility

	#function AspEmbeddedNode($parent, $tag = '', $text = '', $attributes = array()) {return $this->__construct($parent, $tag, $text, $attributes);}

60% of this comment could be valid code. Did you maybe forget this after debugging?

	#php4e

}


?>

It is not recommended to use PHP's closing tag ?> in files other than templates.