pseudo-dom 0.3.0 → 0.5.0

package/README.md

@@ -18,12 +18,35 @@ else, document fragments insert their children, and a node cannot be put inside
 `DOMTokenListService`, `NamedNodeMapService`, `DocumentService` / `DocumentFragmentService`, `PseudoNodeList`, and
 `generateDocument` for creating a document.
 
-Not implemented yet (these throw a "not implemented" error or are missing): `cloneNode`, `compareDocumentPosition`, `isEqualNode`, `querySelector` /
+Standard events: `createEvent(type, init, { browser, trusted })` makes the kind of event which suits the type (a click is a
+`MouseEvent`, a keydown a `KeyboardEvent`, ...). Like the constructor in a browser it gives nothing (no bubbling, no
+cancelling, not trusted) unless asked, but with `browser: true` it uses `eventDefaults`, the table of how the browser
+creates each standard type (click bubbles and can be cancelled, focus does not bubble but focusin does, input bubbles
+but cannot be cancelled, ...), and `trusted: true` makes `isTrusted` true, as for a real user action. The kinds of event
+are `PseudoUIEvent`, `PseudoMouseEvent`, `PseudoPointerEvent`, `PseudoKeyboardEvent`, `PseudoFocusEvent`,
+`PseudoInputEvent` and `PseudoCustomEvent`. Elements have `click()` (an untrusted click, like a script's),
+`focus()` and `blur()` (with blur / focusout / focus / focusin and the related targets, and a focused element for each
+tree), and `simulate.click(element)` / `simulate.keyPress(element, key)` send what a user's action sends (pointerdown,
+mousedown, the focus moving, pointerup, mouseup, click; keydown, keyup), all trusted.
+
+Nodes can be copied and compared: `cloneNode(deep)` copies an element with its attributes (objects such as `style` are
+copied too, not shared) and, when deep, everything below it, without the parent or the event listeners; `isEqualNode`
+compares two nodes by what they hold (tag, attributes in any order, text and children in order);
+`compareDocumentPosition` says where another node is (`NodeService.DOCUMENT_POSITION_*`); `isConnected` is true when the
+tree has a document at the top and `ownerDocument` says which one made the node; `normalize` joins neighbouring text
+nodes. There are text and comment nodes (`PseudoText`, `PseudoComment`) and `textContent` works like the DOM's (the text
+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.
 ## Modules
 
 <dl>
+<dt><a href="#module_pseudoDom/simulate">pseudoDom/simulate</a></dt>
+<dd><p>Simulate what a user does, with the events the browser sends for it.</p>
+</dd>
 <dt><a href="#module_pseudoDom/objects">pseudoDom/objects</a> : <code>Object</code></dt>
 <dd><p>All methods exported from this module are encapsulated within pseudoDom.</p>
 </dd>
@@ -32,15 +55,40 @@ will change before 1.0.
 ## Classes
 
 <dl>
+<dt><a href="#UIEventService">UIEventService</a> ⇐ <code><a href="#EventService">EventService</a></code></dt>
+<dd><p>Simulate the behaviour of the UIEvent Class when there is no DOM available: the events which come from a user
+interface (the mouse, the keyboard, focus and input).</p>
+</dd>
+<dt><a href="#PointerEventService">PointerEventService</a> ⇐ <code><a href="#MouseEventService">MouseEventService</a></code></dt>
+<dd><p>Simulate the behaviour of the PointerEvent Class when there is no DOM available.</p>
+</dd>
 <dt><a href="#NodeService">NodeService</a> ⇐ <code>PseudoEventTarget</code></dt>
 <dd><p>Simulate the behaviour of the Node Class when there is no DOM available.</p>
 </dd>
+<dt><a href="#TextService">TextService</a> ⇐ <code><a href="#NodeService">NodeService</a></code></dt>
+<dd><p>Simulate the behaviour of the Text Class when there is no DOM available: the text in an element.</p>
+</dd>
+<dt><a href="#CommentService">CommentService</a> ⇐ <code><a href="#NodeService">NodeService</a></code></dt>
+<dd><p>Simulate the behaviour of the Comment Class when there is no DOM available: a note in the markup which is not shown.</p>
+</dd>
 <dt><a href="#NamedNodeMapService">NamedNodeMapService</a></dt>
 <dd><p>Simulate the behaviour of the NamedNodeMap Class when there is no DOM available.</p>
 </dd>
+<dt><a href="#MouseEventService">MouseEventService</a> ⇐ <code><a href="#UIEventService">UIEventService</a></code></dt>
+<dd><p>Simulate the behaviour of the MouseEvent Class when there is no DOM available.</p>
+</dd>
+<dt><a href="#KeyboardEventService">KeyboardEventService</a> ⇐ <code><a href="#UIEventService">UIEventService</a></code></dt>
+<dd><p>Simulate the behaviour of the KeyboardEvent Class when there is no DOM available.</p>
+</dd>
+<dt><a href="#InputEventService">InputEventService</a> ⇐ <code><a href="#UIEventService">UIEventService</a></code></dt>
+<dd><p>Simulate the behaviour of the InputEvent Class when there is no DOM available.</p>
+</dd>
 <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="#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>
 <dt><a href="#EventTargetService">EventTargetService</a></dt>
 <dd><p>Simulate the behaviour of the EventTarget Class when there is no DOM available.
 Dispatching an event sends it through the tree the way the DOM does: down from the root to the target (capture
@@ -63,6 +111,9 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 <dt><a href="#DOMTokenListService">DOMTokenListService</a></dt>
 <dd><p>Simulate the behaviour of the DOMTokenList Class when there is no DOM available.</p>
 </dd>
+<dt><a href="#CustomEventService">CustomEventService</a> ⇐ <code><a href="#EventService">EventService</a></code></dt>
+<dd><p>Simulate the behaviour of the CustomEvent Class when there is no DOM available: an event which carries data.</p>
+</dd>
 <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>
@@ -82,9 +133,23 @@ the linkers that hold them.</p>
 </dd>
 </dl>
 
+## Members
+
+<dl>
+<dt><a href="#eventDefaults">eventDefaults</a> : <code>Object.&lt;string, EventDefinition&gt;</code></dt>
+<dd><p>The events which the browser itself creates (for a user action, or for something like element.click()) have these
+options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
+for them, which is why createEvent only uses this table when it is told the browser is creating the event.
+The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.</p>
+</dd>
+</dl>
+
 ## Constants
 
 <dl>
+<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>
@@ -92,6 +157,12 @@ the linkers that hold them.</p>
 ## Functions
 
 <dl>
+<dt><a href="#modifierKeys">modifierKeys([init])</a> ⇒ <code>ModifierKeys</code></dt>
+<dd><p>Pick the modifier keys out of the init object of an event.</p>
+</dd>
+<dt><a href="#modifierState">modifierState(keys, key)</a> ⇒ <code>boolean</code></dt>
+<dd><p>Answer getModifierState for a set of held modifier keys.</p>
+</dd>
 <dt><a href="#getParentNodesFromAttribute">getParentNodesFromAttribute(attr, value, node)</a> ⇒ <code>Array.&lt;PseudoNode&gt;</code></dt>
 <dd><p>A selector function for retrieving existing parent PseudoNode from the given child item.
 This function will check all the parents starting from node, and scan the attributes
@@ -101,6 +172,12 @@ property for matches. The return array contains all matching parent ancestors, s
 <dd><p>Get all of the ancestors of a node, starting with the root of the tree and ending with the node&#39;s own parent (the
 order in which an event travels down through them). A node which has no parent has no ancestors.</p>
 </dd>
+<dt><a href="#getActiveElement">getActiveElement(root)</a> ⇒ <code>Object</code> | <code>null</code></dt>
+<dd><p>Find the element which has the focus in a tree.</p>
+</dd>
+<dt><a href="#setActiveElement">setActiveElement(root, element)</a></dt>
+<dd><p>Remember the element which has the focus in a tree.</p>
+</dd>
 <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>
@@ -112,14 +189,232 @@ 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="#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
+the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
+it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
+real user action (isTrusted).</p>
+</dd>
 </dl>
 
+<a name="module_pseudoDom/simulate"></a>
+
+## pseudoDom/simulate
+Simulate what a user does, with the events the browser sends for it.
+
+**Version**: 1.0.0  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+
+* [pseudoDom/simulate](#module_pseudoDom/simulate)
+    * [~focusableFrom(element)](#module_pseudoDom/simulate..focusableFrom) ⇒ <code>\*</code> \| <code>null</code>
+    * [~click(element, [init])](#module_pseudoDom/simulate..click) ⇒ <code>boolean</code>
+    * [~keyPress(element, key, [init])](#module_pseudoDom/simulate..keyPress) ⇒ <code>boolean</code>
+
+<a name="module_pseudoDom/simulate..focusableFrom"></a>
+
+### pseudoDom/simulate~focusableFrom(element) ⇒ <code>\*</code> \| <code>null</code>
+The nearest element (starting with the element itself) which can have the focus.
+
+**Kind**: inner method of [<code>pseudoDom/simulate</code>](#module_pseudoDom/simulate)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| element | <code>\*</code> | Where to start |
+
+<a name="module_pseudoDom/simulate..click"></a>
+
+### pseudoDom/simulate~click(element, [init]) ⇒ <code>boolean</code>
+Click an element the way a user does: pointerdown and mousedown, then the focus moves to the nearest element which
+can have it (or is taken away from the one which had it) unless mousedown was cancelled, then pointerup, mouseup
+and finally click. Every event is trusted and has the options the browser gives it. A disabled element gets nothing.
+
+**Kind**: inner method of [<code>pseudoDom/simulate</code>](#module_pseudoDom/simulate)  
+**Returns**: <code>boolean</code> - False when the click was cancelled (or the element is disabled), so its default action did not happen  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| element | <code>\*</code> |  | The element to click |
+| [init] | <code>Object</code> | <code>{}</code> | Options for the events (for example clientX, clientY, shiftKey) |
+
+<a name="module_pseudoDom/simulate..keyPress"></a>
+
+### pseudoDom/simulate~keyPress(element, key, [init]) ⇒ <code>boolean</code>
+Press and release a key on an element (the element which has the focus, or one given): keydown and then keyup.
+
+**Kind**: inner method of [<code>pseudoDom/simulate</code>](#module_pseudoDom/simulate)  
+**Returns**: <code>boolean</code> - False when keydown was cancelled, so its default action did not happen  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| element | <code>\*</code> |  | The element which gets the key |
+| key | <code>string</code> |  | The value of the key, such as a or Enter |
+| [init] | <code>Object</code> | <code>{}</code> | Options for the events (for example code, shiftKey) |
+
 <a name="module_pseudoDom/objects"></a>
 
 ## pseudoDom/objects : <code>Object</code>
 All methods exported from this module are encapsulated within pseudoDom.
 
 **Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+<a name="UIEventService"></a>
+
+## UIEventService ⇐ [<code>EventService</code>](#EventService)
+Simulate the behaviour of the UIEvent Class when there is no DOM available: the events which come from a user
+interface (the mouse, the keyboard, focus and input).
+
+**Kind**: global class  
+**Extends**: [<code>EventService</code>](#EventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| detail | <code>number</code> | 
+| view | <code>\*</code> | 
+
+
+* [UIEventService](#UIEventService) ⇐ [<code>EventService</code>](#EventService)
+    * [new UIEventService([typeArg], [init])](#new_UIEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_UIEventService_new"></a>
+
+### new UIEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>UIEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
+
+### uiEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+
+**Kind**: instance property of [<code>UIEventService</code>](#UIEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="EventService+composedPath"></a>
+
+### uiEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+
+**Kind**: instance method of [<code>UIEventService</code>](#UIEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
+
+### uiEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
+
+**Kind**: instance method of [<code>UIEventService</code>](#UIEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
+
+### uiEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
+
+**Kind**: instance method of [<code>UIEventService</code>](#UIEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
+
+### uiEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
+
+**Kind**: instance method of [<code>UIEventService</code>](#UIEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
+<a name="PointerEventService"></a>
+
+## PointerEventService ⇐ [<code>MouseEventService</code>](#MouseEventService)
+Simulate the behaviour of the PointerEvent Class when there is no DOM available.
+
+**Kind**: global class  
+**Extends**: [<code>MouseEventService</code>](#MouseEventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| pointerId | <code>number</code> | 
+| width | <code>number</code> | 
+| height | <code>number</code> | 
+| pressure | <code>number</code> | 
+| pointerType | <code>string</code> | 
+| isPrimary | <code>boolean</code> | 
+
+
+* [PointerEventService](#PointerEventService) ⇐ [<code>MouseEventService</code>](#MouseEventService)
+    * [new PointerEventService([typeArg], [init])](#new_PointerEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.getModifierState(key)](#MouseEventService+getModifierState) ⇒ <code>boolean</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_PointerEventService_new"></a>
+
+### new PointerEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>PointerEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
+
+### pointerEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+
+**Kind**: instance property of [<code>PointerEventService</code>](#PointerEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="MouseEventService+getModifierState"></a>
+
+### pointerEventService.getModifierState(key) ⇒ <code>boolean</code>
+Whether a modifier key was held down when the event happened.
+
+**Kind**: instance method of [<code>PointerEventService</code>](#PointerEventService)  
+**Overrides**: [<code>getModifierState</code>](#MouseEventService+getModifierState)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>string</code> | Control, Shift, Alt or Meta |
+
+<a name="EventService+composedPath"></a>
+
+### pointerEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+
+**Kind**: instance method of [<code>PointerEventService</code>](#PointerEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
+
+### pointerEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
+
+**Kind**: instance method of [<code>PointerEventService</code>](#PointerEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
+
+### pointerEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
+
+**Kind**: instance method of [<code>PointerEventService</code>](#PointerEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
+
+### pointerEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
+
+**Kind**: instance method of [<code>PointerEventService</code>](#PointerEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
 <a name="NodeService"></a>
 
 ## NodeService ⇐ <code>PseudoEventTarget</code>
@@ -138,16 +433,26 @@ Simulate the behaviour of the Node Class when there is no DOM available.
 
 
 * [NodeService](#NodeService) ⇐ <code>PseudoEventTarget</code>
+    * [.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()](#NodeService+cloneNode)
-    * [.compareDocumentPosition()](#NodeService+compareDocumentPosition)
+    * [.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()](#NodeService+isEqualNode)
+    * [.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>
+
+### nodeService.acceptsChildren ⇒ <code>boolean</code>
+Whether this kind of node can have children (text, comments and attributes cannot).
+
+**Kind**: instance property of [<code>NodeService</code>](#NodeService)  
 <a name="NodeService+appendChild"></a>
 
 ### nodeService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -160,6 +465,25 @@ 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>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+<a name="NodeService+equalsShallow"></a>
+
+### nodeService.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>NodeService</code>](#NodeService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
 <a name="NodeService+childInserted"></a>
 
 ### nodeService.childInserted(child)
@@ -174,23 +498,29 @@ Called each time a node has been inserted as a child of this node, so that nodes
 
 <a name="NodeService+cloneNode"></a>
 
-### nodeService.cloneNode()
-Not implemented yet.
+### nodeService.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>NodeService</code>](#NodeService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
 
 <a name="NodeService+compareDocumentPosition"></a>
 
-### nodeService.compareDocumentPosition()
-Not implemented yet.
+### nodeService.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>NodeService</code>](#NodeService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
 
 <a name="NodeService+contains"></a>
 
@@ -223,14 +553,22 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### nodeService.isEqualNode()
-Not implemented yet.
+### nodeService.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>NodeService</code>](#NodeService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+
+<a name="NodeService+normalize"></a>
 
+### nodeService.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>NodeService</code>](#NodeService)  
 <a name="NodeService+removeChild"></a>
 
 ### nodeService.removeChild(childElement) ⇒ <code>PseudoNode</code>
@@ -264,55 +602,837 @@ 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="NamedNodeMapService"></a>
+<a name="TextService"></a>
 
-## NamedNodeMapService
-Simulate the behaviour of the NamedNodeMap Class when there is no DOM available.
+## TextService ⇐ [<code>NodeService</code>](#NodeService)
+Simulate the behaviour of the Text Class when there is no DOM available: the text in an element.
 
 **Kind**: global class  
+**Extends**: [<code>NodeService</code>](#NodeService)  
 **Author**: Joshua Heagle <joshuaheagle@gmail.com>  
-<a name="new_NamedNodeMapService_new"></a>
+**Properties**
 
-### new NamedNodeMapService([attributes])
+| Name | Type | Description |
+| --- | --- | --- |
+| data | <code>string</code> | The text |
+| length | <code>number</code> | How many characters there are |
+| wholeText | <code>string</code> | The text of this node and of the text nodes next to it |
+
+
+* [TextService](#TextService) ⇐ [<code>NodeService</code>](#NodeService)
+    * [new TextService([data])](#new_TextService_new)
+    * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.splitText(offset)](#TextService+splitText) ⇒ [<code>TextService</code>](#TextService)
+    * [.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>
+
+<a name="new_TextService_new"></a>
+
+### new TextService([data])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
+
+<a name="NodeService+acceptsChildren"></a>
+
+### textService.acceptsChildren ⇒ <code>boolean</code>
+Whether this kind of node can have children (text, comments and attributes cannot).
+
+**Kind**: instance property of [<code>TextService</code>](#TextService)  
+**Overrides**: [<code>acceptsChildren</code>](#NodeService+acceptsChildren)  
+<a name="TextService+splitText"></a>
+
+### textService.splitText(offset) ⇒ [<code>TextService</code>](#TextService)
+Break this text node in two at a position: this node keeps the text before it and a new node with the rest is put
+after this one.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**Returns**: [<code>TextService</code>](#TextService) - The new node  
+**Throws**:
+
+- <code>Error</code> When the offset is beyond the end of the text
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| offset | <code>number</code> | How many characters stay in this node |
+
+<a name="NodeService+appendChild"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>appendChild</code>](#NodeService+appendChild)  
+**Returns**: <code>PseudoNode</code> - The added node  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| childNode | <code>PseudoNode</code> | The node to add |
+
+<a name="NodeService+cloneShallow"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
+<a name="NodeService+equalsShallow"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>equalsShallow</code>](#NodeService+equalsShallow)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
+<a name="NodeService+childInserted"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>childInserted</code>](#NodeService+childInserted)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| child | [<code>NodeService</code>](#NodeService) | The node which was inserted |
+
+<a name="NodeService+cloneNode"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**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>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
+
+<a name="NodeService+contains"></a>
+
+### textService.contains(otherNode) ⇒ <code>boolean</code>
+Check whether a node is this node or one of its descendants.
+
+**Kind**: instance method of [<code>TextService</code>](#TextService)  
+**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>
+
+### textService.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>TextService</code>](#TextService)  
+**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>
+
+### textService.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>TextService</code>](#TextService)  
+**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>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>normalize</code>](#NodeService+normalize)  
+<a name="NodeService+removeChild"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**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 |
+| --- | --- | --- |
+| childElement | <code>PseudoNode</code> | The child node to remove |
+
+<a name="NodeService+replaceChild"></a>
+
+### textService.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>TextService</code>](#TextService)  
+**Overrides**: [<code>replaceChild</code>](#NodeService+replaceChild)  
+**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="CommentService"></a>
+
+## CommentService ⇐ [<code>NodeService</code>](#NodeService)
+Simulate the behaviour of the Comment Class when there is no DOM available: a note in the markup which is not shown.
+
+**Kind**: global class  
+**Extends**: [<code>NodeService</code>](#NodeService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| data | <code>string</code> | The comment |
+| length | <code>number</code> | How many characters there are |
+
+
+* [CommentService](#CommentService) ⇐ [<code>NodeService</code>](#NodeService)
+    * [new CommentService([data])](#new_CommentService_new)
+    * [.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>
+
+<a name="new_CommentService_new"></a>
+
+### new CommentService([data])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
+
+<a name="NodeService+acceptsChildren"></a>
+
+### commentService.acceptsChildren ⇒ <code>boolean</code>
+Whether this kind of node can have children (text, comments and attributes cannot).
+
+**Kind**: instance property of [<code>CommentService</code>](#CommentService)  
+**Overrides**: [<code>acceptsChildren</code>](#NodeService+acceptsChildren)  
+<a name="NodeService+appendChild"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>appendChild</code>](#NodeService+appendChild)  
+**Returns**: <code>PseudoNode</code> - The added node  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| childNode | <code>PseudoNode</code> | The node to add |
+
+<a name="NodeService+cloneShallow"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
+<a name="NodeService+equalsShallow"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>equalsShallow</code>](#NodeService+equalsShallow)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
+<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 |
+| --- | --- | --- |
+| childElement | <code>PseudoNode</code> | The child node to remove |
+
+<a name="NodeService+replaceChild"></a>
+
+### commentService.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>CommentService</code>](#CommentService)  
+**Overrides**: [<code>replaceChild</code>](#NodeService+replaceChild)  
+**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="NamedNodeMapService"></a>
+
+## NamedNodeMapService
+Simulate the behaviour of the NamedNodeMap Class when there is no DOM available.
+
+**Kind**: global class  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+<a name="new_NamedNodeMapService_new"></a>
+
+### new NamedNodeMapService([attributes])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [attributes] | <code>Array.&lt;PseudoAttr&gt;</code> | <code>[]</code> | The attributes to start with |
+
+<a name="MouseEventService"></a>
+
+## MouseEventService ⇐ [<code>UIEventService</code>](#UIEventService)
+Simulate the behaviour of the MouseEvent Class when there is no DOM available.
+
+**Kind**: global class  
+**Extends**: [<code>UIEventService</code>](#UIEventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| screenX | <code>number</code> | 
+| screenY | <code>number</code> | 
+| clientX | <code>number</code> | 
+| clientY | <code>number</code> | 
+| button | <code>number</code> | 
+| buttons | <code>number</code> | 
+| relatedTarget | <code>PseudoEventTarget</code> \| <code>null</code> | 
+
+
+* [MouseEventService](#MouseEventService) ⇐ [<code>UIEventService</code>](#UIEventService)
+    * [new MouseEventService([typeArg], [init])](#new_MouseEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.getModifierState(key)](#MouseEventService+getModifierState) ⇒ <code>boolean</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_MouseEventService_new"></a>
+
+### new MouseEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>MouseEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
+
+### mouseEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+
+**Kind**: instance property of [<code>MouseEventService</code>](#MouseEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="MouseEventService+getModifierState"></a>
+
+### mouseEventService.getModifierState(key) ⇒ <code>boolean</code>
+Whether a modifier key was held down when the event happened.
+
+**Kind**: instance method of [<code>MouseEventService</code>](#MouseEventService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>string</code> | Control, Shift, Alt or Meta |
+
+<a name="EventService+composedPath"></a>
+
+### mouseEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+
+**Kind**: instance method of [<code>MouseEventService</code>](#MouseEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
+
+### mouseEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
+
+**Kind**: instance method of [<code>MouseEventService</code>](#MouseEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
+
+### mouseEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
+
+**Kind**: instance method of [<code>MouseEventService</code>](#MouseEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
+
+### mouseEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
+
+**Kind**: instance method of [<code>MouseEventService</code>](#MouseEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
+<a name="KeyboardEventService"></a>
+
+## KeyboardEventService ⇐ [<code>UIEventService</code>](#UIEventService)
+Simulate the behaviour of the KeyboardEvent Class when there is no DOM available.
+
+**Kind**: global class  
+**Extends**: [<code>UIEventService</code>](#UIEventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| key | <code>string</code> | 
+| code | <code>string</code> | 
+| location | <code>number</code> | 
+| repeat | <code>boolean</code> | 
+| isComposing | <code>boolean</code> | 
+
+
+* [KeyboardEventService](#KeyboardEventService) ⇐ [<code>UIEventService</code>](#UIEventService)
+    * [new KeyboardEventService([typeArg], [init])](#new_KeyboardEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.getModifierState(key)](#KeyboardEventService+getModifierState) ⇒ <code>boolean</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_KeyboardEventService_new"></a>
+
+### new KeyboardEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>KeyboardEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
+
+### keyboardEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+
+**Kind**: instance property of [<code>KeyboardEventService</code>](#KeyboardEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="KeyboardEventService+getModifierState"></a>
+
+### keyboardEventService.getModifierState(key) ⇒ <code>boolean</code>
+Whether a modifier key was held down when the event happened.
+
+**Kind**: instance method of [<code>KeyboardEventService</code>](#KeyboardEventService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>string</code> | Control, Shift, Alt or Meta |
+
+<a name="EventService+composedPath"></a>
+
+### keyboardEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+
+**Kind**: instance method of [<code>KeyboardEventService</code>](#KeyboardEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
+
+### keyboardEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
+
+**Kind**: instance method of [<code>KeyboardEventService</code>](#KeyboardEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
+
+### keyboardEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
+
+**Kind**: instance method of [<code>KeyboardEventService</code>](#KeyboardEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
+
+### keyboardEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
+
+**Kind**: instance method of [<code>KeyboardEventService</code>](#KeyboardEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
+<a name="InputEventService"></a>
+
+## InputEventService ⇐ [<code>UIEventService</code>](#UIEventService)
+Simulate the behaviour of the InputEvent Class when there is no DOM available.
+
+**Kind**: global class  
+**Extends**: [<code>UIEventService</code>](#UIEventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| data | <code>string</code> \| <code>null</code> | 
+| inputType | <code>string</code> | 
+| isComposing | <code>boolean</code> | 
+
+
+* [InputEventService](#InputEventService) ⇐ [<code>UIEventService</code>](#UIEventService)
+    * [new InputEventService([typeArg], [init])](#new_InputEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_InputEventService_new"></a>
+
+### new InputEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>InputEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
+
+### inputEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+
+**Kind**: instance property of [<code>InputEventService</code>](#InputEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="EventService+composedPath"></a>
+
+### inputEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+
+**Kind**: instance method of [<code>InputEventService</code>](#InputEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
+
+### inputEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
+
+**Kind**: instance method of [<code>InputEventService</code>](#InputEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
+
+### inputEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
+
+**Kind**: instance method of [<code>InputEventService</code>](#InputEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
+
+### inputEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
+
+**Kind**: instance method of [<code>InputEventService</code>](#InputEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
+<a name="HTMLElementService"></a>
+
+## HTMLElementService ⇐ <code>PseudoElement</code>
+Simulate the behaviour of the HTMLElement Class when there is no DOM available.
+
+**Kind**: global class  
+**Extends**: <code>PseudoElement</code>  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| hidden | <code>boolean</code> | State of whether element is visible |
+| offsetHeight | <code>number</code> | The height of the element as offset by the parent element |
+| offsetLeft | <code>number</code> | The position of the left side of the element based on the parent element |
+| offsetParent | <code>PseudoHTMLElement</code> | A reference to the closest positioned parent element |
+| offsetTop | <code>number</code> | The position of the top side of the element based on the parent element |
+| offsetWidth | <code>number</code> | The width of the element as offset by the parent element |
+| style | <code>Object</code> | A container to define all applied inline-styles |
+| title | <code>string</code> | The title attribute which affects the text visible on hover |
+
+
+* [HTMLElementService](#HTMLElementService) ⇐ <code>PseudoElement</code>
+    * [new HTMLElementService([elementOptions])](#new_HTMLElementService_new)
+    * [.canFocus](#HTMLElementService+canFocus) ⇒ <code>boolean</code>
+    * [.click()](#HTMLElementService+click)
+    * [.focus()](#HTMLElementService+focus)
+    * [.blur()](#HTMLElementService+blur)
+
+<a name="new_HTMLElementService_new"></a>
+
+### new HTMLElementService([elementOptions])
+Simulate the HTMLElement object when the Dom is not available
+
+
+| Param | Type | Default |
+| --- | --- | --- |
+| [elementOptions] | <code>Object</code> | <code>{}</code> | 
+| [elementOptions.tagName] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | 
+| [elementOptions.parent] | <code>PseudoNode</code> \| <code>Object</code> | <code>{}</code> | 
+| [elementOptions.children] | <code>Array</code> | <code>[]</code> | 
+
+<a name="HTMLElementService+canFocus"></a>
+
+### htmlElementService.canFocus ⇒ <code>boolean</code>
+Whether this element can have the focus: form controls and links which are not disabled, and anything with a tabindex.
+
+**Kind**: instance property of [<code>HTMLElementService</code>](#HTMLElementService)  
+<a name="HTMLElementService+click"></a>
+
+### htmlElementService.click()
+Click the element: a click event is sent to it, which bubbles and can be cancelled, like one from a user but a
+script made it (so it is not trusted). A disabled element does nothing.
+
+**Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+<a name="HTMLElementService+focus"></a>
+
+### htmlElementService.focus()
+Give the element the focus. The element which had it gets blur then focusout, and this one gets focus then
+focusin (blur and focus do not bubble, focusin and focusout do). Nothing happens when the element cannot have the
+focus or already has it.
+
+**Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+<a name="HTMLElementService+blur"></a>
+
+### htmlElementService.blur()
+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="FocusEventService"></a>
+
+## FocusEventService ⇐ [<code>UIEventService</code>](#UIEventService)
+Simulate the behaviour of the FocusEvent Class when there is no DOM available.
+
+**Kind**: global class  
+**Extends**: [<code>UIEventService</code>](#UIEventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| relatedTarget | <code>PseudoEventTarget</code> \| <code>null</code> | 
+
+
+* [FocusEventService](#FocusEventService) ⇐ [<code>UIEventService</code>](#UIEventService)
+    * [new FocusEventService([typeArg], [init])](#new_FocusEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_FocusEventService_new"></a>
+
+### new FocusEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>FocusEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [attributes] | <code>Array.&lt;PseudoAttr&gt;</code> | <code>[]</code> | The attributes to start with |
+### focusEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
 
-<a name="HTMLElementService"></a>
+**Kind**: instance property of [<code>FocusEventService</code>](#FocusEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="EventService+composedPath"></a>
 
-## HTMLElementService ⇐ <code>PseudoElement</code>
-Simulate the behaviour of the HTMLElement Class when there is no DOM available.
+### focusEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
 
-**Kind**: global class  
-**Extends**: <code>PseudoElement</code>  
-**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
-**Properties**
+**Kind**: instance method of [<code>FocusEventService</code>](#FocusEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
 
-| Name | Type | Description |
-| --- | --- | --- |
-| hidden | <code>boolean</code> | State of whether element is visible |
-| offsetHeight | <code>number</code> | The height of the element as offset by the parent element |
-| offsetLeft | <code>number</code> | The position of the left side of the element based on the parent element |
-| offsetParent | <code>PseudoHTMLElement</code> | A reference to the closest positioned parent element |
-| offsetTop | <code>number</code> | The position of the top side of the element based on the parent element |
-| offsetWidth | <code>number</code> | The width of the element as offset by the parent element |
-| style | <code>Object</code> | A container to define all applied inline-styles |
-| title | <code>string</code> | The title attribute which affects the text visible on hover |
+### focusEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
 
-<a name="new_HTMLElementService_new"></a>
+**Kind**: instance method of [<code>FocusEventService</code>](#FocusEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
 
-### new HTMLElementService([elementOptions])
-Simulate the HTMLElement object when the Dom is not available
+### focusEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
 
+**Kind**: instance method of [<code>FocusEventService</code>](#FocusEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
 
-| Param | Type | Default |
-| --- | --- | --- |
-| [elementOptions] | <code>Object</code> | <code>{}</code> | 
-| [elementOptions.tagName] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | 
-| [elementOptions.parent] | <code>PseudoNode</code> \| <code>Object</code> | <code>{}</code> | 
-| [elementOptions.children] | <code>Array</code> | <code>[]</code> | 
+### focusEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
 
+**Kind**: instance method of [<code>FocusEventService</code>](#FocusEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
 <a name="EventTargetService"></a>
 
 ## EventTargetService
@@ -546,6 +1666,9 @@ Simulate the behaviour of the Element Class when there is no DOM available.
 
 * [ElementService](#ElementService) ⇐ <code>PseudoNode</code>
     * [new ElementService([settings])](#new_ElementService_new)
+    * [.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>
     * [.childInserted(child)](#ElementService+childInserted)
     * [.hasAttribute(attributeName)](#ElementService+hasAttribute) ⇒ <code>boolean</code>
@@ -565,6 +1688,32 @@ 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+currentAttributes"></a>
+
+### elementService.currentAttributes() ⇒ <code>Array.&lt;{name: string, value: \*}&gt;</code>
+The attributes with the values they have now: the ones which are also properties (className, id, style, ...) can
+have been changed through the property, which does not change the stored list.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+cloneShallow"></a>
+
+### elementService.cloneShallow() ⇒ [<code>ElementService</code>](#ElementService)
+A copy of this element without its children: the same tag and attributes (the values which are objects, such as
+style, are copied too rather than shared), but not its parent or listeners.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+equalsShallow"></a>
+
+### elementService.equalsShallow(other) ⇒ <code>boolean</code>
+Elements are equal when they have the same tag and the same attributes (in any order), which is what isEqualNode
+checks before it compares the children.
+
+**Kind**: instance method of [<code>ElementService</code>](#ElementService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The element to compare with |
+
 <a name="ElementService+applyDefaultEvent"></a>
 
 ### elementService.applyDefaultEvent() ⇒ <code>function</code>
@@ -638,16 +1787,26 @@ Simulate the behaviour of the Document Class when there is no DOM available.
 **Author**: Joshua Heagle <joshuaheagle@gmail.com>  
 
 * [DocumentService](#DocumentService) ⇐ [<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()](#NodeService+cloneNode)
-    * [.compareDocumentPosition()](#NodeService+compareDocumentPosition)
+    * [.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()](#NodeService+isEqualNode)
+    * [.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>
+
+### documentService.acceptsChildren ⇒ <code>boolean</code>
+Whether this kind of node can have children (text, comments and attributes cannot).
+
+**Kind**: instance property of [<code>DocumentService</code>](#DocumentService)  
 <a name="NodeService+appendChild"></a>
 
 ### documentService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -660,6 +1819,25 @@ 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>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+<a name="NodeService+equalsShallow"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
 <a name="NodeService+childInserted"></a>
 
 ### documentService.childInserted(child)
@@ -674,23 +1852,29 @@ Called each time a node has been inserted as a child of this node, so that nodes
 
 <a name="NodeService+cloneNode"></a>
 
-### documentService.cloneNode()
-Not implemented yet.
+### documentService.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>DocumentService</code>](#DocumentService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
 
 <a name="NodeService+compareDocumentPosition"></a>
 
-### documentService.compareDocumentPosition()
-Not implemented yet.
+### documentService.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>DocumentService</code>](#DocumentService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
 
 <a name="NodeService+contains"></a>
 
@@ -723,14 +1907,22 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### documentService.isEqualNode()
-Not implemented yet.
+### documentService.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>DocumentService</code>](#DocumentService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+
+<a name="NodeService+normalize"></a>
+
+### documentService.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>DocumentService</code>](#DocumentService)  
 <a name="NodeService+removeChild"></a>
 
 ### documentService.removeChild(childElement) ⇒ <code>PseudoNode</code>
@@ -775,16 +1967,26 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 **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>
     * [.childInserted(child)](#NodeService+childInserted)
-    * [.cloneNode()](#NodeService+cloneNode)
-    * [.compareDocumentPosition()](#NodeService+compareDocumentPosition)
+    * [.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()](#NodeService+isEqualNode)
+    * [.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>
@@ -797,6 +1999,25 @@ 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>
+
+### 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+childInserted"></a>
 
 ### documentFragmentService.childInserted(child)
@@ -811,23 +2032,29 @@ Called each time a node has been inserted as a child of this node, so that nodes
 
 <a name="NodeService+cloneNode"></a>
 
-### documentFragmentService.cloneNode()
-Not implemented yet.
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
 
 <a name="NodeService+compareDocumentPosition"></a>
 
-### documentFragmentService.compareDocumentPosition()
-Not implemented yet.
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
 
 <a name="NodeService+contains"></a>
 
@@ -860,14 +2087,22 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### documentFragmentService.isEqualNode()
-Not implemented yet.
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+
+<a name="NodeService+normalize"></a>
+
+### documentFragmentService.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>DocumentFragmentService</code>](#DocumentFragmentService)  
 <a name="NodeService+removeChild"></a>
 
 ### documentFragmentService.removeChild(childElement) ⇒ <code>PseudoNode</code>
@@ -917,6 +2152,75 @@ Simulate the behaviour of the DOMTokenList Class when there is no DOM available.
 | [value] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The space separated tokens to start with |
 | [onChange] | <code>function</code> |  | Called with the new value whenever the tokens change |
 
+<a name="CustomEventService"></a>
+
+## CustomEventService ⇐ [<code>EventService</code>](#EventService)
+Simulate the behaviour of the CustomEvent Class when there is no DOM available: an event which carries data.
+
+**Kind**: global class  
+**Extends**: [<code>EventService</code>](#EventService)  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type |
+| --- | --- |
+| detail | <code>\*</code> | 
+
+
+* [CustomEventService](#CustomEventService) ⇐ [<code>EventService</code>](#EventService)
+    * [new CustomEventService([typeArg], [init])](#new_CustomEventService_new)
+    * [.inner](#EventService+inner) ⇒ <code>EventInner</code>
+    * [.composedPath()](#EventService+composedPath) ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+    * [.preventDefault()](#EventService+preventDefault) ⇒ <code>null</code>
+    * [.stopImmediatePropagation()](#EventService+stopImmediatePropagation) ⇒ <code>null</code>
+    * [.stopPropagation()](#EventService+stopPropagation) ⇒ <code>null</code>
+
+<a name="new_CustomEventService_new"></a>
+
+### new CustomEventService([typeArg], [init])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [typeArg] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The type of the event |
+| [init] | <code>CustomEventInit</code> | <code>{}</code> | The options for the event |
+
+<a name="EventService+inner"></a>
+
+### customEventService.inner ⇒ <code>EventInner</code>
+Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+
+**Kind**: instance property of [<code>CustomEventService</code>](#CustomEventService)  
+**Overrides**: [<code>inner</code>](#EventService+inner)  
+<a name="EventService+composedPath"></a>
+
+### customEventService.composedPath() ⇒ <code>Array.&lt;PseudoEventTarget&gt;</code>
+Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+
+**Kind**: instance method of [<code>CustomEventService</code>](#CustomEventService)  
+**Overrides**: [<code>composedPath</code>](#EventService+composedPath)  
+<a name="EventService+preventDefault"></a>
+
+### customEventService.preventDefault() ⇒ <code>null</code>
+Cancels the event (if it is cancelable).
+
+**Kind**: instance method of [<code>CustomEventService</code>](#CustomEventService)  
+**Overrides**: [<code>preventDefault</code>](#EventService+preventDefault)  
+<a name="EventService+stopImmediatePropagation"></a>
+
+### customEventService.stopImmediatePropagation() ⇒ <code>null</code>
+For this particular event, no other listener will be called.
+Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+capture phase, for instance)
+
+**Kind**: instance method of [<code>CustomEventService</code>](#CustomEventService)  
+**Overrides**: [<code>stopImmediatePropagation</code>](#EventService+stopImmediatePropagation)  
+<a name="EventService+stopPropagation"></a>
+
+### customEventService.stopPropagation() ⇒ <code>null</code>
+Stops the propagation of events further along in the Dom.
+
+**Kind**: instance method of [<code>CustomEventService</code>](#CustomEventService)  
+**Overrides**: [<code>stopPropagation</code>](#EventService+stopPropagation)  
 <a name="AttrService"></a>
 
 ## AttrService ⇐ [<code>NodeService</code>](#NodeService)
@@ -928,13 +2232,17 @@ Simulate the behaviour of the Attr Class when there is no DOM available.
 
 * [AttrService](#AttrService) ⇐ [<code>NodeService</code>](#NodeService)
     * [new AttrService(name, [value], [ownerElement], [namespaceURI], [prefix])](#new_AttrService_new)
+    * [.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()](#NodeService+cloneNode)
-    * [.compareDocumentPosition()](#NodeService+compareDocumentPosition)
+    * [.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()](#NodeService+isEqualNode)
+    * [.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>
 
@@ -950,6 +2258,13 @@ Simulate the behaviour of the Attr Class when there is no DOM available.
 | [namespaceURI] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The namespace of the attribute |
 | [prefix] | <code>string</code> \| <code>null</code> | <code>null</code> | The namespace prefix of the attribute |
 
+<a name="NodeService+acceptsChildren"></a>
+
+### attrService.acceptsChildren ⇒ <code>boolean</code>
+Whether this kind of node can have children (text, comments and attributes cannot).
+
+**Kind**: instance property of [<code>AttrService</code>](#AttrService)  
+**Overrides**: [<code>acceptsChildren</code>](#NodeService+acceptsChildren)  
 <a name="NodeService+appendChild"></a>
 
 ### attrService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -963,6 +2278,27 @@ 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>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
+<a name="NodeService+equalsShallow"></a>
+
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>equalsShallow</code>](#NodeService+equalsShallow)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
 <a name="NodeService+childInserted"></a>
 
 ### attrService.childInserted(child)
@@ -978,25 +2314,31 @@ Called each time a node has been inserted as a child of this node, so that nodes
 
 <a name="NodeService+cloneNode"></a>
 
-### attrService.cloneNode()
-Not implemented yet.
+### attrService.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>AttrService</code>](#AttrService)  
 **Overrides**: [<code>cloneNode</code>](#NodeService+cloneNode)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
 
 <a name="NodeService+compareDocumentPosition"></a>
 
-### attrService.compareDocumentPosition()
-Not implemented yet.
+### attrService.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>AttrService</code>](#AttrService)  
 **Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
 
 <a name="NodeService+contains"></a>
 
@@ -1031,15 +2373,24 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### attrService.isEqualNode()
-Not implemented yet.
+### attrService.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>AttrService</code>](#AttrService)  
 **Overrides**: [<code>isEqualNode</code>](#NodeService+isEqualNode)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+
+<a name="NodeService+normalize"></a>
 
+### attrService.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>AttrService</code>](#AttrService)  
+**Overrides**: [<code>normalize</code>](#NodeService+normalize)  
 <a name="NodeService+removeChild"></a>
 
 ### attrService.removeChild(childElement) ⇒ <code>PseudoNode</code>
@@ -1087,13 +2438,17 @@ from that linker, and its parent from the linker's parent when it has not been g
 
 * [LinkedNode](#LinkedNode) ⇐ [<code>NodeService</code>](#NodeService)
     * [new LinkedNode(linker, value)](#new_LinkedNode_new)
+    * [.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()](#NodeService+cloneNode)
-    * [.compareDocumentPosition()](#NodeService+compareDocumentPosition)
+    * [.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()](#NodeService+isEqualNode)
+    * [.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>
 
@@ -1106,6 +2461,13 @@ from that linker, and its parent from the linker's parent when it has not been g
 | linker | <code>TreeLinker</code> | The linker holding this node |
 | value | <code>string</code> \| <code>null</code> | The value of the node |
 
+<a name="NodeService+acceptsChildren"></a>
+
+### linkedNode.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)  
+**Overrides**: [<code>acceptsChildren</code>](#NodeService+acceptsChildren)  
 <a name="NodeService+appendChild"></a>
 
 ### linkedNode.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -1119,6 +2481,27 @@ 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>
+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)  
+**Overrides**: [<code>equalsShallow</code>](#NodeService+equalsShallow)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
 <a name="NodeService+childInserted"></a>
 
 ### linkedNode.childInserted(child)
@@ -1134,25 +2517,31 @@ Called each time a node has been inserted as a child of this node, so that nodes
 
 <a name="NodeService+cloneNode"></a>
 
-### linkedNode.cloneNode()
-Not implemented yet.
+### 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)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
 
 <a name="NodeService+compareDocumentPosition"></a>
 
-### linkedNode.compareDocumentPosition()
-Not implemented yet.
+### linkedNode.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)  
 **Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> | The node to locate |
 
 <a name="NodeService+contains"></a>
 
@@ -1187,15 +2576,24 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### linkedNode.isEqualNode()
-Not implemented yet.
+### linkedNode.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)  
 **Overrides**: [<code>isEqualNode</code>](#NodeService+isEqualNode)  
-**Throws**:
 
-- <code>Error</code> 
+| Param | Type | Description |
+| --- | --- | --- |
+| otherNode | <code>PseudoNode</code> \| <code>null</code> | The node to compare with |
+
+<a name="NodeService+normalize"></a>
 
+### linkedNode.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)  
+**Overrides**: [<code>normalize</code>](#NodeService+normalize)  
 <a name="NodeService+removeChild"></a>
 
 ### linkedNode.removeChild(childElement) ⇒ <code>PseudoNode</code>
@@ -1285,6 +2683,10 @@ Simulate the behaviour of the HTMLDocument Class when there is no DOM available.
     * [.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>
 
@@ -1306,7 +2708,7 @@ Create document body element
 <a name="PseudoHTMLDocument+createElement"></a>
 
 ### pseudoHTMLDocument.createElement(tagName) ⇒ <code>PseudoHTMLElement</code>
-Create and return a PseudoHTMLElement, which is not added to the document until it is appended somewhere
+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)  
 
@@ -1314,6 +2716,47 @@ Create and return a PseudoHTMLElement, which is not added to the document until
 | --- | --- | --- | --- |
 | 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
@@ -1442,10 +2885,48 @@ current one.
 | --- | --- |
 | event | <code>PseudoEvent</code> | 
 
+<a name="eventDefaults"></a>
+
+## eventDefaults : <code>Object.&lt;string, EventDefinition&gt;</code>
+The events which the browser itself creates (for a user action, or for something like element.click()) have these
+options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
+for them, which is why createEvent only uses this table when it is told the browser is creating the event.
+The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.
+
+**Kind**: global variable  
+<a name="focused"></a>
+
+## 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>
+
+## modifierKeys([init]) ⇒ <code>ModifierKeys</code>
+Pick the modifier keys out of the init object of an event.
+
+**Kind**: global function  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [init] | <code>Object</code> | <code>{}</code> | The init of an event |
+
+<a name="modifierState"></a>
+
+## modifierState(keys, key) ⇒ <code>boolean</code>
+Answer getModifierState for a set of held modifier keys.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| keys | <code>ModifierKeys</code> | The modifier keys which were held down |
+| key | <code>string</code> | The name of the modifier (Control, Shift, Alt or Meta) |
+
 <a name="getParentNodesFromAttribute"></a>
 
 ## getParentNodesFromAttribute(attr, value, node) ⇒ <code>Array.&lt;PseudoNode&gt;</code>
@@ -1473,6 +2954,29 @@ order in which an event travels down through them). A node which has no parent h
 | --- | --- | --- |
 | node | <code>PseudoEventTarget</code> \| <code>PseudoNode</code> \| <code>\*</code> | The node to find the ancestors of |
 
+<a name="getActiveElement"></a>
+
+## getActiveElement(root) ⇒ <code>Object</code> \| <code>null</code>
+Find the element which has the focus in a tree.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| root | <code>Object</code> | The root node of the tree |
+
+<a name="setActiveElement"></a>
+
+## setActiveElement(root, element)
+Remember the element which has the focus in a tree.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| root | <code>Object</code> | The root node of the tree |
+| element | <code>Object</code> \| <code>null</code> | The element which now has the focus, or null when nothing has it |
+
 <a name="generateNodeList"></a>
 
 ## generateNodeList([innerList]) ⇒ [<code>PseudoNodeList</code>](#PseudoNodeList)
@@ -1537,3 +3041,20 @@ Create an instance of HTMLElement if not available
 Define document when not available
 
 **Kind**: inner constant of [<code>generateDocument</code>](#generateDocument)  
+<a name="createEvent"></a>
+
+## createEvent(type, [init], [options]) ⇒ [<code>EventService</code>](#EventService)
+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
+the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
+it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
+real user action (isTrusted).
+
+**Kind**: global function  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| type | <code>string</code> |  | The type of the event, such as click |
+| [init] | <code>Object</code> | <code>{}</code> | The options for the event (bubbles, cancelable, composed and those of its kind of event) |
+| [options] | <code>CreateEventOptions</code> | <code>{}</code> | Whether the browser is creating the event, and whether it is trusted |
+