pseudo-dom 0.7.0 → 0.9.0

package/README.md

@@ -18,6 +18,13 @@ else, document fragments insert their children, and a node cannot be put inside
 `DOMTokenListService`, `NamedNodeMapService`, `DocumentService` / `DocumentFragmentService`, `PseudoNodeList`, and
 `generateDocument` for creating a document.
 
+`style` is a real, live `CSSStyleDeclaration`: named property access (\`el.style.backgroundColor = 'red'\`) alongside
+\`getPropertyValue\` / \`setProperty\` / \`removeProperty\` / \`getPropertyPriority\` / \`cssText\`; an unset property
+reads as \`''\`, like the DOM's. \`dataset\` is a live `DOMStringMap`: reading/writing/deleting a camelCase name
+(\`el.dataset.fooBar\`) reads/writes/removes the matching \`data-foo-bar\` attribute directly, so it can never fall out
+of sync with the attributes themselves. Both are on \`HTMLElementService\`, matching the DOM (they are not on the base
+Element).
+
 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
@@ -49,8 +56,14 @@ Selector queries work like the DOM's: \`getElementsByTagName\` / \`getElementsBy
 \`querySelector\` / \`querySelectorAll\` (real CSS selectors, via [css-select](https://www.npmjs.com/package/css-select)
 matched against pseudo-dom's own tree through a custom adapter - \`querySelectorAll\` is a plain array, a snapshot
 taken when it is called, like the DOM's) are on \`NodeService\` so \`Document\`, \`DocumentFragment\` and \`Element\`
-all have them; \`matches\` / \`closest\` are on \`ElementService\`; \`getElementById\` is on \`DocumentService\` only,
-matching the real DOM.
+all have them; \`matches\` / \`closest\` are on \`ElementService\`; \`getElementById\` is on both \`DocumentService\`
+and \`DocumentFragmentService\` (the DOM's \`NonElementParentNode\` mixin, so a \`ShadowRoot\` gets it too), matching
+the real DOM.
+
+\`DocumentService\` matches the real \`Document\` (it is not an \`Element\`, so it has no \`tagName\` / \`classList\` /
+\`matches\` / etc.): \`createElement\`, \`createTextNode\`, \`createComment\`, \`createDocumentFragment\`,
+\`getElementById\`, and \`textContent\` always \`null\`. \`PseudoHTMLDocument\` (what \`generateDocument\` actually
+creates) only adds the \`html\` / \`head\` / \`body\` structure on top.
 
 Not implemented yet (these throw a "not implemented" error or are missing): \`getElementsByTagNameNS\`, \`innerHTML\` /
 \`outerHTML\` parsing, and most of the rest of the Element and Document APIs. The API will change before 1.0.
@@ -131,19 +144,24 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 <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="#CSSStyleDeclarationService">CSSStyleDeclarationService</a></dt>
+<dd><p>Simulate the behaviour of the CSSStyleDeclaration Class when there is no DOM available: an ordered map of CSS
+property/value pairs, parsed from and serialized back to a cssText string. Values are stored and returned as
+given, with no unit conversion, shorthand expansion or validation - this is a data structure, not a real CSS
+engine. Named property access (declaration.backgroundColor, camelCase) is added on top of this by
+createStyleDeclaration, which wraps an instance of this class in a Proxy.</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>
-<dt><a href="#LinkedNode">LinkedNode</a> ⇐ <code><a href="#NodeService">NodeService</a></code></dt>
-<dd><p>A node which is stored in a TreeLinker (for example by a list built from an array of values). It finds its siblings
-from that linker, and its parent from the linker&#39;s parent when it has not been given one by appendChild.</p>
-</dd>
 <dt><a href="#PseudoNodeList">PseudoNodeList</a> ⇐ <code>LinkedTreeList</code></dt>
 <dd><p>A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
 the linkers that hold them.</p>
 </dd>
-<dt><a href="#PseudoHTMLDocument">PseudoHTMLDocument</a> ⇐ <code>PseudoHTMLElement</code></dt>
-<dd><p>Simulate the behaviour of the HTMLDocument Class when there is no DOM available.</p>
+<dt><a href="#PseudoHTMLDocument">PseudoHTMLDocument</a> ⇐ <code><a href="#DocumentService">DocumentService</a></code></dt>
+<dd><p>Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
+only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
+createComment, createDocumentFragment, getElementById, textContent always null).</p>
 </dd>
 <dt><a href="#PseudoEventListener">PseudoEventListener</a></dt>
 <dd><p>Handle events as they are stored and implemented.</p>
@@ -167,8 +185,6 @@ The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop,
 <dt><a href="#focused">focused</a></dt>
 <dd><p>The element which has the focus, kept for each tree (the root node of the tree it is in), like document.activeElement.</p>
 </dd>
-<dt><a href="#HTMLElementService_1">HTMLElementService_1</a> : <code>PseudoHTMLElement</code></dt>
-<dd></dd>
 </dl>
 
 ## Functions
@@ -198,10 +214,6 @@ order in which an event travels down through them). A node which has no parent h
 <dt><a href="#generateNodeList">generateNodeList([innerList])</a> ⇒ <code><a href="#PseudoNodeList">PseudoNodeList</a></code></dt>
 <dd><p>Create a PseudoNodeList, optionally starting from an existing chain of linkers.</p>
 </dd>
-<dt><a href="#generateNode">generateNode()</a> ⇒ <code>function</code></dt>
-<dd><p>Create a TreeLinker class whose linkers each store a node (a LinkedNode) as their data, this can be used to build a
-tree (or list) of nodes from plain values.</p>
-</dd>
 <dt><a href="#generateDocument">generateDocument(root, context)</a> ⇒ <code>Window</code> | <code>PseudoEventTarget</code></dt>
 <dd><p>Construct the Pseudo Dom to provide access to Dom objects which are otherwise not available outside the browser
 context.</p>
@@ -209,6 +221,12 @@ context.</p>
 <dt><a href="#nearestElementSibling">nearestElementSibling(node, direction)</a> ⇒ <code>*</code> | <code>null</code></dt>
 <dd><p>Walk up from a node (not including it) to find the nearest element, in the given direction.</p>
 </dd>
+<dt><a href="#kebabToCamel">kebabToCamel(name)</a> ⇒ <code>string</code></dt>
+<dd><p>kebab-case -&gt; camelCase (&quot;background-color&quot; -&gt; &quot;backgroundColor&quot;).</p>
+</dd>
+<dt><a href="#camelToKebab">camelToKebab(name)</a> ⇒ <code>string</code></dt>
+<dd><p>camelCase -&gt; kebab-case (&quot;backgroundColor&quot; -&gt; &quot;background-color&quot;).</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
@@ -216,6 +234,9 @@ the init says so, and the event is not trusted. With browser: true the event is
 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>
+<dt><a href="#dataAttributes">dataAttributes(element)</a> ⇒ <code>Array.&lt;Array.&lt;string&gt;&gt;</code></dt>
+<dd><p>Every data-* attribute name currently on the element, as [attributeName, camelCaseName] pairs.</p>
+</dd>
 </dl>
 
 <a name="module_pseudoDom/simulate"></a>
@@ -1825,13 +1846,18 @@ Simulate the behaviour of the HTMLElement Class when there is no DOM available.
 | 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 |
+| style | [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService) | The element's inline styles, live and settable per property |
+| dataset | <code>Object.&lt;string, string&gt;</code> | The element's data-* attributes, live, under their camelCase names |
 | 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)
+    * [.style](#HTMLElementService+style) ⇒ [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)
+    * [.dataset](#HTMLElementService+dataset) ⇒ <code>Object.&lt;string, string&gt;</code>
     * [.canFocus](#HTMLElementService+canFocus) ⇒ <code>boolean</code>
+    * [.cloneShallow()](#HTMLElementService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
+    * [.equalsShallow(other)](#HTMLElementService+equalsShallow) ⇒ <code>boolean</code>
     * [.click()](#HTMLElementService+click)
     * [.focus()](#HTMLElementService+focus)
     * [.blur()](#HTMLElementService+blur)
@@ -1849,12 +1875,43 @@ Simulate the HTMLElement object when the Dom is not available
 | [elementOptions.parent] | <code>PseudoNode</code> \| <code>Object</code> | <code>{}</code> | 
 | [elementOptions.children] | <code>Array</code> | <code>[]</code> | 
 
+<a name="HTMLElementService+style"></a>
+
+### htmlElementService.style ⇒ [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)
+The element's inline styles: a live CSSStyleDeclaration-like object, so both style.setProperty('color', 'red')
+and style.color = 'red' work.
+
+**Kind**: instance property of [<code>HTMLElementService</code>](#HTMLElementService)  
+<a name="HTMLElementService+dataset"></a>
+
+### htmlElementService.dataset ⇒ <code>Object.&lt;string, string&gt;</code>
+The element's data-* attributes, live, under their camelCase names (data-foo-bar <-> dataset.fooBar). Backed
+directly by getAttribute / setAttribute, so it is never out of sync with the attributes themselves.
+
+**Kind**: instance property of [<code>HTMLElementService</code>](#HTMLElementService)  
 <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+cloneShallow"></a>
+
+### htmlElementService.cloneShallow() ⇒ [<code>NodeService</code>](#NodeService)
+Style is not attribute-backed like most properties (see the constructor), so cloneNode needs its own copy of it.
+
+**Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+<a name="HTMLElementService+equalsShallow"></a>
+
+### htmlElementService.equalsShallow(other) ⇒ <code>boolean</code>
+Style is not attribute-backed like most properties, so isEqualNode needs to compare it separately too.
+
+**Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| other | [<code>NodeService</code>](#NodeService) | The node to compare with |
+
 <a name="HTMLElementService+click"></a>
 
 ### htmlElementService.click()
@@ -2493,6 +2550,10 @@ Simulate the behaviour of the Document Class when there is no DOM available.
 * [DocumentService](#DocumentService) ⇐ [<code>NodeService</code>](#NodeService)
     * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
     * [.getElementById(id)](#DocumentService+getElementById) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.createElement([tagName])](#DocumentService+createElement) ⇒ <code>PseudoElement</code>
+    * [.createTextNode([data])](#DocumentService+createTextNode) ⇒ [<code>TextService</code>](#TextService)
+    * [.createComment([data])](#DocumentService+createComment) ⇒ [<code>CommentService</code>](#CommentService)
+    * [.createDocumentFragment()](#DocumentService+createDocumentFragment) ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
     * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
     * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</code>
@@ -2535,6 +2596,46 @@ The first element, in tree order, whose id matches the given value, or null when
 | --- | --- |
 | id | <code>string</code> | 
 
+<a name="DocumentService+createElement"></a>
+
+### documentService.createElement([tagName]) ⇒ <code>PseudoElement</code>
+Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [tagName] | <code>string</code> | <code>&quot;&#x27;div&#x27;&quot;</code> | The type of element to create |
+
+<a name="DocumentService+createTextNode"></a>
+
+### documentService.createTextNode([data]) ⇒ [<code>TextService</code>](#TextService)
+Make a text node which belongs to this document.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
+
+<a name="DocumentService+createComment"></a>
+
+### documentService.createComment([data]) ⇒ [<code>CommentService</code>](#CommentService)
+Make a comment which belongs to this document.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
+
+<a name="DocumentService+createDocumentFragment"></a>
+
+### documentService.createDocumentFragment() ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
+Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
+then inserted in one go.
+
+**Kind**: instance method of [<code>DocumentService</code>](#DocumentService)  
 <a name="NodeService+appendChild"></a>
 
 ### documentService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -2840,6 +2941,7 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 
 * [DocumentFragmentService](#DocumentFragmentService) ⇐ [<code>NodeService</code>](#NodeService)
     * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.getElementById(id)](#DocumentFragmentService+getElementById) ⇒ <code>PseudoElement</code> \| <code>null</code>
     * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
     * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</code>
@@ -2871,6 +2973,18 @@ not part of a tree, when it is inserted its children are moved into the tree ins
 Whether this kind of node can have children (text, comments and attributes cannot).
 
 **Kind**: instance property of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+<a name="DocumentFragmentService+getElementById"></a>
+
+### documentFragmentService.getElementById(id) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element, in tree order, whose id matches the given value, or null when there is none (the DOM's
+NonElementParentNode mixin, which Document and DocumentFragment both implement).
+
+**Kind**: instance method of [<code>DocumentFragmentService</code>](#DocumentFragmentService)  
+
+| Param | Type |
+| --- | --- |
+| id | <code>string</code> | 
+
 <a name="NodeService+appendChild"></a>
 
 ### documentFragmentService.appendChild(childNode) ⇒ <code>PseudoNode</code>
@@ -3249,6 +3363,119 @@ 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="CSSStyleDeclarationService"></a>
+
+## CSSStyleDeclarationService
+Simulate the behaviour of the CSSStyleDeclaration Class when there is no DOM available: an ordered map of CSS
+property/value pairs, parsed from and serialized back to a cssText string. Values are stored and returned as
+given, with no unit conversion, shorthand expansion or validation - this is a data structure, not a real CSS
+engine. Named property access (declaration.backgroundColor, camelCase) is added on top of this by
+createStyleDeclaration, which wraps an instance of this class in a Proxy.
+
+**Kind**: global class  
+**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+
+* [CSSStyleDeclarationService](#CSSStyleDeclarationService)
+    * [new CSSStyleDeclarationService([cssText])](#new_CSSStyleDeclarationService_new)
+    * [.length](#CSSStyleDeclarationService+length) ⇒ <code>number</code>
+    * [.cssText](#CSSStyleDeclarationService+cssText) ⇒ <code>string</code>
+    * [.cssText](#CSSStyleDeclarationService+cssText) ⇒ <code>undefined</code>
+    * [.item(index)](#CSSStyleDeclarationService+item) ⇒ <code>string</code>
+    * [.getPropertyValue(property)](#CSSStyleDeclarationService+getPropertyValue) ⇒ <code>string</code>
+    * [.getPropertyPriority(property)](#CSSStyleDeclarationService+getPropertyPriority) ⇒ <code>string</code>
+    * [.setProperty(property, value, [priority])](#CSSStyleDeclarationService+setProperty) ⇒ <code>undefined</code>
+    * [.removeProperty(property)](#CSSStyleDeclarationService+removeProperty) ⇒ <code>string</code>
+
+<a name="new_CSSStyleDeclarationService_new"></a>
+
+### new CSSStyleDeclarationService([cssText])
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [cssText] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | Initial declarations, as CSS text ("color: red; font-size: 12px;") |
+
+<a name="CSSStyleDeclarationService+length"></a>
+
+### cssStyleDeclarationService.length ⇒ <code>number</code>
+How many properties are currently set.
+
+**Kind**: instance property of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+<a name="CSSStyleDeclarationService+cssText"></a>
+
+### cssStyleDeclarationService.cssText ⇒ <code>string</code>
+All the declarations as one CSS text string.
+
+**Kind**: instance property of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+<a name="CSSStyleDeclarationService+cssText"></a>
+
+### cssStyleDeclarationService.cssText ⇒ <code>undefined</code>
+Replace every declaration by parsing a CSS text string ("color: red; font-size: 12px !important;").
+
+**Kind**: instance property of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+
+| Param | Type |
+| --- | --- |
+| cssText | <code>string</code> | 
+
+<a name="CSSStyleDeclarationService+item"></a>
+
+### cssStyleDeclarationService.item(index) ⇒ <code>string</code>
+The name of the property at the given index, in the order it was set, or '' when there is none (matches the
+DOM's CSSStyleDeclaration, which is array-like).
+
+**Kind**: instance method of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+
+| Param | Type |
+| --- | --- |
+| index | <code>number</code> | 
+
+<a name="CSSStyleDeclarationService+getPropertyValue"></a>
+
+### cssStyleDeclarationService.getPropertyValue(property) ⇒ <code>string</code>
+The value of the given property, or '' when it is not set.
+
+**Kind**: instance method of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| property | <code>string</code> | A CSS property name (kebab-case, e.g. "background-color") |
+
+<a name="CSSStyleDeclarationService+getPropertyPriority"></a>
+
+### cssStyleDeclarationService.getPropertyPriority(property) ⇒ <code>string</code>
+"important" when the property was set with !important, otherwise ''.
+
+**Kind**: instance method of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| property | <code>string</code> | A CSS property name (kebab-case) |
+
+<a name="CSSStyleDeclarationService+setProperty"></a>
+
+### cssStyleDeclarationService.setProperty(property, value, [priority]) ⇒ <code>undefined</code>
+Set a property's value (and optionally its priority). An empty, null or undefined value removes the property
+instead, like the DOM.
+
+**Kind**: instance method of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| property | <code>string</code> |  | A CSS property name (kebab-case) |
+| value | <code>string</code> |  | The value, or '' to remove the property |
+| [priority] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | "important" to mark it !important |
+
+<a name="CSSStyleDeclarationService+removeProperty"></a>
+
+### cssStyleDeclarationService.removeProperty(property) ⇒ <code>string</code>
+Remove a property, returning the value it had (or '' when it was not set).
+
+**Kind**: instance method of [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| property | <code>string</code> | A CSS property name (kebab-case) |
+
 <a name="AttrService"></a>
 
 ## AttrService ⇐ [<code>NodeService</code>](#NodeService)
@@ -3622,21 +3849,69 @@ Replace a child of this node with another node (which is moved if it is already
 | newChild | <code>PseudoNode</code> | The node which takes the place |
 | oldChild | <code>PseudoNode</code> | The child of this node to replace |
 
-<a name="LinkedNode"></a>
+<a name="PseudoNodeList"></a>
 
-## LinkedNode ⇐ [<code>NodeService</code>](#NodeService)
-A node which is stored in a TreeLinker (for example by a list built from an array of values). It finds its siblings
-from that linker, and its parent from the linker's parent when it has not been given one by appendChild.
+## PseudoNodeList ⇐ <code>LinkedTreeList</code>
+A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
+the linkers that hold them.
 
 **Kind**: global class  
-**Extends**: [<code>NodeService</code>](#NodeService)  
+**Extends**: <code>LinkedTreeList</code>  
+
+* [PseudoNodeList](#PseudoNodeList) ⇐ <code>LinkedTreeList</code>
+    * [.entries()](#PseudoNodeList+entries) ⇒ <code>Iterator</code>
+    * [.keys()](#PseudoNodeList+keys) ⇒ <code>Iterator</code>
+    * [.values()](#PseudoNodeList+values) ⇒ <code>Iterator</code>
+
+<a name="PseudoNodeList+entries"></a>
+
+### pseudoNodeList.entries() ⇒ <code>Iterator</code>
+Iterate over [index, node] pairs.
+
+**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
+<a name="PseudoNodeList+keys"></a>
+
+### pseudoNodeList.keys() ⇒ <code>Iterator</code>
+Iterate over the indexes.
+
+**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
+<a name="PseudoNodeList+values"></a>
+
+### pseudoNodeList.values() ⇒ <code>Iterator</code>
+Iterate over the nodes.
+
+**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
+<a name="PseudoHTMLDocument"></a>
+
+## PseudoHTMLDocument ⇐ [<code>DocumentService</code>](#DocumentService)
+Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
+only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
+createComment, createDocumentFragment, getElementById, textContent always null).
+
+**Kind**: global class  
+**Extends**: [<code>DocumentService</code>](#DocumentService)  
 **Author**: Joshua Heagle <joshuaheagle@gmail.com>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| head | <code>PseudoHTMLElement</code> | A reference to the Head child element |
+| body | <code>PseudoHTMLElement</code> | A reference to the Body child element |
 
-* [LinkedNode](#LinkedNode) ⇐ [<code>NodeService</code>](#NodeService)
-    * [new LinkedNode(linker, value)](#new_LinkedNode_new)
+
+* [PseudoHTMLDocument](#PseudoHTMLDocument) ⇐ [<code>DocumentService</code>](#DocumentService)
+    * [new PseudoHTMLDocument()](#new_PseudoHTMLDocument_new)
+    * [.head](#PseudoHTMLDocument+head) : <code>PseudoHTMLElement</code>
+    * [.body](#PseudoHTMLDocument+body) : <code>PseudoHTMLElement</code>
     * [.acceptsChildren](#NodeService+acceptsChildren) ⇒ <code>boolean</code>
+    * [.cloneShallow()](#PseudoHTMLDocument+cloneShallow) ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+    * [.cloneNode([deep])](#PseudoHTMLDocument+cloneNode) ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+    * [.getElementById(id)](#DocumentService+getElementById) ⇒ <code>PseudoElement</code> \| <code>null</code>
+    * [.createElement([tagName])](#DocumentService+createElement) ⇒ <code>PseudoElement</code>
+    * [.createTextNode([data])](#DocumentService+createTextNode) ⇒ [<code>TextService</code>](#TextService)
+    * [.createComment([data])](#DocumentService+createComment) ⇒ [<code>CommentService</code>](#CommentService)
+    * [.createDocumentFragment()](#DocumentService+createDocumentFragment) ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
     * [.appendChild(childNode)](#NodeService+appendChild) ⇒ <code>PseudoNode</code>
-    * [.cloneShallow()](#NodeService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#NodeService+equalsShallow) ⇒ <code>boolean</code>
     * [.append(...nodes)](#NodeService+append)
     * [.prepend(...nodes)](#NodeService+prepend)
@@ -3651,7 +3926,6 @@ from that linker, and its parent from the linker's parent when it has not been g
     * [.querySelector(selectors)](#NodeService+querySelector) ⇒ <code>PseudoElement</code> \| <code>null</code>
     * [.querySelectorAll(selectors)](#NodeService+querySelectorAll) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
     * [.childInserted(child)](#NodeService+childInserted)
-    * [.cloneNode([deep])](#NodeService+cloneNode) ⇒ <code>PseudoNode</code>
     * [.compareDocumentPosition(otherNode)](#NodeService+compareDocumentPosition) ⇒ <code>number</code>
     * [.contains(otherNode)](#NodeService+contains) ⇒ <code>boolean</code>
     * [.insertBefore(newNode, [referenceNode])](#NodeService+insertBefore) ⇒ <code>PseudoNode</code>
@@ -3660,28 +3934,113 @@ from that linker, and its parent from the linker's parent when it has not been g
     * [.removeChild(childElement)](#NodeService+removeChild) ⇒ <code>PseudoNode</code>
     * [.replaceChild(newChild, oldChild)](#NodeService+replaceChild) ⇒ <code>PseudoNode</code>
 
-<a name="new_LinkedNode_new"></a>
+<a name="new_PseudoHTMLDocument_new"></a>
 
-### new LinkedNode(linker, value)
+### new PseudoHTMLDocument()
+The root HTML element is acts as the parent to all HTML elements in the document.
 
-| Param | Type | Description |
-| --- | --- | --- |
-| linker | <code>TreeLinker</code> | The linker holding this node |
-| value | <code>string</code> \| <code>null</code> | The value of the node |
+<a name="PseudoHTMLDocument+head"></a>
 
+### pseudoHTMLDocument.head : <code>PseudoHTMLElement</code>
+Create document head element
+
+**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+<a name="PseudoHTMLDocument+body"></a>
+
+### pseudoHTMLDocument.body : <code>PseudoHTMLElement</code>
+Create document body element
+
+**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 <a name="NodeService+acceptsChildren"></a>
 
-### linkedNode.acceptsChildren ⇒ <code>boolean</code>
+### pseudoHTMLDocument.acceptsChildren ⇒ <code>boolean</code>
 Whether this kind of node can have children (text, comments and attributes cannot).
 
-**Kind**: instance property of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>acceptsChildren</code>](#NodeService+acceptsChildren)  
+<a name="PseudoHTMLDocument+cloneShallow"></a>
+
+### pseudoHTMLDocument.cloneShallow() ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+A copy of this document with none of its html/head/body (cloneNode, from the inherited cloneShallow hook, fills
+them back in, deep copies own document's, empty otherwise - see cloneNode).
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
+<a name="PseudoHTMLDocument+cloneNode"></a>
+
+### pseudoHTMLDocument.cloneNode([deep]) ⇒ [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)
+Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in
+the document (a shallow one is an empty document).
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>cloneNode</code>](#NodeService+cloneNode)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [deep] | <code>boolean</code> | <code>false</code> | Copy everything in the document as well |
+
+<a name="DocumentService+getElementById"></a>
+
+### pseudoHTMLDocument.getElementById(id) ⇒ <code>PseudoElement</code> \| <code>null</code>
+The first element, in tree order, whose id matches the given value, or null when there is none.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>getElementById</code>](#DocumentService+getElementById)  
+
+| Param | Type |
+| --- | --- |
+| id | <code>string</code> | 
+
+<a name="DocumentService+createElement"></a>
+
+### pseudoHTMLDocument.createElement([tagName]) ⇒ <code>PseudoElement</code>
+Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createElement</code>](#DocumentService+createElement)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [tagName] | <code>string</code> | <code>&quot;&#x27;div&#x27;&quot;</code> | The type of element to create |
+
+<a name="DocumentService+createTextNode"></a>
+
+### pseudoHTMLDocument.createTextNode([data]) ⇒ [<code>TextService</code>](#TextService)
+Make a text node which belongs to this document.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createTextNode</code>](#DocumentService+createTextNode)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
+
+<a name="DocumentService+createComment"></a>
+
+### pseudoHTMLDocument.createComment([data]) ⇒ [<code>CommentService</code>](#CommentService)
+Make a comment which belongs to this document.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createComment</code>](#DocumentService+createComment)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
+
+<a name="DocumentService+createDocumentFragment"></a>
+
+### pseudoHTMLDocument.createDocumentFragment() ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
+Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
+then inserted in one go.
+
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
+**Overrides**: [<code>createDocumentFragment</code>](#DocumentService+createDocumentFragment)  
 <a name="NodeService+appendChild"></a>
 
-### linkedNode.appendChild(childNode) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.appendChild(childNode) ⇒ <code>PseudoNode</code>
 Add a node as the last child of this node (a node which is already in a tree is moved).
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>appendChild</code>](#NodeService+appendChild)  
 **Returns**: <code>PseudoNode</code> - The added node  
 
@@ -3689,21 +4048,13 @@ Add a node as the last child of this node (a node which is already in a tree is
 | --- | --- | --- |
 | childNode | <code>PseudoNode</code> | The node to add |
 
-<a name="NodeService+cloneShallow"></a>
-
-### linkedNode.cloneShallow() ⇒ [<code>NodeService</code>](#NodeService)
-Make a copy of this node without its children, its parent or its listeners, which is what cloneNode starts from.
-Kinds of node which are made with arguments override this to give them.
-
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
-**Overrides**: [<code>cloneShallow</code>](#NodeService+cloneShallow)  
 <a name="NodeService+equalsShallow"></a>
 
-### linkedNode.equalsShallow(other) ⇒ <code>boolean</code>
+### pseudoHTMLDocument.equalsShallow(other) ⇒ <code>boolean</code>
 Whether another node of the same type is equal to this one apart from its children, which isEqualNode compares
 afterwards. Kinds of node with more to compare (an element has attributes) override this.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>equalsShallow</code>](#NodeService+equalsShallow)  
 
 | Param | Type | Description |
@@ -3712,10 +4063,10 @@ afterwards. Kinds of node with more to compare (an element has attributes) overr
 
 <a name="NodeService+append"></a>
 
-### linkedNode.append(...nodes)
+### pseudoHTMLDocument.append(...nodes)
 Add nodes (strings become text nodes) as the last children of this node, in the order given.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>append</code>](#NodeService+append)  
 **Throws**:
 
@@ -3728,10 +4079,10 @@ Add nodes (strings become text nodes) as the last children of this node, in the
 
 <a name="NodeService+prepend"></a>
 
-### linkedNode.prepend(...nodes)
+### pseudoHTMLDocument.prepend(...nodes)
 Add nodes (strings become text nodes) as the first children of this node, in the order given.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>prepend</code>](#NodeService+prepend)  
 **Throws**:
 
@@ -3744,10 +4095,10 @@ Add nodes (strings become text nodes) as the first children of this node, in the
 
 <a name="NodeService+replaceChildren"></a>
 
-### linkedNode.replaceChildren(...nodes)
+### pseudoHTMLDocument.replaceChildren(...nodes)
 Remove every child of this node and put the given nodes (strings become text nodes) in their place, in order.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>replaceChildren</code>](#NodeService+replaceChildren)  
 **Throws**:
 
@@ -3760,11 +4111,11 @@ Remove every child of this node and put the given nodes (strings become text nod
 
 <a name="NodeService+before"></a>
 
-### linkedNode.before(...nodes)
+### pseudoHTMLDocument.before(...nodes)
 Add nodes (strings become text nodes) as this node's previous siblings, in order. Does nothing when this node has
 no parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>before</code>](#NodeService+before)  
 
 | Param | Type | Description |
@@ -3773,11 +4124,11 @@ no parent.
 
 <a name="NodeService+after"></a>
 
-### linkedNode.after(...nodes)
+### pseudoHTMLDocument.after(...nodes)
 Add nodes (strings become text nodes) as this node's next siblings, in order. Does nothing when this node has no
 parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>after</code>](#NodeService+after)  
 
 | Param | Type | Description |
@@ -3786,11 +4137,11 @@ parent.
 
 <a name="NodeService+replaceWith"></a>
 
-### linkedNode.replaceWith(...nodes)
+### pseudoHTMLDocument.replaceWith(...nodes)
 Put the given nodes (strings become text nodes) where this node is, in order, then remove this node. Does nothing
 when this node has no parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>replaceWith</code>](#NodeService+replaceWith)  
 
 | Param | Type | Description |
@@ -3799,18 +4150,18 @@ when this node has no parent.
 
 <a name="NodeService+remove"></a>
 
-### linkedNode.remove()
+### pseudoHTMLDocument.remove()
 Remove this node from its parent. Does nothing when it has no parent.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>remove</code>](#NodeService+remove)  
 <a name="NodeService+toChildNode"></a>
 
-### linkedNode.toChildNode(value) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.toChildNode(value) ⇒ <code>PseudoNode</code>
 Turn a value given to append / prepend / before / after / replaceWith / replaceChildren into a node: a string
 becomes a text node belonging to this node's document, anything else is returned as it is.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>toChildNode</code>](#NodeService+toChildNode)  
 
 | Param | Type | Description |
@@ -3819,10 +4170,10 @@ becomes a text node belonging to this node's document, anything else is returned
 
 <a name="NodeService+getElementsByTagName"></a>
 
-### linkedNode.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
+### pseudoHTMLDocument.getElementsByTagName(tagName) ⇒ <code>PseudoHTMLCollection</code>
 Every element below this node with the given tag name (or every element when tagName is *), live.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>getElementsByTagName</code>](#NodeService+getElementsByTagName)  
 
 | Param | Type |
@@ -3831,10 +4182,10 @@ Every element below this node with the given tag name (or every element when tag
 
 <a name="NodeService+getElementsByClassName"></a>
 
-### linkedNode.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
+### pseudoHTMLDocument.getElementsByClassName(className) ⇒ <code>PseudoHTMLCollection</code>
 Every element below this node which has all of the given (space separated) classes, live.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>getElementsByClassName</code>](#NodeService+getElementsByClassName)  
 
 | Param | Type |
@@ -3843,10 +4194,10 @@ Every element below this node which has all of the given (space separated) class
 
 <a name="NodeService+querySelector"></a>
 
-### linkedNode.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
+### pseudoHTMLDocument.querySelector(selectors) ⇒ <code>PseudoElement</code> \| <code>null</code>
 The first element below this node which matches the CSS selector, in tree order, or null when there is none.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>querySelector</code>](#NodeService+querySelector)  
 
 | Param | Type | Description |
@@ -3855,11 +4206,11 @@ The first element below this node which matches the CSS selector, in tree order,
 
 <a name="NodeService+querySelectorAll"></a>
 
-### linkedNode.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
+### pseudoHTMLDocument.querySelectorAll(selectors) ⇒ <code>Array.&lt;PseudoElement&gt;</code>
 Every element below this node which matches the CSS selector, in tree order. A plain array (not a live
 collection): like the DOM's querySelectorAll, it is a snapshot taken when it is called.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>querySelectorAll</code>](#NodeService+querySelectorAll)  
 
 | Param | Type | Description |
@@ -3868,39 +4219,26 @@ collection): like the DOM's querySelectorAll, it is a snapshot taken when it is
 
 <a name="NodeService+childInserted"></a>
 
-### linkedNode.childInserted(child)
+### pseudoHTMLDocument.childInserted(child)
 Called each time a node has been inserted as a child of this node, so that nodes which need to react to children
 (for example elements applying default events) can do so.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>childInserted</code>](#NodeService+childInserted)  
 
 | Param | Type | Description |
 | --- | --- | --- |
 | child | [<code>NodeService</code>](#NodeService) | The node which was inserted |
 
-<a name="NodeService+cloneNode"></a>
-
-### linkedNode.cloneNode([deep]) ⇒ <code>PseudoNode</code>
-Make a copy of this node (without its parent, and without its event listeners). With deep the children are copied
-too, all the way down.
-
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
-**Overrides**: [<code>cloneNode</code>](#NodeService+cloneNode)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [deep] | <code>boolean</code> | <code>false</code> | Copy the children as well |
-
 <a name="NodeService+compareDocumentPosition"></a>
 
-### linkedNode.compareDocumentPosition(otherNode) ⇒ <code>number</code>
+### pseudoHTMLDocument.compareDocumentPosition(otherNode) ⇒ <code>number</code>
 Say where another node is in relation to this one, as the bits of NodeService.DOCUMENT_POSITION_*: 0 for this node
 itself, DISCONNECTED (with IMPLEMENTATION_SPECIFIC and a consistent PRECEDING or FOLLOWING) for a node in another tree,
 CONTAINS + PRECEDING when the other node is an ancestor, CONTAINED_BY + FOLLOWING when it is a descendant,
 otherwise PRECEDING or FOLLOWING by their order in the tree.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>compareDocumentPosition</code>](#NodeService+compareDocumentPosition)  
 
 | Param | Type | Description |
@@ -3909,10 +4247,10 @@ otherwise PRECEDING or FOLLOWING by their order in the tree.
 
 <a name="NodeService+contains"></a>
 
-### linkedNode.contains(otherNode) ⇒ <code>boolean</code>
+### pseudoHTMLDocument.contains(otherNode) ⇒ <code>boolean</code>
 Check whether a node is this node or one of its descendants.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>contains</code>](#NodeService+contains)  
 
 | Param | Type | Description |
@@ -3921,11 +4259,11 @@ Check whether a node is this node or one of its descendants.
 
 <a name="NodeService+insertBefore"></a>
 
-### linkedNode.insertBefore(newNode, [referenceNode]) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.insertBefore(newNode, [referenceNode]) ⇒ <code>PseudoNode</code>
 Insert a node as a child of this node, before the given child (or at the end when there is none). A node which is
 already in a tree is moved, and the children of a document fragment are moved in order.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>insertBefore</code>](#NodeService+insertBefore)  
 **Returns**: <code>PseudoNode</code> - The inserted node  
 **Throws**:
@@ -3940,11 +4278,11 @@ already in a tree is moved, and the children of a document fragment are moved in
 
 <a name="NodeService+isEqualNode"></a>
 
-### linkedNode.isEqualNode(otherNode) ⇒ <code>boolean</code>
+### pseudoHTMLDocument.isEqualNode(otherNode) ⇒ <code>boolean</code>
 Whether another node is the same as this one, by what they hold: the same type, name and value (an element also
 needs the same attributes), and children which are equal in the same order.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>isEqualNode</code>](#NodeService+isEqualNode)  
 
 | Param | Type | Description |
@@ -3953,17 +4291,17 @@ needs the same attributes), and children which are equal in the same order.
 
 <a name="NodeService+normalize"></a>
 
-### linkedNode.normalize()
+### pseudoHTMLDocument.normalize()
 Tidy the text below this node: neighbouring text nodes are joined into one and empty text nodes are removed.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>normalize</code>](#NodeService+normalize)  
 <a name="NodeService+removeChild"></a>
 
-### linkedNode.removeChild(childElement) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.removeChild(childElement) ⇒ <code>PseudoNode</code>
 Remove a child from this node, it no longer has a parent or siblings afterwards.
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>removeChild</code>](#NodeService+removeChild)  
 **Returns**: <code>PseudoNode</code> - The removed node  
 **Throws**:
@@ -3977,10 +4315,10 @@ Remove a child from this node, it no longer has a parent or siblings afterwards.
 
 <a name="NodeService+replaceChild"></a>
 
-### linkedNode.replaceChild(newChild, oldChild) ⇒ <code>PseudoNode</code>
+### pseudoHTMLDocument.replaceChild(newChild, oldChild) ⇒ <code>PseudoNode</code>
 Replace a child of this node with another node (which is moved if it is already in a tree).
 
-**Kind**: instance method of [<code>LinkedNode</code>](#LinkedNode)  
+**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
 **Overrides**: [<code>replaceChild</code>](#NodeService+replaceChild)  
 **Returns**: <code>PseudoNode</code> - The replaced node  
 **Throws**:
@@ -3993,134 +4331,6 @@ Replace a child of this node with another node (which is moved if it is already
 | newChild | <code>PseudoNode</code> | The node which takes the place |
 | oldChild | <code>PseudoNode</code> | The child of this node to replace |
 
-<a name="PseudoNodeList"></a>
-
-## PseudoNodeList ⇐ <code>LinkedTreeList</code>
-A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
-the linkers that hold them.
-
-**Kind**: global class  
-**Extends**: <code>LinkedTreeList</code>  
-
-* [PseudoNodeList](#PseudoNodeList) ⇐ <code>LinkedTreeList</code>
-    * [.entries()](#PseudoNodeList+entries) ⇒ <code>Iterator</code>
-    * [.keys()](#PseudoNodeList+keys) ⇒ <code>Iterator</code>
-    * [.values()](#PseudoNodeList+values) ⇒ <code>Iterator</code>
-
-<a name="PseudoNodeList+entries"></a>
-
-### pseudoNodeList.entries() ⇒ <code>Iterator</code>
-Iterate over [index, node] pairs.
-
-**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
-<a name="PseudoNodeList+keys"></a>
-
-### pseudoNodeList.keys() ⇒ <code>Iterator</code>
-Iterate over the indexes.
-
-**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
-<a name="PseudoNodeList+values"></a>
-
-### pseudoNodeList.values() ⇒ <code>Iterator</code>
-Iterate over the nodes.
-
-**Kind**: instance method of [<code>PseudoNodeList</code>](#PseudoNodeList)  
-<a name="PseudoHTMLDocument"></a>
-
-## PseudoHTMLDocument ⇐ <code>PseudoHTMLElement</code>
-Simulate the behaviour of the HTMLDocument Class when there is no DOM available.
-
-**Kind**: global class  
-**Extends**: <code>PseudoHTMLElement</code>  
-**Author**: Joshua Heagle <joshuaheagle@gmail.com>  
-**Properties**
-
-| Name | Type | Description |
-| --- | --- | --- |
-| head | <code>PseudoHTMLElement</code> | A reference to the Head child element |
-| body | <code>PseudoHTMLElement</code> | A reference to the Body child element |
-| createElement | <code>function</code> | Generate a new PseudoHTMLElement (which is not in the document until it is appended) |
-
-
-* [PseudoHTMLDocument](#PseudoHTMLDocument) ⇐ <code>PseudoHTMLElement</code>
-    * [new PseudoHTMLDocument()](#new_PseudoHTMLDocument_new)
-    * [.head](#PseudoHTMLDocument+head) : <code>PseudoHTMLElement</code>
-    * [.body](#PseudoHTMLDocument+body) : <code>PseudoHTMLElement</code>
-    * [.createElement(tagName)](#PseudoHTMLDocument+createElement) ⇒ <code>PseudoHTMLElement</code>
-    * [.createTextNode([data])](#PseudoHTMLDocument+createTextNode) ⇒ [<code>TextService</code>](#TextService)
-    * [.createComment([data])](#PseudoHTMLDocument+createComment) ⇒ [<code>CommentService</code>](#CommentService)
-    * [.createDocumentFragment()](#PseudoHTMLDocument+createDocumentFragment) ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
-    * [.cloneNode([deep])](#PseudoHTMLDocument+cloneNode) ⇒ <code>PseudoNode</code>
-
-<a name="new_PseudoHTMLDocument_new"></a>
-
-### new PseudoHTMLDocument()
-The root HTML element is acts as the parent to all HTML elements in the document.
-
-<a name="PseudoHTMLDocument+head"></a>
-
-### pseudoHTMLDocument.head : <code>PseudoHTMLElement</code>
-Create document head element
-
-**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-<a name="PseudoHTMLDocument+body"></a>
-
-### pseudoHTMLDocument.body : <code>PseudoHTMLElement</code>
-Create document body element
-
-**Kind**: instance property of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-<a name="PseudoHTMLDocument+createElement"></a>
-
-### pseudoHTMLDocument.createElement(tagName) ⇒ <code>PseudoHTMLElement</code>
-Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| tagName | <code>string</code> | <code>&quot;div&quot;</code> | Tag Name is a string representing the type of Dom element this represents |
-
-<a name="PseudoHTMLDocument+createTextNode"></a>
-
-### pseudoHTMLDocument.createTextNode([data]) ⇒ [<code>TextService</code>](#TextService)
-Make a text node which belongs to this document.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The text |
-
-<a name="PseudoHTMLDocument+createComment"></a>
-
-### pseudoHTMLDocument.createComment([data]) ⇒ [<code>CommentService</code>](#CommentService)
-Make a comment which belongs to this document.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [data] | <code>string</code> | <code>&quot;&#x27;&#x27;&quot;</code> | The comment |
-
-<a name="PseudoHTMLDocument+createDocumentFragment"></a>
-
-### pseudoHTMLDocument.createDocumentFragment() ⇒ [<code>DocumentFragmentService</code>](#DocumentFragmentService)
-Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
-then inserted in one go.
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-<a name="PseudoHTMLDocument+cloneNode"></a>
-
-### pseudoHTMLDocument.cloneNode([deep]) ⇒ <code>PseudoNode</code>
-Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in the
-document (a shallow one is an empty document).
-
-**Kind**: instance method of [<code>PseudoHTMLDocument</code>](#PseudoHTMLDocument)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [deep] | <code>boolean</code> | <code>false</code> | Copy everything in the document as well |
-
 <a name="PseudoEventListener"></a>
 
 ## PseudoEventListener
@@ -4263,10 +4473,6 @@ The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop,
 ## focused
 The element which has the focus, kept for each tree (the root node of the tree it is in), like document.activeElement.
 
-**Kind**: global constant  
-<a name="HTMLElementService_1"></a>
-
-## HTMLElementService\_1 : <code>PseudoHTMLElement</code>
 **Kind**: global constant  
 <a name="modifierKeys"></a>
 
@@ -4352,14 +4558,6 @@ Create a PseudoNodeList, optionally starting from an existing chain of linkers.
 | --- | --- | --- |
 | [innerList] | <code>TreeLinker</code> \| <code>null</code> | <code></code> | 
 
-<a name="generateNode"></a>
-
-## generateNode() ⇒ <code>function</code>
-Create a TreeLinker class whose linkers each store a node (a LinkedNode) as their data, this can be used to build a
-tree (or list) of nodes from plain values.
-
-**Kind**: global function  
-**Returns**: <code>function</code> - The NodeFactory class (a TreeLinker) to use as the linker class  
 <a name="generateDocument"></a>
 
 ## generateDocument(root, context) ⇒ <code>Window</code> \| <code>PseudoEventTarget</code>
@@ -4417,6 +4615,28 @@ Walk up from a node (not including it) to find the nearest element, in the given
 | node | <code>\*</code> | The node to start from |
 | direction | <code>&#x27;nextSibling&#x27;</code> \| <code>&#x27;previousSibling&#x27;</code> | Which sibling reference to follow |
 
+<a name="kebabToCamel"></a>
+
+## kebabToCamel(name) ⇒ <code>string</code>
+kebab-case -> camelCase ("background-color" -> "backgroundColor").
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| name | <code>string</code> | 
+
+<a name="camelToKebab"></a>
+
+## camelToKebab(name) ⇒ <code>string</code>
+camelCase -> kebab-case ("backgroundColor" -> "background-color").
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| name | <code>string</code> | 
+
 <a name="createEvent"></a>
 
 ## createEvent(type, [init], [options]) ⇒ [<code>EventService</code>](#EventService)
@@ -4434,3 +4654,14 @@ real user action (isTrusted).
 | [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 |
 
+<a name="dataAttributes"></a>
+
+## dataAttributes(element) ⇒ <code>Array.&lt;Array.&lt;string&gt;&gt;</code>
+Every data-* attribute name currently on the element, as [attributeName, camelCaseName] pairs.
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| element | <code>\*</code> | 
+