pseudo-dom 0.5.1 → 0.7.0

package/README.md

@@ -38,9 +38,22 @@ nodes. There are text and comment nodes (`PseudoText`, `PseudoComment`) and `tex
 of everything below, and setting it replaces the children with a text node); the document makes them with
 `createTextNode`, `createComment` and `createDocumentFragment`.
 
-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.
+Elements can be walked and changed like the DOM: \`children\` is a live \`HTMLCollection\` of just the element
+children, \`childElementCount\`, \`firstElementChild\` / \`lastElementChild\` and \`nextElementSibling\` /
+\`previousElementSibling\` skip text and comment nodes. \`append\` / \`prepend\` / \`before\` / \`after\` / \`remove\` /
+\`replaceWith\` / \`replaceChildren\` accept nodes or strings (a string becomes a text node) and move a node already in
+a tree rather than duplicating it; \`insertAdjacentElement\` / \`insertAdjacentText\` insert at beforebegin / afterbegin
+/ beforeend / afterend (\`insertAdjacentHTML\` is not implemented, no HTML parsing yet).
+
+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 \`DocumentService\` only,
+matching the real DOM.
+
+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>
@@ -86,6 +99,10 @@ interface (the mouse, the keyboard, focus and input).</p>
 <dt><a href="#HTMLElementService">HTMLElementService</a> ⇐ <code>PseudoElement</code></dt>
 <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 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>
 </dd>
@@ -189,6 +206,9 @@ tree (or list) of nodes from plain values.</p>
 <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
@@ -437,6 +457,18 @@ Simulate the behaviour of the Node Class when there is no DOM available.
     * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
@@ -484,6 +516,150 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
+<a name="NodeService+append"></a>
+
+### nodeService.append(...nodes)
+Add nodes (strings become text nodes) as the last children of this node, in the order given.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+prepend"></a>
+
+### nodeService.prepend(...nodes)
+Add nodes (strings become text nodes) as the first children of this node, in the order given.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+before"></a>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+after"></a>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceWith"></a>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
+
+<a name="NodeService+remove"></a>
+
+### nodeService.remove()
+Remove this node from its parent. Does nothing when it has no parent.
+
+**Kind**: instance method of [<code>NodeService</code>](#NodeService)  
+<a name="NodeService+toChildNode"></a>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| 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)
@@ -626,6 +802,18 @@ Simulate the behaviour of the Text Class when there is no DOM available: the tex
     * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
@@ -702,6 +890,162 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
+<a name="NodeService+append"></a>
+
+### textService.append(...nodes)
+Add nodes (strings become text nodes) as the last children of this node, in the order given.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>append</code>](#NodeService+append)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+prepend"></a>
+
+### textService.prepend(...nodes)
+Add nodes (strings become text nodes) as the first children of this node, in the order given.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>prepend</code>](#NodeService+prepend)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>replaceChildren</code>](#NodeService+replaceChildren)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+before"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>before</code>](#NodeService+before)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+after"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>after</code>](#NodeService+after)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceWith"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>replaceWith</code>](#NodeService+replaceWith)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
+
+<a name="NodeService+remove"></a>
+
+### textService.remove()
+Remove this node from its parent. Does nothing when it has no parent.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>remove</code>](#NodeService+remove)  
+<a name="NodeService+toChildNode"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**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>
+
+### 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)
@@ -851,6 +1195,18 @@ Simulate the behaviour of the Comment Class when there is no DOM available: a no
     * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
@@ -910,109 +1266,265 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
-<a name="NodeService+childInserted"></a>
+<a name="NodeService+append"></a>
 
-### commentService.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.
+### commentService.append(...nodes)
+Add nodes (strings become text nodes) as the last children of this node, in the order given.
 
 **Kind**: instance method of [<code>CommentService</code>](#CommentService)  
-**Overrides**: [<code>childInserted</code>](#NodeService+childInserted)  
+**Overrides**: [<code>append</code>](#NodeService+append)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
 
 | Param | Type | Description |
 | --- | --- | --- |
-| child | [<code>NodeService</code>](#NodeService) | The node which was inserted |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
 
-<a name="NodeService+cloneNode"></a>
+<a name="NodeService+prepend"></a>
 
-### commentService.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.
+### commentService.prepend(...nodes)
+Add nodes (strings become text nodes) as the first children of this node, in the order given.
 
 **Kind**: instance method of [<code>CommentService</code>](#CommentService)  
-**Overrides**: [<code>cloneNode</code>](#NodeService+cloneNode)  
+**Overrides**: [<code>prepend</code>](#NodeService+prepend)  
+**Throws**:
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
+- <code>Error</code> When this kind of node cannot have children
 
-<a name="NodeService+compareDocumentPosition"></a>
 
-### commentService.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.
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
-**Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
+**Overrides**: [<code>replaceChildren</code>](#NodeService+replaceChildren)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
 
 | Param | Type | Description |
 | --- | --- | --- |
-| otherNode | <code>PseudoNode</code> | The node to locate |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
 
-<a name="NodeService+contains"></a>
+<a name="NodeService+before"></a>
 
-### commentService.contains(otherNode) ⇒ <code>boolean</code>
-Check whether a node is this node or one of its descendants.
+### commentService.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>CommentService</code>](#CommentService)  
-**Overrides**: [<code>contains</code>](#NodeService+contains)  
+**Overrides**: [<code>before</code>](#NodeService+before)  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to look for |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
 
-<a name="NodeService+insertBefore"></a>
+<a name="NodeService+after"></a>
 
-### commentService.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.
+### commentService.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>CommentService</code>](#CommentService)  
-**Overrides**: [<code>insertBefore</code>](#NodeService+insertBefore)  
-**Returns**: <code>PseudoNode</code> - The inserted node  
-**Throws**:
-
-- <code>Error</code> When the reference node is not a child of this node, or the new node is this node or contains it
-
+**Overrides**: [<code>after</code>](#NodeService+after)  
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| newNode | <code>PseudoNode</code> |  | The node to insert |
-| [referenceNode] | <code>PseudoNode</code> \| <code>null</code> | <code></code> | The child of this node to insert before, or null to insert at the end |
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
 
-<a name="NodeService+isEqualNode"></a>
+<a name="NodeService+replaceWith"></a>
 
-### commentService.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.
+### commentService.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>CommentService</code>](#CommentService)  
-**Overrides**: [<code>isEqualNode</code>](#NodeService+isEqualNode)  
+**Overrides**: [<code>replaceWith</code>](#NodeService+replaceWith)  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
 
-<a name="NodeService+normalize"></a>
+<a name="NodeService+remove"></a>
 
-### commentService.normalize()
-Tidy the text below this node: neighbouring text nodes are joined into one and empty text nodes are removed.
+### commentService.remove()
+Remove this node from its parent. Does nothing when it has no parent.
 
 **Kind**: instance method of [<code>CommentService</code>](#CommentService)  
-**Overrides**: [<code>normalize</code>](#NodeService+normalize)  
-<a name="NodeService+removeChild"></a>
+**Overrides**: [<code>remove</code>](#NodeService+remove)  
+<a name="NodeService+toChildNode"></a>
 
-### commentService.removeChild(childElement) ⇒ <code>PseudoNode</code>
-Remove a child from this node, it no longer has a parent or siblings afterwards.
+### commentService.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>CommentService</code>](#CommentService)  
-**Overrides**: [<code>removeChild</code>](#NodeService+removeChild)  
-**Returns**: <code>PseudoNode</code> - The removed node  
-**Throws**:
-
-- <code>Error</code> When the node is not a child of this node
+**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>
+
+### 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)
+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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>childInserted</code>](#NodeService+childInserted)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| child | [<code>NodeService</code>](#NodeService) | The node which was inserted |
+
+<a name="NodeService+cloneNode"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**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>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
+
+<a name="NodeService+contains"></a>
+
+### commentService.contains(otherNode) ⇒ <code>boolean</code>
+Check whether a node is this node or one of its descendants.
+
+**Kind**: instance method of [<code>CommentService</code>](#CommentService)  
+**Overrides**: [<code>contains</code>](#NodeService+contains)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to look for |
+
+<a name="NodeService+insertBefore"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>insertBefore</code>](#NodeService+insertBefore)  
+**Returns**: <code>PseudoNode</code> - The inserted node  
+**Throws**:
+
+- <code>Error</code> When the reference node is not a child of this node, or the new node is this node or contains it
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| newNode | <code>PseudoNode</code> |  | The node to insert |
+| [referenceNode] | <code>PseudoNode</code> \| <code>null</code> | <code></code> | The child of this node to insert before, or null to insert at the end |
+
+<a name="NodeService+isEqualNode"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>isEqualNode</code>](#NodeService+isEqualNode)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+
+<a name="NodeService+normalize"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>normalize</code>](#NodeService+normalize)  
+<a name="NodeService+removeChild"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>removeChild</code>](#NodeService+removeChild)  
+**Returns**: <code>PseudoNode</code> - The removed node  
+**Throws**:
+
+- <code>Error</code> When the node is not a child of this node
 
 
 | Param | Type | Description |
@@ -1364,6 +1876,66 @@ focus or already has it.
 Take the focus away from the element, when it has it: it gets blur then focusout.
 
 **Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+<a name="HTMLCollectionService"></a>
+
+## HTMLCollectionService
+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, [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>
+    * [.namedItem(name)](#HTMLCollectionService+namedItem) ⇒ <code>\*</code>
+
+<a name="new_HTMLCollectionService_new"></a>
+
+### new HTMLCollectionService(owner, [predicate], [deep])
+
+| 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>
+
+### htmlCollectionService.length ⇒ <code>number</code>
+How many elements are in the collection right now.
+
+**Kind**: instance property of [<code>HTMLCollectionService</code>](#HTMLCollectionService)  
+<a name="HTMLCollectionService+elements"></a>
+
+### htmlCollectionService.elements() ⇒ <code>Array.&lt;PseudoNode&gt;</code>
+The current elements the collection holds, in tree order.
+
+**Kind**: instance method of [<code>HTMLCollectionService</code>](#HTMLCollectionService)  
+<a name="HTMLCollectionService+item"></a>
+
+### htmlCollectionService.item(index) ⇒ <code>\*</code>
+The element at the given index, or null when there is none.
+
+**Kind**: instance method of [<code>HTMLCollectionService</code>](#HTMLCollectionService)  
+
+| Param | Type |
+| --- | --- |
+| index | <code>number</code> | 
+
+<a name="HTMLCollectionService+namedItem"></a>
+
+### htmlCollectionService.namedItem(name) ⇒ <code>\*</code>
+The element whose id, or (failing that) whose name attribute, is the given value, or null when there is none.
+
+**Kind**: instance method of [<code>HTMLCollectionService</code>](#HTMLCollectionService)  
+
+| Param | Type |
+| --- | --- |
+| name | <code>string</code> | 
+
 <a name="FocusEventService"></a>
 
 ## FocusEventService ⇐ [<code>UIEventService</code>](#UIEventService)
@@ -1666,10 +2238,21 @@ Simulate the behaviour of the Element Class when there is no DOM available.
 
 * [ElementService](#ElementService) ⇐ <code>PseudoNode</code>
     * [new ElementService([settings])](#new_ElementService_new)
+    * [.children](#ElementService+children) ⇒ <code>PseudoHTMLCollection</code>
+    * [.childElementCount](#ElementService+childElementCount) ⇒ <code>number</code>
+    * [.firstElementChild](#ElementService+firstElementChild) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.lastElementChild](#ElementService+lastElementChild) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.nextElementSibling](#ElementService+nextElementSibling) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.previousElementSibling](#ElementService+previousElementSibling) ⇒ <code>PseudoElement</code> \| <code>null</code>
     * [.currentAttributes()](#ElementService+currentAttributes) ⇒ <code>Array.&lt;{name: string, value: \*}&gt;</code>
     * [.cloneShallow()](#ElementService+cloneShallow) ⇒ [<code>ElementService</code>](#ElementService)
     * [.equalsShallow(other)](#ElementService+equalsShallow) ⇒ <code>boolean</code>
-    * [.applyDefaultEvent()](#ElementService+applyDefaultEvent) ⇒ <code>function</code>
+    * [.insertAdjacentElement(position, element)](#ElementService+insertAdjacentElement) ⇒ [<code>ElementService</code>](#ElementService) \| <code>null</code>
+    * [.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>
@@ -1688,6 +2271,42 @@ Simulate the behaviour of the Element Class when there is no DOM available.
 | [settings.parent] | <code>PseudoNode</code> \| <code>null</code> | <code></code> | The node to add this element to as its last child |
 | [settings.children] | <code>Array.&lt;PseudoNode&gt;</code> | <code>[]</code> | The nodes to start as children |
 
+<a name="ElementService+children"></a>
+
+### elementService.children ⇒ <code>PseudoHTMLCollection</code>
+A live view of this element's element children (text, comments and the like are not included).
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+childElementCount"></a>
+
+### elementService.childElementCount ⇒ <code>number</code>
+How many element children this element has.
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+firstElementChild"></a>
+
+### elementService.firstElementChild ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first child of this element which is an element, or null when there is none.
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+lastElementChild"></a>
+
+### elementService.lastElementChild ⇒ <code>PseudoElement</code> \| <code>null</code>
+The last child of this element which is an element, or null when there is none.
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+nextElementSibling"></a>
+
+### elementService.nextElementSibling ⇒ <code>PseudoElement</code> \| <code>null</code>
+The sibling after this one which is an element, or null when there is none.
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+previousElementSibling"></a>
+
+### elementService.previousElementSibling ⇒ <code>PseudoElement</code> \| <code>null</code>
+The sibling before this one which is an element, or null when there is none.
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
 <a name="ElementService+currentAttributes"></a>
 
 ### elementService.currentAttributes() ⇒ <code>Array.&lt;{name: string, value: \*}&gt;</code>
@@ -1714,12 +2333,97 @@ checks before it compares the children.
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The element to compare with |
 
-<a name="ElementService+applyDefaultEvent"></a>
+<a name="ElementService+insertAdjacentElement"></a>
+
+### elementService.insertAdjacentElement(position, element) ⇒ [<code>ElementService</code>](#ElementService) \| <code>null</code>
+Put an element at a position relative to this one: beforebegin (before this element, as its previous sibling),
+afterbegin (as this element's first child), beforeend (as this element's last child) or afterend (after this
+element, as its next sibling).
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+**Returns**: [<code>ElementService</code>](#ElementService) \| <code>null</code> - The inserted element, or null when the position needed a parent this element does not have  
+**Throws**:
+
+- <code>Error</code> When the position is not one of the four above
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| position | <code>string</code> | beforebegin, afterbegin, beforeend or afterend |
+| element | [<code>ElementService</code>](#ElementService) | The element to insert |
+
+<a name="ElementService+insertAdjacentText"></a>
 
-### elementService.applyDefaultEvent() ⇒ <code>function</code>
-Some elements have default behaviour, this registers it when the element is added.
+### elementService.insertAdjacentText(position, text)
+Put text at a position relative to this element, the same as insertAdjacentElement but the text becomes a text node.
 
 **Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+**Throws**:
+
+- <code>Error</code> When the position is not one of the four above
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| position | <code>string</code> | beforebegin, afterbegin, beforeend or afterend |
+| text | <code>string</code> | The text to insert |
+
+<a name="ElementService+insertAdjacent"></a>
+
+### elementService.insertAdjacent(position, node) ⇒ <code>PseudoNode</code> \| <code>null</code>
+Shared implementation for insertAdjacentElement / insertAdjacentText.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+**Returns**: <code>PseudoNode</code> \| <code>null</code> - The inserted node, or null when the position needed a parent this element does not have  
+**Throws**:
+
+- <code>Error</code> When the position is not one of the four above
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| position | <code>string</code> | beforebegin, afterbegin, beforeend or afterend |
+| node | <code>PseudoNode</code> \| <code>string</code> | The node (or text) to insert |
+
+<a name="ElementService+insertAdjacentHTML"></a>
+
+### elementService.insertAdjacentHTML(position, text)
+Not implemented yet (HTML parsing is out of scope for now).
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+**Throws**:
+
+- <code>Error</code> 
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| 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)
@@ -1788,9 +2492,22 @@ 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>
     * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
@@ -1807,6 +2524,17 @@ 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="NodeService+appendChild"></a>
 
 ### documentService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -1838,6 +2566,150 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
+<a name="NodeService+append"></a>
+
+### documentService.append(...nodes)
+Add nodes (strings become text nodes) as the last children of this node, in the order given.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+prepend"></a>
+
+### documentService.prepend(...nodes)
+Add nodes (strings become text nodes) as the first children of this node, in the order given.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+before"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+after"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceWith"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
+
+<a name="NodeService+remove"></a>
+
+### documentService.remove()
+Remove this node from its parent. Does nothing when it has no parent.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+<a name="NodeService+toChildNode"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| 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)
@@ -1932,91 +2804,247 @@ Remove a child from this node, it no longer has a parent or siblings afterwards.
 **Returns**: <code>PseudoNode</code> - The removed node  
 **Throws**:
 
-- <code>Error</code> When the node is not a child of this node
+- <code>Error</code> When the node is not a child of this node
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| childElement | <code>PseudoNode</code> | The child node to remove |
+
+<a name="NodeService+replaceChild"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+**Returns**: <code>PseudoNode</code> - The replaced node  
+**Throws**:
+
+- <code>Error</code> When the old node is not a child of this node
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| newChild | <code>PseudoNode</code> | The node which takes the place |
+| oldChild | <code>PseudoNode</code> | The child of this node to replace |
+
+<a name="DocumentFragmentService"></a>
+
+## DocumentFragmentService ⇐ [<code>NodeService</code>](#NodeService)
+Simulate the behaviour of the DocumentFragment Class when there is no DOM available: a container for nodes which is
+not part of a tree, when it is inserted its children are moved into the tree instead.
+
+**Kind**: global class  
+**Extends**: [<code>NodeService</code>](#NodeService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+
+* [DocumentFragmentService](#DocumentFragmentService) ⇐ [<code>NodeService</code>](#NodeService)
+    * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
+    * [.isEqualNode(otherNode)](#NodeService+isEqualNode) ⇒ <code>boolean</code>
+    * [.normalize()](#NodeService+normalize)
+    * [.removeChild(childElement)](#NodeService+removeChild) ⇒ <code>PseudoNode</code>
+    * [.replaceChild(newChild, oldChild)](#NodeService+replaceChild) ⇒ <code>PseudoNode</code>
+
+<a name="NodeService+acceptsChildren"></a>
+
+### documentFragmentService.acceptsChildren ⇒ <code>boolean</code>
+Whether this kind of node can have children (text, comments and attributes cannot).
+
+**Kind**: instance property of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+<a name="NodeService+appendChild"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
+**Returns**: <code>PseudoNode</code> - The added node  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| childNode | <code>PseudoNode</code> | The node to add |
+
+<a name="NodeService+cloneShallow"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
+<a name="NodeService+equalsShallow"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
+<a name="NodeService+append"></a>
+
+### documentFragmentService.append(...nodes)
+Add nodes (strings become text nodes) as the last children of this node, in the order given.
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+prepend"></a>
+
+### documentFragmentService.prepend(...nodes)
+Add nodes (strings become text nodes) as the first children of this node, in the order given.
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+before"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+after"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceWith"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| childElement | <code>PseudoNode</code> | The child node to remove |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
 
-<a name="NodeService+replaceChild"></a>
+<a name="NodeService+remove"></a>
 
-### documentService.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).
+### documentFragmentService.remove()
+Remove this node from its parent. Does nothing when it has no parent.
 
-**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
-**Returns**: <code>PseudoNode</code> - The replaced node  
-**Throws**:
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+<a name="NodeService+toChildNode"></a>
 
-- <code>Error</code> When the old node is not a child of this node
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| newChild | <code>PseudoNode</code> | The node which takes the place |
-| oldChild | <code>PseudoNode</code> | The child of this node to replace |
+| value | <code>PseudoNode</code> \| <code>string</code> | The value to add |
 
-<a name="DocumentFragmentService"></a>
+<a name="NodeService+getElementsByTagName"></a>
 
-## DocumentFragmentService ⇐ [<code>NodeService</code>](#NodeService)
-Simulate the behaviour of the DocumentFragment Class when there is no DOM available: a container for nodes which is
-not part of a tree, when it is inserted its children are moved into the tree instead.
+### documentFragmentService.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node with the given tag name (or every element when tagName is *), live.
 
-**Kind**: global class  
-**Extends**: [<code>NodeService</code>](#NodeService)  
-**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
 
-* [DocumentFragmentService](#DocumentFragmentService) ⇐ [<code>NodeService</code>](#NodeService)
-    * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
-    * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
-    * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
-    * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</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>
-    * [.isEqualNode(otherNode)](#NodeService+isEqualNode) ⇒ <code>boolean</code>
-    * [.normalize()](#NodeService+normalize)
-    * [.removeChild(childElement)](#NodeService+removeChild) ⇒ <code>PseudoNode</code>
-    * [.replaceChild(newChild, oldChild)](#NodeService+replaceChild) ⇒ <code>PseudoNode</code>
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
 
-<a name="NodeService+acceptsChildren"></a>
+<a name="NodeService+getElementsByClassName"></a>
 
-### documentFragmentService.acceptsChildren ⇒ <code>boolean</code>
-Whether this kind of node can have children (text, comments and attributes cannot).
+### documentFragmentService.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+Every element below this node which has all of the given (space separated) classes, live.
 
-**Kind**: instance property of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
-<a name="NodeService+appendChild"></a>
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
 
-### documentFragmentService.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).
+| 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)  
-**Returns**: <code>PseudoNode</code> - The added node  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| childNode | <code>PseudoNode</code> | The node to add |
-
-<a name="NodeService+cloneShallow"></a>
-
-### documentFragmentService.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.
+| selectors | <code>string</code> | A CSS selector |
 
-**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
-<a name="NodeService+equalsShallow"></a>
+<a name="NodeService+querySelectorAll"></a>
 
-### documentFragmentService.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.
+### 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 |
 | --- | --- | --- |
-| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+| selectors | <code>string</code> | A CSS selector |
 
 <a name="NodeService+childInserted"></a>
 
@@ -2236,6 +3264,18 @@ Simulate the behaviour of the Attr Class when there is no DOM available.
     * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
@@ -2299,6 +3339,162 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
+<a name="NodeService+append"></a>
+
+### attrService.append(...nodes)
+Add nodes (strings become text nodes) as the last children of this node, in the order given.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>append</code>](#NodeService+append)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+prepend"></a>
+
+### attrService.prepend(...nodes)
+Add nodes (strings become text nodes) as the first children of this node, in the order given.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>prepend</code>](#NodeService+prepend)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>replaceChildren</code>](#NodeService+replaceChildren)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+before"></a>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>before</code>](#NodeService+before)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+after"></a>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>after</code>](#NodeService+after)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceWith"></a>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>replaceWith</code>](#NodeService+replaceWith)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
+
+<a name="NodeService+remove"></a>
+
+### attrService.remove()
+Remove this node from its parent. Does nothing when it has no parent.
+
+**Kind**: instance method of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>remove</code>](#NodeService+remove)  
+<a name="NodeService+toChildNode"></a>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**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>
+
+### 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)
@@ -2442,6 +3638,18 @@ from that linker, and its parent from the linker's parent when it has not been g
     * [.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)
+    * [.replaceChildren(...nodes)](#NodeService+replaceChildren)
+    * [.before(...nodes)](#NodeService+before)
+    * [.after(...nodes)](#NodeService+after)
+    * [.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>
@@ -2502,6 +3710,162 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
+<a name="NodeService+append"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>append</code>](#NodeService+append)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+prepend"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>prepend</code>](#NodeService+prepend)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceChildren"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>replaceChildren</code>](#NodeService+replaceChildren)  
+**Throws**:
+
+- <code>Error</code> When this kind of node cannot have children
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+before"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>before</code>](#NodeService+before)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+after"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>after</code>](#NodeService+after)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to add |
+
+<a name="NodeService+replaceWith"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>replaceWith</code>](#NodeService+replaceWith)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ...nodes | <code>PseudoNode</code> \| <code>string</code> | The nodes (or text) to put in this node's place |
+
+<a name="NodeService+remove"></a>
+
+### linkedNode.remove()
+Remove this node from its parent. Does nothing when it has no parent.
+
+**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Overrides**: [<code>remove</code>](#NodeService+remove)  
+<a name="NodeService+toChildNode"></a>
+
+### linkedNode.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)  
+**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>
+
+### linkedNode.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>LinkedNode</code>](#LinkedNode)  
+**Overrides**: [<code>getElementsByTagName</code>](#NodeService+getElementsByTagName)  
+
+| Param | Type |
+| --- | --- |
+| tagName | <code>string</code> | 
+
+<a name="NodeService+getElementsByClassName"></a>
+
+### linkedNode.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>LinkedNode</code>](#LinkedNode)  
+**Overrides**: [<code>getElementsByClassName</code>](#NodeService+getElementsByClassName)  
+
+| Param | Type |
+| --- | --- |
+| className | <code>string</code> | 
+
+<a name="NodeService+querySelector"></a>
+
+### linkedNode.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>LinkedNode</code>](#LinkedNode)  
+**Overrides**: [<code>querySelector</code>](#NodeService+querySelector)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
+<a name="NodeService+querySelectorAll"></a>
+
+### linkedNode.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>LinkedNode</code>](#LinkedNode)  
+**Overrides**: [<code>querySelectorAll</code>](#NodeService+querySelectorAll)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| selectors | <code>string</code> | A CSS selector |
+
 <a name="NodeService+childInserted"></a>
 
 ### linkedNode.childInserted(child)
@@ -3041,6 +4405,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)