gc2JRBmk

1<?php
2/**
3 * phpQuery is a server-side, chainable, CSS3 selector driven
4 * Document Object Model (DOM) API based on jQuery JavaScript Library.
5 *
6 * @version 0.9.5
7 * @link http://code.google.com/p/phpquery/
8 * @link http://phpquery-library.blogspot.com/
9 * @link http://jquery.com/
10 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
11 * @license http://www.opensource.org/licenses/mit-license.php MIT License
12 * @package phpQuery
13 */
14
15// class names for instanceof
16// TODO move them as class constants into phpQuery
17define('DOMDOCUMENT', 'DOMDocument');
18define('DOMELEMENT', 'DOMElement');
19define('DOMNODELIST', 'DOMNodeList');
20define('DOMNODE', 'DOMNode');
21
22/**
23 * DOMEvent class.
24 *
25 * Based on
26 * @link http://developer.mozilla.org/En/DOM:event
27 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
28 * @package phpQuery
29 * @todo implement ArrayAccess ?
30 */
31class DOMEvent {
32	/**
33	 * Returns a boolean indicating whether the event bubbles up through the DOM or not.
34	 *
35	 * @var unknown_type
36	 */
37	public $bubbles = true;
38	/**
39	 * Returns a boolean indicating whether the event is cancelable.
40	 *
41	 * @var unknown_type
42	 */
43	public $cancelable = true;
44	/**
45	 * Returns a reference to the currently registered target for the event.
46	 *
47	 * @var unknown_type
48	 */
49	public $currentTarget;
50	/**
51	 * Returns detail about the event, depending on the type of event.
52	 *
53	 * @var unknown_type
54	 * @link http://developer.mozilla.org/en/DOM/event.detail
55	 */
56	public $detail;	// ???
57	/**
58	 * Used to indicate which phase of the event flow is currently being evaluated.
59	 *
60	 * NOT IMPLEMENTED
61	 *
62	 * @var unknown_type
63	 * @link http://developer.mozilla.org/en/DOM/event.eventPhase
64	 */
65	public $eventPhase;	// ???
66	/**
67	 * The explicit original target of the event (Mozilla-specific).
68	 *
69	 * NOT IMPLEMENTED
70	 *
71	 * @var unknown_type
72	 */
73	public $explicitOriginalTarget; // moz only
74	/**
75	 * The original target of the event, before any retargetings (Mozilla-specific).
76	 *
77	 * NOT IMPLEMENTED
78	 *
79	 * @var unknown_type
80	 */
81	public $originalTarget;	// moz only
82	/**
83	 * Identifies a secondary target for the event.
84	 *
85	 * @var unknown_type
86	 */
87	public $relatedTarget;
88	/**
89	 * Returns a reference to the target to which the event was originally dispatched.
90	 *
91	 * @var unknown_type
92	 */
93	public $target;
94	/**
95	 * Returns the time that the event was created.
96	 *
97	 * @var unknown_type
98	 */
99	public $timeStamp;
100	/**
101	 * Returns the name of the event (case-insensitive).
102	 */
103	public $type;
104	public $runDefault = true;
105	public $data = null;
106	public function __construct($data) {
107		foreach($data as $k => $v) {
108			$this->$k = $v;
109		}
110		if (! $this->timeStamp)
111			$this->timeStamp = time();
112	}
113	/**
114	 * Cancels the event (if it is cancelable).
115	 *
116	 */
117	public function preventDefault() {
118		$this->runDefault = false;
119	}
120	/**
121	 * Stops the propagation of events further along in the DOM.
122	 *
123	 */
124	public function stopPropagation() {
125		$this->bubbles = false;
126	}
127}
128
129
130/**
131 * DOMDocumentWrapper class simplifies work with DOMDocument.
132 *
133 * Know bug:
134 * - in XHTML fragments, <br /> changes to <br clear="none" />
135 *
136 * @todo check XML catalogs compatibility
137 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
138 * @package phpQuery
139 */
140class DOMDocumentWrapper {
141	/**
142	 * @var DOMDocument
143	 */
144	public $document;
145	public $id;
146	/**
147	 * @todo Rewrite as method and quess if null.
148	 * @var unknown_type
149	 */
150	public $contentType = '';
151	public $xpath;
152	public $uuid = 0;
153	public $data = array();
154	public $dataNodes = array();
155	public $events = array();
156	public $eventsNodes = array();
157	public $eventsGlobal = array();
158	/**
159	 * @TODO iframes support http://code.google.com/p/phpquery/issues/detail?id=28
160	 * @var unknown_type
161	 */
162	public $frames = array();
163	/**
164	 * Document root, by default equals to document itself.
165	 * Used by documentFragments.
166	 *
167	 * @var DOMNode
168	 */
169	public $root;
170	public $isDocumentFragment;
171	public $isXML = false;
172	public $isXHTML = false;
173	public $isHTML = false;
174	public $charset;
175	public function __construct($markup = null, $contentType = null, $newDocumentID = null) {
176		if (isset($markup))
177			$this->load($markup, $contentType, $newDocumentID);
178		$this->id = $newDocumentID
179			? $newDocumentID
180			: md5(microtime());
181	}
182	public function load($markup, $contentType = null, $newDocumentID = null) {
183//		phpQuery::$documents[$id] = $this;
184		$this->contentType = strtolower($contentType);
185		if ($markup instanceof DOMDOCUMENT) {
186			$this->document = $markup;
187			$this->root = $this->document;
188			$this->charset = $this->document->encoding;
189			// TODO isDocumentFragment
190		} else {
191			$loaded = $this->loadMarkup($markup);
192		}
193		if ($loaded) {
194//			$this->document->formatOutput = true;
195			$this->document->preserveWhiteSpace = true;
196			$this->xpath = new DOMXPath($this->document);
197			$this->afterMarkupLoad();
198			return true;
199			// remember last loaded document
200//			return phpQuery::selectDocument($id);
201		}
202		return false;
203	}
204	protected function afterMarkupLoad() {
205		if ($this->isXHTML) {
206			$this->xpath->registerNamespace("html", "http://www.w3.org/1999/xhtml");
207		}
208	}
209	protected function loadMarkup($markup) {
210		$loaded = false;
211		if ($this->contentType) {
212			self::debug("Load markup for content type {$this->contentType}");
213			// content determined by contentType
214			list($contentType, $charset) = $this->contentTypeToArray($this->contentType);
215			switch($contentType) {
216				case 'text/html':
217					phpQuery::debug("Loading HTML, content type '{$this->contentType}'");
218					$loaded = $this->loadMarkupHTML($markup, $charset);
219				break;
220				case 'text/xml':
221				case 'application/xhtml+xml':
222					phpQuery::debug("Loading XML, content type '{$this->contentType}'");
223					$loaded = $this->loadMarkupXML($markup, $charset);
224				break;
225				default:
226					// for feeds or anything that sometimes doesn't use text/xml
227					if (strpos('xml', $this->contentType) !== false) {
228						phpQuery::debug("Loading XML, content type '{$this->contentType}'");
229						$loaded = $this->loadMarkupXML($markup, $charset);
230					} else
231						phpQuery::debug("Could not determine document type from content type '{$this->contentType}'");
232			}
233		} else {
234			// content type autodetection
235			if ($this->isXML($markup)) {
236				phpQuery::debug("Loading XML, isXML() == true");
237				$loaded = $this->loadMarkupXML($markup);
238				if (! $loaded && $this->isXHTML) {
239					phpQuery::debug('Loading as XML failed, trying to load as HTML, isXHTML == true');
240					$loaded = $this->loadMarkupHTML($markup);
241				}
242			} else {
243				phpQuery::debug("Loading HTML, isXML() == false");
244				$loaded = $this->loadMarkupHTML($markup);
245			}
246		}
247		return $loaded;
248	}
249	protected function loadMarkupReset() {
250		$this->isXML = $this->isXHTML = $this->isHTML = false;
251	}
252	protected function documentCreate($charset, $version = '1.0') {
253		if (! $version)
254			$version = '1.0';
255		$this->document = new DOMDocument($version, $charset);
256		$this->charset = $this->document->encoding;
257//		$this->document->encoding = $charset;
258		$this->document->formatOutput = true;
259		$this->document->preserveWhiteSpace = true;
260	}
261	protected function loadMarkupHTML($markup, $requestedCharset = null) {
262		if (phpQuery::$debug)
263			phpQuery::debug('Full markup load (HTML): '.substr($markup, 0, 250));
264		$this->loadMarkupReset();
265		$this->isHTML = true;
266		if (!isset($this->isDocumentFragment))
267			$this->isDocumentFragment = self::isDocumentFragmentHTML($markup);
268		$charset = null;
269		$documentCharset = $this->charsetFromHTML($markup);
270		$addDocumentCharset = false;
271		if ($documentCharset) {
272			$charset = $documentCharset;
273			$markup = $this->charsetFixHTML($markup);
274		} else if ($requestedCharset) {
275			$charset = $requestedCharset;
276		}
277		if (! $charset)
278			$charset = phpQuery::$defaultCharset;
279		// HTTP 1.1 says that the default charset is ISO-8859-1
280		// @see http://www.w3.org/International/O-HTTP-charset
281		if (! $documentCharset) {
282			$documentCharset = 'ISO-8859-1';
283			$addDocumentCharset = true;	
284		}
285		// Should be careful here, still need 'magic encoding detection' since lots of pages have other 'default encoding'
286		// Worse, some pages can have mixed encodings... we'll try not to worry about that
287		$requestedCharset = strtoupper($requestedCharset);
288		$documentCharset = strtoupper($documentCharset);
289		phpQuery::debug("DOC: $documentCharset REQ: $requestedCharset");
290		if ($requestedCharset && $documentCharset && $requestedCharset !== $documentCharset) {
291			phpQuery::debug("CHARSET CONVERT");
292			// Document Encoding Conversion
293			// http://code.google.com/p/phpquery/issues/detail?id=86
294			if (function_exists('mb_detect_encoding')) {
295				$possibleCharsets = array($documentCharset, $requestedCharset, 'AUTO');
296				$docEncoding = mb_detect_encoding($markup, implode(', ', $possibleCharsets));
297				if (! $docEncoding)
298					$docEncoding = $documentCharset; // ok trust the document
299				phpQuery::debug("DETECTED '$docEncoding'");
300				// Detected does not match what document says...
301				if ($docEncoding !== $documentCharset) {
302					// Tricky..
303				}
304				if ($docEncoding !== $requestedCharset) {
305					phpQuery::debug("CONVERT $docEncoding => $requestedCharset");
306					$markup = mb_convert_encoding($markup, $requestedCharset, $docEncoding);
307					$markup = $this->charsetAppendToHTML($markup, $requestedCharset);
308					$charset = $requestedCharset;
309				}
310			} else {
311				phpQuery::debug("TODO: charset conversion without mbstring...");
312			}
313		}
314		$return = false;
315		if ($this->isDocumentFragment) {
316			phpQuery::debug("Full markup load (HTML), DocumentFragment detected, using charset '$charset'");
317			$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
318		} else {
319			if ($addDocumentCharset) {
320				phpQuery::debug("Full markup load (HTML), appending charset: '$charset'");
321				$markup = $this->charsetAppendToHTML($markup, $charset);
322			}
323			phpQuery::debug("Full markup load (HTML), documentCreate('$charset')");
324			$this->documentCreate($charset);
325			$return = phpQuery::$debug === 2
326				? $this->document->loadHTML($markup)
327				: @$this->document->loadHTML($markup);
328			if ($return)
329				$this->root = $this->document;
330		}
331		if ($return && ! $this->contentType)
332			$this->contentType = 'text/html';
333		return $return;
334	}
335	protected function loadMarkupXML($markup, $requestedCharset = null) {
336		if (phpQuery::$debug)
337			phpQuery::debug('Full markup load (XML): '.substr($markup, 0, 250));
338		$this->loadMarkupReset();
339		$this->isXML = true;
340		// check agains XHTML in contentType or markup
341		$isContentTypeXHTML = $this->isXHTML();
342		$isMarkupXHTML = $this->isXHTML($markup);
343		if ($isContentTypeXHTML || $isMarkupXHTML) {
344			self::debug('Full markup load (XML), XHTML detected');
345			$this->isXHTML = true;
346		}
347		// determine document fragment
348		if (! isset($this->isDocumentFragment))
349			$this->isDocumentFragment = $this->isXHTML
350				? self::isDocumentFragmentXHTML($markup)
351				: self::isDocumentFragmentXML($markup);
352		// this charset will be used
353		$charset = null;
354		// charset from XML declaration @var string
355		$documentCharset = $this->charsetFromXML($markup);
356		if (! $documentCharset) {
357			if ($this->isXHTML) {
358				// this is XHTML, try to get charset from content-type meta header
359				$documentCharset = $this->charsetFromHTML($markup);
360				if ($documentCharset) {
361					phpQuery::debug("Full markup load (XML), appending XHTML charset '$documentCharset'");
362					$this->charsetAppendToXML($markup, $documentCharset);
363					$charset = $documentCharset;
364				}
365			}
366			if (! $documentCharset) {
367				// if still no document charset...
368				$charset = $requestedCharset;
369			}
370		} else if ($requestedCharset) {
371			$charset = $requestedCharset;
372		}
373		if (! $charset) {
374			$charset = phpQuery::$defaultCharset;
375		}
376		if ($requestedCharset && $documentCharset && $requestedCharset != $documentCharset) {
377			// TODO place for charset conversion
378//			$charset = $requestedCharset;
379		}
380		$return = false;
381		if ($this->isDocumentFragment) {
382			phpQuery::debug("Full markup load (XML), DocumentFragment detected, using charset '$charset'");
383			$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
384		} else {
385			// FIXME ???
386			if ($isContentTypeXHTML && ! $isMarkupXHTML)
387			if (! $documentCharset) {
388				phpQuery::debug("Full markup load (XML), appending charset '$charset'");
389				$markup = $this->charsetAppendToXML($markup, $charset);
390			}
391			// see http://pl2.php.net/manual/en/book.dom.php#78929
392			// LIBXML_DTDLOAD (>= PHP 5.1)
393			// does XML ctalogues works with LIBXML_NONET
394	//		$this->document->resolveExternals = true;
395			// TODO test LIBXML_COMPACT for performance improvement
396			// create document
397			$this->documentCreate($charset);
398			if (phpversion() < 5.1) {
399				$this->document->resolveExternals = true;
400				$return = phpQuery::$debug === 2
401					? $this->document->loadXML($markup)
402					: @$this->document->loadXML($markup);
403			} else {
404				/** @link http://pl2.php.net/manual/en/libxml.constants.php */
405				$libxmlStatic = phpQuery::$debug === 2
406					? LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET
407					: LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET|LIBXML_NOWARNING|LIBXML_NOERROR;
408				$return = $this->document->loadXML($markup, $libxmlStatic);
409// 				if (! $return)
410// 					$return = $this->document->loadHTML($markup);
411			}
412			if ($return)
413				$this->root = $this->document;
414		}
415		if ($return) {
416			if (! $this->contentType) {
417				if ($this->isXHTML)
418					$this->contentType = 'application/xhtml+xml';
419				else
420					$this->contentType = 'text/xml';
421			}
422			return $return;
423		} else {
424			throw new Exception("Error loading XML markup");
425		}
426	}
427	protected function isXHTML($markup = null) {
428		if (! isset($markup)) {
429			return strpos($this->contentType, 'xhtml') !== false;
430		}
431		// XXX ok ?
432		return strpos($markup, "<!DOCTYPE html") !== false;
433//		return stripos($doctype, 'xhtml') !== false;
434//		$doctype = isset($dom->doctype) && is_object($dom->doctype)
435//			? $dom->doctype->publicId
436//			: self::$defaultDoctype;
437	}
438	protected function isXML($markup) {
439//		return strpos($markup, '<?xml') !== false && stripos($markup, 'xhtml') === false;
440		return strpos(substr($markup, 0, 100), '<'.'?xml') !== false;
441	}
442	protected function contentTypeToArray($contentType) {
443		$matches = explode(';', trim(strtolower($contentType)));
444		if (isset($matches[1])) {
445			$matches[1] = explode('=', $matches[1]);
446			// strip 'charset='
447			$matches[1] = isset($matches[1][1]) && trim($matches[1][1])
448				? $matches[1][1]
449				: $matches[1][0];
450		} else
451			$matches[1] = null;
452		return $matches;
453	}
454	/**
455	 *
456	 * @param $markup
457	 * @return array contentType, charset
458	 */
459	protected function contentTypeFromHTML($markup) {
460		$matches = array();
461		// find meta tag
462		preg_match('@<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
463			$markup, $matches
464		);
465		if (! isset($matches[0]))
466			return array(null, null);
467		// get attr 'content'
468		preg_match('@content\\s*=\\s*(["|\'])(.+?)\\1@', $matches[0], $matches);
469		if (! isset($matches[0]))
470			return array(null, null);
471		return $this->contentTypeToArray($matches[2]);
472	}
473	protected function charsetFromHTML($markup) {
474		$contentType = $this->contentTypeFromHTML($markup);
475		return $contentType[1];
476	}
477	protected function charsetFromXML($markup) {
478		$matches;
479		// find declaration
480		preg_match('@<'.'?xml[^>]+encoding\\s*=\\s*(["|\'])(.*?)\\1@i',
481			$markup, $matches
482		);
483		return isset($matches[2])
484			? strtolower($matches[2])
485			: null;
486	}
487	/**
488	 * Repositions meta[type=charset] at the start of head. Bypasses DOMDocument bug.
489	 *
490	 * @link http://code.google.com/p/phpquery/issues/detail?id=80
491	 * @param $html
492	 */
493	protected function charsetFixHTML($markup) {
494		$matches = array();
495		// find meta tag
496		preg_match('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
497			$markup, $matches, PREG_OFFSET_CAPTURE
498		);
499		if (! isset($matches[0]))
500			return;
501		$metaContentType = $matches[0][0];
502		$markup = substr($markup, 0, $matches[0][1])
503			.substr($markup, $matches[0][1]+strlen($metaContentType));
504		$headStart = stripos($markup, '<head>');
505		$markup = substr($markup, 0, $headStart+6).$metaContentType
506			.substr($markup, $headStart+6);
507		return $markup;
508	}
509	protected function charsetAppendToHTML($html, $charset, $xhtml = false) {
510		// remove existing meta[type=content-type]
511		$html = preg_replace('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i', '', $html);
512		$meta = '<meta http-equiv="Content-Type" content="text/html;charset='
513			.$charset.'" '
514			.($xhtml ? '/' : '')
515			.'>';
516		if (strpos($html, '<head') === false) {
517			if (strpos($hltml, '<html') === false) {
518				return $meta.$html;
519			} else {
520				return preg_replace(
521					'@<html(.*?)(?(?<!\?)>)@s',
522					"<html\\1><head>{$meta}</head>",
523					$html
524				);
525			}
526		} else {
527			return preg_replace(
528				'@<head(.*?)(?(?<!\?)>)@s',
529				'<head\\1>'.$meta,
530				$html
531			);
532		}
533	}
534	protected function charsetAppendToXML($markup, $charset) {
535		$declaration = '<'.'?xml version="1.0" encoding="'.$charset.'"?'.'>';
536		return $declaration.$markup;
537	}
538	public static function isDocumentFragmentHTML($markup) {
539		return stripos($markup, '<html') === false && stripos($markup, '<!doctype') === false;
540	}
541	public static function isDocumentFragmentXML($markup) {
542		return stripos($markup, '<'.'?xml') === false;
543	}
544	public static function isDocumentFragmentXHTML($markup) {
545		return self::isDocumentFragmentHTML($markup);
546	}
547	public function importAttr($value) {
548		// TODO
549	}
550	/**
551	 *
552	 * @param $source
553	 * @param $target
554	 * @param $sourceCharset
555	 * @return array Array of imported nodes.
556	 */
557	public function import($source, $sourceCharset = null) {
558		// TODO charset conversions
559		$return = array();
560		if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
561			$source = array($source);
562//		if (is_array($source)) {
563//			foreach($source as $node) {
564//				if (is_string($node)) {
565//					// string markup
566//					$fake = $this->documentFragmentCreate($node, $sourceCharset);
567//					if ($fake === false)
568//						throw new Exception("Error loading documentFragment markup");
569//					else
570//						$return = array_merge($return, 
571//							$this->import($fake->root->childNodes)
572//						);
573//				} else {
574//					$return[] = $this->document->importNode($node, true);
575//				}
576//			}
577//			return $return;
578//		} else {
579//			// string markup
580//			$fake = $this->documentFragmentCreate($source, $sourceCharset);
581//			if ($fake === false)
582//				throw new Exception("Error loading documentFragment markup");
583//			else
584//				return $this->import($fake->root->childNodes);
585//		}
586		if (is_array($source) || $source instanceof DOMNODELIST) {
587			// dom nodes
588			self::debug('Importing nodes to document');
589			foreach($source as $node)
590				$return[] = $this->document->importNode($node, true);
591		} else {
592			// string markup
593			$fake = $this->documentFragmentCreate($source, $sourceCharset);
594			if ($fake === false)
595				throw new Exception("Error loading documentFragment markup");
596			else
597				return $this->import($fake->root->childNodes);
598		}
599		return $return;
600	}
601	/**
602	 * Creates new document fragment.
603	 *
604	 * @param $source
605	 * @return DOMDocumentWrapper
606	 */
607	protected function documentFragmentCreate($source, $charset = null) {
608		$fake = new DOMDocumentWrapper();
609		$fake->contentType = $this->contentType;
610		$fake->isXML = $this->isXML;
611		$fake->isHTML = $this->isHTML;
612		$fake->isXHTML = $this->isXHTML;
613		$fake->root = $fake->document;
614		if (! $charset)
615			$charset = $this->charset;
616//	$fake->documentCreate($this->charset);
617		if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
618			$source = array($source);
619		if (is_array($source) || $source instanceof DOMNODELIST) {
620			// dom nodes
621			// load fake document
622			if (! $this->documentFragmentLoadMarkup($fake, $charset))
623				return false;
624			$nodes = $fake->import($source);
625			foreach($nodes as $node)
626				$fake->root->appendChild($node);
627		} else {
628			// string markup
629			$this->documentFragmentLoadMarkup($fake, $charset, $source);
630		}
631		return $fake;
632	}
633	/**
634	 *
635	 * @param $document DOMDocumentWrapper
636	 * @param $markup
637	 * @return $document
638	 */
639	private function documentFragmentLoadMarkup($fragment, $charset, $markup = null) {
640		// TODO error handling
641		// TODO copy doctype
642		// tempolary turn off
643		$fragment->isDocumentFragment = false;
644		if ($fragment->isXML) {
645			if ($fragment->isXHTML) {
646				// add FAKE element to set default namespace
647				$fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?>'
648					.'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
649					.'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
650					.'<fake xmlns="http://www.w3.org/1999/xhtml">'.$markup.'</fake>');
651				$fragment->root = $fragment->document->firstChild->nextSibling;
652			} else {
653				$fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?><fake>'.$markup.'</fake>');
654				$fragment->root = $fragment->document->firstChild;
655			}
656		} else {
657			$markup2 = phpQuery::$defaultDoctype.'<html><head><meta http-equiv="Content-Type" content="text/html;charset='
658				.$charset.'"></head>';
659			$noBody = strpos($markup, '<body') === false;
660			if ($noBody)
661				$markup2 .= '<body>';
662			$markup2 .= $markup;
663			if ($noBody)
664				$markup2 .= '</body>';
665			$markup2 .= '</html>';
666			$fragment->loadMarkupHTML($markup2);
667			// TODO resolv body tag merging issue
668			$fragment->root = $noBody
669				? $fragment->document->firstChild->nextSibling->firstChild->nextSibling
670				: $fragment->document->firstChild->nextSibling->firstChild->nextSibling;
671		}
672		if (! $fragment->root)
673			return false;
674		$fragment->isDocumentFragment = true;
675		return true;
676	}
677	protected function documentFragmentToMarkup($fragment) {
678		phpQuery::debug('documentFragmentToMarkup');
679		$tmp = $fragment->isDocumentFragment;
680		$fragment->isDocumentFragment = false;
681		$markup = $fragment->markup();
682		if ($fragment->isXML) {
683			$markup = substr($markup, 0, strrpos($markup, '</fake>'));
684			if ($fragment->isXHTML) {
685				$markup = substr($markup, strpos($markup, '<fake')+43);
686			} else {
687				$markup = substr($markup, strpos($markup, '<fake>')+6);
688			}
689		} else {
690				$markup = substr($markup, strpos($markup, '<body>')+6);
691				$markup = substr($markup, 0, strrpos($markup, '</body>'));
692		}
693		$fragment->isDocumentFragment = $tmp;
694		if (phpQuery::$debug)
695			phpQuery::debug('documentFragmentToMarkup: '.substr($markup, 0, 150));
696		return $markup;
697	}
698	/**
699	 * Return document markup, starting with optional $nodes as root.
700	 *
701	 * @param $nodes	DOMNode|DOMNodeList
702	 * @return string
703	 */
704	public function markup($nodes = null, $innerMarkup = false) {
705		if (isset($nodes) && count($nodes) == 1 && $nodes[0] instanceof DOMDOCUMENT)
706			$nodes = null;
707		if (isset($nodes)) {
708			$markup = '';
709			if (!is_array($nodes) && !($nodes instanceof DOMNODELIST) )
710				$nodes = array($nodes);
711			if ($this->isDocumentFragment && ! $innerMarkup)
712				foreach($nodes as $i => $node)
713					if ($node->isSameNode($this->root)) {
714					//	var_dump($node);
715						$nodes = array_slice($nodes, 0, $i)
716							+ phpQuery::DOMNodeListToArray($node->childNodes)
717							+ array_slice($nodes, $i+1);
718						}
719			if ($this->isXML && ! $innerMarkup) {
720				self::debug("Getting outerXML with charset '{$this->charset}'");
721				// we need outerXML, so we can benefit from
722				// $node param support in saveXML()
723				foreach($nodes as $node)
724					$markup .= $this->document->saveXML($node);
725			} else {
726				$loop = array();
727				if ($innerMarkup)
728					foreach($nodes as $node) {
729						if ($node->childNodes)
730							foreach($node->childNodes as $child)
731								$loop[] = $child;
732						else
733							$loop[] = $node;
734					}
735				else
736					$loop = $nodes;
737				self::debug("Getting markup, moving selected nodes (".count($loop).") to new DocumentFragment");
738				$fake = $this->documentFragmentCreate($loop);
739				$markup = $this->documentFragmentToMarkup($fake);
740			}
741			if ($this->isXHTML) {
742				self::debug("Fixing XHTML");
743				$markup = self::markupFixXHTML($markup);
744			}
745			self::debug("Markup: ".substr($markup, 0, 250));
746			return $markup;
747		} else {
748			if ($this->isDocumentFragment) {
749				// documentFragment, html only...
750				self::debug("Getting markup, DocumentFragment detected");
751//				return $this->markup(
752////					$this->document->getElementsByTagName('body')->item(0)
753//					$this->document->root, true
754//				);
755				$markup = $this->documentFragmentToMarkup($this);
756				// no need for markupFixXHTML, as it's done thought markup($nodes) method
757				return $markup;
758			} else {
759				self::debug("Getting markup (".($this->isXML?'XML':'HTML')."), final with charset '{$this->charset}'");
760				$markup = $this->isXML
761					? $this->document->saveXML()
762					: $this->document->saveHTML();
763				if ($this->isXHTML) {
764					self::debug("Fixing XHTML");
765					$markup = self::markupFixXHTML($markup);
766				}
767				self::debug("Markup: ".substr($markup, 0, 250));
768				return $markup;
769			}
770		}
771	}
772	protected static function markupFixXHTML($markup) {
773		$markup = self::expandEmptyTag('script', $markup);
774		$markup = self::expandEmptyTag('select', $markup);
775		$markup = self::expandEmptyTag('textarea', $markup);
776		return $markup;
777	}
778	public static function debug($text) {
779		phpQuery::debug($text);
780	}
781	/**
782	 * expandEmptyTag
783	 *
784	 * @param $tag
785	 * @param $xml
786	 * @return unknown_type
787	 * @author mjaque at ilkebenson dot com
788	 * @link http://php.net/manual/en/domdocument.savehtml.php#81256
789	 */
790	public static function expandEmptyTag($tag, $xml){
791        $indice = 0;
792        while ($indice< strlen($xml)){
793            $pos = strpos($xml, "<$tag ", $indice);
794            if ($pos){
795                $posCierre = strpos($xml, ">", $pos);
796                if ($xml[$posCierre-1] == "/"){
797                    $xml = substr_replace($xml, "></$tag>", $posCierre-1, 2);
798                }
799                $indice = $posCierre;
800            }
801            else break;
802        }
803        return $xml;
804	}
805}
806
807/**
808 * Event handling class.
809 *
810 * @author Tobiasz Cudnik
811 * @package phpQuery
812 * @static
813 */
814abstract class phpQueryEvents {
815	/**
816	 * Trigger a type of event on every matched element.
817	 *
818	 * @param DOMNode|phpQueryObject|string $document
819	 * @param unknown_type $type
820	 * @param unknown_type $data
821	 *
822	 * @TODO exclusive events (with !)
823	 * @TODO global events (test)
824	 * @TODO support more than event in $type (space-separated)
825	 */
826	public static function trigger($document, $type, $data = array(), $node = null) {
827		// trigger: function(type, data, elem, donative, extra) {
828		$documentID = phpQuery::getDocumentID($document);
829		$namespace = null;
830		if (strpos($type, '.') !== false)
831			list($name, $namespace) = explode('.', $type);
832		else
833			$name = $type;
834		if (! $node) {
835			if (self::issetGlobal($documentID, $type)) {
836				$pq = phpQuery::getDocument($documentID);
837				// TODO check add($pq->document)
838				$pq->find('*')->add($pq->document)
839					->trigger($type, $data);
840			}
841		} else {
842			if (isset($data[0]) && $data[0] instanceof DOMEvent) {
843				$event = $data[0];
844				$event->relatedTarget = $event->target;
845				$event->target = $node;
846				$data = array_slice($data, 1);
847			} else {
848				$event = new DOMEvent(array(
849					'type' => $type,
850					'target' => $node,
851					'timeStamp' => time(),
852				));
853			}
854			$i = 0;
855			while($node) {
856				// TODO whois
857				phpQuery::debug("Triggering ".($i?"bubbled ":'')."event '{$type}' on "
858					."node \n");//.phpQueryObject::whois($node)."\n");
859				$event->currentTarget = $node;
860				$eventNode = self::getNode($documentID, $node);
861				if (isset($eventNode->eventHandlers)) {
862					foreach($eventNode->eventHandlers as $eventType => $handlers) {
863						$eventNamespace = null;
864						if (strpos($type, '.') !== false)
865							list($eventName, $eventNamespace) = explode('.', $eventType);
866						else
867							$eventName = $eventType;
868						if ($name != $eventName)
869							continue;
870						if ($namespace && $eventNamespace && $namespace != $eventNamespace)
871							continue;
872						foreach($handlers as $handler) {
873							phpQuery::debug("Calling event handler\n");
874							$event->data = $handler['data']
875								? $handler['data']
876								: null;
877							$params = array_merge(array($event), $data);
878							$return = phpQuery::callbackRun($handler['callback'], $params);
879							if ($return === false) {
880								$event->bubbles = false;
881							}
882						}
883					}
884				}
885				// to bubble or not to bubble...
886				if (! $event->bubbles)
887					break;
888				$node = $node->parentNode;
889				$i++;
890			}
891		}
892	}
893	/**
894	 * Binds a handler to one or more events (like click) for each matched element.
895	 * Can also bind custom events.
896	 *
897	 * @param DOMNode|phpQueryObject|string $document
898	 * @param unknown_type $type
899	 * @param unknown_type $data Optional
900	 * @param unknown_type $callback
901	 *
902	 * @TODO support '!' (exclusive) events
903	 * @TODO support more than event in $type (space-separated)
904	 * @TODO support binding to global events
905	 */
906	public static function add($document, $node, $type, $data, $callback = null) {
907		phpQuery::debug("Binding '$type' event");
908		$documentID = phpQuery::getDocumentID($document);
909//		if (is_null($callback) && is_callable($data)) {
910//			$callback = $data;
911//			$data = null;
912//		}
913		$eventNode = self::getNode($documentID, $node);
914		if (! $eventNode)
915			$eventNode = self::setNode($documentID, $node);
916		if (!isset($eventNode->eventHandlers[$type]))
917			$eventNode->eventHandlers[$type] = array();
918		$eventNode->eventHandlers[$type][] = array(
919			'callback' => $callback,
920			'data' => $data,
921		);
922	}
923	/**
924	 * Enter description here...
925	 *
926	 * @param DOMNode|phpQueryObject|string $document
927	 * @param unknown_type $type
928	 * @param unknown_type $callback
929	 *
930	 * @TODO namespace events
931	 * @TODO support more than event in $type (space-separated)
932	 */
933	public static function remove($document, $node, $type = null, $callback = null) {
934		$documentID = phpQuery::getDocumentID($document);
935		$eventNode = self::getNode($documentID, $node);
936		if (is_object($eventNode) && isset($eventNode->eventHandlers[$type])) {
937			if ($callback) {
938				foreach($eventNode->eventHandlers[$type] as $k => $handler)
939					if ($handler['callback'] == $callback)
940						unset($eventNode->eventHandlers[$type][$k]);
941			} else {
942				unset($eventNode->eventHandlers[$type]);
943			}
944		}
945	}
946	protected static function getNode($documentID, $node) {
947		foreach(phpQuery::$documents[$documentID]->eventsNodes as $eventNode) {
948			if ($node->isSameNode($eventNode))
949				return $eventNode;
950		}
951	}
952	protected static function setNode($documentID, $node) {
953		phpQuery::$documents[$documentID]->eventsNodes[] = $node;
954		return phpQuery::$documents[$documentID]->eventsNodes[
955			count(phpQuery::$documents[$documentID]->eventsNodes)-1
956		];
957	}
958	protected static function issetGlobal($documentID, $type) {
959		return isset(phpQuery::$documents[$documentID])
960			? in_array($type, phpQuery::$documents[$documentID]->eventsGlobal)
961			: false;
962	}
963}
964
965
966interface ICallbackNamed {
967	function hasName();
968	function getName();
969}
970/**
971 * Callback class introduces currying-like pattern.
972 * 
973 * Example:
974 * function foo($param1, $param2, $param3) {
975 *   var_dump($param1, $param2, $param3);
976 * }
977 * $fooCurried = new Callback('foo', 
978 *   'param1 is now statically set', 
979 *   new CallbackParam, new CallbackParam
980 * );
981 * phpQuery::callbackRun($fooCurried,
982 * 	array('param2 value', 'param3 value'
983 * );
984 * 
985 * Callback class is supported in all phpQuery methods which accepts callbacks. 
986 *
987 * @link http://code.google.com/p/phpquery/wiki/Callbacks#Param_Structures
988 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
989 * 
990 * @TODO??? return fake forwarding function created via create_function
991 * @TODO honor paramStructure
992 */
993class Callback
994	implements ICallbackNamed {
995	public $callback = null;
996	public $params = null;
997	protected $name;
998	public function __construct($callback, $param1 = null, $param2 = null, 
999			$param3 = null) {
1000		$params = func_get_args();
1001		$params = array_slice($params, 1);
1002		if ($callback instanceof Callback) {
1003			// TODO implement recurention
1004		} else {
1005			$this->callback = $callback;
1006			$this->params = $params;
1007		}
1008	}
1009	public function getName() {
1010		return 'Callback: '.$this->name;
1011	}
1012	public function hasName() {
1013		return isset($this->name) && $this->name;
1014	}
1015	public function setName($name) {
1016		$this->name = $name;
1017		return $this;
1018	}
1019	// TODO test me
1020//	public function addParams() {
1021//		$params = func_get_args();
1022//		return new Callback($this->callback, $this->params+$params);
1023//	}
1024}
1025/**
1026 * Shorthand for new Callback(create_function(...), ...);
1027 * 
1028 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
1029 */
1030class CallbackBody extends Callback {
1031	public function __construct($paramList, $code, $param1 = null, $param2 = null, 
1032			$param3 = null) {
1033		$params = func_get_args();
1034		$params = array_slice($params, 2);
1035		$this->callback = create_function($paramList, $code);
1036		$this->params = $params;
1037	}
1038}
1039/**
1040 * Callback type which on execution returns reference passed during creation.
1041 * 
1042 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
1043 */
1044class CallbackReturnReference extends Callback
1045	implements ICallbackNamed {
1046	protected $reference;
1047	public function __construct(&$reference, $name = null){
1048		$this->reference =& $reference;
1049		$this->callback = array($this, 'callback');
1050	}
1051	public function callback() {
1052		return $this->reference;
1053	}
1054	public function getName() {
1055		return 'Callback: '.$this->name;
1056	}
1057	public function hasName() {
1058		return isset($this->name) && $this->name;
1059	}
1060}
1061/**
1062 * Callback type which on execution returns value passed during creation.
1063 * 
1064 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
1065 */
1066class CallbackReturnValue extends Callback
1067	implements ICallbackNamed {
1068	protected $value;
1069	protected $name;
1070	public function __construct($value, $name = null){
1071		$this->value =& $value;
1072		$this->name = $name;
1073		$this->callback = array($this, 'callback');
1074	}
1075	public function callback() {
1076		return $this->value;
1077	}
1078	public function __toString() {
1079		return $this->getName();
1080	}
1081	public function getName() {
1082		return 'Callback: '.$this->name;
1083	}
1084	public function hasName() {
1085		return isset($this->name) && $this->name;
1086	}
1087}
1088/**
1089 * CallbackParameterToReference can be used when we don't really want a callback,
1090 * only parameter passed to it. CallbackParameterToReference takes first 
1091 * parameter's value and passes it to reference.
1092 *
1093 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
1094 */
1095class CallbackParameterToReference extends Callback {
1096	/**
1097	 * @param $reference
1098	 * @TODO implement $paramIndex; 
1099	 * param index choose which callback param will be passed to reference
1100	 */
1101	public function __construct(&$reference){
1102		$this->callback =& $reference;
1103	}
1104}
1105//class CallbackReference extends Callback {
1106//	/**
1107//	 *
1108//	 * @param $reference
1109//	 * @param $paramIndex
1110//	 * @todo implement $paramIndex; param index choose which callback param will be passed to reference
1111//	 */
1112//	public function __construct(&$reference, $name = null){
1113//		$this->callback =& $reference;
1114//	}
1115//}
1116class CallbackParam {}
1117
1118/**
1119 * Class representing phpQuery objects.
1120 *
1121 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
1122 * @package phpQuery
1123 * @method phpQueryObject clone() clone()
1124 * @method phpQueryObject empty() empty()
1125 * @method phpQueryObject next() next($selector = null)
1126 * @method phpQueryObject prev() prev($selector = null)
1127 * @property Int $length
1128 */
1129class phpQueryObject
1130	implements Iterator, Countable, ArrayAccess {
1131	public $documentID = null;
1132	/**
1133	 * DOMDocument class.
1134	 *
1135	 * @var DOMDocument
1136	 */
1137	public $document = null;
1138	public $charset = null;
1139	/**
1140	 *
1141	 * @var DOMDocumentWrapper
1142	 */
1143	public $documentWrapper = null;
1144	/**
1145	 * XPath interface.
1146	 *
1147	 * @var DOMXPath
1148	 */
1149	public $xpath = null;
1150	/**
1151	 * Stack of selected elements.
1152	 * @TODO refactor to ->nodes
1153	 * @var array
1154	 */
1155	public $elements = array();
1156	/**
1157	 * @access private
1158	 */
1159	protected $elementsBackup = array();
1160	/**
1161	 * @access private
1162	 */
1163	protected $previous = null;
1164	/**
1165	 * @access private
1166	 * @TODO deprecate
1167	 */
1168	protected $root = array();
1169	/**
1170	 * Indicated if doument is just a fragment (no <html> tag).
1171	 *
1172	 * Every document is realy a full document, so even documentFragments can
1173	 * be queried against <html>, but getDocument(id)->htmlOuter() will return
1174	 * only contents of <body>.
1175	 *
1176	 * @var bool
1177	 */
1178	public $documentFragment = true;
1179	/**
1180	 * Iterator interface helper
1181	 * @access private
1182	 */
1183	protected $elementsInterator = array();
1184	/**
1185	 * Iterator interface helper
1186	 * @access private
1187	 */
1188	protected $valid = false;
1189	/**
1190	 * Iterator interface helper
1191	 * @access private
1192	 */
1193	protected $current = null;
1194	/**
1195	 * Enter description here...
1196	 *
1197	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1198	 */
1199	public function __construct($documentID) {
1200//		if ($documentID instanceof self)
1201//			var_dump($documentID->getDocumentID());
1202		$id = $documentID instanceof self
1203			? $documentID->getDocumentID()
1204			: $documentID;
1205//		var_dump($id);
1206		if (! isset(phpQuery::$documents[$id] )) {
1207//			var_dump(phpQuery::$documents);
1208			throw new Exception("Document with ID '{$id}' isn't loaded. Use phpQuery::newDocument(\$html) or phpQuery::newDocumentFile(\$file) first.");
1209		}
1210		$this->documentID = $id;
1211		$this->documentWrapper =& phpQuery::$documents[$id];
1212		$this->document =& $this->documentWrapper->document;
1213		$this->xpath =& $this->documentWrapper->xpath;
1214		$this->charset =& $this->documentWrapper->charset;
1215		$this->documentFragment =& $this->documentWrapper->isDocumentFragment;
1216		// TODO check $this->DOM->documentElement;
1217//		$this->root = $this->document->documentElement;
1218		$this->root =& $this->documentWrapper->root;
1219//		$this->toRoot();
1220		$this->elements = array($this->root);
1221	}
1222	/**
1223	 *
1224	 * @access private
1225	 * @param $attr
1226	 * @return unknown_type
1227	 */
1228	public function __get($attr) {
1229		switch($attr) {
1230			// FIXME doesnt work at all ?
1231			case 'length':
1232				return $this->size();
1233			break;
1234			default:
1235				return $this->$attr;
1236		}
1237	}
1238	/**
1239	 * Saves actual object to $var by reference.
1240	 * Useful when need to break chain.
1241	 * @param phpQueryObject $var
1242	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1243	 */
1244	public function toReference(&$var) {
1245		return $var = $this;
1246	}
1247	public function documentFragment($state = null) {
1248		if ($state) {
1249			phpQuery::$documents[$this->getDocumentID()]['documentFragment'] = $state;
1250			return $this;
1251		}
1252		return $this->documentFragment;
1253	}
1254	/**
1255   * @access private
1256   * @TODO documentWrapper
1257	 */
1258	protected function isRoot( $node) {
1259//		return $node instanceof DOMDOCUMENT || $node->tagName == 'html';
1260		return $node instanceof DOMDOCUMENT
1261			|| ($node instanceof DOMELEMENT && $node->tagName == 'html')
1262			|| $this->root->isSameNode($node);
1263	}
1264	/**
1265   * @access private
1266	 */
1267	protected function stackIsRoot() {
1268		return $this->size() == 1 && $this->isRoot($this->elements[0]);
1269	}
1270	/**
1271	 * Enter description here...
1272	 * NON JQUERY METHOD
1273	 *
1274	 * Watch out, it doesn't creates new instance, can be reverted with end().
1275	 *
1276	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1277	 */
1278	public function toRoot() {
1279		$this->elements = array($this->root);
1280		return $this;
1281//		return $this->newInstance(array($this->root));
1282	}
1283	/**
1284	 * Saves object's DocumentID to $var by reference.
1285	 * <code>
1286	 * $myDocumentId;
1287	 * phpQuery::newDocument('<div/>')
1288	 *     ->getDocumentIDRef($myDocumentId)
1289	 *     ->find('div')->...
1290	 * </code>
1291	 *
1292	 * @param unknown_type $domId
1293	 * @see phpQuery::newDocument
1294	 * @see phpQuery::newDocumentFile
1295	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1296	 */
1297	public function getDocumentIDRef(&$documentID) {
1298		$documentID = $this->getDocumentID();
1299		return $this;
1300	}
1301	/**
1302	 * Returns object with stack set to document root.
1303	 *
1304	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1305	 */
1306	public function getDocument() {
1307		return phpQuery::getDocument($this->getDocumentID());
1308	}
1309	/**
1310	 *
1311	 * @return DOMDocument
1312	 */
1313	public function getDOMDocument() {
1314		return $this->document;
1315	}
1316	/**
1317	 * Get object's Document ID.
1318	 *
1319	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1320	 */
1321	public function getDocumentID() {
1322		return $this->documentID;
1323	}
1324	/**
1325	 * Unloads whole document from memory.
1326	 * CAUTION! None further operations will be possible on this document.
1327	 * All objects refering to it will be useless.
1328	 *
1329	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1330	 */
1331	public function unloadDocument() {
1332		phpQuery::unloadDocuments($this->getDocumentID());
1333	}
1334	public function isHTML() {
1335		return $this->documentWrapper->isHTML;
1336	}
1337	public function isXHTML() {
1338		return $this->documentWrapper->isXHTML;
1339	}
1340	public function isXML() {
1341		return $this->documentWrapper->isXML;
1342	}
1343	/**
1344	 * Enter description here...
1345	 *
1346	 * @link http://docs.jquery.com/Ajax/serialize
1347	 * @return string
1348	 */
1349	public function serialize() {
1350		return phpQuery::param($this->serializeArray());
1351	}
1352	/**
1353	 * Enter description here...
1354	 *
1355	 * @link http://docs.jquery.com/Ajax/serializeArray
1356	 * @return array
1357	 */
1358	public function serializeArray($submit = null) {
1359		$source = $this->filter('form, input, select, textarea')
1360			->find('input, select, textarea')
1361			->andSelf()
1362			->not('form');
1363		$return = array();
1364//		$source->dumpDie();
1365		foreach($source as $input) {
1366			$input = phpQuery::pq($input);
1367			if ($input->is('[disabled]'))
1368				continue;
1369			if (!$input->is('[name]'))
1370				continue;
1371			if ($input->is('[type=checkbox]') && !$input->is('[checked]'))
1372				continue;
1373			// jquery diff
1374			if ($submit && $input->is('[type=submit]')) {
1375				if ($submit instanceof DOMELEMENT && ! $input->elements[0]->isSameNode($submit))
1376					continue;
1377				else if (is_string($submit) && $input->attr('name') != $submit)
1378					continue;
1379			}
1380			$return[] = array(
1381				'name' => $input->attr('name'),
1382				'value' => $input->val(),
1383			);
1384		}
1385		return $return;
1386	}
1387	/**
1388	 * @access private
1389	 */
1390	protected function debug($in) {
1391		if (! phpQuery::$debug )
1392			return;
1393		print('<pre>');
1394		print_r($in);
1395		// file debug
1396//		file_put_contents(dirname(__FILE__).'/phpQuery.log', print_r($in, true)."\n", FILE_APPEND);
1397		// quite handy debug trace
1398//		if ( is_array($in))
1399//			print_r(array_slice(debug_backtrace(), 3));
1400		print("</pre>\n");
1401	}
1402	/**
1403	 * @access private
1404	 */
1405	protected function isRegexp($pattern) {
1406		return in_array(
1407			$pattern[ mb_strlen($pattern)-1 ],
1408			array('^','*','$')
1409		);
1410	}
1411	/**
1412	 * Determines if $char is really a char.
1413	 *
1414	 * @param string $char
1415	 * @return bool
1416	 * @todo rewrite me to charcode range ! ;)
1417	 * @access private
1418	 */
1419	protected function isChar($char) {
1420		return extension_loaded('mbstring') && phpQuery::$mbstringSupport
1421			? mb_eregi('\w', $char)
1422			: preg_match('@\w@', $char);
1423	}
1424	/**
1425	 * @access private
1426	 */
1427	protected function parseSelector($query) {
1428		// clean spaces
1429		// TODO include this inside parsing ?
1430		$query = trim(
1431			preg_replace('@\s+@', ' ',
1432				preg_replace('@\s*(>|\\+|~)\s*@', '\\1', $query)
1433			)
1434		);
1435		$queries = array(array());
1436		if (! $query)
1437			return $queries;
1438		$return =& $queries[0];
1439		$specialChars = array('>',' ');
1440//		$specialCharsMapping = array('/' => '>');
1441		$specialCharsMapping = array();
1442		$strlen = mb_strlen($query);
1443		$classChars = array('.', '-');
1444		$pseudoChars = array('-');
1445		$tagChars = array('*', '|', '-');
1446		// split multibyte string
1447		// http://code.google.com/p/phpquery/issues/detail?id=76
1448		$_query = array();
1449		for ($i=0; $i<$strlen; $i++)
1450			$_query[] = mb_substr($query, $i, 1);
1451		$query = $_query;
1452		// it works, but i dont like it...
1453		$i = 0;
1454		while( $i < $strlen) {
1455			$c = $query[$i];
1456			$tmp = '';
1457			// TAG
1458			if ($this->isChar($c) || in_array($c, $tagChars)) {
1459				while(isset($query[$i])
1460					&& ($this->isChar($query[$i]) || in_array($query[$i], $tagChars))) {
1461					$tmp .= $query[$i];
1462					$i++;
1463				}
1464				$return[] = $tmp;
1465			// IDs
1466			} else if ( $c == '#') {
1467				$i++;
1468				while( isset($query[$i]) && ($this->isChar($query[$i]) || $query[$i] == '-')) {
1469					$tmp .= $query[$i];
1470					$i++;
1471				}
1472				$return[] = '#'.$tmp;
1473			// SPECIAL CHARS
1474			} else if (in_array($c, $specialChars)) {
1475				$return[] = $c;
1476				$i++;
1477			// MAPPED SPECIAL MULTICHARS
1478//			} else if ( $c.$query[$i+1] == '//') {
1479//				$return[] = ' ';
1480//				$i = $i+2;
1481			// MAPPED SPECIAL CHARS
1482			} else if ( isset($specialCharsMapping[$c])) {
1483				$return[] = $specialCharsMapping[$c];
1484				$i++;
1485			// COMMA
1486			} else if ( $c == ',') {
1487				$queries[] = array();
1488				$return =& $queries[ count($queries)-1 ];
1489				$i++;
1490				while( isset($query[$i]) && $query[$i] == ' ')
1491					$i++;
1492			// CLASSES
1493			} else if ($c == '.') {
1494				while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $classChars))) {
1495					$tmp .= $query[$i];
1496					$i++;
1497				}
1498				$return[] = $tmp;
1499			// ~ General Sibling Selector
1500			} else if ($c == '~') {
1501				$spaceAllowed = true;
1502				$tmp .= $query[$i++];
1503				while( isset($query[$i])
1504					&& ($this->isChar($query[$i])
1505						|| in_array($query[$i], $classChars)
1506						|| $query[$i] == '*'
1507						|| ($query[$i] == ' ' && $spaceAllowed)
1508					)) {
1509					if ($query[$i] != ' ')
1510						$spaceAllowed = false;
1511					$tmp .= $query[$i];
1512					$i++;
1513				}
1514				$return[] = $tmp;
1515			// + Adjacent sibling selectors
1516			} else if ($c == '+') {
1517				$spaceAllowed = true;
1518				$tmp .= $query[$i++];
1519				while( isset($query[$i])
1520					&& ($this->isChar($query[$i])
1521						|| in_array($query[$i], $classChars)
1522						|| $query[$i] == '*'
1523						|| ($spaceAllowed && $query[$i] == ' ')
1524					)) {
1525					if ($query[$i] != ' ')
1526						$spaceAllowed = false;
1527					$tmp .= $query[$i];
1528					$i++;
1529				}
1530				$return[] = $tmp;
1531			// ATTRS
1532			} else if ($c == '[') {
1533				$stack = 1;
1534				$tmp .= $c;
1535				while( isset($query[++$i])) {
1536					$tmp .= $query[$i];
1537					if ( $query[$i] == '[') {
1538						$stack++;
1539					} else if ( $query[$i] == ']') {
1540						$stack--;
1541						if (! $stack )
1542							break;
1543					}
1544				}
1545				$return[] = $tmp;
1546				$i++;
1547			// PSEUDO CLASSES
1548			} else if ($c == ':') {
1549				$stack = 1;
1550				$tmp .= $query[$i++];
1551				while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $pseudoChars))) {
1552					$tmp .= $query[$i];
1553					$i++;
1554				}
1555				// with arguments ?
1556				if ( isset($query[$i]) && $query[$i] == '(') {
1557					$tmp .= $query[$i];
1558					$stack = 1;
1559					while( isset($query[++$i])) {
1560						$tmp .= $query[$i];
1561						if ( $query[$i] == '(') {
1562							$stack++;
1563						} else if ( $query[$i] == ')') {
1564							$stack--;
1565							if (! $stack )
1566								break;
1567						}
1568					}
1569					$return[] = $tmp;
1570					$i++;
1571				} else {
1572					$return[] = $tmp;
1573				}
1574			} else {
1575				$i++;
1576			}
1577		}
1578		foreach($queries as $k => $q) {
1579			if (isset($q[0])) {
1580				if (isset($q[0][0]) && $q[0][0] == ':')
1581					array_unshift($queries[$k], '*');
1582				if ($q[0] != '>')
1583					array_unshift($queries[$k], ' ');
1584			}
1585		}
1586		return $queries;
1587	}
1588	/**
1589	 * Return matched DOM nodes.
1590	 *
1591	 * @param int $index
1592	 * @return array|DOMElement Single DOMElement or array of DOMElement.
1593	 */
1594	public function get($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
1595		$return = isset($index)
1596			? (isset($this->elements[$index]) ? $this->elements[$index] : null)
1597			: $this->elements;
1598		// pass thou callbacks
1599		$args = func_get_args();
1600		$args = array_slice($args, 1);
1601		foreach($args as $callback) {
1602			if (is_array($return))
1603				foreach($return as $k => $v)
1604					$return[$k] = phpQuery::callbackRun($callback, array($v));
1605			else
1606				$return = phpQuery::callbackRun($callback, array($return));
1607		}
1608		return $return;
1609	}
1610	/**
1611	 * Return matched DOM nodes.
1612	 * jQuery difference.
1613	 *
1614	 * @param int $index
1615	 * @return array|string Returns string if $index != null
1616	 * @todo implement callbacks
1617	 * @todo return only arrays ?
1618	 * @todo maybe other name...
1619	 */
1620	public function getString($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
1621		if ($index)
1622			$return = $this->eq($index)->text();
1623		else {
1624			$return = array();
1625			for($i = 0; $i < $this->size(); $i++) {
1626				$return[] = $this->eq($i)->text();
1627			}
1628		}
1629		// pass thou callbacks
1630		$args = func_get_args();
1631		$args = array_slice($args, 1);
1632		foreach($args as $callback) {
1633			$return = phpQuery::callbackRun($callback, array($return));
1634		}
1635		return $return;
1636	}
1637	/**
1638	 * Return matched DOM nodes.
1639	 * jQuery difference.
1640	 *
1641	 * @param int $index
1642	 * @return array|string Returns string if $index != null
1643	 * @todo implement callbacks
1644	 * @todo return only arrays ?
1645	 * @todo maybe other name...
1646	 */
1647	public function getStrings($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
1648		if ($index)
1649			$return = $this->eq($index)->text();
1650		else {
1651			$return = array();
1652			for($i = 0; $i < $this->size(); $i++) {
1653				$return[] = $this->eq($i)->text();
1654			}
1655			// pass thou callbacks
1656			$args = func_get_args();
1657			$args = array_slice($args, 1);
1658		}
1659		foreach($args as $callback) {
1660			if (is_array($return))
1661				foreach($return as $k => $v)
1662					$return[$k] = phpQuery::callbackRun($callback, array($v));
1663			else
1664				$return = phpQuery::callbackRun($callback, array($return));
1665		}
1666		return $return;
1667	}
1668	/**
1669	 * Returns new instance of actual class.
1670	 *
1671	 * @param array $newStack Optional. Will replace old stack with new and move old one to history.c
1672	 */
1673	public function newInstance($newStack = null) {
1674		$class = get_class($this);
1675		// support inheritance by passing old object to overloaded constructor
1676		$new = $class != 'phpQuery'
1677			? new $class($this, $this->getDocumentID())
1678			: new phpQueryObject($this->getDocumentID());
1679		$new->previous = $this;
1680		if (is_null($newStack)) {
1681			$new->elements = $this->elements;
1682			if ($this->elementsBackup)
1683				$this->elements = $this->elementsBackup;
1684		} else if (is_string($newStack)) {
1685			$new->elements = phpQuery::pq($newStack, $this->getDocumentID())->stack();
1686		} else {
1687			$new->elements = $newStack;
1688		}
1689		return $new;
1690	}
1691	/**
1692	 * Enter description here...
1693	 *
1694	 * In the future, when PHP will support XLS 2.0, then we would do that this way:
1695	 * contains(tokenize(@class, '\s'), "something")
1696	 * @param unknown_type $class
1697	 * @param unknown_type $node
1698	 * @return boolean
1699	 * @access private
1700	 */
1701	protected function matchClasses($class, $node) {
1702		// multi-class
1703		if ( mb_strpos($class, '.', 1)) {
1704			$classes = explode('.', substr($class, 1));
1705			$classesCount = count( $classes );
1706			$nodeClasses = explode(' ', $node->getAttribute('class') );
1707			$nodeClassesCount = count( $nodeClasses );
1708			if ( $classesCount > $nodeClassesCount )
1709				return false;
1710			$diff = count(
1711				array_diff(
1712					$classes,
1713					$nodeClasses
1714				)
1715			);
1716			if (! $diff )
1717				return true;
1718		// single-class
1719		} else {
1720			return in_array(
1721				// strip leading dot from class name
1722				substr($class, 1),
1723				// get classes for element as array
1724				explode(' ', $node->getAttribute('class') )
1725			);
1726		}
1727	}
1728	/**
1729	 * @access private
1730	 */
1731	protected function runQuery($XQuery, $selector = null, $compare = null) {
1732		if ($compare && ! method_exists($this, $compare))
1733			return false;
1734		$stack = array();
1735		if (! $this->elements)
1736			$this->debug('Stack empty, skipping...');
1737//		var_dump($this->elements[0]->nodeType);
1738		// element, document
1739		foreach($this->stack(array(1, 9, 13)) as $k => $stackNode) {
1740			$detachAfter = false;
1741			// to work on detached nodes we need temporary place them somewhere
1742			// thats because context xpath queries sucks ;]
1743			$testNode = $stackNode;
1744			while ($testNode) {
1745				if (! $testNode->parentNode && ! $this->isRoot($testNode)) {
1746					$this->root->appendChild($testNode);
1747					$detachAfter = $testNode;
1748					break;
1749				}
1750				$testNode = isset($testNode->parentNode)
1751					? $testNode->parentNode
1752					: null;
1753			}
1754			// XXX tmp ?
1755			$xpath = $this->documentWrapper->isXHTML
1756				? $this->getNodeXpath($stackNode, 'html')
1757				: $this->getNodeXpath($stackNode);
1758			// FIXME pseudoclasses-only query, support XML
1759			$query = $XQuery == '//' && $xpath == '/html[1]'
1760				? '//*'
1761				: $xpath.$XQuery;
1762			$this->debug("XPATH: {$query}");
1763			// run query, get elements
1764			$nodes = $this->xpath->query($query);
1765			$this->debug("QUERY FETCHED");
1766			if (! $nodes->length )
1767				$this->debug('Nothing found');
1768			$debug = array();
1769			foreach($nodes as $node) {
1770				$matched = false;
1771				if ( $compare) {
1772					phpQuery::$debug ?
1773						$this->debug("Found: ".$this->whois( $node ).", comparing with {$compare}()")
1774						: null;
1775					$phpQueryDebug = phpQuery::$debug;
1776					phpQuery::$debug = false;
1777					// TODO ??? use phpQuery::callbackRun()
1778					if (call_user_func_array(array($this, $compare), array($selector, $node)))
1779						$matched = true;
1780					phpQuery::$debug = $phpQueryDebug;
1781				} else {
1782					$matched = true;
1783				}
1784				if ( $matched) {
1785					if (phpQuery::$debug)
1786						$debug[] = $this->whois( $node );
1787					$stack[] = $node;
1788				}
1789			}
1790			if (phpQuery::$debug) {
1791				$this->debug("Matched ".count($debug).": ".implode(', ', $debug));
1792			}
1793			if ($detachAfter)
1794				$this->root->removeChild($detachAfter);
1795		}
1796		$this->elements = $stack;
1797	}
1798	/**
1799	 * Enter description here...
1800	 *
1801	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
1802	 */
1803	public function find($selectors, $context = null, $noHistory = false) {
1804		if (!$noHistory)
1805			// backup last stack /for end()/
1806			$this->elementsBackup = $this->elements;
1807		// allow to define context
1808		// TODO combine code below with phpQuery::pq() context guessing code
1809		//   as generic function
1810		if ($context) {
1811			if (! is_array($context) && $context instanceof DOMELEMENT)
1812				$this->elements = array($context);
1813			else if (is_array($context)) {
1814				$this->elements = array();
1815				foreach ($context as $c)
1816					if ($c instanceof DOMELEMENT)
1817						$this->elements[] = $c;
1818			} else if ( $context instanceof self )
1819				$this->elements = $context->elements;
1820		}
1821		$queries = $this->parseSelector($selectors);
1822		$this->debug(array('FIND', $selectors, $queries));
1823		$XQuery = '';
1824		// remember stack state because of multi-queries
1825		$oldStack = $this->elements;
1826		// here we will be keeping found elements
1827		$stack = array();
1828		foreach($queries as $selector) {
1829			$this->elements = $oldStack;
1830			$delimiterBefore = false;
1831			foreach($selector as $s) {
1832				// TAG
1833				$isTag = extension_loaded('mbstring') && phpQuery::$mbstringSupport
1834					? mb_ereg_match('^[\w|\||-]+$', $s) || $s == '*'
1835					: preg_match('@^[\w|\||-]+$@', $s) || $s == '*';
1836				if ($isTag) {
1837					if ($this->isXML()) {
1838						// namespace support
1839						if (mb_strpos($s, '|') !== false) {
1840							$ns = $tag = null;
1841							list($ns, $tag) = explode('|', $s);
1842							$XQuery .= "$ns:$tag";
1843						} else if ($s == '*') {
1844							$XQuery .= "*";
1845						} else {
1846							$XQuery .= "*[local-name()='$s']";
1847						}
1848					} else {
1849						$XQuery .= $s;
1850					}
1851				// ID
1852				} else if ($s[0] == '#') {
1853					if ($delimiterBefore)
1854						$XQuery .= '*';
1855					$XQuery .= "[@id='".substr($s, 1)."']";
1856				// ATTRIBUTES
1857				} else if ($s[0] == '[') {
1858					if ($delimiterBefore)
1859						$XQuery .= '*';
1860					// strip side brackets
1861					$attr = trim($s, '][');
1862					$execute = false;
1863					// attr with specifed value
1864					if (mb_strpos($s, '=')) {
1865						$value = null;
1866						list($attr, $value) = explode('=', $attr);
1867						$value = trim($value, "'\"");
1868						if ($this->isRegexp($attr)) {
1869							// cut regexp character
1870							$attr = substr($attr, 0, -1);
1871							$execute = true;
1872							$XQuery .= "[@{$attr}]";
1873						} else {
1874							$XQuery .= "[@{$attr}='{$value}']";
1875						}
1876					// attr without specified value
1877					} else {
1878						$XQuery .= "[@{$attr}]";
1879					}
1880					if ($execute) {
1881						$this->runQuery($XQuery, $s, 'is');
1882						$XQuery = '';
1883						if (! $this->length())
1884							break;
1885					}
1886				// CLASSES
1887				} else if ($s[0] == '.') {
1888					// TODO use return $this->find("./self::*[contains(concat(\" \",@class,\" \"), \" $class \")]");
1889					// thx wizDom ;)
1890					if ($delimiterBefore)
1891						$XQuery .= '*';
1892					$XQuery .= '[@class]';
1893					$this->runQuery($XQuery, $s, 'matchClasses');
1894					$XQuery = '';
1895					if (! $this->length() )
1896						break;
1897				// ~ General Sibling Selector
1898				} else if ($s[0] == '~') {
1899					$this->runQuery($XQuery);
1900					$XQuery = '';
1901					$this->elements = $this
1902						->siblings(
1903							substr($s, 1)
1904						)->elements;
1905					if (! $this->length() )
1906						break;
1907				// + Adjacent sibling selectors
1908				} else if ($s[0] == '+') {
1909					// TODO /following-sibling::
1910					$this->runQuery($XQuery);
1911					$XQuery = '';
1912					$subSelector = substr($s, 1);
1913					$subElements = $this->elements;
1914					$this->elements = array();
1915					foreach($subElements as $node) {
1916						// search first DOMElement sibling
1917						$test = $node->nextSibling;
1918						while($test && ! ($test instanceof DOMELEMENT))
1919							$test = $test->nextSibling;
1920						if ($test && $this->is($subSelector, $test))
1921							$this->elements[] = $test;
1922					}
1923					if (! $this->length() )
1924						break;
1925				// PSEUDO CLASSES
1926				} else if ($s[0] == ':') {
1927					// TODO optimization for :first :last
1928					if ($XQuery) {
1929						$this->runQuery($XQuery);
1930						$XQuery = '';
1931					}
1932					if (! $this->length())
1933						break;
1934					$this->pseudoClasses($s);
1935					if (! $this->length())
1936						break;
1937				// DIRECT DESCENDANDS
1938				} else if ($s == '>') {
1939					$XQuery .= '/';
1940					$delimiterBefore = 2;
1941				// ALL DESCENDANDS
1942				} else if ($s == ' ') {
1943					$XQuery .= '//';
1944					$delimiterBefore = 2;
1945				// ERRORS
1946				} else {
1947					phpQuery::debug("Unrecognized token '$s'");
1948				}
1949				$delimiterBefore = $delimiterBefore === 2;
1950			}
1951			// run query if any
1952			if ($XQuery && $XQuery != '//') {
1953				$this->runQuery($XQuery);
1954				$XQuery = '';
1955			}
1956			foreach($this->elements as $node)
1957				if (! $this->elementsContainsNode($node, $stack))
1958					$stack[] = $node;
1959		}
1960		$this->elements = $stack;
1961		return $this->newInstance();
1962	}
1963	/**
1964	 * @todo create API for classes with pseudoselectors
1965	 * @access private
1966	 */
1967	protected function pseudoClasses($class) {
1968		// TODO clean args parsing ?
1969		$class = ltrim($class, ':');
1970		$haveArgs = mb_strpos($class, '(');
1971		if ($haveArgs !== false) {
1972			$args = substr($class, $haveArgs+1, -1);
1973			$class = substr($class, 0, $haveArgs);
1974		}
1975		switch($class) {
1976			case 'even':
1977			case 'odd':
1978				$stack = array();
1979				foreach($this->elements as $i => $node) {
1980					if ($class == 'even' && ($i%2) == 0)
1981						$stack[] = $node;
1982					else if ( $class == 'odd' && $i % 2 )
1983						$stack[] = $node;
1984				}
1985				$this->elements = $stack;
1986				break;
1987			case 'eq':
1988				$k = intval($args);
1989				$this->elements = isset( $this->elements[$k] )
1990					? array( $this->elements[$k] )
1991					: array();
1992				break;
1993			case 'gt':
1994				$this->elements = array_slice($this->elements, $args+1);
1995				break;
1996			case 'lt':
1997				$this->elements = array_slice($this->elements, 0, $args+1);
1998				break;
1999			case 'first':
2000				if (isset($this->elements[0]))
2001					$this->elements = array($this->elements[0]);
2002				break;
2003			case 'last':
2004				if ($this->elements)
2005					$this->elements = array($this->elements[count($this->elements)-1]);
2006				break;
2007			/*case 'parent':
2008				$stack = array();
2009				foreach($this->elements as $node) {
2010					if ( $node->childNodes->length )
2011						$stack[] = $node;
2012				}
2013				$this->elements = $stack;
2014				break;*/
2015			case 'contains':
2016				$text = trim($args, "\"'");
2017				$stack = array();
2018				foreach($this->elements as $node) {
2019					if (mb_stripos($node->textContent, $text) === false)
2020						continue;
2021					$stack[] = $node;
2022				}
2023				$this->elements = $stack;
2024				break;
2025			case 'not':
2026				$selector = self::unQuote($args);
2027				$this->elements = $this->not($selector)->stack();
2028				break;
2029			case 'slice':
2030				// TODO jQuery difference ?
2031				$args = explode(',',
2032					str_replace(', ', ',', trim($args, "\"'"))
2033				);
2034				$start = $args[0];
2035				$end = isset($args[1])
2036					? $args[1]
2037					: null;
2038				if ($end > 0)
2039					$end = $end-$start;
2040				$this->elements = array_slice($this->elements, $start, $end);
2041				break;
2042			case 'has':
2043				$selector = trim($args, "\"'");
2044				$stack = array();
2045				foreach($this->stack(1) as $el) {
2046					if ($this->find($selector, $el, true)->length)
2047						$stack[] = $el;
2048				}
2049				$this->elements = $stack;
2050				break;
2051			case 'submit':
2052			case 'reset':
2053				$this->elements = phpQuery::merge(
2054					$this->map(array($this, 'is'),
2055						"input[type=$class]", new CallbackParam()
2056					),
2057					$this->map(array($this, 'is'),
2058						"button[type=$class]", new CallbackParam()
2059					)
2060				);
2061			break;
2062//				$stack = array();
2063//				foreach($this->elements as $node)
2064//					if ($node->is('input[type=submit]') || $node->is('button[type=submit]'))
2065//						$stack[] = $el;
2066//				$this->elements = $stack;
2067			case 'input':
2068				$this->elements = $this->map(
2069					array($this, 'is'),
2070					'input', new CallbackParam()
2071				)->elements;
2072			break;
2073			case 'password':
2074			case 'checkbox':
2075			case 'radio':
2076			case 'hidden':
2077			case 'image':
2078			case 'file':
2079				$this->elements = $this->map(
2080					array($this, 'is'),
2081					"input[type=$class]", new CallbackParam()
2082				)->elements;
2083			break;
2084			case 'parent':
2085				$this->elements = $this->map(
2086					create_function('$node', '
2087						return $node instanceof DOMELEMENT && $node->childNodes->length
2088							? $node : null;')
2089				)->elements;
2090			break;
2091			case 'empty':
2092				$this->elements = $this->map(
2093					create_function('$node', '
2094						return $node instanceof DOMELEMENT && $node->childNodes->length
2095							? null : $node;')
2096				)->elements;
2097			break;
2098			case 'disabled':
2099			case 'selected':
2100			case 'checked':
2101				$this->elements = $this->map(
2102					array($this, 'is'),
2103					"[$class]", new CallbackParam()
2104				)->elements;
2105			break;
2106			case 'enabled':
2107				$this->elements = $this->map(
2108					create_function('$node', '
2109						return pq($node)->not(":disabled") ? $node : null;')
2110				)->elements;
2111			break;
2112			case 'header':
2113				$this->elements = $this->map(
2114					create_function('$node',
2115						'$isHeader = isset($node->tagName) && in_array($node->tagName, array(
2116							"h1", "h2", "h3", "h4", "h5", "h6", "h7"
2117						));
2118						return $isHeader
2119							? $node
2120							: null;')
2121				)->elements;
2122//				$this->elements = $this->map(
2123//					create_function('$node', '$node = pq($node);
2124//						return $node->is("h1")
2125//							|| $node->is("h2")
2126//							|| $node->is("h3")
2127//							|| $node->is("h4")
2128//							|| $node->is("h5")
2129//							|| $node->is("h6")
2130//							|| $node->is("h7")
2131//							? $node
2132//							: null;')
2133//				)->elements;
2134			break;
2135			case 'only-child':
2136				$this->elements = $this->map(
2137					create_function('$node',
2138						'return pq($node)->siblings()->size() == 0 ? $node : null;')
2139				)->elements;
2140			break;
2141			case 'first-child':
2142				$this->elements = $this->map(
2143					create_function('$node', 'return pq($node)->prevAll()->size() == 0 ? $node : null;')
2144				)->elements;
2145			break;
2146			case 'last-child':
2147				$this->elements = $this->map(
2148					create_function('$node', 'return pq($node)->nextAll()->size() == 0 ? $node : null;')
2149				)->elements;
2150			break;
2151			case 'nth-child':
2152				$param = trim($args, "\"'");
2153				if (! $param)
2154					break;
2155					// nth-child(n+b) to nth-child(1n+b)
2156				if ($param{0} == 'n')
2157					$param = '1'.$param;
2158				// :nth-child(index/even/odd/equation)
2159				if ($param == 'even' || $param == 'odd')
2160					$mapped = $this->map(
2161						create_function('$node, $param',
2162							'$index = pq($node)->prevAll()->size()+1;
2163							if ($param == "even" && ($index%2) == 0)
2164								return $node;
2165							else if ($param == "odd" && $index%2 == 1)
2166								return $node;
2167							else
2168								return null;'),
2169						new CallbackParam(), $param
2170					);
2171				else if (mb_strlen($param) > 1 && $param{1} == 'n')
2172					// an+b
2173					$mapped = $this->map(
2174						create_function('$node, $param',
2175							'$prevs = pq($node)->prevAll()->size();
2176							$index = 1+$prevs;
2177							$b = mb_strlen($param) > 3
2178								? $param{3}
2179								: 0;
2180							$a = $param{0};
2181							if ($b && $param{2} == "-")
2182								$b = -$b;
2183							if ($a > 0) {
2184								return ($index-$b)%$a == 0
2185									? $node
2186									: null;
2187								phpQuery::debug($a."*".floor($index/$a)."+$b-1 == ".($a*floor($index/$a)+$b-1)." ?= $prevs");
2188								return $a*floor($index/$a)+$b-1 == $prevs
2189										? $node
2190										: null;
2191							} else if ($a == 0)
2192								return $index == $b
2193										? $node
2194										: null;
2195							else
2196								// negative value
2197								return $index <= $b
2198										? $node
2199										: null;
2200//							if (! $b)
2201//								return $index%$a == 0
2202//									? $node
2203//									: null;
2204//							else
2205//								return ($index-$b)%$a == 0
2206//									? $node
2207//									: null;
2208							'),
2209						new CallbackParam(), $param
2210					);
2211				else
2212					// index
2213					$mapped = $this->map(
2214						create_function('$node, $index',
2215							'$prevs = pq($node)->prevAll()->size();
2216							if ($prevs && $prevs == $index-1)
2217								return $node;
2218							else if (! $prevs && $index == 1)
2219								return $node;
2220							else
2221								return null;'),
2222						new CallbackParam(), $param
2223					);
2224				$this->elements = $mapped->elements;
2225			break;
2226			default:
2227				$this->debug("Unknown pseudoclass '{$class}', skipping...");
2228		}
2229	}
2230	/**
2231	 * @access private
2232	 */
2233	protected function __pseudoClassParam($paramsString) {
2234		// TODO;
2235	}
2236	/**
2237	 * Enter description here...
2238	 *
2239	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2240	 */
2241	public function is($selector, $nodes = null) {
2242		phpQuery::debug(array("Is:", $selector));
2243		if (! $selector)
2244			return false;
2245		$oldStack = $this->elements;
2246		$returnArray = false;
2247		if ($nodes && is_array($nodes)) {
2248			$this->elements = $nodes;
2249		} else if ($nodes)
2250			$this->elements = array($nodes);
2251		$this->filter($selector, true);
2252		$stack = $this->elements;
2253		$this->elements = $oldStack;
2254		if ($nodes)
2255			return $stack ? $stack : null;
2256		return (bool)count($stack);
2257	}
2258	/**
2259	 * Enter description here...
2260	 * jQuery difference.
2261	 *
2262	 * Callback:
2263	 * - $index int
2264	 * - $node DOMNode
2265	 *
2266	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2267	 * @link http://docs.jquery.com/Traversing/filter
2268	 */
2269	public function filterCallback($callback, $_skipHistory = false) {
2270		if (! $_skipHistory) {
2271			$this->elementsBackup = $this->elements;
2272			$this->debug("Filtering by callback");
2273		}
2274		$newStack = array();
2275		foreach($this->elements as $index => $node) {
2276			$result = phpQuery::callbackRun($callback, array($index, $node));
2277			if (is_null($result) || (! is_null($result) && $result))
2278				$newStack[] = $node;
2279		}
2280		$this->elements = $newStack;
2281		return $_skipHistory
2282			? $this
2283			: $this->newInstance();
2284	}
2285	/**
2286	 * Enter description here...
2287	 *
2288	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2289	 * @link http://docs.jquery.com/Traversing/filter
2290	 */
2291	public function filter($selectors, $_skipHistory = false) {
2292		if ($selectors instanceof Callback OR $selectors instanceof Closure)
2293			return $this->filterCallback($selectors, $_skipHistory);
2294		if (! $_skipHistory)
2295			$this->elementsBackup = $this->elements;
2296		$notSimpleSelector = array(' ', '>', '~', '+', '/');
2297		if (! is_array($selectors))
2298			$selectors = $this->parseSelector($selectors);
2299		if (! $_skipHistory)
2300			$this->debug(array("Filtering:", $selectors));
2301		$finalStack = array();
2302		foreach($selectors as $selector) {
2303			$stack = array();
2304			if (! $selector)
2305				break;
2306			// avoid first space or /
2307			if (in_array($selector[0], $notSimpleSelector))
2308				$selector = array_slice($selector, 1);
2309			// PER NODE selector chunks
2310			foreach($this->stack() as $node) {
2311				$break = false;
2312				foreach($selector as $s) {
2313					if (!($node instanceof DOMELEMENT)) {
2314						// all besides DOMElement
2315						if ( $s[0] == '[') {
2316							$attr = trim($s, '[]');
2317							if ( mb_strpos($attr, '=')) {
2318								list( $attr, $val ) = explode('=', $attr);
2319								if ($attr == 'nodeType' && $node->nodeType != $val)
2320									$break = true;
2321							}
2322						} else
2323							$break = true;
2324					} else {
2325						// DOMElement only
2326						// ID
2327						if ( $s[0] == '#') {
2328							if ( $node->getAttribute('id') != substr($s, 1) )
2329								$break = true;
2330						// CLASSES
2331						} else if ( $s[0] == '.') {
2332							if (! $this->matchClasses( $s, $node ) )
2333								$break = true;
2334						// ATTRS
2335						} else if ( $s[0] == '[') {
2336							// strip side brackets
2337							$attr = trim($s, '[]');
2338							if (mb_strpos($attr, '=')) {
2339								list($attr, $val) = explode('=', $attr);
2340								$val = self::unQuote($val);
2341								if ($attr == 'nodeType') {
2342									if ($val != $node->nodeType)
2343										$break = true;
2344								} else if ($this->isRegexp($attr)) {
2345									$val = extension_loaded('mbstring') && phpQuery::$mbstringSupport
2346										? quotemeta(trim($val, '"\''))
2347										: preg_quote(trim($val, '"\''), '@');
2348									// switch last character
2349									switch( substr($attr, -1)) {
2350										// quotemeta used insted of preg_quote
2351										// http://code.google.com/p/phpquery/issues/detail?id=76
2352										case '^':
2353											$pattern = '^'.$val;
2354											break;
2355										case '*':
2356											$pattern = '.*'.$val.'.*';
2357											break;
2358										case '$':
2359											$pattern = '.*'.$val.'$';
2360											break;
2361									}
2362									// cut last character
2363									$attr = substr($attr, 0, -1);
2364									$isMatch = extension_loaded('mbstring') && phpQuery::$mbstringSupport
2365										? mb_ereg_match($pattern, $node->getAttribute($attr))
2366										: preg_match("@{$pattern}@", $node->getAttribute($attr));
2367									if (! $isMatch)
2368										$break = true;
2369								} else if ($node->getAttribute($attr) != $val)
2370									$break = true;
2371							} else if (! $node->hasAttribute($attr))
2372								$break = true;
2373						// PSEUDO CLASSES
2374						} else if ( $s[0] == ':') {
2375							// skip
2376						// TAG
2377						} else if (trim($s)) {
2378							if ($s != '*') {
2379								// TODO namespaces
2380								if (isset($node->tagName)) {
2381									if ($node->tagName != $s)
2382										$break = true;
2383								} else if ($s == 'html' && ! $this->isRoot($node))
2384									$break = true;
2385							}
2386						// AVOID NON-SIMPLE SELECTORS
2387						} else if (in_array($s, $notSimpleSelector)) {
2388							$break = true;
2389							$this->debug(array('Skipping non simple selector', $selector));
2390						}
2391					}
2392					if ($break)
2393						break;
2394				}
2395				// if element passed all chunks of selector - add it to new stack
2396				if (! $break )
2397					$stack[] = $node;
2398			}
2399			$tmpStack = $this->elements;
2400			$this->elements = $stack;
2401			// PER ALL NODES selector chunks
2402			foreach($selector as $s)
2403				// PSEUDO CLASSES
2404				if ($s[0] == ':')
2405					$this->pseudoClasses($s);
2406			foreach($this->elements as $node)
2407				// XXX it should be merged without duplicates
2408				// but jQuery doesnt do that
2409				$finalStack[] = $node;
2410			$this->elements = $tmpStack;
2411		}
2412		$this->elements = $finalStack;
2413		if ($_skipHistory) {
2414			return $this;
2415		} else {
2416			$this->debug("Stack length after filter(): ".count($finalStack));
2417			return $this->newInstance();
2418		}
2419	}
2420	/**
2421	 *
2422	 * @param $value
2423	 * @return unknown_type
2424	 * @TODO implement in all methods using passed parameters
2425	 */
2426	protected static function unQuote($value) {
2427		return $value[0] == '\'' || $value[0] == '"'
2428			? substr($value, 1, -1)
2429			: $value;
2430	}
2431	/**
2432	 * Enter description here...
2433	 *
2434	 * @link http://docs.jquery.com/Ajax/load
2435	 * @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2436	 * @todo Support $selector
2437	 */
2438	public function load($url, $data = null, $callback = null) {
2439		if ($data && ! is_array($data)) {
2440			$callback = $data;
2441			$data = null;
2442		}
2443		if (mb_strpos($url, ' ') !== false) {
2444			$matches = null;
2445			if (extension_loaded('mbstring') && phpQuery::$mbstringSupport)
2446				mb_ereg('^([^ ]+) (.*)$', $url, $matches);
2447			else
2448				preg_match('^([^ ]+) (.*)$', $url, $matches);
2449			$url = $matches[1];
2450			$selector = $matches[2];
2451			// FIXME this sucks, pass as callback param
2452			$this->_loadSelector = $selector;
2453		}
2454		$ajax = array(
2455			'url' => $url,
2456			'type' => $data ? 'POST' : 'GET',
2457			'data' => $data,
2458			'complete' => $callback,
2459			'success' => array($this, '__loadSuccess')
2460		);
2461		phpQuery::ajax($ajax);
2462		return $this;
2463	}
2464	/**
2465	 * @access private
2466	 * @param $html
2467	 * @return unknown_type
2468	 */
2469	public function __loadSuccess($html) {
2470		if ($this->_loadSelector) {
2471			$html = phpQuery::newDocument($html)->find($this->_loadSelector);
2472			unset($this->_loadSelector);
2473		}
2474		foreach($this->stack(1) as $node) {
2475			phpQuery::pq($node, $this->getDocumentID())
2476				->markup($html);
2477		}
2478	}
2479	/**
2480	 * Enter description here...
2481	 *
2482	 * @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2483	 * @todo
2484	 */
2485	public function css() {
2486		// TODO
2487		return $this;
2488	}
2489	/**
2490	 * @todo
2491	 *
2492	 */
2493	public function show(){
2494		// TODO
2495		return $this;
2496	}
2497	/**
2498	 * @todo
2499	 *
2500	 */
2501	public function hide(){
2502		// TODO
2503		return $this;
2504	}
2505	/**
2506	 * Trigger a type of event on every matched element.
2507	 *
2508	 * @param unknown_type $type
2509	 * @param unknown_type $data
2510	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2511	 * @TODO support more than event in $type (space-separated)
2512	 */
2513	public function trigger($type, $data = array()) {
2514		foreach($this->elements as $node)
2515			phpQueryEvents::trigger($this->getDocumentID(), $type, $data, $node);
2516		return $this;
2517	}
2518	/**
2519	 * This particular method triggers all bound event handlers on an element (for a specific event type) WITHOUT executing the browsers default actions.
2520	 *
2521	 * @param unknown_type $type
2522	 * @param unknown_type $data
2523	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2524	 * @TODO
2525	 */
2526	public function triggerHandler($type, $data = array()) {
2527		// TODO;
2528	}
2529	/**
2530	 * Binds a handler to one or more events (like click) for each matched element.
2531	 * Can also bind custom events.
2532	 *
2533	 * @param unknown_type $type
2534	 * @param unknown_type $data Optional
2535	 * @param unknown_type $callback
2536	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2537	 * @TODO support '!' (exclusive) events
2538	 * @TODO support more than event in $type (space-separated)
2539	 */
2540	public function bind($type, $data, $callback = null) {
2541		// TODO check if $data is callable, not using is_callable
2542		if (! isset($callback)) {
2543			$callback = $data;
2544			$data = null;
2545		}
2546		foreach($this->elements as $node)
2547			phpQueryEvents::add($this->getDocumentID(), $node, $type, $data, $callback);
2548		return $this;
2549	}
2550	/**
2551	 * Enter description here...
2552	 *
2553	 * @param unknown_type $type
2554	 * @param unknown_type $callback
2555	 * @return unknown
2556	 * @TODO namespace events
2557	 * @TODO support more than event in $type (space-separated)
2558	 */
2559	public function unbind($type = null, $callback = null) {
2560		foreach($this->elements as $node)
2561			phpQueryEvents::remove($this->getDocumentID(), $node, $type, $callback);
2562		return $this;
2563	}
2564	/**
2565	 * Enter description here...
2566	 *
2567	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2568	 */
2569	public function change($callback = null) {
2570		if ($callback)
2571			return $this->bind('change', $callback);
2572		return $this->trigger('change');
2573	}
2574	/**
2575	 * Enter description here...
2576	 *
2577	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2578	 */
2579	public function submit($callback = null) {
2580		if ($callback)
2581			return $this->bind('submit', $callback);
2582		return $this->trigger('submit');
2583	}
2584	/**
2585	 * Enter description here...
2586	 *
2587	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2588	 */
2589	public function click($callback = null) {
2590		if ($callback)
2591			return $this->bind('click', $callback);
2592		return $this->trigger('click');
2593	}
2594	/**
2595	 * Enter description here...
2596	 *
2597	 * @param String|phpQuery
2598	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2599	 */
2600	public function wrapAllOld($wrapper) {
2601		$wrapper = pq($wrapper)->_clone();
2602		if (! $wrapper->length() || ! $this->length() )
2603			return $this;
2604		$wrapper->insertBefore($this->elements[0]);
2605		$deepest = $wrapper->elements[0];
2606		while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
2607			$deepest = $deepest->firstChild;
2608		pq($deepest)->append($this);
2609		return $this;
2610	}
2611	/**
2612	 * Enter description here...
2613	 *
2614	 * TODO testme...
2615	 * @param String|phpQuery
2616	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2617	 */
2618	public function wrapAll($wrapper) {
2619		if (! $this->length())
2620			return $this;
2621		return phpQuery::pq($wrapper, $this->getDocumentID())
2622			->clone()
2623			->insertBefore($this->get(0))
2624			->map(array($this, '___wrapAllCallback'))
2625			->append($this);
2626	}
2627  /**
2628   *
2629	 * @param $node
2630	 * @return unknown_type
2631	 * @access private
2632   */
2633	public function ___wrapAllCallback($node) {
2634		$deepest = $node;
2635		while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
2636			$deepest = $deepest->firstChild;
2637		return $deepest;
2638	}
2639	/**
2640	 * Enter description here...
2641	 * NON JQUERY METHOD
2642	 *
2643	 * @param String|phpQuery
2644	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2645	 */
2646	public function wrapAllPHP($codeBefore, $codeAfter) {
2647		return $this
2648			->slice(0, 1)
2649				->beforePHP($codeBefore)
2650			->end()
2651			->slice(-1)
2652				->afterPHP($codeAfter)
2653			->end();
2654	}
2655	/**
2656	 * Enter description here...
2657	 *
2658	 * @param String|phpQuery
2659	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2660	 */
2661	public function wrap($wrapper) {
2662		foreach($this->stack() as $node)
2663			phpQuery::pq($node, $this->getDocumentID())->wrapAll($wrapper);
2664		return $this;
2665	}
2666	/**
2667	 * Enter description here...
2668	 *
2669	 * @param String|phpQuery
2670	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2671	 */
2672	public function wrapPHP($codeBefore, $codeAfter) {
2673		foreach($this->stack() as $node)
2674			phpQuery::pq($node, $this->getDocumentID())->wrapAllPHP($codeBefore, $codeAfter);
2675		return $this;
2676	}
2677	/**
2678	 * Enter description here...
2679	 *
2680	 * @param String|phpQuery
2681	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2682	 */
2683	public function wrapInner($wrapper) {
2684		foreach($this->stack() as $node)
2685			phpQuery::pq($node, $this->getDocumentID())->contents()->wrapAll($wrapper);
2686		return $this;
2687	}
2688	/**
2689	 * Enter description here...
2690	 *
2691	 * @param String|phpQuery
2692	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2693	 */
2694	public function wrapInnerPHP($codeBefore, $codeAfter) {
2695		foreach($this->stack(1) as $node)
2696			phpQuery::pq($node, $this->getDocumentID())->contents()
2697				->wrapAllPHP($codeBefore, $codeAfter);
2698		return $this;
2699	}
2700	/**
2701	 * Enter description here...
2702	 *
2703	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2704	 * @testme Support for text nodes
2705	 */
2706	public function contents() {
2707		$stack = array();
2708		foreach($this->stack(1) as $el) {
2709			// FIXME (fixed) http://code.google.com/p/phpquery/issues/detail?id=56
2710//			if (! isset($el->childNodes))
2711//				continue;
2712			foreach($el->childNodes as $node) {
2713				$stack[] = $node;
2714			}
2715		}
2716		return $this->newInstance($stack);
2717	}
2718	/**
2719	 * Enter description here...
2720	 *
2721	 * jQuery difference.
2722	 *
2723	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2724	 */
2725	public function contentsUnwrap() {
2726		foreach($this->stack(1) as $node) {
2727			if (! $node->parentNode )
2728				continue;
2729			$childNodes = array();
2730			// any modification in DOM tree breaks childNodes iteration, so cache them first
2731			foreach($node->childNodes as $chNode )
2732				$childNodes[] = $chNode;
2733			foreach($childNodes as $chNode )
2734//				$node->parentNode->appendChild($chNode);
2735				$node->parentNode->insertBefore($chNode, $node);
2736			$node->parentNode->removeChild($node);
2737		}
2738		return $this;
2739	}
2740	/**
2741	 * Enter description here...
2742	 *
2743	 * jQuery difference.
2744	 */
2745	public function switchWith($markup) {
2746		$markup = pq($markup, $this->getDocumentID());
2747		$content = null;
2748		foreach($this->stack(1) as $node) {
2749			pq($node)
2750				->contents()->toReference($content)->end()
2751				->replaceWith($markup->clone()->append($content));
2752		}
2753		return $this;
2754	}
2755	/**
2756	 * Enter description here...
2757	 *
2758	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2759	 */
2760	public function eq($num) {
2761		$oldStack = $this->elements;
2762		$this->elementsBackup = $this->elements;
2763		$this->elements = array();
2764		if ( isset($oldStack[$num]) )
2765			$this->elements[] = $oldStack[$num];
2766		return $this->newInstance();
2767	}
2768	/**
2769	 * Enter description here...
2770	 *
2771	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2772	 */
2773	public function size() {
2774		return count($this->elements);
2775	}
2776	/**
2777	 * Enter description here...
2778	 *
2779	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2780	 * @deprecated Use length as attribute
2781	 */
2782	public function length() {
2783		return $this->size();
2784	}
2785	public function count() {
2786		return $this->size();
2787	}
2788	/**
2789	 * Enter description here...
2790	 *
2791	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2792	 * @todo $level
2793	 */
2794	public function end($level = 1) {
2795//		$this->elements = array_pop( $this->history );
2796//		return $this;
2797//		$this->previous->DOM = $this->DOM;
2798//		$this->previous->XPath = $this->XPath;
2799		return $this->previous
2800			? $this->previous
2801			: $this;
2802	}
2803	/**
2804	 * Enter description here...
2805	 * Normal use ->clone() .
2806	 *
2807	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2808	 * @access private
2809	 */
2810	public function _clone() {
2811		$newStack = array();
2812		//pr(array('copy... ', $this->whois()));
2813		//$this->dumpHistory('copy');
2814		$this->elementsBackup = $this->elements;
2815		foreach($this->elements as $node) {
2816			$newStack[] = $node->cloneNode(true);
2817		}
2818		$this->elements = $newStack;
2819		return $this->newInstance();
2820	}
2821	/**
2822	 * Enter description here...
2823	 *
2824	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2825	 */
2826	public function replaceWithPHP($code) {
2827		return $this->replaceWith(phpQuery::php($code));
2828	}
2829	/**
2830	 * Enter description here...
2831	 *
2832	 * @param String|phpQuery $content
2833	 * @link http://docs.jquery.com/Manipulation/replaceWith#content
2834	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2835	 */
2836	public function replaceWith($content) {
2837		return $this->after($content)->remove();
2838	}
2839	/**
2840	 * Enter description here...
2841	 *
2842	 * @param String $selector
2843	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2844	 * @todo this works ?
2845	 */
2846	public function replaceAll($selector) {
2847		foreach(phpQuery::pq($selector, $this->getDocumentID()) as $node)
2848			phpQuery::pq($node, $this->getDocumentID())
2849				->after($this->_clone())
2850				->remove();
2851		return $this;
2852	}
2853	/**
2854	 * Enter description here...
2855	 *
2856	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2857	 */
2858	public function remove($selector = null) {
2859		$loop = $selector
2860			? $this->filter($selector)->elements
2861			: $this->elements;
2862		foreach($loop as $node) {
2863			if (! $node->parentNode )
2864				continue;
2865			if (isset($node->tagName))
2866				$this->debug("Removing '{$node->tagName}'");
2867			$node->parentNode->removeChild($node);
2868			// Mutation event
2869			$event = new DOMEvent(array(
2870				'target' => $node,
2871				'type' => 'DOMNodeRemoved'
2872			));
2873			phpQueryEvents::trigger($this->getDocumentID(),
2874				$event->type, array($event), $node
2875			);
2876		}
2877		return $this;
2878	}
2879	protected function markupEvents($newMarkup, $oldMarkup, $node) {
2880		if ($node->tagName == 'textarea' && $newMarkup != $oldMarkup) {
2881			$event = new DOMEvent(array(
2882				'target' => $node,
2883				'type' => 'change'
2884			));
2885			phpQueryEvents::trigger($this->getDocumentID(),
2886				$event->type, array($event), $node
2887			);
2888		}
2889	}
2890	/**
2891	 * jQuey difference
2892	 *
2893	 * @param $markup
2894	 * @return unknown_type
2895	 * @TODO trigger change event for textarea
2896	 */
2897	public function markup($markup = null, $callback1 = null, $callback2 = null, $callback3 = null) {
2898		$args = func_get_args();
2899		if ($this->documentWrapper->isXML)
2900			return call_user_func_array(array($this, 'xml'), $args);
2901		else
2902			return call_user_func_array(array($this, 'html'), $args);
2903	}
2904	/**
2905	 * jQuey difference
2906	 *
2907	 * @param $markup
2908	 * @return unknown_type
2909	 */
2910	public function markupOuter($callback1 = null, $callback2 = null, $callback3 = null) {
2911		$args = func_get_args();
2912		if ($this->documentWrapper->isXML)
2913			return call_user_func_array(array($this, 'xmlOuter'), $args);
2914		else
2915			return call_user_func_array(array($this, 'htmlOuter'), $args);
2916	}
2917	/**
2918	 * Enter description here...
2919	 *
2920	 * @param unknown_type $html
2921	 * @return string|phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2922	 * @TODO force html result
2923	 */
2924	public function html($html = null, $callback1 = null, $callback2 = null, $callback3 = null) {
2925		if (isset($html)) {
2926			// INSERT
2927			$nodes = $this->documentWrapper->import($html);
2928			$this->empty();
2929			foreach($this->stack(1) as $alreadyAdded => $node) {
2930				// for now, limit events for textarea
2931				if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
2932					$oldHtml = pq($node, $this->getDocumentID())->markup();
2933				foreach($nodes as $newNode) {
2934					$node->appendChild($alreadyAdded
2935						? $newNode->cloneNode(true)
2936						: $newNode
2937					);
2938				}
2939				// for now, limit events for textarea
2940				if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
2941					$this->markupEvents($html, $oldHtml, $node);
2942			}
2943			return $this;
2944		} else {
2945			// FETCH
2946			$return = $this->documentWrapper->markup($this->elements, true);
2947			$args = func_get_args();
2948			foreach(array_slice($args, 1) as $callback) {
2949				$return = phpQuery::callbackRun($callback, array($return));
2950			}
2951			return $return;
2952		}
2953	}
2954	/**
2955	 * @TODO force xml result
2956	 */
2957	public function xml($xml = null, $callback1 = null, $callback2 = null, $callback3 = null) {
2958		$args = func_get_args();
2959		return call_user_func_array(array($this, 'html'), $args);
2960	}
2961	/**
2962	 * Enter description here...
2963	 * @TODO force html result
2964	 *
2965	 * @return String
2966	 */
2967	public function htmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
2968		$markup = $this->documentWrapper->markup($this->elements);
2969		// pass thou callbacks
2970		$args = func_get_args();
2971		foreach($args as $callback) {
2972			$markup = phpQuery::callbackRun($callback, array($markup));
2973		}
2974		return $markup;
2975	}
2976	/**
2977	 * @TODO force xml result
2978	 */
2979	public function xmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
2980		$args = func_get_args();
2981		return call_user_func_array(array($this, 'htmlOuter'), $args);
2982	}
2983	public function __toString() {
2984		return $this->markupOuter();
2985	}
2986	/**
2987	 * Just like html(), but returns markup with VALID (dangerous) PHP tags.
2988	 *
2989	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
2990	 * @todo support returning markup with PHP tags when called without param
2991	 */
2992	public function php($code = null) {
2993		return $this->markupPHP($code);
2994	}
2995	/**
2996	 * Enter description here...
2997	 * 
2998	 * @param $code
2999	 * @return unknown_type
3000	 */
3001	public function markupPHP($code = null) {
3002		return isset($code)
3003			? $this->markup(phpQuery::php($code))
3004			: phpQuery::markupToPHP($this->markup());
3005	}
3006	/**
3007	 * Enter description here...
3008	 * 
3009	 * @param $code
3010	 * @return unknown_type
3011	 */
3012	public function markupOuterPHP() {
3013		return phpQuery::markupToPHP($this->markupOuter());
3014	}
3015	/**
3016	 * Enter description here...
3017	 *
3018	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3019	 */
3020	public function children($selector = null) {
3021		$stack = array();
3022		foreach($this->stack(1) as $node) {
3023//			foreach($node->getElementsByTagName('*') as $newNode) {
3024			foreach($node->childNodes as $newNode) {
3025				if ($newNode->nodeType != 1)
3026					continue;
3027				if ($selector && ! $this->is($selector, $newNode))
3028					continue;
3029				if ($this->elementsContainsNode($newNode, $stack))
3030					continue;
3031				$stack[] = $newNode;
3032			}
3033		}
3034		$this->elementsBackup = $this->elements;
3035		$this->elements = $stack;
3036		return $this->newInstance();
3037	}
3038	/**
3039	 * Enter description here...
3040	 *
3041	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3042	 */
3043	public function ancestors($selector = null) {
3044		return $this->children( $selector );
3045	}
3046	/**
3047	 * Enter description here...
3048	 *
3049	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3050	 */
3051	public function append( $content) {
3052		return $this->insert($content, __FUNCTION__);
3053	}
3054	/**
3055	 * Enter description here...
3056	 *
3057	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3058	 */
3059	public function appendPHP( $content) {
3060		return $this->insert("<php><!-- {$content} --></php>", 'append');
3061	}
3062	/**
3063	 * Enter description here...
3064	 *
3065	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3066	 */
3067	public function appendTo( $seletor) {
3068		return $this->insert($seletor, __FUNCTION__);
3069	}
3070	/**
3071	 * Enter description here...
3072	 *
3073	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3074	 */
3075	public function prepend( $content) {
3076		return $this->insert($content, __FUNCTION__);
3077	}
3078	/**
3079	 * Enter description here...
3080	 *
3081	 * @todo accept many arguments, which are joined, arrays maybe also
3082	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3083	 */
3084	public function prependPHP( $content) {
3085		return $this->insert("<php><!-- {$content} --></php>", 'prepend');
3086	}
3087	/**
3088	 * Enter description here...
3089	 *
3090	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3091	 */
3092	public function prependTo( $seletor) {
3093		return $this->insert($seletor, __FUNCTION__);
3094	}
3095	/**
3096	 * Enter description here...
3097	 *
3098	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3099	 */
3100	public function before($content) {
3101		return $this->insert($content, __FUNCTION__);
3102	}
3103	/**
3104	 * Enter description here...
3105	 *
3106	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3107	 */
3108	public function beforePHP( $content) {
3109		return $this->insert("<php><!-- {$content} --></php>", 'before');
3110	}
3111	/**
3112	 * Enter description here...
3113	 *
3114	 * @param String|phpQuery
3115	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3116	 */
3117	public function insertBefore( $seletor) {
3118		return $this->insert($seletor, __FUNCTION__);
3119	}
3120	/**
3121	 * Enter description here...
3122	 *
3123	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3124	 */
3125	public function after( $content) {
3126		return $this->insert($content, __FUNCTION__);
3127	}
3128	/**
3129	 * Enter description here...
3130	 *
3131	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3132	 */
3133	public function afterPHP( $content) {
3134		return $this->insert("<php><!-- {$content} --></php>", 'after');
3135	}
3136	/**
3137	 * Enter description here...
3138	 *
3139	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3140	 */
3141	public function insertAfter( $seletor) {
3142		return $this->insert($seletor, __FUNCTION__);
3143	}
3144	/**
3145	 * Internal insert method. Don't use it.
3146	 *
3147	 * @param unknown_type $target
3148	 * @param unknown_type $type
3149	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3150	 * @access private
3151	 */
3152	public function insert($target, $type) {
3153		$this->debug("Inserting data with '{$type}'");
3154		$to = false;
3155		switch( $type) {
3156			case 'appendTo':
3157			case 'prependTo':
3158			case 'insertBefore':
3159			case 'insertAfter':
3160				$to = true;
3161		}
3162		switch(gettype($target)) {
3163			case 'string':
3164				$insertFrom = $insertTo = array();
3165				if ($to) {
3166					// INSERT TO
3167					$insertFrom = $this->elements;
3168					if (phpQuery::isMarkup($target)) {
3169						// $target is new markup, import it
3170						$insertTo = $this->documentWrapper->import($target);
3171					// insert into selected element
3172					} else {
3173						// $tagret is a selector
3174						$thisStack = $this->elements;
3175						$this->toRoot();
3176						$insertTo = $this->find($target)->elements;
3177						$this->elements = $thisStack;
3178					}
3179				} else {
3180					// INSERT FROM
3181					$insertTo = $this->elements;
3182					$insertFrom = $this->documentWrapper->import($target);
3183				}
3184				break;
3185			case 'object':
3186				$insertFrom = $insertTo = array();
3187				// phpQuery
3188				if ($target instanceof self) {
3189					if ($to) {
3190						$insertTo = $target->elements;
3191						if ($this->documentFragment && $this->stackIsRoot())
3192							// get all body children
3193//							$loop = $this->find('body > *')->elements;
3194							// TODO test it, test it hard...
3195//							$loop = $this->newInstance($this->root)->find('> *')->elements;
3196							$loop = $this->root->childNodes;
3197						else
3198							$loop = $this->elements;
3199						// import nodes if needed
3200						$insertFrom = $this->getDocumentID() == $target->getDocumentID()
3201							? $loop
3202							: $target->documentWrapper->import($loop);
3203					} else {
3204						$insertTo = $this->elements;
3205						if ( $target->documentFragment && $target->stackIsRoot() )
3206							// get all body children
3207//							$loop = $target->find('body > *')->elements;
3208							$loop = $target->root->childNodes;
3209						else
3210							$loop = $target->elements;
3211						// import nodes if needed
3212						$insertFrom = $this->getDocumentID() == $target->getDocumentID()
3213							? $loop
3214							: $this->documentWrapper->import($loop);
3215					}
3216				// DOMNODE
3217				} elseif ($target instanceof DOMNODE) {
3218					// import node if needed
3219//					if ( $target->ownerDocument != $this->DOM )
3220//						$target = $this->DOM->importNode($target, true);
3221					if ( $to) {
3222						$insertTo = array($target);
3223						if ($this->documentFragment && $this->stackIsRoot())
3224							// get all body children
3225							$loop = $this->root->childNodes;
3226//							$loop = $this->find('body > *')->elements;
3227						else
3228							$loop = $this->elements;
3229						foreach($loop as $fromNode)
3230							// import nodes if needed
3231							$insertFrom[] = ! $fromNode->ownerDocument->isSameNode($target->ownerDocument)
3232								? $target->ownerDocument->importNode($fromNode, true)
3233								: $fromNode;
3234					} else {
3235						// import node if needed
3236						if (! $target->ownerDocument->isSameNode($this->document))
3237							$target = $this->document->importNode($target, true);
3238						$insertTo = $this->elements;
3239						$insertFrom[] = $target;
3240					}
3241				}
3242				break;
3243		}
3244		phpQuery::debug("From ".count($insertFrom)."; To ".count($insertTo)." nodes");
3245		foreach($insertTo as $insertNumber => $toNode) {
3246			// we need static relative elements in some cases
3247			switch( $type) {
3248				case 'prependTo':
3249				case 'prepend':
3250					$firstChild = $toNode->firstChild;
3251					break;
3252				case 'insertAfter':
3253				case 'after':
3254					$nextSibling = $toNode->nextSibling;
3255					break;
3256			}
3257			foreach($insertFrom as $fromNode) {
3258				// clone if inserted already before
3259				$insert = $insertNumber
3260					? $fromNode->cloneNode(true)
3261					: $fromNode;
3262				switch($type) {
3263					case 'appendTo':
3264					case 'append':
3265//						$toNode->insertBefore(
3266//							$fromNode,
3267//							$toNode->lastChild->nextSibling
3268//						);
3269						$toNode->appendChild($insert);
3270						$eventTarget = $insert;
3271						break;
3272					case 'prependTo':
3273					case 'prepend':
3274						$toNode->insertBefore(
3275							$insert,
3276							$firstChild
3277						);
3278						break;
3279					case 'insertBefore':
3280					case 'before':
3281						if (! $toNode->parentNode)
3282							throw new Exception("No parentNode, can't do {$type}()");
3283						else
3284							$toNode->parentNode->insertBefore(
3285								$insert,
3286								$toNode
3287							);
3288						break;
3289					case 'insertAfter':
3290					case 'after':
3291						if (! $toNode->parentNode)
3292							throw new Exception("No parentNode, can't do {$type}()");
3293						else
3294							$toNode->parentNode->insertBefore(
3295								$insert,
3296								$nextSibling
3297							);
3298						break;
3299				}
3300				// Mutation event
3301				$event = new DOMEvent(array(
3302					'target' => $insert,
3303					'type' => 'DOMNodeInserted'
3304				));
3305				phpQueryEvents::trigger($this->getDocumentID(),
3306					$event->type, array($event), $insert
3307				);
3308			}
3309		}
3310		return $this;
3311	}
3312	/**
3313	 * Enter description here...
3314	 *
3315	 * @return Int
3316	 */
3317	public function index($subject) {
3318		$index = -1;
3319		$subject = $subject instanceof phpQueryObject
3320			? $subject->elements[0]
3321			: $subject;
3322		foreach($this->newInstance() as $k => $node) {
3323			if ($node->isSameNode($subject))
3324				$index = $k;
3325		}
3326		return $index;
3327	}
3328	/**
3329	 * Enter description here...
3330	 *
3331	 * @param unknown_type $start
3332	 * @param unknown_type $end
3333	 *
3334	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3335	 * @testme
3336	 */
3337	public function slice($start, $end = null) {
3338//		$last = count($this->elements)-1;
3339//		$end = $end
3340//			? min($end, $last)
3341//			: $last;
3342//		if ($start < 0)
3343//			$start = $last+$start;
3344//		if ($start > $last)
3345//			return array();
3346		if ($end > 0)
3347			$end = $end-$start;
3348		return $this->newInstance(
3349			array_slice($this->elements, $start, $end)
3350		);
3351	}
3352	/**
3353	 * Enter description here...
3354	 *
3355	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3356	 */
3357	public function reverse() {
3358		$this->elementsBackup = $this->elements;
3359		$this->elements = array_reverse($this->elements);
3360		return $this->newInstance();
3361	}
3362	/**
3363	 * Return joined text content.
3364	 * @return String
3365	 */
3366	public function text($text = null, $callback1 = null, $callback2 = null, $callback3 = null) {
3367		if (isset($text))
3368			return $this->html(htmlspecialchars($text));
3369		$args = func_get_args();
3370		$args = array_slice($args, 1);
3371		$return = '';
3372		foreach($this->elements as $node) {
3373			$text = $node->textContent;
3374			if (count($this->elements) > 1 && $text)
3375				$text .= "\n";
3376			foreach($args as $callback) {
3377				$text = phpQuery::callbackRun($callback, array($text));
3378			}
3379			$return .= $text;
3380		}
3381		return $return;
3382	}
3383	/**
3384	 * Enter description here...
3385	 *
3386	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3387	 */
3388	public function plugin($class, $file = null) {
3389		phpQuery::plugin($class, $file);
3390		return $this;
3391	}
3392	/**
3393	 * Deprecated, use $pq->plugin() instead.
3394	 *
3395	 * @deprecated
3396	 * @param $class
3397	 * @param $file
3398	 * @return unknown_type
3399	 */
3400	public static function extend($class, $file = null) {
3401		return $this->plugin($class, $file);
3402	}
3403	/**
3404	 *
3405	 * @access private
3406	 * @param $method
3407	 * @param $args
3408	 * @return unknown_type
3409	 */
3410	public function __call($method, $args) {
3411		$aliasMethods = array('clone', 'empty');
3412		if (isset(phpQuery::$extendMethods[$method])) {
3413			array_unshift($args, $this);
3414			return phpQuery::callbackRun(
3415				phpQuery::$extendMethods[$method], $args
3416			);
3417		} else if (isset(phpQuery::$pluginsMethods[$method])) {
3418			array_unshift($args, $this);
3419			$class = phpQuery::$pluginsMethods[$method];
3420			$realClass = "phpQueryObjectPlugin_$class";
3421			$return = call_user_func_array(
3422				array($realClass, $method),
3423				$args
3424			);
3425			// XXX deprecate ?
3426			return is_null($return)
3427				? $this
3428				: $return;
3429		} else if (in_array($method, $aliasMethods)) {
3430			return call_user_func_array(array($this, '_'.$method), $args);
3431		} else
3432			throw new Exception("Method '{$method}' doesnt exist");
3433	}
3434	/**
3435	 * Safe rename of next().
3436	 *
3437	 * Use it ONLY when need to call next() on an iterated object (in same time).
3438	 * Normaly there is no need to do such thing ;)
3439	 *
3440	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3441	 * @access private
3442	 */
3443	public function _next($selector = null) {
3444		return $this->newInstance(
3445			$this->getElementSiblings('nextSibling', $selector, true)
3446		);
3447	}
3448	/**
3449	 * Use prev() and next().
3450	 *
3451	 * @deprecated
3452	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3453	 * @access private
3454	 */
3455	public function _prev($selector = null) {
3456		return $this->prev($selector);
3457	}
3458	/**
3459	 * Enter description here...
3460	 *
3461	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3462	 */
3463	public function prev($selector = null) {
3464		return $this->newInstance(
3465			$this->getElementSiblings('previousSibling', $selector, true)
3466		);
3467	}
3468	/**
3469	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3470	 * @todo
3471	 */
3472	public function prevAll($selector = null) {
3473		return $this->newInstance(
3474			$this->getElementSiblings('previousSibling', $selector)
3475		);
3476	}
3477	/**
3478	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3479	 * @todo FIXME: returns source elements insted of next siblings
3480	 */
3481	public function nextAll($selector = null) {
3482		return $this->newInstance(
3483			$this->getElementSiblings('nextSibling', $selector)
3484		);
3485	}
3486	/**
3487	 * @access private
3488	 */
3489	protected function getElementSiblings($direction, $selector = null, $limitToOne = false) {
3490		$stack = array();
3491		$count = 0;
3492		foreach($this->stack() as $node) {
3493			$test = $node;
3494			while( isset($test->{$direction}) && $test->{$direction}) {
3495				$test = $test->{$direction};
3496				if (! $test instanceof DOMELEMENT)
3497					continue;
3498				$stack[] = $test;
3499				if ($limitToOne)
3500					break;
3501			}
3502		}
3503		if ($selector) {
3504			$stackOld = $this->elements;
3505			$this->elements = $stack;
3506			$stack = $this->filter($selector, true)->stack();
3507			$this->elements = $stackOld;
3508		}
3509		return $stack;
3510	}
3511	/**
3512	 * Enter description here...
3513	 *
3514	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3515	 */
3516	public function siblings($selector = null) {
3517		$stack = array();
3518		$siblings = array_merge(
3519			$this->getElementSiblings('previousSibling', $selector),
3520			$this->getElementSiblings('nextSibling', $selector)
3521		);
3522		foreach($siblings as $node) {
3523			if (! $this->elementsContainsNode($node, $stack))
3524				$stack[] = $node;
3525		}
3526		return $this->newInstance($stack);
3527	}
3528	/**
3529	 * Enter description here...
3530	 *
3531	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3532	 */
3533	public function not($selector = null) {
3534		if (is_string($selector))
3535			phpQuery::debug(array('not', $selector));
3536		else
3537			phpQuery::debug('not');
3538		$stack = array();
3539		if ($selector instanceof self || $selector instanceof DOMNODE) {
3540			foreach($this->stack() as $node) {
3541				if ($selector instanceof self) {
3542					$matchFound = false;
3543					foreach($selector->stack() as $notNode) {
3544						if ($notNode->isSameNode($node))
3545							$matchFound = true;
3546					}
3547					if (! $matchFound)
3548						$stack[] = $node;
3549				} else if ($selector instanceof DOMNODE) {
3550					if (! $selector->isSameNode($node))
3551						$stack[] = $node;
3552				} else {
3553					if (! $this->is($selector))
3554						$stack[] = $node;
3555				}
3556			}
3557		} else {
3558			$orgStack = $this->stack();
3559			$matched = $this->filter($selector, true)->stack();
3560//			$matched = array();
3561//			// simulate OR in filter() instead of AND 5y
3562//			foreach($this->parseSelector($selector) as $s) {
3563//				$matched = array_merge($matched,
3564//					$this->filter(array($s))->stack()
3565//				);
3566//			}
3567			foreach($orgStack as $node)
3568				if (! $this->elementsContainsNode($node, $matched))
3569					$stack[] = $node;
3570		}
3571		return $this->newInstance($stack);
3572	}
3573	/**
3574	 * Enter description here...
3575	 *
3576	 * @param string|phpQueryObject
3577	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3578	 */
3579	public function add($selector = null) {
3580		if (! $selector)
3581			return $this;
3582		$stack = array();
3583		$this->elementsBackup = $this->elements;
3584		$found = phpQuery::pq($selector, $this->getDocumentID());
3585		$this->merge($found->elements);
3586		return $this->newInstance();
3587	}
3588	/**
3589	 * @access private
3590	 */
3591	protected function merge() {
3592		foreach(func_get_args() as $nodes)
3593			foreach($nodes as $newNode )
3594				if (! $this->elementsContainsNode($newNode) )
3595					$this->elements[] = $newNode;
3596	}
3597	/**
3598	 * @access private
3599	 * TODO refactor to stackContainsNode
3600	 */
3601	protected function elementsContainsNode($nodeToCheck, $elementsStack = null) {
3602		$loop = ! is_null($elementsStack)
3603			? $elementsStack
3604			: $this->elements;
3605		foreach($loop as $node) {
3606			if ( $node->isSameNode( $nodeToCheck ) )
3607				return true;
3608		}
3609		return false;
3610	}
3611	/**
3612	 * Enter description here...
3613	 *
3614	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3615	 */
3616	public function parent($selector = null) {
3617		$stack = array();
3618		foreach($this->elements as $node )
3619			if ( $node->parentNode && ! $this->elementsContainsNode($node->parentNode, $stack) )
3620				$stack[] = $node->parentNode;
3621		$this->elementsBackup = $this->elements;
3622		$this->elements = $stack;
3623		if ( $selector )
3624			$this->filter($selector, true);
3625		return $this->newInstance();
3626	}
3627	/**
3628	 * Enter description here...
3629	 *
3630	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3631	 */
3632	public function parents($selector = null) {
3633		$stack = array();
3634		if (! $this->elements )
3635			$this->debug('parents() - stack empty');
3636		foreach($this->elements as $node) {
3637			$test = $node;
3638			while( $test->parentNode) {
3639				$test = $test->parentNode;
3640				if ($this->isRoot($test))
3641					break;
3642				if (! $this->elementsContainsNode($test, $stack)) {
3643					$stack[] = $test;
3644					continue;
3645				}
3646			}
3647		}
3648		$this->elementsBackup = $this->elements;
3649		$this->elements = $stack;
3650		if ( $selector )
3651			$this->filter($selector, true);
3652		return $this->newInstance();
3653	}
3654	/**
3655	 * Internal stack iterator.
3656	 *
3657	 * @access private
3658	 */
3659	public function stack($nodeTypes = null) {
3660		if (!isset($nodeTypes))
3661			return $this->elements;
3662		if (!is_array($nodeTypes))
3663			$nodeTypes = array($nodeTypes);
3664		$return = array();
3665		foreach($this->elements as $node) {
3666			if (in_array($node->nodeType, $nodeTypes))
3667				$return[] = $node;
3668		}
3669		return $return;
3670	}
3671	// TODO phpdoc; $oldAttr is result of hasAttribute, before any changes
3672	protected function attrEvents($attr, $oldAttr, $oldValue, $node) {
3673		// skip events for XML documents
3674		if (! $this->isXHTML() && ! $this->isHTML())
3675			return;
3676		$event = null;
3677		// identify
3678		$isInputValue = $node->tagName == 'input'
3679			&& (
3680				in_array($node->getAttribute('type'),
3681					array('text', 'password', 'hidden'))
3682				|| !$node->getAttribute('type')
3683				 );
3684		$isRadio = $node->tagName == 'input'
3685			&& $node->getAttribute('type') == 'radio';
3686		$isCheckbox = $node->tagName == 'input'
3687			&& $node->getAttribute('type') == 'checkbox';
3688		$isOption = $node->tagName == 'option';
3689		if ($isInputValue && $attr == 'value' && $oldValue != $node->getAttribute($attr)) {
3690			$event = new DOMEvent(array(
3691				'target' => $node,
3692				'type' => 'change'
3693			));
3694		} else if (($isRadio || $isCheckbox) && $attr == 'checked' && (
3695				// check
3696				(! $oldAttr && $node->hasAttribute($attr))
3697				// un-check
3698				|| (! $node->hasAttribute($attr) && $oldAttr)
3699			)) {
3700			$event = new DOMEvent(array(
3701				'target' => $node,
3702				'type' => 'change'
3703			));
3704		} else if ($isOption && $node->parentNode && $attr == 'selected' && (
3705				// select
3706				(! $oldAttr && $node->hasAttribute($attr))
3707				// un-select
3708				|| (! $node->hasAttribute($attr) && $oldAttr)
3709			)) {
3710			$event = new DOMEvent(array(
3711				'target' => $node->parentNode,
3712				'type' => 'change'
3713			));
3714		}
3715		if ($event) {
3716			phpQueryEvents::trigger($this->getDocumentID(),
3717				$event->type, array($event), $node
3718			);
3719		}
3720	}
3721	public function attr($attr = null, $value = null) {
3722		foreach($this->stack(1) as $node) {
3723			if (! is_null($value)) {
3724				$loop = $attr == '*'
3725					? $this->getNodeAttrs($node)
3726					: array($attr);
3727				foreach($loop as $a) {
3728					$oldValue = $node->getAttribute($a);
3729					$oldAttr = $node->hasAttribute($a);
3730					// TODO raises an error when charset other than UTF-8
3731					// while document's charset is also not UTF-8
3732					@$node->setAttribute($a, $value);
3733					$this->attrEvents($a, $oldAttr, $oldValue, $node);
3734				}
3735			} else if ($attr == '*') {
3736				// jQuery difference
3737				$return = array();
3738				foreach($node->attributes as $n => $v)
3739					$return[$n] = $v->value;
3740				return $return;
3741			} else
3742				return $node->hasAttribute($attr)
3743					? $node->getAttribute($attr)
3744					: null;
3745		}
3746		return is_null($value)
3747			? '' : $this;
3748	}
3749	/**
3750	 * @access private
3751	 */
3752	protected function getNodeAttrs($node) {
3753		$return = array();
3754		foreach($node->attributes as $n => $o)
3755			$return[] = $n;
3756		return $return;
3757	}
3758	/**
3759	 * Enter description here...
3760	 *
3761	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3762	 * @todo check CDATA ???
3763	 */
3764	public function attrPHP($attr, $code) {
3765		if (! is_null($code)) {
3766			$value = '<'.'?php '.$code.' ?'.'>';
3767			// TODO tempolary solution
3768			// http://code.google.com/p/phpquery/issues/detail?id=17
3769//			if (function_exists('mb_detect_encoding') && mb_detect_encoding($value) == 'ASCII')
3770//				$value	= mb_convert_encoding($value, 'UTF-8', 'HTML-ENTITIES');
3771		}
3772		foreach($this->stack(1) as $node) {
3773			if (! is_null($code)) {
3774//				$attrNode = $this->DOM->createAttribute($attr);
3775				$node->setAttribute($attr, $value);
3776//				$attrNode->value = $value;
3777//				$node->appendChild($attrNode);
3778			} else if ( $attr == '*') {
3779				// jQuery diff
3780				$return = array();
3781				foreach($node->attributes as $n => $v)
3782					$return[$n] = $v->value;
3783				return $return;
3784			} else
3785				return $node->getAttribute($attr);
3786		}
3787		return $this;
3788	}
3789	/**
3790	 * Enter description here...
3791	 *
3792	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3793	 */
3794	public function removeAttr($attr) {
3795		foreach($this->stack(1) as $node) {
3796			$loop = $attr == '*'
3797				? $this->getNodeAttrs($node)
3798				: array($attr);
3799			foreach($loop as $a) {
3800				$oldValue = $node->getAttribute($a);
3801				$node->removeAttribute($a);
3802				$this->attrEvents($a, $oldValue, null, $node);
3803			}
3804		}
3805		return $this;
3806	}
3807	/**
3808	 * Return form element value.
3809	 *
3810	 * @return String Fields value.
3811	 */
3812	public function val($val = null) {
3813		if (! isset($val)) {
3814			if ($this->eq(0)->is('select')) {
3815					$selected = $this->eq(0)->find('option[selected=selected]');
3816					if ($selected->is('[value]'))
3817						return $selected->attr('value');
3818					else
3819						return $selected->text();
3820			} else if ($this->eq(0)->is('textarea'))
3821					return $this->eq(0)->markup();
3822				else
3823					return $this->eq(0)->attr('value');
3824		} else {
3825			$_val = null;
3826			foreach($this->stack(1) as $node) {
3827				$node = pq($node, $this->getDocumentID());
3828				if (is_array($val) && in_array($node->attr('type'), array('checkbox', 'radio'))) {
3829					$isChecked = in_array($node->attr('value'), $val)
3830							|| in_array($node->attr('name'), $val);
3831					if ($isChecked)
3832						$node->attr('checked', 'checked');
3833					else
3834						$node->removeAttr('checked');
3835				} else if ($node->get(0)->tagName == 'select') {
3836					if (! isset($_val)) {
3837						$_val = array();
3838						if (! is_array($val))
3839							$_val = array((string)$val);
3840						else
3841							foreach($val as $v)
3842								$_val[] = $v;
3843					}
3844					foreach($node['option']->stack(1) as $option) {
3845						$option = pq($option, $this->getDocumentID());
3846						$selected = false;
3847						// XXX: workaround for string comparsion, see issue #96
3848						// http://code.google.com/p/phpquery/issues/detail?id=96
3849						$selected = is_null($option->attr('value'))
3850							? in_array($option->markup(), $_val)
3851							: in_array($option->attr('value'), $_val);
3852//						$optionValue = $option->attr('value');
3853//						$optionText = $option->text();
3854//						$optionTextLenght = mb_strlen($optionText);
3855//						foreach($_val as $v)
3856//							if ($optionValue == $v)
3857//								$selected = true;
3858//							else if ($optionText == $v && $optionTextLenght == mb_strlen($v))
3859//								$selected = true;
3860						if ($selected)
3861							$option->attr('selected', 'selected');
3862						else
3863							$option->removeAttr('selected');
3864					}
3865				} else if ($node->get(0)->tagName == 'textarea')
3866					$node->markup($val);
3867				else
3868					$node->attr('value', $val);
3869			}
3870		}
3871		return $this;
3872	}
3873	/**
3874	 * Enter description here...
3875	 *
3876	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3877	 */
3878	public function andSelf() {
3879		if ( $this->previous )
3880			$this->elements = array_merge($this->elements, $this->previous->elements);
3881		return $this;
3882	}
3883	/**
3884	 * Enter description here...
3885	 *
3886	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3887	 */
3888	public function addClass( $className) {
3889		if (! $className)
3890			return $this;
3891		foreach($this->stack(1) as $node) {
3892			if (! $this->is(".$className", $node))
3893				$node->setAttribute(
3894					'class',
3895					trim($node->getAttribute('class').' '.$className)
3896				);
3897		}
3898		return $this;
3899	}
3900	/**
3901	 * Enter description here...
3902	 *
3903	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3904	 */
3905	public function addClassPHP( $className) {
3906		foreach($this->stack(1) as $node) {
3907				$classes = $node->getAttribute('class');
3908				$newValue = $classes
3909					? $classes.' <'.'?php '.$className.' ?'.'>'
3910					: '<'.'?php '.$className.' ?'.'>';
3911				$node->setAttribute('class', $newValue);
3912		}
3913		return $this;
3914	}
3915	/**
3916	 * Enter description here...
3917	 *
3918	 * @param	string	$className
3919	 * @return	bool
3920	 */
3921	public function hasClass($className) {
3922		foreach($this->stack(1) as $node) {
3923			if ( $this->is(".$className", $node))
3924				return true;
3925		}
3926		return false;
3927	}
3928	/**
3929	 * Enter description here...
3930	 *
3931	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3932	 */
3933	public function removeClass($className) {
3934		foreach($this->stack(1) as $node) {
3935			$classes = explode( ' ', $node->getAttribute('class'));
3936			if ( in_array($className, $classes)) {
3937				$classes = array_diff($classes, array($className));
3938				if ( $classes )
3939					$node->setAttribute('class', implode(' ', $classes));
3940				else
3941					$node->removeAttribute('class');
3942			}
3943		}
3944		return $this;
3945	}
3946	/**
3947	 * Enter description here...
3948	 *
3949	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3950	 */
3951	public function toggleClass($className) {
3952		foreach($this->stack(1) as $node) {
3953			if ( $this->is( $node, '.'.$className ))
3954				$this->removeClass($className);
3955			else
3956				$this->addClass($className);
3957		}
3958		return $this;
3959	}
3960	/**
3961	 * Proper name without underscore (just ->empty()) also works.
3962	 *
3963	 * Removes all child nodes from the set of matched elements.
3964	 *
3965	 * Example:
3966	 * pq("p")._empty()
3967	 *
3968	 * HTML:
3969	 * <p>Hello, <span>Person</span> <a href="#">and person</a></p>
3970	 *
3971	 * Result:
3972	 * [ <p></p> ]
3973	 *
3974	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3975	 * @access private
3976	 */
3977	public function _empty() {
3978		foreach($this->stack(1) as $node) {
3979			// thx to 'dave at dgx dot cz'
3980			$node->nodeValue = '';
3981		}
3982		return $this;
3983	}
3984	/**
3985	 * Enter description here...
3986	 *
3987	 * @param array|string $callback Expects $node as first param, $index as second
3988	 * @param array $scope External variables passed to callback. Use compact('varName1', 'varName2'...) and extract($scope)
3989	 * @param array $arg1 Will ba passed as third and futher args to callback.
3990	 * @param array $arg2 Will ba passed as fourth and futher args to callback, and so on...
3991	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
3992	 */
3993	public function each($callback, $param1 = null, $param2 = null, $param3 = null) {
3994		$paramStructure = null;
3995		if (func_num_args() > 1) {
3996			$paramStructure = func_get_args();
3997			$paramStructure = array_slice($paramStructure, 1);
3998		}
3999		foreach($this->elements as $v)
4000			phpQuery::callbackRun($callback, array($v), $paramStructure);
4001		return $this;
4002	}
4003	/**
4004	 * Run callback on actual object.
4005	 *
4006	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4007	 */
4008	public function callback($callback, $param1 = null, $param2 = null, $param3 = null) {
4009		$params = func_get_args();
4010		$params[0] = $this;
4011		phpQuery::callbackRun($callback, $params);
4012		return $this;
4013	}
4014	/**
4015	 * Enter description here...
4016	 *
4017	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4018	 * @todo add $scope and $args as in each() ???
4019	 */
4020	public function map($callback, $param1 = null, $param2 = null, $param3 = null) {
4021//		$stack = array();
4022////		foreach($this->newInstance() as $node) {
4023//		foreach($this->newInstance() as $node) {
4024//			$result = call_user_func($callback, $node);
4025//			if ($result)
4026//				$stack[] = $result;
4027//		}
4028		$params = func_get_args();
4029		array_unshift($params, $this->elements);
4030		return $this->newInstance(
4031			call_user_func_array(array('phpQuery', 'map'), $params)
4032//			phpQuery::map($this->elements, $callback)
4033		);
4034	}
4035	/**
4036	 * Enter description here...
4037	 * 
4038	 * @param <type> $key
4039	 * @param <type> $value
4040	 */
4041	public function data($key, $value = null) {
4042		if (! isset($value)) {
4043			// TODO? implement specific jQuery behavior od returning parent values
4044			// is child which we look up doesn't exist
4045			return phpQuery::data($this->get(0), $key, $value, $this->getDocumentID());
4046		} else {
4047			foreach($this as $node)
4048				phpQuery::data($node, $key, $value, $this->getDocumentID());
4049			return $this;
4050		}
4051	}
4052	/**
4053	 * Enter description here...
4054	 * 
4055	 * @param <type> $key
4056	 */
4057	public function removeData($key) {
4058		foreach($this as $node)
4059			phpQuery::removeData($node, $key, $this->getDocumentID());
4060		return $this;
4061	}
4062	// INTERFACE IMPLEMENTATIONS
4063
4064	// ITERATOR INTERFACE
4065	/**
4066   * @access private
4067	 */
4068	public function rewind(){
4069		$this->debug('iterating foreach');
4070//		phpQuery::selectDocument($this->getDocumentID());
4071		$this->elementsBackup = $this->elements;
4072		$this->elementsInterator = $this->elements;
4073		$this->valid = isset( $this->elements[0] )
4074			? 1 : 0;
4075// 		$this->elements = $this->valid
4076// 			? array($this->elements[0])
4077// 			: array();
4078		$this->current = 0;
4079	}
4080	/**
4081   * @access private
4082	 */
4083	public function current(){
4084		return $this->elementsInterator[ $this->current ];
4085	}
4086	/**
4087   * @access private
4088	 */
4089	public function key(){
4090		return $this->current;
4091	}
4092	/**
4093	 * Double-function method.
4094	 *
4095	 * First: main iterator interface method.
4096	 * Second: Returning next sibling, alias for _next().
4097	 *
4098	 * Proper functionality is choosed automagicaly.
4099	 *
4100	 * @see phpQueryObject::_next()
4101	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4102	 */
4103	public function next($cssSelector = null){
4104//		if ($cssSelector || $this->valid)
4105//			return $this->_next($cssSelector);
4106		$this->valid = isset( $this->elementsInterator[ $this->current+1 ] )
4107			? true
4108			: false;
4109		if (! $this->valid && $this->elementsInterator) {
4110			$this->elementsInterator = null;
4111		} else if ($this->valid) {
4112			$this->current++;
4113		} else {
4114			return $this->_next($cssSelector);
4115		}
4116	}
4117	/**
4118   * @access private
4119	 */
4120	public function valid(){
4121		return $this->valid;
4122	}
4123	// ITERATOR INTERFACE END
4124	// ARRAYACCESS INTERFACE
4125	/**
4126   * @access private
4127	 */
4128	public function offsetExists($offset) {
4129		return $this->find($offset)->size() > 0;
4130	}
4131	/**
4132   * @access private
4133	 */
4134	public function offsetGet($offset) {
4135		return $this->find($offset);
4136	}
4137	/**
4138   * @access private
4139	 */
4140	public function offsetSet($offset, $value) {
4141//		$this->find($offset)->replaceWith($value);
4142		$this->find($offset)->html($value);
4143	}
4144	/**
4145   * @access private
4146	 */
4147	public function offsetUnset($offset) {
4148		// empty
4149		throw new Exception("Can't do unset, use array interface only for calling queries and replacing HTML.");
4150	}
4151	// ARRAYACCESS INTERFACE END
4152	/**
4153	 * Returns node's XPath.
4154	 *
4155	 * @param unknown_type $oneNode
4156	 * @return string
4157	 * @TODO use native getNodePath is avaible
4158	 * @access private
4159	 */
4160	protected function getNodeXpath($oneNode = null, $namespace = null) {
4161		$return = array();
4162		$loop = $oneNode
4163			? array($oneNode)
4164			: $this->elements;
4165//		if ($namespace)
4166//			$namespace .= ':';
4167		foreach($loop as $node) {
4168			if ($node instanceof DOMDOCUMENT) {
4169				$return[] = '';
4170				continue;
4171			}
4172			$xpath = array();
4173			while(! ($node instanceof DOMDOCUMENT)) {
4174				$i = 1;
4175				$sibling = $node;
4176				while($sibling->previousSibling) {
4177					$sibling = $sibling->previousSibling;
4178					$isElement = $sibling instanceof DOMELEMENT;
4179					if ($isElement && $sibling->tagName == $node->tagName)
4180						$i++;
4181				}
4182				$xpath[] = $this->isXML()
4183					? "*[local-name()='{$node->tagName}'][{$i}]"
4184					: "{$node->tagName}[{$i}]";
4185				$node = $node->parentNode;
4186			}
4187			$xpath = join('/', array_reverse($xpath));
4188			$return[] = '/'.$xpath;
4189		}
4190		return $oneNode
4191			? $return[0]
4192			: $return;
4193	}
4194	// HELPERS
4195	public function whois($oneNode = null) {
4196		$return = array();
4197		$loop = $oneNode
4198			? array( $oneNode )
4199			: $this->elements;
4200		foreach($loop as $node) {
4201			if (isset($node->tagName)) {
4202				$tag = in_array($node->tagName, array('php', 'js'))
4203					? strtoupper($node->tagName)
4204					: $node->tagName;
4205				$return[] = $tag
4206					.($node->getAttribute('id')
4207						? '#'.$node->getAttribute('id'):'')
4208					.($node->getAttribute('class')
4209						? '.'.join('.', split(' ', $node->getAttribute('class'))):'')
4210					.($node->getAttribute('name')
4211						? '[name="'.$node->getAttribute('name').'"]':'')
4212					.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') === false
4213						? '[value="'.substr(str_replace("\n", '', $node->getAttribute('value')), 0, 15).'"]':'')
4214					.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') !== false
4215						? '[value=PHP]':'')
4216					.($node->getAttribute('selected')
4217						? '[selected]':'')
4218					.($node->getAttribute('checked')
4219						? '[checked]':'')
4220				;
4221			} else if ($node instanceof DOMTEXT) {
4222				if (trim($node->textContent))
4223					$return[] = 'Text:'.substr(str_replace("\n", ' ', $node->textContent), 0, 15);
4224			} else {
4225
4226			}
4227		}
4228		return $oneNode && isset($return[0])
4229			? $return[0]
4230			: $return;
4231	}
4232	/**
4233	 * Dump htmlOuter and preserve chain. Usefull for debugging.
4234	 *
4235	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4236	 *
4237	 */
4238	public function dump() {
4239		print 'DUMP #'.(phpQuery::$dumpCount++).' ';
4240		$debug = phpQuery::$debug;
4241		phpQuery::$debug = false;
4242//		print __FILE__.':'.__LINE__."\n";
4243		var_dump($this->htmlOuter());
4244		return $this;
4245	}
4246	public function dumpWhois() {
4247		print 'DUMP #'.(phpQuery::$dumpCount++).' ';
4248		$debug = phpQuery::$debug;
4249		phpQuery::$debug = false;
4250//		print __FILE__.':'.__LINE__."\n";
4251		var_dump('whois', $this->whois());
4252		phpQuery::$debug = $debug;
4253		return $this;
4254	}
4255	public function dumpLength() {
4256		print 'DUMP #'.(phpQuery::$dumpCount++).' ';
4257		$debug = phpQuery::$debug;
4258		phpQuery::$debug = false;
4259//		print __FILE__.':'.__LINE__."\n";
4260		var_dump('length', $this->length());
4261		phpQuery::$debug = $debug;
4262		return $this;
4263	}
4264	public function dumpTree($html = true, $title = true) {
4265		$output = $title
4266			? 'DUMP #'.(phpQuery::$dumpCount++)." \n" : '';
4267		$debug = phpQuery::$debug;
4268		phpQuery::$debug = false;
4269		foreach($this->stack() as $node)
4270			$output .= $this->__dumpTree($node);
4271		phpQuery::$debug = $debug;
4272		print $html
4273			? nl2br(str_replace(' ', '&nbsp;', $output))
4274			: $output;
4275		return $this;
4276	}
4277	private function __dumpTree($node, $intend = 0) {
4278		$whois = $this->whois($node);
4279		$return = '';
4280		if ($whois)
4281			$return .= str_repeat(' - ', $intend).$whois."\n";
4282		if (isset($node->childNodes))
4283			foreach($node->childNodes as $chNode)
4284				$return .= $this->__dumpTree($chNode, $intend+1);
4285		return $return;
4286	}
4287	/**
4288	 * Dump htmlOuter and stop script execution. Usefull for debugging.
4289	 *
4290	 */
4291	public function dumpDie() {
4292		print __FILE__.':'.__LINE__;
4293		var_dump($this->htmlOuter());
4294		die();
4295	}
4296}
4297
4298
4299// -- Multibyte Compatibility functions ---------------------------------------
4300// http://svn.iphonewebdev.com/lace/lib/mb_compat.php
4301
4302/**
4303 *  mb_internal_encoding()
4304 *
4305 *  Included for mbstring pseudo-compatability.
4306 */
4307if (!function_exists('mb_internal_encoding'))
4308{
4309	function mb_internal_encoding($enc) {return true; }
4310}
4311
4312/**
4313 *  mb_regex_encoding()
4314 *
4315 *  Included for mbstring pseudo-compatability.
4316 */
4317if (!function_exists('mb_regex_encoding'))
4318{
4319	function mb_regex_encoding($enc) {return true; }
4320}
4321
4322/**
4323 *  mb_strlen()
4324 *
4325 *  Included for mbstring pseudo-compatability.
4326 */
4327if (!function_exists('mb_strlen'))
4328{
4329	function mb_strlen($str)
4330	{
4331		return strlen($str);
4332	}
4333}
4334
4335/**
4336 *  mb_strpos()
4337 *
4338 *  Included for mbstring pseudo-compatability.
4339 */
4340if (!function_exists('mb_strpos'))
4341{
4342	function mb_strpos($haystack, $needle, $offset=0)
4343	{
4344		return strpos($haystack, $needle, $offset);
4345	}
4346}
4347/**
4348 *  mb_stripos()
4349 *
4350 *  Included for mbstring pseudo-compatability.
4351 */
4352if (!function_exists('mb_stripos'))
4353{
4354	function mb_stripos($haystack, $needle, $offset=0)
4355	{
4356		return stripos($haystack, $needle, $offset);
4357	}
4358}
4359
4360/**
4361 *  mb_substr()
4362 *
4363 *  Included for mbstring pseudo-compatability.
4364 */
4365if (!function_exists('mb_substr'))
4366{
4367	function mb_substr($str, $start, $length=0)
4368	{
4369		return substr($str, $start, $length);
4370	}
4371}
4372
4373/**
4374 *  mb_substr_count()
4375 *
4376 *  Included for mbstring pseudo-compatability.
4377 */
4378if (!function_exists('mb_substr_count'))
4379{
4380	function mb_substr_count($haystack, $needle)
4381	{
4382		return substr_count($haystack, $needle);
4383	}
4384}
4385
4386
4387/**
4388 * Static namespace for phpQuery functions.
4389 *
4390 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
4391 * @package phpQuery
4392 */
4393abstract class phpQuery {
4394	/**
4395	 * XXX: Workaround for mbstring problems 
4396	 * 
4397	 * @var bool
4398	 */
4399	public static $mbstringSupport = true;
4400	public static $debug = false;
4401	public static $documents = array();
4402	public static $defaultDocumentID = null;
4403//	public static $defaultDoctype = 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"';
4404	/**
4405	 * Applies only to HTML.
4406	 *
4407	 * @var unknown_type
4408	 */
4409	public static $defaultDoctype = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
4410"http://www.w3.org/TR/html4/loose.dtd">';
4411	public static $defaultCharset = 'UTF-8';
4412	/**
4413	 * Static namespace for plugins.
4414	 *
4415	 * @var object
4416	 */
4417	public static $plugins = array();
4418	/**
4419	 * List of loaded plugins.
4420	 *
4421	 * @var unknown_type
4422	 */
4423	public static $pluginsLoaded = array();
4424	public static $pluginsMethods = array();
4425	public static $pluginsStaticMethods = array();
4426	public static $extendMethods = array();
4427	/**
4428	 * @TODO implement
4429	 */
4430	public static $extendStaticMethods = array();
4431	/**
4432	 * Hosts allowed for AJAX connections.
4433	 * Dot '.' means $_SERVER['HTTP_HOST'] (if any).
4434	 *
4435	 * @var array
4436	 */
4437	public static $ajaxAllowedHosts = array(
4438		'.'
4439	);
4440	/**
4441	 * AJAX settings.
4442	 *
4443	 * @var array
4444	 * XXX should it be static or not ?
4445	 */
4446	public static $ajaxSettings = array(
4447		'url' => '',//TODO
4448		'global' => true,
4449		'type' => "GET",
4450		'timeout' => null,
4451		'contentType' => "application/x-www-form-urlencoded",
4452		'processData' => true,
4453//		'async' => true,
4454		'data' => null,
4455		'username' => null,
4456		'password' => null,
4457		'accepts' => array(
4458			'xml' => "application/xml, text/xml",
4459			'html' => "text/html",
4460			'script' => "text/javascript, application/javascript",
4461			'json' => "application/json, text/javascript",
4462			'text' => "text/plain",
4463			'_default' => "*/*"
4464		)
4465	);
4466	public static $lastModified = null;
4467	public static $active = 0;
4468	public static $dumpCount = 0;
4469	/**
4470	 * Multi-purpose function.
4471	 * Use pq() as shortcut.
4472	 *
4473	 * In below examples, $pq is any result of pq(); function.
4474	 *
4475	 * 1. Import markup into existing document (without any attaching):
4476	 * - Import into selected document:
4477	 *   pq('<div/>')				// DOESNT accept text nodes at beginning of input string !
4478	 * - Import into document with ID from $pq->getDocumentID():
4479	 *   pq('<div/>', $pq->getDocumentID())
4480	 * - Import into same document as DOMNode belongs to:
4481	 *   pq('<div/>', DOMNode)
4482	 * - Import into document from phpQuery object:
4483	 *   pq('<div/>', $pq)
4484	 *
4485	 * 2. Run query:
4486	 * - Run query on last selected document:
4487	 *   pq('div.myClass')
4488	 * - Run query on document with ID from $pq->getDocumentID():
4489	 *   pq('div.myClass', $pq->getDocumentID())
4490	 * - Run query on same document as DOMNode belongs to and use node(s)as root for query:
4491	 *   pq('div.myClass', DOMNode)
4492	 * - Run query on document from phpQuery object
4493	 *   and use object's stack as root node(s) for query:
4494	 *   pq('div.myClass', $pq)
4495	 *
4496	 * @param string|DOMNode|DOMNodeList|array	$arg1	HTML markup, CSS Selector, DOMNode or array of DOMNodes
4497	 * @param string|phpQueryObject|DOMNode	$context	DOM ID from $pq->getDocumentID(), phpQuery object (determines also query root) or DOMNode (determines also query root)
4498	 *
4499	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery|QueryTemplatesPhpQuery|false
4500   * phpQuery object or false in case of error.
4501	 */
4502	public static function pq($arg1, $context = null) {
4503		if ($arg1 instanceof DOMNODE && ! isset($context)) {
4504			foreach(phpQuery::$documents as $documentWrapper) {
4505				$compare = $arg1 instanceof DOMDocument
4506					? $arg1 : $arg1->ownerDocument;
4507				if ($documentWrapper->document->isSameNode($compare))
4508					$context = $documentWrapper->id;
4509			}
4510		}
4511		if (! $context) {
4512			$domId = self::$defaultDocumentID;
4513			if (! $domId)
4514				throw new Exception("Can't use last created DOM, because there isn't any. Use phpQuery::newDocument() first.");
4515//		} else if (is_object($context) && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
4516		} else if (is_object($context) && $context instanceof phpQueryObject)
4517			$domId = $context->getDocumentID();
4518		else if ($context instanceof DOMDOCUMENT) {
4519			$domId = self::getDocumentID($context);
4520			if (! $domId) {
4521				//throw new Exception('Orphaned DOMDocument');
4522				$domId = self::newDocument($context)->getDocumentID();
4523			}
4524		} else if ($context instanceof DOMNODE) {
4525			$domId = self::getDocumentID($context);
4526			if (! $domId) {
4527				throw new Exception('Orphaned DOMNode');
4528//				$domId = self::newDocument($context->ownerDocument);
4529			}
4530		} else
4531			$domId = $context;
4532		if ($arg1 instanceof phpQueryObject) {
4533//		if (is_object($arg1) && (get_class($arg1) == 'phpQueryObject' || $arg1 instanceof PHPQUERY || is_subclass_of($arg1, 'phpQueryObject'))) {
4534			/**
4535			 * Return $arg1 or import $arg1 stack if document differs:
4536			 * pq(pq('<div/>'))
4537			 */
4538			if ($arg1->getDocumentID() == $domId)
4539				return $arg1;
4540			$class = get_class($arg1);
4541			// support inheritance by passing old object to overloaded constructor
4542			$phpQuery = $class != 'phpQuery'
4543				? new $class($arg1, $domId)
4544				: new phpQueryObject($domId);
4545			$phpQuery->elements = array();
4546			foreach($arg1->elements as $node)
4547				$phpQuery->elements[] = $phpQuery->document->importNode($node, true);
4548			return $phpQuery;
4549		} else if ($arg1 instanceof DOMNODE || (is_array($arg1) && isset($arg1[0]) && $arg1[0] instanceof DOMNODE)) {
4550			/*
4551			 * Wrap DOM nodes with phpQuery object, import into document when needed:
4552			 * pq(array($domNode1, $domNode2))
4553			 */
4554			$phpQuery = new phpQueryObject($domId);
4555			if (!($arg1 instanceof DOMNODELIST) && ! is_array($arg1))
4556				$arg1 = array($arg1);
4557			$phpQuery->elements = array();
4558			foreach($arg1 as $node) {
4559				$sameDocument = $node->ownerDocument instanceof DOMDOCUMENT
4560					&& ! $node->ownerDocument->isSameNode($phpQuery->document);
4561				$phpQuery->elements[] = $sameDocument
4562					? $phpQuery->document->importNode($node, true)
4563					: $node;
4564			}
4565			return $phpQuery;
4566		} else if (self::isMarkup($arg1)) {
4567			/**
4568			 * Import HTML:
4569			 * pq('<div/>')
4570			 */
4571			$phpQuery = new phpQueryObject($domId);
4572			return $phpQuery->newInstance(
4573				$phpQuery->documentWrapper->import($arg1)
4574			);
4575		} else {
4576			/**
4577			 * Run CSS query:
4578			 * pq('div.myClass')
4579			 */
4580			$phpQuery = new phpQueryObject($domId);
4581//			if ($context && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
4582			if ($context && $context instanceof phpQueryObject)
4583				$phpQuery->elements = $context->elements;
4584			else if ($context && $context instanceof DOMNODELIST) {
4585				$phpQuery->elements = array();
4586				foreach($context as $node)
4587					$phpQuery->elements[] = $node;
4588			} else if ($context && $context instanceof DOMNODE)
4589				$phpQuery->elements = array($context);
4590			return $phpQuery->find($arg1);
4591		}
4592	}
4593	/**
4594	 * Sets default document to $id. Document has to be loaded prior
4595	 * to using this method.
4596	 * $id can be retrived via getDocumentID() or getDocumentIDRef().
4597	 *
4598	 * @param unknown_type $id
4599	 */
4600	public static function selectDocument($id) {
4601		$id = self::getDocumentID($id);
4602		self::debug("Selecting document '$id' as default one");
4603		self::$defaultDocumentID = self::getDocumentID($id);
4604	}
4605	/**
4606	 * Returns document with id $id or last used as phpQueryObject.
4607	 * $id can be retrived via getDocumentID() or getDocumentIDRef().
4608	 * Chainable.
4609	 *
4610	 * @see phpQuery::selectDocument()
4611	 * @param unknown_type $id
4612	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4613	 */
4614	public static function getDocument($id = null) {
4615		if ($id)
4616			phpQuery::selectDocument($id);
4617		else
4618			$id = phpQuery::$defaultDocumentID;
4619		return new phpQueryObject($id);
4620	}
4621	/**
4622	 * Creates new document from markup.
4623	 * Chainable.
4624	 *
4625	 * @param unknown_type $markup
4626	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4627	 */
4628	public static function newDocument($markup = null, $contentType = null) {
4629		if (! $markup)
4630			$markup = '';
4631		$documentID = phpQuery::createDocumentWrapper($markup, $contentType);
4632		return new phpQueryObject($documentID);
4633	}
4634	/**
4635	 * Creates new document from markup.
4636	 * Chainable.
4637	 *
4638	 * @param unknown_type $markup
4639	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4640	 */
4641	public static function newDocumentHTML($markup = null, $charset = null) {
4642		$contentType = $charset
4643			? ";charset=$charset"
4644			: '';
4645		return self::newDocument($markup, "text/html{$contentType}");
4646	}
4647	/**
4648	 * Creates new document from markup.
4649	 * Chainable.
4650	 *
4651	 * @param unknown_type $markup
4652	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4653	 */
4654	public static function newDocumentXML($markup = null, $charset = null) {
4655		$contentType = $charset
4656			? ";charset=$charset"
4657			: '';
4658		return self::newDocument($markup, "text/xml{$contentType}");
4659	}
4660	/**
4661	 * Creates new document from markup.
4662	 * Chainable.
4663	 *
4664	 * @param unknown_type $markup
4665	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4666	 */
4667	public static function newDocumentXHTML($markup = null, $charset = null) {
4668		$contentType = $charset
4669			? ";charset=$charset"
4670			: '';
4671		return self::newDocument($markup, "application/xhtml+xml{$contentType}");
4672	}
4673	/**
4674	 * Creates new document from markup.
4675	 * Chainable.
4676	 *
4677	 * @param unknown_type $markup
4678	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4679	 */
4680	public static function newDocumentPHP($markup = null, $contentType = "text/html") {
4681		// TODO pass charset to phpToMarkup if possible (use DOMDocumentWrapper function)
4682		$markup = phpQuery::phpToMarkup($markup, self::$defaultCharset);
4683		return self::newDocument($markup, $contentType);
4684	}
4685	public static function phpToMarkup($php, $charset = 'utf-8') {
4686		$regexes = array(
4687			'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)<'.'?php?(.*?)(?:\\?>)([^\']*)\'@s',
4688			'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)<'.'?php?(.*?)(?:\\?>)([^"]*)"@s',
4689		);
4690		foreach($regexes as $regex)
4691			while (preg_match($regex, $php, $matches)) {
4692				$php = preg_replace_callback(
4693					$regex,
4694//					create_function('$m, $charset = "'.$charset.'"',
4695//						'return $m[1].$m[2]
4696//							.htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
4697//							.$m[5].$m[2];'
4698//					),
4699					array('phpQuery', '_phpToMarkupCallback'),
4700					$php
4701				);
4702			}
4703		$regex = '@(^|>[^<]*)+?(<\?php(.*?)(\?>))@s';
4704//preg_match_all($regex, $php, $matches);
4705//var_dump($matches);
4706		$php = preg_replace($regex, '\\1<php><!-- \\3 --></php>', $php);
4707		return $php;
4708	}
4709	public static function _phpToMarkupCallback($php, $charset = 'utf-8') {
4710		return $m[1].$m[2]
4711			.htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
4712			.$m[5].$m[2];
4713	}
4714	public static function _markupToPHPCallback($m) {
4715		return "<"."?php ".htmlspecialchars_decode($m[1])." ?".">";
4716	}
4717	/**
4718	 * Converts document markup containing PHP code generated by phpQuery::php()
4719	 * into valid (executable) PHP code syntax.
4720	 *
4721	 * @param string|phpQueryObject $content
4722	 * @return string PHP code.
4723	 */
4724	public static function markupToPHP($content) {
4725		if ($content instanceof phpQueryObject)
4726			$content = $content->markupOuter();
4727		/* <php>...</php> to <?php...? > */
4728		$content = preg_replace_callback(
4729			'@<php>\s*<!--(.*?)-->\s*</php>@s',
4730//			create_function('$m',
4731//				'return "<'.'?php ".htmlspecialchars_decode($m[1])." ?'.'>";'
4732//			),
4733			array('phpQuery', '_markupToPHPCallback'),
4734			$content
4735		);
4736		/* <node attr='< ?php ? >'> extra space added to save highlighters */
4737		$regexes = array(
4738			'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)(?:&lt;|%3C)\\?(?:php)?(.*?)(?:\\?(?:&gt;|%3E))([^\']*)\'@s',
4739			'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)(?:&lt;|%3C)\\?(?:php)?(.*?)(?:\\?(?:&gt;|%3E))([^"]*)"@s',
4740		);
4741		foreach($regexes as $regex)
4742			while (preg_match($regex, $content))
4743				$content = preg_replace_callback(
4744					$regex,
4745					create_function('$m',
4746						'return $m[1].$m[2].$m[3]."<?php "
4747							.str_replace(
4748								array("%20", "%3E", "%09", "&#10;", "&#9;", "%7B", "%24", "%7D", "%22", "%5B", "%5D"),
4749								array(" ", ">", "	", "\n", "	", "{", "$", "}", \'"\', "[", "]"),
4750								htmlspecialchars_decode($m[4])
4751							)
4752							." ?>".$m[5].$m[2];'
4753					),
4754					$content
4755				);
4756		return $content;
4757	}
4758	/**
4759	 * Creates new document from file $file.
4760	 * Chainable.
4761	 *
4762	 * @param string $file URLs allowed. See File wrapper page at php.net for more supported sources.
4763	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4764	 */
4765	public static function newDocumentFile($file, $contentType = null) {
4766		$documentID = self::createDocumentWrapper(
4767			file_get_contents($file), $contentType
4768		);
4769		return new phpQueryObject($documentID);
4770	}
4771	/**
4772	 * Creates new document from markup.
4773	 * Chainable.
4774	 *
4775	 * @param unknown_type $markup
4776	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4777	 */
4778	public static function newDocumentFileHTML($file, $charset = null) {
4779		$contentType = $charset
4780			? ";charset=$charset"
4781			: '';
4782		return self::newDocumentFile($file, "text/html{$contentType}");
4783	}
4784	/**
4785	 * Creates new document from markup.
4786	 * Chainable.
4787	 *
4788	 * @param unknown_type $markup
4789	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4790	 */
4791	public static function newDocumentFileXML($file, $charset = null) {
4792		$contentType = $charset
4793			? ";charset=$charset"
4794			: '';
4795		return self::newDocumentFile($file, "text/xml{$contentType}");
4796	}
4797	/**
4798	 * Creates new document from markup.
4799	 * Chainable.
4800	 *
4801	 * @param unknown_type $markup
4802	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4803	 */
4804	public static function newDocumentFileXHTML($file, $charset = null) {
4805		$contentType = $charset
4806			? ";charset=$charset"
4807			: '';
4808		return self::newDocumentFile($file, "application/xhtml+xml{$contentType}");
4809	}
4810	/**
4811	 * Creates new document from markup.
4812	 * Chainable.
4813	 *
4814	 * @param unknown_type $markup
4815	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4816	 */
4817	public static function newDocumentFilePHP($file, $contentType = null) {
4818		return self::newDocumentPHP(file_get_contents($file), $contentType);
4819	}
4820	/**
4821	 * Reuses existing DOMDocument object.
4822	 * Chainable.
4823	 *
4824	 * @param $document DOMDocument
4825	 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
4826	 * @TODO support DOMDocument
4827	 */
4828	public static function loadDocument($document) {
4829		// TODO
4830		die('TODO loadDocument');
4831	}
4832	/**
4833	 * Enter description here...
4834	 *
4835	 * @param unknown_type $html
4836	 * @param unknown_type $domId
4837	 * @return unknown New DOM ID
4838	 * @todo support PHP tags in input
4839	 * @todo support passing DOMDocument object from self::loadDocument
4840	 */
4841	protected static function createDocumentWrapper($html, $contentType = null, $documentID = null) {
4842		if (function_exists('domxml_open_mem'))
4843			throw new Exception("Old PHP4 DOM XML extension detected. phpQuery won't work until this extension is enabled.");
4844//		$id = $documentID
4845//			? $documentID
4846//			: md5(microtime());
4847		$document = null;
4848		if ($html instanceof DOMDOCUMENT) {
4849			if (self::getDocumentID($html)) {
4850				// document already exists in phpQuery::$documents, make a copy
4851				$document = clone $html;
4852			} else {
4853				// new document, add it to phpQuery::$documents
4854				$wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
4855			}
4856		} else {
4857			$wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
4858		}
4859//		$wrapper->id = $id;
4860		// bind document
4861		phpQuery::$documents[$wrapper->id] = $wrapper;
4862		// remember last loaded document
4863		phpQuery::selectDocument($wrapper->id);
4864		return $wrapper->id;
4865	}
4866	/**
4867	 * Extend class namespace.
4868	 *
4869	 * @param string|array $target
4870	 * @param array $source
4871	 * @TODO support string $source
4872	 * @return unknown_type
4873	 */
4874	public static function extend($target, $source) {
4875		switch($target) {
4876			case 'phpQueryObject':
4877				$targetRef = &self::$extendMethods;
4878				$targetRef2 = &self::$pluginsMethods;
4879				break;
4880			case 'phpQuery':
4881				$targetRef = &self::$extendStaticMethods;
4882				$targetRef2 = &self::$pluginsStaticMethods;
4883				break;
4884			default:
4885				throw new Exception("Unsupported \$target type");
4886		}
4887		if (is_string($source))
4888			$source = array($source => $source);
4889		foreach($source as $method => $callback) {
4890			if (isset($targetRef[$method])) {
4891//				throw new Exception
4892				self::debug("Duplicate method '{$method}', can\'t extend '{$target}'");
4893				continue;
4894			}
4895			if (isset($targetRef2[$method])) {
4896//				throw new Exception
4897				self::debug("Duplicate method '{$method}' from plugin '{$targetRef2[$method]}',"
4898					." can\'t extend '{$target}'");
4899				continue;
4900			}
4901			$targetRef[$method] = $callback;
4902		}
4903		return true;
4904	}
4905	/**
4906	 * Extend phpQuery with $class from $file.
4907	 *
4908	 * @param string $class Extending class name. Real class name can be prepended phpQuery_.
4909	 * @param string $file Filename to include. Defaults to "{$class}.php".
4910	 */
4911	public static function plugin($class, $file = null) {
4912		// TODO $class checked agains phpQuery_$class
4913//		if (strpos($class, 'phpQuery') === 0)
4914//			$class = substr($class, 8);
4915		if (in_array($class, self::$pluginsLoaded))
4916			return true;
4917		if (! $file)
4918			$file = $class.'.php';
4919		$objectClassExists = class_exists('phpQueryObjectPlugin_'.$class);
4920		$staticClassExists = class_exists('phpQueryPlugin_'.$class);
4921		if (! $objectClassExists && ! $staticClassExists)
4922			require_once($file);
4923		self::$pluginsLoaded[] = $class;
4924		// static methods
4925		if (class_exists('phpQueryPlugin_'.$class)) {
4926			$realClass = 'phpQueryPlugin_'.$class;
4927			$vars = get_class_vars($realClass);
4928			$loop = isset($vars['phpQueryMethods'])
4929				&& ! is_null($vars['phpQueryMethods'])
4930				? $vars['phpQueryMethods']
4931				: get_class_methods($realClass);
4932			foreach($loop as $method) {
4933				if ($method == '__initialize')
4934					continue;
4935				if (! is_callable(array($realClass, $method)))
4936					continue;
4937				if (isset(self::$pluginsStaticMethods[$method])) {
4938					throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsStaticMethods[$method]."'");
4939					return;
4940				}
4941				self::$pluginsStaticMethods[$method] = $class;
4942			}
4943			if (method_exists($realClass, '__initialize'))
4944				call_user_func_array(array($realClass, '__initialize'), array());
4945		}
4946		// object methods
4947		if (class_exists('phpQueryObjectPlugin_'.$class)) {
4948			$realClass = 'phpQueryObjectPlugin_'.$class;
4949			$vars = get_class_vars($realClass);
4950			$loop = isset($vars['phpQueryMethods'])
4951				&& ! is_null($vars['phpQueryMethods'])
4952				? $vars['phpQueryMethods']
4953				: get_class_methods($realClass);
4954			foreach($loop as $method) {
4955				if (! is_callable(array($realClass, $method)))
4956					continue;
4957				if (isset(self::$pluginsMethods[$method])) {
4958					throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsMethods[$method]."'");
4959					continue;
4960				}
4961				self::$pluginsMethods[$method] = $class;
4962			}
4963		}
4964		return true;
4965	}
4966	/**
4967	 * Unloades all or specified document from memory.
4968	 *
4969	 * @param mixed $documentID @see phpQuery::getDocumentID() for supported types.
4970	 */
4971	public static function unloadDocuments($id = null) {
4972		if (isset($id)) {
4973			if ($id = self::getDocumentID($id))
4974				unset(phpQuery::$documents[$id]);
4975		} else {
4976			foreach(phpQuery::$documents as $k => $v) {
4977				unset(phpQuery::$documents[$k]);
4978			}
4979		}
4980	}
4981	/**
4982	 * Parses phpQuery object or HTML result against PHP tags and makes them active.
4983	 *
4984	 * @param phpQuery|string $content
4985	 * @deprecated
4986	 * @return string
4987	 */
4988	public static function unsafePHPTags($content) {
4989		return self::markupToPHP($content);
4990	}
4991	public static function DOMNodeListToArray($DOMNodeList) {
4992		$array = array();
4993		if (! $DOMNodeList)
4994			return $array;
4995		foreach($DOMNodeList as $node)
4996			$array[] = $node;
4997		return $array;
4998	}
4999	/**
5000	 * Checks if $input is HTML string, which has to start with '<'.
5001	 *
5002	 * @deprecated
5003	 * @param String $input
5004	 * @return Bool
5005	 * @todo still used ?
5006	 */
5007	public static function isMarkup($input) {
5008		return ! is_array($input) && substr(trim($input), 0, 1) == '<';
5009	}
5010	public static function debug($text) {
5011		if (self::$debug)
5012			print var_dump($text);
5013	}
5014	/**
5015	 * Make an AJAX request.
5016	 *
5017	 * @param array See $options http://docs.jquery.com/Ajax/jQuery.ajax#toptions
5018	 * Additional options are:
5019	 * 'document' - document for global events, @see phpQuery::getDocumentID()
5020	 * 'referer' - implemented
5021	 * 'requested_with' - TODO; not implemented (X-Requested-With)
5022	 * @return Zend_Http_Client
5023	 * @link http://docs.jquery.com/Ajax/jQuery.ajax
5024	 *
5025	 * @TODO $options['cache']
5026	 * @TODO $options['processData']
5027	 * @TODO $options['xhr']
5028	 * @TODO $options['data'] as string
5029	 * @TODO XHR interface
5030	 */
5031	public static function ajax($options = array(), $xhr = null) {
5032		$options = array_merge(
5033			self::$ajaxSettings, $options
5034		);
5035		$documentID = isset($options['document'])
5036			? self::getDocumentID($options['document'])
5037			: null;
5038		if ($xhr) {
5039			// reuse existing XHR object, but clean it up
5040			$client = $xhr;
5041//			$client->setParameterPost(null);
5042//			$client->setParameterGet(null);
5043			$client->setAuth(false);
5044			$client->setHeaders("If-Modified-Since", null);
5045			$client->setHeaders("Referer", null);
5046			$client->resetParameters();
5047		} else {
5048			// create new XHR object
5049			require_once('Zend/Http/Client.php');
5050			$client = new Zend_Http_Client();
5051			$client->setCookieJar();
5052		}
5053		if (isset($options['timeout']))
5054			$client->setConfig(array(
5055				'timeout'      => $options['timeout'],
5056			));
5057//			'maxredirects' => 0,
5058		foreach(self::$ajaxAllowedHosts as $k => $host)
5059			if ($host == '.' && isset($_SERVER['HTTP_HOST']))
5060				self::$ajaxAllowedHosts[$k] = $_SERVER['HTTP_HOST'];
5061		$host = parse_url($options['url'], PHP_URL_HOST);
5062		if (! in_array($host, self::$ajaxAllowedHosts)) {
5063			throw new Exception("Request not permitted, host '$host' not present in "
5064				."phpQuery::\$ajaxAllowedHosts");
5065		}
5066		// JSONP
5067		$jsre = "/=\\?(&|$)/";
5068		if (isset($options['dataType']) && $options['dataType'] == 'jsonp') {
5069			$jsonpCallbackParam = $options['jsonp']
5070				? $options['jsonp'] : 'callback';
5071			if (strtolower($options['type']) == 'get') {
5072				if (! preg_match($jsre, $options['url'])) {
5073					$sep = strpos($options['url'], '?')
5074						? '&' : '?';
5075					$options['url'] .= "$sep$jsonpCallbackParam=?";
5076				}
5077			} else if ($options['data']) {
5078				$jsonp = false;
5079				foreach($options['data'] as $n => $v) {
5080					if ($v == '?')
5081						$jsonp = true;
5082				}
5083				if (! $jsonp) {
5084					$options['data'][$jsonpCallbackParam] = '?';
5085				}
5086			}
5087			$options['dataType'] = 'json';
5088		}
5089		if (isset($options['dataType']) && $options['dataType'] == 'json') {
5090			$jsonpCallback = 'json_'.md5(microtime());
5091			$jsonpData = $jsonpUrl = false;
5092			if ($options['data']) {
5093				foreach($options['data'] as $n => $v) {
5094					if ($v == '?')
5095						$jsonpData = $n;
5096				}
5097			}
5098			if (preg_match($jsre, $options['url']))
5099				$jsonpUrl = true;
5100			if ($jsonpData !== false || $jsonpUrl) {
5101				// remember callback name for httpData()
5102				$options['_jsonp'] = $jsonpCallback;
5103				if ($jsonpData !== false)
5104					$options['data'][$jsonpData] = $jsonpCallback;
5105				if ($jsonpUrl)
5106					$options['url'] = preg_replace($jsre, "=$jsonpCallback\\1", $options['url']);
5107			}
5108		}
5109		$client->setUri($options['url']);
5110		$client->setMethod(strtoupper($options['type']));
5111		if (isset($options['referer']) && $options['referer'])
5112			$client->setHeaders('Referer', $options['referer']);
5113		$client->setHeaders(array(
5114//			'content-type' => $options['contentType'],
5115			'User-Agent' => 'Mozilla/5.0 (X11; U; Linux x86; en-US; rv:1.9.0.5) Gecko'
5116				 .'/2008122010 Firefox/3.0.5',
5117	 		// TODO custom charset
5118			'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
5119// 	 		'Connection' => 'keep-alive',
5120// 			'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
5121	 		'Accept-Language' => 'en-us,en;q=0.5',
5122		));
5123		if ($options['username'])
5124			$client->setAuth($options['username'], $options['password']);
5125		if (isset($options['ifModified']) && $options['ifModified'])
5126			$client->setHeaders("If-Modified-Since",
5127				self::$lastModified
5128					? self::$lastModified
5129					: "Thu, 01 Jan 1970 00:00:00 GMT"
5130			);
5131		$client->setHeaders("Accept",
5132			isset($options['dataType'])
5133			&& isset(self::$ajaxSettings['accepts'][ $options['dataType'] ])
5134				? self::$ajaxSettings['accepts'][ $options['dataType'] ].", */*"
5135				: self::$ajaxSettings['accepts']['_default']
5136		);
5137		// TODO $options['processData']
5138		if ($options['data'] instanceof phpQueryObject) {
5139			$serialized = $options['data']->serializeArray($options['data']);
5140			$options['data'] = array();
5141			foreach($serialized as $r)
5142				$options['data'][ $r['name'] ] = $r['value'];
5143		}
5144		if (strtolower($options['type']) == 'get') {
5145			$client->setParameterGet($options['data']);
5146		} else if (strtolower($options['type']) == 'post') {
5147			$client->setEncType($options['contentType']);
5148			$client->setParameterPost($options['data']);
5149		}
5150		if (self::$active == 0 && $options['global'])
5151			phpQueryEvents::trigger($documentID, 'ajaxStart');
5152		self::$active++;
5153		// beforeSend callback
5154		if (isset($options['beforeSend']) && $options['beforeSend'])
5155			phpQuery::callbackRun($options['beforeSend'], array($client));
5156		// ajaxSend event
5157		if ($options['global'])
5158			phpQueryEvents::trigger($documentID, 'ajaxSend', array($client, $options));
5159		if (phpQuery::$debug) {
5160			self::debug("{$options['type']}: {$options['url']}\n");
5161			self::debug("Options: <pre>".var_export($options, true)."</pre>\n");
5162//			if ($client->getCookieJar())
5163//				self::debug("Cookies: <pre>".var_export($client->getCookieJar()->getMatchingCookies($options['url']), true)."</pre>\n");
5164		}
5165		// request
5166		$response = $client->request();
5167		if (phpQuery::$debug) {
5168			self::debug('Status: '.$response->getStatus().' / '.$response->getMessage());
5169			self::debug($client->getLastRequest());
5170			self::debug($response->getHeaders());
5171		}
5172		if ($response->isSuccessful()) {
5173			// XXX tempolary
5174			self::$lastModified = $response->getHeader('Last-Modified');
5175			$data = self::httpData($response->getBody(), $options['dataType'], $options);
5176			if (isset($options['success']) && $options['success'])
5177				phpQuery::callbackRun($options['success'], array($data, $response->getStatus(), $options));
5178			if ($options['global'])
5179				phpQueryEvents::trigger($documentID, 'ajaxSuccess', array($client, $options));
5180		} else {
5181			if (isset($options['error']) && $options['error'])
5182				phpQuery::callbackRun($options['error'], array($client, $response->getStatus(), $response->getMessage()));
5183			if ($options['global'])
5184				phpQueryEvents::trigger($documentID, 'ajaxError', array($client, /*$response->getStatus(),*/$response->getMessage(), $options));
5185		}
5186		if (isset($options['complete']) && $options['complete'])
5187			phpQuery::callbackRun($options['complete'], array($client, $response->getStatus()));
5188		if ($options['global'])
5189			phpQueryEvents::trigger($documentID, 'ajaxComplete', array($client, $options));
5190		if ($options['global'] && ! --self::$active)
5191			phpQueryEvents::trigger($documentID, 'ajaxStop');
5192		return $client;
5193//		if (is_null($domId))
5194//			$domId = self::$defaultDocumentID ? self::$defaultDocumentID : false;
5195//		return new phpQueryAjaxResponse($response, $domId);
5196	}
5197	protected static function httpData($data, $type, $options) {
5198		if (isset($options['dataFilter']) && $options['dataFilter'])
5199			$data = self::callbackRun($options['dataFilter'], array($data, $type));
5200		if (is_string($data)) {
5201			if ($type == "json") {
5202				if (isset($options['_jsonp']) && $options['_jsonp']) {
5203					$data = preg_replace('/^\s*\w+\((.*)\)\s*$/s', '$1', $data);
5204				}
5205				$data = self::parseJSON($data);
5206			}
5207		}
5208		return $data;
5209	}
5210	/**
5211	 * Enter description here...
5212	 *
5213	 * @param array|phpQuery $data
5214	 *
5215	 */
5216	public static function param($data) {
5217		return http_build_query($data, null, '&');
5218	}
5219	public static function get($url, $data = null, $callback = null, $type = null) {
5220		if (!is_array($data)) {
5221			$callback = $data;
5222			$data = null;
5223		}
5224		// TODO some array_values on this shit
5225		return phpQuery::ajax(array(
5226			'type' => 'GET',
5227			'url' => $url,
5228			'data' => $data,
5229			'success' => $callback,
5230			'dataType' => $type,
5231		));
5232	}
5233	public static function post($url, $data = null, $callback = null, $type = null) {
5234		if (!is_array($data)) {
5235			$callback = $data;
5236			$data = null;
5237		}
5238		return phpQuery::ajax(array(
5239			'type' => 'POST',
5240			'url' => $url,
5241			'data' => $data,
5242			'success' => $callback,
5243			'dataType' => $type,
5244		));
5245	}
5246	public static function getJSON($url, $data = null, $callback = null) {
5247		if (!is_array($data)) {
5248			$callback = $data;
5249			$data = null;
5250		}
5251		// TODO some array_values on this shit
5252		return phpQuery::ajax(array(
5253			'type' => 'GET',
5254			'url' => $url,
5255			'data' => $data,
5256			'success' => $callback,
5257			'dataType' => 'json',
5258		));
5259	}
5260	public static function ajaxSetup($options) {
5261		self::$ajaxSettings = array_merge(
5262			self::$ajaxSettings,
5263			$options
5264		);
5265	}
5266	public static function ajaxAllowHost($host1, $host2 = null, $host3 = null) {
5267		$loop = is_array($host1)
5268			? $host1
5269			: func_get_args();
5270		foreach($loop as $host) {
5271			if ($host && ! in_array($host, phpQuery::$ajaxAllowedHosts)) {
5272				phpQuery::$ajaxAllowedHosts[] = $host;
5273			}
5274		}
5275	}
5276	public static function ajaxAllowURL($url1, $url2 = null, $url3 = null) {
5277		$loop = is_array($url1)
5278			? $url1
5279			: func_get_args();
5280		foreach($loop as $url)
5281			phpQuery::ajaxAllowHost(parse_url($url, PHP_URL_HOST));
5282	}
5283	/**
5284	 * Returns JSON representation of $data.
5285	 *
5286	 * @static
5287	 * @param mixed $data
5288	 * @return string
5289	 */
5290	public static function toJSON($data) {
5291		if (function_exists('json_encode'))
5292			return json_encode($data);
5293		require_once('Zend/Json/Encoder.php');
5294		return Zend_Json_Encoder::encode($data);
5295	}
5296	/**
5297	 * Parses JSON into proper PHP type.
5298	 *
5299	 * @static
5300	 * @param string $json
5301	 * @return mixed
5302	 */
5303	public static function parseJSON($json) {
5304		if (function_exists('json_decode')) {
5305			$return = json_decode(trim($json), true);
5306			// json_decode and UTF8 issues
5307			if (isset($return))
5308				return $return;
5309		}
5310		require_once('Zend/Json/Decoder.php');
5311		return Zend_Json_Decoder::decode($json);
5312	}
5313	/**
5314	 * Returns source's document ID.
5315	 *
5316	 * @param $source DOMNode|phpQueryObject
5317	 * @return string
5318	 */
5319	public static function getDocumentID($source) {
5320		if ($source instanceof DOMDOCUMENT) {
5321			foreach(phpQuery::$documents as $id => $document) {
5322				if ($source->isSameNode($document->document))
5323					return $id;
5324			}
5325		} else if ($source instanceof DOMNODE) {
5326			foreach(phpQuery::$documents as $id => $document) {
5327				if ($source->ownerDocument->isSameNode($document->document))
5328					return $id;
5329			}
5330		} else if ($source instanceof phpQueryObject)
5331			return $source->getDocumentID();
5332		else if (is_string($source) && isset(phpQuery::$documents[$source]))
5333			return $source;
5334	}
5335	/**
5336	 * Get DOMDocument object related to $source.
5337	 * Returns null if such document doesn't exist.
5338	 *
5339	 * @param $source DOMNode|phpQueryObject|string
5340	 * @return string
5341	 */
5342	public static function getDOMDocument($source) {
5343		if ($source instanceof DOMDOCUMENT)
5344			return $source;
5345		$source = self::getDocumentID($source);
5346		return $source
5347			? self::$documents[$id]['document']
5348			: null;
5349	}
5350
5351	// UTILITIES
5352	// http://docs.jquery.com/Utilities
5353
5354	/**
5355	 *
5356	 * @return unknown_type
5357	 * @link http://docs.jquery.com/Utilities/jQuery.makeArray
5358	 */
5359	public static function makeArray($obj) {
5360		$array = array();
5361		if (is_object($object) && $object instanceof DOMNODELIST) {
5362			foreach($object as $value)
5363				$array[] = $value;
5364		} else if (is_object($object) && ! ($object instanceof Iterator)) {
5365			foreach(get_object_vars($object) as $name => $value)
5366				$array[0][$name] = $value;
5367		} else {
5368			foreach($object as $name => $value)
5369				$array[0][$name] = $value;
5370		}
5371		return $array;
5372	}
5373	public static function inArray($value, $array) {
5374		return in_array($value, $array);
5375	}
5376	/**
5377	 *
5378	 * @param $object
5379	 * @param $callback
5380	 * @return unknown_type
5381	 * @link http://docs.jquery.com/Utilities/jQuery.each
5382	 */
5383	public static function each($object, $callback, $param1 = null, $param2 = null, $param3 = null) {
5384		$paramStructure = null;
5385		if (func_num_args() > 2) {
5386			$paramStructure = func_get_args();
5387			$paramStructure = array_slice($paramStructure, 2);
5388		}
5389		if (is_object($object) && ! ($object instanceof Iterator)) {
5390			foreach(get_object_vars($object) as $name => $value)
5391				phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
5392		} else {
5393			foreach($object as $name => $value)
5394				phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
5395		}
5396	}
5397	/**
5398	 *
5399	 * @link http://docs.jquery.com/Utilities/jQuery.map
5400	 */
5401	public static function map($array, $callback, $param1 = null, $param2 = null, $param3 = null) {
5402		$result = array();
5403		$paramStructure = null;
5404		if (func_num_args() > 2) {
5405			$paramStructure = func_get_args();
5406			$paramStructure = array_slice($paramStructure, 2);
5407		}
5408		foreach($array as $v) {
5409			$vv = phpQuery::callbackRun($callback, array($v), $paramStructure);
5410//			$callbackArgs = $args;
5411//			foreach($args as $i => $arg) {
5412//				$callbackArgs[$i] = $arg instanceof CallbackParam
5413//					? $v
5414//					: $arg;
5415//			}
5416//			$vv = call_user_func_array($callback, $callbackArgs);
5417			if (is_array($vv))  {
5418				foreach($vv as $vvv)
5419					$result[] = $vvv;
5420			} else if ($vv !== null) {
5421				$result[] = $vv;
5422			}
5423		}
5424		return $result;
5425	}
5426	/**
5427	 *
5428	 * @param $callback Callback
5429	 * @param $params
5430	 * @param $paramStructure
5431	 * @return unknown_type
5432	 */
5433	public static function callbackRun($callback, $params = array(), $paramStructure = null) {
5434		if (! $callback)
5435			return;
5436		if ($callback instanceof CallbackParameterToReference) {
5437			// TODO support ParamStructure to select which $param push to reference
5438			if (isset($params[0]))
5439				$callback->callback = $params[0];
5440			return true;
5441		}
5442		if ($callback instanceof Callback) {
5443			$paramStructure = $callback->params;
5444			$callback = $callback->callback;
5445		}
5446		if (! $paramStructure)
5447			return call_user_func_array($callback, $params);
5448		$p = 0;
5449		foreach($paramStructure as $i => $v) {
5450			$paramStructure[$i] = $v instanceof CallbackParam
5451				? $params[$p++]
5452				: $v;
5453		}
5454		return call_user_func_array($callback, $paramStructure);
5455	}
5456	/**
5457	 * Merge 2 phpQuery objects.
5458	 * @param array $one
5459	 * @param array $two
5460	 * @protected
5461	 * @todo node lists, phpQueryObject
5462	 */
5463	public static function merge($one, $two) {
5464		$elements = $one->elements;
5465		foreach($two->elements as $node) {
5466			$exists = false;
5467			foreach($elements as $node2) {
5468				if ($node2->isSameNode($node))
5469					$exists = true;
5470			}
5471			if (! $exists)
5472				$elements[] = $node;
5473		}
5474		return $elements;
5475//		$one = $one->newInstance();
5476//		$one->elements = $elements;
5477//		return $one;
5478	}
5479	/**
5480	 *
5481	 * @param $array
5482	 * @param $callback
5483	 * @param $invert
5484	 * @return unknown_type
5485	 * @link http://docs.jquery.com/Utilities/jQuery.grep
5486	 */
5487	public static function grep($array, $callback, $invert = false) {
5488		$result = array();
5489		foreach($array as $k => $v) {
5490			$r = call_user_func_array($callback, array($v, $k));
5491			if ($r === !(bool)$invert)
5492				$result[] = $v;
5493		}
5494		return $result;
5495	}
5496	public static function unique($array) {
5497		return array_unique($array);
5498	}
5499	/**
5500	 *
5501	 * @param $function
5502	 * @return unknown_type
5503	 * @TODO there are problems with non-static methods, second parameter pass it
5504	 * 	but doesnt verify is method is really callable
5505	 */
5506	public static function isFunction($function) {
5507		return is_callable($function);
5508	}
5509	public static function trim($str) {
5510		return trim($str);
5511	}
5512	/* PLUGINS NAMESPACE */
5513	/**
5514	 *
5515	 * @param $url
5516	 * @param $callback
5517	 * @param $param1
5518	 * @param $param2
5519	 * @param $param3
5520	 * @return phpQueryObject
5521	 */
5522	public static function browserGet($url, $callback, $param1 = null, $param2 = null, $param3 = null) {
5523		if (self::plugin('WebBrowser')) {
5524			$params = func_get_args();
5525			return self::callbackRun(array(self::$plugins, 'browserGet'), $params);
5526		} else {
5527			self::debug('WebBrowser plugin not available...');
5528		}
5529	}
5530	/**
5531	 *
5532	 * @param $url
5533	 * @param $data
5534	 * @param $callback
5535	 * @param $param1
5536	 * @param $param2
5537	 * @param $param3
5538	 * @return phpQueryObject
5539	 */
5540	public static function browserPost($url, $data, $callback, $param1 = null, $param2 = null, $param3 = null) {
5541		if (self::plugin('WebBrowser')) {
5542			$params = func_get_args();
5543			return self::callbackRun(array(self::$plugins, 'browserPost'), $params);
5544		} else {
5545			self::debug('WebBrowser plugin not available...');
5546		}
5547	}
5548	/**
5549	 *
5550	 * @param $ajaxSettings
5551	 * @param $callback
5552	 * @param $param1
5553	 * @param $param2
5554	 * @param $param3
5555	 * @return phpQueryObject
5556	 */
5557	public static function browser($ajaxSettings, $callback, $param1 = null, $param2 = null, $param3 = null) {
5558		if (self::plugin('WebBrowser')) {
5559			$params = func_get_args();
5560			return self::callbackRun(array(self::$plugins, 'browser'), $params);
5561		} else {
5562			self::debug('WebBrowser plugin not available...');
5563		}
5564	}
5565	/**
5566	 *
5567	 * @param $code
5568	 * @return string
5569	 */
5570	public static function php($code) {
5571		return self::code('php', $code);
5572	}
5573	/**
5574	 *
5575	 * @param $type
5576	 * @param $code
5577	 * @return string
5578	 */
5579	public static function code($type, $code) {
5580		return "<$type><!-- ".trim($code)." --></$type>";
5581	}
5582
5583	public static function __callStatic($method, $params) {
5584		return call_user_func_array(
5585			array(phpQuery::$plugins, $method),
5586			$params
5587		);
5588	}
5589	protected static function dataSetupNode($node, $documentID) {
5590		// search are return if alredy exists
5591		foreach(phpQuery::$documents[$documentID]->dataNodes as $dataNode) {
5592			if ($node->isSameNode($dataNode))
5593				return $dataNode;
5594		}
5595		// if doesn't, add it
5596		phpQuery::$documents[$documentID]->dataNodes[] = $node;
5597		return $node;
5598	}
5599	protected static function dataRemoveNode($node, $documentID) {
5600		// search are return if alredy exists
5601		foreach(phpQuery::$documents[$documentID]->dataNodes as $k => $dataNode) {
5602			if ($node->isSameNode($dataNode)) {
5603				unset(self::$documents[$documentID]->dataNodes[$k]);
5604				unset(self::$documents[$documentID]->data[ $dataNode->dataID ]);
5605			}
5606		}
5607	}
5608	public static function data($node, $name, $data, $documentID = null) {
5609		if (! $documentID)
5610			// TODO check if this works
5611			$documentID = self::getDocumentID($node);
5612		$document = phpQuery::$documents[$documentID];
5613		$node = self::dataSetupNode($node, $documentID);
5614		if (! isset($node->dataID))
5615			$node->dataID = ++phpQuery::$documents[$documentID]->uuid;
5616		$id = $node->dataID;
5617		if (! isset($document->data[$id]))
5618			$document->data[$id] = array();
5619		if (! is_null($data))
5620			$document->data[$id][$name] = $data;
5621		if ($name) {
5622			if (isset($document->data[$id][$name]))
5623				return $document->data[$id][$name];
5624		} else
5625			return $id;
5626	}
5627	public static function removeData($node, $name, $documentID) {
5628		if (! $documentID)
5629			// TODO check if this works
5630			$documentID = self::getDocumentID($node);
5631		$document = phpQuery::$documents[$documentID];
5632		$node = self::dataSetupNode($node, $documentID);
5633		$id = $node->dataID;
5634		if ($name) {
5635			if (isset($document->data[$id][$name]))
5636				unset($document->data[$id][$name]);
5637			$name = null;
5638			foreach($document->data[$id] as $name)
5639				break;
5640			if (! $name)
5641				self::removeData($node, $name, $documentID);
5642		} else {
5643			self::dataRemoveNode($node, $documentID);
5644		}
5645	}
5646}
5647/**
5648 * Plugins static namespace class.
5649 *
5650 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
5651 * @package phpQuery
5652 * @todo move plugin methods here (as statics)
5653 */
5654class phpQueryPlugins {
5655	public function __call($method, $args) {
5656		if (isset(phpQuery::$extendStaticMethods[$method])) {
5657			$return = call_user_func_array(
5658				phpQuery::$extendStaticMethods[$method],
5659				$args
5660			);
5661		} else if (isset(phpQuery::$pluginsStaticMethods[$method])) {
5662			$class = phpQuery::$pluginsStaticMethods[$method];
5663			$realClass = "phpQueryPlugin_$class";
5664			$return = call_user_func_array(
5665				array($realClass, $method),
5666				$args
5667			);
5668			return isset($return)
5669				? $return
5670				: $this;
5671		} else
5672			throw new Exception("Method '{$method}' doesnt exist");
5673	}
5674}
5675/**
5676 * Shortcut to phpQuery::pq($arg1, $context)
5677 * Chainable.
5678 *
5679 * @see phpQuery::pq()
5680 * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
5681 * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
5682 * @package phpQuery
5683 */
5684function pq($arg1, $context = null) {
5685	$args = func_get_args();
5686	return call_user_func_array(
5687		array('phpQuery', 'pq'),
5688		$args
5689	);
5690}
5691// add plugins dir and Zend framework to include path
5692set_include_path(
5693	get_include_path()
5694		.PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/'
5695		.PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/plugins/'
5696);
5697// why ? no __call nor __get for statics in php...
5698// XXX __callStatic will be available in PHP 5.3
5699phpQuery::$plugins = new phpQueryPlugins();
5700// include bootstrap file (personal library config)
5701if (file_exists(dirname(__FILE__).'/phpQuery/bootstrap.php'))
5702	require_once dirname(__FILE__).'/phpQuery/bootstrap.php';