pseudo-dom 0.6.0 → 0.8.0

package/README.md

@@ -45,9 +45,21 @@ children, \`childElementCount\`, \`firstElementChild\` / \`lastElementChild\` an
 a tree rather than duplicating it; \`insertAdjacentElement\` / \`insertAdjacentText\` insert at beforebegin / afterbegin
 / beforeend / afterend (\`insertAdjacentHTML\` is not implemented, no HTML parsing yet).
 
-Not implemented yet (these throw a "not implemented" error or are missing): `querySelector` /
-`querySelectorAll`, `innerHTML` / `outerHTML` parsing, and most of the rest of the Element and Document APIs. The API
-will change before 1.0.
+Selector queries work like the DOM's: \`getElementsByTagName\` / \`getElementsByClassName\` (live, on any node) and
+\`querySelector\` / \`querySelectorAll\` (real CSS selectors, via [css-select](https://www.npmjs.com/package/css-select)
+matched against pseudo-dom's own tree through a custom adapter - \`querySelectorAll\` is a plain array, a snapshot
+taken when it is called, like the DOM's) are on \`NodeService\` so \`Document\`, \`DocumentFragment\` and \`Element\`
+all have them; \`matches\` / \`closest\` are on \`ElementService\`; \`getElementById\` is on both \`DocumentService\`
+and \`DocumentFragmentService\` (the DOM's \`NonElementParentNode\` mixin, so a \`ShadowRoot\` gets it too), matching
+the real DOM.
+
+\`DocumentService\` matches the real \`Document\` (it is not an \`Element\`, so it has no \`tagName\` / \`classList\` /
+\`matches\` / etc.): \`createElement\`, \`createTextNode\`, \`createComment\`, \`createDocumentFragment\`,
+\`getElementById\`, and \`textContent\` always \`null\`. \`PseudoHTMLDocument\` (what \`generateDocument\` actually
+creates) only adds the \`html\` / \`head\` / \`body\` structure on top.
+
+Not implemented yet (these throw a "not implemented" error or are missing): \`getElementsByTagNameNS\`, \`innerHTML\` /
+\`outerHTML\` parsing, and most of the rest of the Element and Document APIs. The API will change before 1.0.
 ## Modules
 
 <dl>
@@ -94,8 +106,8 @@ interface (the mouse, the keyboard, focus and input).</p>
 <dd><p>Simulate the behaviour of the HTMLElement Class when there is no DOM available.</p>
 </dd>
 <dt><a href="#HTMLCollectionService">HTMLCollectionService</a></dt>
-<dd><p>Simulate the behaviour of the HTMLCollection Class when there is no DOM available: a live view of the element
-children of a node, recomputed from its childNodes each time it is used rather than kept in sync as they change.</p>
+<dd><p>Simulate the behaviour of the HTMLCollection Class when there is no DOM available: a live view of some of a node&#39;s
+element descendants, recomputed each time it is used rather than kept in sync as they change.</p>
 </dd>
 <dt><a href="#FocusEventService">FocusEventService</a> ⇐ <code><a href="#UIEventService">UIEventService</a></code></dt>
 <dd><p>Simulate the behaviour of the FocusEvent Class when there is no DOM available.</p>
@@ -128,16 +140,14 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 <dt><a href="#AttrService">AttrService</a> ⇐ <code><a href="#NodeService">NodeService</a></code></dt>
 <dd><p>Simulate the behaviour of the Attr Class when there is no DOM available.</p>
 </dd>
-<dt><a href="#LinkedNode">LinkedNode</a> ⇐ <code><a href="#NodeService">NodeService</a></code></dt>
-<dd><p>A node which is stored in a TreeLinker (for example by a list built from an array of values). It finds its siblings
-from that linker, and its parent from the linker&#39;s parent when it has not been given one by appendChild.</p>
-</dd>
 <dt><a href="#PseudoNodeList">PseudoNodeList</a> ⇐ <code>LinkedTreeList</code></dt>
 <dd><p>A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
 the linkers that hold them.</p>
 </dd>
-<dt><a href="#PseudoHTMLDocument">PseudoHTMLDocument</a> ⇐ <code>PseudoHTMLElement</code></dt>
-<dd><p>Simulate the behaviour of the HTMLDocument Class when there is no DOM available.</p>
+<dt><a href="#PseudoHTMLDocument">PseudoHTMLDocument</a> ⇐ <code><a href="#DocumentService">DocumentService</a></code></dt>
+<dd><p>Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
+only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
+createComment, createDocumentFragment, getElementById, textContent always null).</p>
 </dd>
 <dt><a href="#PseudoEventListener">PseudoEventListener</a></dt>
 <dd><p>Handle events as they are stored and implemented.</p>
@@ -161,8 +171,6 @@ The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop,
 <dt><a href="#focused">focused</a></dt>
 <dd><p>The element which has the focus, kept for each tree (the root node of the tree it is in), like document.activeElement.</p>
 </dd>
-<dt><a href="#HTMLElementService_1">HTMLElementService_1</a> : <code>PseudoHTMLElement</code></dt>
-<dd></dd>
 </dl>
 
 ## Functions
@@ -192,14 +200,13 @@ order in which an event travels down through them). A node which has no parent h
 <dt><a href="#generateNodeList">generateNodeList([innerList])</a> ⇒ <code><a href="#PseudoNodeList">PseudoNodeList</a></code></dt>
 <dd><p>Create a PseudoNodeList, optionally starting from an existing chain of linkers.</p>
 </dd>
-<dt><a href="#generateNode">generateNode()</a> ⇒ <code>function</code></dt>
-<dd><p>Create a TreeLinker class whose linkers each store a node (a LinkedNode) as their data, this can be used to build a
-tree (or list) of nodes from plain values.</p>
-</dd>
 <dt><a href="#generateDocument">generateDocument(root, context)</a> ⇒ <code>Window</code> | <code>PseudoEventTarget</code></dt>
 <dd><p>Construct the Pseudo Dom to provide access to Dom objects which are otherwise not available outside the browser
 context.</p>
 </dd>
+<dt><a href="#nearestElementSibling">nearestElementSibling(node, direction)</a> ⇒ <code>*</code> | <code>null</code></dt>
+<dd><p>Walk up from a node (not including it) to find the nearest element, in the given direction.</p>
+</dd>
 <dt><a href="#createEvent">createEvent(type, [init], [options])</a> ⇒ <code><a href="#EventService">EventService</a></code></dt>
 <dd><p>Create an event of the kind which suits its type (a click is a MouseEvent, a keydown a KeyboardEvent, ...).
 By default this is like using the constructor of the event in a script: nothing bubbles or can be cancelled unless
@@ -456,6 +463,10 @@ Simulate the behaviour of the Node Class when there is no DOM available.
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
     * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
@@ -602,6 +613,51 @@ becomes a text node belonging to this node's document, anything else is returned
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### nodeService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### nodeService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### nodeService.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### nodeService.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### nodeService.childInserted(child)
@@ -752,6 +808,10 @@ Simulate the behaviour of the Text Class when there is no DOM available: the tex
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
     * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
@@ -935,6 +995,55 @@ becomes a text node belonging to this node's document, anything else is returned
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### textService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>getElementsByTagName</code>](#NodeService+getElementsByTagName)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### textService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>getElementsByClassName</code>](#NodeService+getElementsByClassName)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### textService.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>querySelector</code>](#NodeService+querySelector)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### textService.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>querySelectorAll</code>](#NodeService+querySelectorAll)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### textService.childInserted(child)
@@ -1092,6 +1201,10 @@ Simulate the behaviour of the Comment Class when there is no DOM available: a no
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
     * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
@@ -1258,6 +1371,55 @@ becomes a text node belonging to this node's document, anything else is returned
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### commentService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>CommentService</code>](#CommentService)  
+**Overrides**: [<code>getElementsByTagName</code>](#NodeService+getElementsByTagName)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### commentService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>CommentService</code>](#CommentService)  
+**Overrides**: [<code>getElementsByClassName</code>](#NodeService+getElementsByClassName)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### commentService.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>CommentService</code>](#CommentService)  
+**Overrides**: [<code>querySelector</code>](#NodeService+querySelector)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### commentService.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>CommentService</code>](#CommentService)  
+**Overrides**: [<code>querySelectorAll</code>](#NodeService+querySelectorAll)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### commentService.childInserted(child)
@@ -1715,14 +1877,14 @@ Take the focus away from the element, when it has it: it gets blur then focusout
 <a name="HTMLCollectionService"></a>
 
 ## HTMLCollectionService
-Simulate the behaviour of the HTMLCollection Class when there is no DOM available: a live view of the element
-children of a node, recomputed from its childNodes each time it is used rather than kept in sync as they change.
+Simulate the behaviour of the HTMLCollection Class when there is no DOM available: a live view of some of a node's
+element descendants, recomputed each time it is used rather than kept in sync as they change.
 
 **Kind**: global class  
 **Author**: Joshua Heagle <joshuaheagle@gmail.com>  
 
 * [HTMLCollectionService](#HTMLCollectionService)
-    * [new HTMLCollectionService(owner)](#new_HTMLCollectionService_new)
+    * [new HTMLCollectionService(owner, [predicate], [deep])](#new_HTMLCollectionService_new)
     * [.length](#HTMLCollectionService+length) ⇒ <code>number</code>
     * [.elements()](#HTMLCollectionService+elements) ⇒ <code>Array.&lt;PseudoNode&gt;</code>
     * [.item(index)](#HTMLCollectionService+item) ⇒ <code>\*</code>
@@ -1730,11 +1892,13 @@ children of a node, recomputed from its childNodes each time it is used rather t
 
 <a name="new_HTMLCollectionService_new"></a>
 
-### new HTMLCollectionService(owner)
+### new HTMLCollectionService(owner, [predicate], [deep])
 
-| Param | Type | Description |
-| --- | --- | --- |
-| owner | [<code>NodeService</code>](#NodeService) | The node whose element children this is a live view of |
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| owner | [<code>NodeService</code>](#NodeService) |  | The node this is a live view of a part of |
+| [predicate] | <code>function</code> |  | Only elements which pass this are included (every element by default) |
+| [deep] | <code>boolean</code> | <code>false</code> | Include every matching descendant (true, like getElementsByTagName), not just the direct element children (false, like Element.children) |
 
 <a name="HTMLCollectionService+length"></a>
 
@@ -1745,7 +1909,7 @@ How many elements are in the collection right now.
 <a name="HTMLCollectionService+elements"></a>
 
 ### htmlCollectionService.elements() ⇒ <code>Array.&lt;PseudoNode&gt;</code>
-The current element children of the owner, in order.
+The current elements the collection holds, in tree order.
 
 **Kind**: instance method of [<code>HTMLCollectionService</code>](#HTMLCollectionService)  
 <a name="HTMLCollectionService+item"></a>
@@ -2085,6 +2249,8 @@ Simulate the behaviour of the Element Class when there is no DOM available.
     * [.insertAdjacentText(position, text)](#ElementService+insertAdjacentText)
     * [.insertAdjacent(position, node)](#ElementService+insertAdjacent) ⇒ <code>PseudoNode</code> \| <code>null</code>
     * [.insertAdjacentHTML(position, text)](#ElementService+insertAdjacentHTML)
+    * [.matches(selectors)](#ElementService+matches) ⇒ <code>boolean</code>
+    * [.closest(selectors)](#ElementService+closest) ⇒ <code>PseudoElement</code> \| <code>null</code>
     * [.childInserted(child)](#ElementService+childInserted)
     * [.hasAttribute(attributeName)](#ElementService+hasAttribute) ⇒ <code>boolean</code>
     * [.setAttribute(attributeName, attributeValue)](#ElementService+setAttribute) ⇒ <code>undefined</code>
@@ -2233,6 +2399,29 @@ Not implemented yet (HTML parsing is out of scope for now).
 | position | <code>string</code> | beforebegin, afterbegin, beforeend or afterend |
 | text | <code>string</code> | The markup which would be parsed |
 
+<a name="ElementService+matches"></a>
+
+### elementService.matches(selectors) ⇒ <code>boolean</code>
+Whether this element itself (not its descendants) matches the given CSS selector.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="ElementService+closest"></a>
+
+### elementService.closest(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The nearest ancestor of this element (starting with this element itself) which matches the CSS selector, or
+null when none of them do.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="ElementService+childInserted"></a>
 
 ### elementService.childInserted(child)
@@ -2301,6 +2490,11 @@ Simulate the behaviour of the Document Class when there is no DOM available.
 
 * [DocumentService](#DocumentService) ⇐ [<code>NodeService</code>](#NodeService)
     * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.getElementById(id)](#DocumentService+getElementById) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.createElement([tagName])](#DocumentService+createElement) ⇒ <code>PseudoElement</code>
+    * [.createTextNode([data])](#DocumentService+createTextNode) ⇒ [<code>TextService</code>](#TextService)
+    * [.createComment([data])](#DocumentService+createComment) ⇒ [<code>CommentService</code>](#CommentService)
+    * [.createDocumentFragment()](#DocumentService+createDocumentFragment) ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
     * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
     * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</code>
@@ -2312,6 +2506,10 @@ Simulate the behaviour of the Document Class when there is no DOM available.
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
     * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
@@ -2328,6 +2526,57 @@ Simulate the behaviour of the Document Class when there is no DOM available.
 Whether this kind of node can have children (text, comments and attributes cannot).
 
 **Kind**: instance property of [<code>DocumentService</code>](#DocumentService)  
+<a name="DocumentService+getElementById"></a>
+
+### documentService.getElementById(id) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element, in tree order, whose id matches the given value, or null when there is none.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type |
+| --- | --- |
+| id | <code>string</code> | 
+
+<a name="DocumentService+createElement"></a>
+
+### documentService.createElement([tagName]) ⇒ <code>PseudoElement</code>
+Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [tagName] | <code>string</code> | <code>&quot;&#x27;div&#x27;&quot;</code> | The type of element to create |
+
+<a name="DocumentService+createTextNode"></a>
+
+### documentService.createTextNode([data]) ⇒ [<code>TextService</code>](#TextService)
+Make a text node which belongs to this document.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
+
+<a name="DocumentService+createComment"></a>
+
+### documentService.createComment([data]) ⇒ [<code>CommentService</code>](#CommentService)
+Make a comment which belongs to this document.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
+
+<a name="DocumentService+createDocumentFragment"></a>
+
+### documentService.createDocumentFragment() ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
+Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
+then inserted in one go.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
 <a name="NodeService+appendChild"></a>
 
 ### documentService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -2458,6 +2707,51 @@ becomes a text node belonging to this node's document, anything else is returned
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### documentService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### documentService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### documentService.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### documentService.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### documentService.childInserted(child)
@@ -2588,6 +2882,7 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 
 * [DocumentFragmentService](#DocumentFragmentService) ⇐ [<code>NodeService</code>](#NodeService)
     * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.getElementById(id)](#DocumentFragmentService+getElementById) ⇒ <code>PseudoElement</code> \| <code>null</code>
     * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
     * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</code>
@@ -2599,6 +2894,10 @@ not part of a tree, when it is inserted its children are moved into the tree ins
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
     * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
@@ -2615,6 +2914,18 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 Whether this kind of node can have children (text, comments and attributes cannot).
 
 **Kind**: instance property of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+<a name="DocumentFragmentService+getElementById"></a>
+
+### documentFragmentService.getElementById(id) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element, in tree order, whose id matches the given value, or null when there is none (the DOM's
+NonElementParentNode mixin, which Document and DocumentFragment both implement).
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type |
+| --- | --- |
+| id | <code>string</code> | 
+
 <a name="NodeService+appendChild"></a>
 
 ### documentFragmentService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -2745,6 +3056,51 @@ becomes a text node belonging to this node's document, anything else is returned
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### documentFragmentService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### documentFragmentService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### documentFragmentService.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### documentFragmentService.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### documentFragmentService.childInserted(child)
@@ -2971,6 +3327,10 @@ Simulate the behaviour of the Attr Class when there is no DOM available.
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
     * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
@@ -3141,6 +3501,55 @@ becomes a text node belonging to this node's document, anything else is returned
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### attrService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>getElementsByTagName</code>](#NodeService+getElementsByTagName)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### attrService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>getElementsByClassName</code>](#NodeService+getElementsByClassName)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### attrService.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>querySelector</code>](#NodeService+querySelector)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### attrService.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>querySelectorAll</code>](#NodeService+querySelectorAll)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### attrService.childInserted(child)
@@ -3268,21 +3677,69 @@ Replace a child of this node with another node (which is moved if it is already
 | newChild | <code>PseudoNode</code> | The node which takes the place |
 | oldChild | <code>PseudoNode</code> | The child of this node to replace |
 
-<a name="LinkedNode"></a>
+<a name="PseudoNodeList"></a>
 
-## LinkedNode ⇐ [<code>NodeService</code>](#NodeService)
-A node which is stored in a TreeLinker (for example by a list built from an array of values). It finds its siblings
-from that linker, and its parent from the linker's parent when it has not been given one by appendChild.
+## PseudoNodeList ⇐ <code>LinkedTreeList</code>
+A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
+the linkers that hold them.
 
 **Kind**: global class  
-**Extends**: [<code>NodeService</code>](#NodeService)  
-**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Extends**: <code>LinkedTreeList</code>  
 
-* [LinkedNode](#LinkedNode) ⇐ [<code>NodeService</code>](#NodeService)
-    * [new LinkedNode(linker, value)](#new_LinkedNode_new)
-    * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+* [PseudoNodeList](#PseudoNodeList) ⇐ <code>LinkedTreeList</code>
+    * [.entries()](#PseudoNodeList+entries) ⇒ <code>Iterator</code>
+    * [.keys()](#PseudoNodeList+keys) ⇒ <code>Iterator</code>
+    * [.values()](#PseudoNodeList+values) ⇒ <code>Iterator</code>
+
+<a name="PseudoNodeList+entries"></a>
+
+### pseudoNodeList.entries() ⇒ <code>Iterator</code>
+Iterate over [index, node] pairs.
+
+**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
+<a name="PseudoNodeList+keys"></a>
+
+### pseudoNodeList.keys() ⇒ <code>Iterator</code>
+Iterate over the indexes.
+
+**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
+<a name="PseudoNodeList+values"></a>
+
+### pseudoNodeList.values() ⇒ <code>Iterator</code>
+Iterate over the nodes.
+
+**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
+<a name="PseudoHTMLDocument"></a>
+
+## PseudoHTMLDocument ⇐ [<code>DocumentService</code>](#DocumentService)
+Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
+only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
+createComment, createDocumentFragment, getElementById, textContent always null).
+
+**Kind**: global class  
+**Extends**: [<code>DocumentService</code>](#DocumentService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| head | <code>PseudoHTMLElement</code> | A reference to the Head child element |
+| body | <code>PseudoHTMLElement</code> | A reference to the Body child element |
+
+
+* [PseudoHTMLDocument](#PseudoHTMLDocument) ⇐ [<code>DocumentService</code>](#DocumentService)
+    * [new PseudoHTMLDocument()](#new_PseudoHTMLDocument_new)
+    * [.head](#PseudoHTMLDocument+head) : <code>PseudoHTMLElement</code>
+    * [.body](#PseudoHTMLDocument+body) : <code>PseudoHTMLElement</code>
+    * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.cloneShallow()](#PseudoHTMLDocument+cloneShallow) ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+    * [.cloneNode([deep])](#PseudoHTMLDocument+cloneNode) ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+    * [.getElementById(id)](#DocumentService+getElementById) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.createElement([tagName])](#DocumentService+createElement) ⇒ <code>PseudoElement</code>
+    * [.createTextNode([data])](#DocumentService+createTextNode) ⇒ [<code>TextService</code>](#TextService)
+    * [.createComment([data])](#DocumentService+createComment) ⇒ [<code>CommentService</code>](#CommentService)
+    * [.createDocumentFragment()](#DocumentService+createDocumentFragment) ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
     * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
-    * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</code>
     * [.append(...nodes)](#NodeService+append)
     * [.prepend(...nodes)](#NodeService+prepend)
@@ -3292,8 +3749,11 @@ from that linker, and its parent from the linker's parent when it has not been g
     * [.replaceWith(...nodes)](#NodeService+replaceWith)
     * [.remove()](#NodeService+remove)
     * [.toChildNode(value)](#NodeService+toChildNode) ⇒ <code>PseudoNode</code>
+    * [.getElementsByTagName(tagName)](#NodeService+getElementsByTagName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.getElementsByClassName(className)](#NodeService+getElementsByClassName) ⇒ <code>PseudoHTMLCollection</code>
+    * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
-    * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
     * [.contains(otherNode)](#NodeService+contains) ⇒ <code>boolean</code>
     * [.insertBefore(newNode, [referenceNode])](#NodeService+insertBefore) ⇒ <code>PseudoNode</code>
@@ -3302,28 +3762,113 @@ from that linker, and its parent from the linker's parent when it has not been g
     * [.removeChild(childElement)](#NodeService+removeChild) ⇒ <code>PseudoNode</code>
     * [.replaceChild(newChild, oldChild)](#NodeService+replaceChild) ⇒ <code>PseudoNode</code>
 
-<a name="new_LinkedNode_new"></a>
+<a name="new_PseudoHTMLDocument_new"></a>
 
-### new LinkedNode(linker, value)
+### new PseudoHTMLDocument()
+The root HTML element is acts as the parent to all HTML elements in the document.
 
-| Param | Type | Description |
-| --- | --- | --- |
-| linker | <code>TreeLinker</code> | The linker holding this node |
-| value | <code>string</code> \| <code>null</code> | The value of the node |
+<a name="PseudoHTMLDocument+head"></a>
+
+### pseudoHTMLDocument.head : <code>PseudoHTMLElement</code>
+Create document head element
+
+**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+<a name="PseudoHTMLDocument+body"></a>
+
+### pseudoHTMLDocument.body : <code>PseudoHTMLElement</code>
+Create document body element
 
+**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 <a name="NodeService+acceptsChildren"></a>
 
-### linkedNode.acceptsChildren ⇒ <code>boolean</code>
+### pseudoHTMLDocument.acceptsChildren ⇒ <code>boolean</code>
 Whether this kind of node can have children (text, comments and attributes cannot).
 
-**Kind**: instance property of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>acceptsChildren</code>](#NodeService+acceptsChildren)  
+<a name="PseudoHTMLDocument+cloneShallow"></a>
+
+### pseudoHTMLDocument.cloneShallow() ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+A copy of this document with none of its html/head/body (cloneNode, from the inherited cloneShallow hook, fills
+them back in, deep copies own document's, empty otherwise - see cloneNode).
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
+<a name="PseudoHTMLDocument+cloneNode"></a>
+
+### pseudoHTMLDocument.cloneNode([deep]) ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in
+the document (a shallow one is an empty document).
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>cloneNode</code>](#NodeService+cloneNode)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy everything in the document as well |
+
+<a name="DocumentService+getElementById"></a>
+
+### pseudoHTMLDocument.getElementById(id) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element, in tree order, whose id matches the given value, or null when there is none.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>getElementById</code>](#DocumentService+getElementById)  
+
+| Param | Type |
+| --- | --- |
+| id | <code>string</code> | 
+
+<a name="DocumentService+createElement"></a>
+
+### pseudoHTMLDocument.createElement([tagName]) ⇒ <code>PseudoElement</code>
+Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createElement</code>](#DocumentService+createElement)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [tagName] | <code>string</code> | <code>&quot;&#x27;div&#x27;&quot;</code> | The type of element to create |
+
+<a name="DocumentService+createTextNode"></a>
+
+### pseudoHTMLDocument.createTextNode([data]) ⇒ [<code>TextService</code>](#TextService)
+Make a text node which belongs to this document.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createTextNode</code>](#DocumentService+createTextNode)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
+
+<a name="DocumentService+createComment"></a>
+
+### pseudoHTMLDocument.createComment([data]) ⇒ [<code>CommentService</code>](#CommentService)
+Make a comment which belongs to this document.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createComment</code>](#DocumentService+createComment)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
+
+<a name="DocumentService+createDocumentFragment"></a>
+
+### pseudoHTMLDocument.createDocumentFragment() ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
+Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
+then inserted in one go.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createDocumentFragment</code>](#DocumentService+createDocumentFragment)  
 <a name="NodeService+appendChild"></a>
 
-### linkedNode.appendChild(childNode) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.appendChild(childNode) ⇒ <code>PseudoNode</code>
 Add a node as the last child of this node (a node which is already in a tree is moved).
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>appendChild</code>](#NodeService+appendChild)  
 **Returns**: <code>PseudoNode</code> - The added node  
 
@@ -3331,21 +3876,13 @@ Add a node as the last child of this node (a node which is already in a tree is
 | --- | --- | --- |
 | childNode | <code>PseudoNode</code> | The node to add |
 
-<a name="NodeService+cloneShallow"></a>
-
-### linkedNode.cloneShallow() ⇒ [<code>NodeService</code>](#NodeService)
-Make a copy of this node without its children, its parent or its listeners, which is what cloneNode starts from.
-Kinds of node which are made with arguments override this to give them.
-
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
-**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
 <a name="NodeService+equalsShallow"></a>
 
-### linkedNode.equalsShallow(other) ⇒ <code>boolean</code>
+### pseudoHTMLDocument.equalsShallow(other) ⇒ <code>boolean</code>
 Whether another node of the same type is equal to this one apart from its children, which isEqualNode compares
 afterwards. Kinds of node with more to compare (an element has attributes) override this.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>equalsShallow</code>](#NodeService+equalsShallow)  
 
 | Param | Type | Description |
@@ -3354,10 +3891,10 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 
 <a name="NodeService+append"></a>
 
-### linkedNode.append(...nodes)
+### pseudoHTMLDocument.append(...nodes)
 Add nodes (strings become text nodes) as the last children of this node, in the order given.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>append</code>](#NodeService+append)  
 **Throws**:
 
@@ -3370,10 +3907,10 @@ Add nodes (strings become text nodes) as the last children of this node, in the
 
 <a name="NodeService+prepend"></a>
 
-### linkedNode.prepend(...nodes)
+### pseudoHTMLDocument.prepend(...nodes)
 Add nodes (strings become text nodes) as the first children of this node, in the order given.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>prepend</code>](#NodeService+prepend)  
 **Throws**:
 
@@ -3386,10 +3923,10 @@ Add nodes (strings become text nodes) as the first children of this node, in the
 
 <a name="NodeService+replaceChildren"></a>
 
-### linkedNode.replaceChildren(...nodes)
+### pseudoHTMLDocument.replaceChildren(...nodes)
 Remove every child of this node and put the given nodes (strings become text nodes) in their place, in order.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>replaceChildren</code>](#NodeService+replaceChildren)  
 **Throws**:
 
@@ -3402,11 +3939,11 @@ Remove every child of this node and put the given nodes (strings become text nod
 
 <a name="NodeService+before"></a>
 
-### linkedNode.before(...nodes)
+### pseudoHTMLDocument.before(...nodes)
 Add nodes (strings become text nodes) as this node's previous siblings, in order. Does nothing when this node has
 no parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>before</code>](#NodeService+before)  
 
 | Param | Type | Description |
@@ -3415,11 +3952,11 @@ no parent.
 
 <a name="NodeService+after"></a>
 
-### linkedNode.after(...nodes)
+### pseudoHTMLDocument.after(...nodes)
 Add nodes (strings become text nodes) as this node's next siblings, in order. Does nothing when this node has no
 parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>after</code>](#NodeService+after)  
 
 | Param | Type | Description |
@@ -3428,11 +3965,11 @@ parent.
 
 <a name="NodeService+replaceWith"></a>
 
-### linkedNode.replaceWith(...nodes)
+### pseudoHTMLDocument.replaceWith(...nodes)
 Put the given nodes (strings become text nodes) where this node is, in order, then remove this node. Does nothing
 when this node has no parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>replaceWith</code>](#NodeService+replaceWith)  
 
 | Param | Type | Description |
@@ -3441,59 +3978,95 @@ when this node has no parent.
 
 <a name="NodeService+remove"></a>
 
-### linkedNode.remove()
+### pseudoHTMLDocument.remove()
 Remove this node from its parent. Does nothing when it has no parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>remove</code>](#NodeService+remove)  
 <a name="NodeService+toChildNode"></a>
 
-### linkedNode.toChildNode(value) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.toChildNode(value) ⇒ <code>PseudoNode</code>
 Turn a value given to append / prepend / before / after / replaceWith / replaceChildren into a node: a string
 becomes a text node belonging to this node's document, anything else is returned as it is.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>toChildNode</code>](#NodeService+toChildNode)  
 
 | Param | Type | Description |
 | --- | --- | --- |
 | value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
+<a name="NodeService+getElementsByTagName"></a>
+
+### pseudoHTMLDocument.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>getElementsByTagName</code>](#NodeService+getElementsByTagName)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### pseudoHTMLDocument.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>getElementsByClassName</code>](#NodeService+getElementsByClassName)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### pseudoHTMLDocument.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element below this node which matches the CSS selector, in tree order, or null when there is none.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>querySelector</code>](#NodeService+querySelector)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### pseudoHTMLDocument.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
+collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>querySelectorAll</code>](#NodeService+querySelectorAll)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
-### linkedNode.childInserted(child)
+### pseudoHTMLDocument.childInserted(child)
 Called each time a node has been inserted as a child of this node, so that nodes which need to react to children
 (for example elements applying default events) can do so.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>childInserted</code>](#NodeService+childInserted)  
 
 | Param | Type | Description |
 | --- | --- | --- |
 | child | [<code>NodeService</code>](#NodeService) | The node which was inserted |
 
-<a name="NodeService+cloneNode"></a>
-
-### linkedNode.cloneNode([deep]) ⇒ <code>PseudoNode</code>
-Make a copy of this node (without its parent, and without its event listeners). With deep the children are copied
-too, all the way down.
-
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
-**Overrides**: [<code>cloneNode</code>](#NodeService+cloneNode)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
-
 <a name="NodeService+compareDocumentPosition"></a>
 
-### linkedNode.compareDocumentPosition(otherNode) ⇒ <code>number</code>
+### pseudoHTMLDocument.compareDocumentPosition(otherNode) ⇒ <code>number</code>
 Say where another node is in relation to this one, as the bits of NodeService.DOCUMENT_POSITION_*: 0 for this node
 itself, DISCONNECTED (with IMPLEMENTATION_SPECIFIC and a consistent PRECEDING or FOLLOWING) for a node in another tree,
 CONTAINS + PRECEDING when the other node is an ancestor, CONTAINED_BY + FOLLOWING when it is a descendant,
 otherwise PRECEDING or FOLLOWING by their order in the tree.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
 
 | Param | Type | Description |
@@ -3502,10 +4075,10 @@ otherwise PRECEDING or FOLLOWING by their order in the tree.
 
 <a name="NodeService+contains"></a>
 
-### linkedNode.contains(otherNode) ⇒ <code>boolean</code>
+### pseudoHTMLDocument.contains(otherNode) ⇒ <code>boolean</code>
 Check whether a node is this node or one of its descendants.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>contains</code>](#NodeService+contains)  
 
 | Param | Type | Description |
@@ -3514,11 +4087,11 @@ Check whether a node is this node or one of its descendants.
 
 <a name="NodeService+insertBefore"></a>
 
-### linkedNode.insertBefore(newNode, [referenceNode]) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.insertBefore(newNode, [referenceNode]) ⇒ <code>PseudoNode</code>
 Insert a node as a child of this node, before the given child (or at the end when there is none). A node which is
 already in a tree is moved, and the children of a document fragment are moved in order.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>insertBefore</code>](#NodeService+insertBefore)  
 **Returns**: <code>PseudoNode</code> - The inserted node  
 **Throws**:
@@ -3533,11 +4106,11 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### linkedNode.isEqualNode(otherNode) ⇒ <code>boolean</code>
+### pseudoHTMLDocument.isEqualNode(otherNode) ⇒ <code>boolean</code>
 Whether another node is the same as this one, by what they hold: the same type, name and value (an element also
 needs the same attributes), and children which are equal in the same order.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>isEqualNode</code>](#NodeService+isEqualNode)  
 
 | Param | Type | Description |
@@ -3546,17 +4119,17 @@ needs the same attributes), and children which are equal in the same order.
 
 <a name="NodeService+normalize"></a>
 
-### linkedNode.normalize()
+### pseudoHTMLDocument.normalize()
 Tidy the text below this node: neighbouring text nodes are joined into one and empty text nodes are removed.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>normalize</code>](#NodeService+normalize)  
 <a name="NodeService+removeChild"></a>
 
-### linkedNode.removeChild(childElement) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.removeChild(childElement) ⇒ <code>PseudoNode</code>
 Remove a child from this node, it no longer has a parent or siblings afterwards.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>removeChild</code>](#NodeService+removeChild)  
 **Returns**: <code>PseudoNode</code> - The removed node  
 **Throws**:
@@ -3570,10 +4143,10 @@ Remove a child from this node, it no longer has a parent or siblings afterwards.
 
 <a name="NodeService+replaceChild"></a>
 
-### linkedNode.replaceChild(newChild, oldChild) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.replaceChild(newChild, oldChild) ⇒ <code>PseudoNode</code>
 Replace a child of this node with another node (which is moved if it is already in a tree).
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>replaceChild</code>](#NodeService+replaceChild)  
 **Returns**: <code>PseudoNode</code> - The replaced node  
 **Throws**:
@@ -3586,134 +4159,6 @@ Replace a child of this node with another node (which is moved if it is already
 | newChild | <code>PseudoNode</code> | The node which takes the place |
 | oldChild | <code>PseudoNode</code> | The child of this node to replace |
 
-<a name="PseudoNodeList"></a>
-
-## PseudoNodeList ⇐ <code>LinkedTreeList</code>
-A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
-the linkers that hold them.
-
-**Kind**: global class  
-**Extends**: <code>LinkedTreeList</code>  
-
-* [PseudoNodeList](#PseudoNodeList) ⇐ <code>LinkedTreeList</code>
-    * [.entries()](#PseudoNodeList+entries) ⇒ <code>Iterator</code>
-    * [.keys()](#PseudoNodeList+keys) ⇒ <code>Iterator</code>
-    * [.values()](#PseudoNodeList+values) ⇒ <code>Iterator</code>
-
-<a name="PseudoNodeList+entries"></a>
-
-### pseudoNodeList.entries() ⇒ <code>Iterator</code>
-Iterate over [index, node] pairs.
-
-**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
-<a name="PseudoNodeList+keys"></a>
-
-### pseudoNodeList.keys() ⇒ <code>Iterator</code>
-Iterate over the indexes.
-
-**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
-<a name="PseudoNodeList+values"></a>
-
-### pseudoNodeList.values() ⇒ <code>Iterator</code>
-Iterate over the nodes.
-
-**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
-<a name="PseudoHTMLDocument"></a>
-
-## PseudoHTMLDocument ⇐ <code>PseudoHTMLElement</code>
-Simulate the behaviour of the HTMLDocument Class when there is no DOM available.
-
-**Kind**: global class  
-**Extends**: <code>PseudoHTMLElement</code>  
-**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
-**Properties**
-
-| Name | Type | Description |
-| --- | --- | --- |
-| head | <code>PseudoHTMLElement</code> | A reference to the Head child element |
-| body | <code>PseudoHTMLElement</code> | A reference to the Body child element |
-| createElement | <code>function</code> | Generate a new PseudoHTMLElement (which is not in the document until it is appended) |
-
-
-* [PseudoHTMLDocument](#PseudoHTMLDocument) ⇐ <code>PseudoHTMLElement</code>
-    * [new PseudoHTMLDocument()](#new_PseudoHTMLDocument_new)
-    * [.head](#PseudoHTMLDocument+head) : <code>PseudoHTMLElement</code>
-    * [.body](#PseudoHTMLDocument+body) : <code>PseudoHTMLElement</code>
-    * [.createElement(tagName)](#PseudoHTMLDocument+createElement) ⇒ <code>PseudoHTMLElement</code>
-    * [.createTextNode([data])](#PseudoHTMLDocument+createTextNode) ⇒ [<code>TextService</code>](#TextService)
-    * [.createComment([data])](#PseudoHTMLDocument+createComment) ⇒ [<code>CommentService</code>](#CommentService)
-    * [.createDocumentFragment()](#PseudoHTMLDocument+createDocumentFragment) ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
-    * [.cloneNode([deep])](#PseudoHTMLDocument+cloneNode) ⇒ <code>PseudoNode</code>
-
-<a name="new_PseudoHTMLDocument_new"></a>
-
-### new PseudoHTMLDocument()
-The root HTML element is acts as the parent to all HTML elements in the document.
-
-<a name="PseudoHTMLDocument+head"></a>
-
-### pseudoHTMLDocument.head : <code>PseudoHTMLElement</code>
-Create document head element
-
-**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-<a name="PseudoHTMLDocument+body"></a>
-
-### pseudoHTMLDocument.body : <code>PseudoHTMLElement</code>
-Create document body element
-
-**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-<a name="PseudoHTMLDocument+createElement"></a>
-
-### pseudoHTMLDocument.createElement(tagName) ⇒ <code>PseudoHTMLElement</code>
-Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| tagName | <code>string</code> | <code>&quot;div&quot;</code> | Tag Name is a string representing the type of Dom element this represents |
-
-<a name="PseudoHTMLDocument+createTextNode"></a>
-
-### pseudoHTMLDocument.createTextNode([data]) ⇒ [<code>TextService</code>](#TextService)
-Make a text node which belongs to this document.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
-
-<a name="PseudoHTMLDocument+createComment"></a>
-
-### pseudoHTMLDocument.createComment([data]) ⇒ [<code>CommentService</code>](#CommentService)
-Make a comment which belongs to this document.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
-
-<a name="PseudoHTMLDocument+createDocumentFragment"></a>
-
-### pseudoHTMLDocument.createDocumentFragment() ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
-Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
-then inserted in one go.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-<a name="PseudoHTMLDocument+cloneNode"></a>
-
-### pseudoHTMLDocument.cloneNode([deep]) ⇒ <code>PseudoNode</code>
-Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in the
-document (a shallow one is an empty document).
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [deep] | <code>boolean</code> | <code>false</code> | Copy everything in the document as well |
-
 <a name="PseudoEventListener"></a>
 
 ## PseudoEventListener
@@ -3856,10 +4301,6 @@ The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop,
 ## focused
 The element which has the focus, kept for each tree (the root node of the tree it is in), like document.activeElement.
 
-**Kind**: global constant  
-<a name="HTMLElementService_1"></a>
-
-## HTMLElementService\_1 : <code>PseudoHTMLElement</code>
 **Kind**: global constant  
 <a name="modifierKeys"></a>
 
@@ -3945,14 +4386,6 @@ Create a PseudoNodeList, optionally starting from an existing chain of linkers.
 | --- | --- | --- |
 | [innerList] | <code>TreeLinker</code> \| <code>null</code> | <code></code> | 
 
-<a name="generateNode"></a>
-
-## generateNode() ⇒ <code>function</code>
-Create a TreeLinker class whose linkers each store a node (a LinkedNode) as their data, this can be used to build a
-tree (or list) of nodes from plain values.
-
-**Kind**: global function  
-**Returns**: <code>function</code> - The NodeFactory class (a TreeLinker) to use as the linker class  
 <a name="generateDocument"></a>
 
 ## generateDocument(root, context) ⇒ <code>Window</code> \| <code>PseudoEventTarget</code>
@@ -3998,6 +4431,18 @@ Create an instance of HTMLElement if not available
 Define document when not available
 
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
+<a name="nearestElementSibling"></a>
+
+## nearestElementSibling(node, direction) ⇒ <code>\*</code> \| <code>null</code>
+Walk up from a node (not including it) to find the nearest element, in the given direction.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | <code>\*</code> | The node to start from |
+| direction | <code>&#x27;nextSibling&#x27;</code> \| <code>&#x27;previousSibling&#x27;</code> | Which sibling reference to follow |
+
 <a name="createEvent"></a>
 
 ## createEvent(type, [init], [options]) ⇒ [<code>EventService</code>](#EventService)