<?php
/**
 * phpQuery is a server-side, chainable, CSS3 selector driven
 * Document Object Model (DOM) API based on jQuery JavaScript Library.
 *
 * @version 0.9.5
 * @link http://code.google.com/p/phpquery/
 * @link http://phpquery-library.blogspot.com/
 * @link http://jquery.com/
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @license http://www.opensource.org/licenses/mit-license.php MIT License
 * @package phpQuery
 */

// class names for instanceof
// TODO move them as class constants into phpQuery
define('DOMDOCUMENT', 'DOMDocument');
define('DOMELEMENT', 'DOMElement');
define('DOMNODELIST', 'DOMNodeList');
define('DOMNODE', 'DOMNode');

/**
 * DOMEvent class.
 *
 * Based on
 * @link http://developer.mozilla.org/En/DOM:event
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @package phpQuery
 * @todo implement ArrayAccess ?
 */
if (!class_exists('DOMEvent')) {

	class DOMEvent {
		/**
		 * Returns a boolean indicating whether the event bubbles up through the DOM or not.
		 *
		 * @var unknown_type
		 */
		public $bubbles = true;
		/**
		 * Returns a boolean indicating whether the event is cancelable.
		 *
		 * @var unknown_type
		 */
		public $cancelable = true;
		/**
		 * Returns a reference to the currently registered target for the event.
		 *
		 * @var unknown_type
		 */
		public $currentTarget;
		/**
		 * Returns detail about the event, depending on the type of event.
		 *
		 * @var unknown_type
		 * @link http://developer.mozilla.org/en/DOM/event.detail
		 */
		public $detail;	// ???
		/**
		 * Used to indicate which phase of the event flow is currently being evaluated.
		 *
		 * NOT IMPLEMENTED
		 *
		 * @var unknown_type
		 * @link http://developer.mozilla.org/en/DOM/event.eventPhase
		 */
		public $eventPhase;	// ???
		/**
		 * The explicit original target of the event (Mozilla-specific).
		 *
		 * NOT IMPLEMENTED
		 *
		 * @var unknown_type
		 */
		public $explicitOriginalTarget; // moz only
		/**
		 * The original target of the event, before any retargetings (Mozilla-specific).
		 *
		 * NOT IMPLEMENTED
		 *
		 * @var unknown_type
		 */
		public $originalTarget;	// moz only
		/**
		 * Identifies a secondary target for the event.
		 *
		 * @var unknown_type
		 */
		public $relatedTarget;
		/**
		 * Returns a reference to the target to which the event was originally dispatched.
		 *
		 * @var unknown_type
		 */
		public $target;
		/**
		 * Returns the time that the event was created.
		 *
		 * @var unknown_type
		 */
		public $timeStamp;
		/**
		 * Returns the name of the event (case-insensitive).
		 */
		public $type;
		public $runDefault = true;
		public $data = null;
		public function __construct($data) {
			foreach($data as $k => $v) {
				$this->$k = $v;
			}
			if (! $this->timeStamp)
				$this->timeStamp = time();
		}
		/**
		 * Cancels the event (if it is cancelable).
		 *
		 */
		public function preventDefault() {
			$this->runDefault = false;
		}
		/**
		 * Stops the propagation of events further along in the DOM.
		 *
		 */
		public function stopPropagation() {
			$this->bubbles = false;
		}
	}
}


/**
 * DOMDocumentWrapper class simplifies work with DOMDocument.
 *
 * Know bug:
 * - in XHTML fragments, <br /> changes to <br clear="none" />
 *
 * @todo check XML catalogs compatibility
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @package phpQuery
 */
if (!class_exists('DOMDocumentWrapper')) {
	class DOMDocumentWrapper {
		/**
		 * @var DOMDocument
		 */
		public $document;
		public $id;
		/**
		 * @todo Rewrite as method and quess if null.
		 * @var unknown_type
		 */
		public $contentType = '';
		public $xpath;
		public $uuid = 0;
		public $data = array();
		public $dataNodes = array();
		public $events = array();
		public $eventsNodes = array();
		public $eventsGlobal = array();
		/**
		 * @TODO iframes support http://code.google.com/p/phpquery/issues/detail?id=28
		 * @var unknown_type
		 */
		public $frames = array();
		/**
		 * Document root, by default equals to document itself.
		 * Used by documentFragments.
		 *
		 * @var DOMNode
		 */
		public $root;
		public $isDocumentFragment;
		public $isXML = false;
		public $isXHTML = false;
		public $isHTML = false;
		public $charset;
		public function __construct($markup = null, $contentType = null, $newDocumentID = null) {
			if (isset($markup))
				$this->load($markup, $contentType, $newDocumentID);
			$this->id = $newDocumentID
				? $newDocumentID
				: md5(microtime());
		}
		public function load($markup, $contentType = null, $newDocumentID = null) {
	//		phpQuery::$documents[$id] = $this;
			$this->contentType = strtolower($contentType);
			if ($markup instanceof DOMDOCUMENT) {
				$this->document = $markup;
				$this->root = $this->document;
				$this->charset = $this->document->encoding;
				// TODO isDocumentFragment
			} else {
				$loaded = $this->loadMarkup($markup);
			}
			if ($loaded) {
	//			$this->document->formatOutput = true;
				$this->document->preserveWhiteSpace = true;
				$this->xpath = new DOMXPath($this->document);
				$this->afterMarkupLoad();
				return true;
				// remember last loaded document
	//			return phpQuery::selectDocument($id);
			}
			return false;
		}
		protected function afterMarkupLoad() {
			if ($this->isXHTML) {
				$this->xpath->registerNamespace("html", "http://www.w3.org/1999/xhtml");
			}
		}
		protected function loadMarkup($markup) {
			$loaded = false;
			if ($this->contentType) {
				self::debug("Load markup for content type {$this->contentType}");
				// content determined by contentType
				list($contentType, $charset) = $this->contentTypeToArray($this->contentType);
				switch($contentType) {
					case 'text/html':
						phpQuery::debug("Loading HTML, content type '{$this->contentType}'");
						$loaded = $this->loadMarkupHTML($markup, $charset);
					break;
					case 'text/xml':
					case 'application/xhtml+xml':
						phpQuery::debug("Loading XML, content type '{$this->contentType}'");
						$loaded = $this->loadMarkupXML($markup, $charset);
					break;
					default:
						// for feeds or anything that sometimes doesn't use text/xml
						if (strpos('xml', $this->contentType) !== false) {
							phpQuery::debug("Loading XML, content type '{$this->contentType}'");
							$loaded = $this->loadMarkupXML($markup, $charset);
						} else
							phpQuery::debug("Could not determine document type from content type '{$this->contentType}'");
				}
			} else {
				// content type autodetection
				if ($this->isXML($markup)) {
					phpQuery::debug("Loading XML, isXML() == true");
					$loaded = $this->loadMarkupXML($markup);
					if (! $loaded && $this->isXHTML) {
						phpQuery::debug('Loading as XML failed, trying to load as HTML, isXHTML == true');
						$loaded = $this->loadMarkupHTML($markup);
					}
				} else {
					phpQuery::debug("Loading HTML, isXML() == false");
					$loaded = $this->loadMarkupHTML($markup);
				}
			}
			return $loaded;
		}
		protected function loadMarkupReset() {
			$this->isXML = $this->isXHTML = $this->isHTML = false;
		}
		protected function documentCreate($charset, $version = '1.0') {
			if (! $version)
				$version = '1.0';
			$this->document = new DOMDocument($version, $charset);
			$this->charset = $this->document->encoding;
	//		$this->document->encoding = $charset;
			$this->document->formatOutput = true;
			$this->document->preserveWhiteSpace = true;
		}
		protected function loadMarkupHTML($markup, $requestedCharset = null) {
			if (phpQuery::$debug)
				phpQuery::debug('Full markup load (HTML): '.substr($markup, 0, 250));
			$this->loadMarkupReset();
			$this->isHTML = true;
			if (!isset($this->isDocumentFragment))
				$this->isDocumentFragment = self::isDocumentFragmentHTML($markup);
			$charset = null;
			$documentCharset = $this->charsetFromHTML($markup);
			$addDocumentCharset = false;
			if ($documentCharset) {
				$charset = $documentCharset;
				$markup = $this->charsetFixHTML($markup);
			} else if ($requestedCharset) {
				$charset = $requestedCharset;
			}
			if (! $charset)
				$charset = phpQuery::$defaultCharset;
			// HTTP 1.1 says that the default charset is ISO-8859-1
			// @see http://www.w3.org/International/O-HTTP-charset
			if (! $documentCharset) {
				$documentCharset = 'ISO-8859-1';
				$addDocumentCharset = true;	
			}
			// Should be careful here, still need 'magic encoding detection' since lots of pages have other 'default encoding'
			// Worse, some pages can have mixed encodings... we'll try not to worry about that
			$requestedCharset = strtoupper($requestedCharset);
			$documentCharset = strtoupper($documentCharset);
			phpQuery::debug("DOC: $documentCharset REQ: $requestedCharset");
			if ($requestedCharset && $documentCharset && $requestedCharset !== $documentCharset) {
				phpQuery::debug("CHARSET CONVERT");
				// Document Encoding Conversion
				// http://code.google.com/p/phpquery/issues/detail?id=86
				if (function_exists('mb_detect_encoding')) {
					$possibleCharsets = array($documentCharset, $requestedCharset, 'AUTO');
					$docEncoding = mb_detect_encoding($markup, implode(', ', $possibleCharsets));
					if (! $docEncoding)
						$docEncoding = $documentCharset; // ok trust the document
					phpQuery::debug("DETECTED '$docEncoding'");
					// Detected does not match what document says...
					if ($docEncoding !== $documentCharset) {
						// Tricky..
					}
					if ($docEncoding !== $requestedCharset) {
						phpQuery::debug("CONVERT $docEncoding => $requestedCharset");
						$markup = mb_convert_encoding($markup, $requestedCharset, $docEncoding);
						$markup = $this->charsetAppendToHTML($markup, $requestedCharset);
						$charset = $requestedCharset;
					}
				} else {
					phpQuery::debug("TODO: charset conversion without mbstring...");
				}
			}
			$return = false;
			if ($this->isDocumentFragment) {
				phpQuery::debug("Full markup load (HTML), DocumentFragment detected, using charset '$charset'");
				$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
			} else {
				if ($addDocumentCharset) {
					phpQuery::debug("Full markup load (HTML), appending charset: '$charset'");
					$markup = $this->charsetAppendToHTML($markup, $charset);
				}
				phpQuery::debug("Full markup load (HTML), documentCreate('$charset')");
				$this->documentCreate($charset);
				$return = phpQuery::$debug === 2
					? $this->document->loadHTML($markup)
					: @$this->document->loadHTML($markup);
				if ($return)
					$this->root = $this->document;
			}
			if ($return && ! $this->contentType)
				$this->contentType = 'text/html';
			return $return;
		}
		protected function loadMarkupXML($markup, $requestedCharset = null) {
			if (phpQuery::$debug)
				phpQuery::debug('Full markup load (XML): '.substr($markup, 0, 250));
			$this->loadMarkupReset();
			$this->isXML = true;
			// check agains XHTML in contentType or markup
			$isContentTypeXHTML = $this->isXHTML();
			$isMarkupXHTML = $this->isXHTML($markup);
			if ($isContentTypeXHTML || $isMarkupXHTML) {
				self::debug('Full markup load (XML), XHTML detected');
				$this->isXHTML = true;
			}
			// determine document fragment
			if (! isset($this->isDocumentFragment))
				$this->isDocumentFragment = $this->isXHTML
					? self::isDocumentFragmentXHTML($markup)
					: self::isDocumentFragmentXML($markup);
			// this charset will be used
			$charset = null;
			// charset from XML declaration @var string
			$documentCharset = $this->charsetFromXML($markup);
			if (! $documentCharset) {
				if ($this->isXHTML) {
					// this is XHTML, try to get charset from content-type meta header
					$documentCharset = $this->charsetFromHTML($markup);
					if ($documentCharset) {
						phpQuery::debug("Full markup load (XML), appending XHTML charset '$documentCharset'");
						$this->charsetAppendToXML($markup, $documentCharset);
						$charset = $documentCharset;
					}
				}
				if (! $documentCharset) {
					// if still no document charset...
					$charset = $requestedCharset;
				}
			} else if ($requestedCharset) {
				$charset = $requestedCharset;
			}
			if (! $charset) {
				$charset = phpQuery::$defaultCharset;
			}
			if ($requestedCharset && $documentCharset && $requestedCharset != $documentCharset) {
				// TODO place for charset conversion
	//			$charset = $requestedCharset;
			}
			$return = false;
			if ($this->isDocumentFragment) {
				phpQuery::debug("Full markup load (XML), DocumentFragment detected, using charset '$charset'");
				$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
			} else {
				// FIXME ???
				if ($isContentTypeXHTML && ! $isMarkupXHTML)
				if (! $documentCharset) {
					phpQuery::debug("Full markup load (XML), appending charset '$charset'");
					$markup = $this->charsetAppendToXML($markup, $charset);
				}
				// see http://pl2.php.net/manual/en/book.dom.php#78929
				// LIBXML_DTDLOAD (>= PHP 5.1)
				// does XML ctalogues works with LIBXML_NONET
		//		$this->document->resolveExternals = true;
				// TODO test LIBXML_COMPACT for performance improvement
				// create document
				$this->documentCreate($charset);
				if (phpversion() < 5.1) {
					$this->document->resolveExternals = true;
					$return = phpQuery::$debug === 2
						? $this->document->loadXML($markup)
						: @$this->document->loadXML($markup);
				} else {
					/** @link http://pl2.php.net/manual/en/libxml.constants.php */
					$libxmlStatic = phpQuery::$debug === 2
						? LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET
						: LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET|LIBXML_NOWARNING|LIBXML_NOERROR;
					$return = $this->document->loadXML($markup, $libxmlStatic);
	// 				if (! $return)
	// 					$return = $this->document->loadHTML($markup);
				}
				if ($return)
					$this->root = $this->document;
			}
			if ($return) {
				if (! $this->contentType) {
					if ($this->isXHTML)
						$this->contentType = 'application/xhtml+xml';
					else
						$this->contentType = 'text/xml';
				}
				return $return;
			} else {
				throw new Exception("Error loading XML markup");
			}
		}
		protected function isXHTML($markup = null) {
			if (! isset($markup)) {
				return strpos($this->contentType, 'xhtml') !== false;
			}
			// XXX ok ?
			return strpos($markup, "<!DOCTYPE html") !== false;
	//		return stripos($doctype, 'xhtml') !== false;
	//		$doctype = isset($dom->doctype) && is_object($dom->doctype)
	//			? $dom->doctype->publicId
	//			: self::$defaultDoctype;
		}
		protected function isXML($markup) {
	//		return strpos($markup, '<?xml') !== false && stripos($markup, 'xhtml') === false;
			return strpos(substr($markup, 0, 100), '<'.'?xml') !== false;
		}
		protected function contentTypeToArray($contentType) {
			$matches = explode(';', trim(strtolower($contentType)));
			if (isset($matches[1])) {
				$matches[1] = explode('=', $matches[1]);
				// strip 'charset='
				$matches[1] = isset($matches[1][1]) && trim($matches[1][1])
					? $matches[1][1]
					: $matches[1][0];
			} else
				$matches[1] = null;
			return $matches;
		}
		/**
		 *
		 * @param $markup
		 * @return array contentType, charset
		 */
		protected function contentTypeFromHTML($markup) {
			$matches = array();
			// find meta tag
			preg_match('@<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
				$markup, $matches
			);
			if (! isset($matches[0]))
				return array(null, null);
			// get attr 'content'
			preg_match('@content\\s*=\\s*(["|\'])(.+?)\\1@', $matches[0], $matches);
			if (! isset($matches[0]))
				return array(null, null);
			return $this->contentTypeToArray($matches[2]);
		}
		protected function charsetFromHTML($markup) {
			$contentType = $this->contentTypeFromHTML($markup);
			return $contentType[1];
		}
		protected function charsetFromXML($markup) {
			$matches;
			// find declaration
			preg_match('@<'.'?xml[^>]+encoding\\s*=\\s*(["|\'])(.*?)\\1@i',
				$markup, $matches
			);
			return isset($matches[2])
				? strtolower($matches[2])
				: null;
		}
		/**
		 * Repositions meta[type=charset] at the start of head. Bypasses DOMDocument bug.
		 *
		 * @link http://code.google.com/p/phpquery/issues/detail?id=80
		 * @param $html
		 */
		protected function charsetFixHTML($markup) {
			$matches = array();
			// find meta tag
			preg_match('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
				$markup, $matches, PREG_OFFSET_CAPTURE
			);
			if (! isset($matches[0]))
				return;
			$metaContentType = $matches[0][0];
			$markup = substr($markup, 0, $matches[0][1])
				.substr($markup, $matches[0][1]+strlen($metaContentType));
			$headStart = stripos($markup, '<head>');
			$markup = substr($markup, 0, $headStart+6).$metaContentType
				.substr($markup, $headStart+6);
			return $markup;
		}
		protected function charsetAppendToHTML($html, $charset, $xhtml = false) {
			// remove existing meta[type=content-type]
			$html = preg_replace('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i', '', $html);
			$meta = '<meta http-equiv="Content-Type" content="text/html;charset='
				.$charset.'" '
				.($xhtml ? '/' : '')
				.'>';
			if (strpos($html, '<head') === false) {
				if (strpos($hltml, '<html') === false) {
					return $meta.$html;
				} else {
					return preg_replace(
						'@<html(.*?)(?(?<!\?)>)@s',
						"<html\\1><head>{$meta}</head>",
						$html
					);
				}
			} else {
				return preg_replace(
					'@<head(.*?)(?(?<!\?)>)@s',
					'<head\\1>'.$meta,
					$html
				);
			}
		}
		protected function charsetAppendToXML($markup, $charset) {
			$declaration = '<'.'?xml version="1.0" encoding="'.$charset.'"?'.'>';
			return $declaration.$markup;
		}
		public static function isDocumentFragmentHTML($markup) {
			return stripos($markup, '<html') === false && stripos($markup, '<!doctype') === false;
		}
		public static function isDocumentFragmentXML($markup) {
			return stripos($markup, '<'.'?xml') === false;
		}
		public static function isDocumentFragmentXHTML($markup) {
			return self::isDocumentFragmentHTML($markup);
		}
		public function importAttr($value) {
			// TODO
		}
		/**
		 *
		 * @param $source
		 * @param $target
		 * @param $sourceCharset
		 * @return array Array of imported nodes.
		 */
		public function import($source, $sourceCharset = null) {
			// TODO charset conversions
			$return = array();
			if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
				$source = array($source);
	//		if (is_array($source)) {
	//			foreach($source as $node) {
	//				if (is_string($node)) {
	//					// string markup
	//					$fake = $this->documentFragmentCreate($node, $sourceCharset);
	//					if ($fake === false)
	//						throw new Exception("Error loading documentFragment markup");
	//					else
	//						$return = array_merge($return, 
	//							$this->import($fake->root->childNodes)
	//						);
	//				} else {
	//					$return[] = $this->document->importNode($node, true);
	//				}
	//			}
	//			return $return;
	//		} else {
	//			// string markup
	//			$fake = $this->documentFragmentCreate($source, $sourceCharset);
	//			if ($fake === false)
	//				throw new Exception("Error loading documentFragment markup");
	//			else
	//				return $this->import($fake->root->childNodes);
	//		}
			if (is_array($source) || $source instanceof DOMNODELIST) {
				// dom nodes
				self::debug('Importing nodes to document');
				foreach($source as $node)
					$return[] = $this->document->importNode($node, true);
			} else {
				// string markup
				$fake = $this->documentFragmentCreate($source, $sourceCharset);
				if ($fake === false)
					throw new Exception("Error loading documentFragment markup");
				else
					return $this->import($fake->root->childNodes);
			}
			return $return;
		}
		/**
		 * Creates new document fragment.
		 *
		 * @param $source
		 * @return DOMDocumentWrapper
		 */
		protected function documentFragmentCreate($source, $charset = null) {
			$fake = new DOMDocumentWrapper();
			$fake->contentType = $this->contentType;
			$fake->isXML = $this->isXML;
			$fake->isHTML = $this->isHTML;
			$fake->isXHTML = $this->isXHTML;
			$fake->root = $fake->document;
			if (! $charset)
				$charset = $this->charset;
	//	$fake->documentCreate($this->charset);
			if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
				$source = array($source);
			if (is_array($source) || $source instanceof DOMNODELIST) {
				// dom nodes
				// load fake document
				if (! $this->documentFragmentLoadMarkup($fake, $charset))
					return false;
				$nodes = $fake->import($source);
				foreach($nodes as $node)
					$fake->root->appendChild($node);
			} else {
				// string markup
				$this->documentFragmentLoadMarkup($fake, $charset, $source);
			}
			return $fake;
		}
		/**
		 *
		 * @param $document DOMDocumentWrapper
		 * @param $markup
		 * @return $document
		 */
		private function documentFragmentLoadMarkup($fragment, $charset, $markup = null) {
			// TODO error handling
			// TODO copy doctype
			// tempolary turn off
			$fragment->isDocumentFragment = false;
			if ($fragment->isXML) {
				if ($fragment->isXHTML) {
					// add FAKE element to set default namespace
					$fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?>'
						.'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
						.'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
						.'<fake xmlns="http://www.w3.org/1999/xhtml">'.$markup.'</fake>');
					$fragment->root = $fragment->document->firstChild->nextSibling;
				} else {
					$fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?><fake>'.$markup.'</fake>');
					$fragment->root = $fragment->document->firstChild;
				}
			} else {
				$markup2 = phpQuery::$defaultDoctype.'<html><head><meta http-equiv="Content-Type" content="text/html;charset='
					.$charset.'"></head>';
				$noBody = strpos($markup, '<body') === false;
				if ($noBody)
					$markup2 .= '<body>';
				$markup2 .= $markup;
				if ($noBody)
					$markup2 .= '</body>';
				$markup2 .= '</html>';
				$fragment->loadMarkupHTML($markup2);
				// TODO resolv body tag merging issue
				$fragment->root = $noBody
					? $fragment->document->firstChild->nextSibling->firstChild->nextSibling
					: $fragment->document->firstChild->nextSibling->firstChild->nextSibling;
			}
			if (! $fragment->root)
				return false;
			$fragment->isDocumentFragment = true;
			return true;
		}
		protected function documentFragmentToMarkup($fragment) {
			phpQuery::debug('documentFragmentToMarkup');
			$tmp = $fragment->isDocumentFragment;
			$fragment->isDocumentFragment = false;
			$markup = $fragment->markup();
			if ($fragment->isXML) {
				$markup = substr($markup, 0, strrpos($markup, '</fake>'));
				if ($fragment->isXHTML) {
					$markup = substr($markup, strpos($markup, '<fake')+43);
				} else {
					$markup = substr($markup, strpos($markup, '<fake>')+6);
				}
			} else {
					$markup = substr($markup, strpos($markup, '<body>')+6);
					$markup = substr($markup, 0, strrpos($markup, '</body>'));
			}
			$fragment->isDocumentFragment = $tmp;
			if (phpQuery::$debug)
				phpQuery::debug('documentFragmentToMarkup: '.substr($markup, 0, 150));
			return $markup;
		}
		/**
		 * Return document markup, starting with optional $nodes as root.
		 *
		 * @param $nodes	DOMNode|DOMNodeList
		 * @return string
		 */
		public function markup($nodes = null, $innerMarkup = false) {
			if (isset($nodes) && count($nodes) == 1 && $nodes[0] instanceof DOMDOCUMENT)
				$nodes = null;
			if (isset($nodes)) {
				$markup = '';
				if (!is_array($nodes) && !($nodes instanceof DOMNODELIST) )
					$nodes = array($nodes);
				if ($this->isDocumentFragment && ! $innerMarkup)
					foreach($nodes as $i => $node)
						if ($node->isSameNode($this->root)) {
						//	var_dump($node);
							$nodes = array_slice($nodes, 0, $i)
								+ phpQuery::DOMNodeListToArray($node->childNodes)
								+ array_slice($nodes, $i+1);
							}
				if ($this->isXML && ! $innerMarkup) {
					self::debug("Getting outerXML with charset '{$this->charset}'");
					// we need outerXML, so we can benefit from
					// $node param support in saveXML()
					foreach($nodes as $node)
						$markup .= $this->document->saveXML($node);
				} else {
					$loop = array();
					if ($innerMarkup)
						foreach($nodes as $node) {
							if ($node->childNodes)
								foreach($node->childNodes as $child)
									$loop[] = $child;
							else
								$loop[] = $node;
						}
					else
						$loop = $nodes;
					self::debug("Getting markup, moving selected nodes (".count($loop).") to new DocumentFragment");
					$fake = $this->documentFragmentCreate($loop);
					$markup = $this->documentFragmentToMarkup($fake);
				}
				if ($this->isXHTML) {
					self::debug("Fixing XHTML");
					$markup = self::markupFixXHTML($markup);
				}
				self::debug("Markup: ".substr($markup, 0, 250));
				return $markup;
			} else {
				if ($this->isDocumentFragment) {
					// documentFragment, html only...
					self::debug("Getting markup, DocumentFragment detected");
	//				return $this->markup(
	////					$this->document->getElementsByTagName('body')->item(0)
	//					$this->document->root, true
	//				);
					$markup = $this->documentFragmentToMarkup($this);
					// no need for markupFixXHTML, as it's done thought markup($nodes) method
					return $markup;
				} else {
					self::debug("Getting markup (".($this->isXML?'XML':'HTML')."), final with charset '{$this->charset}'");
					$markup = $this->isXML
						? $this->document->saveXML()
						: $this->document->saveHTML();
					if ($this->isXHTML) {
						self::debug("Fixing XHTML");
						$markup = self::markupFixXHTML($markup);
					}
					self::debug("Markup: ".substr($markup, 0, 250));
					return $markup;
				}
			}
		}
		protected static function markupFixXHTML($markup) {
			$markup = self::expandEmptyTag('script', $markup);
			$markup = self::expandEmptyTag('select', $markup);
			$markup = self::expandEmptyTag('textarea', $markup);
			return $markup;
		}
		public static function debug($text) {
			phpQuery::debug($text);
		}
		/**
		 * expandEmptyTag
		 *
		 * @param $tag
		 * @param $xml
		 * @return unknown_type
		 * @author mjaque at ilkebenson dot com
		 * @link http://php.net/manual/en/domdocument.savehtml.php#81256
		 */
		public static function expandEmptyTag($tag, $xml){
	        $indice = 0;
	        while ($indice< strlen($xml)){
	            $pos = strpos($xml, "<$tag ", $indice);
	            if ($pos){
	                $posCierre = strpos($xml, ">", $pos);
	                if ($xml[$posCierre-1] == "/"){
	                    $xml = substr_replace($xml, "></$tag>", $posCierre-1, 2);
	                }
	                $indice = $posCierre;
	            }
	            else break;
	        }
	        return $xml;
		}
	}
}

/**
 * Event handling class.
 *
 * @author Tobiasz Cudnik
 * @package phpQuery
 * @static
 */
if (!class_exists('phpQueryEvents')) {
	abstract class phpQueryEvents {
		/**
		 * Trigger a type of event on every matched element.
		 *
		 * @param DOMNode|phpQueryObject|string $document
		 * @param unknown_type $type
		 * @param unknown_type $data
		 *
		 * @TODO exclusive events (with !)
		 * @TODO global events (test)
		 * @TODO support more than event in $type (space-separated)
		 */
		public static function trigger($document, $type, $data = array(), $node = null) {
			// trigger: function(type, data, elem, donative, extra) {
			$documentID = phpQuery::getDocumentID($document);
			$namespace = null;
			if (strpos($type, '.') !== false)
				list($name, $namespace) = explode('.', $type);
			else
				$name = $type;
			if (! $node) {
				if (self::issetGlobal($documentID, $type)) {
					$pq = phpQuery::getDocument($documentID);
					// TODO check add($pq->document)
					$pq->find('*')->add($pq->document)
						->trigger($type, $data);
				}
			} else {
				if (isset($data[0]) && $data[0] instanceof DOMEvent) {
					$event = $data[0];
					$event->relatedTarget = $event->target;
					$event->target = $node;
					$data = array_slice($data, 1);
				} else {
					$event = new DOMEvent(array(
						'type' => $type,
						'target' => $node,
						'timeStamp' => time(),
					));
				}
				$i = 0;
				while($node) {
					// TODO whois
					phpQuery::debug("Triggering ".($i?"bubbled ":'')."event '{$type}' on "
						."node \n");//.phpQueryObject::whois($node)."\n");
					$event->currentTarget = $node;
					$eventNode = self::getNode($documentID, $node);
					if (isset($eventNode->eventHandlers)) {
						foreach($eventNode->eventHandlers as $eventType => $handlers) {
							$eventNamespace = null;
							if (strpos($type, '.') !== false)
								list($eventName, $eventNamespace) = explode('.', $eventType);
							else
								$eventName = $eventType;
							if ($name != $eventName)
								continue;
							if ($namespace && $eventNamespace && $namespace != $eventNamespace)
								continue;
							foreach($handlers as $handler) {
								phpQuery::debug("Calling event handler\n");
								$event->data = $handler['data']
									? $handler['data']
									: null;
								$params = array_merge(array($event), $data);
								$return = phpQuery::callbackRun($handler['callback'], $params);
								if ($return === false) {
									$event->bubbles = false;
								}
							}
						}
					}
					// to bubble or not to bubble...
					if (! $event->bubbles)
						break;
					$node = $node->parentNode;
					$i++;
				}
			}
		}
		/**
		 * Binds a handler to one or more events (like click) for each matched element.
		 * Can also bind custom events.
		 *
		 * @param DOMNode|phpQueryObject|string $document
		 * @param unknown_type $type
		 * @param unknown_type $data Optional
		 * @param unknown_type $callback
		 *
		 * @TODO support '!' (exclusive) events
		 * @TODO support more than event in $type (space-separated)
		 * @TODO support binding to global events
		 */
		public static function add($document, $node, $type, $data, $callback = null) {
			phpQuery::debug("Binding '$type' event");
			$documentID = phpQuery::getDocumentID($document);
	//		if (is_null($callback) && is_callable($data)) {
	//			$callback = $data;
	//			$data = null;
	//		}
			$eventNode = self::getNode($documentID, $node);
			if (! $eventNode)
				$eventNode = self::setNode($documentID, $node);
			if (!isset($eventNode->eventHandlers[$type]))
				$eventNode->eventHandlers[$type] = array();
			$eventNode->eventHandlers[$type][] = array(
				'callback' => $callback,
				'data' => $data,
			);
		}
		/**
		 * Enter description here...
		 *
		 * @param DOMNode|phpQueryObject|string $document
		 * @param unknown_type $type
		 * @param unknown_type $callback
		 *
		 * @TODO namespace events
		 * @TODO support more than event in $type (space-separated)
		 */
		public static function remove($document, $node, $type = null, $callback = null) {
			$documentID = phpQuery::getDocumentID($document);
			$eventNode = self::getNode($documentID, $node);
			if (is_object($eventNode) && isset($eventNode->eventHandlers[$type])) {
				if ($callback) {
					foreach($eventNode->eventHandlers[$type] as $k => $handler)
						if ($handler['callback'] == $callback)
							unset($eventNode->eventHandlers[$type][$k]);
				} else {
					unset($eventNode->eventHandlers[$type]);
				}
			}
		}
		protected static function getNode($documentID, $node) {
			foreach(phpQuery::$documents[$documentID]->eventsNodes as $eventNode) {
				if ($node->isSameNode($eventNode))
					return $eventNode;
			}
		}
		protected static function setNode($documentID, $node) {
			phpQuery::$documents[$documentID]->eventsNodes[] = $node;
			return phpQuery::$documents[$documentID]->eventsNodes[
				count(phpQuery::$documents[$documentID]->eventsNodes)-1
			];
		}
		protected static function issetGlobal($documentID, $type) {
			return isset(phpQuery::$documents[$documentID])
				? in_array($type, phpQuery::$documents[$documentID]->eventsGlobal)
				: false;
		}
	}
}

interface ICallbackNamed {
	function hasName();
	function getName();
}
/**
 * Callback class introduces currying-like pattern.
 * 
 * Example:
 * function foo($param1, $param2, $param3) {
 *   var_dump($param1, $param2, $param3);
 * }
 * $fooCurried = new Callback('foo', 
 *   'param1 is now statically set', 
 *   new CallbackParam, new CallbackParam
 * );
 * phpQuery::callbackRun($fooCurried,
 * 	array('param2 value', 'param3 value'
 * );
 * 
 * Callback class is supported in all phpQuery methods which accepts callbacks. 
 *
 * @link http://code.google.com/p/phpquery/wiki/Callbacks#Param_Structures
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * 
 * @TODO??? return fake forwarding function created via create_function
 * @TODO honor paramStructure
 */
if (!class_exists('Callback')) {
	class Callback
		implements ICallbackNamed {
		public $callback = null;
		public $params = null;
		protected $name;
		public function __construct($callback, $param1 = null, $param2 = null, 
				$param3 = null) {
			$params = func_get_args();
			$params = array_slice($params, 1);
			if ($callback instanceof Callback) {
				// TODO implement recurention
			} else {
				$this->callback = $callback;
				$this->params = $params;
			}
		}
		public function getName() {
			return 'Callback: '.$this->name;
		}
		public function hasName() {
			return isset($this->name) && $this->name;
		}
		public function setName($name) {
			$this->name = $name;
			return $this;
		}
		// TODO test me
	//	public function addParams() {
	//		$params = func_get_args();
	//		return new Callback($this->callback, $this->params+$params);
	//	}
	}
}
/**
 * Shorthand for new Callback(create_function(...), ...);
 * 
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 */
if (!class_exists('CallbackBody')) {
	class CallbackBody extends Callback {
		public function __construct($paramList, $code, $param1 = null, $param2 = null, 
				$param3 = null) {
			$params = func_get_args();
			$params = array_slice($params, 2);
			$this->callback = create_function($paramList, $code);
			$this->params = $params;
		}
	}
}
/**
 * Callback type which on execution returns reference passed during creation.
 * 
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 */
if (!class_exists('CallbackReturnReference')) {
	class CallbackReturnReference extends Callback
		implements ICallbackNamed {
		protected $reference;
		public function __construct(&$reference, $name = null){
			$this->reference =& $reference;
			$this->callback = array($this, 'callback');
		}
		public function callback() {
			return $this->reference;
		}
		public function getName() {
			return 'Callback: '.$this->name;
		}
		public function hasName() {
			return isset($this->name) && $this->name;
		}
	}
}
/**
 * Callback type which on execution returns value passed during creation.
 * 
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 */
if (!class_exists('CallbackReturnValue')) {
	class CallbackReturnValue extends Callback
		implements ICallbackNamed {
		protected $value;
		protected $name;
		public function __construct($value, $name = null){
			$this->value =& $value;
			$this->name = $name;
			$this->callback = array($this, 'callback');
		}
		public function callback() {
			return $this->value;
		}
		public function __toString() {
			return $this->getName();
		}
		public function getName() {
			return 'Callback: '.$this->name;
		}
		public function hasName() {
			return isset($this->name) && $this->name;
		}
	}
}
/**
 * CallbackParameterToReference can be used when we don't really want a callback,
 * only parameter passed to it. CallbackParameterToReference takes first 
 * parameter's value and passes it to reference.
 *
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 */
if (!class_exists('CallbackParameterToReference')) {
	class CallbackParameterToReference extends Callback {
		/**
		 * @param $reference
		 * @TODO implement $paramIndex; 
		 * param index choose which callback param will be passed to reference
		 */
		public function __construct(&$reference){
			$this->callback =& $reference;
		}
	}
}
//class CallbackReference extends Callback {
//	/**
//	 *
//	 * @param $reference
//	 * @param $paramIndex
//	 * @todo implement $paramIndex; param index choose which callback param will be passed to reference
//	 */
//	public function __construct(&$reference, $name = null){
//		$this->callback =& $reference;
//	}
//}
if (!class_exists('CallbackParam')) {
	class CallbackParam {}
}

/**
 * Class representing phpQuery objects.
 *
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @package phpQuery
 * @method phpQueryObject clone() clone()
 * @method phpQueryObject empty() empty()
 * @method phpQueryObject next() next($selector = null)
 * @method phpQueryObject prev() prev($selector = null)
 * @property Int $length
 */
if (!class_exists('phpQueryObject')) {
	class phpQueryObject
		implements Iterator, Countable, ArrayAccess {
		public $documentID = null;
		/**
		 * DOMDocument class.
		 *
		 * @var DOMDocument
		 */
		public $document = null;
		public $charset = null;
		/**
		 *
		 * @var DOMDocumentWrapper
		 */
		public $documentWrapper = null;
		/**
		 * XPath interface.
		 *
		 * @var DOMXPath
		 */
		public $xpath = null;
		/**
		 * Stack of selected elements.
		 * @TODO refactor to ->nodes
		 * @var array
		 */
		public $elements = array();
		/**
		 * @access private
		 */
		protected $elementsBackup = array();
		/**
		 * @access private
		 */
		protected $previous = null;
		/**
		 * @access private
		 * @TODO deprecate
		 */
		protected $root = array();
		/**
		 * Indicated if doument is just a fragment (no <html> tag).
		 *
		 * Every document is realy a full document, so even documentFragments can
		 * be queried against <html>, but getDocument(id)->htmlOuter() will return
		 * only contents of <body>.
		 *
		 * @var bool
		 */
		public $documentFragment = true;
		/**
		 * Iterator interface helper
		 * @access private
		 */
		protected $elementsInterator = array();
		/**
		 * Iterator interface helper
		 * @access private
		 */
		protected $valid = false;
		/**
		 * Iterator interface helper
		 * @access private
		 */
		protected $current = null;
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function __construct($documentID) {
	//		if ($documentID instanceof self)
	//			var_dump($documentID->getDocumentID());
			$id = $documentID instanceof self
				? $documentID->getDocumentID()
				: $documentID;
	//		var_dump($id);
			if (! isset(phpQuery::$documents[$id] )) {
	//			var_dump(phpQuery::$documents);
				throw new Exception("Document with ID '{$id}' isn't loaded. Use phpQuery::newDocument(\$html) or phpQuery::newDocumentFile(\$file) first.");
			}
			$this->documentID = $id;
			$this->documentWrapper =& phpQuery::$documents[$id];
			$this->document =& $this->documentWrapper->document;
			$this->xpath =& $this->documentWrapper->xpath;
			$this->charset =& $this->documentWrapper->charset;
			$this->documentFragment =& $this->documentWrapper->isDocumentFragment;
			// TODO check $this->DOM->documentElement;
	//		$this->root = $this->document->documentElement;
			$this->root =& $this->documentWrapper->root;
	//		$this->toRoot();
			$this->elements = array($this->root);
		}
		/**
		 *
		 * @access private
		 * @param $attr
		 * @return unknown_type
		 */
		public function __get($attr) {
			switch($attr) {
				// FIXME doesnt work at all ?
				case 'length':
					return $this->size();
				break;
				default:
					return $this->$attr;
			}
		}
		/**
		 * Saves actual object to $var by reference.
		 * Useful when need to break chain.
		 * @param phpQueryObject $var
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function toReference(&$var) {
			return $var = $this;
		}
		public function documentFragment($state = null) {
			if ($state) {
				phpQuery::$documents[$this->getDocumentID()]['documentFragment'] = $state;
				return $this;
			}
			return $this->documentFragment;
		}
		/**
	   * @access private
	   * @TODO documentWrapper
		 */
		protected function isRoot( $node) {
	//		return $node instanceof DOMDOCUMENT || $node->tagName == 'html';
			return $node instanceof DOMDOCUMENT
				|| ($node instanceof DOMELEMENT && $node->tagName == 'html')
				|| $this->root->isSameNode($node);
		}
		/**
	   * @access private
		 */
		protected function stackIsRoot() {
			return $this->size() == 1 && $this->isRoot($this->elements[0]);
		}
		/**
		 * Enter description here...
		 * NON JQUERY METHOD
		 *
		 * Watch out, it doesn't creates new instance, can be reverted with end().
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function toRoot() {
			$this->elements = array($this->root);
			return $this;
	//		return $this->newInstance(array($this->root));
		}
		/**
		 * Saves object's DocumentID to $var by reference.
		 * <code>
		 * $myDocumentId;
		 * phpQuery::newDocument('<div/>')
		 *     ->getDocumentIDRef($myDocumentId)
		 *     ->find('div')->...
		 * </code>
		 *
		 * @param unknown_type $domId
		 * @see phpQuery::newDocument
		 * @see phpQuery::newDocumentFile
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function getDocumentIDRef(&$documentID) {
			$documentID = $this->getDocumentID();
			return $this;
		}
		/**
		 * Returns object with stack set to document root.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function getDocument() {
			return phpQuery::getDocument($this->getDocumentID());
		}
		/**
		 *
		 * @return DOMDocument
		 */
		public function getDOMDocument() {
			return $this->document;
		}
		/**
		 * Get object's Document ID.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function getDocumentID() {
			return $this->documentID;
		}
		/**
		 * Unloads whole document from memory.
		 * CAUTION! None further operations will be possible on this document.
		 * All objects refering to it will be useless.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function unloadDocument() {
			phpQuery::unloadDocuments($this->getDocumentID());
		}
		public function isHTML() {
			return $this->documentWrapper->isHTML;
		}
		public function isXHTML() {
			return $this->documentWrapper->isXHTML;
		}
		public function isXML() {
			return $this->documentWrapper->isXML;
		}
		/**
		 * Enter description here...
		 *
		 * @link http://docs.jquery.com/Ajax/serialize
		 * @return string
		 */
		public function serialize() {
			return phpQuery::param($this->serializeArray());
		}
		/**
		 * Enter description here...
		 *
		 * @link http://docs.jquery.com/Ajax/serializeArray
		 * @return array
		 */
		public function serializeArray($submit = null) {
			$source = $this->filter('form, input, select, textarea')
				->find('input, select, textarea')
				->andSelf()
				->not('form');
			$return = array();
	//		$source->dumpDie();
			foreach($source as $input) {
				$input = phpQuery::pq($input);
				if ($input->is('[disabled]'))
					continue;
				if (!$input->is('[name]'))
					continue;
				if ($input->is('[type=checkbox]') && !$input->is('[checked]'))
					continue;
				// jquery diff
				if ($submit && $input->is('[type=submit]')) {
					if ($submit instanceof DOMELEMENT && ! $input->elements[0]->isSameNode($submit))
						continue;
					else if (is_string($submit) && $input->attr('name') != $submit)
						continue;
				}
				$return[] = array(
					'name' => $input->attr('name'),
					'value' => $input->val(),
				);
			}
			return $return;
		}
		/**
		 * @access private
		 */
		protected function debug($in) {
			if (! phpQuery::$debug )
				return;
			print('<pre>');
			print_r($in);
			// file debug
	//		file_put_contents(dirname(__FILE__).'/phpQuery.log', print_r($in, true)."\n", FILE_APPEND);
			// quite handy debug trace
	//		if ( is_array($in))
	//			print_r(array_slice(debug_backtrace(), 3));
			print("</pre>\n");
		}
		/**
		 * @access private
		 */
		protected function isRegexp($pattern) {
			return in_array(
				$pattern[ mb_strlen($pattern)-1 ],
				array('^','*','$')
			);
		}
		/**
		 * Determines if $char is really a char.
		 *
		 * @param string $char
		 * @return bool
		 * @todo rewrite me to charcode range ! ;)
		 * @access private
		 */
		protected function isChar($char) {
			return extension_loaded('mbstring') && phpQuery::$mbstringSupport
				? mb_eregi('\w', $char)
				: preg_match('@\w@', $char);
		}
		/**
		 * @access private
		 */
		protected function parseSelector($query) {
			// clean spaces
			// TODO include this inside parsing ?
			$query = trim(
				preg_replace('@\s+@', ' ',
					preg_replace('@\s*(>|\\+|~)\s*@', '\\1', $query)
				)
			);
			$queries = array(array());
			if (! $query)
				return $queries;
			$return =& $queries[0];
			$specialChars = array('>',' ');
	//		$specialCharsMapping = array('/' => '>');
			$specialCharsMapping = array();
			$strlen = mb_strlen($query);
			$classChars = array('.', '-');
			$pseudoChars = array('-');
			$tagChars = array('*', '|', '-');
			// split multibyte string
			// http://code.google.com/p/phpquery/issues/detail?id=76
			$_query = array();
			for ($i=0; $i<$strlen; $i++)
				$_query[] = mb_substr($query, $i, 1);
			$query = $_query;
			// it works, but i dont like it...
			$i = 0;
			while( $i < $strlen) {
				$c = $query[$i];
				$tmp = '';
				// TAG
				if ($this->isChar($c) || in_array($c, $tagChars)) {
					while(isset($query[$i])
						&& ($this->isChar($query[$i]) || in_array($query[$i], $tagChars))) {
						$tmp .= $query[$i];
						$i++;
					}
					$return[] = $tmp;
				// IDs
				} else if ( $c == '#') {
					$i++;
					while( isset($query[$i]) && ($this->isChar($query[$i]) || $query[$i] == '-')) {
						$tmp .= $query[$i];
						$i++;
					}
					$return[] = '#'.$tmp;
				// SPECIAL CHARS
				} else if (in_array($c, $specialChars)) {
					$return[] = $c;
					$i++;
				// MAPPED SPECIAL MULTICHARS
	//			} else if ( $c.$query[$i+1] == '//') {
	//				$return[] = ' ';
	//				$i = $i+2;
				// MAPPED SPECIAL CHARS
				} else if ( isset($specialCharsMapping[$c])) {
					$return[] = $specialCharsMapping[$c];
					$i++;
				// COMMA
				} else if ( $c == ',') {
					$queries[] = array();
					$return =& $queries[ count($queries)-1 ];
					$i++;
					while( isset($query[$i]) && $query[$i] == ' ')
						$i++;
				// CLASSES
				} else if ($c == '.') {
					while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $classChars))) {
						$tmp .= $query[$i];
						$i++;
					}
					$return[] = $tmp;
				// ~ General Sibling Selector
				} else if ($c == '~') {
					$spaceAllowed = true;
					$tmp .= $query[$i++];
					while( isset($query[$i])
						&& ($this->isChar($query[$i])
							|| in_array($query[$i], $classChars)
							|| $query[$i] == '*'
							|| ($query[$i] == ' ' && $spaceAllowed)
						)) {
						if ($query[$i] != ' ')
							$spaceAllowed = false;
						$tmp .= $query[$i];
						$i++;
					}
					$return[] = $tmp;
				// + Adjacent sibling selectors
				} else if ($c == '+') {
					$spaceAllowed = true;
					$tmp .= $query[$i++];
					while( isset($query[$i])
						&& ($this->isChar($query[$i])
							|| in_array($query[$i], $classChars)
							|| $query[$i] == '*'
							|| ($spaceAllowed && $query[$i] == ' ')
						)) {
						if ($query[$i] != ' ')
							$spaceAllowed = false;
						$tmp .= $query[$i];
						$i++;
					}
					$return[] = $tmp;
				// ATTRS
				} else if ($c == '[') {
					$stack = 1;
					$tmp .= $c;
					while( isset($query[++$i])) {
						$tmp .= $query[$i];
						if ( $query[$i] == '[') {
							$stack++;
						} else if ( $query[$i] == ']') {
							$stack--;
							if (! $stack )
								break;
						}
					}
					$return[] = $tmp;
					$i++;
				// PSEUDO CLASSES
				} else if ($c == ':') {
					$stack = 1;
					$tmp .= $query[$i++];
					while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $pseudoChars))) {
						$tmp .= $query[$i];
						$i++;
					}
					// with arguments ?
					if ( isset($query[$i]) && $query[$i] == '(') {
						$tmp .= $query[$i];
						$stack = 1;
						while( isset($query[++$i])) {
							$tmp .= $query[$i];
							if ( $query[$i] == '(') {
								$stack++;
							} else if ( $query[$i] == ')') {
								$stack--;
								if (! $stack )
									break;
							}
						}
						$return[] = $tmp;
						$i++;
					} else {
						$return[] = $tmp;
					}
				} else {
					$i++;
				}
			}
			foreach($queries as $k => $q) {
				if (isset($q[0])) {
					if (isset($q[0][0]) && $q[0][0] == ':')
						array_unshift($queries[$k], '*');
					if ($q[0] != '>')
						array_unshift($queries[$k], ' ');
				}
			}
			return $queries;
		}
		/**
		 * Return matched DOM nodes.
		 *
		 * @param int $index
		 * @return array|DOMElement Single DOMElement or array of DOMElement.
		 */
		public function get($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			$return = isset($index)
				? (isset($this->elements[$index]) ? $this->elements[$index] : null)
				: $this->elements;
			// pass thou callbacks
			$args = func_get_args();
			$args = array_slice($args, 1);
			foreach($args as $callback) {
				if (is_array($return))
					foreach($return as $k => $v)
						$return[$k] = phpQuery::callbackRun($callback, array($v));
				else
					$return = phpQuery::callbackRun($callback, array($return));
			}
			return $return;
		}
		/**
		 * Return matched DOM nodes.
		 * jQuery difference.
		 *
		 * @param int $index
		 * @return array|string Returns string if $index != null
		 * @todo implement callbacks
		 * @todo return only arrays ?
		 * @todo maybe other name...
		 */
		public function getString($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			if ($index)
				$return = $this->eq($index)->text();
			else {
				$return = array();
				for($i = 0; $i < $this->size(); $i++) {
					$return[] = $this->eq($i)->text();
				}
			}
			// pass thou callbacks
			$args = func_get_args();
			$args = array_slice($args, 1);
			foreach($args as $callback) {
				$return = phpQuery::callbackRun($callback, array($return));
			}
			return $return;
		}
		/**
		 * Return matched DOM nodes.
		 * jQuery difference.
		 *
		 * @param int $index
		 * @return array|string Returns string if $index != null
		 * @todo implement callbacks
		 * @todo return only arrays ?
		 * @todo maybe other name...
		 */
		public function getStrings($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			if ($index)
				$return = $this->eq($index)->text();
			else {
				$return = array();
				for($i = 0; $i < $this->size(); $i++) {
					$return[] = $this->eq($i)->text();
				}
				// pass thou callbacks
				$args = func_get_args();
				$args = array_slice($args, 1);
			}
			foreach($args as $callback) {
				if (is_array($return))
					foreach($return as $k => $v)
						$return[$k] = phpQuery::callbackRun($callback, array($v));
				else
					$return = phpQuery::callbackRun($callback, array($return));
			}
			return $return;
		}
		/**
		 * Returns new instance of actual class.
		 *
		 * @param array $newStack Optional. Will replace old stack with new and move old one to history.c
		 */
		public function newInstance($newStack = null) {
			$class = get_class($this);
			// support inheritance by passing old object to overloaded constructor
			$new = $class != 'phpQuery'
				? new $class($this, $this->getDocumentID())
				: new phpQueryObject($this->getDocumentID());
			$new->previous = $this;
			if (is_null($newStack)) {
				$new->elements = $this->elements;
				if ($this->elementsBackup)
					$this->elements = $this->elementsBackup;
			} else if (is_string($newStack)) {
				$new->elements = phpQuery::pq($newStack, $this->getDocumentID())->stack();
			} else {
				$new->elements = $newStack;
			}
			return $new;
		}
		/**
		 * Enter description here...
		 *
		 * In the future, when PHP will support XLS 2.0, then we would do that this way:
		 * contains(tokenize(@class, '\s'), "something")
		 * @param unknown_type $class
		 * @param unknown_type $node
		 * @return boolean
		 * @access private
		 */
		protected function matchClasses($class, $node) {
			// multi-class
			if ( mb_strpos($class, '.', 1)) {
				$classes = explode('.', substr($class, 1));
				$classesCount = count( $classes );
				$nodeClasses = explode(' ', $node->getAttribute('class') );
				$nodeClassesCount = count( $nodeClasses );
				if ( $classesCount > $nodeClassesCount )
					return false;
				$diff = count(
					array_diff(
						$classes,
						$nodeClasses
					)
				);
				if (! $diff )
					return true;
			// single-class
			} else {
				return in_array(
					// strip leading dot from class name
					substr($class, 1),
					// get classes for element as array
					explode(' ', $node->getAttribute('class') )
				);
			}
		}
		/**
		 * @access private
		 */
		protected function runQuery($XQuery, $selector = null, $compare = null) {
			if ($compare && ! method_exists($this, $compare))
				return false;
			$stack = array();
			if (! $this->elements)
				$this->debug('Stack empty, skipping...');
	//		var_dump($this->elements[0]->nodeType);
			// element, document
			foreach($this->stack(array(1, 9, 13)) as $k => $stackNode) {
				$detachAfter = false;
				// to work on detached nodes we need temporary place them somewhere
				// thats because context xpath queries sucks ;]
				$testNode = $stackNode;
				while ($testNode) {
					if (! $testNode->parentNode && ! $this->isRoot($testNode)) {
						$this->root->appendChild($testNode);
						$detachAfter = $testNode;
						break;
					}
					$testNode = isset($testNode->parentNode)
						? $testNode->parentNode
						: null;
				}
				// XXX tmp ?
				$xpath = $this->documentWrapper->isXHTML
					? $this->getNodeXpath($stackNode, 'html')
					: $this->getNodeXpath($stackNode);
				// FIXME pseudoclasses-only query, support XML
				$query = $XQuery == '//' && $xpath == '/html[1]'
					? '//*'
					: $xpath.$XQuery;
				$this->debug("XPATH: {$query}");
				// run query, get elements
				$nodes = $this->xpath->query($query);
				$this->debug("QUERY FETCHED");
				if (! $nodes->length )
					$this->debug('Nothing found');
				$debug = array();
				foreach($nodes as $node) {
					$matched = false;
					if ( $compare) {
						phpQuery::$debug ?
							$this->debug("Found: ".$this->whois( $node ).", comparing with {$compare}()")
							: null;
						$phpQueryDebug = phpQuery::$debug;
						phpQuery::$debug = false;
						// TODO ??? use phpQuery::callbackRun()
						if (call_user_func_array(array($this, $compare), array($selector, $node)))
							$matched = true;
						phpQuery::$debug = $phpQueryDebug;
					} else {
						$matched = true;
					}
					if ( $matched) {
						if (phpQuery::$debug)
							$debug[] = $this->whois( $node );
						$stack[] = $node;
					}
				}
				if (phpQuery::$debug) {
					$this->debug("Matched ".count($debug).": ".implode(', ', $debug));
				}
				if ($detachAfter)
					$this->root->removeChild($detachAfter);
			}
			$this->elements = $stack;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function find($selectors, $context = null, $noHistory = false) {
			if (!$noHistory)
				// backup last stack /for end()/
				$this->elementsBackup = $this->elements;
			// allow to define context
			// TODO combine code below with phpQuery::pq() context guessing code
			//   as generic function
			if ($context) {
				if (! is_array($context) && $context instanceof DOMELEMENT)
					$this->elements = array($context);
				else if (is_array($context)) {
					$this->elements = array();
					foreach ($context as $c)
						if ($c instanceof DOMELEMENT)
							$this->elements[] = $c;
				} else if ( $context instanceof self )
					$this->elements = $context->elements;
			}
			$queries = $this->parseSelector($selectors);
			$this->debug(array('FIND', $selectors, $queries));
			$XQuery = '';
			// remember stack state because of multi-queries
			$oldStack = $this->elements;
			// here we will be keeping found elements
			$stack = array();
			foreach($queries as $selector) {
				$this->elements = $oldStack;
				$delimiterBefore = false;
				foreach($selector as $s) {
					// TAG
					$isTag = extension_loaded('mbstring') && phpQuery::$mbstringSupport
						? mb_ereg_match('^[\w|\||-]+$', $s) || $s == '*'
						: preg_match('@^[\w|\||-]+$@', $s) || $s == '*';
					if ($isTag) {
						if ($this->isXML()) {
							// namespace support
							if (mb_strpos($s, '|') !== false) {
								$ns = $tag = null;
								list($ns, $tag) = explode('|', $s);
								$XQuery .= "$ns:$tag";
							} else if ($s == '*') {
								$XQuery .= "*";
							} else {
								$XQuery .= "*[local-name()='$s']";
							}
						} else {
							$XQuery .= $s;
						}
					// ID
					} else if ($s[0] == '#') {
						if ($delimiterBefore)
							$XQuery .= '*';
						$XQuery .= "[@id='".substr($s, 1)."']";
					// ATTRIBUTES
					} else if ($s[0] == '[') {
						if ($delimiterBefore)
							$XQuery .= '*';
						// strip side brackets
						$attr = trim($s, '][');
						$execute = false;
						// attr with specifed value
						if (mb_strpos($s, '=')) {
							$value = null;
							list($attr, $value) = explode('=', $attr);
							$value = trim($value, "'\"");
							if ($this->isRegexp($attr)) {
								// cut regexp character
								$attr = substr($attr, 0, -1);
								$execute = true;
								$XQuery .= "[@{$attr}]";
							} else {
								$XQuery .= "[@{$attr}='{$value}']";
							}
						// attr without specified value
						} else {
							$XQuery .= "[@{$attr}]";
						}
						if ($execute) {
							$this->runQuery($XQuery, $s, 'is');
							$XQuery = '';
							if (! $this->length())
								break;
						}
					// CLASSES
					} else if ($s[0] == '.') {
						// TODO use return $this->find("./self::*[contains(concat(\" \",@class,\" \"), \" $class \")]");
						// thx wizDom ;)
						if ($delimiterBefore)
							$XQuery .= '*';
						$XQuery .= '[@class]';
						$this->runQuery($XQuery, $s, 'matchClasses');
						$XQuery = '';
						if (! $this->length() )
							break;
					// ~ General Sibling Selector
					} else if ($s[0] == '~') {
						$this->runQuery($XQuery);
						$XQuery = '';
						$this->elements = $this
							->siblings(
								substr($s, 1)
							)->elements;
						if (! $this->length() )
							break;
					// + Adjacent sibling selectors
					} else if ($s[0] == '+') {
						// TODO /following-sibling::
						$this->runQuery($XQuery);
						$XQuery = '';
						$subSelector = substr($s, 1);
						$subElements = $this->elements;
						$this->elements = array();
						foreach($subElements as $node) {
							// search first DOMElement sibling
							$test = $node->nextSibling;
							while($test && ! ($test instanceof DOMELEMENT))
								$test = $test->nextSibling;
							if ($test && $this->is($subSelector, $test))
								$this->elements[] = $test;
						}
						if (! $this->length() )
							break;
					// PSEUDO CLASSES
					} else if ($s[0] == ':') {
						// TODO optimization for :first :last
						if ($XQuery) {
							$this->runQuery($XQuery);
							$XQuery = '';
						}
						if (! $this->length())
							break;
						$this->pseudoClasses($s);
						if (! $this->length())
							break;
					// DIRECT DESCENDANDS
					} else if ($s == '>') {
						$XQuery .= '/';
						$delimiterBefore = 2;
					// ALL DESCENDANDS
					} else if ($s == ' ') {
						$XQuery .= '//';
						$delimiterBefore = 2;
					// ERRORS
					} else {
						phpQuery::debug("Unrecognized token '$s'");
					}
					$delimiterBefore = $delimiterBefore === 2;
				}
				// run query if any
				if ($XQuery && $XQuery != '//') {
					$this->runQuery($XQuery);
					$XQuery = '';
				}
				foreach($this->elements as $node)
					if (! $this->elementsContainsNode($node, $stack))
						$stack[] = $node;
			}
			$this->elements = $stack;
			return $this->newInstance();
		}
		/**
		 * @todo create API for classes with pseudoselectors
		 * @access private
		 */
		protected function pseudoClasses($class) {
			// TODO clean args parsing ?
			$class = ltrim($class, ':');
			$haveArgs = mb_strpos($class, '(');
			if ($haveArgs !== false) {
				$args = substr($class, $haveArgs+1, -1);
				$class = substr($class, 0, $haveArgs);
			}
			switch($class) {
				case 'even':
				case 'odd':
					$stack = array();
					foreach($this->elements as $i => $node) {
						if ($class == 'even' && ($i%2) == 0)
							$stack[] = $node;
						else if ( $class == 'odd' && $i % 2 )
							$stack[] = $node;
					}
					$this->elements = $stack;
					break;
				case 'eq':
					$k = intval($args);
					$this->elements = isset( $this->elements[$k] )
						? array( $this->elements[$k] )
						: array();
					break;
				case 'gt':
					$this->elements = array_slice($this->elements, $args+1);
					break;
				case 'lt':
					$this->elements = array_slice($this->elements, 0, $args+1);
					break;
				case 'first':
					if (isset($this->elements[0]))
						$this->elements = array($this->elements[0]);
					break;
				case 'last':
					if ($this->elements)
						$this->elements = array($this->elements[count($this->elements)-1]);
					break;
				/*case 'parent':
					$stack = array();
					foreach($this->elements as $node) {
						if ( $node->childNodes->length )
							$stack[] = $node;
					}
					$this->elements = $stack;
					break;*/
				case 'contains':
					$text = trim($args, "\"'");
					$stack = array();
					foreach($this->elements as $node) {
						if (mb_stripos($node->textContent, $text) === false)
							continue;
						$stack[] = $node;
					}
					$this->elements = $stack;
					break;
				case 'not':
					$selector = self::unQuote($args);
					$this->elements = $this->not($selector)->stack();
					break;
				case 'slice':
					// TODO jQuery difference ?
					$args = explode(',',
						str_replace(', ', ',', trim($args, "\"'"))
					);
					$start = $args[0];
					$end = isset($args[1])
						? $args[1]
						: null;
					if ($end > 0)
						$end = $end-$start;
					$this->elements = array_slice($this->elements, $start, $end);
					break;
				case 'has':
					$selector = trim($args, "\"'");
					$stack = array();
					foreach($this->stack(1) as $el) {
						if ($this->find($selector, $el, true)->length)
							$stack[] = $el;
					}
					$this->elements = $stack;
					break;
				case 'submit':
				case 'reset':
					$this->elements = phpQuery::merge(
						$this->map(array($this, 'is'),
							"input[type=$class]", new CallbackParam()
						),
						$this->map(array($this, 'is'),
							"button[type=$class]", new CallbackParam()
						)
					);
				break;
	//				$stack = array();
	//				foreach($this->elements as $node)
	//					if ($node->is('input[type=submit]') || $node->is('button[type=submit]'))
	//						$stack[] = $el;
	//				$this->elements = $stack;
				case 'input':
					$this->elements = $this->map(
						array($this, 'is'),
						'input', new CallbackParam()
					)->elements;
				break;
				case 'password':
				case 'checkbox':
				case 'radio':
				case 'hidden':
				case 'image':
				case 'file':
					$this->elements = $this->map(
						array($this, 'is'),
						"input[type=$class]", new CallbackParam()
					)->elements;
				break;
				case 'parent':
					$this->elements = $this->map(
						create_function('$node', '
							return $node instanceof DOMELEMENT && $node->childNodes->length
								? $node : null;')
					)->elements;
				break;
				case 'empty':
					$this->elements = $this->map(
						create_function('$node', '
							return $node instanceof DOMELEMENT && $node->childNodes->length
								? null : $node;')
					)->elements;
				break;
				case 'disabled':
				case 'selected':
				case 'checked':
					$this->elements = $this->map(
						array($this, 'is'),
						"[$class]", new CallbackParam()
					)->elements;
				break;
				case 'enabled':
					$this->elements = $this->map(
						create_function('$node', '
							return pq($node)->not(":disabled") ? $node : null;')
					)->elements;
				break;
				case 'header':
					$this->elements = $this->map(
						create_function('$node',
							'$isHeader = isset($node->tagName) && in_array($node->tagName, array(
								"h1", "h2", "h3", "h4", "h5", "h6", "h7"
							));
							return $isHeader
								? $node
								: null;')
					)->elements;
	//				$this->elements = $this->map(
	//					create_function('$node', '$node = pq($node);
	//						return $node->is("h1")
	//							|| $node->is("h2")
	//							|| $node->is("h3")
	//							|| $node->is("h4")
	//							|| $node->is("h5")
	//							|| $node->is("h6")
	//							|| $node->is("h7")
	//							? $node
	//							: null;')
	//				)->elements;
				break;
				case 'only-child':
					$this->elements = $this->map(
						create_function('$node',
							'return pq($node)->siblings()->size() == 0 ? $node : null;')
					)->elements;
				break;
				case 'first-child':
					$this->elements = $this->map(
						create_function('$node', 'return pq($node)->prevAll()->size() == 0 ? $node : null;')
					)->elements;
				break;
				case 'last-child':
					$this->elements = $this->map(
						create_function('$node', 'return pq($node)->nextAll()->size() == 0 ? $node : null;')
					)->elements;
				break;
				case 'nth-child':
					$param = trim($args, "\"'");
					if (! $param)
						break;
						// nth-child(n+b) to nth-child(1n+b)
					if ($param{0} == 'n')
						$param = '1'.$param;
					// :nth-child(index/even/odd/equation)
					if ($param == 'even' || $param == 'odd')
						$mapped = $this->map(
							create_function('$node, $param',
								'$index = pq($node)->prevAll()->size()+1;
								if ($param == "even" && ($index%2) == 0)
									return $node;
								else if ($param == "odd" && $index%2 == 1)
									return $node;
								else
									return null;'),
							new CallbackParam(), $param
						);
					else if (mb_strlen($param) > 1 && $param{1} == 'n')
						// an+b
						$mapped = $this->map(
							create_function('$node, $param',
								'$prevs = pq($node)->prevAll()->size();
								$index = 1+$prevs;
								$b = mb_strlen($param) > 3
									? $param{3}
									: 0;
								$a = $param{0};
								if ($b && $param{2} == "-")
									$b = -$b;
								if ($a > 0) {
									return ($index-$b)%$a == 0
										? $node
										: null;
									phpQuery::debug($a."*".floor($index/$a)."+$b-1 == ".($a*floor($index/$a)+$b-1)." ?= $prevs");
									return $a*floor($index/$a)+$b-1 == $prevs
											? $node
											: null;
								} else if ($a == 0)
									return $index == $b
											? $node
											: null;
								else
									// negative value
									return $index <= $b
											? $node
											: null;
	//							if (! $b)
	//								return $index%$a == 0
	//									? $node
	//									: null;
	//							else
	//								return ($index-$b)%$a == 0
	//									? $node
	//									: null;
								'),
							new CallbackParam(), $param
						);
					else
						// index
						$mapped = $this->map(
							create_function('$node, $index',
								'$prevs = pq($node)->prevAll()->size();
								if ($prevs && $prevs == $index-1)
									return $node;
								else if (! $prevs && $index == 1)
									return $node;
								else
									return null;'),
							new CallbackParam(), $param
						);
					$this->elements = $mapped->elements;
				break;
				default:
					$this->debug("Unknown pseudoclass '{$class}', skipping...");
			}
		}
		/**
		 * @access private
		 */
		protected function __pseudoClassParam($paramsString) {
			// TODO;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function is($selector, $nodes = null) {
			phpQuery::debug(array("Is:", $selector));
			if (! $selector)
				return false;
			$oldStack = $this->elements;
			$returnArray = false;
			if ($nodes && is_array($nodes)) {
				$this->elements = $nodes;
			} else if ($nodes)
				$this->elements = array($nodes);
			$this->filter($selector, true);
			$stack = $this->elements;
			$this->elements = $oldStack;
			if ($nodes)
				return $stack ? $stack : null;
			return (bool)count($stack);
		}
		/**
		 * Enter description here...
		 * jQuery difference.
		 *
		 * Callback:
		 * - $index int
		 * - $node DOMNode
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @link http://docs.jquery.com/Traversing/filter
		 */
		public function filterCallback($callback, $_skipHistory = false) {
			if (! $_skipHistory) {
				$this->elementsBackup = $this->elements;
				$this->debug("Filtering by callback");
			}
			$newStack = array();
			foreach($this->elements as $index => $node) {
				$result = phpQuery::callbackRun($callback, array($index, $node));
				if (is_null($result) || (! is_null($result) && $result))
					$newStack[] = $node;
			}
			$this->elements = $newStack;
			return $_skipHistory
				? $this
				: $this->newInstance();
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @link http://docs.jquery.com/Traversing/filter
		 */
		public function filter($selectors, $_skipHistory = false) {
			if ($selectors instanceof Callback OR $selectors instanceof Closure)
				return $this->filterCallback($selectors, $_skipHistory);
			if (! $_skipHistory)
				$this->elementsBackup = $this->elements;
			$notSimpleSelector = array(' ', '>', '~', '+', '/');
			if (! is_array($selectors))
				$selectors = $this->parseSelector($selectors);
			if (! $_skipHistory)
				$this->debug(array("Filtering:", $selectors));
			$finalStack = array();
			foreach($selectors as $selector) {
				$stack = array();
				if (! $selector)
					break;
				// avoid first space or /
				if (in_array($selector[0], $notSimpleSelector))
					$selector = array_slice($selector, 1);
				// PER NODE selector chunks
				foreach($this->stack() as $node) {
					$break = false;
					foreach($selector as $s) {
						if (!($node instanceof DOMELEMENT)) {
							// all besides DOMElement
							if ( $s[0] == '[') {
								$attr = trim($s, '[]');
								if ( mb_strpos($attr, '=')) {
									list( $attr, $val ) = explode('=', $attr);
									if ($attr == 'nodeType' && $node->nodeType != $val)
										$break = true;
								}
							} else
								$break = true;
						} else {
							// DOMElement only
							// ID
							if ( $s[0] == '#') {
								if ( $node->getAttribute('id') != substr($s, 1) )
									$break = true;
							// CLASSES
							} else if ( $s[0] == '.') {
								if (! $this->matchClasses( $s, $node ) )
									$break = true;
							// ATTRS
							} else if ( $s[0] == '[') {
								// strip side brackets
								$attr = trim($s, '[]');
								if (mb_strpos($attr, '=')) {
									list($attr, $val) = explode('=', $attr);
									$val = self::unQuote($val);
									if ($attr == 'nodeType') {
										if ($val != $node->nodeType)
											$break = true;
									} else if ($this->isRegexp($attr)) {
										$val = extension_loaded('mbstring') && phpQuery::$mbstringSupport
											? quotemeta(trim($val, '"\''))
											: preg_quote(trim($val, '"\''), '@');
										// switch last character
										switch( substr($attr, -1)) {
											// quotemeta used insted of preg_quote
											// http://code.google.com/p/phpquery/issues/detail?id=76
											case '^':
												$pattern = '^'.$val;
												break;
											case '*':
												$pattern = '.*'.$val.'.*';
												break;
											case '$':
												$pattern = '.*'.$val.'$';
												break;
										}
										// cut last character
										$attr = substr($attr, 0, -1);
										$isMatch = extension_loaded('mbstring') && phpQuery::$mbstringSupport
											? mb_ereg_match($pattern, $node->getAttribute($attr))
											: preg_match("@{$pattern}@", $node->getAttribute($attr));
										if (! $isMatch)
											$break = true;
									} else if ($node->getAttribute($attr) != $val)
										$break = true;
								} else if (! $node->hasAttribute($attr))
									$break = true;
							// PSEUDO CLASSES
							} else if ( $s[0] == ':') {
								// skip
							// TAG
							} else if (trim($s)) {
								if ($s != '*') {
									// TODO namespaces
									if (isset($node->tagName)) {
										if ($node->tagName != $s)
											$break = true;
									} else if ($s == 'html' && ! $this->isRoot($node))
										$break = true;
								}
							// AVOID NON-SIMPLE SELECTORS
							} else if (in_array($s, $notSimpleSelector)) {
								$break = true;
								$this->debug(array('Skipping non simple selector', $selector));
							}
						}
						if ($break)
							break;
					}
					// if element passed all chunks of selector - add it to new stack
					if (! $break )
						$stack[] = $node;
				}
				$tmpStack = $this->elements;
				$this->elements = $stack;
				// PER ALL NODES selector chunks
				foreach($selector as $s)
					// PSEUDO CLASSES
					if ($s[0] == ':')
						$this->pseudoClasses($s);
				foreach($this->elements as $node)
					// XXX it should be merged without duplicates
					// but jQuery doesnt do that
					$finalStack[] = $node;
				$this->elements = $tmpStack;
			}
			$this->elements = $finalStack;
			if ($_skipHistory) {
				return $this;
			} else {
				$this->debug("Stack length after filter(): ".count($finalStack));
				return $this->newInstance();
			}
		}
		/**
		 *
		 * @param $value
		 * @return unknown_type
		 * @TODO implement in all methods using passed parameters
		 */
		protected static function unQuote($value) {
			return $value[0] == '\'' || $value[0] == '"'
				? substr($value, 1, -1)
				: $value;
		}
		/**
		 * Enter description here...
		 *
		 * @link http://docs.jquery.com/Ajax/load
		 * @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo Support $selector
		 */
		public function load($url, $data = null, $callback = null) {
			if ($data && ! is_array($data)) {
				$callback = $data;
				$data = null;
			}
			if (mb_strpos($url, ' ') !== false) {
				$matches = null;
				if (extension_loaded('mbstring') && phpQuery::$mbstringSupport)
					mb_ereg('^([^ ]+) (.*)$', $url, $matches);
				else
					preg_match('^([^ ]+) (.*)$', $url, $matches);
				$url = $matches[1];
				$selector = $matches[2];
				// FIXME this sucks, pass as callback param
				$this->_loadSelector = $selector;
			}
			$ajax = array(
				'url' => $url,
				'type' => $data ? 'POST' : 'GET',
				'data' => $data,
				'complete' => $callback,
				'success' => array($this, '__loadSuccess')
			);
			phpQuery::ajax($ajax);
			return $this;
		}
		/**
		 * @access private
		 * @param $html
		 * @return unknown_type
		 */
		public function __loadSuccess($html) {
			if ($this->_loadSelector) {
				$html = phpQuery::newDocument($html)->find($this->_loadSelector);
				unset($this->_loadSelector);
			}
			foreach($this->stack(1) as $node) {
				phpQuery::pq($node, $this->getDocumentID())
					->markup($html);
			}
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo
		 */
		public function css() {
			// TODO
			return $this;
		}
		/**
		 * @todo
		 *
		 */
		public function show(){
			// TODO
			return $this;
		}
		/**
		 * @todo
		 *
		 */
		public function hide(){
			// TODO
			return $this;
		}
		/**
		 * Trigger a type of event on every matched element.
		 *
		 * @param unknown_type $type
		 * @param unknown_type $data
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @TODO support more than event in $type (space-separated)
		 */
		public function trigger($type, $data = array()) {
			foreach($this->elements as $node)
				phpQueryEvents::trigger($this->getDocumentID(), $type, $data, $node);
			return $this;
		}
		/**
		 * This particular method triggers all bound event handlers on an element (for a specific event type) WITHOUT executing the browsers default actions.
		 *
		 * @param unknown_type $type
		 * @param unknown_type $data
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @TODO
		 */
		public function triggerHandler($type, $data = array()) {
			// TODO;
		}
		/**
		 * Binds a handler to one or more events (like click) for each matched element.
		 * Can also bind custom events.
		 *
		 * @param unknown_type $type
		 * @param unknown_type $data Optional
		 * @param unknown_type $callback
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @TODO support '!' (exclusive) events
		 * @TODO support more than event in $type (space-separated)
		 */
		public function bind($type, $data, $callback = null) {
			// TODO check if $data is callable, not using is_callable
			if (! isset($callback)) {
				$callback = $data;
				$data = null;
			}
			foreach($this->elements as $node)
				phpQueryEvents::add($this->getDocumentID(), $node, $type, $data, $callback);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @param unknown_type $type
		 * @param unknown_type $callback
		 * @return unknown
		 * @TODO namespace events
		 * @TODO support more than event in $type (space-separated)
		 */
		public function unbind($type = null, $callback = null) {
			foreach($this->elements as $node)
				phpQueryEvents::remove($this->getDocumentID(), $node, $type, $callback);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function change($callback = null) {
			if ($callback)
				return $this->bind('change', $callback);
			return $this->trigger('change');
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function submit($callback = null) {
			if ($callback)
				return $this->bind('submit', $callback);
			return $this->trigger('submit');
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function click($callback = null) {
			if ($callback)
				return $this->bind('click', $callback);
			return $this->trigger('click');
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrapAllOld($wrapper) {
			$wrapper = pq($wrapper)->_clone();
			if (! $wrapper->length() || ! $this->length() )
				return $this;
			$wrapper->insertBefore($this->elements[0]);
			$deepest = $wrapper->elements[0];
			while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
				$deepest = $deepest->firstChild;
			pq($deepest)->append($this);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * TODO testme...
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrapAll($wrapper) {
			if (! $this->length())
				return $this;
			return phpQuery::pq($wrapper, $this->getDocumentID())
				->clone()
				->insertBefore($this->get(0))
				->map(array($this, '___wrapAllCallback'))
				->append($this);
		}
	  /**
	   *
		 * @param $node
		 * @return unknown_type
		 * @access private
	   */
		public function ___wrapAllCallback($node) {
			$deepest = $node;
			while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
				$deepest = $deepest->firstChild;
			return $deepest;
		}
		/**
		 * Enter description here...
		 * NON JQUERY METHOD
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrapAllPHP($codeBefore, $codeAfter) {
			return $this
				->slice(0, 1)
					->beforePHP($codeBefore)
				->end()
				->slice(-1)
					->afterPHP($codeAfter)
				->end();
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrap($wrapper) {
			foreach($this->stack() as $node)
				phpQuery::pq($node, $this->getDocumentID())->wrapAll($wrapper);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrapPHP($codeBefore, $codeAfter) {
			foreach($this->stack() as $node)
				phpQuery::pq($node, $this->getDocumentID())->wrapAllPHP($codeBefore, $codeAfter);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrapInner($wrapper) {
			foreach($this->stack() as $node)
				phpQuery::pq($node, $this->getDocumentID())->contents()->wrapAll($wrapper);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function wrapInnerPHP($codeBefore, $codeAfter) {
			foreach($this->stack(1) as $node)
				phpQuery::pq($node, $this->getDocumentID())->contents()
					->wrapAllPHP($codeBefore, $codeAfter);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @testme Support for text nodes
		 */
		public function contents() {
			$stack = array();
			foreach($this->stack(1) as $el) {
				// FIXME (fixed) http://code.google.com/p/phpquery/issues/detail?id=56
	//			if (! isset($el->childNodes))
	//				continue;
				foreach($el->childNodes as $node) {
					$stack[] = $node;
				}
			}
			return $this->newInstance($stack);
		}
		/**
		 * Enter description here...
		 *
		 * jQuery difference.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function contentsUnwrap() {
			foreach($this->stack(1) as $node) {
				if (! $node->parentNode )
					continue;
				$childNodes = array();
				// any modification in DOM tree breaks childNodes iteration, so cache them first
				foreach($node->childNodes as $chNode )
					$childNodes[] = $chNode;
				foreach($childNodes as $chNode )
	//				$node->parentNode->appendChild($chNode);
					$node->parentNode->insertBefore($chNode, $node);
				$node->parentNode->removeChild($node);
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * jQuery difference.
		 */
		public function switchWith($markup) {
			$markup = pq($markup, $this->getDocumentID());
			$content = null;
			foreach($this->stack(1) as $node) {
				pq($node)
					->contents()->toReference($content)->end()
					->replaceWith($markup->clone()->append($content));
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function eq($num) {
			$oldStack = $this->elements;
			$this->elementsBackup = $this->elements;
			$this->elements = array();
			if ( isset($oldStack[$num]) )
				$this->elements[] = $oldStack[$num];
			return $this->newInstance();
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function size() {
			return count($this->elements);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @deprecated Use length as attribute
		 */
		public function length() {
			return $this->size();
		}
		public function count() {
			return $this->size();
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo $level
		 */
		public function end($level = 1) {
	//		$this->elements = array_pop( $this->history );
	//		return $this;
	//		$this->previous->DOM = $this->DOM;
	//		$this->previous->XPath = $this->XPath;
			return $this->previous
				? $this->previous
				: $this;
		}
		/**
		 * Enter description here...
		 * Normal use ->clone() .
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @access private
		 */
		public function _clone() {
			$newStack = array();
			//pr(array('copy... ', $this->whois()));
			//$this->dumpHistory('copy');
			$this->elementsBackup = $this->elements;
			foreach($this->elements as $node) {
				$newStack[] = $node->cloneNode(true);
			}
			$this->elements = $newStack;
			return $this->newInstance();
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function replaceWithPHP($code) {
			return $this->replaceWith(phpQuery::php($code));
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery $content
		 * @link http://docs.jquery.com/Manipulation/replaceWith#content
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function replaceWith($content) {
			return $this->after($content)->remove();
		}
		/**
		 * Enter description here...
		 *
		 * @param String $selector
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo this works ?
		 */
		public function replaceAll($selector) {
			foreach(phpQuery::pq($selector, $this->getDocumentID()) as $node)
				phpQuery::pq($node, $this->getDocumentID())
					->after($this->_clone())
					->remove();
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function remove($selector = null) {
			$loop = $selector
				? $this->filter($selector)->elements
				: $this->elements;
			foreach($loop as $node) {
				if (! $node->parentNode )
					continue;
				if (isset($node->tagName))
					$this->debug("Removing '{$node->tagName}'");
				$node->parentNode->removeChild($node);
				// Mutation event
				$event = new DOMEvent(array(
					'target' => $node,
					'type' => 'DOMNodeRemoved'
				));
				phpQueryEvents::trigger($this->getDocumentID(),
					$event->type, array($event), $node
				);
			}
			return $this;
		}
		protected function markupEvents($newMarkup, $oldMarkup, $node) {
			if ($node->tagName == 'textarea' && $newMarkup != $oldMarkup) {
				$event = new DOMEvent(array(
					'target' => $node,
					'type' => 'change'
				));
				phpQueryEvents::trigger($this->getDocumentID(),
					$event->type, array($event), $node
				);
			}
		}
		/**
		 * jQuey difference
		 *
		 * @param $markup
		 * @return unknown_type
		 * @TODO trigger change event for textarea
		 */
		public function markup($markup = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			$args = func_get_args();
			if ($this->documentWrapper->isXML)
				return call_user_func_array(array($this, 'xml'), $args);
			else
				return call_user_func_array(array($this, 'html'), $args);
		}
		/**
		 * jQuey difference
		 *
		 * @param $markup
		 * @return unknown_type
		 */
		public function markupOuter($callback1 = null, $callback2 = null, $callback3 = null) {
			$args = func_get_args();
			if ($this->documentWrapper->isXML)
				return call_user_func_array(array($this, 'xmlOuter'), $args);
			else
				return call_user_func_array(array($this, 'htmlOuter'), $args);
		}
		/**
		 * Enter description here...
		 *
		 * @param unknown_type $html
		 * @return string|phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @TODO force html result
		 */
		public function html($html = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			if (isset($html)) {
				// INSERT
				$nodes = $this->documentWrapper->import($html);
				$this->empty();
				foreach($this->stack(1) as $alreadyAdded => $node) {
					// for now, limit events for textarea
					if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
						$oldHtml = pq($node, $this->getDocumentID())->markup();
					foreach($nodes as $newNode) {
						$node->appendChild($alreadyAdded
							? $newNode->cloneNode(true)
							: $newNode
						);
					}
					// for now, limit events for textarea
					if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
						$this->markupEvents($html, $oldHtml, $node);
				}
				return $this;
			} else {
				// FETCH
				$return = $this->documentWrapper->markup($this->elements, true);
				$args = func_get_args();
				foreach(array_slice($args, 1) as $callback) {
					$return = phpQuery::callbackRun($callback, array($return));
				}
				return $return;
			}
		}
		/**
		 * @TODO force xml result
		 */
		public function xml($xml = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			$args = func_get_args();
			return call_user_func_array(array($this, 'html'), $args);
		}
		/**
		 * Enter description here...
		 * @TODO force html result
		 *
		 * @return String
		 */
		public function htmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
			$markup = $this->documentWrapper->markup($this->elements);
			// pass thou callbacks
			$args = func_get_args();
			foreach($args as $callback) {
				$markup = phpQuery::callbackRun($callback, array($markup));
			}
			return $markup;
		}
		/**
		 * @TODO force xml result
		 */
		public function xmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
			$args = func_get_args();
			return call_user_func_array(array($this, 'htmlOuter'), $args);
		}
		public function __toString() {
			return $this->markupOuter();
		}
		/**
		 * Just like html(), but returns markup with VALID (dangerous) PHP tags.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo support returning markup with PHP tags when called without param
		 */
		public function php($code = null) {
			return $this->markupPHP($code);
		}
		/**
		 * Enter description here...
		 * 
		 * @param $code
		 * @return unknown_type
		 */
		public function markupPHP($code = null) {
			return isset($code)
				? $this->markup(phpQuery::php($code))
				: phpQuery::markupToPHP($this->markup());
		}
		/**
		 * Enter description here...
		 * 
		 * @param $code
		 * @return unknown_type
		 */
		public function markupOuterPHP() {
			return phpQuery::markupToPHP($this->markupOuter());
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function children($selector = null) {
			$stack = array();
			foreach($this->stack(1) as $node) {
	//			foreach($node->getElementsByTagName('*') as $newNode) {
				foreach($node->childNodes as $newNode) {
					if ($newNode->nodeType != 1)
						continue;
					if ($selector && ! $this->is($selector, $newNode))
						continue;
					if ($this->elementsContainsNode($newNode, $stack))
						continue;
					$stack[] = $newNode;
				}
			}
			$this->elementsBackup = $this->elements;
			$this->elements = $stack;
			return $this->newInstance();
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function ancestors($selector = null) {
			return $this->children( $selector );
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function append( $content) {
			return $this->insert($content, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function appendPHP( $content) {
			return $this->insert("<php><!-- {$content} --></php>", 'append');
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function appendTo( $seletor) {
			return $this->insert($seletor, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function prepend( $content) {
			return $this->insert($content, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @todo accept many arguments, which are joined, arrays maybe also
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function prependPHP( $content) {
			return $this->insert("<php><!-- {$content} --></php>", 'prepend');
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function prependTo( $seletor) {
			return $this->insert($seletor, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function before($content) {
			return $this->insert($content, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function beforePHP( $content) {
			return $this->insert("<php><!-- {$content} --></php>", 'before');
		}
		/**
		 * Enter description here...
		 *
		 * @param String|phpQuery
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function insertBefore( $seletor) {
			return $this->insert($seletor, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function after( $content) {
			return $this->insert($content, __FUNCTION__);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function afterPHP( $content) {
			return $this->insert("<php><!-- {$content} --></php>", 'after');
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function insertAfter( $seletor) {
			return $this->insert($seletor, __FUNCTION__);
		}
		/**
		 * Internal insert method. Don't use it.
		 *
		 * @param unknown_type $target
		 * @param unknown_type $type
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @access private
		 */
		public function insert($target, $type) {
			$this->debug("Inserting data with '{$type}'");
			$to = false;
			switch( $type) {
				case 'appendTo':
				case 'prependTo':
				case 'insertBefore':
				case 'insertAfter':
					$to = true;
			}
			switch(gettype($target)) {
				case 'string':
					$insertFrom = $insertTo = array();
					if ($to) {
						// INSERT TO
						$insertFrom = $this->elements;
						if (phpQuery::isMarkup($target)) {
							// $target is new markup, import it
							$insertTo = $this->documentWrapper->import($target);
						// insert into selected element
						} else {
							// $tagret is a selector
							$thisStack = $this->elements;
							$this->toRoot();
							$insertTo = $this->find($target)->elements;
							$this->elements = $thisStack;
						}
					} else {
						// INSERT FROM
						$insertTo = $this->elements;
						$insertFrom = $this->documentWrapper->import($target);
					}
					break;
				case 'object':
					$insertFrom = $insertTo = array();
					// phpQuery
					if ($target instanceof self) {
						if ($to) {
							$insertTo = $target->elements;
							if ($this->documentFragment && $this->stackIsRoot())
								// get all body children
	//							$loop = $this->find('body > *')->elements;
								// TODO test it, test it hard...
	//							$loop = $this->newInstance($this->root)->find('> *')->elements;
								$loop = $this->root->childNodes;
							else
								$loop = $this->elements;
							// import nodes if needed
							$insertFrom = $this->getDocumentID() == $target->getDocumentID()
								? $loop
								: $target->documentWrapper->import($loop);
						} else {
							$insertTo = $this->elements;
							if ( $target->documentFragment && $target->stackIsRoot() )
								// get all body children
	//							$loop = $target->find('body > *')->elements;
								$loop = $target->root->childNodes;
							else
								$loop = $target->elements;
							// import nodes if needed
							$insertFrom = $this->getDocumentID() == $target->getDocumentID()
								? $loop
								: $this->documentWrapper->import($loop);
						}
					// DOMNODE
					} elseif ($target instanceof DOMNODE) {
						// import node if needed
	//					if ( $target->ownerDocument != $this->DOM )
	//						$target = $this->DOM->importNode($target, true);
						if ( $to) {
							$insertTo = array($target);
							if ($this->documentFragment && $this->stackIsRoot())
								// get all body children
								$loop = $this->root->childNodes;
	//							$loop = $this->find('body > *')->elements;
							else
								$loop = $this->elements;
							foreach($loop as $fromNode)
								// import nodes if needed
								$insertFrom[] = ! $fromNode->ownerDocument->isSameNode($target->ownerDocument)
									? $target->ownerDocument->importNode($fromNode, true)
									: $fromNode;
						} else {
							// import node if needed
							if (! $target->ownerDocument->isSameNode($this->document))
								$target = $this->document->importNode($target, true);
							$insertTo = $this->elements;
							$insertFrom[] = $target;
						}
					}
					break;
			}
			phpQuery::debug("From ".count($insertFrom)."; To ".count($insertTo)." nodes");
			foreach($insertTo as $insertNumber => $toNode) {
				// we need static relative elements in some cases
				switch( $type) {
					case 'prependTo':
					case 'prepend':
						$firstChild = $toNode->firstChild;
						break;
					case 'insertAfter':
					case 'after':
						$nextSibling = $toNode->nextSibling;
						break;
				}
				foreach($insertFrom as $fromNode) {
					// clone if inserted already before
					$insert = $insertNumber
						? $fromNode->cloneNode(true)
						: $fromNode;
					switch($type) {
						case 'appendTo':
						case 'append':
	//						$toNode->insertBefore(
	//							$fromNode,
	//							$toNode->lastChild->nextSibling
	//						);
							$toNode->appendChild($insert);
							$eventTarget = $insert;
							break;
						case 'prependTo':
						case 'prepend':
							$toNode->insertBefore(
								$insert,
								$firstChild
							);
							break;
						case 'insertBefore':
						case 'before':
							if (! $toNode->parentNode)
								throw new Exception("No parentNode, can't do {$type}()");
							else
								$toNode->parentNode->insertBefore(
									$insert,
									$toNode
								);
							break;
						case 'insertAfter':
						case 'after':
							if (! $toNode->parentNode)
								throw new Exception("No parentNode, can't do {$type}()");
							else
								$toNode->parentNode->insertBefore(
									$insert,
									$nextSibling
								);
							break;
					}
					// Mutation event
					$event = new DOMEvent(array(
						'target' => $insert,
						'type' => 'DOMNodeInserted'
					));
					phpQueryEvents::trigger($this->getDocumentID(),
						$event->type, array($event), $insert
					);
				}
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return Int
		 */
		public function index($subject) {
			$index = -1;
			$subject = $subject instanceof phpQueryObject
				? $subject->elements[0]
				: $subject;
			foreach($this->newInstance() as $k => $node) {
				if ($node->isSameNode($subject))
					$index = $k;
			}
			return $index;
		}
		/**
		 * Enter description here...
		 *
		 * @param unknown_type $start
		 * @param unknown_type $end
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @testme
		 */
		public function slice($start, $end = null) {
	//		$last = count($this->elements)-1;
	//		$end = $end
	//			? min($end, $last)
	//			: $last;
	//		if ($start < 0)
	//			$start = $last+$start;
	//		if ($start > $last)
	//			return array();
			if ($end > 0)
				$end = $end-$start;
			return $this->newInstance(
				array_slice($this->elements, $start, $end)
			);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function reverse() {
			$this->elementsBackup = $this->elements;
			$this->elements = array_reverse($this->elements);
			return $this->newInstance();
		}
		/**
		 * Return joined text content.
		 * @return String
		 */
		public function text($text = null, $callback1 = null, $callback2 = null, $callback3 = null) {
			if (isset($text))
				return $this->html(htmlspecialchars($text));
			$args = func_get_args();
			$args = array_slice($args, 1);
			$return = '';
			foreach($this->elements as $node) {
				$text = $node->textContent;
				if (count($this->elements) > 1 && $text)
					$text .= "\n";
				foreach($args as $callback) {
					$text = phpQuery::callbackRun($callback, array($text));
				}
				$return .= $text;
			}
			return $return;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function plugin($class, $file = null) {
			phpQuery::plugin($class, $file);
			return $this;
		}
		/**
		 * Deprecated, use $pq->plugin() instead.
		 *
		 * @deprecated
		 * @param $class
		 * @param $file
		 * @return unknown_type
		 */
		public static function extend($class, $file = null) {
			return $this->plugin($class, $file);
		}
		/**
		 *
		 * @access private
		 * @param $method
		 * @param $args
		 * @return unknown_type
		 */
		public function __call($method, $args) {
			$aliasMethods = array('clone', 'empty');
			if (isset(phpQuery::$extendMethods[$method])) {
				array_unshift($args, $this);
				return phpQuery::callbackRun(
					phpQuery::$extendMethods[$method], $args
				);
			} else if (isset(phpQuery::$pluginsMethods[$method])) {
				array_unshift($args, $this);
				$class = phpQuery::$pluginsMethods[$method];
				$realClass = "phpQueryObjectPlugin_$class";
				$return = call_user_func_array(
					array($realClass, $method),
					$args
				);
				// XXX deprecate ?
				return is_null($return)
					? $this
					: $return;
			} else if (in_array($method, $aliasMethods)) {
				return call_user_func_array(array($this, '_'.$method), $args);
			} else
				throw new Exception("Method '{$method}' doesnt exist");
		}
		/**
		 * Safe rename of next().
		 *
		 * Use it ONLY when need to call next() on an iterated object (in same time).
		 * Normaly there is no need to do such thing ;)
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @access private
		 */
		public function _next($selector = null) {
			return $this->newInstance(
				$this->getElementSiblings('nextSibling', $selector, true)
			);
		}
		/**
		 * Use prev() and next().
		 *
		 * @deprecated
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @access private
		 */
		public function _prev($selector = null) {
			return $this->prev($selector);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function prev($selector = null) {
			return $this->newInstance(
				$this->getElementSiblings('previousSibling', $selector, true)
			);
		}
		/**
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo
		 */
		public function prevAll($selector = null) {
			return $this->newInstance(
				$this->getElementSiblings('previousSibling', $selector)
			);
		}
		/**
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo FIXME: returns source elements insted of next siblings
		 */
		public function nextAll($selector = null) {
			return $this->newInstance(
				$this->getElementSiblings('nextSibling', $selector)
			);
		}
		/**
		 * @access private
		 */
		protected function getElementSiblings($direction, $selector = null, $limitToOne = false) {
			$stack = array();
			$count = 0;
			foreach($this->stack() as $node) {
				$test = $node;
				while( isset($test->{$direction}) && $test->{$direction}) {
					$test = $test->{$direction};
					if (! $test instanceof DOMELEMENT)
						continue;
					$stack[] = $test;
					if ($limitToOne)
						break;
				}
			}
			if ($selector) {
				$stackOld = $this->elements;
				$this->elements = $stack;
				$stack = $this->filter($selector, true)->stack();
				$this->elements = $stackOld;
			}
			return $stack;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function siblings($selector = null) {
			$stack = array();
			$siblings = array_merge(
				$this->getElementSiblings('previousSibling', $selector),
				$this->getElementSiblings('nextSibling', $selector)
			);
			foreach($siblings as $node) {
				if (! $this->elementsContainsNode($node, $stack))
					$stack[] = $node;
			}
			return $this->newInstance($stack);
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function not($selector = null) {
			if (is_string($selector))
				phpQuery::debug(array('not', $selector));
			else
				phpQuery::debug('not');
			$stack = array();
			if ($selector instanceof self || $selector instanceof DOMNODE) {
				foreach($this->stack() as $node) {
					if ($selector instanceof self) {
						$matchFound = false;
						foreach($selector->stack() as $notNode) {
							if ($notNode->isSameNode($node))
								$matchFound = true;
						}
						if (! $matchFound)
							$stack[] = $node;
					} else if ($selector instanceof DOMNODE) {
						if (! $selector->isSameNode($node))
							$stack[] = $node;
					} else {
						if (! $this->is($selector))
							$stack[] = $node;
					}
				}
			} else {
				$orgStack = $this->stack();
				$matched = $this->filter($selector, true)->stack();
	//			$matched = array();
	//			// simulate OR in filter() instead of AND 5y
	//			foreach($this->parseSelector($selector) as $s) {
	//				$matched = array_merge($matched,
	//					$this->filter(array($s))->stack()
	//				);
	//			}
				foreach($orgStack as $node)
					if (! $this->elementsContainsNode($node, $matched))
						$stack[] = $node;
			}
			return $this->newInstance($stack);
		}
		/**
		 * Enter description here...
		 *
		 * @param string|phpQueryObject
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function add($selector = null) {
			if (! $selector)
				return $this;
			$stack = array();
			$this->elementsBackup = $this->elements;
			$found = phpQuery::pq($selector, $this->getDocumentID());
			$this->merge($found->elements);
			return $this->newInstance();
		}
		/**
		 * @access private
		 */
		protected function merge() {
			foreach(func_get_args() as $nodes)
				foreach($nodes as $newNode )
					if (! $this->elementsContainsNode($newNode) )
						$this->elements[] = $newNode;
		}
		/**
		 * @access private
		 * TODO refactor to stackContainsNode
		 */
		protected function elementsContainsNode($nodeToCheck, $elementsStack = null) {
			$loop = ! is_null($elementsStack)
				? $elementsStack
				: $this->elements;
			foreach($loop as $node) {
				if ( $node->isSameNode( $nodeToCheck ) )
					return true;
			}
			return false;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function parent($selector = null) {
			$stack = array();
			foreach($this->elements as $node )
				if ( $node->parentNode && ! $this->elementsContainsNode($node->parentNode, $stack) )
					$stack[] = $node->parentNode;
			$this->elementsBackup = $this->elements;
			$this->elements = $stack;
			if ( $selector )
				$this->filter($selector, true);
			return $this->newInstance();
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function parents($selector = null) {
			$stack = array();
			if (! $this->elements )
				$this->debug('parents() - stack empty');
			foreach($this->elements as $node) {
				$test = $node;
				while( $test->parentNode) {
					$test = $test->parentNode;
					if ($this->isRoot($test))
						break;
					if (! $this->elementsContainsNode($test, $stack)) {
						$stack[] = $test;
						continue;
					}
				}
			}
			$this->elementsBackup = $this->elements;
			$this->elements = $stack;
			if ( $selector )
				$this->filter($selector, true);
			return $this->newInstance();
		}
		/**
		 * Internal stack iterator.
		 *
		 * @access private
		 */
		public function stack($nodeTypes = null) {
			if (!isset($nodeTypes))
				return $this->elements;
			if (!is_array($nodeTypes))
				$nodeTypes = array($nodeTypes);
			$return = array();
			foreach($this->elements as $node) {
				if (in_array($node->nodeType, $nodeTypes))
					$return[] = $node;
			}
			return $return;
		}
		// TODO phpdoc; $oldAttr is result of hasAttribute, before any changes
		protected function attrEvents($attr, $oldAttr, $oldValue, $node) {
			// skip events for XML documents
			if (! $this->isXHTML() && ! $this->isHTML())
				return;
			$event = null;
			// identify
			$isInputValue = $node->tagName == 'input'
				&& (
					in_array($node->getAttribute('type'),
						array('text', 'password', 'hidden'))
					|| !$node->getAttribute('type')
					 );
			$isRadio = $node->tagName == 'input'
				&& $node->getAttribute('type') == 'radio';
			$isCheckbox = $node->tagName == 'input'
				&& $node->getAttribute('type') == 'checkbox';
			$isOption = $node->tagName == 'option';
			if ($isInputValue && $attr == 'value' && $oldValue != $node->getAttribute($attr)) {
				$event = new DOMEvent(array(
					'target' => $node,
					'type' => 'change'
				));
			} else if (($isRadio || $isCheckbox) && $attr == 'checked' && (
					// check
					(! $oldAttr && $node->hasAttribute($attr))
					// un-check
					|| (! $node->hasAttribute($attr) && $oldAttr)
				)) {
				$event = new DOMEvent(array(
					'target' => $node,
					'type' => 'change'
				));
			} else if ($isOption && $node->parentNode && $attr == 'selected' && (
					// select
					(! $oldAttr && $node->hasAttribute($attr))
					// un-select
					|| (! $node->hasAttribute($attr) && $oldAttr)
				)) {
				$event = new DOMEvent(array(
					'target' => $node->parentNode,
					'type' => 'change'
				));
			}
			if ($event) {
				phpQueryEvents::trigger($this->getDocumentID(),
					$event->type, array($event), $node
				);
			}
		}
		public function attr($attr = null, $value = null) {
			foreach($this->stack(1) as $node) {
				if (! is_null($value)) {
					$loop = $attr == '*'
						? $this->getNodeAttrs($node)
						: array($attr);
					foreach($loop as $a) {
						$oldValue = $node->getAttribute($a);
						$oldAttr = $node->hasAttribute($a);
						// TODO raises an error when charset other than UTF-8
						// while document's charset is also not UTF-8
						@$node->setAttribute($a, $value);
						$this->attrEvents($a, $oldAttr, $oldValue, $node);
					}
				} else if ($attr == '*') {
					// jQuery difference
					$return = array();
					foreach($node->attributes as $n => $v)
						$return[$n] = $v->value;
					return $return;
				} else
					return $node->hasAttribute($attr)
						? $node->getAttribute($attr)
						: null;
			}
			return is_null($value)
				? '' : $this;
		}
		/**
		 * @access private
		 */
		protected function getNodeAttrs($node) {
			$return = array();
			foreach($node->attributes as $n => $o)
				$return[] = $n;
			return $return;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo check CDATA ???
		 */
		public function attrPHP($attr, $code) {
			if (! is_null($code)) {
				$value = '<'.'?php '.$code.' ?'.'>';
				// TODO tempolary solution
				// http://code.google.com/p/phpquery/issues/detail?id=17
	//			if (function_exists('mb_detect_encoding') && mb_detect_encoding($value) == 'ASCII')
	//				$value	= mb_convert_encoding($value, 'UTF-8', 'HTML-ENTITIES');
			}
			foreach($this->stack(1) as $node) {
				if (! is_null($code)) {
	//				$attrNode = $this->DOM->createAttribute($attr);
					$node->setAttribute($attr, $value);
	//				$attrNode->value = $value;
	//				$node->appendChild($attrNode);
				} else if ( $attr == '*') {
					// jQuery diff
					$return = array();
					foreach($node->attributes as $n => $v)
						$return[$n] = $v->value;
					return $return;
				} else
					return $node->getAttribute($attr);
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function removeAttr($attr) {
			foreach($this->stack(1) as $node) {
				$loop = $attr == '*'
					? $this->getNodeAttrs($node)
					: array($attr);
				foreach($loop as $a) {
					$oldValue = $node->getAttribute($a);
					$node->removeAttribute($a);
					$this->attrEvents($a, $oldValue, null, $node);
				}
			}
			return $this;
		}
		/**
		 * Return form element value.
		 *
		 * @return String Fields value.
		 */
		public function val($val = null) {
			if (! isset($val)) {
				if ($this->eq(0)->is('select')) {
						$selected = $this->eq(0)->find('option[selected=selected]');
						if ($selected->is('[value]'))
							return $selected->attr('value');
						else
							return $selected->text();
				} else if ($this->eq(0)->is('textarea'))
						return $this->eq(0)->markup();
					else
						return $this->eq(0)->attr('value');
			} else {
				$_val = null;
				foreach($this->stack(1) as $node) {
					$node = pq($node, $this->getDocumentID());
					if (is_array($val) && in_array($node->attr('type'), array('checkbox', 'radio'))) {
						$isChecked = in_array($node->attr('value'), $val)
								|| in_array($node->attr('name'), $val);
						if ($isChecked)
							$node->attr('checked', 'checked');
						else
							$node->removeAttr('checked');
					} else if ($node->get(0)->tagName == 'select') {
						if (! isset($_val)) {
							$_val = array();
							if (! is_array($val))
								$_val = array((string)$val);
							else
								foreach($val as $v)
									$_val[] = $v;
						}
						foreach($node['option']->stack(1) as $option) {
							$option = pq($option, $this->getDocumentID());
							$selected = false;
							// XXX: workaround for string comparsion, see issue #96
							// http://code.google.com/p/phpquery/issues/detail?id=96
							$selected = is_null($option->attr('value'))
								? in_array($option->markup(), $_val)
								: in_array($option->attr('value'), $_val);
	//						$optionValue = $option->attr('value');
	//						$optionText = $option->text();
	//						$optionTextLenght = mb_strlen($optionText);
	//						foreach($_val as $v)
	//							if ($optionValue == $v)
	//								$selected = true;
	//							else if ($optionText == $v && $optionTextLenght == mb_strlen($v))
	//								$selected = true;
							if ($selected)
								$option->attr('selected', 'selected');
							else
								$option->removeAttr('selected');
						}
					} else if ($node->get(0)->tagName == 'textarea')
						$node->markup($val);
					else
						$node->attr('value', $val);
				}
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function andSelf() {
			if ( $this->previous )
				$this->elements = array_merge($this->elements, $this->previous->elements);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function addClass( $className) {
			if (! $className)
				return $this;
			foreach($this->stack(1) as $node) {
				if (! $this->is(".$className", $node))
					$node->setAttribute(
						'class',
						trim($node->getAttribute('class').' '.$className)
					);
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function addClassPHP( $className) {
			foreach($this->stack(1) as $node) {
					$classes = $node->getAttribute('class');
					$newValue = $classes
						? $classes.' <'.'?php '.$className.' ?'.'>'
						: '<'.'?php '.$className.' ?'.'>';
					$node->setAttribute('class', $newValue);
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @param	string	$className
		 * @return	bool
		 */
		public function hasClass($className) {
			foreach($this->stack(1) as $node) {
				if ( $this->is(".$className", $node))
					return true;
			}
			return false;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function removeClass($className) {
			foreach($this->stack(1) as $node) {
				$classes = explode( ' ', $node->getAttribute('class'));
				if ( in_array($className, $classes)) {
					$classes = array_diff($classes, array($className));
					if ( $classes )
						$node->setAttribute('class', implode(' ', $classes));
					else
						$node->removeAttribute('class');
				}
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function toggleClass($className) {
			foreach($this->stack(1) as $node) {
				if ( $this->is( $node, '.'.$className ))
					$this->removeClass($className);
				else
					$this->addClass($className);
			}
			return $this;
		}
		/**
		 * Proper name without underscore (just ->empty()) also works.
		 *
		 * Removes all child nodes from the set of matched elements.
		 *
		 * Example:
		 * pq("p")._empty()
		 *
		 * HTML:
		 * <p>Hello, <span>Person</span> <a href="#">and person</a></p>
		 *
		 * Result:
		 * [ <p></p> ]
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @access private
		 */
		public function _empty() {
			foreach($this->stack(1) as $node) {
				// thx to 'dave at dgx dot cz'
				$node->nodeValue = '';
			}
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @param array|string $callback Expects $node as first param, $index as second
		 * @param array $scope External variables passed to callback. Use compact('varName1', 'varName2'...) and extract($scope)
		 * @param array $arg1 Will ba passed as third and futher args to callback.
		 * @param array $arg2 Will ba passed as fourth and futher args to callback, and so on...
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function each($callback, $param1 = null, $param2 = null, $param3 = null) {
			$paramStructure = null;
			if (func_num_args() > 1) {
				$paramStructure = func_get_args();
				$paramStructure = array_slice($paramStructure, 1);
			}
			foreach($this->elements as $v)
				phpQuery::callbackRun($callback, array($v), $paramStructure);
			return $this;
		}
		/**
		 * Run callback on actual object.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function callback($callback, $param1 = null, $param2 = null, $param3 = null) {
			$params = func_get_args();
			$params[0] = $this;
			phpQuery::callbackRun($callback, $params);
			return $this;
		}
		/**
		 * Enter description here...
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @todo add $scope and $args as in each() ???
		 */
		public function map($callback, $param1 = null, $param2 = null, $param3 = null) {
	//		$stack = array();
	////		foreach($this->newInstance() as $node) {
	//		foreach($this->newInstance() as $node) {
	//			$result = call_user_func($callback, $node);
	//			if ($result)
	//				$stack[] = $result;
	//		}
			$params = func_get_args();
			array_unshift($params, $this->elements);
			return $this->newInstance(
				call_user_func_array(array('phpQuery', 'map'), $params)
	//			phpQuery::map($this->elements, $callback)
			);
		}
		/**
		 * Enter description here...
		 * 
		 * @param <type> $key
		 * @param <type> $value
		 */
		public function data($key, $value = null) {
			if (! isset($value)) {
				// TODO? implement specific jQuery behavior od returning parent values
				// is child which we look up doesn't exist
				return phpQuery::data($this->get(0), $key, $value, $this->getDocumentID());
			} else {
				foreach($this as $node)
					phpQuery::data($node, $key, $value, $this->getDocumentID());
				return $this;
			}
		}
		/**
		 * Enter description here...
		 * 
		 * @param <type> $key
		 */
		public function removeData($key) {
			foreach($this as $node)
				phpQuery::removeData($node, $key, $this->getDocumentID());
			return $this;
		}
		// INTERFACE IMPLEMENTATIONS

		// ITERATOR INTERFACE
		/**
	   * @access private
		 */
		public function rewind(){
			$this->debug('iterating foreach');
	//		phpQuery::selectDocument($this->getDocumentID());
			$this->elementsBackup = $this->elements;
			$this->elementsInterator = $this->elements;
			$this->valid = isset( $this->elements[0] )
				? 1 : 0;
	// 		$this->elements = $this->valid
	// 			? array($this->elements[0])
	// 			: array();
			$this->current = 0;
		}
		/**
	   * @access private
		 */
		public function current(){
			return $this->elementsInterator[ $this->current ];
		}
		/**
	   * @access private
		 */
		public function key(){
			return $this->current;
		}
		/**
		 * Double-function method.
		 *
		 * First: main iterator interface method.
		 * Second: Returning next sibling, alias for _next().
		 *
		 * Proper functionality is choosed automagicaly.
		 *
		 * @see phpQueryObject::_next()
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public function next($cssSelector = null){
	//		if ($cssSelector || $this->valid)
	//			return $this->_next($cssSelector);
			$this->valid = isset( $this->elementsInterator[ $this->current+1 ] )
				? true
				: false;
			if (! $this->valid && $this->elementsInterator) {
				$this->elementsInterator = null;
			} else if ($this->valid) {
				$this->current++;
			} else {
				return $this->_next($cssSelector);
			}
		}
		/**
	   * @access private
		 */
		public function valid(){
			return $this->valid;
		}
		// ITERATOR INTERFACE END
		// ARRAYACCESS INTERFACE
		/**
	   * @access private
		 */
		public function offsetExists($offset) {
			return $this->find($offset)->size() > 0;
		}
		/**
	   * @access private
		 */
		public function offsetGet($offset) {
			return $this->find($offset);
		}
		/**
	   * @access private
		 */
		public function offsetSet($offset, $value) {
	//		$this->find($offset)->replaceWith($value);
			$this->find($offset)->html($value);
		}
		/**
	   * @access private
		 */
		public function offsetUnset($offset) {
			// empty
			throw new Exception("Can't do unset, use array interface only for calling queries and replacing HTML.");
		}
		// ARRAYACCESS INTERFACE END
		/**
		 * Returns node's XPath.
		 *
		 * @param unknown_type $oneNode
		 * @return string
		 * @TODO use native getNodePath is avaible
		 * @access private
		 */
		protected function getNodeXpath($oneNode = null, $namespace = null) {
			$return = array();
			$loop = $oneNode
				? array($oneNode)
				: $this->elements;
	//		if ($namespace)
	//			$namespace .= ':';
			foreach($loop as $node) {
				if ($node instanceof DOMDOCUMENT) {
					$return[] = '';
					continue;
				}
				$xpath = array();
				while(! ($node instanceof DOMDOCUMENT)) {
					$i = 1;
					$sibling = $node;
					while($sibling->previousSibling) {
						$sibling = $sibling->previousSibling;
						$isElement = $sibling instanceof DOMELEMENT;
						if ($isElement && $sibling->tagName == $node->tagName)
							$i++;
					}
					$xpath[] = $this->isXML()
						? "*[local-name()='{$node->tagName}'][{$i}]"
						: "{$node->tagName}[{$i}]";
					$node = $node->parentNode;
				}
				$xpath = join('/', array_reverse($xpath));
				$return[] = '/'.$xpath;
			}
			return $oneNode
				? $return[0]
				: $return;
		}
		// HELPERS
		public function whois($oneNode = null) {
			$return = array();
			$loop = $oneNode
				? array( $oneNode )
				: $this->elements;
			foreach($loop as $node) {
				if (isset($node->tagName)) {
					$tag = in_array($node->tagName, array('php', 'js'))
						? strtoupper($node->tagName)
						: $node->tagName;
					$return[] = $tag
						.($node->getAttribute('id')
							? '#'.$node->getAttribute('id'):'')
						.($node->getAttribute('class')
							? '.'.join('.', split(' ', $node->getAttribute('class'))):'')
						.($node->getAttribute('name')
							? '[name="'.$node->getAttribute('name').'"]':'')
						.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') === false
							? '[value="'.substr(str_replace("\n", '', $node->getAttribute('value')), 0, 15).'"]':'')
						.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') !== false
							? '[value=PHP]':'')
						.($node->getAttribute('selected')
							? '[selected]':'')
						.($node->getAttribute('checked')
							? '[checked]':'')
					;
				} else if ($node instanceof DOMTEXT) {
					if (trim($node->textContent))
						$return[] = 'Text:'.substr(str_replace("\n", ' ', $node->textContent), 0, 15);
				} else {

				}
			}
			return $oneNode && isset($return[0])
				? $return[0]
				: $return;
		}
		/**
		 * Dump htmlOuter and preserve chain. Usefull for debugging.
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 *
		 */
		public function dump() {
			print 'DUMP #'.(phpQuery::$dumpCount++).' ';
			$debug = phpQuery::$debug;
			phpQuery::$debug = false;
	//		print __FILE__.':'.__LINE__."\n";
			var_dump($this->htmlOuter());
			return $this;
		}
		public function dumpWhois() {
			print 'DUMP #'.(phpQuery::$dumpCount++).' ';
			$debug = phpQuery::$debug;
			phpQuery::$debug = false;
	//		print __FILE__.':'.__LINE__."\n";
			var_dump('whois', $this->whois());
			phpQuery::$debug = $debug;
			return $this;
		}
		public function dumpLength() {
			print 'DUMP #'.(phpQuery::$dumpCount++).' ';
			$debug = phpQuery::$debug;
			phpQuery::$debug = false;
	//		print __FILE__.':'.__LINE__."\n";
			var_dump('length', $this->length());
			phpQuery::$debug = $debug;
			return $this;
		}
		public function dumpTree($html = true, $title = true) {
			$output = $title
				? 'DUMP #'.(phpQuery::$dumpCount++)." \n" : '';
			$debug = phpQuery::$debug;
			phpQuery::$debug = false;
			foreach($this->stack() as $node)
				$output .= $this->__dumpTree($node);
			phpQuery::$debug = $debug;
			print $html
				? nl2br(str_replace(' ', '&nbsp;', $output))
				: $output;
			return $this;
		}
		private function __dumpTree($node, $intend = 0) {
			$whois = $this->whois($node);
			$return = '';
			if ($whois)
				$return .= str_repeat(' - ', $intend).$whois."\n";
			if (isset($node->childNodes))
				foreach($node->childNodes as $chNode)
					$return .= $this->__dumpTree($chNode, $intend+1);
			return $return;
		}
		/**
		 * Dump htmlOuter and stop script execution. Usefull for debugging.
		 *
		 */
		public function dumpDie() {
			print __FILE__.':'.__LINE__;
			var_dump($this->htmlOuter());
			die();
		}
	}
}


// -- Multibyte Compatibility functions ---------------------------------------
// http://svn.iphonewebdev.com/lace/lib/mb_compat.php

/**
 *  mb_internal_encoding()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_internal_encoding'))
{
	function mb_internal_encoding($enc) {return true; }
}

/**
 *  mb_regex_encoding()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_regex_encoding'))
{
	function mb_regex_encoding($enc) {return true; }
}

/**
 *  mb_strlen()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_strlen'))
{
	function mb_strlen($str)
	{
		return strlen($str);
	}
}

/**
 *  mb_strpos()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_strpos'))
{
	function mb_strpos($haystack, $needle, $offset=0)
	{
		return strpos($haystack, $needle, $offset);
	}
}
/**
 *  mb_stripos()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_stripos'))
{
	function mb_stripos($haystack, $needle, $offset=0)
	{
		return stripos($haystack, $needle, $offset);
	}
}

/**
 *  mb_substr()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_substr'))
{
	function mb_substr($str, $start, $length=0)
	{
		return substr($str, $start, $length);
	}
}

/**
 *  mb_substr_count()
 *
 *  Included for mbstring pseudo-compatability.
 */
if (!function_exists('mb_substr_count'))
{
	function mb_substr_count($haystack, $needle)
	{
		return substr_count($haystack, $needle);
	}
}


/**
 * Static namespace for phpQuery functions.
 *
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @package phpQuery
 */
if (!class_exists('phpQuery')) {
	abstract class phpQuery {
		/**
		 * XXX: Workaround for mbstring problems 
		 * 
		 * @var bool
		 */
		public static $mbstringSupport = true;
		public static $debug = false;
		public static $documents = array();
		public static $defaultDocumentID = null;
	//	public static $defaultDoctype = 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"';
		/**
		 * Applies only to HTML.
		 *
		 * @var unknown_type
		 */
		public static $defaultDoctype = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
	"http://www.w3.org/TR/html4/loose.dtd">';
		public static $defaultCharset = 'UTF-8';
		/**
		 * Static namespace for plugins.
		 *
		 * @var object
		 */
		public static $plugins = array();
		/**
		 * List of loaded plugins.
		 *
		 * @var unknown_type
		 */
		public static $pluginsLoaded = array();
		public static $pluginsMethods = array();
		public static $pluginsStaticMethods = array();
		public static $extendMethods = array();
		/**
		 * @TODO implement
		 */
		public static $extendStaticMethods = array();
		/**
		 * Hosts allowed for AJAX connections.
		 * Dot '.' means $_SERVER['HTTP_HOST'] (if any).
		 *
		 * @var array
		 */
		public static $ajaxAllowedHosts = array(
			'.'
		);
		/**
		 * AJAX settings.
		 *
		 * @var array
		 * XXX should it be static or not ?
		 */
		public static $ajaxSettings = array(
			'url' => '',//TODO
			'global' => true,
			'type' => "GET",
			'timeout' => null,
			'contentType' => "application/x-www-form-urlencoded",
			'processData' => true,
	//		'async' => true,
			'data' => null,
			'username' => null,
			'password' => null,
			'accepts' => array(
				'xml' => "application/xml, text/xml",
				'html' => "text/html",
				'script' => "text/javascript, application/javascript",
				'json' => "application/json, text/javascript",
				'text' => "text/plain",
				'_default' => "*/*"
			)
		);
		public static $lastModified = null;
		public static $active = 0;
		public static $dumpCount = 0;
		/**
		 * Multi-purpose function.
		 * Use pq() as shortcut.
		 *
		 * In below examples, $pq is any result of pq(); function.
		 *
		 * 1. Import markup into existing document (without any attaching):
		 * - Import into selected document:
		 *   pq('<div/>')				// DOESNT accept text nodes at beginning of input string !
		 * - Import into document with ID from $pq->getDocumentID():
		 *   pq('<div/>', $pq->getDocumentID())
		 * - Import into same document as DOMNode belongs to:
		 *   pq('<div/>', DOMNode)
		 * - Import into document from phpQuery object:
		 *   pq('<div/>', $pq)
		 *
		 * 2. Run query:
		 * - Run query on last selected document:
		 *   pq('div.myClass')
		 * - Run query on document with ID from $pq->getDocumentID():
		 *   pq('div.myClass', $pq->getDocumentID())
		 * - Run query on same document as DOMNode belongs to and use node(s)as root for query:
		 *   pq('div.myClass', DOMNode)
		 * - Run query on document from phpQuery object
		 *   and use object's stack as root node(s) for query:
		 *   pq('div.myClass', $pq)
		 *
		 * @param string|DOMNode|DOMNodeList|array	$arg1	HTML markup, CSS Selector, DOMNode or array of DOMNodes
		 * @param string|phpQueryObject|DOMNode	$context	DOM ID from $pq->getDocumentID(), phpQuery object (determines also query root) or DOMNode (determines also query root)
		 *
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery|QueryTemplatesPhpQuery|false
	   * phpQuery object or false in case of error.
		 */
		public static function pq($arg1, $context = null) {
			if ($arg1 instanceof DOMNODE && ! isset($context)) {
				foreach(phpQuery::$documents as $documentWrapper) {
					$compare = $arg1 instanceof DOMDocument
						? $arg1 : $arg1->ownerDocument;
					if ($documentWrapper->document->isSameNode($compare))
						$context = $documentWrapper->id;
				}
			}
			if (! $context) {
				$domId = self::$defaultDocumentID;
				if (! $domId)
					throw new Exception("Can't use last created DOM, because there isn't any. Use phpQuery::newDocument() first.");
	//		} else if (is_object($context) && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
			} else if (is_object($context) && $context instanceof phpQueryObject)
				$domId = $context->getDocumentID();
			else if ($context instanceof DOMDOCUMENT) {
				$domId = self::getDocumentID($context);
				if (! $domId) {
					//throw new Exception('Orphaned DOMDocument');
					$domId = self::newDocument($context)->getDocumentID();
				}
			} else if ($context instanceof DOMNODE) {
				$domId = self::getDocumentID($context);
				if (! $domId) {
					throw new Exception('Orphaned DOMNode');
	//				$domId = self::newDocument($context->ownerDocument);
				}
			} else
				$domId = $context;
			if ($arg1 instanceof phpQueryObject) {
	//		if (is_object($arg1) && (get_class($arg1) == 'phpQueryObject' || $arg1 instanceof PHPQUERY || is_subclass_of($arg1, 'phpQueryObject'))) {
				/**
				 * Return $arg1 or import $arg1 stack if document differs:
				 * pq(pq('<div/>'))
				 */
				if ($arg1->getDocumentID() == $domId)
					return $arg1;
				$class = get_class($arg1);
				// support inheritance by passing old object to overloaded constructor
				$phpQuery = $class != 'phpQuery'
					? new $class($arg1, $domId)
					: new phpQueryObject($domId);
				$phpQuery->elements = array();
				foreach($arg1->elements as $node)
					$phpQuery->elements[] = $phpQuery->document->importNode($node, true);
				return $phpQuery;
			} else if ($arg1 instanceof DOMNODE || (is_array($arg1) && isset($arg1[0]) && $arg1[0] instanceof DOMNODE)) {
				/*
				 * Wrap DOM nodes with phpQuery object, import into document when needed:
				 * pq(array($domNode1, $domNode2))
				 */
				$phpQuery = new phpQueryObject($domId);
				if (!($arg1 instanceof DOMNODELIST) && ! is_array($arg1))
					$arg1 = array($arg1);
				$phpQuery->elements = array();
				foreach($arg1 as $node) {
					$sameDocument = $node->ownerDocument instanceof DOMDOCUMENT
						&& ! $node->ownerDocument->isSameNode($phpQuery->document);
					$phpQuery->elements[] = $sameDocument
						? $phpQuery->document->importNode($node, true)
						: $node;
				}
				return $phpQuery;
			} else if (self::isMarkup($arg1)) {
				/**
				 * Import HTML:
				 * pq('<div/>')
				 */
				$phpQuery = new phpQueryObject($domId);
				return $phpQuery->newInstance(
					$phpQuery->documentWrapper->import($arg1)
				);
			} else {
				/**
				 * Run CSS query:
				 * pq('div.myClass')
				 */
				$phpQuery = new phpQueryObject($domId);
	//			if ($context && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
				if ($context && $context instanceof phpQueryObject)
					$phpQuery->elements = $context->elements;
				else if ($context && $context instanceof DOMNODELIST) {
					$phpQuery->elements = array();
					foreach($context as $node)
						$phpQuery->elements[] = $node;
				} else if ($context && $context instanceof DOMNODE)
					$phpQuery->elements = array($context);
				return $phpQuery->find($arg1);
			}
		}
		/**
		 * Sets default document to $id. Document has to be loaded prior
		 * to using this method.
		 * $id can be retrived via getDocumentID() or getDocumentIDRef().
		 *
		 * @param unknown_type $id
		 */
		public static function selectDocument($id) {
			$id = self::getDocumentID($id);
			self::debug("Selecting document '$id' as default one");
			self::$defaultDocumentID = self::getDocumentID($id);
		}
		/**
		 * Returns document with id $id or last used as phpQueryObject.
		 * $id can be retrived via getDocumentID() or getDocumentIDRef().
		 * Chainable.
		 *
		 * @see phpQuery::selectDocument()
		 * @param unknown_type $id
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function getDocument($id = null) {
			if ($id)
				phpQuery::selectDocument($id);
			else
				$id = phpQuery::$defaultDocumentID;
			return new phpQueryObject($id);
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocument($markup = null, $contentType = null) {
			if (! $markup)
				$markup = '';
			$documentID = phpQuery::createDocumentWrapper($markup, $contentType);
			return new phpQueryObject($documentID);
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentHTML($markup = null, $charset = null) {
			$contentType = $charset
				? ";charset=$charset"
				: '';
			return self::newDocument($markup, "text/html{$contentType}");
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentXML($markup = null, $charset = null) {
			$contentType = $charset
				? ";charset=$charset"
				: '';
			return self::newDocument($markup, "text/xml{$contentType}");
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentXHTML($markup = null, $charset = null) {
			$contentType = $charset
				? ";charset=$charset"
				: '';
			return self::newDocument($markup, "application/xhtml+xml{$contentType}");
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentPHP($markup = null, $contentType = "text/html") {
			// TODO pass charset to phpToMarkup if possible (use DOMDocumentWrapper function)
			$markup = phpQuery::phpToMarkup($markup, self::$defaultCharset);
			return self::newDocument($markup, $contentType);
		}
		public static function phpToMarkup($php, $charset = 'utf-8') {
			$regexes = array(
				'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)<'.'?php?(.*?)(?:\\?>)([^\']*)\'@s',
				'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)<'.'?php?(.*?)(?:\\?>)([^"]*)"@s',
			);
			foreach($regexes as $regex)
				while (preg_match($regex, $php, $matches)) {
					$php = preg_replace_callback(
						$regex,
	//					create_function('$m, $charset = "'.$charset.'"',
	//						'return $m[1].$m[2]
	//							.htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
	//							.$m[5].$m[2];'
	//					),
						array('phpQuery', '_phpToMarkupCallback'),
						$php
					);
				}
			$regex = '@(^|>[^<]*)+?(<\?php(.*?)(\?>))@s';
	//preg_match_all($regex, $php, $matches);
	//var_dump($matches);
			$php = preg_replace($regex, '\\1<php><!-- \\3 --></php>', $php);
			return $php;
		}
		public static function _phpToMarkupCallback($php, $charset = 'utf-8') {
			return $m[1].$m[2]
				.htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
				.$m[5].$m[2];
		}
		public static function _markupToPHPCallback($m) {
			return "<"."?php ".htmlspecialchars_decode($m[1])." ?".">";
		}
		/**
		 * Converts document markup containing PHP code generated by phpQuery::php()
		 * into valid (executable) PHP code syntax.
		 *
		 * @param string|phpQueryObject $content
		 * @return string PHP code.
		 */
		public static function markupToPHP($content) {
			if ($content instanceof phpQueryObject)
				$content = $content->markupOuter();
			/* <php>...</php> to <?php...? > */
			$content = preg_replace_callback(
				'@<php>\s*<!--(.*?)-->\s*</php>@s',
	//			create_function('$m',
	//				'return "<'.'?php ".htmlspecialchars_decode($m[1])." ?'.'>";'
	//			),
				array('phpQuery', '_markupToPHPCallback'),
				$content
			);
			/* <node attr='< ?php ? >'> extra space added to save highlighters */
			$regexes = array(
				'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)(?:&lt;|%3C)\\?(?:php)?(.*?)(?:\\?(?:&gt;|%3E))([^\']*)\'@s',
				'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)(?:&lt;|%3C)\\?(?:php)?(.*?)(?:\\?(?:&gt;|%3E))([^"]*)"@s',
			);
			foreach($regexes as $regex)
				while (preg_match($regex, $content))
					$content = preg_replace_callback(
						$regex,
						create_function('$m',
							'return $m[1].$m[2].$m[3]."<?php "
								.str_replace(
									array("%20", "%3E", "%09", "&#10;", "&#9;", "%7B", "%24", "%7D", "%22", "%5B", "%5D"),
									array(" ", ">", "	", "\n", "	", "{", "$", "}", \'"\', "[", "]"),
									htmlspecialchars_decode($m[4])
								)
								." ?>".$m[5].$m[2];'
						),
						$content
					);
			return $content;
		}
		/**
		 * Creates new document from file $file.
		 * Chainable.
		 *
		 * @param string $file URLs allowed. See File wrapper page at php.net for more supported sources.
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentFile($file, $contentType = null) {
			$documentID = self::createDocumentWrapper(
				file_get_contents($file), $contentType
			);
			return new phpQueryObject($documentID);
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentFileHTML($file, $charset = null) {
			$contentType = $charset
				? ";charset=$charset"
				: '';
			return self::newDocumentFile($file, "text/html{$contentType}");
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentFileXML($file, $charset = null) {
			$contentType = $charset
				? ";charset=$charset"
				: '';
			return self::newDocumentFile($file, "text/xml{$contentType}");
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentFileXHTML($file, $charset = null) {
			$contentType = $charset
				? ";charset=$charset"
				: '';
			return self::newDocumentFile($file, "application/xhtml+xml{$contentType}");
		}
		/**
		 * Creates new document from markup.
		 * Chainable.
		 *
		 * @param unknown_type $markup
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 */
		public static function newDocumentFilePHP($file, $contentType = null) {
			return self::newDocumentPHP(file_get_contents($file), $contentType);
		}
		/**
		 * Reuses existing DOMDocument object.
		 * Chainable.
		 *
		 * @param $document DOMDocument
		 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
		 * @TODO support DOMDocument
		 */
		public static function loadDocument($document) {
			// TODO
			die('TODO loadDocument');
		}
		/**
		 * Enter description here...
		 *
		 * @param unknown_type $html
		 * @param unknown_type $domId
		 * @return unknown New DOM ID
		 * @todo support PHP tags in input
		 * @todo support passing DOMDocument object from self::loadDocument
		 */
		protected static function createDocumentWrapper($html, $contentType = null, $documentID = null) {
			if (function_exists('domxml_open_mem'))
				throw new Exception("Old PHP4 DOM XML extension detected. phpQuery won't work until this extension is enabled.");
	//		$id = $documentID
	//			? $documentID
	//			: md5(microtime());
			$document = null;
			if ($html instanceof DOMDOCUMENT) {
				if (self::getDocumentID($html)) {
					// document already exists in phpQuery::$documents, make a copy
					$document = clone $html;
				} else {
					// new document, add it to phpQuery::$documents
					$wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
				}
			} else {
				$wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
			}
	//		$wrapper->id = $id;
			// bind document
			phpQuery::$documents[$wrapper->id] = $wrapper;
			// remember last loaded document
			phpQuery::selectDocument($wrapper->id);
			return $wrapper->id;
		}
		/**
		 * Extend class namespace.
		 *
		 * @param string|array $target
		 * @param array $source
		 * @TODO support string $source
		 * @return unknown_type
		 */
		public static function extend($target, $source) {
			switch($target) {
				case 'phpQueryObject':
					$targetRef = &self::$extendMethods;
					$targetRef2 = &self::$pluginsMethods;
					break;
				case 'phpQuery':
					$targetRef = &self::$extendStaticMethods;
					$targetRef2 = &self::$pluginsStaticMethods;
					break;
				default:
					throw new Exception("Unsupported \$target type");
			}
			if (is_string($source))
				$source = array($source => $source);
			foreach($source as $method => $callback) {
				if (isset($targetRef[$method])) {
	//				throw new Exception
					self::debug("Duplicate method '{$method}', can\'t extend '{$target}'");
					continue;
				}
				if (isset($targetRef2[$method])) {
	//				throw new Exception
					self::debug("Duplicate method '{$method}' from plugin '{$targetRef2[$method]}',"
						." can\'t extend '{$target}'");
					continue;
				}
				$targetRef[$method] = $callback;
			}
			return true;
		}
		/**
		 * Extend phpQuery with $class from $file.
		 *
		 * @param string $class Extending class name. Real class name can be prepended phpQuery_.
		 * @param string $file Filename to include. Defaults to "{$class}.php".
		 */
		public static function plugin($class, $file = null) {
			// TODO $class checked agains phpQuery_$class
	//		if (strpos($class, 'phpQuery') === 0)
	//			$class = substr($class, 8);
			if (in_array($class, self::$pluginsLoaded))
				return true;
			if (! $file)
				$file = $class.'.php';
			$objectClassExists = class_exists('phpQueryObjectPlugin_'.$class);
			$staticClassExists = class_exists('phpQueryPlugin_'.$class);
			if (! $objectClassExists && ! $staticClassExists)
				require_once($file);
			self::$pluginsLoaded[] = $class;
			// static methods
			if (class_exists('phpQueryPlugin_'.$class)) {
				$realClass = 'phpQueryPlugin_'.$class;
				$vars = get_class_vars($realClass);
				$loop = isset($vars['phpQueryMethods'])
					&& ! is_null($vars['phpQueryMethods'])
					? $vars['phpQueryMethods']
					: get_class_methods($realClass);
				foreach($loop as $method) {
					if ($method == '__initialize')
						continue;
					if (! is_callable(array($realClass, $method)))
						continue;
					if (isset(self::$pluginsStaticMethods[$method])) {
						throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsStaticMethods[$method]."'");
						return;
					}
					self::$pluginsStaticMethods[$method] = $class;
				}
				if (method_exists($realClass, '__initialize'))
					call_user_func_array(array($realClass, '__initialize'), array());
			}
			// object methods
			if (class_exists('phpQueryObjectPlugin_'.$class)) {
				$realClass = 'phpQueryObjectPlugin_'.$class;
				$vars = get_class_vars($realClass);
				$loop = isset($vars['phpQueryMethods'])
					&& ! is_null($vars['phpQueryMethods'])
					? $vars['phpQueryMethods']
					: get_class_methods($realClass);
				foreach($loop as $method) {
					if (! is_callable(array($realClass, $method)))
						continue;
					if (isset(self::$pluginsMethods[$method])) {
						throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsMethods[$method]."'");
						continue;
					}
					self::$pluginsMethods[$method] = $class;
				}
			}
			return true;
		}
		/**
		 * Unloades all or specified document from memory.
		 *
		 * @param mixed $documentID @see phpQuery::getDocumentID() for supported types.
		 */
		public static function unloadDocuments($id = null) {
			if (isset($id)) {
				if ($id = self::getDocumentID($id))
					unset(phpQuery::$documents[$id]);
			} else {
				foreach(phpQuery::$documents as $k => $v) {
					unset(phpQuery::$documents[$k]);
				}
			}
		}
		/**
		 * Parses phpQuery object or HTML result against PHP tags and makes them active.
		 *
		 * @param phpQuery|string $content
		 * @deprecated
		 * @return string
		 */
		public static function unsafePHPTags($content) {
			return self::markupToPHP($content);
		}
		public static function DOMNodeListToArray($DOMNodeList) {
			$array = array();
			if (! $DOMNodeList)
				return $array;
			foreach($DOMNodeList as $node)
				$array[] = $node;
			return $array;
		}
		/**
		 * Checks if $input is HTML string, which has to start with '<'.
		 *
		 * @deprecated
		 * @param String $input
		 * @return Bool
		 * @todo still used ?
		 */
		public static function isMarkup($input) {
			return ! is_array($input) && substr(trim($input), 0, 1) == '<';
		}
		public static function debug($text) {
			if (self::$debug)
				print var_dump($text);
		}
		/**
		 * Make an AJAX request.
		 *
		 * @param array See $options http://docs.jquery.com/Ajax/jQuery.ajax#toptions
		 * Additional options are:
		 * 'document' - document for global events, @see phpQuery::getDocumentID()
		 * 'referer' - implemented
		 * 'requested_with' - TODO; not implemented (X-Requested-With)
		 * @return Zend_Http_Client
		 * @link http://docs.jquery.com/Ajax/jQuery.ajax
		 *
		 * @TODO $options['cache']
		 * @TODO $options['processData']
		 * @TODO $options['xhr']
		 * @TODO $options['data'] as string
		 * @TODO XHR interface
		 */
		public static function ajax($options = array(), $xhr = null) {
			$options = array_merge(
				self::$ajaxSettings, $options
			);
			$documentID = isset($options['document'])
				? self::getDocumentID($options['document'])
				: null;
			if ($xhr) {
				// reuse existing XHR object, but clean it up
				$client = $xhr;
	//			$client->setParameterPost(null);
	//			$client->setParameterGet(null);
				$client->setAuth(false);
				$client->setHeaders("If-Modified-Since", null);
				$client->setHeaders("Referer", null);
				$client->resetParameters();
			} else {
				// create new XHR object
				require_once('Zend/Http/Client.php');
				$client = new Zend_Http_Client();
				$client->setCookieJar();
			}
			if (isset($options['timeout']))
				$client->setConfig(array(
					'timeout'      => $options['timeout'],
				));
	//			'maxredirects' => 0,
			foreach(self::$ajaxAllowedHosts as $k => $host)
				if ($host == '.' && isset($_SERVER['HTTP_HOST']))
					self::$ajaxAllowedHosts[$k] = $_SERVER['HTTP_HOST'];
			$host = parse_url($options['url'], PHP_URL_HOST);
			if (! in_array($host, self::$ajaxAllowedHosts)) {
				throw new Exception("Request not permitted, host '$host' not present in "
					."phpQuery::\$ajaxAllowedHosts");
			}
			// JSONP
			$jsre = "/=\\?(&|$)/";
			if (isset($options['dataType']) && $options['dataType'] == 'jsonp') {
				$jsonpCallbackParam = $options['jsonp']
					? $options['jsonp'] : 'callback';
				if (strtolower($options['type']) == 'get') {
					if (! preg_match($jsre, $options['url'])) {
						$sep = strpos($options['url'], '?')
							? '&' : '?';
						$options['url'] .= "$sep$jsonpCallbackParam=?";
					}
				} else if ($options['data']) {
					$jsonp = false;
					foreach($options['data'] as $n => $v) {
						if ($v == '?')
							$jsonp = true;
					}
					if (! $jsonp) {
						$options['data'][$jsonpCallbackParam] = '?';
					}
				}
				$options['dataType'] = 'json';
			}
			if (isset($options['dataType']) && $options['dataType'] == 'json') {
				$jsonpCallback = 'json_'.md5(microtime());
				$jsonpData = $jsonpUrl = false;
				if ($options['data']) {
					foreach($options['data'] as $n => $v) {
						if ($v == '?')
							$jsonpData = $n;
					}
				}
				if (preg_match($jsre, $options['url']))
					$jsonpUrl = true;
				if ($jsonpData !== false || $jsonpUrl) {
					// remember callback name for httpData()
					$options['_jsonp'] = $jsonpCallback;
					if ($jsonpData !== false)
						$options['data'][$jsonpData] = $jsonpCallback;
					if ($jsonpUrl)
						$options['url'] = preg_replace($jsre, "=$jsonpCallback\\1", $options['url']);
				}
			}
			$client->setUri($options['url']);
			$client->setMethod(strtoupper($options['type']));
			if (isset($options['referer']) && $options['referer'])
				$client->setHeaders('Referer', $options['referer']);
			$client->setHeaders(array(
	//			'content-type' => $options['contentType'],
				'User-Agent' => 'Mozilla/5.0 (X11; U; Linux x86; en-US; rv:1.9.0.5) Gecko'
					 .'/2008122010 Firefox/3.0.5',
		 		// TODO custom charset
				'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
	// 	 		'Connection' => 'keep-alive',
	// 			'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
		 		'Accept-Language' => 'en-us,en;q=0.5',
			));
			if ($options['username'])
				$client->setAuth($options['username'], $options['password']);
			if (isset($options['ifModified']) && $options['ifModified'])
				$client->setHeaders("If-Modified-Since",
					self::$lastModified
						? self::$lastModified
						: "Thu, 01 Jan 1970 00:00:00 GMT"
				);
			$client->setHeaders("Accept",
				isset($options['dataType'])
				&& isset(self::$ajaxSettings['accepts'][ $options['dataType'] ])
					? self::$ajaxSettings['accepts'][ $options['dataType'] ].", */*"
					: self::$ajaxSettings['accepts']['_default']
			);
			// TODO $options['processData']
			if ($options['data'] instanceof phpQueryObject) {
				$serialized = $options['data']->serializeArray($options['data']);
				$options['data'] = array();
				foreach($serialized as $r)
					$options['data'][ $r['name'] ] = $r['value'];
			}
			if (strtolower($options['type']) == 'get') {
				$client->setParameterGet($options['data']);
			} else if (strtolower($options['type']) == 'post') {
				$client->setEncType($options['contentType']);
				$client->setParameterPost($options['data']);
			}
			if (self::$active == 0 && $options['global'])
				phpQueryEvents::trigger($documentID, 'ajaxStart');
			self::$active++;
			// beforeSend callback
			if (isset($options['beforeSend']) && $options['beforeSend'])
				phpQuery::callbackRun($options['beforeSend'], array($client));
			// ajaxSend event
			if ($options['global'])
				phpQueryEvents::trigger($documentID, 'ajaxSend', array($client, $options));
			if (phpQuery::$debug) {
				self::debug("{$options['type']}: {$options['url']}\n");
				self::debug("Options: <pre>".var_export($options, true)."</pre>\n");
	//			if ($client->getCookieJar())
	//				self::debug("Cookies: <pre>".var_export($client->getCookieJar()->getMatchingCookies($options['url']), true)."</pre>\n");
			}
			// request
			$response = $client->request();
			if (phpQuery::$debug) {
				self::debug('Status: '.$response->getStatus().' / '.$response->getMessage());
				self::debug($client->getLastRequest());
				self::debug($response->getHeaders());
			}
			if ($response->isSuccessful()) {
				// XXX tempolary
				self::$lastModified = $response->getHeader('Last-Modified');
				$data = self::httpData($response->getBody(), $options['dataType'], $options);
				if (isset($options['success']) && $options['success'])
					phpQuery::callbackRun($options['success'], array($data, $response->getStatus(), $options));
				if ($options['global'])
					phpQueryEvents::trigger($documentID, 'ajaxSuccess', array($client, $options));
			} else {
				if (isset($options['error']) && $options['error'])
					phpQuery::callbackRun($options['error'], array($client, $response->getStatus(), $response->getMessage()));
				if ($options['global'])
					phpQueryEvents::trigger($documentID, 'ajaxError', array($client, /*$response->getStatus(),*/$response->getMessage(), $options));
			}
			if (isset($options['complete']) && $options['complete'])
				phpQuery::callbackRun($options['complete'], array($client, $response->getStatus()));
			if ($options['global'])
				phpQueryEvents::trigger($documentID, 'ajaxComplete', array($client, $options));
			if ($options['global'] && ! --self::$active)
				phpQueryEvents::trigger($documentID, 'ajaxStop');
			return $client;
	//		if (is_null($domId))
	//			$domId = self::$defaultDocumentID ? self::$defaultDocumentID : false;
	//		return new phpQueryAjaxResponse($response, $domId);
		}
		protected static function httpData($data, $type, $options) {
			if (isset($options['dataFilter']) && $options['dataFilter'])
				$data = self::callbackRun($options['dataFilter'], array($data, $type));
			if (is_string($data)) {
				if ($type == "json") {
					if (isset($options['_jsonp']) && $options['_jsonp']) {
						$data = preg_replace('/^\s*\w+\((.*)\)\s*$/s', '$1', $data);
					}
					$data = self::parseJSON($data);
				}
			}
			return $data;
		}
		/**
		 * Enter description here...
		 *
		 * @param array|phpQuery $data
		 *
		 */
		public static function param($data) {
			return http_build_query($data, null, '&');
		}
		public static function get($url, $data = null, $callback = null, $type = null) {
			if (!is_array($data)) {
				$callback = $data;
				$data = null;
			}
			// TODO some array_values on this shit
			return phpQuery::ajax(array(
				'type' => 'GET',
				'url' => $url,
				'data' => $data,
				'success' => $callback,
				'dataType' => $type,
			));
		}
		public static function post($url, $data = null, $callback = null, $type = null) {
			if (!is_array($data)) {
				$callback = $data;
				$data = null;
			}
			return phpQuery::ajax(array(
				'type' => 'POST',
				'url' => $url,
				'data' => $data,
				'success' => $callback,
				'dataType' => $type,
			));
		}
		public static function getJSON($url, $data = null, $callback = null) {
			if (!is_array($data)) {
				$callback = $data;
				$data = null;
			}
			// TODO some array_values on this shit
			return phpQuery::ajax(array(
				'type' => 'GET',
				'url' => $url,
				'data' => $data,
				'success' => $callback,
				'dataType' => 'json',
			));
		}
		public static function ajaxSetup($options) {
			self::$ajaxSettings = array_merge(
				self::$ajaxSettings,
				$options
			);
		}
		public static function ajaxAllowHost($host1, $host2 = null, $host3 = null) {
			$loop = is_array($host1)
				? $host1
				: func_get_args();
			foreach($loop as $host) {
				if ($host && ! in_array($host, phpQuery::$ajaxAllowedHosts)) {
					phpQuery::$ajaxAllowedHosts[] = $host;
				}
			}
		}
		public static function ajaxAllowURL($url1, $url2 = null, $url3 = null) {
			$loop = is_array($url1)
				? $url1
				: func_get_args();
			foreach($loop as $url)
				phpQuery::ajaxAllowHost(parse_url($url, PHP_URL_HOST));
		}
		/**
		 * Returns JSON representation of $data.
		 *
		 * @static
		 * @param mixed $data
		 * @return string
		 */
		public static function toJSON($data) {
			if (function_exists('json_encode'))
				return json_encode($data);
			require_once('Zend/Json/Encoder.php');
			return Zend_Json_Encoder::encode($data);
		}
		/**
		 * Parses JSON into proper PHP type.
		 *
		 * @static
		 * @param string $json
		 * @return mixed
		 */
		public static function parseJSON($json) {
			if (function_exists('json_decode')) {
				$return = json_decode(trim($json), true);
				// json_decode and UTF8 issues
				if (isset($return))
					return $return;
			}
			require_once('Zend/Json/Decoder.php');
			return Zend_Json_Decoder::decode($json);
		}
		/**
		 * Returns source's document ID.
		 *
		 * @param $source DOMNode|phpQueryObject
		 * @return string
		 */
		public static function getDocumentID($source) {
			if ($source instanceof DOMDOCUMENT) {
				foreach(phpQuery::$documents as $id => $document) {
					if ($source->isSameNode($document->document))
						return $id;
				}
			} else if ($source instanceof DOMNODE) {
				foreach(phpQuery::$documents as $id => $document) {
					if ($source->ownerDocument->isSameNode($document->document))
						return $id;
				}
			} else if ($source instanceof phpQueryObject)
				return $source->getDocumentID();
			else if (is_string($source) && isset(phpQuery::$documents[$source]))
				return $source;
		}
		/**
		 * Get DOMDocument object related to $source.
		 * Returns null if such document doesn't exist.
		 *
		 * @param $source DOMNode|phpQueryObject|string
		 * @return string
		 */
		public static function getDOMDocument($source) {
			if ($source instanceof DOMDOCUMENT)
				return $source;
			$source = self::getDocumentID($source);
			return $source
				? self::$documents[$id]['document']
				: null;
		}

		// UTILITIES
		// http://docs.jquery.com/Utilities

		/**
		 *
		 * @return unknown_type
		 * @link http://docs.jquery.com/Utilities/jQuery.makeArray
		 */
		public static function makeArray($obj) {
			$array = array();
			if (is_object($object) && $object instanceof DOMNODELIST) {
				foreach($object as $value)
					$array[] = $value;
			} else if (is_object($object) && ! ($object instanceof Iterator)) {
				foreach(get_object_vars($object) as $name => $value)
					$array[0][$name] = $value;
			} else {
				foreach($object as $name => $value)
					$array[0][$name] = $value;
			}
			return $array;
		}
		public static function inArray($value, $array) {
			return in_array($value, $array);
		}
		/**
		 *
		 * @param $object
		 * @param $callback
		 * @return unknown_type
		 * @link http://docs.jquery.com/Utilities/jQuery.each
		 */
		public static function each($object, $callback, $param1 = null, $param2 = null, $param3 = null) {
			$paramStructure = null;
			if (func_num_args() > 2) {
				$paramStructure = func_get_args();
				$paramStructure = array_slice($paramStructure, 2);
			}
			if (is_object($object) && ! ($object instanceof Iterator)) {
				foreach(get_object_vars($object) as $name => $value)
					phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
			} else {
				foreach($object as $name => $value)
					phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
			}
		}
		/**
		 *
		 * @link http://docs.jquery.com/Utilities/jQuery.map
		 */
		public static function map($array, $callback, $param1 = null, $param2 = null, $param3 = null) {
			$result = array();
			$paramStructure = null;
			if (func_num_args() > 2) {
				$paramStructure = func_get_args();
				$paramStructure = array_slice($paramStructure, 2);
			}
			foreach($array as $v) {
				$vv = phpQuery::callbackRun($callback, array($v), $paramStructure);
	//			$callbackArgs = $args;
	//			foreach($args as $i => $arg) {
	//				$callbackArgs[$i] = $arg instanceof CallbackParam
	//					? $v
	//					: $arg;
	//			}
	//			$vv = call_user_func_array($callback, $callbackArgs);
				if (is_array($vv))  {
					foreach($vv as $vvv)
						$result[] = $vvv;
				} else if ($vv !== null) {
					$result[] = $vv;
				}
			}
			return $result;
		}
		/**
		 *
		 * @param $callback Callback
		 * @param $params
		 * @param $paramStructure
		 * @return unknown_type
		 */
		public static function callbackRun($callback, $params = array(), $paramStructure = null) {
			if (! $callback)
				return;
			if ($callback instanceof CallbackParameterToReference) {
				// TODO support ParamStructure to select which $param push to reference
				if (isset($params[0]))
					$callback->callback = $params[0];
				return true;
			}
			if ($callback instanceof Callback) {
				$paramStructure = $callback->params;
				$callback = $callback->callback;
			}
			if (! $paramStructure)
				return call_user_func_array($callback, $params);
			$p = 0;
			foreach($paramStructure as $i => $v) {
				$paramStructure[$i] = $v instanceof CallbackParam
					? $params[$p++]
					: $v;
			}
			return call_user_func_array($callback, $paramStructure);
		}
		/**
		 * Merge 2 phpQuery objects.
		 * @param array $one
		 * @param array $two
		 * @protected
		 * @todo node lists, phpQueryObject
		 */
		public static function merge($one, $two) {
			$elements = $one->elements;
			foreach($two->elements as $node) {
				$exists = false;
				foreach($elements as $node2) {
					if ($node2->isSameNode($node))
						$exists = true;
				}
				if (! $exists)
					$elements[] = $node;
			}
			return $elements;
	//		$one = $one->newInstance();
	//		$one->elements = $elements;
	//		return $one;
		}
		/**
		 *
		 * @param $array
		 * @param $callback
		 * @param $invert
		 * @return unknown_type
		 * @link http://docs.jquery.com/Utilities/jQuery.grep
		 */
		public static function grep($array, $callback, $invert = false) {
			$result = array();
			foreach($array as $k => $v) {
				$r = call_user_func_array($callback, array($v, $k));
				if ($r === !(bool)$invert)
					$result[] = $v;
			}
			return $result;
		}
		public static function unique($array) {
			return array_unique($array);
		}
		/**
		 *
		 * @param $function
		 * @return unknown_type
		 * @TODO there are problems with non-static methods, second parameter pass it
		 * 	but doesnt verify is method is really callable
		 */
		public static function isFunction($function) {
			return is_callable($function);
		}
		public static function trim($str) {
			return trim($str);
		}
		/* PLUGINS NAMESPACE */
		/**
		 *
		 * @param $url
		 * @param $callback
		 * @param $param1
		 * @param $param2
		 * @param $param3
		 * @return phpQueryObject
		 */
		public static function browserGet($url, $callback, $param1 = null, $param2 = null, $param3 = null) {
			if (self::plugin('WebBrowser')) {
				$params = func_get_args();
				return self::callbackRun(array(self::$plugins, 'browserGet'), $params);
			} else {
				self::debug('WebBrowser plugin not available...');
			}
		}
		/**
		 *
		 * @param $url
		 * @param $data
		 * @param $callback
		 * @param $param1
		 * @param $param2
		 * @param $param3
		 * @return phpQueryObject
		 */
		public static function browserPost($url, $data, $callback, $param1 = null, $param2 = null, $param3 = null) {
			if (self::plugin('WebBrowser')) {
				$params = func_get_args();
				return self::callbackRun(array(self::$plugins, 'browserPost'), $params);
			} else {
				self::debug('WebBrowser plugin not available...');
			}
		}
		/**
		 *
		 * @param $ajaxSettings
		 * @param $callback
		 * @param $param1
		 * @param $param2
		 * @param $param3
		 * @return phpQueryObject
		 */
		public static function browser($ajaxSettings, $callback, $param1 = null, $param2 = null, $param3 = null) {
			if (self::plugin('WebBrowser')) {
				$params = func_get_args();
				return self::callbackRun(array(self::$plugins, 'browser'), $params);
			} else {
				self::debug('WebBrowser plugin not available...');
			}
		}
		/**
		 *
		 * @param $code
		 * @return string
		 */
		public static function php($code) {
			return self::code('php', $code);
		}
		/**
		 *
		 * @param $type
		 * @param $code
		 * @return string
		 */
		public static function code($type, $code) {
			return "<$type><!-- ".trim($code)." --></$type>";
		}

		public static function __callStatic($method, $params) {
			return call_user_func_array(
				array(phpQuery::$plugins, $method),
				$params
			);
		}
		protected static function dataSetupNode($node, $documentID) {
			// search are return if alredy exists
			foreach(phpQuery::$documents[$documentID]->dataNodes as $dataNode) {
				if ($node->isSameNode($dataNode))
					return $dataNode;
			}
			// if doesn't, add it
			phpQuery::$documents[$documentID]->dataNodes[] = $node;
			return $node;
		}
		protected static function dataRemoveNode($node, $documentID) {
			// search are return if alredy exists
			foreach(phpQuery::$documents[$documentID]->dataNodes as $k => $dataNode) {
				if ($node->isSameNode($dataNode)) {
					unset(self::$documents[$documentID]->dataNodes[$k]);
					unset(self::$documents[$documentID]->data[ $dataNode->dataID ]);
				}
			}
		}
		public static function data($node, $name, $data, $documentID = null) {
			if (! $documentID)
				// TODO check if this works
				$documentID = self::getDocumentID($node);
			$document = phpQuery::$documents[$documentID];
			$node = self::dataSetupNode($node, $documentID);
			if (! isset($node->dataID))
				$node->dataID = ++phpQuery::$documents[$documentID]->uuid;
			$id = $node->dataID;
			if (! isset($document->data[$id]))
				$document->data[$id] = array();
			if (! is_null($data))
				$document->data[$id][$name] = $data;
			if ($name) {
				if (isset($document->data[$id][$name]))
					return $document->data[$id][$name];
			} else
				return $id;
		}
		public static function removeData($node, $name, $documentID) {
			if (! $documentID)
				// TODO check if this works
				$documentID = self::getDocumentID($node);
			$document = phpQuery::$documents[$documentID];
			$node = self::dataSetupNode($node, $documentID);
			$id = $node->dataID;
			if ($name) {
				if (isset($document->data[$id][$name]))
					unset($document->data[$id][$name]);
				$name = null;
				foreach($document->data[$id] as $name)
					break;
				if (! $name)
					self::removeData($node, $name, $documentID);
			} else {
				self::dataRemoveNode($node, $documentID);
			}
		}
	}
}
/**
 * Plugins static namespace class.
 *
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @package phpQuery
 * @todo move plugin methods here (as statics)
 */
if (!class_exists('phpQueryPlugins')) {
	class phpQueryPlugins {
		public function __call($method, $args) {
			if (isset(phpQuery::$extendStaticMethods[$method])) {
				$return = call_user_func_array(
					phpQuery::$extendStaticMethods[$method],
					$args
				);
			} else if (isset(phpQuery::$pluginsStaticMethods[$method])) {
				$class = phpQuery::$pluginsStaticMethods[$method];
				$realClass = "phpQueryPlugin_$class";
				$return = call_user_func_array(
					array($realClass, $method),
					$args
				);
				return isset($return)
					? $return
					: $this;
			} else
				throw new Exception("Method '{$method}' doesnt exist");
		}
	}
}
/**
 * Shortcut to phpQuery::pq($arg1, $context)
 * Chainable.
 *
 * @see phpQuery::pq()
 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
 * @package phpQuery
 */
if (!function_exists('pq')) {
	function pq($arg1, $context = null) {
		$args = func_get_args();
		return call_user_func_array(
			array('phpQuery', 'pq'),
			$args
		);
	}
}
// add plugins dir and Zend framework to include path
set_include_path(
	get_include_path()
		.PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/'
		.PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/plugins/'
);
// why ? no __call nor __get for statics in php...
// XXX __callStatic will be available in PHP 5.3
phpQuery::$plugins = new phpQueryPlugins();
// include bootstrap file (personal library config)
if (file_exists(dirname(__FILE__).'/phpQuery/bootstrap.php'))
	require_once dirname(__FILE__).'/phpQuery/bootstrap.php';