pseudo-dom 0.17.0 → 1.0.1

package/dist/factories/generateDocument.js

@@ -1,82 +1,86 @@
-'use strict'
-
-const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-  return mod && mod.__esModule
-    ? mod
-    : {
-        default: mod
-      }
-}
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-const EventTargetService_1 = __importDefault(require('../services/EventTargetService'))
-const NodeService_1 = require('../services/NodeService')
-const ElementService_1 = require('../services/ElementService')
-const HTMLElementService_1 = require('../services/HTMLElementService')
-const PseudoHTMLDocument_1 = __importDefault(require('../classes/PseudoHTMLDocument'))
-/**
- * Construct the Pseudo Dom to provide access to Dom objects which are otherwise not available outside the browser
- * context.
- * @function generateDocument
- * @param {Object} root
- * @param {Object} context
- * @returns {Window|PseudoEventTarget}
- */
-const generateDocument = (root, context = {}) => {
-  /**
-   *
-   * @type {Window|PseudoEventTarget}
-   */
-  const newWindow = typeof root.document === 'undefined' ? root : new EventTargetService_1.default()
-  /**
-   * The Node class itself (matching the DOM's window.Node), not an instance - the right-hand side of `instanceof`
-   * must be a constructor, so `x instanceof Node` needs this, not `new PseudoNode()`.
-   * @type {Function}
-   */
-  const Node = root.Node || NodeService_1.NodeService
-  if (typeof newWindow.Node === 'undefined') {
-    newWindow.Node = Node
-  }
-  /**
-   * The Element class itself, for the same reason as Node.
-   * @type {Function}
-   */
-  const Element = root.Element || ElementService_1.ElementService
-  if (typeof newWindow.Element === 'undefined') {
-    newWindow.Element = Element
-  }
-  /**
-   * The HTMLElement class itself, for the same reason as Node.
-   * @type {Function}
-   */
-  const HTMLElement = root.HTMLElement || HTMLElementService_1.HTMLElementService
-  if (typeof newWindow.HTMLElement === 'undefined') {
-    newWindow.HTMLElement = HTMLElement
-  }
-  /**
-   * The HTMLDocument class itself, for the same reason as Node (so `document instanceof HTMLDocument`, a common
-   * real-DOM-detection check, works).
-   * @type {Function}
-   */
-  const HTMLDocument = root.HTMLDocument || PseudoHTMLDocument_1.default
-  if (typeof newWindow.HTMLDocument === 'undefined') {
-    newWindow.HTMLDocument = HTMLDocument
-  }
-  /**
-   * Define document when not available - a real instance, unlike the classes above (window.document IS an object,
-   * not a constructor).
-   * @type {Document|PseudoHTMLDocument}
-   */
-  const document = root.document || new PseudoHTMLDocument_1.default()
-  if (typeof newWindow.document === 'undefined') {
-    newWindow.document = document
-  }
-  // When there was no real document, newWindow is root itself (see above), so every assignment above already
-  // mutated it directly. If context is also that same object (root and context given as one and the same, as
-  // installGlobal does) merging is already done - doing it again would be Object.assign(target, target), which
-  // throws on any getter-only own property target already has (globalThis.crypto, in Node).
-  const mergeInto = context || root
-  return newWindow === mergeInto ? newWindow : Object.assign(mergeInto, newWindow)
-}
-exports.default = generateDocument
+'use strict'
+
+const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule
+    ? mod
+    : {
+        default: mod
+      }
+}
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+const EventTargetService_1 = __importDefault(require('../services/EventTargetService'))
+const NodeService_1 = require('../services/NodeService')
+const ElementService_1 = require('../services/ElementService')
+const HTMLElementService_1 = require('../services/HTMLElementService')
+const EventService_1 = require('../services/EventService')
+const PseudoHTMLDocument_1 = __importDefault(require('../classes/PseudoHTMLDocument'))
+/**
+ * Construct the Pseudo Dom to provide access to Dom objects which are otherwise not available outside the browser
+ * context.
+ * @param root
+ * @param context
+ */
+const generateDocument = (root, context = {}) => {
+  const newWindow = typeof root.document === 'undefined' ? root : new EventTargetService_1.default()
+  /**
+   * The Node class itself (matching the DOM's window.Node), not an instance - the right-hand side of `instanceof`
+   * must be a constructor, so `x instanceof Node` needs this, not `new PseudoNode()`.
+   */
+  const Node = root.Node || NodeService_1.NodeService
+  if (typeof newWindow.Node === 'undefined') {
+    newWindow.Node = Node
+  }
+  /**
+   * The Element class itself, for the same reason as Node.
+   */
+  const Element = root.Element || ElementService_1.ElementService
+  if (typeof newWindow.Element === 'undefined') {
+    newWindow.Element = Element
+  }
+  /**
+   * The HTMLElement class itself, for the same reason as Node.
+   */
+  const HTMLElement = root.HTMLElement || HTMLElementService_1.HTMLElementService
+  if (typeof newWindow.HTMLElement === 'undefined') {
+    newWindow.HTMLElement = HTMLElement
+  }
+  /**
+   * The HTMLDocument class itself, for the same reason as Node (so `document instanceof HTMLDocument`, a common
+   * real-DOM-detection check, works).
+   */
+  const HTMLDocument = root.HTMLDocument || PseudoHTMLDocument_1.default
+  if (typeof newWindow.HTMLDocument === 'undefined') {
+    newWindow.HTMLDocument = HTMLDocument
+  }
+  /**
+   * The Event class itself, so code which does `new Event(type)` then `target.dispatchEvent(...)` - the standard,
+   * environment-agnostic way to synthesize and dispatch an event - works the same as it would against a real DOM.
+   * Unlike Node/Element/HTMLElement/HTMLDocument above, this is NOT `root.Event || PseudoEvent`: Node.js itself has
+   * had a global Event/EventTarget since v15, unrelated to this module and incompatible with it (dispatchEvent
+   * below expects the inner/dispatching bookkeeping only this module's own instances carry) - so by the time this
+   * function is reached (no real document, meaning no real browser or jsdom either), any Event already on root can
+   * only be that unrelated native one, or this module's own from an earlier install (functionally identical to
+   * reinstalling it) - never a real browser's. Preferring root.Event the way the others do would keep Node's
+   * incompatible one every time, since it is never actually undefined.
+   */
+  if (newWindow.Event !== EventService_1.EventService) {
+    newWindow.Event = EventService_1.EventService
+  }
+  /**
+   * Define document when not available - a real instance, unlike the classes above (window.document IS an object,
+   * not a constructor).
+   */
+  const document = root.document || new PseudoHTMLDocument_1.default()
+  if (typeof newWindow.document === 'undefined') {
+    newWindow.document = document
+  }
+  // When there was no real document, newWindow is root itself (see above), so every assignment above already
+  // mutated it directly. If context is also that same object (root and context given as one and the same, as
+  // installGlobal does) merging is already done - doing it again would be Object.assign(target, target), which
+  // throws on any getter-only own property target already has (globalThis.crypto, in Node).
+  const mergeInto = context || root
+  return newWindow === mergeInto ? newWindow : Object.assign(mergeInto, newWindow)
+}
+exports.default = generateDocument

package/dist/factories/generateDocument.min.js

@@ -1 +1 @@
-"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const EventTargetService_1=__importDefault(require("../services/EventTargetService")),NodeService_1=require("../services/NodeService"),ElementService_1=require("../services/ElementService"),HTMLElementService_1=require("../services/HTMLElementService"),PseudoHTMLDocument_1=__importDefault(require("../classes/PseudoHTMLDocument")),generateDocument=(e,t={})=>{const n=void 0===e.document?e:new EventTargetService_1.default,r=e.Node||NodeService_1.NodeService;void 0===n.Node&&(n.Node=r);const o=e.Element||ElementService_1.ElementService;void 0===n.Element&&(n.Element=o);const c=e.HTMLElement||HTMLElementService_1.HTMLElementService;void 0===n.HTMLElement&&(n.HTMLElement=c);const i=e.HTMLDocument||PseudoHTMLDocument_1.default;void 0===n.HTMLDocument&&(n.HTMLDocument=i);const u=e.document||new PseudoHTMLDocument_1.default;void 0===n.document&&(n.document=u);const m=t||e;return n===m?n:Object.assign(m,n)};exports.default=generateDocument;
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const EventTargetService_1=__importDefault(require("../services/EventTargetService")),NodeService_1=require("../services/NodeService"),ElementService_1=require("../services/ElementService"),HTMLElementService_1=require("../services/HTMLElementService"),EventService_1=require("../services/EventService"),PseudoHTMLDocument_1=__importDefault(require("../classes/PseudoHTMLDocument")),generateDocument=(e,t={})=>{const r=void 0===e.document?e:new EventTargetService_1.default,n=e.Node||NodeService_1.NodeService;void 0===r.Node&&(r.Node=n);const c=e.Element||ElementService_1.ElementService;void 0===r.Element&&(r.Element=c);const o=e.HTMLElement||HTMLElementService_1.HTMLElementService;void 0===r.HTMLElement&&(r.HTMLElement=o);const i=e.HTMLDocument||PseudoHTMLDocument_1.default;void 0===r.HTMLDocument&&(r.HTMLDocument=i),r.Event!==EventService_1.EventService&&(r.Event=EventService_1.EventService);const v=e.document||new PseudoHTMLDocument_1.default;void 0===r.document&&(r.document=v);const u=t||e;return r===u?r:Object.assign(u,r)};exports.default=generateDocument;

package/dist/factories/generateNodeList.d.ts

@@ -2,8 +2,7 @@ import { PseudoNodeList } from '../classes/PseudoNodeList';
 import { TreeLinker } from 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker';
 /**
  * Create a PseudoNodeList, optionally starting from an existing chain of linkers.
- * @param {TreeLinker|null} [innerList=null]
- * @returns {PseudoNodeList}
+ * @param innerList
  */
 declare const generateNodeList: (innerList?: TreeLinker | null) => PseudoNodeList;
 export default generateNodeList;

package/dist/factories/generateNodeList.js

@@ -6,8 +6,7 @@ Object.defineProperty(exports, '__esModule', {
 const PseudoNodeList_1 = require('../classes/PseudoNodeList')
 /**
  * Create a PseudoNodeList, optionally starting from an existing chain of linkers.
- * @param {TreeLinker|null} [innerList=null]
- * @returns {PseudoNodeList}
+ * @param innerList
  */
 const generateNodeList = (innerList = null) => new PseudoNodeList_1.PseudoNodeList().initialize(innerList)
 exports.default = generateNodeList

package/dist/factories/installGlobal.d.ts

@@ -6,10 +6,9 @@
  * real browser's global scope - some code checks for a bare `window` before falling back to `global`), so code
  * written against a real DOM's globals works as-is. Does nothing when a real DOM is already there, matching
  * generateDocument's own only-fill-what-is-missing behaviour - calling this is always safe, in any environment.
- * @memberOf module:factories
- * @param {*} [target] The object to add document / Node / Element / HTMLElement / window onto - defaults to
+ * @param target The object to add document / Node / Element / HTMLElement / window onto - defaults to
  * globalThis, so bare `document`, `Node`, `window`, etc. resolve from anywhere once this has run
- * @returns {*} The same target, for convenience
+ * @returns The same target, for convenience
  */
 declare const installGlobal: (target?: any) => any;
 export default installGlobal;

package/dist/factories/installGlobal.js

@@ -11,11 +11,9 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 /**
- * @file Makes pseudo-dom a drop-in swap for a real DOM: code written against bare globals (document.createElement,
+ * Makes pseudo-dom a drop-in swap for a real DOM: code written against bare globals (document.createElement,
  * new Node(), ...) works unmodified, in the browser or in Node, without an if (typeof document === 'undefined')
  * check at every call site.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const browser_or_node_1 = require('browser-or-node')
 const generateDocument_1 = __importDefault(require('./generateDocument'))
@@ -27,10 +25,9 @@ const generateDocument_1 = __importDefault(require('./generateDocument'))
  * real browser's global scope - some code checks for a bare `window` before falling back to `global`), so code
  * written against a real DOM's globals works as-is. Does nothing when a real DOM is already there, matching
  * generateDocument's own only-fill-what-is-missing behaviour - calling this is always safe, in any environment.
- * @memberOf module:factories
- * @param {*} [target] The object to add document / Node / Element / HTMLElement / window onto - defaults to
+ * @param target The object to add document / Node / Element / HTMLElement / window onto - defaults to
  * globalThis, so bare `document`, `Node`, `window`, etc. resolve from anywhere once this has run
- * @returns {*} The same target, for convenience
+ * @returns The same target, for convenience
  */
 const installGlobal = (target = typeof globalThis !== 'undefined' ? globalThis : {}) => {
   if (!browser_or_node_1.isBrowser) {

package/dist/factories/logElement.d.ts

@@ -1,9 +1,7 @@
 /**
  * Print a node's markup to the console, indented for readability (see prettyPrint).
- * @memberOf module:factories
- * @param {*} node
- * @param {string} [label=''] A label printed above the markup, to identify this log call
- * @returns {undefined}
+ * @param node
+ * @param label A label printed above the markup, to identify this log call
  */
 declare const logElement: (node: any, label?: string) => void;
 export default logElement;

package/dist/factories/logElement.js

@@ -4,18 +4,14 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 /**
- * @file Prints an element (or any node) to the console, readably - the point of pseudo-dom running headlessly is
+ * Prints an element (or any node) to the console, readably - the point of pseudo-dom running headlessly is
  * usually to watch what code does to a tree without a real browser to look at.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const serializeHTML_1 = require('./serializeHTML')
 /**
  * Print a node's markup to the console, indented for readability (see prettyPrint).
- * @memberOf module:factories
- * @param {*} node
- * @param {string} [label=''] A label printed above the markup, to identify this log call
- * @returns {undefined}
+ * @param node
+ * @param label A label printed above the markup, to identify this log call
  */
 const logElement = (node, label = '') => {
   console.log(`${label ? `${label}\n` : ''}${(0, serializeHTML_1.prettyPrint)(node)}`)

package/dist/factories/parseHTML.d.ts

@@ -1,11 +1,9 @@
 /**
  * Parse an HTML string into the nodes it describes (siblings at the top level, exactly like the DOM's own HTML
  * parsing does for innerHTML / insertAdjacentHTML - there is no single root unless the markup itself has one).
- * @memberOf module:factories
- * @param {string} html
- * @param {*} ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
- * @param {function(new: *, {tagName: string})} ElementClass The class to build each parsed element with
- * @returns {Array<*>}
+ * @param html
+ * @param ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
+ * @param ElementClass The class to build each parsed element with
  */
 declare const parseHTML: (html: string, ownerDocument: any, ElementClass: new (options: {
     tagName: string;

package/dist/factories/parseHTML.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 /**
- * @file Parses an HTML string into pseudo-dom nodes, for innerHTML / outerHTML / insertAdjacentHTML. Built on
+ * Parses an HTML string into pseudo-dom nodes, for innerHTML / outerHTML / insertAdjacentHTML. Built on
  * htmlparser2's Parser (a SAX-style tokenizer) with a custom handler which builds pseudo-dom nodes directly -
  * htmlparser2's own default DomHandler / domutils tree (which this never uses) is stubbed out of the browser bundle
  * by the browser.ignore config, the same way css-select's unused default adapter already is.
@@ -12,19 +12,15 @@ Object.defineProperty(exports, '__esModule', {
  * The class to build parsed elements with is given by the caller (rather than imported here) so this has no
  * dependency on ElementService / HTMLElementService - importing either here, from a factory ElementService itself
  * would need to call, would create an import cycle.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const htmlparser2_1 = require('htmlparser2')
 const NodeService_1 = require('../services/NodeService')
 /**
  * Parse an HTML string into the nodes it describes (siblings at the top level, exactly like the DOM's own HTML
  * parsing does for innerHTML / insertAdjacentHTML - there is no single root unless the markup itself has one).
- * @memberOf module:factories
- * @param {string} html
- * @param {*} ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
- * @param {function(new: *, {tagName: string})} ElementClass The class to build each parsed element with
- * @returns {Array<*>}
+ * @param html
+ * @param ownerDocument The document the new nodes belong to (matches what innerHTML etc. would set), or null
+ * @param ElementClass The class to build each parsed element with
  */
 const parseHTML = (html, ownerDocument, ElementClass) => {
   const roots = []

package/dist/factories/query.d.ts

@@ -1,33 +1,25 @@
 /**
  * All of the elements below (not including) scope which match the selector, in tree order.
- * @memberOf module:factories
- * @param {string} selector A CSS selector
- * @param {*} scope The node to search below
- * @returns {Array<*>}
+ * @param selector A CSS selector
+ * @param scope The node to search below
  */
 export declare const querySelectorAll: (selector: string, scope: any) => Array<any>;
 /**
  * The first element below (not including) scope which matches the selector, in tree order, or null when there is none.
- * @memberOf module:factories
- * @param {string} selector A CSS selector
- * @param {*} scope The node to search below
- * @returns {*|null}
+ * @param selector A CSS selector
+ * @param scope The node to search below
  */
 export declare const querySelector: (selector: string, scope: any) => any | null;
 /**
  * Whether an element itself (not its descendants) matches the selector.
- * @memberOf module:factories
- * @param {*} element The element to test
- * @param {string} selector A CSS selector
- * @returns {boolean}
+ * @param element The element to test
+ * @param selector A CSS selector
  */
 export declare const matches: (element: any, selector: string) => boolean;
 /**
  * The nearest ancestor of an element (starting with the element itself) which matches the selector, or null when
  * none of them do.
- * @memberOf module:factories
- * @param {*} element The element to start from
- * @param {string} selector A CSS selector
- * @returns {*|null}
+ * @param element The element to start from
+ * @param selector A CSS selector
  */
 export declare const closest: (element: any, selector: string) => any | null;

package/dist/factories/query.js

@@ -5,19 +5,15 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.closest = exports.matches = exports.querySelector = exports.querySelectorAll = void 0
 /**
- * @file Selector queries (querySelector, querySelectorAll, matches, closest), built on css-select and the
+ * Selector queries (querySelector, querySelectorAll, matches, closest), built on css-select and the
  * cssSelectAdapter which lets it query pseudo-dom's own tree.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
  */
 const css_select_1 = require('css-select')
 const cssSelectAdapter_1 = require('./cssSelectAdapter')
 /**
  * All of the elements below (not including) scope which match the selector, in tree order.
- * @memberOf module:factories
- * @param {string} selector A CSS selector
- * @param {*} scope The node to search below
- * @returns {Array<*>}
+ * @param selector A CSS selector
+ * @param scope The node to search below
  */
 const querySelectorAll = (selector, scope) => (0, css_select_1.selectAll)(selector, scope, {
   adapter: cssSelectAdapter_1.cssSelectAdapter
@@ -25,10 +21,8 @@ const querySelectorAll = (selector, scope) => (0, css_select_1.selectAll)(select
 exports.querySelectorAll = querySelectorAll
 /**
  * The first element below (not including) scope which matches the selector, in tree order, or null when there is none.
- * @memberOf module:factories
- * @param {string} selector A CSS selector
- * @param {*} scope The node to search below
- * @returns {*|null}
+ * @param selector A CSS selector
+ * @param scope The node to search below
  */
 const querySelector = (selector, scope) => (0, css_select_1.selectOne)(selector, scope, {
   adapter: cssSelectAdapter_1.cssSelectAdapter
@@ -36,10 +30,8 @@ const querySelector = (selector, scope) => (0, css_select_1.selectOne)(selector,
 exports.querySelector = querySelector
 /**
  * Whether an element itself (not its descendants) matches the selector.
- * @memberOf module:factories
- * @param {*} element The element to test
- * @param {string} selector A CSS selector
- * @returns {boolean}
+ * @param element The element to test
+ * @param selector A CSS selector
  */
 const matches = (element, selector) => (0, css_select_1.is)(element, selector, {
   adapter: cssSelectAdapter_1.cssSelectAdapter
@@ -48,10 +40,8 @@ exports.matches = matches
 /**
  * The nearest ancestor of an element (starting with the element itself) which matches the selector, or null when
  * none of them do.
- * @memberOf module:factories
- * @param {*} element The element to start from
- * @param {string} selector A CSS selector
- * @returns {*|null}
+ * @param element The element to start from
+ * @param selector A CSS selector
  */
 const closest = (element, selector) => {
   let current = element

package/dist/factories/serializeHTML.d.ts

@@ -1,25 +1,19 @@
 /**
  * A node's children, serialized in order (this is what innerHTML returns).
- * @memberOf module:factories
- * @param {*} node
- * @returns {string}
+ * @param node
  */
 declare const serializeChildren: (node: any) => string;
 /**
  * An element itself, serialized with its children (this is what outerHTML returns).
- * @memberOf module:factories
- * @param {*} element
- * @returns {string}
+ * @param element
  */
 declare const serializeOuter: (element: any) => string;
 /**
  * A node's markup, indented one level per level of nesting - a real DOM's outerHTML / innerHTML has no line breaks
  * at all, which does not read well for a whole tree (a board full of cells, say). Useful for watching pseudo-dom-
  * driven code run headlessly, printed to a terminal - see also logElement, which does the printing too.
- * @memberOf module:factories
- * @param {*} node
- * @param {string} [indent='  '] The indentation used per level of nesting
- * @returns {string}
+ * @param node
+ * @param indent The indentation used per level of nesting
  */
 declare const prettyPrint: (node: any, indent?: string) => string;
 export { serializeChildren, serializeOuter, prettyPrint };

package/dist/factories/serializeHTML.js

@@ -24,9 +24,7 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.prettyPrint = exports.serializeOuter = exports.serializeChildren = void 0
 /**
- * @file Serializes pseudo-dom nodes back into an HTML string, for innerHTML / outerHTML.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Serializes pseudo-dom nodes back into an HTML string, for innerHTML / outerHTML.
  */
 const NodeService_1 = require('../services/NodeService')
 // Void elements are self-closing and never serialize a closing tag or children (there is no HTML parsing of their
@@ -46,23 +44,20 @@ const BOOLEAN_ATTRIBUTES = new Set(['hidden'])
  * Escape text so it is safe inside HTML text content. Coerces to a string first - unlike a real DOM, pseudo-dom's
  * setAttribute does not itself coerce (see the same note on escapeAttributeValue), and nodeValue is not guaranteed
  * to be a string either.
- * @param {*} text
- * @returns {string}
+ * @param text
  */
 const escapeText = text => String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
 /**
  * Escape a value so it is safe inside a double-quoted HTML attribute. Coerces to a string first: a real DOM's
  * setAttribute always stores a string, however pseudo-dom's does not coerce what it is given, so a value set via
  * setAttribute(name, 5) is stored (and read back by getAttribute) as the number 5, not the string '5'.
- * @param {*} value
- * @returns {string}
+ * @param value
  */
 const escapeAttributeValue = value => String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;')
 /**
  * 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).
- * @param {*} element
- * @returns {string}
+ * @param element
  */
 const serializeAttributes = element => {
   let result = (element.getAttributeNames ? element.getAttributeNames() : []).filter(name => !NEVER_SERIALIZE.has(name)).map(name => {
@@ -80,8 +75,7 @@ const serializeAttributes = element => {
 }
 /**
  * One node, serialized (its own markup only - see serializeChildren for its descendants too).
- * @param {*} node
- * @returns {string}
+ * @param node
  */
 const serializeNode = node => {
   if (node.nodeType === NodeService_1.NodeService.TEXT_NODE) {
@@ -102,27 +96,22 @@ const serializeNode = node => {
 }
 /**
  * A node's children, serialized in order (this is what innerHTML returns).
- * @memberOf module:factories
- * @param {*} node
- * @returns {string}
+ * @param node
  */
 const serializeChildren = node => Array.from(node.childNodes).map(serializeNode).join('')
 exports.serializeChildren = serializeChildren
 /**
  * An element itself, serialized with its children (this is what outerHTML returns).
- * @memberOf module:factories
- * @param {*} element
- * @returns {string}
+ * @param element
  */
 const serializeOuter = element => serializeNode(element)
 exports.serializeOuter = serializeOuter
 /**
  * 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.
- * @param {*} node
- * @param {number} depth
- * @param {string} indent
- * @returns {string}
+ * @param node
+ * @param depth
+ * @param indent
  */
 const prettyPrintNode = (node, depth, indent) => {
   const pad = indent.repeat(depth)
@@ -151,10 +140,8 @@ const prettyPrintNode = (node, depth, indent) => {
  * A node's markup, indented one level per level of nesting - a real DOM's outerHTML / innerHTML has no line breaks
  * at all, which does not read well for a whole tree (a board full of cells, say). Useful for watching pseudo-dom-
  * driven code run headlessly, printed to a terminal - see also logElement, which does the printing too.
- * @memberOf module:factories
- * @param {*} node
- * @param {string} [indent='  '] The indentation used per level of nesting
- * @returns {string}
+ * @param node
+ * @param indent The indentation used per level of nesting
  */
 const prettyPrint = (node, indent = '  ') => prettyPrintNode(node, 0, indent)
 exports.prettyPrint = prettyPrint

package/dist/functions/activeElement.d.ts

@@ -1,14 +1,11 @@
 /**
  * Find the element which has the focus in a tree.
- * @function getActiveElement
- * @param {Object} root The root node of the tree
- * @returns {Object|null}
+ * @param root The root node of the tree
  */
 export declare const getActiveElement: (root: object) => any | null;
 /**
  * Remember the element which has the focus in a tree.
- * @function setActiveElement
- * @param {Object} root The root node of the tree
- * @param {Object|null} element The element which now has the focus, or null when nothing has it
+ * @param root The root node of the tree
+ * @param element The element which now has the focus, or null when nothing has it
  */
 export declare const setActiveElement: (root: object, element: any | null) => void;

package/dist/functions/activeElement.js

@@ -11,17 +11,14 @@ exports.setActiveElement = exports.getActiveElement = void 0
 const focused = new WeakMap()
 /**
  * Find the element which has the focus in a tree.
- * @function getActiveElement
- * @param {Object} root The root node of the tree
- * @returns {Object|null}
+ * @param root The root node of the tree
  */
 const getActiveElement = root => focused.get(root) || null
 exports.getActiveElement = getActiveElement
 /**
  * Remember the element which has the focus in a tree.
- * @function setActiveElement
- * @param {Object} root The root node of the tree
- * @param {Object|null} element The element which now has the focus, or null when nothing has it
+ * @param root The root node of the tree
+ * @param element The element which now has the focus, or null when nothing has it
  */
 const setActiveElement = (root, element) => {
   if (element === null) {

package/dist/functions/getElementById.d.ts

@@ -4,10 +4,8 @@ import { PseudoElement } from '../interfaces/PseudoElement';
  * The first element, in tree order, below (not including) the given node whose id matches the given value, or null
  * when there is none. Shared by Document and DocumentFragment, which both implement the DOM's NonElementParentNode
  * mixin (so ShadowRoot, a DocumentFragment, gets it too).
- * @memberOf module:functions
- * @param {NodeService} root The node to search below
- * @param {string} id
- * @returns {PseudoElement|null}
+ * @param root The node to search below
+ * @param id
  */
 declare const getElementById: (root: NodeService, id: string) => PseudoElement | null;
 export default getElementById;

package/dist/functions/getElementById.js

@@ -8,10 +8,8 @@ const NodeService_1 = require('../services/NodeService')
  * The first element, in tree order, below (not including) the given node whose id matches the given value, or null
  * when there is none. Shared by Document and DocumentFragment, which both implement the DOM's NonElementParentNode
  * mixin (so ShadowRoot, a DocumentFragment, gets it too).
- * @memberOf module:functions
- * @param {NodeService} root The node to search below
- * @param {string} id
- * @returns {PseudoElement|null}
+ * @param root The node to search below
+ * @param id
  */
 const getElementById = (root, id) => {
   const search = node => {