moved _testing to _test

5 files changed, 6003 insertions, 0 deletions

diff --git a/_test/core/DokuWikiTest.php b/_test/core/DokuWikiTest.php
new file mode 100644
index 000000000..e47c06329
--- /dev/null
+++ b/_test/core/DokuWikiTest.php
@@ -0,0 +1,96 @@
+<?php
+/**
+ * Helper class to provide basic functionality for tests
+ */
+abstract class DokuWikiTest extends PHPUnit_Framework_TestCase {
+
+    /**
+     * tests can override this
+     *
+     * @var array plugins to enable for test class
+     */
+    protected $pluginsEnabled = array();
+
+    /**
+     * tests can override this
+     *
+     * @var array plugins to disable for test class
+     */
+    protected $pluginsDisabled = array();
+
+    /**
+     * Reset the DokuWiki environment before each test run. Makes sure loaded config,
+     * language and plugins are correct.
+     *
+     * @throws Exception if plugin actions fail
+     * @return void
+     */
+    public function setUp() {
+        // reload config
+        global $conf, $config_cascade;
+        $conf = array();
+        foreach (array('default','local','protected') as $config_group) {
+            if (empty($config_cascade['main'][$config_group])) continue;
+            foreach ($config_cascade['main'][$config_group] as $config_file) {
+                if (@file_exists($config_file)) {
+                    include($config_file);
+                }
+            }
+        }
+
+        // reload license config
+        global $license;
+        $license = array();
+
+        // load the license file(s)
+        foreach (array('default','local') as $config_group) {
+            if (empty($config_cascade['license'][$config_group])) continue;
+            foreach ($config_cascade['license'][$config_group] as $config_file) {
+                if(@file_exists($config_file)){
+                    include($config_file);
+                }
+            }
+        }
+
+        // make real paths and check them
+        init_paths();
+        init_files();
+
+        // reset loaded plugins
+        global $plugin_controller_class, $plugin_controller;
+        $plugin_controller = new $plugin_controller_class();
+
+        // disable all non-default plugins
+        global $default_plugins;
+        foreach ($plugin_controller->getList() as $plugin) {
+            if (!in_array($plugin, $default_plugins)) {
+                if (!$plugin_controller->disable($plugin)) {
+                    throw new Exception('Could not disable plugin "'.$plugin.'"!');
+                }
+            }
+        }
+
+        // disable and enable configured plugins
+        foreach ($this->pluginsDisabled as $plugin) {
+            if (!$plugin_controller->disable($plugin)) {
+                throw new Exception('Could not disable plugin "'.$plugin.'"!');
+            }
+        }
+        foreach ($this->pluginsEnabled as $plugin) {
+            /*  enable() returns false but works...
+            if (!$plugin_controller->enable($plugin)) {
+                throw new Exception('Could not enable plugin "'.$plugin.'"!');
+            }
+            */
+            $plugin_controller->enable($plugin);
+        }
+
+        // reset event handler
+        global $EVENT_HANDLER;
+        $EVENT_HANDLER = new Doku_Event_Handler();
+
+        // reload language
+        $local = $conf['lang'];
+        trigger_event('INIT_LANG_LOAD', $local, 'init_lang', true);
+    }
+}
diff --git a/_test/core/TestRequest.php b/_test/core/TestRequest.php
new file mode 100644
index 000000000..fa3ddec90
--- /dev/null
+++ b/_test/core/TestRequest.php
@@ -0,0 +1,82 @@
+<?php
+/**
+ * Simulates a full DokuWiki HTTP Request and allows
+ * runtime inspection.
+ */
+
+// output buffering
+$output_buffer = '';
+
+function ob_start_callback($buffer) {
+    global $output_buffer;
+    $output_buffer .= $buffer;
+}
+
+
+/**
+ * Helper class to execute a fake request
+ */
+class TestRequest {
+
+    private $server = array();
+    private $session = array();
+    private $get = array();
+    private $post = array();
+
+    public function getServer($key) { return $this->server[$key]; }
+    public function getSession($key) { return $this->session[$key]; }
+    public function getGet($key) { return $this->get[$key]; }
+    public function getPost($key) { return $this->post[$key]; }
+
+    public function setServer($key, $value) { $this->server[$key] = $value; }
+    public function setSession($key, $value) { $this->session[$key] = $value; }
+    public function setGet($key, $value) { $this->get[$key] = $value; }
+    public function setPost($key, $value) { $this->post[$key] = $value; }
+
+    /**
+     * Executes the request
+     *
+     * @return TestResponse the resulting output of the request
+     */
+    public function execute() {
+        // save old environment
+        $server = $_SERVER;
+        $session = $_SESSION;
+        $get = $_GET;
+        $post = $_POST;
+        $request = $_REQUEST;
+
+        // fake environment
+        global $default_server_vars;
+        $_SERVER = array_merge($default_server_vars, $this->server);
+        $_SESSION = $this->session;
+        $_GET = $this->get;
+        $_POST = $this->post;
+        $_REQUEST = array_merge($_GET, $_POST);
+
+        // reset output buffer
+        global $output_buffer;
+        $output_buffer = '';
+
+        // now execute dokuwiki and grep the output
+        header_remove();
+        ob_start('ob_start_callback');
+        include(DOKU_INC.'doku.php');
+        ob_end_flush();
+
+        // create the response object
+        $response = new TestResponse(
+            $output_buffer,
+            headers_list()
+        );
+
+        // reset environment
+        $_SERVER = $server;
+        $_SESSION = $session;
+        $_GET = $get;
+        $_POST = $post;
+        $_REQUEST = $request;
+
+        return $response;
+    }
+}
diff --git a/_test/core/TestResponse.php b/_test/core/TestResponse.php
new file mode 100644
index 000000000..6d20afb28
--- /dev/null
+++ b/_test/core/TestResponse.php
@@ -0,0 +1,55 @@
+<?php
+/**
+ * holds a copy of all produced outputs of a TestRequest
+ */
+class TestResponse {
+    /**
+     * @var string
+     */
+    private $content;
+
+    /**
+     * @var array
+     */
+    private $headers;
+
+    /**
+     * @var phpQueryObject
+     */
+    private $pq = null;
+
+    /**
+     * @param $content string
+     * @param $headers array
+     */
+    function __construct($content, $headers) {
+        $this->content = $content;
+        $this->headers = $headers;
+    }
+
+    /**
+     * @return string
+     */
+    public function getContent() {
+        return $this->content;
+    }
+
+    /**
+     * @return array
+     */
+    public function getHeaders() {
+        return $this->headers;
+    }
+
+    /**
+     * Query the response for a JQuery compatible CSS selector
+     *
+     * @link https://code.google.com/p/phpquery/wiki/Selectors
+     * @param $selector string
+     * @return phpQueryObject
+     */
+    public function queryHTML($selector){
+        if(is_null($this->pq)) $this->pq = phpQuery::newDocument($this->content);
+        return $this->pq->find($selector);
+    }
+}
diff --git a/_test/core/TestUtils.php b/_test/core/TestUtils.php
new file mode 100644
index 000000000..64de62213
--- /dev/null
+++ b/_test/core/TestUtils.php
@@ -0,0 +1,68 @@
+<?php
+
+/**
+ * Helper class with some filesystem utilities.
+ */
+class TestUtils {
+
+    /**
+     * helper for recursive copy()
+     *
+     * @static
+     * @param $destdir string
+     * @param $source string
+     */
+    public static function rcopy($destdir, $source) {
+        if (!is_dir($source)) {
+            copy($source, $destdir.'/'.basename($source));
+        } else {
+            $newdestdir = $destdir.'/'.basename($source);
+            mkdir($newdestdir);
+
+            $dh = dir($source);
+            while (false !== ($entry = $dh->read())) {
+                if ($entry == '.' || $entry == '..') {
+                    continue;
+                }
+                TestUtils::rcopy($newdestdir, $source.'/'.$entry);
+            }
+            $dh->close();
+        }
+    }
+
+    /**
+     * helper for recursive rmdir()/unlink()
+     *
+     * @static
+     * @param $target string
+     */
+    public static function rdelete($target) {
+        if (!is_dir($target)) {
+            unlink($target);
+        } else {
+            $dh = dir($target);
+            while (false !== ($entry = $dh->read())) {
+                if ($entry == '.' || $entry == '..') {
+                    continue;
+                }
+                TestUtils::rdelete("$target/$entry");
+            }
+            $dh->close();
+            rmdir($target);
+        }
+    }
+
+    /**
+     * helper to append text to a file
+     *
+     * @static
+     * @param $file string
+     * @param $text string
+     */
+    public static function fappend($file, $text) {
+        $fh = fopen($file, 'a');
+        fwrite($fh, $text);
+        fclose($fh);
+    }
+
+}
diff --git a/_test/core/phpQuery-onefile.php b/_test/core/phpQuery-onefile.php
new file mode 100644
index 000000000..4c1dfa3da
--- /dev/null
+++ b/_test/core/phpQuery-onefile.php
@@ -0,0 +1,5702 @@
+<?php
+/**
+ * phpQuery is a server-side, chainable, CSS3 selector driven
+ * Document Object Model (DOM) API based on jQuery JavaScript Library.
+ *
+ * @version 0.9.5
+ * @link http://code.google.com/p/phpquery/
+ * @link http://phpquery-library.blogspot.com/
+ * @link http://jquery.com/
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @license http://www.opensource.org/licenses/mit-license.php MIT License
+ * @package phpQuery
+ */
+
+// class names for instanceof
+// TODO move them as class constants into phpQuery
+define('DOMDOCUMENT', 'DOMDocument');
+define('DOMELEMENT', 'DOMElement');
+define('DOMNODELIST', 'DOMNodeList');
+define('DOMNODE', 'DOMNode');
+
+/**
+ * DOMEvent class.
+ *
+ * Based on
+ * @link http://developer.mozilla.org/En/DOM:event
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @package phpQuery
+ * @todo implement ArrayAccess ?
+ */
+class DOMEvent {
+    /**
+     * Returns a boolean indicating whether the event bubbles up through the DOM or not.
+     *
+     * @var unknown_type
+     */
+    public $bubbles = true;
+    /**
+     * Returns a boolean indicating whether the event is cancelable.
+     *
+     * @var unknown_type
+     */
+    public $cancelable = true;
+    /**
+     * Returns a reference to the currently registered target for the event.
+     *
+     * @var unknown_type
+     */
+    public $currentTarget;
+    /**
+     * Returns detail about the event, depending on the type of event.
+     *
+     * @var unknown_type
+     * @link http://developer.mozilla.org/en/DOM/event.detail
+     */
+    public $detail; // ???
+    /**
+     * Used to indicate which phase of the event flow is currently being evaluated.
+     *
+     * NOT IMPLEMENTED
+     *
+     * @var unknown_type
+     * @link http://developer.mozilla.org/en/DOM/event.eventPhase
+     */
+    public $eventPhase; // ???
+    /**
+     * The explicit original target of the event (Mozilla-specific).
+     *
+     * NOT IMPLEMENTED
+     *
+     * @var unknown_type
+     */
+    public $explicitOriginalTarget; // moz only
+    /**
+     * The original target of the event, before any retargetings (Mozilla-specific).
+     *
+     * NOT IMPLEMENTED
+     *
+     * @var unknown_type
+     */
+    public $originalTarget; // moz only
+    /**
+     * Identifies a secondary target for the event.
+     *
+     * @var unknown_type
+     */
+    public $relatedTarget;
+    /**
+     * Returns a reference to the target to which the event was originally dispatched.
+     *
+     * @var unknown_type
+     */
+    public $target;
+    /**
+     * Returns the time that the event was created.
+     *
+     * @var unknown_type
+     */
+    public $timeStamp;
+    /**
+     * Returns the name of the event (case-insensitive).
+     */
+    public $type;
+    public $runDefault = true;
+    public $data = null;
+    public function __construct($data) {
+        foreach($data as $k => $v) {
+            $this->$k = $v;
+        }
+        if (! $this->timeStamp)
+            $this->timeStamp = time();
+    }
+    /**
+     * Cancels the event (if it is cancelable).
+     *
+     */
+    public function preventDefault() {
+        $this->runDefault = false;
+    }
+    /**
+     * Stops the propagation of events further along in the DOM.
+     *
+     */
+    public function stopPropagation() {
+        $this->bubbles = false;
+    }
+}
+
+
+/**
+ * DOMDocumentWrapper class simplifies work with DOMDocument.
+ *
+ * Know bug:
+ * - in XHTML fragments, <br /> changes to <br clear="none" />
+ *
+ * @todo check XML catalogs compatibility
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @package phpQuery
+ */
+class DOMDocumentWrapper {
+    /**
+     * @var DOMDocument
+     */
+    public $document;
+    public $id;
+    /**
+     * @todo Rewrite as method and quess if null.
+     * @var unknown_type
+     */
+    public $contentType = '';
+    public $xpath;
+    public $uuid = 0;
+    public $data = array();
+    public $dataNodes = array();
+    public $events = array();
+    public $eventsNodes = array();
+    public $eventsGlobal = array();
+    /**
+     * @TODO iframes support http://code.google.com/p/phpquery/issues/detail?id=28
+     * @var unknown_type
+     */
+    public $frames = array();
+    /**
+     * Document root, by default equals to document itself.
+     * Used by documentFragments.
+     *
+     * @var DOMNode
+     */
+    public $root;
+    public $isDocumentFragment;
+    public $isXML = false;
+    public $isXHTML = false;
+    public $isHTML = false;
+    public $charset;
+    public function __construct($markup = null, $contentType = null, $newDocumentID = null) {
+        if (isset($markup))
+            $this->load($markup, $contentType, $newDocumentID);
+        $this->id = $newDocumentID
+            ? $newDocumentID
+            : md5(microtime());
+    }
+    public function load($markup, $contentType = null, $newDocumentID = null) {
+//      phpQuery::$documents[$id] = $this;
+        $this->contentType = strtolower($contentType);
+        if ($markup instanceof DOMDOCUMENT) {
+            $this->document = $markup;
+            $this->root = $this->document;
+            $this->charset = $this->document->encoding;
+            // TODO isDocumentFragment
+        } else {
+            $loaded = $this->loadMarkup($markup);
+        }
+        if ($loaded) {
+//          $this->document->formatOutput = true;
+            $this->document->preserveWhiteSpace = true;
+            $this->xpath = new DOMXPath($this->document);
+            $this->afterMarkupLoad();
+            return true;
+            // remember last loaded document
+//          return phpQuery::selectDocument($id);
+        }
+        return false;
+    }
+    protected function afterMarkupLoad() {
+        if ($this->isXHTML) {
+            $this->xpath->registerNamespace("html", "http://www.w3.org/1999/xhtml");
+        }
+    }
+    protected function loadMarkup($markup) {
+        $loaded = false;
+        if ($this->contentType) {
+            self::debug("Load markup for content type {$this->contentType}");
+            // content determined by contentType
+            list($contentType, $charset) = $this->contentTypeToArray($this->contentType);
+            switch($contentType) {
+                case 'text/html':
+                    phpQuery::debug("Loading HTML, content type '{$this->contentType}'");
+                    $loaded = $this->loadMarkupHTML($markup, $charset);
+                break;
+                case 'text/xml':
+                case 'application/xhtml+xml':
+                    phpQuery::debug("Loading XML, content type '{$this->contentType}'");
+                    $loaded = $this->loadMarkupXML($markup, $charset);
+                break;
+                default:
+                    // for feeds or anything that sometimes doesn't use text/xml
+                    if (strpos('xml', $this->contentType) !== false) {
+                        phpQuery::debug("Loading XML, content type '{$this->contentType}'");
+                        $loaded = $this->loadMarkupXML($markup, $charset);
+                    } else
+                        phpQuery::debug("Could not determine document type from content type '{$this->contentType}'");
+            }
+        } else {
+            // content type autodetection
+            if ($this->isXML($markup)) {
+                phpQuery::debug("Loading XML, isXML() == true");
+                $loaded = $this->loadMarkupXML($markup);
+                if (! $loaded && $this->isXHTML) {
+                    phpQuery::debug('Loading as XML failed, trying to load as HTML, isXHTML == true');
+                    $loaded = $this->loadMarkupHTML($markup);
+                }
+            } else {
+                phpQuery::debug("Loading HTML, isXML() == false");
+                $loaded = $this->loadMarkupHTML($markup);
+            }
+        }
+        return $loaded;
+    }
+    protected function loadMarkupReset() {
+        $this->isXML = $this->isXHTML = $this->isHTML = false;
+    }
+    protected function documentCreate($charset, $version = '1.0') {
+        if (! $version)
+            $version = '1.0';
+        $this->document = new DOMDocument($version, $charset);
+        $this->charset = $this->document->encoding;
+//      $this->document->encoding = $charset;
+        $this->document->formatOutput = true;
+        $this->document->preserveWhiteSpace = true;
+    }
+    protected function loadMarkupHTML($markup, $requestedCharset = null) {
+        if (phpQuery::$debug)
+            phpQuery::debug('Full markup load (HTML): '.substr($markup, 0, 250));
+        $this->loadMarkupReset();
+        $this->isHTML = true;
+        if (!isset($this->isDocumentFragment))
+            $this->isDocumentFragment = self::isDocumentFragmentHTML($markup);
+        $charset = null;
+        $documentCharset = $this->charsetFromHTML($markup);
+        $addDocumentCharset = false;
+        if ($documentCharset) {
+            $charset = $documentCharset;
+            $markup = $this->charsetFixHTML($markup);
+        } else if ($requestedCharset) {
+            $charset = $requestedCharset;
+        }
+        if (! $charset)
+            $charset = phpQuery::$defaultCharset;
+        // HTTP 1.1 says that the default charset is ISO-8859-1
+        // @see http://www.w3.org/International/O-HTTP-charset
+        if (! $documentCharset) {
+            $documentCharset = 'ISO-8859-1';
+            $addDocumentCharset = true;
+        }
+        // Should be careful here, still need 'magic encoding detection' since lots of pages have other 'default encoding'
+        // Worse, some pages can have mixed encodings... we'll try not to worry about that
+        $requestedCharset = strtoupper($requestedCharset);
+        $documentCharset = strtoupper($documentCharset);
+        phpQuery::debug("DOC: $documentCharset REQ: $requestedCharset");
+        if ($requestedCharset && $documentCharset && $requestedCharset !== $documentCharset) {
+            phpQuery::debug("CHARSET CONVERT");
+            // Document Encoding Conversion
+            // http://code.google.com/p/phpquery/issues/detail?id=86
+            if (function_exists('mb_detect_encoding')) {
+                $possibleCharsets = array($documentCharset, $requestedCharset, 'AUTO');
+                $docEncoding = mb_detect_encoding($markup, implode(', ', $possibleCharsets));
+                if (! $docEncoding)
+                    $docEncoding = $documentCharset; // ok trust the document
+                phpQuery::debug("DETECTED '$docEncoding'");
+                // Detected does not match what document says...
+                if ($docEncoding !== $documentCharset) {
+                    // Tricky..
+                }
+                if ($docEncoding !== $requestedCharset) {
+                    phpQuery::debug("CONVERT $docEncoding => $requestedCharset");
+                    $markup = mb_convert_encoding($markup, $requestedCharset, $docEncoding);
+                    $markup = $this->charsetAppendToHTML($markup, $requestedCharset);
+                    $charset = $requestedCharset;
+                }
+            } else {
+                phpQuery::debug("TODO: charset conversion without mbstring...");
+            }
+        }
+        $return = false;
+        if ($this->isDocumentFragment) {
+            phpQuery::debug("Full markup load (HTML), DocumentFragment detected, using charset '$charset'");
+            $return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
+        } else {
+            if ($addDocumentCharset) {
+                phpQuery::debug("Full markup load (HTML), appending charset: '$charset'");
+                $markup = $this->charsetAppendToHTML($markup, $charset);
+            }
+            phpQuery::debug("Full markup load (HTML), documentCreate('$charset')");
+            $this->documentCreate($charset);
+            $return = phpQuery::$debug === 2
+                ? $this->document->loadHTML($markup)
+                : @$this->document->loadHTML($markup);
+            if ($return)
+                $this->root = $this->document;
+        }
+        if ($return && ! $this->contentType)
+            $this->contentType = 'text/html';
+        return $return;
+    }
+    protected function loadMarkupXML($markup, $requestedCharset = null) {
+        if (phpQuery::$debug)
+            phpQuery::debug('Full markup load (XML): '.substr($markup, 0, 250));
+        $this->loadMarkupReset();
+        $this->isXML = true;
+        // check agains XHTML in contentType or markup
+        $isContentTypeXHTML = $this->isXHTML();
+        $isMarkupXHTML = $this->isXHTML($markup);
+        if ($isContentTypeXHTML || $isMarkupXHTML) {
+            self::debug('Full markup load (XML), XHTML detected');
+            $this->isXHTML = true;
+        }
+        // determine document fragment
+        if (! isset($this->isDocumentFragment))
+            $this->isDocumentFragment = $this->isXHTML
+                ? self::isDocumentFragmentXHTML($markup)
+                : self::isDocumentFragmentXML($markup);
+        // this charset will be used
+        $charset = null;
+        // charset from XML declaration @var string
+        $documentCharset = $this->charsetFromXML($markup);
+        if (! $documentCharset) {
+            if ($this->isXHTML) {
+                // this is XHTML, try to get charset from content-type meta header
+                $documentCharset = $this->charsetFromHTML($markup);
+                if ($documentCharset) {
+                    phpQuery::debug("Full markup load (XML), appending XHTML charset '$documentCharset'");
+                    $this->charsetAppendToXML($markup, $documentCharset);
+                    $charset = $documentCharset;
+                }
+            }
+            if (! $documentCharset) {
+                // if still no document charset...
+                $charset = $requestedCharset;
+            }
+        } else if ($requestedCharset) {
+            $charset = $requestedCharset;
+        }
+        if (! $charset) {
+            $charset = phpQuery::$defaultCharset;
+        }
+        if ($requestedCharset && $documentCharset && $requestedCharset != $documentCharset) {
+            // TODO place for charset conversion
+//          $charset = $requestedCharset;
+        }
+        $return = false;
+        if ($this->isDocumentFragment) {
+            phpQuery::debug("Full markup load (XML), DocumentFragment detected, using charset '$charset'");
+            $return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
+        } else {
+            // FIXME ???
+            if ($isContentTypeXHTML && ! $isMarkupXHTML)
+            if (! $documentCharset) {
+                phpQuery::debug("Full markup load (XML), appending charset '$charset'");
+                $markup = $this->charsetAppendToXML($markup, $charset);
+            }
+            // see http://pl2.php.net/manual/en/book.dom.php#78929
+            // LIBXML_DTDLOAD (>= PHP 5.1)
+            // does XML ctalogues works with LIBXML_NONET
+    //      $this->document->resolveExternals = true;
+            // TODO test LIBXML_COMPACT for performance improvement
+            // create document
+            $this->documentCreate($charset);
+            if (phpversion() < 5.1) {
+                $this->document->resolveExternals = true;
+                $return = phpQuery::$debug === 2
+                    ? $this->document->loadXML($markup)
+                    : @$this->document->loadXML($markup);
+            } else {
+                /** @link http://pl2.php.net/manual/en/libxml.constants.php */
+                $libxmlStatic = phpQuery::$debug === 2
+                    ? LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET
+                    : LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET|LIBXML_NOWARNING|LIBXML_NOERROR;
+                $return = $this->document->loadXML($markup, $libxmlStatic);
+//              if (! $return)
+//                  $return = $this->document->loadHTML($markup);
+            }
+            if ($return)
+                $this->root = $this->document;
+        }
+        if ($return) {
+            if (! $this->contentType) {
+                if ($this->isXHTML)
+                    $this->contentType = 'application/xhtml+xml';
+                else
+                    $this->contentType = 'text/xml';
+            }
+            return $return;
+        } else {
+            throw new Exception("Error loading XML markup");
+        }
+    }
+    protected function isXHTML($markup = null) {
+        if (! isset($markup)) {
+            return strpos($this->contentType, 'xhtml') !== false;
+        }
+        // XXX ok ?
+        return strpos($markup, "<!DOCTYPE html") !== false;
+//      return stripos($doctype, 'xhtml') !== false;
+//      $doctype = isset($dom->doctype) && is_object($dom->doctype)
+//          ? $dom->doctype->publicId
+//          : self::$defaultDoctype;
+    }
+    protected function isXML($markup) {
+//      return strpos($markup, '<?xml') !== false && stripos($markup, 'xhtml') === false;
+        return strpos(substr($markup, 0, 100), '<'.'?xml') !== false;
+    }
+    protected function contentTypeToArray($contentType) {
+        $matches = explode(';', trim(strtolower($contentType)));
+        if (isset($matches[1])) {
+            $matches[1] = explode('=', $matches[1]);
+            // strip 'charset='
+            $matches[1] = isset($matches[1][1]) && trim($matches[1][1])
+                ? $matches[1][1]
+                : $matches[1][0];
+        } else
+            $matches[1] = null;
+        return $matches;
+    }
+    /**
+     *
+     * @param $markup
+     * @return array contentType, charset
+     */
+    protected function contentTypeFromHTML($markup) {
+        $matches = array();
+        // find meta tag
+        preg_match('@<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
+            $markup, $matches
+        );
+        if (! isset($matches[0]))
+            return array(null, null);
+        // get attr 'content'
+        preg_match('@content\\s*=\\s*(["|\'])(.+?)\\1@', $matches[0], $matches);
+        if (! isset($matches[0]))
+            return array(null, null);
+        return $this->contentTypeToArray($matches[2]);
+    }
+    protected function charsetFromHTML($markup) {
+        $contentType = $this->contentTypeFromHTML($markup);
+        return $contentType[1];
+    }
+    protected function charsetFromXML($markup) {
+        $matches;
+        // find declaration
+        preg_match('@<'.'?xml[^>]+encoding\\s*=\\s*(["|\'])(.*?)\\1@i',
+            $markup, $matches
+        );
+        return isset($matches[2])
+            ? strtolower($matches[2])
+            : null;
+    }
+    /**
+     * Repositions meta[type=charset] at the start of head. Bypasses DOMDocument bug.
+     *
+     * @link http://code.google.com/p/phpquery/issues/detail?id=80
+     * @param $html
+     */
+    protected function charsetFixHTML($markup) {
+        $matches = array();
+        // find meta tag
+        preg_match('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
+            $markup, $matches, PREG_OFFSET_CAPTURE
+        );
+        if (! isset($matches[0]))
+            return;
+        $metaContentType = $matches[0][0];
+        $markup = substr($markup, 0, $matches[0][1])
+            .substr($markup, $matches[0][1]+strlen($metaContentType));
+        $headStart = stripos($markup, '<head>');
+        $markup = substr($markup, 0, $headStart+6).$metaContentType
+            .substr($markup, $headStart+6);
+        return $markup;
+    }
+    protected function charsetAppendToHTML($html, $charset, $xhtml = false) {
+        // remove existing meta[type=content-type]
+        $html = preg_replace('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i', '', $html);
+        $meta = '<meta http-equiv="Content-Type" content="text/html;charset='
+            .$charset.'" '
+            .($xhtml ? '/' : '')
+            .'>';
+        if (strpos($html, '<head') === false) {
+            if (strpos($hltml, '<html') === false) {
+                return $meta.$html;
+            } else {
+                return preg_replace(
+                    '@<html(.*?)(?(?<!\?)>)@s',
+                    "<html\\1><head>{$meta}</head>",
+                    $html
+                );
+            }
+        } else {
+            return preg_replace(
+                '@<head(.*?)(?(?<!\?)>)@s',
+                '<head\\1>'.$meta,
+                $html
+            );
+        }
+    }
+    protected function charsetAppendToXML($markup, $charset) {
+        $declaration = '<'.'?xml version="1.0" encoding="'.$charset.'"?'.'>';
+        return $declaration.$markup;
+    }
+    public static function isDocumentFragmentHTML($markup) {
+        return stripos($markup, '<html') === false && stripos($markup, '<!doctype') === false;
+    }
+    public static function isDocumentFragmentXML($markup) {
+        return stripos($markup, '<'.'?xml') === false;
+    }
+    public static function isDocumentFragmentXHTML($markup) {
+        return self::isDocumentFragmentHTML($markup);
+    }
+    public function importAttr($value) {
+        // TODO
+    }
+    /**
+     *
+     * @param $source
+     * @param $target
+     * @param $sourceCharset
+     * @return array Array of imported nodes.
+     */
+    public function import($source, $sourceCharset = null) {
+        // TODO charset conversions
+        $return = array();
+        if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
+            $source = array($source);
+//      if (is_array($source)) {
+//          foreach($source as $node) {
+//              if (is_string($node)) {
+//                  // string markup
+//                  $fake = $this->documentFragmentCreate($node, $sourceCharset);
+//                  if ($fake === false)
+//                      throw new Exception("Error loading documentFragment markup");
+//                  else
+//                      $return = array_merge($return,
+//                          $this->import($fake->root->childNodes)
+//                      );
+//              } else {
+//                  $return[] = $this->document->importNode($node, true);
+//              }
+//          }
+//          return $return;
+//      } else {
+//          // string markup
+//          $fake = $this->documentFragmentCreate($source, $sourceCharset);
+//          if ($fake === false)
+//              throw new Exception("Error loading documentFragment markup");
+//          else
+//              return $this->import($fake->root->childNodes);
+//      }
+        if (is_array($source) || $source instanceof DOMNODELIST) {
+            // dom nodes
+            self::debug('Importing nodes to document');
+            foreach($source as $node)
+                $return[] = $this->document->importNode($node, true);
+        } else {
+            // string markup
+            $fake = $this->documentFragmentCreate($source, $sourceCharset);
+            if ($fake === false)
+                throw new Exception("Error loading documentFragment markup");
+            else
+                return $this->import($fake->root->childNodes);
+        }
+        return $return;
+    }
+    /**
+     * Creates new document fragment.
+     *
+     * @param $source
+     * @return DOMDocumentWrapper
+     */
+    protected function documentFragmentCreate($source, $charset = null) {
+        $fake = new DOMDocumentWrapper();
+        $fake->contentType = $this->contentType;
+        $fake->isXML = $this->isXML;
+        $fake->isHTML = $this->isHTML;
+        $fake->isXHTML = $this->isXHTML;
+        $fake->root = $fake->document;
+        if (! $charset)
+            $charset = $this->charset;
+//  $fake->documentCreate($this->charset);
+        if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
+            $source = array($source);
+        if (is_array($source) || $source instanceof DOMNODELIST) {
+            // dom nodes
+            // load fake document
+            if (! $this->documentFragmentLoadMarkup($fake, $charset))
+                return false;
+            $nodes = $fake->import($source);
+            foreach($nodes as $node)
+                $fake->root->appendChild($node);
+        } else {
+            // string markup
+            $this->documentFragmentLoadMarkup($fake, $charset, $source);
+        }
+        return $fake;
+    }
+    /**
+     *
+     * @param $document DOMDocumentWrapper
+     * @param $markup
+     * @return $document
+     */
+    private function documentFragmentLoadMarkup($fragment, $charset, $markup = null) {
+        // TODO error handling
+        // TODO copy doctype
+        // tempolary turn off
+        $fragment->isDocumentFragment = false;
+        if ($fragment->isXML) {
+            if ($fragment->isXHTML) {
+                // add FAKE element to set default namespace
+                $fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?>'
+                    .'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
+                    .'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+                    .'<fake xmlns="http://www.w3.org/1999/xhtml">'.$markup.'</fake>');
+                $fragment->root = $fragment->document->firstChild->nextSibling;
+            } else {
+                $fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?><fake>'.$markup.'</fake>');
+                $fragment->root = $fragment->document->firstChild;
+            }
+        } else {
+            $markup2 = phpQuery::$defaultDoctype.'<html><head><meta http-equiv="Content-Type" content="text/html;charset='
+                .$charset.'"></head>';
+            $noBody = strpos($markup, '<body') === false;
+            if ($noBody)
+                $markup2 .= '<body>';
+            $markup2 .= $markup;
+            if ($noBody)
+                $markup2 .= '</body>';
+            $markup2 .= '</html>';
+            $fragment->loadMarkupHTML($markup2);
+            // TODO resolv body tag merging issue
+            $fragment->root = $noBody
+                ? $fragment->document->firstChild->nextSibling->firstChild->nextSibling
+                : $fragment->document->firstChild->nextSibling->firstChild->nextSibling;
+        }
+        if (! $fragment->root)
+            return false;
+        $fragment->isDocumentFragment = true;
+        return true;
+    }
+    protected function documentFragmentToMarkup($fragment) {
+        phpQuery::debug('documentFragmentToMarkup');
+        $tmp = $fragment->isDocumentFragment;
+        $fragment->isDocumentFragment = false;
+        $markup = $fragment->markup();
+        if ($fragment->isXML) {
+            $markup = substr($markup, 0, strrpos($markup, '</fake>'));
+            if ($fragment->isXHTML) {
+                $markup = substr($markup, strpos($markup, '<fake')+43);
+            } else {
+                $markup = substr($markup, strpos($markup, '<fake>')+6);
+            }
+        } else {
+                $markup = substr($markup, strpos($markup, '<body>')+6);
+                $markup = substr($markup, 0, strrpos($markup, '</body>'));
+        }
+        $fragment->isDocumentFragment = $tmp;
+        if (phpQuery::$debug)
+            phpQuery::debug('documentFragmentToMarkup: '.substr($markup, 0, 150));
+        return $markup;
+    }
+    /**
+     * Return document markup, starting with optional $nodes as root.
+     *
+     * @param $nodes    DOMNode|DOMNodeList
+     * @return string
+     */
+    public function markup($nodes = null, $innerMarkup = false) {
+        if (isset($nodes) && count($nodes) == 1 && $nodes[0] instanceof DOMDOCUMENT)
+            $nodes = null;
+        if (isset($nodes)) {
+            $markup = '';
+            if (!is_array($nodes) && !($nodes instanceof DOMNODELIST) )
+                $nodes = array($nodes);
+            if ($this->isDocumentFragment && ! $innerMarkup)
+                foreach($nodes as $i => $node)
+                    if ($node->isSameNode($this->root)) {
+                    //  var_dump($node);
+                        $nodes = array_slice($nodes, 0, $i)
+                            + phpQuery::DOMNodeListToArray($node->childNodes)
+                            + array_slice($nodes, $i+1);
+                        }
+            if ($this->isXML && ! $innerMarkup) {
+                self::debug("Getting outerXML with charset '{$this->charset}'");
+                // we need outerXML, so we can benefit from
+                // $node param support in saveXML()
+                foreach($nodes as $node)
+                    $markup .= $this->document->saveXML($node);
+            } else {
+                $loop = array();
+                if ($innerMarkup)
+                    foreach($nodes as $node) {
+                        if ($node->childNodes)
+                            foreach($node->childNodes as $child)
+                                $loop[] = $child;
+                        else
+                            $loop[] = $node;
+                    }
+                else
+                    $loop = $nodes;
+                self::debug("Getting markup, moving selected nodes (".count($loop).") to new DocumentFragment");
+                $fake = $this->documentFragmentCreate($loop);
+                $markup = $this->documentFragmentToMarkup($fake);
+            }
+            if ($this->isXHTML) {
+                self::debug("Fixing XHTML");
+                $markup = self::markupFixXHTML($markup);
+            }
+            self::debug("Markup: ".substr($markup, 0, 250));
+            return $markup;
+        } else {
+            if ($this->isDocumentFragment) {
+                // documentFragment, html only...
+                self::debug("Getting markup, DocumentFragment detected");
+//              return $this->markup(
+////                    $this->document->getElementsByTagName('body')->item(0)
+//                  $this->document->root, true
+//              );
+                $markup = $this->documentFragmentToMarkup($this);
+                // no need for markupFixXHTML, as it's done thought markup($nodes) method
+                return $markup;
+            } else {
+                self::debug("Getting markup (".($this->isXML?'XML':'HTML')."), final with charset '{$this->charset}'");
+                $markup = $this->isXML
+                    ? $this->document->saveXML()
+                    : $this->document->saveHTML();
+                if ($this->isXHTML) {
+                    self::debug("Fixing XHTML");
+                    $markup = self::markupFixXHTML($markup);
+                }
+                self::debug("Markup: ".substr($markup, 0, 250));
+                return $markup;
+            }
+        }
+    }
+    protected static function markupFixXHTML($markup) {
+        $markup = self::expandEmptyTag('script', $markup);
+        $markup = self::expandEmptyTag('select', $markup);
+        $markup = self::expandEmptyTag('textarea', $markup);
+        return $markup;
+    }
+    public static function debug($text) {
+        phpQuery::debug($text);
+    }
+    /**
+     * expandEmptyTag
+     *
+     * @param $tag
+     * @param $xml
+     * @return unknown_type
+     * @author mjaque at ilkebenson dot com
+     * @link http://php.net/manual/en/domdocument.savehtml.php#81256
+     */
+    public static function expandEmptyTag($tag, $xml){
+        $indice = 0;
+        while ($indice< strlen($xml)){
+            $pos = strpos($xml, "<$tag ", $indice);
+            if ($pos){
+                $posCierre = strpos($xml, ">", $pos);
+                if ($xml[$posCierre-1] == "/"){
+                    $xml = substr_replace($xml, "></$tag>", $posCierre-1, 2);
+                }
+                $indice = $posCierre;
+            }
+            else break;
+        }
+        return $xml;
+    }
+}
+
+/**
+ * Event handling class.
+ *
+ * @author Tobiasz Cudnik
+ * @package phpQuery
+ * @static
+ */
+abstract class phpQueryEvents {
+    /**
+     * Trigger a type of event on every matched element.
+     *
+     * @param DOMNode|phpQueryObject|string $document
+     * @param unknown_type $type
+     * @param unknown_type $data
+     *
+     * @TODO exclusive events (with !)
+     * @TODO global events (test)
+     * @TODO support more than event in $type (space-separated)
+     */
+    public static function trigger($document, $type, $data = array(), $node = null) {
+        // trigger: function(type, data, elem, donative, extra) {
+        $documentID = phpQuery::getDocumentID($document);
+        $namespace = null;
+        if (strpos($type, '.') !== false)
+            list($name, $namespace) = explode('.', $type);
+        else
+            $name = $type;
+        if (! $node) {
+            if (self::issetGlobal($documentID, $type)) {
+                $pq = phpQuery::getDocument($documentID);
+                // TODO check add($pq->document)
+                $pq->find('*')->add($pq->document)
+                    ->trigger($type, $data);
+            }
+        } else {
+            if (isset($data[0]) && $data[0] instanceof DOMEvent) {
+                $event = $data[0];
+                $event->relatedTarget = $event->target;
+                $event->target = $node;
+                $data = array_slice($data, 1);
+            } else {
+                $event = new DOMEvent(array(
+                    'type' => $type,
+                    'target' => $node,
+                    'timeStamp' => time(),
+                ));
+            }
+            $i = 0;
+            while($node) {
+                // TODO whois
+                phpQuery::debug("Triggering ".($i?"bubbled ":'')."event '{$type}' on "
+                    ."node \n");//.phpQueryObject::whois($node)."\n");
+                $event->currentTarget = $node;
+                $eventNode = self::getNode($documentID, $node);
+                if (isset($eventNode->eventHandlers)) {
+                    foreach($eventNode->eventHandlers as $eventType => $handlers) {
+                        $eventNamespace = null;
+                        if (strpos($type, '.') !== false)
+                            list($eventName, $eventNamespace) = explode('.', $eventType);
+                        else
+                            $eventName = $eventType;
+                        if ($name != $eventName)
+                            continue;
+                        if ($namespace && $eventNamespace && $namespace != $eventNamespace)
+                            continue;
+                        foreach($handlers as $handler) {
+                            phpQuery::debug("Calling event handler\n");
+                            $event->data = $handler['data']
+                                ? $handler['data']
+                                : null;
+                            $params = array_merge(array($event), $data);
+                            $return = phpQuery::callbackRun($handler['callback'], $params);
+                            if ($return === false) {
+                                $event->bubbles = false;
+                            }
+                        }
+                    }
+                }
+                // to bubble or not to bubble...
+                if (! $event->bubbles)
+                    break;
+                $node = $node->parentNode;
+                $i++;
+            }
+        }
+    }
+    /**
+     * Binds a handler to one or more events (like click) for each matched element.
+     * Can also bind custom events.
+     *
+     * @param DOMNode|phpQueryObject|string $document
+     * @param unknown_type $type
+     * @param unknown_type $data Optional
+     * @param unknown_type $callback
+     *
+     * @TODO support '!' (exclusive) events
+     * @TODO support more than event in $type (space-separated)
+     * @TODO support binding to global events
+     */
+    public static function add($document, $node, $type, $data, $callback = null) {
+        phpQuery::debug("Binding '$type' event");
+        $documentID = phpQuery::getDocumentID($document);
+//      if (is_null($callback) && is_callable($data)) {
+//          $callback = $data;
+//          $data = null;
+//      }
+        $eventNode = self::getNode($documentID, $node);
+        if (! $eventNode)
+            $eventNode = self::setNode($documentID, $node);
+        if (!isset($eventNode->eventHandlers[$type]))
+            $eventNode->eventHandlers[$type] = array();
+        $eventNode->eventHandlers[$type][] = array(
+            'callback' => $callback,
+            'data' => $data,
+        );
+    }
+    /**
+     * Enter description here...
+     *
+     * @param DOMNode|phpQueryObject|string $document
+     * @param unknown_type $type
+     * @param unknown_type $callback
+     *
+     * @TODO namespace events
+     * @TODO support more than event in $type (space-separated)
+     */
+    public static function remove($document, $node, $type = null, $callback = null) {
+        $documentID = phpQuery::getDocumentID($document);
+        $eventNode = self::getNode($documentID, $node);
+        if (is_object($eventNode) && isset($eventNode->eventHandlers[$type])) {
+            if ($callback) {
+                foreach($eventNode->eventHandlers[$type] as $k => $handler)
+                    if ($handler['callback'] == $callback)
+                        unset($eventNode->eventHandlers[$type][$k]);
+            } else {
+                unset($eventNode->eventHandlers[$type]);
+            }
+        }
+    }
+    protected static function getNode($documentID, $node) {
+        foreach(phpQuery::$documents[$documentID]->eventsNodes as $eventNode) {
+            if ($node->isSameNode($eventNode))
+                return $eventNode;
+        }
+    }
+    protected static function setNode($documentID, $node) {
+        phpQuery::$documents[$documentID]->eventsNodes[] = $node;
+        return phpQuery::$documents[$documentID]->eventsNodes[
+            count(phpQuery::$documents[$documentID]->eventsNodes)-1
+        ];
+    }
+    protected static function issetGlobal($documentID, $type) {
+        return isset(phpQuery::$documents[$documentID])
+            ? in_array($type, phpQuery::$documents[$documentID]->eventsGlobal)
+            : false;
+    }
+}
+
+
+interface ICallbackNamed {
+    function hasName();
+    function getName();
+}
+/**
+ * Callback class introduces currying-like pattern.
+ *
+ * Example:
+ * function foo($param1, $param2, $param3) {
+ *   var_dump($param1, $param2, $param3);
+ * }
+ * $fooCurried = new Callback('foo',
+ *   'param1 is now statically set',
+ *   new CallbackParam, new CallbackParam
+ * );
+ * phpQuery::callbackRun($fooCurried,
+ *  array('param2 value', 'param3 value'
+ * );
+ *
+ * Callback class is supported in all phpQuery methods which accepts callbacks.
+ *
+ * @link http://code.google.com/p/phpquery/wiki/Callbacks#Param_Structures
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ *
+ * @TODO??? return fake forwarding function created via create_function
+ * @TODO honor paramStructure
+ */
+class Callback
+    implements ICallbackNamed {
+    public $callback = null;
+    public $params = null;
+    protected $name;
+    public function __construct($callback, $param1 = null, $param2 = null,
+            $param3 = null) {
+        $params = func_get_args();
+        $params = array_slice($params, 1);
+        if ($callback instanceof Callback) {
+            // TODO implement recurention
+        } else {
+            $this->callback = $callback;
+            $this->params = $params;
+        }
+    }
+    public function getName() {
+        return 'Callback: '.$this->name;
+    }
+    public function hasName() {
+        return isset($this->name) && $this->name;
+    }
+    public function setName($name) {
+        $this->name = $name;
+        return $this;
+    }
+    // TODO test me
+//  public function addParams() {
+//      $params = func_get_args();
+//      return new Callback($this->callback, $this->params+$params);
+//  }
+}
+/**
+ * Shorthand for new Callback(create_function(...), ...);
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ */
+class CallbackBody extends Callback {
+    public function __construct($paramList, $code, $param1 = null, $param2 = null,
+            $param3 = null) {
+        $params = func_get_args();
+        $params = array_slice($params, 2);
+        $this->callback = create_function($paramList, $code);
+        $this->params = $params;
+    }
+}
+/**
+ * Callback type which on execution returns reference passed during creation.
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ */
+class CallbackReturnReference extends Callback
+    implements ICallbackNamed {
+    protected $reference;
+    public function __construct(&$reference, $name = null){
+        $this->reference =& $reference;
+        $this->callback = array($this, 'callback');
+    }
+    public function callback() {
+        return $this->reference;
+    }
+    public function getName() {
+        return 'Callback: '.$this->name;
+    }
+    public function hasName() {
+        return isset($this->name) && $this->name;
+    }
+}
+/**
+ * Callback type which on execution returns value passed during creation.
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ */
+class CallbackReturnValue extends Callback
+    implements ICallbackNamed {
+    protected $value;
+    protected $name;
+    public function __construct($value, $name = null){
+        $this->value =& $value;
+        $this->name = $name;
+        $this->callback = array($this, 'callback');
+    }
+    public function callback() {
+        return $this->value;
+    }
+    public function __toString() {
+        return $this->getName();
+    }
+    public function getName() {
+        return 'Callback: '.$this->name;
+    }
+    public function hasName() {
+        return isset($this->name) && $this->name;
+    }
+}
+/**
+ * CallbackParameterToReference can be used when we don't really want a callback,
+ * only parameter passed to it. CallbackParameterToReference takes first
+ * parameter's value and passes it to reference.
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ */
+class CallbackParameterToReference extends Callback {
+    /**
+     * @param $reference
+     * @TODO implement $paramIndex;
+     * param index choose which callback param will be passed to reference
+     */
+    public function __construct(&$reference){
+        $this->callback =& $reference;
+    }
+}
+//class CallbackReference extends Callback {
+//  /**
+//   *
+//   * @param $reference
+//   * @param $paramIndex
+//   * @todo implement $paramIndex; param index choose which callback param will be passed to reference
+//   */
+//  public function __construct(&$reference, $name = null){
+//      $this->callback =& $reference;
+//  }
+//}
+class CallbackParam {}
+
+/**
+ * Class representing phpQuery objects.
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @package phpQuery
+ * @method phpQueryObject clone() clone()
+ * @method phpQueryObject empty() empty()
+ * @method phpQueryObject next() next($selector = null)
+ * @method phpQueryObject prev() prev($selector = null)
+ * @property Int $length
+ */
+class phpQueryObject
+    implements Iterator, Countable, ArrayAccess {
+    public $documentID = null;
+    /**
+     * DOMDocument class.
+     *
+     * @var DOMDocument
+     */
+    public $document = null;
+    public $charset = null;
+    /**
+     *
+     * @var DOMDocumentWrapper
+     */
+    public $documentWrapper = null;
+    /**
+     * XPath interface.
+     *
+     * @var DOMXPath
+     */
+    public $xpath = null;
+    /**
+     * Stack of selected elements.
+     * @TODO refactor to ->nodes
+     * @var array
+     */
+    public $elements = array();
+    /**
+     * @access private
+     */
+    protected $elementsBackup = array();
+    /**
+     * @access private
+     */
+    protected $previous = null;
+    /**
+     * @access private
+     * @TODO deprecate
+     */
+    protected $root = array();
+    /**
+     * Indicated if doument is just a fragment (no <html> tag).
+     *
+     * Every document is realy a full document, so even documentFragments can
+     * be queried against <html>, but getDocument(id)->htmlOuter() will return
+     * only contents of <body>.
+     *
+     * @var bool
+     */
+    public $documentFragment = true;
+    /**
+     * Iterator interface helper
+     * @access private
+     */
+    protected $elementsInterator = array();
+    /**
+     * Iterator interface helper
+     * @access private
+     */
+    protected $valid = false;
+    /**
+     * Iterator interface helper
+     * @access private
+     */
+    protected $current = null;
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function __construct($documentID) {
+//      if ($documentID instanceof self)
+//          var_dump($documentID->getDocumentID());
+        $id = $documentID instanceof self
+            ? $documentID->getDocumentID()
+            : $documentID;
+//      var_dump($id);
+        if (! isset(phpQuery::$documents[$id] )) {
+//          var_dump(phpQuery::$documents);
+            throw new Exception("Document with ID '{$id}' isn't loaded. Use phpQuery::newDocument(\$html) or phpQuery::newDocumentFile(\$file) first.");
+        }
+        $this->documentID = $id;
+        $this->documentWrapper =& phpQuery::$documents[$id];
+        $this->document =& $this->documentWrapper->document;
+        $this->xpath =& $this->documentWrapper->xpath;
+        $this->charset =& $this->documentWrapper->charset;
+        $this->documentFragment =& $this->documentWrapper->isDocumentFragment;
+        // TODO check $this->DOM->documentElement;
+//      $this->root = $this->document->documentElement;
+        $this->root =& $this->documentWrapper->root;
+//      $this->toRoot();
+        $this->elements = array($this->root);
+    }
+    /**
+     *
+     * @access private
+     * @param $attr
+     * @return unknown_type
+     */
+    public function __get($attr) {
+        switch($attr) {
+            // FIXME doesnt work at all ?
+            case 'length':
+                return $this->size();
+            break;
+            default:
+                return $this->$attr;
+        }
+    }
+    /**
+     * Saves actual object to $var by reference.
+     * Useful when need to break chain.
+     * @param phpQueryObject $var
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function toReference(&$var) {
+        return $var = $this;
+    }
+    public function documentFragment($state = null) {
+        if ($state) {
+            phpQuery::$documents[$this->getDocumentID()]['documentFragment'] = $state;
+            return $this;
+        }
+        return $this->documentFragment;
+    }
+    /**
+   * @access private
+   * @TODO documentWrapper
+     */
+    protected function isRoot( $node) {
+//      return $node instanceof DOMDOCUMENT || $node->tagName == 'html';
+        return $node instanceof DOMDOCUMENT
+            || ($node instanceof DOMELEMENT && $node->tagName == 'html')
+            || $this->root->isSameNode($node);
+    }
+    /**
+   * @access private
+     */
+    protected function stackIsRoot() {
+        return $this->size() == 1 && $this->isRoot($this->elements[0]);
+    }
+    /**
+     * Enter description here...
+     * NON JQUERY METHOD
+     *
+     * Watch out, it doesn't creates new instance, can be reverted with end().
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function toRoot() {
+        $this->elements = array($this->root);
+        return $this;
+//      return $this->newInstance(array($this->root));
+    }
+    /**
+     * Saves object's DocumentID to $var by reference.
+     * <code>
+     * $myDocumentId;
+     * phpQuery::newDocument('<div/>')
+     *     ->getDocumentIDRef($myDocumentId)
+     *     ->find('div')->...
+     * </code>
+     *
+     * @param unknown_type $domId
+     * @see phpQuery::newDocument
+     * @see phpQuery::newDocumentFile
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function getDocumentIDRef(&$documentID) {
+        $documentID = $this->getDocumentID();
+        return $this;
+    }
+    /**
+     * Returns object with stack set to document root.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function getDocument() {
+        return phpQuery::getDocument($this->getDocumentID());
+    }
+    /**
+     *
+     * @return DOMDocument
+     */
+    public function getDOMDocument() {
+        return $this->document;
+    }
+    /**
+     * Get object's Document ID.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function getDocumentID() {
+        return $this->documentID;
+    }
+    /**
+     * Unloads whole document from memory.
+     * CAUTION! None further operations will be possible on this document.
+     * All objects refering to it will be useless.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function unloadDocument() {
+        phpQuery::unloadDocuments($this->getDocumentID());
+    }
+    public function isHTML() {
+        return $this->documentWrapper->isHTML;
+    }
+    public function isXHTML() {
+        return $this->documentWrapper->isXHTML;
+    }
+    public function isXML() {
+        return $this->documentWrapper->isXML;
+    }
+    /**
+     * Enter description here...
+     *
+     * @link http://docs.jquery.com/Ajax/serialize
+     * @return string
+     */
+    public function serialize() {
+        return phpQuery::param($this->serializeArray());
+    }
+    /**
+     * Enter description here...
+     *
+     * @link http://docs.jquery.com/Ajax/serializeArray
+     * @return array
+     */
+    public function serializeArray($submit = null) {
+        $source = $this->filter('form, input, select, textarea')
+            ->find('input, select, textarea')
+            ->andSelf()
+            ->not('form');
+        $return = array();
+//      $source->dumpDie();
+        foreach($source as $input) {
+            $input = phpQuery::pq($input);
+            if ($input->is('[disabled]'))
+                continue;
+            if (!$input->is('[name]'))
+                continue;
+            if ($input->is('[type=checkbox]') && !$input->is('[checked]'))
+                continue;
+            // jquery diff
+            if ($submit && $input->is('[type=submit]')) {
+                if ($submit instanceof DOMELEMENT && ! $input->elements[0]->isSameNode($submit))
+                    continue;
+                else if (is_string($submit) && $input->attr('name') != $submit)
+                    continue;
+            }
+            $return[] = array(
+                'name' => $input->attr('name'),
+                'value' => $input->val(),
+            );
+        }
+        return $return;
+    }
+    /**
+     * @access private
+     */
+    protected function debug($in) {
+        if (! phpQuery::$debug )
+            return;
+        print('<pre>');
+        print_r($in);
+        // file debug
+//      file_put_contents(dirname(__FILE__).'/phpQuery.log', print_r($in, true)."\n", FILE_APPEND);
+        // quite handy debug trace
+//      if ( is_array($in))
+//          print_r(array_slice(debug_backtrace(), 3));
+        print("</pre>\n");
+    }
+    /**
+     * @access private
+     */
+    protected function isRegexp($pattern) {
+        return in_array(
+            $pattern[ mb_strlen($pattern)-1 ],
+            array('^','*','$')
+        );
+    }
+    /**
+     * Determines if $char is really a char.
+     *
+     * @param string $char
+     * @return bool
+     * @todo rewrite me to charcode range ! ;)
+     * @access private
+     */
+    protected function isChar($char) {
+        return extension_loaded('mbstring') && phpQuery::$mbstringSupport
+            ? mb_eregi('\w', $char)
+            : preg_match('@\w@', $char);
+    }
+    /**
+     * @access private
+     */
+    protected function parseSelector($query) {
+        // clean spaces
+        // TODO include this inside parsing ?
+        $query = trim(
+            preg_replace('@\s+@', ' ',
+                preg_replace('@\s*(>|\\+|~)\s*@', '\\1', $query)
+            )
+        );
+        $queries = array(array());
+        if (! $query)
+            return $queries;
+        $return =& $queries[0];
+        $specialChars = array('>',' ');
+//      $specialCharsMapping = array('/' => '>');
+        $specialCharsMapping = array();
+        $strlen = mb_strlen($query);
+        $classChars = array('.', '-');
+        $pseudoChars = array('-');
+        $tagChars = array('*', '|', '-');
+        // split multibyte string
+        // http://code.google.com/p/phpquery/issues/detail?id=76
+        $_query = array();
+        for ($i=0; $i<$strlen; $i++)
+            $_query[] = mb_substr($query, $i, 1);
+        $query = $_query;
+        // it works, but i dont like it...
+        $i = 0;
+        while( $i < $strlen) {
+            $c = $query[$i];
+            $tmp = '';
+            // TAG
+            if ($this->isChar($c) || in_array($c, $tagChars)) {
+                while(isset($query[$i])
+                    && ($this->isChar($query[$i]) || in_array($query[$i], $tagChars))) {
+                    $tmp .= $query[$i];
+                    $i++;
+                }
+                $return[] = $tmp;
+            // IDs
+            } else if ( $c == '#') {
+                $i++;
+                while( isset($query[$i]) && ($this->isChar($query[$i]) || $query[$i] == '-')) {
+                    $tmp .= $query[$i];
+                    $i++;
+                }
+                $return[] = '#'.$tmp;
+            // SPECIAL CHARS
+            } else if (in_array($c, $specialChars)) {
+                $return[] = $c;
+                $i++;
+            // MAPPED SPECIAL MULTICHARS
+//          } else if ( $c.$query[$i+1] == '//') {
+//              $return[] = ' ';
+//              $i = $i+2;
+            // MAPPED SPECIAL CHARS
+            } else if ( isset($specialCharsMapping[$c])) {
+                $return[] = $specialCharsMapping[$c];
+                $i++;
+            // COMMA
+            } else if ( $c == ',') {
+                $queries[] = array();
+                $return =& $queries[ count($queries)-1 ];
+                $i++;
+                while( isset($query[$i]) && $query[$i] == ' ')
+                    $i++;
+            // CLASSES
+            } else if ($c == '.') {
+                while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $classChars))) {
+                    $tmp .= $query[$i];
+                    $i++;
+                }
+                $return[] = $tmp;
+            // ~ General Sibling Selector
+            } else if ($c == '~') {
+                $spaceAllowed = true;
+                $tmp .= $query[$i++];
+                while( isset($query[$i])
+                    && ($this->isChar($query[$i])
+                        || in_array($query[$i], $classChars)
+                        || $query[$i] == '*'
+                        || ($query[$i] == ' ' && $spaceAllowed)
+                    )) {
+                    if ($query[$i] != ' ')
+                        $spaceAllowed = false;
+                    $tmp .= $query[$i];
+                    $i++;
+                }
+                $return[] = $tmp;
+            // + Adjacent sibling selectors
+            } else if ($c == '+') {
+                $spaceAllowed = true;
+                $tmp .= $query[$i++];
+                while( isset($query[$i])
+                    && ($this->isChar($query[$i])
+                        || in_array($query[$i], $classChars)
+                        || $query[$i] == '*'
+                        || ($spaceAllowed && $query[$i] == ' ')
+                    )) {
+                    if ($query[$i] != ' ')
+                        $spaceAllowed = false;
+                    $tmp .= $query[$i];
+                    $i++;
+                }
+                $return[] = $tmp;
+            // ATTRS
+            } else if ($c == '[') {
+                $stack = 1;
+                $tmp .= $c;
+                while( isset($query[++$i])) {
+                    $tmp .= $query[$i];
+                    if ( $query[$i] == '[') {
+                        $stack++;
+                    } else if ( $query[$i] == ']') {
+                        $stack--;
+                        if (! $stack )
+                            break;
+                    }
+                }
+                $return[] = $tmp;
+                $i++;
+            // PSEUDO CLASSES
+            } else if ($c == ':') {
+                $stack = 1;
+                $tmp .= $query[$i++];
+                while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $pseudoChars))) {
+                    $tmp .= $query[$i];
+                    $i++;
+                }
+                // with arguments ?
+                if ( isset($query[$i]) && $query[$i] == '(') {
+                    $tmp .= $query[$i];
+                    $stack = 1;
+                    while( isset($query[++$i])) {
+                        $tmp .= $query[$i];
+                        if ( $query[$i] == '(') {
+                            $stack++;
+                        } else if ( $query[$i] == ')') {
+                            $stack--;
+                            if (! $stack )
+                                break;
+                        }
+                    }
+                    $return[] = $tmp;
+                    $i++;
+                } else {
+                    $return[] = $tmp;
+                }
+            } else {
+                $i++;
+            }
+        }
+        foreach($queries as $k => $q) {
+            if (isset($q[0])) {
+                if (isset($q[0][0]) && $q[0][0] == ':')
+                    array_unshift($queries[$k], '*');
+                if ($q[0] != '>')
+                    array_unshift($queries[$k], ' ');
+            }
+        }
+        return $queries;
+    }
+    /**
+     * Return matched DOM nodes.
+     *
+     * @param int $index
+     * @return array|DOMElement Single DOMElement or array of DOMElement.
+     */
+    public function get($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        $return = isset($index)
+            ? (isset($this->elements[$index]) ? $this->elements[$index] : null)
+            : $this->elements;
+        // pass thou callbacks
+        $args = func_get_args();
+        $args = array_slice($args, 1);
+        foreach($args as $callback) {
+            if (is_array($return))
+                foreach($return as $k => $v)
+                    $return[$k] = phpQuery::callbackRun($callback, array($v));
+            else
+                $return = phpQuery::callbackRun($callback, array($return));
+        }
+        return $return;
+    }
+    /**
+     * Return matched DOM nodes.
+     * jQuery difference.
+     *
+     * @param int $index
+     * @return array|string Returns string if $index != null
+     * @todo implement callbacks
+     * @todo return only arrays ?
+     * @todo maybe other name...
+     */
+    public function getString($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        if ($index)
+            $return = $this->eq($index)->text();
+        else {
+            $return = array();
+            for($i = 0; $i < $this->size(); $i++) {
+                $return[] = $this->eq($i)->text();
+            }
+        }
+        // pass thou callbacks
+        $args = func_get_args();
+        $args = array_slice($args, 1);
+        foreach($args as $callback) {
+            $return = phpQuery::callbackRun($callback, array($return));
+        }
+        return $return;
+    }
+    /**
+     * Return matched DOM nodes.
+     * jQuery difference.
+     *
+     * @param int $index
+     * @return array|string Returns string if $index != null
+     * @todo implement callbacks
+     * @todo return only arrays ?
+     * @todo maybe other name...
+     */
+    public function getStrings($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        if ($index)
+            $return = $this->eq($index)->text();
+        else {
+            $return = array();
+            for($i = 0; $i < $this->size(); $i++) {
+                $return[] = $this->eq($i)->text();
+            }
+            // pass thou callbacks
+            $args = func_get_args();
+            $args = array_slice($args, 1);
+        }
+        foreach($args as $callback) {
+            if (is_array($return))
+                foreach($return as $k => $v)
+                    $return[$k] = phpQuery::callbackRun($callback, array($v));
+            else
+                $return = phpQuery::callbackRun($callback, array($return));
+        }
+        return $return;
+    }
+    /**
+     * Returns new instance of actual class.
+     *
+     * @param array $newStack Optional. Will replace old stack with new and move old one to history.c
+     */
+    public function newInstance($newStack = null) {
+        $class = get_class($this);
+        // support inheritance by passing old object to overloaded constructor
+        $new = $class != 'phpQuery'
+            ? new $class($this, $this->getDocumentID())
+            : new phpQueryObject($this->getDocumentID());
+        $new->previous = $this;
+        if (is_null($newStack)) {
+            $new->elements = $this->elements;
+            if ($this->elementsBackup)
+                $this->elements = $this->elementsBackup;
+        } else if (is_string($newStack)) {
+            $new->elements = phpQuery::pq($newStack, $this->getDocumentID())->stack();
+        } else {
+            $new->elements = $newStack;
+        }
+        return $new;
+    }
+    /**
+     * Enter description here...
+     *
+     * In the future, when PHP will support XLS 2.0, then we would do that this way:
+     * contains(tokenize(@class, '\s'), "something")
+     * @param unknown_type $class
+     * @param unknown_type $node
+     * @return boolean
+     * @access private
+     */
+    protected function matchClasses($class, $node) {
+        // multi-class
+        if ( mb_strpos($class, '.', 1)) {
+            $classes = explode('.', substr($class, 1));
+            $classesCount = count( $classes );
+            $nodeClasses = explode(' ', $node->getAttribute('class') );
+            $nodeClassesCount = count( $nodeClasses );
+            if ( $classesCount > $nodeClassesCount )
+                return false;
+            $diff = count(
+                array_diff(
+                    $classes,
+                    $nodeClasses
+                )
+            );
+            if (! $diff )
+                return true;
+        // single-class
+        } else {
+            return in_array(
+                // strip leading dot from class name
+                substr($class, 1),
+                // get classes for element as array
+                explode(' ', $node->getAttribute('class') )
+            );
+        }
+    }
+    /**
+     * @access private
+     */
+    protected function runQuery($XQuery, $selector = null, $compare = null) {
+        if ($compare && ! method_exists($this, $compare))
+            return false;
+        $stack = array();
+        if (! $this->elements)
+            $this->debug('Stack empty, skipping...');
+//      var_dump($this->elements[0]->nodeType);
+        // element, document
+        foreach($this->stack(array(1, 9, 13)) as $k => $stackNode) {
+            $detachAfter = false;
+            // to work on detached nodes we need temporary place them somewhere
+            // thats because context xpath queries sucks ;]
+            $testNode = $stackNode;
+            while ($testNode) {
+                if (! $testNode->parentNode && ! $this->isRoot($testNode)) {
+                    $this->root->appendChild($testNode);
+                    $detachAfter = $testNode;
+                    break;
+                }
+                $testNode = isset($testNode->parentNode)
+                    ? $testNode->parentNode
+                    : null;
+            }
+            // XXX tmp ?
+            $xpath = $this->documentWrapper->isXHTML
+                ? $this->getNodeXpath($stackNode, 'html')
+                : $this->getNodeXpath($stackNode);
+            // FIXME pseudoclasses-only query, support XML
+            $query = $XQuery == '//' && $xpath == '/html[1]'
+                ? '//*'
+                : $xpath.$XQuery;
+            $this->debug("XPATH: {$query}");
+            // run query, get elements
+            $nodes = $this->xpath->query($query);
+            $this->debug("QUERY FETCHED");
+            if (! $nodes->length )
+                $this->debug('Nothing found');
+            $debug = array();
+            foreach($nodes as $node) {
+                $matched = false;
+                if ( $compare) {
+                    phpQuery::$debug ?
+                        $this->debug("Found: ".$this->whois( $node ).", comparing with {$compare}()")
+                        : null;
+                    $phpQueryDebug = phpQuery::$debug;
+                    phpQuery::$debug = false;
+                    // TODO ??? use phpQuery::callbackRun()
+                    if (call_user_func_array(array($this, $compare), array($selector, $node)))
+                        $matched = true;
+                    phpQuery::$debug = $phpQueryDebug;
+                } else {
+                    $matched = true;
+                }
+                if ( $matched) {
+                    if (phpQuery::$debug)
+                        $debug[] = $this->whois( $node );
+                    $stack[] = $node;
+                }
+            }
+            if (phpQuery::$debug) {
+                $this->debug("Matched ".count($debug).": ".implode(', ', $debug));
+            }
+            if ($detachAfter)
+                $this->root->removeChild($detachAfter);
+        }
+        $this->elements = $stack;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function find($selectors, $context = null, $noHistory = false) {
+        if (!$noHistory)
+            // backup last stack /for end()/
+            $this->elementsBackup = $this->elements;
+        // allow to define context
+        // TODO combine code below with phpQuery::pq() context guessing code
+        //   as generic function
+        if ($context) {
+            if (! is_array($context) && $context instanceof DOMELEMENT)
+                $this->elements = array($context);
+            else if (is_array($context)) {
+                $this->elements = array();
+                foreach ($context as $c)
+                    if ($c instanceof DOMELEMENT)
+                        $this->elements[] = $c;
+            } else if ( $context instanceof self )
+                $this->elements = $context->elements;
+        }
+        $queries = $this->parseSelector($selectors);
+        $this->debug(array('FIND', $selectors, $queries));
+        $XQuery = '';
+        // remember stack state because of multi-queries
+        $oldStack = $this->elements;
+        // here we will be keeping found elements
+        $stack = array();
+        foreach($queries as $selector) {
+            $this->elements = $oldStack;
+            $delimiterBefore = false;
+            foreach($selector as $s) {
+                // TAG
+                $isTag = extension_loaded('mbstring') && phpQuery::$mbstringSupport
+                    ? mb_ereg_match('^[\w|\||-]+$', $s) || $s == '*'
+                    : preg_match('@^[\w|\||-]+$@', $s) || $s == '*';
+                if ($isTag) {
+                    if ($this->isXML()) {
+                        // namespace support
+                        if (mb_strpos($s, '|') !== false) {
+                            $ns = $tag = null;
+                            list($ns, $tag) = explode('|', $s);
+                            $XQuery .= "$ns:$tag";
+                        } else if ($s == '*') {
+                            $XQuery .= "*";
+                        } else {
+                            $XQuery .= "*[local-name()='$s']";
+                        }
+                    } else {
+                        $XQuery .= $s;
+                    }
+                // ID
+                } else if ($s[0] == '#') {
+                    if ($delimiterBefore)
+                        $XQuery .= '*';
+                    $XQuery .= "[@id='".substr($s, 1)."']";
+                // ATTRIBUTES
+                } else if ($s[0] == '[') {
+                    if ($delimiterBefore)
+                        $XQuery .= '*';
+                    // strip side brackets
+                    $attr = trim($s, '][');
+                    $execute = false;
+                    // attr with specifed value
+                    if (mb_strpos($s, '=')) {
+                        $value = null;
+                        list($attr, $value) = explode('=', $attr);
+                        $value = trim($value, "'\"");
+                        if ($this->isRegexp($attr)) {
+                            // cut regexp character
+                            $attr = substr($attr, 0, -1);
+                            $execute = true;
+                            $XQuery .= "[@{$attr}]";
+                        } else {
+                            $XQuery .= "[@{$attr}='{$value}']";
+                        }
+                    // attr without specified value
+                    } else {
+                        $XQuery .= "[@{$attr}]";
+                    }
+                    if ($execute) {
+                        $this->runQuery($XQuery, $s, 'is');
+                        $XQuery = '';
+                        if (! $this->length())
+                            break;
+                    }
+                // CLASSES
+                } else if ($s[0] == '.') {
+                    // TODO use return $this->find("./self::*[contains(concat(\" \",@class,\" \"), \" $class \")]");
+                    // thx wizDom ;)
+                    if ($delimiterBefore)
+                        $XQuery .= '*';
+                    $XQuery .= '[@class]';
+                    $this->runQuery($XQuery, $s, 'matchClasses');
+                    $XQuery = '';
+                    if (! $this->length() )
+                        break;
+                // ~ General Sibling Selector
+                } else if ($s[0] == '~') {
+                    $this->runQuery($XQuery);
+                    $XQuery = '';
+                    $this->elements = $this
+                        ->siblings(
+                            substr($s, 1)
+                        )->elements;
+                    if (! $this->length() )
+                        break;
+                // + Adjacent sibling selectors
+                } else if ($s[0] == '+') {
+                    // TODO /following-sibling::
+                    $this->runQuery($XQuery);
+                    $XQuery = '';
+                    $subSelector = substr($s, 1);
+                    $subElements = $this->elements;
+                    $this->elements = array();
+                    foreach($subElements as $node) {
+                        // search first DOMElement sibling
+                        $test = $node->nextSibling;
+                        while($test && ! ($test instanceof DOMELEMENT))
+                            $test = $test->nextSibling;
+                        if ($test && $this->is($subSelector, $test))
+                            $this->elements[] = $test;
+                    }
+                    if (! $this->length() )
+                        break;
+                // PSEUDO CLASSES
+                } else if ($s[0] == ':') {
+                    // TODO optimization for :first :last
+                    if ($XQuery) {
+                        $this->runQuery($XQuery);
+                        $XQuery = '';
+                    }
+                    if (! $this->length())
+                        break;
+                    $this->pseudoClasses($s);
+                    if (! $this->length())
+                        break;
+                // DIRECT DESCENDANDS
+                } else if ($s == '>') {
+                    $XQuery .= '/';
+                    $delimiterBefore = 2;
+                // ALL DESCENDANDS
+                } else if ($s == ' ') {
+                    $XQuery .= '//';
+                    $delimiterBefore = 2;
+                // ERRORS
+                } else {
+                    phpQuery::debug("Unrecognized token '$s'");
+                }
+                $delimiterBefore = $delimiterBefore === 2;
+            }
+            // run query if any
+            if ($XQuery && $XQuery != '//') {
+                $this->runQuery($XQuery);
+                $XQuery = '';
+            }
+            foreach($this->elements as $node)
+                if (! $this->elementsContainsNode($node, $stack))
+                    $stack[] = $node;
+        }
+        $this->elements = $stack;
+        return $this->newInstance();
+    }
+    /**
+     * @todo create API for classes with pseudoselectors
+     * @access private
+     */
+    protected function pseudoClasses($class) {
+        // TODO clean args parsing ?
+        $class = ltrim($class, ':');
+        $haveArgs = mb_strpos($class, '(');
+        if ($haveArgs !== false) {
+            $args = substr($class, $haveArgs+1, -1);
+            $class = substr($class, 0, $haveArgs);
+        }
+        switch($class) {
+            case 'even':
+            case 'odd':
+                $stack = array();
+                foreach($this->elements as $i => $node) {
+                    if ($class == 'even' && ($i%2) == 0)
+                        $stack[] = $node;
+                    else if ( $class == 'odd' && $i % 2 )
+                        $stack[] = $node;
+                }
+                $this->elements = $stack;
+                break;
+            case 'eq':
+                $k = intval($args);
+                $this->elements = isset( $this->elements[$k] )
+                    ? array( $this->elements[$k] )
+                    : array();
+                break;
+            case 'gt':
+                $this->elements = array_slice($this->elements, $args+1);
+                break;
+            case 'lt':
+                $this->elements = array_slice($this->elements, 0, $args+1);
+                break;
+            case 'first':
+                if (isset($this->elements[0]))
+                    $this->elements = array($this->elements[0]);
+                break;
+            case 'last':
+                if ($this->elements)
+                    $this->elements = array($this->elements[count($this->elements)-1]);
+                break;
+            /*case 'parent':
+                $stack = array();
+                foreach($this->elements as $node) {
+                    if ( $node->childNodes->length )
+                        $stack[] = $node;
+                }
+                $this->elements = $stack;
+                break;*/
+            case 'contains':
+                $text = trim($args, "\"'");
+                $stack = array();
+                foreach($this->elements as $node) {
+                    if (mb_stripos($node->textContent, $text) === false)
+                        continue;
+                    $stack[] = $node;
+                }
+                $this->elements = $stack;
+                break;
+            case 'not':
+                $selector = self::unQuote($args);
+                $this->elements = $this->not($selector)->stack();
+                break;
+            case 'slice':
+                // TODO jQuery difference ?
+                $args = explode(',',
+                    str_replace(', ', ',', trim($args, "\"'"))
+                );
+                $start = $args[0];
+                $end = isset($args[1])
+                    ? $args[1]
+                    : null;
+                if ($end > 0)
+                    $end = $end-$start;
+                $this->elements = array_slice($this->elements, $start, $end);
+                break;
+            case 'has':
+                $selector = trim($args, "\"'");
+                $stack = array();
+                foreach($this->stack(1) as $el) {
+                    if ($this->find($selector, $el, true)->length)
+                        $stack[] = $el;
+                }
+                $this->elements = $stack;
+                break;
+            case 'submit':
+            case 'reset':
+                $this->elements = phpQuery::merge(
+                    $this->map(array($this, 'is'),
+                        "input[type=$class]", new CallbackParam()
+                    ),
+                    $this->map(array($this, 'is'),
+                        "button[type=$class]", new CallbackParam()
+                    )
+                );
+            break;
+//              $stack = array();
+//              foreach($this->elements as $node)
+//                  if ($node->is('input[type=submit]') || $node->is('button[type=submit]'))
+//                      $stack[] = $el;
+//              $this->elements = $stack;
+            case 'input':
+                $this->elements = $this->map(
+                    array($this, 'is'),
+                    'input', new CallbackParam()
+                )->elements;
+            break;
+            case 'password':
+            case 'checkbox':
+            case 'radio':
+            case 'hidden':
+            case 'image':
+            case 'file':
+                $this->elements = $this->map(
+                    array($this, 'is'),
+                    "input[type=$class]", new CallbackParam()
+                )->elements;
+            break;
+            case 'parent':
+                $this->elements = $this->map(
+                    create_function('$node', '
+                        return $node instanceof DOMELEMENT && $node->childNodes->length
+                            ? $node : null;')
+                )->elements;
+            break;
+            case 'empty':
+                $this->elements = $this->map(
+                    create_function('$node', '
+                        return $node instanceof DOMELEMENT && $node->childNodes->length
+                            ? null : $node;')
+                )->elements;
+            break;
+            case 'disabled':
+            case 'selected':
+            case 'checked':
+                $this->elements = $this->map(
+                    array($this, 'is'),
+                    "[$class]", new CallbackParam()
+                )->elements;
+            break;
+            case 'enabled':
+                $this->elements = $this->map(
+                    create_function('$node', '
+                        return pq($node)->not(":disabled") ? $node : null;')
+                )->elements;
+            break;
+            case 'header':
+                $this->elements = $this->map(
+                    create_function('$node',
+                        '$isHeader = isset($node->tagName) && in_array($node->tagName, array(
+                            "h1", "h2", "h3", "h4", "h5", "h6", "h7"
+                        ));
+                        return $isHeader
+                            ? $node
+                            : null;')
+                )->elements;
+//              $this->elements = $this->map(
+//                  create_function('$node', '$node = pq($node);
+//                      return $node->is("h1")
+//                          || $node->is("h2")
+//                          || $node->is("h3")
+//                          || $node->is("h4")
+//                          || $node->is("h5")
+//                          || $node->is("h6")
+//                          || $node->is("h7")
+//                          ? $node
+//                          : null;')
+//              )->elements;
+            break;
+            case 'only-child':
+                $this->elements = $this->map(
+                    create_function('$node',
+                        'return pq($node)->siblings()->size() == 0 ? $node : null;')
+                )->elements;
+            break;
+            case 'first-child':
+                $this->elements = $this->map(
+                    create_function('$node', 'return pq($node)->prevAll()->size() == 0 ? $node : null;')
+                )->elements;
+            break;
+            case 'last-child':
+                $this->elements = $this->map(
+                    create_function('$node', 'return pq($node)->nextAll()->size() == 0 ? $node : null;')
+                )->elements;
+            break;
+            case 'nth-child':
+                $param = trim($args, "\"'");
+                if (! $param)
+                    break;
+                    // nth-child(n+b) to nth-child(1n+b)
+                if ($param{0} == 'n')
+                    $param = '1'.$param;
+                // :nth-child(index/even/odd/equation)
+                if ($param == 'even' || $param == 'odd')
+                    $mapped = $this->map(
+                        create_function('$node, $param',
+                            '$index = pq($node)->prevAll()->size()+1;
+                            if ($param == "even" && ($index%2) == 0)
+                                return $node;
+                            else if ($param == "odd" && $index%2 == 1)
+                                return $node;
+                            else
+                                return null;'),
+                        new CallbackParam(), $param
+                    );
+                else if (mb_strlen($param) > 1 && $param{1} == 'n')
+                    // an+b
+                    $mapped = $this->map(
+                        create_function('$node, $param',
+                            '$prevs = pq($node)->prevAll()->size();
+                            $index = 1+$prevs;
+                            $b = mb_strlen($param) > 3
+                                ? $param{3}
+                                : 0;
+                            $a = $param{0};
+                            if ($b && $param{2} == "-")
+                                $b = -$b;
+                            if ($a > 0) {
+                                return ($index-$b)%$a == 0
+                                    ? $node
+                                    : null;
+                                phpQuery::debug($a."*".floor($index/$a)."+$b-1 == ".($a*floor($index/$a)+$b-1)." ?= $prevs");
+                                return $a*floor($index/$a)+$b-1 == $prevs
+                                        ? $node
+                                        : null;
+                            } else if ($a == 0)
+                                return $index == $b
+                                        ? $node
+                                        : null;
+                            else
+                                // negative value
+                                return $index <= $b
+                                        ? $node
+                                        : null;
+//                          if (! $b)
+//                              return $index%$a == 0
+//                                  ? $node
+//                                  : null;
+//                          else
+//                              return ($index-$b)%$a == 0
+//                                  ? $node
+//                                  : null;
+                            '),
+                        new CallbackParam(), $param
+                    );
+                else
+                    // index
+                    $mapped = $this->map(
+                        create_function('$node, $index',
+                            '$prevs = pq($node)->prevAll()->size();
+                            if ($prevs && $prevs == $index-1)
+                                return $node;
+                            else if (! $prevs && $index == 1)
+                                return $node;
+                            else
+                                return null;'),
+                        new CallbackParam(), $param
+                    );
+                $this->elements = $mapped->elements;
+            break;
+            default:
+                $this->debug("Unknown pseudoclass '{$class}', skipping...");
+        }
+    }
+    /**
+     * @access private
+     */
+    protected function __pseudoClassParam($paramsString) {
+        // TODO;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function is($selector, $nodes = null) {
+        phpQuery::debug(array("Is:", $selector));
+        if (! $selector)
+            return false;
+        $oldStack = $this->elements;
+        $returnArray = false;
+        if ($nodes && is_array($nodes)) {
+            $this->elements = $nodes;
+        } else if ($nodes)
+            $this->elements = array($nodes);
+        $this->filter($selector, true);
+        $stack = $this->elements;
+        $this->elements = $oldStack;
+        if ($nodes)
+            return $stack ? $stack : null;
+        return (bool)count($stack);
+    }
+    /**
+     * Enter description here...
+     * jQuery difference.
+     *
+     * Callback:
+     * - $index int
+     * - $node DOMNode
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @link http://docs.jquery.com/Traversing/filter
+     */
+    public function filterCallback($callback, $_skipHistory = false) {
+        if (! $_skipHistory) {
+            $this->elementsBackup = $this->elements;
+            $this->debug("Filtering by callback");
+        }
+        $newStack = array();
+        foreach($this->elements as $index => $node) {
+            $result = phpQuery::callbackRun($callback, array($index, $node));
+            if (is_null($result) || (! is_null($result) && $result))
+                $newStack[] = $node;
+        }
+        $this->elements = $newStack;
+        return $_skipHistory
+            ? $this
+            : $this->newInstance();
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @link http://docs.jquery.com/Traversing/filter
+     */
+    public function filter($selectors, $_skipHistory = false) {
+        if ($selectors instanceof Callback OR $selectors instanceof Closure)
+            return $this->filterCallback($selectors, $_skipHistory);
+        if (! $_skipHistory)
+            $this->elementsBackup = $this->elements;
+        $notSimpleSelector = array(' ', '>', '~', '+', '/');
+        if (! is_array($selectors))
+            $selectors = $this->parseSelector($selectors);
+        if (! $_skipHistory)
+            $this->debug(array("Filtering:", $selectors));
+        $finalStack = array();
+        foreach($selectors as $selector) {
+            $stack = array();
+            if (! $selector)
+                break;
+            // avoid first space or /
+            if (in_array($selector[0], $notSimpleSelector))
+                $selector = array_slice($selector, 1);
+            // PER NODE selector chunks
+            foreach($this->stack() as $node) {
+                $break = false;
+                foreach($selector as $s) {
+                    if (!($node instanceof DOMELEMENT)) {
+                        // all besides DOMElement
+                        if ( $s[0] == '[') {
+                            $attr = trim($s, '[]');
+                            if ( mb_strpos($attr, '=')) {
+                                list( $attr, $val ) = explode('=', $attr);
+                                if ($attr == 'nodeType' && $node->nodeType != $val)
+                                    $break = true;
+                            }
+                        } else
+                            $break = true;
+                    } else {
+                        // DOMElement only
+                        // ID
+                        if ( $s[0] == '#') {
+                            if ( $node->getAttribute('id') != substr($s, 1) )
+                                $break = true;
+                        // CLASSES
+                        } else if ( $s[0] == '.') {
+                            if (! $this->matchClasses( $s, $node ) )
+                                $break = true;
+                        // ATTRS
+                        } else if ( $s[0] == '[') {
+                            // strip side brackets
+                            $attr = trim($s, '[]');
+                            if (mb_strpos($attr, '=')) {
+                                list($attr, $val) = explode('=', $attr);
+                                $val = self::unQuote($val);
+                                if ($attr == 'nodeType') {
+                                    if ($val != $node->nodeType)
+                                        $break = true;
+                                } else if ($this->isRegexp($attr)) {
+                                    $val = extension_loaded('mbstring') && phpQuery::$mbstringSupport
+                                        ? quotemeta(trim($val, '"\''))
+                                        : preg_quote(trim($val, '"\''), '@');
+                                    // switch last character
+                                    switch( substr($attr, -1)) {
+                                        // quotemeta used insted of preg_quote
+                                        // http://code.google.com/p/phpquery/issues/detail?id=76
+                                        case '^':
+                                            $pattern = '^'.$val;
+                                            break;
+                                        case '*':
+                                            $pattern = '.*'.$val.'.*';
+                                            break;
+                                        case '$':
+                                            $pattern = '.*'.$val.'$';
+                                            break;
+                                    }
+                                    // cut last character
+                                    $attr = substr($attr, 0, -1);
+                                    $isMatch = extension_loaded('mbstring') && phpQuery::$mbstringSupport
+                                        ? mb_ereg_match($pattern, $node->getAttribute($attr))
+                                        : preg_match("@{$pattern}@", $node->getAttribute($attr));
+                                    if (! $isMatch)
+                                        $break = true;
+                                } else if ($node->getAttribute($attr) != $val)
+                                    $break = true;
+                            } else if (! $node->hasAttribute($attr))
+                                $break = true;
+                        // PSEUDO CLASSES
+                        } else if ( $s[0] == ':') {
+                            // skip
+                        // TAG
+                        } else if (trim($s)) {
+                            if ($s != '*') {
+                                // TODO namespaces
+                                if (isset($node->tagName)) {
+                                    if ($node->tagName != $s)
+                                        $break = true;
+                                } else if ($s == 'html' && ! $this->isRoot($node))
+                                    $break = true;
+                            }
+                        // AVOID NON-SIMPLE SELECTORS
+                        } else if (in_array($s, $notSimpleSelector)) {
+                            $break = true;
+                            $this->debug(array('Skipping non simple selector', $selector));
+                        }
+                    }
+                    if ($break)
+                        break;
+                }
+                // if element passed all chunks of selector - add it to new stack
+                if (! $break )
+                    $stack[] = $node;
+            }
+            $tmpStack = $this->elements;
+            $this->elements = $stack;
+            // PER ALL NODES selector chunks
+            foreach($selector as $s)
+                // PSEUDO CLASSES
+                if ($s[0] == ':')
+                    $this->pseudoClasses($s);
+            foreach($this->elements as $node)
+                // XXX it should be merged without duplicates
+                // but jQuery doesnt do that
+                $finalStack[] = $node;
+            $this->elements = $tmpStack;
+        }
+        $this->elements = $finalStack;
+        if ($_skipHistory) {
+            return $this;
+        } else {
+            $this->debug("Stack length after filter(): ".count($finalStack));
+            return $this->newInstance();
+        }
+    }
+    /**
+     *
+     * @param $value
+     * @return unknown_type
+     * @TODO implement in all methods using passed parameters
+     */
+    protected static function unQuote($value) {
+        return $value[0] == '\'' || $value[0] == '"'
+            ? substr($value, 1, -1)
+            : $value;
+    }
+    /**
+     * Enter description here...
+     *
+     * @link http://docs.jquery.com/Ajax/load
+     * @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo Support $selector
+     */
+    public function load($url, $data = null, $callback = null) {
+        if ($data && ! is_array($data)) {
+            $callback = $data;
+            $data = null;
+        }
+        if (mb_strpos($url, ' ') !== false) {
+            $matches = null;
+            if (extension_loaded('mbstring') && phpQuery::$mbstringSupport)
+                mb_ereg('^([^ ]+) (.*)$', $url, $matches);
+            else
+                preg_match('^([^ ]+) (.*)$', $url, $matches);
+            $url = $matches[1];
+            $selector = $matches[2];
+            // FIXME this sucks, pass as callback param
+            $this->_loadSelector = $selector;
+        }
+        $ajax = array(
+            'url' => $url,
+            'type' => $data ? 'POST' : 'GET',
+            'data' => $data,
+            'complete' => $callback,
+            'success' => array($this, '__loadSuccess')
+        );
+        phpQuery::ajax($ajax);
+        return $this;
+    }
+    /**
+     * @access private
+     * @param $html
+     * @return unknown_type
+     */
+    public function __loadSuccess($html) {
+        if ($this->_loadSelector) {
+            $html = phpQuery::newDocument($html)->find($this->_loadSelector);
+            unset($this->_loadSelector);
+        }
+        foreach($this->stack(1) as $node) {
+            phpQuery::pq($node, $this->getDocumentID())
+                ->markup($html);
+        }
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo
+     */
+    public function css() {
+        // TODO
+        return $this;
+    }
+    /**
+     * @todo
+     *
+     */
+    public function show(){
+        // TODO
+        return $this;
+    }
+    /**
+     * @todo
+     *
+     */
+    public function hide(){
+        // TODO
+        return $this;
+    }
+    /**
+     * Trigger a type of event on every matched element.
+     *
+     * @param unknown_type $type
+     * @param unknown_type $data
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @TODO support more than event in $type (space-separated)
+     */
+    public function trigger($type, $data = array()) {
+        foreach($this->elements as $node)
+            phpQueryEvents::trigger($this->getDocumentID(), $type, $data, $node);
+        return $this;
+    }
+    /**
+     * This particular method triggers all bound event handlers on an element (for a specific event type) WITHOUT executing the browsers default actions.
+     *
+     * @param unknown_type $type
+     * @param unknown_type $data
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @TODO
+     */
+    public function triggerHandler($type, $data = array()) {
+        // TODO;
+    }
+    /**
+     * Binds a handler to one or more events (like click) for each matched element.
+     * Can also bind custom events.
+     *
+     * @param unknown_type $type
+     * @param unknown_type $data Optional
+     * @param unknown_type $callback
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @TODO support '!' (exclusive) events
+     * @TODO support more than event in $type (space-separated)
+     */
+    public function bind($type, $data, $callback = null) {
+        // TODO check if $data is callable, not using is_callable
+        if (! isset($callback)) {
+            $callback = $data;
+            $data = null;
+        }
+        foreach($this->elements as $node)
+            phpQueryEvents::add($this->getDocumentID(), $node, $type, $data, $callback);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param unknown_type $type
+     * @param unknown_type $callback
+     * @return unknown
+     * @TODO namespace events
+     * @TODO support more than event in $type (space-separated)
+     */
+    public function unbind($type = null, $callback = null) {
+        foreach($this->elements as $node)
+            phpQueryEvents::remove($this->getDocumentID(), $node, $type, $callback);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function change($callback = null) {
+        if ($callback)
+            return $this->bind('change', $callback);
+        return $this->trigger('change');
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function submit($callback = null) {
+        if ($callback)
+            return $this->bind('submit', $callback);
+        return $this->trigger('submit');
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function click($callback = null) {
+        if ($callback)
+            return $this->bind('click', $callback);
+        return $this->trigger('click');
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrapAllOld($wrapper) {
+        $wrapper = pq($wrapper)->_clone();
+        if (! $wrapper->length() || ! $this->length() )
+            return $this;
+        $wrapper->insertBefore($this->elements[0]);
+        $deepest = $wrapper->elements[0];
+        while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
+            $deepest = $deepest->firstChild;
+        pq($deepest)->append($this);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * TODO testme...
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrapAll($wrapper) {
+        if (! $this->length())
+            return $this;
+        return phpQuery::pq($wrapper, $this->getDocumentID())
+            ->clone()
+            ->insertBefore($this->get(0))
+            ->map(array($this, '___wrapAllCallback'))
+            ->append($this);
+    }
+  /**
+   *
+     * @param $node
+     * @return unknown_type
+     * @access private
+   */
+    public function ___wrapAllCallback($node) {
+        $deepest = $node;
+        while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
+            $deepest = $deepest->firstChild;
+        return $deepest;
+    }
+    /**
+     * Enter description here...
+     * NON JQUERY METHOD
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrapAllPHP($codeBefore, $codeAfter) {
+        return $this
+            ->slice(0, 1)
+                ->beforePHP($codeBefore)
+            ->end()
+            ->slice(-1)
+                ->afterPHP($codeAfter)
+            ->end();
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrap($wrapper) {
+        foreach($this->stack() as $node)
+            phpQuery::pq($node, $this->getDocumentID())->wrapAll($wrapper);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrapPHP($codeBefore, $codeAfter) {
+        foreach($this->stack() as $node)
+            phpQuery::pq($node, $this->getDocumentID())->wrapAllPHP($codeBefore, $codeAfter);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrapInner($wrapper) {
+        foreach($this->stack() as $node)
+            phpQuery::pq($node, $this->getDocumentID())->contents()->wrapAll($wrapper);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function wrapInnerPHP($codeBefore, $codeAfter) {
+        foreach($this->stack(1) as $node)
+            phpQuery::pq($node, $this->getDocumentID())->contents()
+                ->wrapAllPHP($codeBefore, $codeAfter);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @testme Support for text nodes
+     */
+    public function contents() {
+        $stack = array();
+        foreach($this->stack(1) as $el) {
+            // FIXME (fixed) http://code.google.com/p/phpquery/issues/detail?id=56
+//          if (! isset($el->childNodes))
+//              continue;
+            foreach($el->childNodes as $node) {
+                $stack[] = $node;
+            }
+        }
+        return $this->newInstance($stack);
+    }
+    /**
+     * Enter description here...
+     *
+     * jQuery difference.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function contentsUnwrap() {
+        foreach($this->stack(1) as $node) {
+            if (! $node->parentNode )
+                continue;
+            $childNodes = array();
+            // any modification in DOM tree breaks childNodes iteration, so cache them first
+            foreach($node->childNodes as $chNode )
+                $childNodes[] = $chNode;
+            foreach($childNodes as $chNode )
+//              $node->parentNode->appendChild($chNode);
+                $node->parentNode->insertBefore($chNode, $node);
+            $node->parentNode->removeChild($node);
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * jQuery difference.
+     */
+    public function switchWith($markup) {
+        $markup = pq($markup, $this->getDocumentID());
+        $content = null;
+        foreach($this->stack(1) as $node) {
+            pq($node)
+                ->contents()->toReference($content)->end()
+                ->replaceWith($markup->clone()->append($content));
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function eq($num) {
+        $oldStack = $this->elements;
+        $this->elementsBackup = $this->elements;
+        $this->elements = array();
+        if ( isset($oldStack[$num]) )
+            $this->elements[] = $oldStack[$num];
+        return $this->newInstance();
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function size() {
+        return count($this->elements);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @deprecated Use length as attribute
+     */
+    public function length() {
+        return $this->size();
+    }
+    public function count() {
+        return $this->size();
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo $level
+     */
+    public function end($level = 1) {
+//      $this->elements = array_pop( $this->history );
+//      return $this;
+//      $this->previous->DOM = $this->DOM;
+//      $this->previous->XPath = $this->XPath;
+        return $this->previous
+            ? $this->previous
+            : $this;
+    }
+    /**
+     * Enter description here...
+     * Normal use ->clone() .
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @access private
+     */
+    public function _clone() {
+        $newStack = array();
+        //pr(array('copy... ', $this->whois()));
+        //$this->dumpHistory('copy');
+        $this->elementsBackup = $this->elements;
+        foreach($this->elements as $node) {
+            $newStack[] = $node->cloneNode(true);
+        }
+        $this->elements = $newStack;
+        return $this->newInstance();
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function replaceWithPHP($code) {
+        return $this->replaceWith(phpQuery::php($code));
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery $content
+     * @link http://docs.jquery.com/Manipulation/replaceWith#content
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function replaceWith($content) {
+        return $this->after($content)->remove();
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String $selector
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo this works ?
+     */
+    public function replaceAll($selector) {
+        foreach(phpQuery::pq($selector, $this->getDocumentID()) as $node)
+            phpQuery::pq($node, $this->getDocumentID())
+                ->after($this->_clone())
+                ->remove();
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function remove($selector = null) {
+        $loop = $selector
+            ? $this->filter($selector)->elements
+            : $this->elements;
+        foreach($loop as $node) {
+            if (! $node->parentNode )
+                continue;
+            if (isset($node->tagName))
+                $this->debug("Removing '{$node->tagName}'");
+            $node->parentNode->removeChild($node);
+            // Mutation event
+            $event = new DOMEvent(array(
+                'target' => $node,
+                'type' => 'DOMNodeRemoved'
+            ));
+            phpQueryEvents::trigger($this->getDocumentID(),
+                $event->type, array($event), $node
+            );
+        }
+        return $this;
+    }
+    protected function markupEvents($newMarkup, $oldMarkup, $node) {
+        if ($node->tagName == 'textarea' && $newMarkup != $oldMarkup) {
+            $event = new DOMEvent(array(
+                'target' => $node,
+                'type' => 'change'
+            ));
+            phpQueryEvents::trigger($this->getDocumentID(),
+                $event->type, array($event), $node
+            );
+        }
+    }
+    /**
+     * jQuey difference
+     *
+     * @param $markup
+     * @return unknown_type
+     * @TODO trigger change event for textarea
+     */
+    public function markup($markup = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        $args = func_get_args();
+        if ($this->documentWrapper->isXML)
+            return call_user_func_array(array($this, 'xml'), $args);
+        else
+            return call_user_func_array(array($this, 'html'), $args);
+    }
+    /**
+     * jQuey difference
+     *
+     * @param $markup
+     * @return unknown_type
+     */
+    public function markupOuter($callback1 = null, $callback2 = null, $callback3 = null) {
+        $args = func_get_args();
+        if ($this->documentWrapper->isXML)
+            return call_user_func_array(array($this, 'xmlOuter'), $args);
+        else
+            return call_user_func_array(array($this, 'htmlOuter'), $args);
+    }
+    /**
+     * Enter description here...
+     *
+     * @param unknown_type $html
+     * @return string|phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @TODO force html result
+     */
+    public function html($html = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        if (isset($html)) {
+            // INSERT
+            $nodes = $this->documentWrapper->import($html);
+            $this->empty();
+            foreach($this->stack(1) as $alreadyAdded => $node) {
+                // for now, limit events for textarea
+                if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
+                    $oldHtml = pq($node, $this->getDocumentID())->markup();
+                foreach($nodes as $newNode) {
+                    $node->appendChild($alreadyAdded
+                        ? $newNode->cloneNode(true)
+                        : $newNode
+                    );
+                }
+                // for now, limit events for textarea
+                if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
+                    $this->markupEvents($html, $oldHtml, $node);
+            }
+            return $this;
+        } else {
+            // FETCH
+            $return = $this->documentWrapper->markup($this->elements, true);
+            $args = func_get_args();
+            foreach(array_slice($args, 1) as $callback) {
+                $return = phpQuery::callbackRun($callback, array($return));
+            }
+            return $return;
+        }
+    }
+    /**
+     * @TODO force xml result
+     */
+    public function xml($xml = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        $args = func_get_args();
+        return call_user_func_array(array($this, 'html'), $args);
+    }
+    /**
+     * Enter description here...
+     * @TODO force html result
+     *
+     * @return String
+     */
+    public function htmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
+        $markup = $this->documentWrapper->markup($this->elements);
+        // pass thou callbacks
+        $args = func_get_args();
+        foreach($args as $callback) {
+            $markup = phpQuery::callbackRun($callback, array($markup));
+        }
+        return $markup;
+    }
+    /**
+     * @TODO force xml result
+     */
+    public function xmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
+        $args = func_get_args();
+        return call_user_func_array(array($this, 'htmlOuter'), $args);
+    }
+    public function __toString() {
+        return $this->markupOuter();
+    }
+    /**
+     * Just like html(), but returns markup with VALID (dangerous) PHP tags.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo support returning markup with PHP tags when called without param
+     */
+    public function php($code = null) {
+        return $this->markupPHP($code);
+    }
+    /**
+     * Enter description here...
+     *
+     * @param $code
+     * @return unknown_type
+     */
+    public function markupPHP($code = null) {
+        return isset($code)
+            ? $this->markup(phpQuery::php($code))
+            : phpQuery::markupToPHP($this->markup());
+    }
+    /**
+     * Enter description here...
+     *
+     * @param $code
+     * @return unknown_type
+     */
+    public function markupOuterPHP() {
+        return phpQuery::markupToPHP($this->markupOuter());
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function children($selector = null) {
+        $stack = array();
+        foreach($this->stack(1) as $node) {
+//          foreach($node->getElementsByTagName('*') as $newNode) {
+            foreach($node->childNodes as $newNode) {
+                if ($newNode->nodeType != 1)
+                    continue;
+                if ($selector && ! $this->is($selector, $newNode))
+                    continue;
+                if ($this->elementsContainsNode($newNode, $stack))
+                    continue;
+                $stack[] = $newNode;
+            }
+        }
+        $this->elementsBackup = $this->elements;
+        $this->elements = $stack;
+        return $this->newInstance();
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function ancestors($selector = null) {
+        return $this->children( $selector );
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function append( $content) {
+        return $this->insert($content, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function appendPHP( $content) {
+        return $this->insert("<php><!-- {$content} --></php>", 'append');
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function appendTo( $seletor) {
+        return $this->insert($seletor, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function prepend( $content) {
+        return $this->insert($content, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @todo accept many arguments, which are joined, arrays maybe also
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function prependPHP( $content) {
+        return $this->insert("<php><!-- {$content} --></php>", 'prepend');
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function prependTo( $seletor) {
+        return $this->insert($seletor, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function before($content) {
+        return $this->insert($content, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function beforePHP( $content) {
+        return $this->insert("<php><!-- {$content} --></php>", 'before');
+    }
+    /**
+     * Enter description here...
+     *
+     * @param String|phpQuery
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function insertBefore( $seletor) {
+        return $this->insert($seletor, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function after( $content) {
+        return $this->insert($content, __FUNCTION__);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function afterPHP( $content) {
+        return $this->insert("<php><!-- {$content} --></php>", 'after');
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function insertAfter( $seletor) {
+        return $this->insert($seletor, __FUNCTION__);
+    }
+    /**
+     * Internal insert method. Don't use it.
+     *
+     * @param unknown_type $target
+     * @param unknown_type $type
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @access private
+     */
+    public function insert($target, $type) {
+        $this->debug("Inserting data with '{$type}'");
+        $to = false;
+        switch( $type) {
+            case 'appendTo':
+            case 'prependTo':
+            case 'insertBefore':
+            case 'insertAfter':
+                $to = true;
+        }
+        switch(gettype($target)) {
+            case 'string':
+                $insertFrom = $insertTo = array();
+                if ($to) {
+                    // INSERT TO
+                    $insertFrom = $this->elements;
+                    if (phpQuery::isMarkup($target)) {
+                        // $target is new markup, import it
+                        $insertTo = $this->documentWrapper->import($target);
+                    // insert into selected element
+                    } else {
+                        // $tagret is a selector
+                        $thisStack = $this->elements;
+                        $this->toRoot();
+                        $insertTo = $this->find($target)->elements;
+                        $this->elements = $thisStack;
+                    }
+                } else {
+                    // INSERT FROM
+                    $insertTo = $this->elements;
+                    $insertFrom = $this->documentWrapper->import($target);
+                }
+                break;
+            case 'object':
+                $insertFrom = $insertTo = array();
+                // phpQuery
+                if ($target instanceof self) {
+                    if ($to) {
+                        $insertTo = $target->elements;
+                        if ($this->documentFragment && $this->stackIsRoot())
+                            // get all body children
+//                          $loop = $this->find('body > *')->elements;
+                            // TODO test it, test it hard...
+//                          $loop = $this->newInstance($this->root)->find('> *')->elements;
+                            $loop = $this->root->childNodes;
+                        else
+                            $loop = $this->elements;
+                        // import nodes if needed
+                        $insertFrom = $this->getDocumentID() == $target->getDocumentID()
+                            ? $loop
+                            : $target->documentWrapper->import($loop);
+                    } else {
+                        $insertTo = $this->elements;
+                        if ( $target->documentFragment && $target->stackIsRoot() )
+                            // get all body children
+//                          $loop = $target->find('body > *')->elements;
+                            $loop = $target->root->childNodes;
+                        else
+                            $loop = $target->elements;
+                        // import nodes if needed
+                        $insertFrom = $this->getDocumentID() == $target->getDocumentID()
+                            ? $loop
+                            : $this->documentWrapper->import($loop);
+                    }
+                // DOMNODE
+                } elseif ($target instanceof DOMNODE) {
+                    // import node if needed
+//                  if ( $target->ownerDocument != $this->DOM )
+//                      $target = $this->DOM->importNode($target, true);
+                    if ( $to) {
+                        $insertTo = array($target);
+                        if ($this->documentFragment && $this->stackIsRoot())
+                            // get all body children
+                            $loop = $this->root->childNodes;
+//                          $loop = $this->find('body > *')->elements;
+                        else
+                            $loop = $this->elements;
+                        foreach($loop as $fromNode)
+                            // import nodes if needed
+                            $insertFrom[] = ! $fromNode->ownerDocument->isSameNode($target->ownerDocument)
+                                ? $target->ownerDocument->importNode($fromNode, true)
+                                : $fromNode;
+                    } else {
+                        // import node if needed
+                        if (! $target->ownerDocument->isSameNode($this->document))
+                            $target = $this->document->importNode($target, true);
+                        $insertTo = $this->elements;
+                        $insertFrom[] = $target;
+                    }
+                }
+                break;
+        }
+        phpQuery::debug("From ".count($insertFrom)."; To ".count($insertTo)." nodes");
+        foreach($insertTo as $insertNumber => $toNode) {
+            // we need static relative elements in some cases
+            switch( $type) {
+                case 'prependTo':
+                case 'prepend':
+                    $firstChild = $toNode->firstChild;
+                    break;
+                case 'insertAfter':
+                case 'after':
+                    $nextSibling = $toNode->nextSibling;
+                    break;
+            }
+            foreach($insertFrom as $fromNode) {
+                // clone if inserted already before
+                $insert = $insertNumber
+                    ? $fromNode->cloneNode(true)
+                    : $fromNode;
+                switch($type) {
+                    case 'appendTo':
+                    case 'append':
+//                      $toNode->insertBefore(
+//                          $fromNode,
+//                          $toNode->lastChild->nextSibling
+//                      );
+                        $toNode->appendChild($insert);
+                        $eventTarget = $insert;
+                        break;
+                    case 'prependTo':
+                    case 'prepend':
+                        $toNode->insertBefore(
+                            $insert,
+                            $firstChild
+                        );
+                        break;
+                    case 'insertBefore':
+                    case 'before':
+                        if (! $toNode->parentNode)
+                            throw new Exception("No parentNode, can't do {$type}()");
+                        else
+                            $toNode->parentNode->insertBefore(
+                                $insert,
+                                $toNode
+                            );
+                        break;
+                    case 'insertAfter':
+                    case 'after':
+                        if (! $toNode->parentNode)
+                            throw new Exception("No parentNode, can't do {$type}()");
+                        else
+                            $toNode->parentNode->insertBefore(
+                                $insert,
+                                $nextSibling
+                            );
+                        break;
+                }
+                // Mutation event
+                $event = new DOMEvent(array(
+                    'target' => $insert,
+                    'type' => 'DOMNodeInserted'
+                ));
+                phpQueryEvents::trigger($this->getDocumentID(),
+                    $event->type, array($event), $insert
+                );
+            }
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return Int
+     */
+    public function index($subject) {
+        $index = -1;
+        $subject = $subject instanceof phpQueryObject
+            ? $subject->elements[0]
+            : $subject;
+        foreach($this->newInstance() as $k => $node) {
+            if ($node->isSameNode($subject))
+                $index = $k;
+        }
+        return $index;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param unknown_type $start
+     * @param unknown_type $end
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @testme
+     */
+    public function slice($start, $end = null) {
+//      $last = count($this->elements)-1;
+//      $end = $end
+//          ? min($end, $last)
+//          : $last;
+//      if ($start < 0)
+//          $start = $last+$start;
+//      if ($start > $last)
+//          return array();
+        if ($end > 0)
+            $end = $end-$start;
+        return $this->newInstance(
+            array_slice($this->elements, $start, $end)
+        );
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function reverse() {
+        $this->elementsBackup = $this->elements;
+        $this->elements = array_reverse($this->elements);
+        return $this->newInstance();
+    }
+    /**
+     * Return joined text content.
+     * @return String
+     */
+    public function text($text = null, $callback1 = null, $callback2 = null, $callback3 = null) {
+        if (isset($text))
+            return $this->html(htmlspecialchars($text));
+        $args = func_get_args();
+        $args = array_slice($args, 1);
+        $return = '';
+        foreach($this->elements as $node) {
+            $text = $node->textContent;
+            if (count($this->elements) > 1 && $text)
+                $text .= "\n";
+            foreach($args as $callback) {
+                $text = phpQuery::callbackRun($callback, array($text));
+            }
+            $return .= $text;
+        }
+        return $return;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function plugin($class, $file = null) {
+        phpQuery::plugin($class, $file);
+        return $this;
+    }
+    /**
+     * Deprecated, use $pq->plugin() instead.
+     *
+     * @deprecated
+     * @param $class
+     * @param $file
+     * @return unknown_type
+     */
+    public static function extend($class, $file = null) {
+        return $this->plugin($class, $file);
+    }
+    /**
+     *
+     * @access private
+     * @param $method
+     * @param $args
+     * @return unknown_type
+     */
+    public function __call($method, $args) {
+        $aliasMethods = array('clone', 'empty');
+        if (isset(phpQuery::$extendMethods[$method])) {
+            array_unshift($args, $this);
+            return phpQuery::callbackRun(
+                phpQuery::$extendMethods[$method], $args
+            );
+        } else if (isset(phpQuery::$pluginsMethods[$method])) {
+            array_unshift($args, $this);
+            $class = phpQuery::$pluginsMethods[$method];
+            $realClass = "phpQueryObjectPlugin_$class";
+            $return = call_user_func_array(
+                array($realClass, $method),
+                $args
+            );
+            // XXX deprecate ?
+            return is_null($return)
+                ? $this
+                : $return;
+        } else if (in_array($method, $aliasMethods)) {
+            return call_user_func_array(array($this, '_'.$method), $args);
+        } else
+            throw new Exception("Method '{$method}' doesnt exist");
+    }
+    /**
+     * Safe rename of next().
+     *
+     * Use it ONLY when need to call next() on an iterated object (in same time).
+     * Normaly there is no need to do such thing ;)
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @access private
+     */
+    public function _next($selector = null) {
+        return $this->newInstance(
+            $this->getElementSiblings('nextSibling', $selector, true)
+        );
+    }
+    /**
+     * Use prev() and next().
+     *
+     * @deprecated
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @access private
+     */
+    public function _prev($selector = null) {
+        return $this->prev($selector);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function prev($selector = null) {
+        return $this->newInstance(
+            $this->getElementSiblings('previousSibling', $selector, true)
+        );
+    }
+    /**
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo
+     */
+    public function prevAll($selector = null) {
+        return $this->newInstance(
+            $this->getElementSiblings('previousSibling', $selector)
+        );
+    }
+    /**
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo FIXME: returns source elements insted of next siblings
+     */
+    public function nextAll($selector = null) {
+        return $this->newInstance(
+            $this->getElementSiblings('nextSibling', $selector)
+        );
+    }
+    /**
+     * @access private
+     */
+    protected function getElementSiblings($direction, $selector = null, $limitToOne = false) {
+        $stack = array();
+        $count = 0;
+        foreach($this->stack() as $node) {
+            $test = $node;
+            while( isset($test->{$direction}) && $test->{$direction}) {
+                $test = $test->{$direction};
+                if (! $test instanceof DOMELEMENT)
+                    continue;
+                $stack[] = $test;
+                if ($limitToOne)
+                    break;
+            }
+        }
+        if ($selector) {
+            $stackOld = $this->elements;
+            $this->elements = $stack;
+            $stack = $this->filter($selector, true)->stack();
+            $this->elements = $stackOld;
+        }
+        return $stack;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function siblings($selector = null) {
+        $stack = array();
+        $siblings = array_merge(
+            $this->getElementSiblings('previousSibling', $selector),
+            $this->getElementSiblings('nextSibling', $selector)
+        );
+        foreach($siblings as $node) {
+            if (! $this->elementsContainsNode($node, $stack))
+                $stack[] = $node;
+        }
+        return $this->newInstance($stack);
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function not($selector = null) {
+        if (is_string($selector))
+            phpQuery::debug(array('not', $selector));
+        else
+            phpQuery::debug('not');
+        $stack = array();
+        if ($selector instanceof self || $selector instanceof DOMNODE) {
+            foreach($this->stack() as $node) {
+                if ($selector instanceof self) {
+                    $matchFound = false;
+                    foreach($selector->stack() as $notNode) {
+                        if ($notNode->isSameNode($node))
+                            $matchFound = true;
+                    }
+                    if (! $matchFound)
+                        $stack[] = $node;
+                } else if ($selector instanceof DOMNODE) {
+                    if (! $selector->isSameNode($node))
+                        $stack[] = $node;
+                } else {
+                    if (! $this->is($selector))
+                        $stack[] = $node;
+                }
+            }
+        } else {
+            $orgStack = $this->stack();
+            $matched = $this->filter($selector, true)->stack();
+//          $matched = array();
+//          // simulate OR in filter() instead of AND 5y
+//          foreach($this->parseSelector($selector) as $s) {
+//              $matched = array_merge($matched,
+//                  $this->filter(array($s))->stack()
+//              );
+//          }
+            foreach($orgStack as $node)
+                if (! $this->elementsContainsNode($node, $matched))
+                    $stack[] = $node;
+        }
+        return $this->newInstance($stack);
+    }
+    /**
+     * Enter description here...
+     *
+     * @param string|phpQueryObject
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function add($selector = null) {
+        if (! $selector)
+            return $this;
+        $stack = array();
+        $this->elementsBackup = $this->elements;
+        $found = phpQuery::pq($selector, $this->getDocumentID());
+        $this->merge($found->elements);
+        return $this->newInstance();
+    }
+    /**
+     * @access private
+     */
+    protected function merge() {
+        foreach(func_get_args() as $nodes)
+            foreach($nodes as $newNode )
+                if (! $this->elementsContainsNode($newNode) )
+                    $this->elements[] = $newNode;
+    }
+    /**
+     * @access private
+     * TODO refactor to stackContainsNode
+     */
+    protected function elementsContainsNode($nodeToCheck, $elementsStack = null) {
+        $loop = ! is_null($elementsStack)
+            ? $elementsStack
+            : $this->elements;
+        foreach($loop as $node) {
+            if ( $node->isSameNode( $nodeToCheck ) )
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function parent($selector = null) {
+        $stack = array();
+        foreach($this->elements as $node )
+            if ( $node->parentNode && ! $this->elementsContainsNode($node->parentNode, $stack) )
+                $stack[] = $node->parentNode;
+        $this->elementsBackup = $this->elements;
+        $this->elements = $stack;
+        if ( $selector )
+            $this->filter($selector, true);
+        return $this->newInstance();
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function parents($selector = null) {
+        $stack = array();
+        if (! $this->elements )
+            $this->debug('parents() - stack empty');
+        foreach($this->elements as $node) {
+            $test = $node;
+            while( $test->parentNode) {
+                $test = $test->parentNode;
+                if ($this->isRoot($test))
+                    break;
+                if (! $this->elementsContainsNode($test, $stack)) {
+                    $stack[] = $test;
+                    continue;
+                }
+            }
+        }
+        $this->elementsBackup = $this->elements;
+        $this->elements = $stack;
+        if ( $selector )
+            $this->filter($selector, true);
+        return $this->newInstance();
+    }
+    /**
+     * Internal stack iterator.
+     *
+     * @access private
+     */
+    public function stack($nodeTypes = null) {
+        if (!isset($nodeTypes))
+            return $this->elements;
+        if (!is_array($nodeTypes))
+            $nodeTypes = array($nodeTypes);
+        $return = array();
+        foreach($this->elements as $node) {
+            if (in_array($node->nodeType, $nodeTypes))
+                $return[] = $node;
+        }
+        return $return;
+    }
+    // TODO phpdoc; $oldAttr is result of hasAttribute, before any changes
+    protected function attrEvents($attr, $oldAttr, $oldValue, $node) {
+        // skip events for XML documents
+        if (! $this->isXHTML() && ! $this->isHTML())
+            return;
+        $event = null;
+        // identify
+        $isInputValue = $node->tagName == 'input'
+            && (
+                in_array($node->getAttribute('type'),
+                    array('text', 'password', 'hidden'))
+                || !$node->getAttribute('type')
+                 );
+        $isRadio = $node->tagName == 'input'
+            && $node->getAttribute('type') == 'radio';
+        $isCheckbox = $node->tagName == 'input'
+            && $node->getAttribute('type') == 'checkbox';
+        $isOption = $node->tagName == 'option';
+        if ($isInputValue && $attr == 'value' && $oldValue != $node->getAttribute($attr)) {
+            $event = new DOMEvent(array(
+                'target' => $node,
+                'type' => 'change'
+            ));
+        } else if (($isRadio || $isCheckbox) && $attr == 'checked' && (
+                // check
+                (! $oldAttr && $node->hasAttribute($attr))
+                // un-check
+                || (! $node->hasAttribute($attr) && $oldAttr)
+            )) {
+            $event = new DOMEvent(array(
+                'target' => $node,
+                'type' => 'change'
+            ));
+        } else if ($isOption && $node->parentNode && $attr == 'selected' && (
+                // select
+                (! $oldAttr && $node->hasAttribute($attr))
+                // un-select
+                || (! $node->hasAttribute($attr) && $oldAttr)
+            )) {
+            $event = new DOMEvent(array(
+                'target' => $node->parentNode,
+                'type' => 'change'
+            ));
+        }
+        if ($event) {
+            phpQueryEvents::trigger($this->getDocumentID(),
+                $event->type, array($event), $node
+            );
+        }
+    }
+    public function attr($attr = null, $value = null) {
+        foreach($this->stack(1) as $node) {
+            if (! is_null($value)) {
+                $loop = $attr == '*'
+                    ? $this->getNodeAttrs($node)
+                    : array($attr);
+                foreach($loop as $a) {
+                    $oldValue = $node->getAttribute($a);
+                    $oldAttr = $node->hasAttribute($a);
+                    // TODO raises an error when charset other than UTF-8
+                    // while document's charset is also not UTF-8
+                    @$node->setAttribute($a, $value);
+                    $this->attrEvents($a, $oldAttr, $oldValue, $node);
+                }
+            } else if ($attr == '*') {
+                // jQuery difference
+                $return = array();
+                foreach($node->attributes as $n => $v)
+                    $return[$n] = $v->value;
+                return $return;
+            } else
+                return $node->hasAttribute($attr)
+                    ? $node->getAttribute($attr)
+                    : null;
+        }
+        return is_null($value)
+            ? '' : $this;
+    }
+    /**
+     * @access private
+     */
+    protected function getNodeAttrs($node) {
+        $return = array();
+        foreach($node->attributes as $n => $o)
+            $return[] = $n;
+        return $return;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo check CDATA ???
+     */
+    public function attrPHP($attr, $code) {
+        if (! is_null($code)) {
+            $value = '<'.'?php '.$code.' ?'.'>';
+            // TODO tempolary solution
+            // http://code.google.com/p/phpquery/issues/detail?id=17
+//          if (function_exists('mb_detect_encoding') && mb_detect_encoding($value) == 'ASCII')
+//              $value  = mb_convert_encoding($value, 'UTF-8', 'HTML-ENTITIES');
+        }
+        foreach($this->stack(1) as $node) {
+            if (! is_null($code)) {
+//              $attrNode = $this->DOM->createAttribute($attr);
+                $node->setAttribute($attr, $value);
+//              $attrNode->value = $value;
+//              $node->appendChild($attrNode);
+            } else if ( $attr == '*') {
+                // jQuery diff
+                $return = array();
+                foreach($node->attributes as $n => $v)
+                    $return[$n] = $v->value;
+                return $return;
+            } else
+                return $node->getAttribute($attr);
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function removeAttr($attr) {
+        foreach($this->stack(1) as $node) {
+            $loop = $attr == '*'
+                ? $this->getNodeAttrs($node)
+                : array($attr);
+            foreach($loop as $a) {
+                $oldValue = $node->getAttribute($a);
+                $node->removeAttribute($a);
+                $this->attrEvents($a, $oldValue, null, $node);
+            }
+        }
+        return $this;
+    }
+    /**
+     * Return form element value.
+     *
+     * @return String Fields value.
+     */
+    public function val($val = null) {
+        if (! isset($val)) {
+            if ($this->eq(0)->is('select')) {
+                    $selected = $this->eq(0)->find('option[selected=selected]');
+                    if ($selected->is('[value]'))
+                        return $selected->attr('value');
+                    else
+                        return $selected->text();
+            } else if ($this->eq(0)->is('textarea'))
+                    return $this->eq(0)->markup();
+                else
+                    return $this->eq(0)->attr('value');
+        } else {
+            $_val = null;
+            foreach($this->stack(1) as $node) {
+                $node = pq($node, $this->getDocumentID());
+                if (is_array($val) && in_array($node->attr('type'), array('checkbox', 'radio'))) {
+                    $isChecked = in_array($node->attr('value'), $val)
+                            || in_array($node->attr('name'), $val);
+                    if ($isChecked)
+                        $node->attr('checked', 'checked');
+                    else
+                        $node->removeAttr('checked');
+                } else if ($node->get(0)->tagName == 'select') {
+                    if (! isset($_val)) {
+                        $_val = array();
+                        if (! is_array($val))
+                            $_val = array((string)$val);
+                        else
+                            foreach($val as $v)
+                                $_val[] = $v;
+                    }
+                    foreach($node['option']->stack(1) as $option) {
+                        $option = pq($option, $this->getDocumentID());
+                        $selected = false;
+                        // XXX: workaround for string comparsion, see issue #96
+                        // http://code.google.com/p/phpquery/issues/detail?id=96
+                        $selected = is_null($option->attr('value'))
+                            ? in_array($option->markup(), $_val)
+                            : in_array($option->attr('value'), $_val);
+//                      $optionValue = $option->attr('value');
+//                      $optionText = $option->text();
+//                      $optionTextLenght = mb_strlen($optionText);
+//                      foreach($_val as $v)
+//                          if ($optionValue == $v)
+//                              $selected = true;
+//                          else if ($optionText == $v && $optionTextLenght == mb_strlen($v))
+//                              $selected = true;
+                        if ($selected)
+                            $option->attr('selected', 'selected');
+                        else
+                            $option->removeAttr('selected');
+                    }
+                } else if ($node->get(0)->tagName == 'textarea')
+                    $node->markup($val);
+                else
+                    $node->attr('value', $val);
+            }
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function andSelf() {
+        if ( $this->previous )
+            $this->elements = array_merge($this->elements, $this->previous->elements);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function addClass( $className) {
+        if (! $className)
+            return $this;
+        foreach($this->stack(1) as $node) {
+            if (! $this->is(".$className", $node))
+                $node->setAttribute(
+                    'class',
+                    trim($node->getAttribute('class').' '.$className)
+                );
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function addClassPHP( $className) {
+        foreach($this->stack(1) as $node) {
+                $classes = $node->getAttribute('class');
+                $newValue = $classes
+                    ? $classes.' <'.'?php '.$className.' ?'.'>'
+                    : '<'.'?php '.$className.' ?'.'>';
+                $node->setAttribute('class', $newValue);
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param   string  $className
+     * @return  bool
+     */
+    public function hasClass($className) {
+        foreach($this->stack(1) as $node) {
+            if ( $this->is(".$className", $node))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function removeClass($className) {
+        foreach($this->stack(1) as $node) {
+            $classes = explode( ' ', $node->getAttribute('class'));
+            if ( in_array($className, $classes)) {
+                $classes = array_diff($classes, array($className));
+                if ( $classes )
+                    $node->setAttribute('class', implode(' ', $classes));
+                else
+                    $node->removeAttribute('class');
+            }
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function toggleClass($className) {
+        foreach($this->stack(1) as $node) {
+            if ( $this->is( $node, '.'.$className ))
+                $this->removeClass($className);
+            else
+                $this->addClass($className);
+        }
+        return $this;
+    }
+    /**
+     * Proper name without underscore (just ->empty()) also works.
+     *
+     * Removes all child nodes from the set of matched elements.
+     *
+     * Example:
+     * pq("p")._empty()
+     *
+     * HTML:
+     * <p>Hello, <span>Person</span> <a href="#">and person</a></p>
+     *
+     * Result:
+     * [ <p></p> ]
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @access private
+     */
+    public function _empty() {
+        foreach($this->stack(1) as $node) {
+            // thx to 'dave at dgx dot cz'
+            $node->nodeValue = '';
+        }
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param array|string $callback Expects $node as first param, $index as second
+     * @param array $scope External variables passed to callback. Use compact('varName1', 'varName2'...) and extract($scope)
+     * @param array $arg1 Will ba passed as third and futher args to callback.
+     * @param array $arg2 Will ba passed as fourth and futher args to callback, and so on...
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function each($callback, $param1 = null, $param2 = null, $param3 = null) {
+        $paramStructure = null;
+        if (func_num_args() > 1) {
+            $paramStructure = func_get_args();
+            $paramStructure = array_slice($paramStructure, 1);
+        }
+        foreach($this->elements as $v)
+            phpQuery::callbackRun($callback, array($v), $paramStructure);
+        return $this;
+    }
+    /**
+     * Run callback on actual object.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function callback($callback, $param1 = null, $param2 = null, $param3 = null) {
+        $params = func_get_args();
+        $params[0] = $this;
+        phpQuery::callbackRun($callback, $params);
+        return $this;
+    }
+    /**
+     * Enter description here...
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @todo add $scope and $args as in each() ???
+     */
+    public function map($callback, $param1 = null, $param2 = null, $param3 = null) {
+//      $stack = array();
+////        foreach($this->newInstance() as $node) {
+//      foreach($this->newInstance() as $node) {
+//          $result = call_user_func($callback, $node);
+//          if ($result)
+//              $stack[] = $result;
+//      }
+        $params = func_get_args();
+        array_unshift($params, $this->elements);
+        return $this->newInstance(
+            call_user_func_array(array('phpQuery', 'map'), $params)
+//          phpQuery::map($this->elements, $callback)
+        );
+    }
+    /**
+     * Enter description here...
+     *
+     * @param <type> $key
+     * @param <type> $value
+     */
+    public function data($key, $value = null) {
+        if (! isset($value)) {
+            // TODO? implement specific jQuery behavior od returning parent values
+            // is child which we look up doesn't exist
+            return phpQuery::data($this->get(0), $key, $value, $this->getDocumentID());
+        } else {
+            foreach($this as $node)
+                phpQuery::data($node, $key, $value, $this->getDocumentID());
+            return $this;
+        }
+    }
+    /**
+     * Enter description here...
+     *
+     * @param <type> $key
+     */
+    public function removeData($key) {
+        foreach($this as $node)
+            phpQuery::removeData($node, $key, $this->getDocumentID());
+        return $this;
+    }
+    // INTERFACE IMPLEMENTATIONS
+
+    // ITERATOR INTERFACE
+    /**
+   * @access private
+     */
+    public function rewind(){
+        $this->debug('iterating foreach');
+//      phpQuery::selectDocument($this->getDocumentID());
+        $this->elementsBackup = $this->elements;
+        $this->elementsInterator = $this->elements;
+        $this->valid = isset( $this->elements[0] )
+            ? 1 : 0;
+//      $this->elements = $this->valid
+//          ? array($this->elements[0])
+//          : array();
+        $this->current = 0;
+    }
+    /**
+   * @access private
+     */
+    public function current(){
+        return $this->elementsInterator[ $this->current ];
+    }
+    /**
+   * @access private
+     */
+    public function key(){
+        return $this->current;
+    }
+    /**
+     * Double-function method.
+     *
+     * First: main iterator interface method.
+     * Second: Returning next sibling, alias for _next().
+     *
+     * Proper functionality is choosed automagicaly.
+     *
+     * @see phpQueryObject::_next()
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public function next($cssSelector = null){
+//      if ($cssSelector || $this->valid)
+//          return $this->_next($cssSelector);
+        $this->valid = isset( $this->elementsInterator[ $this->current+1 ] )
+            ? true
+            : false;
+        if (! $this->valid && $this->elementsInterator) {
+            $this->elementsInterator = null;
+        } else if ($this->valid) {
+            $this->current++;
+        } else {
+            return $this->_next($cssSelector);
+        }
+    }
+    /**
+   * @access private
+     */
+    public function valid(){
+        return $this->valid;
+    }
+    // ITERATOR INTERFACE END
+    // ARRAYACCESS INTERFACE
+    /**
+   * @access private
+     */
+    public function offsetExists($offset) {
+        return $this->find($offset)->size() > 0;
+    }
+    /**
+   * @access private
+     */
+    public function offsetGet($offset) {
+        return $this->find($offset);
+    }
+    /**
+   * @access private
+     */
+    public function offsetSet($offset, $value) {
+//      $this->find($offset)->replaceWith($value);
+        $this->find($offset)->html($value);
+    }
+    /**
+   * @access private
+     */
+    public function offsetUnset($offset) {
+        // empty
+        throw new Exception("Can't do unset, use array interface only for calling queries and replacing HTML.");
+    }
+    // ARRAYACCESS INTERFACE END
+    /**
+     * Returns node's XPath.
+     *
+     * @param unknown_type $oneNode
+     * @return string
+     * @TODO use native getNodePath is avaible
+     * @access private
+     */
+    protected function getNodeXpath($oneNode = null, $namespace = null) {
+        $return = array();
+        $loop = $oneNode
+            ? array($oneNode)
+            : $this->elements;
+//      if ($namespace)
+//          $namespace .= ':';
+        foreach($loop as $node) {
+            if ($node instanceof DOMDOCUMENT) {
+                $return[] = '';
+                continue;
+            }
+            $xpath = array();
+            while(! ($node instanceof DOMDOCUMENT)) {
+                $i = 1;
+                $sibling = $node;
+                while($sibling->previousSibling) {
+                    $sibling = $sibling->previousSibling;
+                    $isElement = $sibling instanceof DOMELEMENT;
+                    if ($isElement && $sibling->tagName == $node->tagName)
+                        $i++;
+                }
+                $xpath[] = $this->isXML()
+                    ? "*[local-name()='{$node->tagName}'][{$i}]"
+                    : "{$node->tagName}[{$i}]";
+                $node = $node->parentNode;
+            }
+            $xpath = join('/', array_reverse($xpath));
+            $return[] = '/'.$xpath;
+        }
+        return $oneNode
+            ? $return[0]
+            : $return;
+    }
+    // HELPERS
+    public function whois($oneNode = null) {
+        $return = array();
+        $loop = $oneNode
+            ? array( $oneNode )
+            : $this->elements;
+        foreach($loop as $node) {
+            if (isset($node->tagName)) {
+                $tag = in_array($node->tagName, array('php', 'js'))
+                    ? strtoupper($node->tagName)
+                    : $node->tagName;
+                $return[] = $tag
+                    .($node->getAttribute('id')
+                        ? '#'.$node->getAttribute('id'):'')
+                    .($node->getAttribute('class')
+                        ? '.'.join('.', split(' ', $node->getAttribute('class'))):'')
+                    .($node->getAttribute('name')
+                        ? '[name="'.$node->getAttribute('name').'"]':'')
+                    .($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') === false
+                        ? '[value="'.substr(str_replace("\n", '', $node->getAttribute('value')), 0, 15).'"]':'')
+                    .($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') !== false
+                        ? '[value=PHP]':'')
+                    .($node->getAttribute('selected')
+                        ? '[selected]':'')
+                    .($node->getAttribute('checked')
+                        ? '[checked]':'')
+                ;
+            } else if ($node instanceof DOMTEXT) {
+                if (trim($node->textContent))
+                    $return[] = 'Text:'.substr(str_replace("\n", ' ', $node->textContent), 0, 15);
+            } else {
+
+            }
+        }
+        return $oneNode && isset($return[0])
+            ? $return[0]
+            : $return;
+    }
+    /**
+     * Dump htmlOuter and preserve chain. Usefull for debugging.
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     *
+     */
+    public function dump() {
+        print 'DUMP #'.(phpQuery::$dumpCount++).' ';
+        $debug = phpQuery::$debug;
+        phpQuery::$debug = false;
+//      print __FILE__.':'.__LINE__."\n";
+        var_dump($this->htmlOuter());
+        return $this;
+    }
+    public function dumpWhois() {
+        print 'DUMP #'.(phpQuery::$dumpCount++).' ';
+        $debug = phpQuery::$debug;
+        phpQuery::$debug = false;
+//      print __FILE__.':'.__LINE__."\n";
+        var_dump('whois', $this->whois());
+        phpQuery::$debug = $debug;
+        return $this;
+    }
+    public function dumpLength() {
+        print 'DUMP #'.(phpQuery::$dumpCount++).' ';
+        $debug = phpQuery::$debug;
+        phpQuery::$debug = false;
+//      print __FILE__.':'.__LINE__."\n";
+        var_dump('length', $this->length());
+        phpQuery::$debug = $debug;
+        return $this;
+    }
+    public function dumpTree($html = true, $title = true) {
+        $output = $title
+            ? 'DUMP #'.(phpQuery::$dumpCount++)." \n" : '';
+        $debug = phpQuery::$debug;
+        phpQuery::$debug = false;
+        foreach($this->stack() as $node)
+            $output .= $this->__dumpTree($node);
+        phpQuery::$debug = $debug;
+        print $html
+            ? nl2br(str_replace(' ', '&nbsp;', $output))
+            : $output;
+        return $this;
+    }
+    private function __dumpTree($node, $intend = 0) {
+        $whois = $this->whois($node);
+        $return = '';
+        if ($whois)
+            $return .= str_repeat(' - ', $intend).$whois."\n";
+        if (isset($node->childNodes))
+            foreach($node->childNodes as $chNode)
+                $return .= $this->__dumpTree($chNode, $intend+1);
+        return $return;
+    }
+    /**
+     * Dump htmlOuter and stop script execution. Usefull for debugging.
+     *
+     */
+    public function dumpDie() {
+        print __FILE__.':'.__LINE__;
+        var_dump($this->htmlOuter());
+        die();
+    }
+}
+
+
+// -- Multibyte Compatibility functions ---------------------------------------
+// http://svn.iphonewebdev.com/lace/lib/mb_compat.php
+
+/**
+ *  mb_internal_encoding()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_internal_encoding'))
+{
+    function mb_internal_encoding($enc) {return true; }
+}
+
+/**
+ *  mb_regex_encoding()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_regex_encoding'))
+{
+    function mb_regex_encoding($enc) {return true; }
+}
+
+/**
+ *  mb_strlen()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_strlen'))
+{
+    function mb_strlen($str)
+    {
+        return strlen($str);
+    }
+}
+
+/**
+ *  mb_strpos()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_strpos'))
+{
+    function mb_strpos($haystack, $needle, $offset=0)
+    {
+        return strpos($haystack, $needle, $offset);
+    }
+}
+/**
+ *  mb_stripos()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_stripos'))
+{
+    function mb_stripos($haystack, $needle, $offset=0)
+    {
+        return stripos($haystack, $needle, $offset);
+    }
+}
+
+/**
+ *  mb_substr()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_substr'))
+{
+    function mb_substr($str, $start, $length=0)
+    {
+        return substr($str, $start, $length);
+    }
+}
+
+/**
+ *  mb_substr_count()
+ *
+ *  Included for mbstring pseudo-compatability.
+ */
+if (!function_exists('mb_substr_count'))
+{
+    function mb_substr_count($haystack, $needle)
+    {
+        return substr_count($haystack, $needle);
+    }
+}
+
+
+/**
+ * Static namespace for phpQuery functions.
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @package phpQuery
+ */
+abstract class phpQuery {
+    /**
+     * XXX: Workaround for mbstring problems
+     *
+     * @var bool
+     */
+    public static $mbstringSupport = true;
+    public static $debug = false;
+    public static $documents = array();
+    public static $defaultDocumentID = null;
+//  public static $defaultDoctype = 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"';
+    /**
+     * Applies only to HTML.
+     *
+     * @var unknown_type
+     */
+    public static $defaultDoctype = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">';
+    public static $defaultCharset = 'UTF-8';
+    /**
+     * Static namespace for plugins.
+     *
+     * @var object
+     */
+    public static $plugins = array();
+    /**
+     * List of loaded plugins.
+     *
+     * @var unknown_type
+     */
+    public static $pluginsLoaded = array();
+    public static $pluginsMethods = array();
+    public static $pluginsStaticMethods = array();
+    public static $extendMethods = array();
+    /**
+     * @TODO implement
+     */
+    public static $extendStaticMethods = array();
+    /**
+     * Hosts allowed for AJAX connections.
+     * Dot '.' means $_SERVER['HTTP_HOST'] (if any).
+     *
+     * @var array
+     */
+    public static $ajaxAllowedHosts = array(
+        '.'
+    );
+    /**
+     * AJAX settings.
+     *
+     * @var array
+     * XXX should it be static or not ?
+     */
+    public static $ajaxSettings = array(
+        'url' => '',//TODO
+        'global' => true,
+        'type' => "GET",
+        'timeout' => null,
+        'contentType' => "application/x-www-form-urlencoded",
+        'processData' => true,
+//      'async' => true,
+        'data' => null,
+        'username' => null,
+        'password' => null,
+        'accepts' => array(
+            'xml' => "application/xml, text/xml",
+            'html' => "text/html",
+            'script' => "text/javascript, application/javascript",
+            'json' => "application/json, text/javascript",
+            'text' => "text/plain",
+            '_default' => "*/*"
+        )
+    );
+    public static $lastModified = null;
+    public static $active = 0;
+    public static $dumpCount = 0;
+    /**
+     * Multi-purpose function.
+     * Use pq() as shortcut.
+     *
+     * In below examples, $pq is any result of pq(); function.
+     *
+     * 1. Import markup into existing document (without any attaching):
+     * - Import into selected document:
+     *   pq('<div/>')               // DOESNT accept text nodes at beginning of input string !
+     * - Import into document with ID from $pq->getDocumentID():
+     *   pq('<div/>', $pq->getDocumentID())
+     * - Import into same document as DOMNode belongs to:
+     *   pq('<div/>', DOMNode)
+     * - Import into document from phpQuery object:
+     *   pq('<div/>', $pq)
+     *
+     * 2. Run query:
+     * - Run query on last selected document:
+     *   pq('div.myClass')
+     * - Run query on document with ID from $pq->getDocumentID():
+     *   pq('div.myClass', $pq->getDocumentID())
+     * - Run query on same document as DOMNode belongs to and use node(s)as root for query:
+     *   pq('div.myClass', DOMNode)
+     * - Run query on document from phpQuery object
+     *   and use object's stack as root node(s) for query:
+     *   pq('div.myClass', $pq)
+     *
+     * @param string|DOMNode|DOMNodeList|array  $arg1   HTML markup, CSS Selector, DOMNode or array of DOMNodes
+     * @param string|phpQueryObject|DOMNode $context    DOM ID from $pq->getDocumentID(), phpQuery object (determines also query root) or DOMNode (determines also query root)
+     *
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery|QueryTemplatesPhpQuery|false
+   * phpQuery object or false in case of error.
+     */
+    public static function pq($arg1, $context = null) {
+        if ($arg1 instanceof DOMNODE && ! isset($context)) {
+            foreach(phpQuery::$documents as $documentWrapper) {
+                $compare = $arg1 instanceof DOMDocument
+                    ? $arg1 : $arg1->ownerDocument;
+                if ($documentWrapper->document->isSameNode($compare))
+                    $context = $documentWrapper->id;
+            }
+        }
+        if (! $context) {
+            $domId = self::$defaultDocumentID;
+            if (! $domId)
+                throw new Exception("Can't use last created DOM, because there isn't any. Use phpQuery::newDocument() first.");
+//      } else if (is_object($context) && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
+        } else if (is_object($context) && $context instanceof phpQueryObject)
+            $domId = $context->getDocumentID();
+        else if ($context instanceof DOMDOCUMENT) {
+            $domId = self::getDocumentID($context);
+            if (! $domId) {
+                //throw new Exception('Orphaned DOMDocument');
+                $domId = self::newDocument($context)->getDocumentID();
+            }
+        } else if ($context instanceof DOMNODE) {
+            $domId = self::getDocumentID($context);
+            if (! $domId) {
+                throw new Exception('Orphaned DOMNode');
+//              $domId = self::newDocument($context->ownerDocument);
+            }
+        } else
+            $domId = $context;
+        if ($arg1 instanceof phpQueryObject) {
+//      if (is_object($arg1) && (get_class($arg1) == 'phpQueryObject' || $arg1 instanceof PHPQUERY || is_subclass_of($arg1, 'phpQueryObject'))) {
+            /**
+             * Return $arg1 or import $arg1 stack if document differs:
+             * pq(pq('<div/>'))
+             */
+            if ($arg1->getDocumentID() == $domId)
+                return $arg1;
+            $class = get_class($arg1);
+            // support inheritance by passing old object to overloaded constructor
+            $phpQuery = $class != 'phpQuery'
+                ? new $class($arg1, $domId)
+                : new phpQueryObject($domId);
+            $phpQuery->elements = array();
+            foreach($arg1->elements as $node)
+                $phpQuery->elements[] = $phpQuery->document->importNode($node, true);
+            return $phpQuery;
+        } else if ($arg1 instanceof DOMNODE || (is_array($arg1) && isset($arg1[0]) && $arg1[0] instanceof DOMNODE)) {
+            /*
+             * Wrap DOM nodes with phpQuery object, import into document when needed:
+             * pq(array($domNode1, $domNode2))
+             */
+            $phpQuery = new phpQueryObject($domId);
+            if (!($arg1 instanceof DOMNODELIST) && ! is_array($arg1))
+                $arg1 = array($arg1);
+            $phpQuery->elements = array();
+            foreach($arg1 as $node) {
+                $sameDocument = $node->ownerDocument instanceof DOMDOCUMENT
+                    && ! $node->ownerDocument->isSameNode($phpQuery->document);
+                $phpQuery->elements[] = $sameDocument
+                    ? $phpQuery->document->importNode($node, true)
+                    : $node;
+            }
+            return $phpQuery;
+        } else if (self::isMarkup($arg1)) {
+            /**
+             * Import HTML:
+             * pq('<div/>')
+             */
+            $phpQuery = new phpQueryObject($domId);
+            return $phpQuery->newInstance(
+                $phpQuery->documentWrapper->import($arg1)
+            );
+        } else {
+            /**
+             * Run CSS query:
+             * pq('div.myClass')
+             */
+            $phpQuery = new phpQueryObject($domId);
+//          if ($context && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
+            if ($context && $context instanceof phpQueryObject)
+                $phpQuery->elements = $context->elements;
+            else if ($context && $context instanceof DOMNODELIST) {
+                $phpQuery->elements = array();
+                foreach($context as $node)
+                    $phpQuery->elements[] = $node;
+            } else if ($context && $context instanceof DOMNODE)
+                $phpQuery->elements = array($context);
+            return $phpQuery->find($arg1);
+        }
+    }
+    /**
+     * Sets default document to $id. Document has to be loaded prior
+     * to using this method.
+     * $id can be retrived via getDocumentID() or getDocumentIDRef().
+     *
+     * @param unknown_type $id
+     */
+    public static function selectDocument($id) {
+        $id = self::getDocumentID($id);
+        self::debug("Selecting document '$id' as default one");
+        self::$defaultDocumentID = self::getDocumentID($id);
+    }
+    /**
+     * Returns document with id $id or last used as phpQueryObject.
+     * $id can be retrived via getDocumentID() or getDocumentIDRef().
+     * Chainable.
+     *
+     * @see phpQuery::selectDocument()
+     * @param unknown_type $id
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function getDocument($id = null) {
+        if ($id)
+            phpQuery::selectDocument($id);
+        else
+            $id = phpQuery::$defaultDocumentID;
+        return new phpQueryObject($id);
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocument($markup = null, $contentType = null) {
+        if (! $markup)
+            $markup = '';
+        $documentID = phpQuery::createDocumentWrapper($markup, $contentType);
+        return new phpQueryObject($documentID);
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentHTML($markup = null, $charset = null) {
+        $contentType = $charset
+            ? ";charset=$charset"
+            : '';
+        return self::newDocument($markup, "text/html{$contentType}");
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentXML($markup = null, $charset = null) {
+        $contentType = $charset
+            ? ";charset=$charset"
+            : '';
+        return self::newDocument($markup, "text/xml{$contentType}");
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentXHTML($markup = null, $charset = null) {
+        $contentType = $charset
+            ? ";charset=$charset"
+            : '';
+        return self::newDocument($markup, "application/xhtml+xml{$contentType}");
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentPHP($markup = null, $contentType = "text/html") {
+        // TODO pass charset to phpToMarkup if possible (use DOMDocumentWrapper function)
+        $markup = phpQuery::phpToMarkup($markup, self::$defaultCharset);
+        return self::newDocument($markup, $contentType);
+    }
+    public static function phpToMarkup($php, $charset = 'utf-8') {
+        $regexes = array(
+            '@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)<'.'?php?(.*?)(?:\\?>)([^\']*)\'@s',
+            '@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)<'.'?php?(.*?)(?:\\?>)([^"]*)"@s',
+        );
+        foreach($regexes as $regex)
+            while (preg_match($regex, $php, $matches)) {
+                $php = preg_replace_callback(
+                    $regex,
+//                  create_function('$m, $charset = "'.$charset.'"',
+//                      'return $m[1].$m[2]
+//                          .htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
+//                          .$m[5].$m[2];'
+//                  ),
+                    array('phpQuery', '_phpToMarkupCallback'),
+                    $php
+                );
+            }
+        $regex = '@(^|>[^<]*)+?(<\?php(.*?)(\?>))@s';
+//preg_match_all($regex, $php, $matches);
+//var_dump($matches);
+        $php = preg_replace($regex, '\\1<php><!-- \\3 --></php>', $php);
+        return $php;
+    }
+    public static function _phpToMarkupCallback($php, $charset = 'utf-8') {
+        return $m[1].$m[2]
+            .htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
+            .$m[5].$m[2];
+    }
+    public static function _markupToPHPCallback($m) {
+        return "<"."?php ".htmlspecialchars_decode($m[1])." ?".">";
+    }
+    /**
+     * Converts document markup containing PHP code generated by phpQuery::php()
+     * into valid (executable) PHP code syntax.
+     *
+     * @param string|phpQueryObject $content
+     * @return string PHP code.
+     */
+    public static function markupToPHP($content) {
+        if ($content instanceof phpQueryObject)
+            $content = $content->markupOuter();
+        /* <php>...</php> to <?php...? > */
+        $content = preg_replace_callback(
+            '@<php>\s*<!--(.*?)-->\s*</php>@s',
+//          create_function('$m',
+//              'return "<'.'?php ".htmlspecialchars_decode($m[1])." ?'.'>";'
+//          ),
+            array('phpQuery', '_markupToPHPCallback'),
+            $content
+        );
+        /* <node attr='< ?php ? >'> extra space added to save highlighters */
+        $regexes = array(
+            '@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)(?:&lt;|%3C)\\?(?:php)?(.*?)(?:\\?(?:&gt;|%3E))([^\']*)\'@s',
+            '@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)(?:&lt;|%3C)\\?(?:php)?(.*?)(?:\\?(?:&gt;|%3E))([^"]*)"@s',
+        );
+        foreach($regexes as $regex)
+            while (preg_match($regex, $content))
+                $content = preg_replace_callback(
+                    $regex,
+                    create_function('$m',
+                        'return $m[1].$m[2].$m[3]."<?php "
+                            .str_replace(
+                                array("%20", "%3E", "%09", "&#10;", "&#9;", "%7B", "%24", "%7D", "%22", "%5B", "%5D"),
+                                array(" ", ">", "   ", "\n", "  ", "{", "$", "}", \'"\', "[", "]"),
+                                htmlspecialchars_decode($m[4])
+                            )
+                            ." ?>".$m[5].$m[2];'
+                    ),
+                    $content
+                );
+        return $content;
+    }
+    /**
+     * Creates new document from file $file.
+     * Chainable.
+     *
+     * @param string $file URLs allowed. See File wrapper page at php.net for more supported sources.
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentFile($file, $contentType = null) {
+        $documentID = self::createDocumentWrapper(
+            file_get_contents($file), $contentType
+        );
+        return new phpQueryObject($documentID);
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentFileHTML($file, $charset = null) {
+        $contentType = $charset
+            ? ";charset=$charset"
+            : '';
+        return self::newDocumentFile($file, "text/html{$contentType}");
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentFileXML($file, $charset = null) {
+        $contentType = $charset
+            ? ";charset=$charset"
+            : '';
+        return self::newDocumentFile($file, "text/xml{$contentType}");
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentFileXHTML($file, $charset = null) {
+        $contentType = $charset
+            ? ";charset=$charset"
+            : '';
+        return self::newDocumentFile($file, "application/xhtml+xml{$contentType}");
+    }
+    /**
+     * Creates new document from markup.
+     * Chainable.
+     *
+     * @param unknown_type $markup
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     */
+    public static function newDocumentFilePHP($file, $contentType = null) {
+        return self::newDocumentPHP(file_get_contents($file), $contentType);
+    }
+    /**
+     * Reuses existing DOMDocument object.
+     * Chainable.
+     *
+     * @param $document DOMDocument
+     * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+     * @TODO support DOMDocument
+     */
+    public static function loadDocument($document) {
+        // TODO
+        die('TODO loadDocument');
+    }
+    /**
+     * Enter description here...
+     *
+     * @param unknown_type $html
+     * @param unknown_type $domId
+     * @return unknown New DOM ID
+     * @todo support PHP tags in input
+     * @todo support passing DOMDocument object from self::loadDocument
+     */
+    protected static function createDocumentWrapper($html, $contentType = null, $documentID = null) {
+        if (function_exists('domxml_open_mem'))
+            throw new Exception("Old PHP4 DOM XML extension detected. phpQuery won't work until this extension is enabled.");
+//      $id = $documentID
+//          ? $documentID
+//          : md5(microtime());
+        $document = null;
+        if ($html instanceof DOMDOCUMENT) {
+            if (self::getDocumentID($html)) {
+                // document already exists in phpQuery::$documents, make a copy
+                $document = clone $html;
+            } else {
+                // new document, add it to phpQuery::$documents
+                $wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
+            }
+        } else {
+            $wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
+        }
+//      $wrapper->id = $id;
+        // bind document
+        phpQuery::$documents[$wrapper->id] = $wrapper;
+        // remember last loaded document
+        phpQuery::selectDocument($wrapper->id);
+        return $wrapper->id;
+    }
+    /**
+     * Extend class namespace.
+     *
+     * @param string|array $target
+     * @param array $source
+     * @TODO support string $source
+     * @return unknown_type
+     */
+    public static function extend($target, $source) {
+        switch($target) {
+            case 'phpQueryObject':
+                $targetRef = &self::$extendMethods;
+                $targetRef2 = &self::$pluginsMethods;
+                break;
+            case 'phpQuery':
+                $targetRef = &self::$extendStaticMethods;
+                $targetRef2 = &self::$pluginsStaticMethods;
+                break;
+            default:
+                throw new Exception("Unsupported \$target type");
+        }
+        if (is_string($source))
+            $source = array($source => $source);
+        foreach($source as $method => $callback) {
+            if (isset($targetRef[$method])) {
+//              throw new Exception
+                self::debug("Duplicate method '{$method}', can\'t extend '{$target}'");
+                continue;
+            }
+            if (isset($targetRef2[$method])) {
+//              throw new Exception
+                self::debug("Duplicate method '{$method}' from plugin '{$targetRef2[$method]}',"
+                    ." can\'t extend '{$target}'");
+                continue;
+            }
+            $targetRef[$method] = $callback;
+        }
+        return true;
+    }
+    /**
+     * Extend phpQuery with $class from $file.
+     *
+     * @param string $class Extending class name. Real class name can be prepended phpQuery_.
+     * @param string $file Filename to include. Defaults to "{$class}.php".
+     */
+    public static function plugin($class, $file = null) {
+        // TODO $class checked agains phpQuery_$class
+//      if (strpos($class, 'phpQuery') === 0)
+//          $class = substr($class, 8);
+        if (in_array($class, self::$pluginsLoaded))
+            return true;
+        if (! $file)
+            $file = $class.'.php';
+        $objectClassExists = class_exists('phpQueryObjectPlugin_'.$class);
+        $staticClassExists = class_exists('phpQueryPlugin_'.$class);
+        if (! $objectClassExists && ! $staticClassExists)
+            require_once($file);
+        self::$pluginsLoaded[] = $class;
+        // static methods
+        if (class_exists('phpQueryPlugin_'.$class)) {
+            $realClass = 'phpQueryPlugin_'.$class;
+            $vars = get_class_vars($realClass);
+            $loop = isset($vars['phpQueryMethods'])
+                && ! is_null($vars['phpQueryMethods'])
+                ? $vars['phpQueryMethods']
+                : get_class_methods($realClass);
+            foreach($loop as $method) {
+                if ($method == '__initialize')
+                    continue;
+                if (! is_callable(array($realClass, $method)))
+                    continue;
+                if (isset(self::$pluginsStaticMethods[$method])) {
+                    throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsStaticMethods[$method]."'");
+                    return;
+                }
+                self::$pluginsStaticMethods[$method] = $class;
+            }
+            if (method_exists($realClass, '__initialize'))
+                call_user_func_array(array($realClass, '__initialize'), array());
+        }
+        // object methods
+        if (class_exists('phpQueryObjectPlugin_'.$class)) {
+            $realClass = 'phpQueryObjectPlugin_'.$class;
+            $vars = get_class_vars($realClass);
+            $loop = isset($vars['phpQueryMethods'])
+                && ! is_null($vars['phpQueryMethods'])
+                ? $vars['phpQueryMethods']
+                : get_class_methods($realClass);
+            foreach($loop as $method) {
+                if (! is_callable(array($realClass, $method)))
+                    continue;
+                if (isset(self::$pluginsMethods[$method])) {
+                    throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsMethods[$method]."'");
+                    continue;
+                }
+                self::$pluginsMethods[$method] = $class;
+            }
+        }
+        return true;
+    }
+    /**
+     * Unloades all or specified document from memory.
+     *
+     * @param mixed $documentID @see phpQuery::getDocumentID() for supported types.
+     */
+    public static function unloadDocuments($id = null) {
+        if (isset($id)) {
+            if ($id = self::getDocumentID($id))
+                unset(phpQuery::$documents[$id]);
+        } else {
+            foreach(phpQuery::$documents as $k => $v) {
+                unset(phpQuery::$documents[$k]);
+            }
+        }
+    }
+    /**
+     * Parses phpQuery object or HTML result against PHP tags and makes them active.
+     *
+     * @param phpQuery|string $content
+     * @deprecated
+     * @return string
+     */
+    public static function unsafePHPTags($content) {
+        return self::markupToPHP($content);
+    }
+    public static function DOMNodeListToArray($DOMNodeList) {
+        $array = array();
+        if (! $DOMNodeList)
+            return $array;
+        foreach($DOMNodeList as $node)
+            $array[] = $node;
+        return $array;
+    }
+    /**
+     * Checks if $input is HTML string, which has to start with '<'.
+     *
+     * @deprecated
+     * @param String $input
+     * @return Bool
+     * @todo still used ?
+     */
+    public static function isMarkup($input) {
+        return ! is_array($input) && substr(trim($input), 0, 1) == '<';
+    }
+    public static function debug($text) {
+        if (self::$debug)
+            print var_dump($text);
+    }
+    /**
+     * Make an AJAX request.
+     *
+     * @param array See $options http://docs.jquery.com/Ajax/jQuery.ajax#toptions
+     * Additional options are:
+     * 'document' - document for global events, @see phpQuery::getDocumentID()
+     * 'referer' - implemented
+     * 'requested_with' - TODO; not implemented (X-Requested-With)
+     * @return Zend_Http_Client
+     * @link http://docs.jquery.com/Ajax/jQuery.ajax
+     *
+     * @TODO $options['cache']
+     * @TODO $options['processData']
+     * @TODO $options['xhr']
+     * @TODO $options['data'] as string
+     * @TODO XHR interface
+     */
+    public static function ajax($options = array(), $xhr = null) {
+        $options = array_merge(
+            self::$ajaxSettings, $options
+        );
+        $documentID = isset($options['document'])
+            ? self::getDocumentID($options['document'])
+            : null;
+        if ($xhr) {
+            // reuse existing XHR object, but clean it up
+            $client = $xhr;
+//          $client->setParameterPost(null);
+//          $client->setParameterGet(null);
+            $client->setAuth(false);
+            $client->setHeaders("If-Modified-Since", null);
+            $client->setHeaders("Referer", null);
+            $client->resetParameters();
+        } else {
+            // create new XHR object
+            require_once('Zend/Http/Client.php');
+            $client = new Zend_Http_Client();
+            $client->setCookieJar();
+        }
+        if (isset($options['timeout']))
+            $client->setConfig(array(
+                'timeout'      => $options['timeout'],
+            ));
+//          'maxredirects' => 0,
+        foreach(self::$ajaxAllowedHosts as $k => $host)
+            if ($host == '.' && isset($_SERVER['HTTP_HOST']))
+                self::$ajaxAllowedHosts[$k] = $_SERVER['HTTP_HOST'];
+        $host = parse_url($options['url'], PHP_URL_HOST);
+        if (! in_array($host, self::$ajaxAllowedHosts)) {
+            throw new Exception("Request not permitted, host '$host' not present in "
+                ."phpQuery::\$ajaxAllowedHosts");
+        }
+        // JSONP
+        $jsre = "/=\\?(&|$)/";
+        if (isset($options['dataType']) && $options['dataType'] == 'jsonp') {
+            $jsonpCallbackParam = $options['jsonp']
+                ? $options['jsonp'] : 'callback';
+            if (strtolower($options['type']) == 'get') {
+                if (! preg_match($jsre, $options['url'])) {
+                    $sep = strpos($options['url'], '?')
+                        ? '&' : '?';
+                    $options['url'] .= "$sep$jsonpCallbackParam=?";
+                }
+            } else if ($options['data']) {
+                $jsonp = false;
+                foreach($options['data'] as $n => $v) {
+                    if ($v == '?')
+                        $jsonp = true;
+                }
+                if (! $jsonp) {
+                    $options['data'][$jsonpCallbackParam] = '?';
+                }
+            }
+            $options['dataType'] = 'json';
+        }
+        if (isset($options['dataType']) && $options['dataType'] == 'json') {
+            $jsonpCallback = 'json_'.md5(microtime());
+            $jsonpData = $jsonpUrl = false;
+            if ($options['data']) {
+                foreach($options['data'] as $n => $v) {
+                    if ($v == '?')
+                        $jsonpData = $n;
+                }
+            }
+            if (preg_match($jsre, $options['url']))
+                $jsonpUrl = true;
+            if ($jsonpData !== false || $jsonpUrl) {
+                // remember callback name for httpData()
+                $options['_jsonp'] = $jsonpCallback;
+                if ($jsonpData !== false)
+                    $options['data'][$jsonpData] = $jsonpCallback;
+                if ($jsonpUrl)
+                    $options['url'] = preg_replace($jsre, "=$jsonpCallback\\1", $options['url']);
+            }
+        }
+        $client->setUri($options['url']);
+        $client->setMethod(strtoupper($options['type']));
+        if (isset($options['referer']) && $options['referer'])
+            $client->setHeaders('Referer', $options['referer']);
+        $client->setHeaders(array(
+//          'content-type' => $options['contentType'],
+            'User-Agent' => 'Mozilla/5.0 (X11; U; Linux x86; en-US; rv:1.9.0.5) Gecko'
+                 .'/2008122010 Firefox/3.0.5',
+            // TODO custom charset
+            'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+//          'Connection' => 'keep-alive',
+//          'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language' => 'en-us,en;q=0.5',
+        ));
+        if ($options['username'])
+            $client->setAuth($options['username'], $options['password']);
+        if (isset($options['ifModified']) && $options['ifModified'])
+            $client->setHeaders("If-Modified-Since",
+                self::$lastModified
+                    ? self::$lastModified
+                    : "Thu, 01 Jan 1970 00:00:00 GMT"
+            );
+        $client->setHeaders("Accept",
+            isset($options['dataType'])
+            && isset(self::$ajaxSettings['accepts'][ $options['dataType'] ])
+                ? self::$ajaxSettings['accepts'][ $options['dataType'] ].", */*"
+                : self::$ajaxSettings['accepts']['_default']
+        );
+        // TODO $options['processData']
+        if ($options['data'] instanceof phpQueryObject) {
+            $serialized = $options['data']->serializeArray($options['data']);
+            $options['data'] = array();
+            foreach($serialized as $r)
+                $options['data'][ $r['name'] ] = $r['value'];
+        }
+        if (strtolower($options['type']) == 'get') {
+            $client->setParameterGet($options['data']);
+        } else if (strtolower($options['type']) == 'post') {
+            $client->setEncType($options['contentType']);
+            $client->setParameterPost($options['data']);
+        }
+        if (self::$active == 0 && $options['global'])
+            phpQueryEvents::trigger($documentID, 'ajaxStart');
+        self::$active++;
+        // beforeSend callback
+        if (isset($options['beforeSend']) && $options['beforeSend'])
+            phpQuery::callbackRun($options['beforeSend'], array($client));
+        // ajaxSend event
+        if ($options['global'])
+            phpQueryEvents::trigger($documentID, 'ajaxSend', array($client, $options));
+        if (phpQuery::$debug) {
+            self::debug("{$options['type']}: {$options['url']}\n");
+            self::debug("Options: <pre>".var_export($options, true)."</pre>\n");
+//          if ($client->getCookieJar())
+//              self::debug("Cookies: <pre>".var_export($client->getCookieJar()->getMatchingCookies($options['url']), true)."</pre>\n");
+        }
+        // request
+        $response = $client->request();
+        if (phpQuery::$debug) {
+            self::debug('Status: '.$response->getStatus().' / '.$response->getMessage());
+            self::debug($client->getLastRequest());
+            self::debug($response->getHeaders());
+        }
+        if ($response->isSuccessful()) {
+            // XXX tempolary
+            self::$lastModified = $response->getHeader('Last-Modified');
+            $data = self::httpData($response->getBody(), $options['dataType'], $options);
+            if (isset($options['success']) && $options['success'])
+                phpQuery::callbackRun($options['success'], array($data, $response->getStatus(), $options));
+            if ($options['global'])
+                phpQueryEvents::trigger($documentID, 'ajaxSuccess', array($client, $options));
+        } else {
+            if (isset($options['error']) && $options['error'])
+                phpQuery::callbackRun($options['error'], array($client, $response->getStatus(), $response->getMessage()));
+            if ($options['global'])
+                phpQueryEvents::trigger($documentID, 'ajaxError', array($client, /*$response->getStatus(),*/$response->getMessage(), $options));
+        }
+        if (isset($options['complete']) && $options['complete'])
+            phpQuery::callbackRun($options['complete'], array($client, $response->getStatus()));
+        if ($options['global'])
+            phpQueryEvents::trigger($documentID, 'ajaxComplete', array($client, $options));
+        if ($options['global'] && ! --self::$active)
+            phpQueryEvents::trigger($documentID, 'ajaxStop');
+        return $client;
+//      if (is_null($domId))
+//          $domId = self::$defaultDocumentID ? self::$defaultDocumentID : false;
+//      return new phpQueryAjaxResponse($response, $domId);
+    }
+    protected static function httpData($data, $type, $options) {
+        if (isset($options['dataFilter']) && $options['dataFilter'])
+            $data = self::callbackRun($options['dataFilter'], array($data, $type));
+        if (is_string($data)) {
+            if ($type == "json") {
+                if (isset($options['_jsonp']) && $options['_jsonp']) {
+                    $data = preg_replace('/^\s*\w+\((.*)\)\s*$/s', '$1', $data);
+                }
+                $data = self::parseJSON($data);
+            }
+        }
+        return $data;
+    }
+    /**
+     * Enter description here...
+     *
+     * @param array|phpQuery $data
+     *
+     */
+    public static function param($data) {
+        return http_build_query($data, null, '&');
+    }
+    public static function get($url, $data = null, $callback = null, $type = null) {
+        if (!is_array($data)) {
+            $callback = $data;
+            $data = null;
+        }
+        // TODO some array_values on this shit
+        return phpQuery::ajax(array(
+            'type' => 'GET',
+            'url' => $url,
+            'data' => $data,
+            'success' => $callback,
+            'dataType' => $type,
+        ));
+    }
+    public static function post($url, $data = null, $callback = null, $type = null) {
+        if (!is_array($data)) {
+            $callback = $data;
+            $data = null;
+        }
+        return phpQuery::ajax(array(
+            'type' => 'POST',
+            'url' => $url,
+            'data' => $data,
+            'success' => $callback,
+            'dataType' => $type,
+        ));
+    }
+    public static function getJSON($url, $data = null, $callback = null) {
+        if (!is_array($data)) {
+            $callback = $data;
+            $data = null;
+        }
+        // TODO some array_values on this shit
+        return phpQuery::ajax(array(
+            'type' => 'GET',
+            'url' => $url,
+            'data' => $data,
+            'success' => $callback,
+            'dataType' => 'json',
+        ));
+    }
+    public static function ajaxSetup($options) {
+        self::$ajaxSettings = array_merge(
+            self::$ajaxSettings,
+            $options
+        );
+    }
+    public static function ajaxAllowHost($host1, $host2 = null, $host3 = null) {
+        $loop = is_array($host1)
+            ? $host1
+            : func_get_args();
+        foreach($loop as $host) {
+            if ($host && ! in_array($host, phpQuery::$ajaxAllowedHosts)) {
+                phpQuery::$ajaxAllowedHosts[] = $host;
+            }
+        }
+    }
+    public static function ajaxAllowURL($url1, $url2 = null, $url3 = null) {
+        $loop = is_array($url1)
+            ? $url1
+            : func_get_args();
+        foreach($loop as $url)
+            phpQuery::ajaxAllowHost(parse_url($url, PHP_URL_HOST));
+    }
+    /**
+     * Returns JSON representation of $data.
+     *
+     * @static
+     * @param mixed $data
+     * @return string
+     */
+    public static function toJSON($data) {
+        if (function_exists('json_encode'))
+            return json_encode($data);
+        require_once('Zend/Json/Encoder.php');
+        return Zend_Json_Encoder::encode($data);
+    }
+    /**
+     * Parses JSON into proper PHP type.
+     *
+     * @static
+     * @param string $json
+     * @return mixed
+     */
+    public static function parseJSON($json) {
+        if (function_exists('json_decode')) {
+            $return = json_decode(trim($json), true);
+            // json_decode and UTF8 issues
+            if (isset($return))
+                return $return;
+        }
+        require_once('Zend/Json/Decoder.php');
+        return Zend_Json_Decoder::decode($json);
+    }
+    /**
+     * Returns source's document ID.
+     *
+     * @param $source DOMNode|phpQueryObject
+     * @return string
+     */
+    public static function getDocumentID($source) {
+        if ($source instanceof DOMDOCUMENT) {
+            foreach(phpQuery::$documents as $id => $document) {
+                if ($source->isSameNode($document->document))
+                    return $id;
+            }
+        } else if ($source instanceof DOMNODE) {
+            foreach(phpQuery::$documents as $id => $document) {
+                if ($source->ownerDocument->isSameNode($document->document))
+                    return $id;
+            }
+        } else if ($source instanceof phpQueryObject)
+            return $source->getDocumentID();
+        else if (is_string($source) && isset(phpQuery::$documents[$source]))
+            return $source;
+    }
+    /**
+     * Get DOMDocument object related to $source.
+     * Returns null if such document doesn't exist.
+     *
+     * @param $source DOMNode|phpQueryObject|string
+     * @return string
+     */
+    public static function getDOMDocument($source) {
+        if ($source instanceof DOMDOCUMENT)
+            return $source;
+        $source = self::getDocumentID($source);
+        return $source
+            ? self::$documents[$id]['document']
+            : null;
+    }
+
+    // UTILITIES
+    // http://docs.jquery.com/Utilities
+
+    /**
+     *
+     * @return unknown_type
+     * @link http://docs.jquery.com/Utilities/jQuery.makeArray
+     */
+    public static function makeArray($obj) {
+        $array = array();
+        if (is_object($object) && $object instanceof DOMNODELIST) {
+            foreach($object as $value)
+                $array[] = $value;
+        } else if (is_object($object) && ! ($object instanceof Iterator)) {
+            foreach(get_object_vars($object) as $name => $value)
+                $array[0][$name] = $value;
+        } else {
+            foreach($object as $name => $value)
+                $array[0][$name] = $value;
+        }
+        return $array;
+    }
+    public static function inArray($value, $array) {
+        return in_array($value, $array);
+    }
+    /**
+     *
+     * @param $object
+     * @param $callback
+     * @return unknown_type
+     * @link http://docs.jquery.com/Utilities/jQuery.each
+     */
+    public static function each($object, $callback, $param1 = null, $param2 = null, $param3 = null) {
+        $paramStructure = null;
+        if (func_num_args() > 2) {
+            $paramStructure = func_get_args();
+            $paramStructure = array_slice($paramStructure, 2);
+        }
+        if (is_object($object) && ! ($object instanceof Iterator)) {
+            foreach(get_object_vars($object) as $name => $value)
+                phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
+        } else {
+            foreach($object as $name => $value)
+                phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
+        }
+    }
+    /**
+     *
+     * @link http://docs.jquery.com/Utilities/jQuery.map
+     */
+    public static function map($array, $callback, $param1 = null, $param2 = null, $param3 = null) {
+        $result = array();
+        $paramStructure = null;
+        if (func_num_args() > 2) {
+            $paramStructure = func_get_args();
+            $paramStructure = array_slice($paramStructure, 2);
+        }
+        foreach($array as $v) {
+            $vv = phpQuery::callbackRun($callback, array($v), $paramStructure);
+//          $callbackArgs = $args;
+//          foreach($args as $i => $arg) {
+//              $callbackArgs[$i] = $arg instanceof CallbackParam
+//                  ? $v
+//                  : $arg;
+//          }
+//          $vv = call_user_func_array($callback, $callbackArgs);
+            if (is_array($vv))  {
+                foreach($vv as $vvv)
+                    $result[] = $vvv;
+            } else if ($vv !== null) {
+                $result[] = $vv;
+            }
+        }
+        return $result;
+    }
+    /**
+     *
+     * @param $callback Callback
+     * @param $params
+     * @param $paramStructure
+     * @return unknown_type
+     */
+    public static function callbackRun($callback, $params = array(), $paramStructure = null) {
+        if (! $callback)
+            return;
+        if ($callback instanceof CallbackParameterToReference) {
+            // TODO support ParamStructure to select which $param push to reference
+            if (isset($params[0]))
+                $callback->callback = $params[0];
+            return true;
+        }
+        if ($callback instanceof Callback) {
+            $paramStructure = $callback->params;
+            $callback = $callback->callback;
+        }
+        if (! $paramStructure)
+            return call_user_func_array($callback, $params);
+        $p = 0;
+        foreach($paramStructure as $i => $v) {
+            $paramStructure[$i] = $v instanceof CallbackParam
+                ? $params[$p++]
+                : $v;
+        }
+        return call_user_func_array($callback, $paramStructure);
+    }
+    /**
+     * Merge 2 phpQuery objects.
+     * @param array $one
+     * @param array $two
+     * @protected
+     * @todo node lists, phpQueryObject
+     */
+    public static function merge($one, $two) {
+        $elements = $one->elements;
+        foreach($two->elements as $node) {
+            $exists = false;
+            foreach($elements as $node2) {
+                if ($node2->isSameNode($node))
+                    $exists = true;
+            }
+            if (! $exists)
+                $elements[] = $node;
+        }
+        return $elements;
+//      $one = $one->newInstance();
+//      $one->elements = $elements;
+//      return $one;
+    }
+    /**
+     *
+     * @param $array
+     * @param $callback
+     * @param $invert
+     * @return unknown_type
+     * @link http://docs.jquery.com/Utilities/jQuery.grep
+     */
+    public static function grep($array, $callback, $invert = false) {
+        $result = array();
+        foreach($array as $k => $v) {
+            $r = call_user_func_array($callback, array($v, $k));
+            if ($r === !(bool)$invert)
+                $result[] = $v;
+        }
+        return $result;
+    }
+    public static function unique($array) {
+        return array_unique($array);
+    }
+    /**
+     *
+     * @param $function
+     * @return unknown_type
+     * @TODO there are problems with non-static methods, second parameter pass it
+     *  but doesnt verify is method is really callable
+     */
+    public static function isFunction($function) {
+        return is_callable($function);
+    }
+    public static function trim($str) {
+        return trim($str);
+    }
+    /* PLUGINS NAMESPACE */
+    /**
+     *
+     * @param $url
+     * @param $callback
+     * @param $param1
+     * @param $param2
+     * @param $param3
+     * @return phpQueryObject
+     */
+    public static function browserGet($url, $callback, $param1 = null, $param2 = null, $param3 = null) {
+        if (self::plugin('WebBrowser')) {
+            $params = func_get_args();
+            return self::callbackRun(array(self::$plugins, 'browserGet'), $params);
+        } else {
+            self::debug('WebBrowser plugin not available...');
+        }
+    }
+    /**
+     *
+     * @param $url
+     * @param $data
+     * @param $callback
+     * @param $param1
+     * @param $param2
+     * @param $param3
+     * @return phpQueryObject
+     */
+    public static function browserPost($url, $data, $callback, $param1 = null, $param2 = null, $param3 = null) {
+        if (self::plugin('WebBrowser')) {
+            $params = func_get_args();
+            return self::callbackRun(array(self::$plugins, 'browserPost'), $params);
+        } else {
+            self::debug('WebBrowser plugin not available...');
+        }
+    }
+    /**
+     *
+     * @param $ajaxSettings
+     * @param $callback
+     * @param $param1
+     * @param $param2
+     * @param $param3
+     * @return phpQueryObject
+     */
+    public static function browser($ajaxSettings, $callback, $param1 = null, $param2 = null, $param3 = null) {
+        if (self::plugin('WebBrowser')) {
+            $params = func_get_args();
+            return self::callbackRun(array(self::$plugins, 'browser'), $params);
+        } else {
+            self::debug('WebBrowser plugin not available...');
+        }
+    }
+    /**
+     *
+     * @param $code
+     * @return string
+     */
+    public static function php($code) {
+        return self::code('php', $code);
+    }
+    /**
+     *
+     * @param $type
+     * @param $code
+     * @return string
+     */
+    public static function code($type, $code) {
+        return "<$type><!-- ".trim($code)." --></$type>";
+    }
+
+    public static function __callStatic($method, $params) {
+        return call_user_func_array(
+            array(phpQuery::$plugins, $method),
+            $params
+        );
+    }
+    protected static function dataSetupNode($node, $documentID) {
+        // search are return if alredy exists
+        foreach(phpQuery::$documents[$documentID]->dataNodes as $dataNode) {
+            if ($node->isSameNode($dataNode))
+                return $dataNode;
+        }
+        // if doesn't, add it
+        phpQuery::$documents[$documentID]->dataNodes[] = $node;
+        return $node;
+    }
+    protected static function dataRemoveNode($node, $documentID) {
+        // search are return if alredy exists
+        foreach(phpQuery::$documents[$documentID]->dataNodes as $k => $dataNode) {
+            if ($node->isSameNode($dataNode)) {
+                unset(self::$documents[$documentID]->dataNodes[$k]);
+                unset(self::$documents[$documentID]->data[ $dataNode->dataID ]);
+            }
+        }
+    }
+    public static function data($node, $name, $data, $documentID = null) {
+        if (! $documentID)
+            // TODO check if this works
+            $documentID = self::getDocumentID($node);
+        $document = phpQuery::$documents[$documentID];
+        $node = self::dataSetupNode($node, $documentID);
+        if (! isset($node->dataID))
+            $node->dataID = ++phpQuery::$documents[$documentID]->uuid;
+        $id = $node->dataID;
+        if (! isset($document->data[$id]))
+            $document->data[$id] = array();
+        if (! is_null($data))
+            $document->data[$id][$name] = $data;
+        if ($name) {
+            if (isset($document->data[$id][$name]))
+                return $document->data[$id][$name];
+        } else
+            return $id;
+    }
+    public static function removeData($node, $name, $documentID) {
+        if (! $documentID)
+            // TODO check if this works
+            $documentID = self::getDocumentID($node);
+        $document = phpQuery::$documents[$documentID];
+        $node = self::dataSetupNode($node, $documentID);
+        $id = $node->dataID;
+        if ($name) {
+            if (isset($document->data[$id][$name]))
+                unset($document->data[$id][$name]);
+            $name = null;
+            foreach($document->data[$id] as $name)
+                break;
+            if (! $name)
+                self::removeData($node, $name, $documentID);
+        } else {
+            self::dataRemoveNode($node, $documentID);
+        }
+    }
+}
+/**
+ * Plugins static namespace class.
+ *
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @package phpQuery
+ * @todo move plugin methods here (as statics)
+ */
+class phpQueryPlugins {
+    public function __call($method, $args) {
+        if (isset(phpQuery::$extendStaticMethods[$method])) {
+            $return = call_user_func_array(
+                phpQuery::$extendStaticMethods[$method],
+                $args
+            );
+        } else if (isset(phpQuery::$pluginsStaticMethods[$method])) {
+            $class = phpQuery::$pluginsStaticMethods[$method];
+            $realClass = "phpQueryPlugin_$class";
+            $return = call_user_func_array(
+                array($realClass, $method),
+                $args
+            );
+            return isset($return)
+                ? $return
+                : $this;
+        } else
+            throw new Exception("Method '{$method}' doesnt exist");
+    }
+}
+/**
+ * Shortcut to phpQuery::pq($arg1, $context)
+ * Chainable.
+ *
+ * @see phpQuery::pq()
+ * @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
+ * @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
+ * @package phpQuery
+ */
+function pq($arg1, $context = null) {
+    $args = func_get_args();
+    return call_user_func_array(
+        array('phpQuery', 'pq'),
+        $args
+    );
+}
+// add plugins dir and Zend framework to include path
+set_include_path(
+    get_include_path()
+        .PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/'
+        .PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/plugins/'
+);
+// why ? no __call nor __get for statics in php...
+// XXX __callStatic will be available in PHP 5.3
+phpQuery::$plugins = new phpQueryPlugins();
+// include bootstrap file (personal library config)
+if (file_exists(dirname(__FILE__).'/phpQuery/bootstrap.php'))
+    require_once dirname(__FILE__).'/phpQuery/bootstrap.php';