pseudo-dom 0.10.0 → 0.12.0

package/README.md

@@ -1,92 +1,173 @@
 # Pseudo DOM
 
-Mock the DOM for server side-side DOM state and in tests.
+Mock the DOM for server-side DOM state and in tests.
 
 ## Status: early development (0.x)
 
-Pseudo DOM recreates the browser DOM API (following the MDN documentation) so DOM-dependent code can run in Node, for
-example in tests, without a real or headless browser. It is written in TypeScript and ships type definitions.
-
-Working today: `EventService` (Event) and `EventTargetService` (EventTarget), which dispatch an event through the tree the
-way the DOM does (capture down from the root, the target, then bubbling back up, with `stopPropagation`,
-`stopImmediatePropagation`, `once`, `passive`, `preventDefault` and the default action of the target; clicking a submit
-button sends a `submit` event to its form), `NodeService`
-(Node: a real tree with `parentNode`, `previousSibling` / `nextSibling`, `firstChild` / `lastChild`, `appendChild`,
-`insertBefore`, `removeChild`, `replaceChild`, `contains` and `getRootNode`; nodes move when they are added somewhere
-else, document fragments insert their children, and a node cannot be put inside itself), `ElementService` /
-`HTMLElementService` (Element and HTMLElement, including attributes, `NamedNodeMap`, `classList`), `AttrService`,
-`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
-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`.
-
-Elements can be walked and changed like the DOM: \`children\` is a live \`HTMLCollection\` of just the element
-children, \`childElementCount\`, \`firstElementChild\` / \`lastElementChild\` and \`nextElementSibling\` /
-\`previousElementSibling\` skip text and comment nodes. \`append\` / \`prepend\` / \`before\` / \`after\` / \`remove\` /
-\`replaceWith\` / \`replaceChildren\` accept nodes or strings (a string becomes a text node) and move a node already in
-a tree rather than duplicating it; \`insertAdjacentElement\` / \`insertAdjacentText\` insert at beforebegin / afterbegin
-/ beforeend / afterend (\`insertAdjacentHTML\` is not implemented, no HTML parsing yet).
-
-Selector queries work like the DOM's: \`getElementsByTagName\` / \`getElementsByClassName\` (live, on any node) and
-\`querySelector\` / \`querySelectorAll\` (real CSS selectors, via [css-select](https://www.npmjs.com/package/css-select)
-matched against pseudo-dom's own tree through a custom adapter - \`querySelectorAll\` is a plain array, a snapshot
-taken when it is called, like the DOM's) are on \`NodeService\` so \`Document\`, \`DocumentFragment\` and \`Element\`
-all have them; \`matches\` / \`closest\` are on \`ElementService\`; \`getElementById\` is on 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.
-
-Attribute helpers work like the DOM's: \`getAttributeNames\`, \`hasAttributes\`, \`toggleAttribute(name, [force])\`;
-\`localName\` matches \`tagName\` and \`prefix\` is always null (there is no real namespace parsing);
-\`getElementsByTagNameNS\` behaves exactly like \`getElementsByTagName\`, ignoring the namespace.
-
-\`attachShadow({mode})\` attaches a real (\`DocumentFragmentService\`-based) \`ShadowRoot\`, with \`host\` and \`mode\`
-set; \`element.shadowRoot\` reaches it when the mode is 'open', like the DOM's (a 'closed' one still exists, just not
-this way); attaching a second one throws.
-
-There is no layout engine, so anything that would need one is settable directly rather than really computed - set the
-value a test needs and the getter/method returns it: \`clientWidth\` / \`clientHeight\` / \`clientTop\` /
-\`clientLeft\` / \`scrollWidth\` / \`scrollHeight\` (numbers, alongside the existing \`offsetWidth\` etc.),
-\`boundingClientRect\` (what \`getBoundingClientRect()\` returns), \`clientRects\` (\`getClientRects()\`),
-\`animations\` (\`getAnimations()\`) and \`isVisible\` (\`checkVisibility()\`). \`scrollLeft\` / \`scrollTop\` are real,
-plain settable numbers, and \`scroll\` / \`scrollTo\` / \`scrollBy\` (a number pair or an options object) update them
-for real; \`scrollIntoView\` is a real callable no-op (there is no viewport to scroll within).
-\`hasPointerCapture\` / \`setPointerCapture\` / \`releasePointerCapture\` genuinely track capture per pointer id.
-\`requestFullscreen\` / \`requestPointerLock\` resolve, like a browser granting the request would.
-\`computedStyleMap()\` is a thin read-only view of the element's own inline style (there is no CSS cascade).
-
-Not implemented yet (these throw a "not implemented" error or are missing): \`innerHTML\` / \`outerHTML\` parsing, the
-\`aria*\` reflected properties, and the \`Attr\`-node / namespaced attribute methods (\`getAttributeNode\`,
-\`getAttributeNS\`, ...). The API will change before 1.0.
+Pseudo DOM recreates the browser DOM API (following the MDN documentation) so DOM-dependent code can run in Node -
+in tests, without a real or headless browser. It's written in TypeScript and ships type definitions. The API will
+change before 1.0.
+
+## At a glance
+
+- **Tree & events** - a real node tree with full event dispatch (capture → target → bubble) and standard event
+  defaults for clicks, focus and more
+- **Elements** - attributes, `classList`, a real live `style` and `dataset`, `children`, and DOM-style mutation
+  (`append`, `before`, `remove`, `replaceWith`, ...)
+- **HTML parsing** - `innerHTML` / `outerHTML` / `insertAdjacentHTML` parse and serialize real HTML
+- **Queries** - `querySelector` / `querySelectorAll` with real CSS selectors, `getElementById`, `matches`, `closest`
+- **Document** - `createElement`, `createTextNode`, and `generateDocument()` to get a `window`-like object with
+  `document` already on it
+- **Cloning & comparison** - `cloneNode`, `isEqualNode`, `compareDocumentPosition`, `contains`
+- **Running headlessly** - `installGlobal()` makes code written against real DOM globals (`document.createElement`,
+  ...) run unmodified in Node; `logElement()` prints a readable, indented view of an element to the console
+
+Everything below goes into more detail, section by section.
+
+## Tree, nodes & events
+
+A real tree: `parentNode`, `previousSibling` / `nextSibling`, `firstChild` / `lastChild`, `appendChild`,
+`insertBefore`, `removeChild`, `replaceChild`, `contains`, `getRootNode`. Nodes move when they're added somewhere
+else, document fragments insert their children instead of themselves, and a node can't be put inside itself.
+
+`EventService` / `EventTargetService` dispatch an event through the tree the way the DOM does:
+
+- Capture down from the root, hit the target, then bubble back up
+- `stopPropagation`, `stopImmediatePropagation`, `once`, `passive`, `preventDefault`, and the target's default action
+  (clicking a submit button sends a `submit` event to its form)
+- `createEvent(type, init, { browser, trusted })` makes the kind of event that suits the type (a click is a
+  `MouseEvent`, a keydown a `KeyboardEvent`, ...). Like a real constructor, it gives nothing (no bubbling, no
+  cancelling, not trusted) unless asked - but `browser: true` applies `eventDefaults`, the table of how a browser
+  creates each standard type (click bubbles and can be cancelled; focus doesn't bubble but focusin does; input
+  bubbles but can't be cancelled; ...), and `trusted: true` makes `isTrusted` true, as for a real user action
+- The event kinds: `PseudoUIEvent`, `PseudoMouseEvent`, `PseudoPointerEvent`, `PseudoKeyboardEvent`,
+  `PseudoFocusEvent`, `PseudoInputEvent`, `PseudoCustomEvent`
+- Elements have `click()` (an untrusted click, like a script's) and `focus()` / `blur()` (blur/focusout/focus/focusin
+  and the related targets, with a focused element tracked per tree)
+- `simulate.click(element)` / `simulate.keyPress(element, key)` send what a real user action sends - pointerdown,
+  mousedown, the focus moving, pointerup, mouseup, click; keydown, keyup - all trusted
+
+## Elements
+
+`ElementService` / `HTMLElementService` cover `Element` and `HTMLElement`: attributes, `NamedNodeMap`, `classList`.
+`AttrService`, `DOMTokenListService` and `NamedNodeMapService` back them.
+
+**Attribute helpers** work like the DOM's: `getAttributeNames`, `hasAttributes`, `toggleAttribute(name, [force])`.
+`localName` matches `tagName` and `prefix` is always `null` (there's no real namespace parsing);
+`getElementsByTagNameNS` behaves exactly like `getElementsByTagName`, ignoring the namespace.
+
+**`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.
+
+*(`style` and `dataset` are both on `HTMLElementService`, matching the DOM - they're not on the base `Element`.)*
+
+**Traversal & mutation** work like the DOM's:
+
+- `children` is a live `HTMLCollection` of just the element children; `childElementCount`, `firstElementChild` /
+  `lastElementChild` and `nextElementSibling` / `previousElementSibling` skip text and comment nodes
+- `append` / `prepend` / `before` / `after` / `remove` / `replaceWith` / `replaceChildren` accept nodes or strings (a
+  string becomes a text node), and move a node already in a tree rather than duplicating it
+- `insertAdjacentElement` / `insertAdjacentText` / `insertAdjacentHTML` insert at beforebegin / afterbegin /
+  beforeend / afterend
+
+**`attachShadow({mode})`** attaches a real (`DocumentFragmentService`-based) `ShadowRoot`, with `host` and `mode`
+set. `element.shadowRoot` reaches it when the mode is `'open'`, like the DOM's (a `'closed'` one still exists, just
+not reachable this way); attaching a second one throws.
+
+### HTML parsing
+
+`innerHTML` / `outerHTML` / `insertAdjacentHTML` parse and serialize real HTML, via
+[htmlparser2](https://www.npmjs.com/package/htmlparser2) (a SAX-style tokenizer - pseudo-dom builds its own nodes
+from its events, the same way it builds matches from `css-select`).
+
+- Entities decode, and void elements (`br`, `img`, ...) auto-close
+- `class` / `style` attributes populate `className` / `classList` and `style` for real, not just a generic attribute
+- The setters (`innerHTML =`, `outerHTML =`) and `insertAdjacentHTML` are on `HTMLElementService` (building new
+  elements needs a concrete element class); `ElementService` only has the getters, since serializing doesn't
+
+### Layout (mocked, not computed)
+
+There's no layout engine, so anything that would need one is **settable directly** rather than really computed - set
+the value a test needs, and the getter/method returns it:
+
+- `clientWidth` / `clientHeight` / `clientTop` / `clientLeft` / `scrollWidth` / `scrollHeight` (plain numbers,
+  alongside the existing `offsetWidth` etc.)
+- `boundingClientRect` backs `getBoundingClientRect()`, `clientRects` backs `getClientRects()`, `animations` backs
+  `getAnimations()`, `isVisible` backs `checkVisibility()`
+
+A few things in this group are genuinely real, not mocked:
+
+- `scrollLeft` / `scrollTop` are plain settable numbers, and `scroll` / `scrollTo` / `scrollBy` (a number pair or an
+  options object) update them for real; `scrollIntoView` is a callable no-op (there's no viewport to scroll within)
+- `hasPointerCapture` / `setPointerCapture` / `releasePointerCapture` genuinely track capture per pointer id
+- `requestFullscreen` / `requestPointerLock` resolve, like a browser granting the request would
+- `computedStyleMap()` is a thin read-only view of the element's own inline style (there's no CSS cascade)
+
+## Queries
+
+`getElementsByTagName` / `getElementsByClassName` (live, on any node) and `querySelector` / `querySelectorAll` (real
+CSS selectors, via [css-select](https://www.npmjs.com/package/css-select) matched against pseudo-dom's own tree
+through a custom adapter) are on `NodeService`, so `Document`, `DocumentFragment` and `Element` all have them.
+`querySelectorAll` returns a plain array - a snapshot taken when it's called, like the DOM's.
+
+`matches` / `closest` are on `ElementService`. `getElementById` is on both `DocumentService` and
+`DocumentFragmentService` (the DOM's `NonElementParentNode` mixin, so a `ShadowRoot` gets it too).
+
+## Document
+
+`DocumentService` matches the real `Document` - it's not an `Element`, so it has no `tagName` / `classList` /
+`matches` / etc:
+
+- `createElement`, `createTextNode`, `createComment`, `createDocumentFragment`
+- `getElementById`
+- `textContent` is always `null`
+
+`DocumentFragmentService` is the plain `DocumentFragment`. `PseudoHTMLDocument` - what `generateDocument()` actually
+creates - only adds the `html` / `head` / `body` structure on top of `DocumentService`. `PseudoNodeList` backs
+`childNodes`.
+
+## Running headlessly
+
+Code written against a real DOM's globals (`document.createElement`, `new Node()`, ...) can run unmodified in Node,
+without an `if (typeof document === 'undefined')` check at every call site:
+
+```js
+if (typeof document === 'undefined') {
+  require('pseudo-dom').installGlobal(globalThis)
+}
+```
+
+`installGlobal(target = globalThis)` fills in `document` / `Node` / `Element` / `HTMLElement` on `target`, using
+[browser-or-node](https://www.npmjs.com/package/browser-or-node) to check whether a real DOM (a real browser, or a
+jsdom-based test environment) is already there first - it's always safe to call, everywhere: it does nothing when
+one is.
+
+There's no real rendering to look at, so `logElement(node, [label])` prints a readable, indented view of a node's
+markup to the console (`prettyPrint(node, [indent])`, from the same module, returns the string instead of printing
+it) - useful for watching pseudo-dom-driven code run, or checking a final result, from a terminal.
+
+## Cloning, comparison & connection
+
+- `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; `ownerDocument` says which one made the node
+- `normalize` joins neighbouring text nodes
+- There are text and comment nodes (`PseudoText`, `PseudoComment`); `textContent` works like the DOM's (the text of
+  everything below, and setting it replaces the children with a text node)
+
+## Not implemented yet
+
+- The `aria*` reflected properties
+- The `Attr`-node / namespaced attribute methods (`getAttributeNode`, `getAttributeNS`, ...)
 ## Modules
 
 <dl>
@@ -235,6 +316,23 @@ order in which an event travels down through them). A node which has no parent h
 <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="#escapeText">escapeText(text)</a> ⇒ <code>string</code></dt>
+<dd><p>Escape text so it is safe inside HTML text content.</p>
+</dd>
+<dt><a href="#escapeAttributeValue">escapeAttributeValue(value)</a> ⇒ <code>string</code></dt>
+<dd><p>Escape a value so it is safe inside a double-quoted HTML attribute.</p>
+</dd>
+<dt><a href="#serializeAttributes">serializeAttributes(element)</a> ⇒ <code>string</code></dt>
+<dd><p>Every attribute of the element, serialized (class instead of className, boolean attributes bare, the never-real
+mock properties left out, style added from the live CSSStyleDeclaration when it is not empty).</p>
+</dd>
+<dt><a href="#serializeNode">serializeNode(node)</a> ⇒ <code>string</code></dt>
+<dd><p>One node, serialized (its own markup only - see serializeChildren for its descendants too).</p>
+</dd>
+<dt><a href="#prettyPrintNode">prettyPrintNode(node, depth, indent)</a> ⇒ <code>string</code></dt>
+<dd><p>One node, indented for readability (see prettyPrint) - unlike serializeNode, every non-empty node is its own
+line, so the structure of a whole tree is easy to read at a glance.</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>
@@ -2327,9 +2425,13 @@ Simulate the behaviour of the HTMLElement Class when there is no DOM available.
     * [new HTMLElementService([elementOptions])](#new_HTMLElementService_new)
     * [.style](#HTMLElementService+style) ⇒ [<code>CSSStyleDeclarationService</code>](#CSSStyleDeclarationService)
     * [.dataset](#HTMLElementService+dataset) ⇒ <code>Object.&lt;string, string&gt;</code>
+    * [.innerHTML](#HTMLElementService+innerHTML) ⇒ <code>undefined</code>
+    * [.outerHTML](#HTMLElementService+outerHTML) ⇒ <code>undefined</code>
     * [.canFocus](#HTMLElementService+canFocus) ⇒ <code>boolean</code>
     * [.cloneShallow()](#HTMLElementService+cloneShallow) ⇒ [<code>NodeService</code>](#NodeService)
     * [.equalsShallow(other)](#HTMLElementService+equalsShallow) ⇒ <code>boolean</code>
+    * [.parse(html)](#HTMLElementService+parse) ⇒ <code>Array.&lt;\*&gt;</code>
+    * [.insertAdjacentHTML(position, html)](#HTMLElementService+insertAdjacentHTML) ⇒ <code>undefined</code>
     * [.click()](#HTMLElementService+click)
     * [.focus()](#HTMLElementService+focus)
     * [.blur()](#HTMLElementService+blur)
@@ -2361,6 +2463,30 @@ The element's data-* attributes, live, under their camelCase names (data-foo-bar
 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+innerHTML"></a>
+
+### htmlElementService.innerHTML ⇒ <code>undefined</code>
+Replace this element's children by parsing html. innerHTML's setter is here rather than on ElementService (which
+only has the getter) because building the new elements needs a concrete element class - see parse().
+
+**Kind**: instance property of [<code>HTMLElementService</code>](#HTMLElementService)  
+
+| Param | Type |
+| --- | --- |
+| html | <code>string</code> | 
+
+<a name="HTMLElementService+outerHTML"></a>
+
+### htmlElementService.outerHTML ⇒ <code>undefined</code>
+Replace this element itself, in its parent, by parsing html. Does nothing when it has no parent, like
+replaceWith. outerHTML's setter is here rather than on ElementService for the same reason as innerHTML's.
+
+**Kind**: instance property of [<code>HTMLElementService</code>](#HTMLElementService)  
+
+| Param | Type |
+| --- | --- |
+| html | <code>string</code> | 
+
 <a name="HTMLElementService+canFocus"></a>
 
 ### htmlElementService.canFocus ⇒ <code>boolean</code>
@@ -2384,6 +2510,35 @@ Style is not attribute-backed like most properties, so isEqualNode needs to comp
 | --- | --- | --- |
 | other | [<code>NodeService</code>](#NodeService) | The node to compare with |
 
+<a name="HTMLElementService+parse"></a>
+
+### htmlElementService.parse(html) ⇒ <code>Array.&lt;\*&gt;</code>
+Parses html with this class building each new element (matches HTML: parsed elements behave like plain
+HTMLElements, not whatever specialized class happens to be setting innerHTML / outerHTML).
+
+**Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+
+| Param | Type |
+| --- | --- |
+| html | <code>string</code> | 
+
+<a name="HTMLElementService+insertAdjacentHTML"></a>
+
+### htmlElementService.insertAdjacentHTML(position, html) ⇒ <code>undefined</code>
+Parse html and insert the resulting nodes at the given position, like insertAdjacentElement /
+insertAdjacentText.
+
+**Kind**: instance method of [<code>HTMLElementService</code>](#HTMLElementService)  
+**Throws**:
+
+- <code>Error</code> When the position is not one of the four above
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| position | <code>string</code> | beforebegin, afterbegin, beforeend or afterend |
+| html | <code>string</code> | The markup to parse |
+
 <a name="HTMLElementService+click"></a>
 
 ### htmlElementService.click()
@@ -2773,6 +2928,8 @@ Simulate the behaviour of the Element Class when there is no DOM available.
     * [.isVisible](#ElementService+isVisible)
     * [.localName](#ElementService+localName) ⇒ <code>string</code>
     * [.prefix](#ElementService+prefix) ⇒ <code>string</code> \| <code>null</code>
+    * [.innerHTML](#ElementService+innerHTML) ⇒ <code>string</code>
+    * [.outerHTML](#ElementService+outerHTML) ⇒ <code>string</code>
     * [.children](#ElementService+children) ⇒ <code>PseudoHTMLCollection</code>
     * [.childElementCount](#ElementService+childElementCount) ⇒ <code>number</code>
     * [.firstElementChild](#ElementService+firstElementChild) ⇒ <code>PseudoElement</code> \| <code>null</code>
@@ -2862,6 +3019,19 @@ same as tagName.
 The element's namespace prefix, or null when it has none. There is no real namespace parsing here, so this is
 always null.
 
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+innerHTML"></a>
+
+### elementService.innerHTML ⇒ <code>string</code>
+The HTML markup of this element's children. Only the getter is here (the setter, which needs to build new
+elements from parsed HTML, is on HTMLElementService - see its class comment).
+
+**Kind**: instance property of [<code>ElementService</code>](#ElementService)  
+<a name="ElementService+outerHTML"></a>
+
+### elementService.outerHTML ⇒ <code>string</code>
+The HTML markup of this element itself, including its children. Only the getter is here (see innerHTML).
+
 **Kind**: instance property of [<code>ElementService</code>](#ElementService)  
 <a name="ElementService+children"></a>
 
@@ -5310,6 +5480,65 @@ Remember the element which has the focus in a tree.
 | 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="escapeText"></a>
+
+## escapeText(text) ⇒ <code>string</code>
+Escape text so it is safe inside HTML text content.
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| text | <code>string</code> | 
+
+<a name="escapeAttributeValue"></a>
+
+## escapeAttributeValue(value) ⇒ <code>string</code>
+Escape a value so it is safe inside a double-quoted HTML attribute.
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| value | <code>string</code> | 
+
+<a name="serializeAttributes"></a>
+
+## serializeAttributes(element) ⇒ <code>string</code>
+Every attribute of the element, serialized (class instead of className, boolean attributes bare, the never-real
+mock properties left out, style added from the live CSSStyleDeclaration when it is not empty).
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| element | <code>\*</code> | 
+
+<a name="serializeNode"></a>
+
+## serializeNode(node) ⇒ <code>string</code>
+One node, serialized (its own markup only - see serializeChildren for its descendants too).
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| node | <code>\*</code> | 
+
+<a name="prettyPrintNode"></a>
+
+## prettyPrintNode(node, depth, indent) ⇒ <code>string</code>
+One node, indented for readability (see prettyPrint) - unlike serializeNode, every non-empty node is its own
+line, so the structure of a whole tree is easy to read at a glance.
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| node | <code>\*</code> | 
+| depth | <code>number</code> | 
+| indent | <code>string</code> | 
+
 <a name="generateNodeList"></a>
 
 ## generateNodeList([innerList]) ⇒ [<code>PseudoNodeList</code>](#PseudoNodeList)