pseudo-dom 0.1.0 → 0.3.0

package/browser/pseudo-dom.js

@@ -20,6 +20,13 @@
  * @property {boolean} isDefault
  */
     class PseudoEventListener {
+      /**
+   * @param {string} eventType The type of event this listens for
+   * @param {Object} [options] The capture, once and passive options
+   * @param {Function} handleEvent The function which is called with the event, already bound to what it should run as
+   * @param {Function} [originalCallback=handleEvent] The function (or object) which was given when registering, used to find this listener again
+   * @constructor
+   */
       constructor (eventType, {
         capture = false,
         once = false,
@@ -32,6 +39,7 @@
         }
         this.eventType = ''
         this.defaultListener = false
+        this.isRemoved = false
         this.eventOptions = {
           capture,
           once,
@@ -49,6 +57,11 @@
         return this.originalCallback
       }
 
+      /** Whether this listener listens in the capture phase (and at the target) rather than in the bubble phase. */
+      get capture () {
+        return this.eventOptions.capture
+      }
+
       get isDefault () {
         return this.defaultListener
       }
@@ -57,6 +70,20 @@
         return this.eventOptions.once
       }
 
+      /** Whether the listener promises not to prevent the default (preventDefault does nothing while it runs). */
+      get passive () {
+        return this.eventOptions.passive
+      }
+
+      /** Whether this listener has been removed, a removed listener does not run even if the event already started. */
+      get removed () {
+        return this.isRemoved
+      }
+
+      set removed (removed) {
+        this.isRemoved = removed
+      }
+
       /**
    * @method
    * @name PseudoEventListener#handleEvent
@@ -68,6 +95,7 @@
       }
 
       /**
+   * A capture listener runs while the event travels down to the target.
    * @method
    * @name PseudoEventListener#doCapturePhase
    * @param {PseudoEvent} event
@@ -78,6 +106,7 @@
       }
 
       /**
+   * Every listener of the target itself runs, capture listeners first.
    * @method
    * @name PseudoEventListener#doTargetPhase
    * @param {PseudoEvent} event
@@ -88,13 +117,14 @@
       }
 
       /**
+   * A listener which is not a capture listener runs while the event travels back up (when it bubbles).
    * @method
    * @name PseudoEventListener#doBubblePhase
    * @param {PseudoEvent} event
-   * @returns {boolean|*}
+   * @returns {boolean}
    */
       doBubblePhase (event) {
-        return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && (event.bubbles || !this.eventOptions.capture)
+        return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && !this.eventOptions.capture
       }
 
       /**
@@ -108,43 +138,16 @@
       }
 
       /**
-   * @method
-   * @name PseudoEventListener#skipDefault
-   * @param {PseudoEvent} event
-   * @returns {boolean|*}
-   */
-      skipDefault (event) {
-        return this.isDefault && event.defaultPrevented
-      }
-
-      /**
-   * @method
-   * @name PseudoEventListener#stopPropagation
-   * @param {PseudoEvent} event
-   * @returns {boolean}
-   */
-      stopPropagation (event) {
-        return !this.doTargetPhase(event) && event.inner.propagationStopped
-      }
-
-      /**
-   * @method
-   * @name PseudoEventListener#nonPassiveHalt
-   * @param {PseudoEvent} event
-   * @returns {boolean|*}
-   */
-      nonPassiveHalt (event) {
-        return !this.eventOptions.passive && (this.skipDefault(event) || event.inner.immediatePropagationStopped || this.stopPropagation(event))
-      }
-
-      /**
+   * Whether this listener should not run for the event as it is now (it was removed, or it is for another phase).
+   * Stopping propagation is handled by the dispatching, since it stops other targets and not the listeners of the
+   * current one.
    * @method
    * @name PseudoEventListener#rejectEvent
    * @param {PseudoEvent} event
-   * @returns {*|boolean}
+   * @returns {boolean}
    */
       rejectEvent (event) {
-        return this.nonPassiveHalt(event) || this.skipPhase(event)
+        return this.isRemoved || this.skipPhase(event)
       }
     }
     exports.default = PseudoEventListener
@@ -152,13 +155,6 @@
   2: [function (require, module, exports) {
     'use strict'
 
-    const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-      return mod && mod.__esModule
-        ? mod
-        : {
-            default: mod
-          }
-    }
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
@@ -172,8 +168,6 @@
  * @type {PseudoHTMLElement}
  */
     const HTMLElementService_1 = require('../services/HTMLElementService')
-    const generateNodeList_1 = __importDefault(require('../factories/generateNodeList'))
-    const TreeLinker_1 = require('collect-your-stuff/dist/collections/linked-tree-list/TreeLinker')
     /**
  * Simulate the behaviour of the HTMLDocument Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -181,7 +175,7 @@
  * @augments PseudoHTMLElement
  * @property {PseudoHTMLElement} head - A reference to the Head child element
  * @property {PseudoHTMLElement} body - A reference to the Body child element
- * @property {function} createElement - Generate a new PseudoHTMLElement with parent of document
+ * @property {function} createElement - Generate a new PseudoHTMLElement (which is not in the document until it is appended)
  */
     class PseudoHTMLDocument extends HTMLElementService_1.HTMLElementService {
       /**
@@ -191,43 +185,41 @@
       constructor () {
         super()
         const html = new HTMLElementService_1.HTMLElementService({
-          tagName: 'html',
-          parent: this
+          tagName: 'html'
         })
+        this.appendChild(html)
         /**
      * Create document head element
      * @type {PseudoHTMLElement}
      */
         this.head = new HTMLElementService_1.HTMLElementService({
-          tagName: 'head',
-          parent: html
+          tagName: 'head'
         })
+        html.appendChild(this.head)
         /**
      * Create document body element
      * @type {PseudoHTMLElement}
      */
         this.body = new HTMLElementService_1.HTMLElementService({
-          tagName: 'body',
-          parent: html
+          tagName: 'body'
         })
-        html.children = (0, generateNodeList_1.default)(TreeLinker_1.TreeLinker.fromArray([this.head, this.body]).head)
+        html.appendChild(this.body)
       }
 
       /**
-   * Create and return a PseudoHTMLElement
+   * Create and return a PseudoHTMLElement, which is not added to the document until it is appended somewhere
    * @param {string} tagName - Tag Name is a string representing the type of Dom element this represents
    * @returns {PseudoHTMLElement}
    */
       createElement (tagName = 'div') {
-        const returnElement = new HTMLElementService_1.HTMLElementService({
+        // Like the DOM, the new element is not added anywhere: it has no parent until it is appended
+        return new HTMLElementService_1.HTMLElementService({
           tagName
         })
-        returnElement.parent = this
-        return returnElement
       }
     }
     exports.default = PseudoHTMLDocument
-  }, { '../factories/generateNodeList': 5, '../services/HTMLElementService': 14, 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker': 24 }],
+  }, { '../services/HTMLElementService': 14 }],
   3: [function (require, module, exports) {
     'use strict'
 
@@ -255,16 +247,22 @@
    * @returns {Iterator}
    */
       [Symbol.iterator] () {
-        const linkers = super[Symbol.iterator]()
+        // Walk the nodes of this list only (the linkers of a child list have no children of their own)
+        let current = this.first
         return {
           next: () => {
-            const result = linkers.next()
-            return result.done
-              ? result
-              : {
-                  done: false,
-                  value: result.value.data
-                }
+            if (current === null) {
+              return {
+                done: true,
+                value: undefined
+              }
+            }
+            const result = {
+              done: false,
+              value: current.data
+            }
+            current = current.next
+            return result
           }
         }
       }
@@ -380,31 +378,58 @@
   6: [function (require, module, exports) {
     '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 getParentNodesFromAttribute_1 = __importDefault(require('./getParentNodesFromAttribute'))
-    const getParentNodes = node => (0, getParentNodesFromAttribute_1.default)('', false, node)
+    /**
+ * Get all of the ancestors of a node, starting with the root of the tree and ending with the node's own parent (the
+ * order in which an event travels down through them). A node which has no parent has no ancestors.
+ * @function getParentNodes
+ * @param {PseudoEventTarget|PseudoNode|*} node The node to find the ancestors of
+ * @returns {Array<PseudoNode>}
+ */
+    const getParentNodes = node => {
+      const parents = []
+      let current = node && node.parentNode ? node.parentNode : null
+      while (current) {
+        parents.unshift(current)
+        current = current.parentNode
+      }
+      return parents
+    }
     exports.default = getParentNodes
-  }, { './getParentNodesFromAttribute': 7 }],
+  }, {}],
   7: [function (require, module, exports) {
     'use strict'
 
+    require('core-js/modules/esnext.iterator.constructor.js')
+    require('core-js/modules/esnext.iterator.filter.js')
+    const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+      return mod && mod.__esModule
+        ? mod
+        : {
+            default: mod
+          }
+    }
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
+    const getParentNodes_1 = __importDefault(require('./getParentNodes'))
+    /**
+ * A selector function for retrieving existing parent PseudoNode from the given child item.
+ * This function will check all the parents starting from node, and scan the attributes
+ * property for matches. The return array contains all matching parent ancestors, starting with the root of the tree.
+ * @function getParentNodesFromAttribute
+ * @param {string} attr The property to compare on each ancestor (a missing property counts as false)
+ * @param {boolean|number|string} value The value the property must have
+ * @param {PseudoEventTarget|PseudoNode|*} node The node to find the matching ancestors of
+ * @returns {Array.<PseudoNode>}
+ */
     const getParentNodesFromAttribute = (attr, value, node) => {
-      return Object.keys(node.parentNode).length ? (node.parentNode[attr] || false) === value ? getParentNodesFromAttribute(attr, value, node.parentNode).concat([node.parentNode]) : getParentNodesFromAttribute(attr, value, node.parentNode) : []
+      return (0, getParentNodes_1.default)(node).filter(parent => (parent[attr] || false) === value)
     }
     exports.default = getParentNodesFromAttribute
-  }, {}],
+  }, { './getParentNodes': 6, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.filter.js': 131 }],
   8: [function (require, module, exports) {
     'use strict'
 
@@ -679,8 +704,7 @@
       value: true
     })
     exports.ElementService = void 0
-    const generateNodeList_1 = __importDefault(require('../factories/generateNodeList'))
-    const TreeLinker_1 = require('collect-your-stuff/dist/collections/linked-tree-list/TreeLinker')
+    const EventService_1 = require('./EventService')
     const NodeService_1 = require('./NodeService')
     const AttrService_1 = require('./AttrService')
     const DOMTokenListService_1 = require('./DOMTokenListService')
@@ -706,8 +730,8 @@
    * @param {Object} [settings={}]
    * @param {string} [settings.tagName=''] The name of the tag this element represents
    * @param {Array<{name: string, value: *}>} [settings.attributes=[]] The attributes (also assigned as properties) to start with
-   * @param {PseudoNode|null} [settings.parent=null] The parent node
-   * @param {Array} [settings.children=[]] The values or nodes to start as children
+   * @param {PseudoNode|null} [settings.parent=null] The node to add this element to as its last child
+   * @param {Array<PseudoNode>} [settings.children=[]] The nodes to start as children
    * @constructor
    */
       constructor ({
@@ -717,9 +741,8 @@
         children = []
       } = {}) {
         super()
+        this.defaultEventApplied = false
         this.tokenList = new DOMTokenListService_1.DOMTokenListService()
-        this.parent = parent
-        this.children = (0, generateNodeList_1.default)(TreeLinker_1.TreeLinker.fromArray(children).head)
         this.tag = tagName
         this.attributeList = attributes.concat([{
           name: 'className',
@@ -740,6 +763,15 @@
         }) => {
           this[name] = value
         })
+        children.forEach(child => {
+          if (!child || typeof child.nodeType !== 'number') {
+            throw new TypeError('The children of an element must be nodes.')
+          }
+          this.appendChild(child)
+        })
+        if (parent) {
+          parent.appendChild(this)
+        }
       }
 
       get tagName () {
@@ -775,34 +807,38 @@
    */
       applyDefaultEvent () {
         let callback = event => undefined
+        if (this.defaultEventApplied) {
+          return callback
+        }
         switch (this.tagName) {
-          case 'form':
-            this.addEventListener('submit', callback)
-            break
           case 'button':
           case 'input':
             if (/^(submit|image)$/i.test(this.type || '')) {
+              // Clicking a submit button submits the form it is in: the form gets a submit event, which can be cancelled
               callback = event => {
                 const forms = (0, getParentNodesFromAttribute_1.default)('tagName', 'form', this)
                 if (forms.length) {
-                  forms[0].submit()
+                  forms[forms.length - 1].dispatchEvent(new EventService_1.EventService('submit', {
+                    bubbles: true,
+                    cancelable: true
+                  }))
                 }
               }
               super.setDefaultEvent('click', callback)
+              this.defaultEventApplied = true
             }
         }
         return callback
       }
 
       /**
-   *
-   * @param {PseudoNode|ElementService} childElement
-   * @returns {PseudoNode}
+   * An element which is added as a child gets its default events (for example a submit button submits its form).
+   * @param {NodeService} child The node which was inserted
    */
-      appendChild (childElement) {
-        super.appendChild(childElement)
-        childElement.applyDefaultEvent()
-        return childElement
+      childInserted (child) {
+        if (typeof child.applyDefaultEvent === 'function') {
+          child.applyDefaultEvent()
+        }
       }
 
       /**
@@ -866,7 +902,7 @@
       }
     }
     exports.ElementService = ElementService
-  }, { '../factories/generateNodeList': 5, '../functions/getParentNodesFromAttribute': 7, './AttrService': 9, './DOMTokenListService': 10, './NamedNodeMapService': 15, './NodeService': 16, 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker': 24, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.find.js': 132, 'core-js/modules/esnext.iterator.for-each.js': 133, 'core-js/modules/esnext.iterator.map.js': 134, 'core-js/modules/esnext.iterator.some.js': 136 }],
+  }, { '../functions/getParentNodesFromAttribute': 7, './AttrService': 9, './DOMTokenListService': 10, './EventService': 12, './NamedNodeMapService': 15, './NodeService': 16, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.find.js': 132, 'core-js/modules/esnext.iterator.for-each.js': 133, 'core-js/modules/esnext.iterator.map.js': 134, 'core-js/modules/esnext.iterator.some.js': 136 }],
   12: [function (require, module, exports) {
     'use strict'
 
@@ -875,18 +911,10 @@
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @version 1.0.0
  */
-    const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-      return mod && mod.__esModule
-        ? mod
-        : {
-            default: mod
-          }
-    }
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
     exports.EventService = void 0
-    const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
     /**
  * Simulate the behaviour of the Event Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -921,20 +949,20 @@
    *
    * @param {string} typeArg
    * @param {Object} [eventOptions={}]
-   * @param {boolean} [eventOptions.bubbles=true]
-   * @param {boolean} [eventOptions.cancelable=true]
-   * @param {boolean} [eventOptions.composed=true]
+   * @param {boolean} [eventOptions.bubbles=false]
+   * @param {boolean} [eventOptions.cancelable=false]
+   * @param {boolean} [eventOptions.composed=false]
    * @constructor
    */
       constructor (typeArg = '', {
-        bubbles = true,
-        cancelable = true,
-        composed = true
+        bubbles = false,
+        cancelable = false,
+        composed = false
       } = {}) {
         this.properties = {
-          bubbles: true,
-          cancelable: true,
-          composed: true,
+          bubbles: false,
+          cancelable: false,
+          composed: false,
           currentTarget: null,
           defaultPrevented: false,
           immediatePropagationStopped: false,
@@ -943,7 +971,10 @@
           target: null,
           timeStamp: Math.floor(Date.now() / 1000),
           type: '',
-          isTrusted: true
+          isTrusted: true,
+          dispatching: false,
+          inPassiveListener: false,
+          path: []
         }
         this.setReadOnlyProperties({
           type: typeArg,
@@ -1000,12 +1031,21 @@
       get inner () {
         const self = this
         return {
+          get currentTarget () {
+            return self.properties.currentTarget
+          },
           set currentTarget (target) {
             self.properties.currentTarget = target
           },
+          get eventPhase () {
+            return self.properties.eventPhase
+          },
           set eventPhase (phase) {
             self.properties.eventPhase = phase
           },
+          get target () {
+            return self.properties.target
+          },
           set target (target) {
             self.properties.target = target
           },
@@ -1014,6 +1054,35 @@
           },
           get propagationStopped () {
             return self.properties.propagationStopped
+          },
+          get dispatching () {
+            return self.properties.dispatching
+          },
+          set dispatching (dispatching) {
+            self.properties.dispatching = dispatching
+          },
+          get inPassiveListener () {
+            return self.properties.inPassiveListener
+          },
+          set inPassiveListener (passive) {
+            self.properties.inPassiveListener = passive
+          },
+          get path () {
+            return self.properties.path
+          },
+          set path (path) {
+            self.properties.path = path
+          },
+          finishDispatch () {
+            self.setReadOnlyProperties({
+              currentTarget: null,
+              eventPhase: EventService.NONE,
+              path: [],
+              dispatching: false,
+              inPassiveListener: false,
+              propagationStopped: false,
+              immediatePropagationStopped: false
+            })
           }
         }
       }
@@ -1024,16 +1093,8 @@
    * @returns {Array.<PseudoEventTarget>}
    */
       composedPath () {
-        switch (this.eventPhase) {
-          case EventService.CAPTURING_PHASE:
-            return (0, getParentNodes_1.default)(this.target)
-          case EventService.BUBBLING_PHASE:
-            return (0, getParentNodes_1.default)(this.target).slice().reverse()
-          case EventService.AT_TARGET:
-            return [this.target]
-          default:
-            return []
-        }
+        // While the event is being dispatched this is every target it travels through, the target first and the root last
+        return this.properties.dispatching ? this.properties.path.slice() : []
       }
 
       /**
@@ -1042,9 +1103,12 @@
    * @returns {null}
    */
       preventDefault () {
-        this.setReadOnlyProperties({
-          defaultPrevented: true
-        })
+        // Only an event which can be cancelled can be prevented, and a passive listener cannot prevent the default
+        if (this.cancelable && !this.properties.inPassiveListener) {
+          this.setReadOnlyProperties({
+            defaultPrevented: true
+          })
+        }
         return null
       }
 
@@ -1084,7 +1148,7 @@
     EventService.CAPTURING_PHASE = 1
     EventService.AT_TARGET = 2
     EventService.BUBBLING_PHASE = 3
-  }, { '../functions/getParentNodes': 6 }],
+  }, {}],
   13: [function (require, module, exports) {
     'use strict'
 
@@ -1092,6 +1156,8 @@
     require('core-js/modules/esnext.iterator.filter.js')
     require('core-js/modules/esnext.iterator.find.js')
     require('core-js/modules/esnext.iterator.for-each.js')
+    require('core-js/modules/esnext.iterator.map.js')
+    require('core-js/modules/esnext.iterator.some.js')
     const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
       return mod && mod.__esModule
         ? mod
@@ -1109,9 +1175,13 @@
  */
     const EventService_1 = require('./EventService')
     const PseudoEventListener_1 = __importDefault(require('../classes/PseudoEventListener'))
+    const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
     const LinkedList_1 = require('collect-your-stuff/dist/collections/linked-list/LinkedList')
     /**
  * Simulate the behaviour of the EventTarget Class when there is no DOM available.
+ * Dispatching an event sends it through the tree the way the DOM does: down from the root to the target (capture
+ * listeners), to the target itself, then back up to the root (the listeners which are not capture listeners, when the
+ * event bubbles).
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @class
  * @property {Object.<string, Array.<PseudoEventListener>>} listeners
@@ -1141,33 +1211,51 @@
       }
 
       /**
-   * Run each of the listeners registered on this target for the type of the event.
-   * Listeners which do not apply to the event's phase are skipped, running stops once immediate propagation is stopped,
-   * and listeners added or removed while running do not change which ones run for this event.
-   * @param {EventService} event
-   * @returns {*} true when there was nothing registered, otherwise the last value returned from a handler (null when none ran)
+   * Run the listeners registered on this target for the type of the event which apply to the phase the event is in
+   * (at the target, the capture listeners run before the others). Listeners which are added while this runs do not run
+   * for this event, and listeners which are removed while it runs no longer do. Running stops as soon as immediate
+   * propagation is stopped. A listener which throws does not stop the others.
+   * @param {EventService} event The event, which is at a phase and has a current target
+   * @returns {Array<*>} The errors which the listeners threw
    */
       runEvents (event) {
+        const errors = []
         if (!(event.type in this.listeners)) {
-          return true
+          return errors
         }
-        const listeners = this.listeners[event.type]
-        let eventReturn = null
-        // Work from a copy of the linkers so that removing a listener (for example a once listener) does not disturb the walk
-        for (const linker of Array.from(listeners)) {
-          const listener = linker.data
+        const listeners = Array.from(this.listeners[event.type]).map(linker => linker.data)
+        // At the target the capture listeners come first, otherwise the order is the order they were added
+        const ordered = event.eventPhase === EventService_1.EventService.AT_TARGET ? listeners.filter(listener => listener.capture).concat(listeners.filter(listener => !listener.capture)) : listeners
+        for (const listener of ordered) {
           if (event.inner.immediatePropagationStopped) {
             break
           }
           if (listener.rejectEvent(event)) {
             continue
           }
-          eventReturn = listener.handleEvent(event)
           if (listener.once) {
-            listeners.remove(linker)
+            this.removeListener(event.type, listener)
+          }
+          event.inner.inPassiveListener = listener.passive
+          try {
+            listener.handleEvent(event)
+          } catch (error) {
+            errors.push(error)
           }
+          event.inner.inPassiveListener = false
         }
-        return eventReturn
+        return errors
+      }
+
+      /**
+   * Take a listener out of the registered listeners, so that it does not run again.
+   * @param {string} type
+   * @param {PseudoEventListener} listener
+   */
+      removeListener (type, listener) {
+        listener.removed = true
+        const registered = this.listeners[type]
+        Array.from(registered).filter(linker => linker.data === listener).forEach(linker => registered.remove(linker))
       }
 
       /**
@@ -1180,48 +1268,34 @@
         this.defaultEvent[type] = callback
       }
 
-      runDefaultEvent (event) {
-        if (event.defaultPrevented) {
-          return false
-        }
-        this.defaultEvent[event.type](event)
-        return true
-      }
-
-      startEvents (eventType) {
-        const event = new EventService_1.EventService(eventType)
-        event.inner.target = this;
-        [EventService_1.EventService.CAPTURING_PHASE, EventService_1.EventService.AT_TARGET, EventService_1.EventService.BUBBLING_PHASE].forEach(phase => {
-          let continueEvents = null
-          if (phase === EventService_1.EventService.AT_TARGET || !event.inner.propagationStopped) {
-            event.inner.eventPhase = phase
-            event.composedPath().forEach(target => {
-              event.inner.currentTarget = target
-              continueEvents = event.currentTarget.runEvents(event)
-            })
-          }
-          if (event.eventPhase === EventService_1.EventService.AT_TARGET && typeof continueEvents !== 'boolean' && this.defaultEvent[eventType]) {
-            this.runDefaultEvent(event)
-          }
-        })
-        return true
-      }
-
+      /**
+   * Registers an event handler of a specific event type. Adding the same handler again for the same type and phase does
+   * nothing, like the DOM.
+   * @param {string} type The type of event to listen for
+   * @param {Function|Object} callback The function to call (or an object with a handleEvent function)
+   * @param {Object|boolean} [useCapture=false] Listen while the event travels down to the target (true), or an object with capture, once and passive
+   */
       addEventListener (type, callback, useCapture = false) {
         let options = {
           capture: false,
           once: false,
           passive: false
         }
-        if (typeof useCapture === 'object') {
+        if (typeof useCapture === 'object' && useCapture !== null) {
           // Originally useCapture was a single boolean flag, later optional other flags can be used
           // Here we take all the given flags from the object and assign them as the options
           options = Object.assign(options, useCapture)
         } else {
-          options.capture = useCapture
+          options.capture = !!useCapture
         }
-        const listener = new PseudoEventListener_1.default(type, options, (callback.handleEvent || callback).bind(this), callback)
         const listeners = this.listenersFor(type)
+        const alreadyAdded = Array.from(listeners).some(linker => linker.data.callback === callback && linker.data.capture === options.capture)
+        if (alreadyAdded) {
+          return
+        }
+        // A function runs with this target as this, an object runs its handleEvent as itself
+        const handler = typeof callback === 'function' ? callback.bind(this) : callback.handleEvent.bind(callback)
+        const listener = new PseudoEventListener_1.default(type, options, handler, callback)
         // Listeners run in the order they were added, except that listeners which are not defaults always come before the defaults
         const firstDefault = Array.from(listeners).find(linker => linker.data.isDefault)
         if (firstDefault && !listener.isDefault) {
@@ -1231,25 +1305,84 @@
         }
       }
 
-      removeEventListener (type, callback) {
+      /**
+   * Removes an event listener, the one which was added with the same type, handler and phase.
+   * @param {string} type The type of event
+   * @param {Function|Object} callback The handler which was added
+   * @param {Object|boolean} [options=false] Whether the listener was a capture listener (true), or an object with capture
+   */
+      removeEventListener (type, callback, options = false) {
         if (!(type in this.listeners)) {
           return
         }
-        const listeners = this.listeners[type]
-        Array.from(listeners).filter(linker => !linker.data.isDefault && linker.data.callback === callback).forEach(linker => listeners.remove(linker))
+        const capture = typeof options === 'object' && options !== null ? !!options.capture : !!options
+        Array.from(this.listeners[type]).map(linker => linker.data).filter(listener => !listener.isDefault && listener.callback === callback && listener.capture === capture).forEach(listener => this.removeListener(type, listener))
       }
 
-      dispatchEvent (event, target = this) {
-        event.inner.target = target
-        if (!(event.type in this.listeners)) {
-          return true
+      /**
+   * Dispatches an event to this target and through the tree: capture listeners of the ancestors from the root down,
+   * then the listeners of this target, then (when the event bubbles) the other listeners of the ancestors from the
+   * parent up to the root. stopPropagation() stops it reaching further targets, stopImmediatePropagation() also stops
+   * the remaining listeners of the current target. Afterwards, unless the default was prevented, the default action
+   * of this target (see setDefaultEvent) runs. The event can be dispatched again afterwards.
+   * @param {EventService} event The event to dispatch
+   * @returns {boolean} False when the event was cancelable and a listener prevented the default, otherwise true
+   * @throws {Error} When the event is already being dispatched, or (after the whole dispatch has finished) the error
+   * which a listener threw (an error with all of them in its errors property when several did)
+   */
+      dispatchEvent (event) {
+        if (event.inner.dispatching) {
+          throw new Error('The event is already being dispatched.')
+        }
+        event.inner.dispatching = true
+        event.inner.target = this
+        // The ancestors, the root first, which can have listeners
+        const ancestors = (0, getParentNodes_1.default)(this).filter(node => node instanceof EventTargetService)
+        event.inner.path = [this].concat(ancestors.slice().reverse())
+        const errors = []
+        const visit = (target, phase) => {
+          event.inner.eventPhase = phase
+          event.inner.currentTarget = target
+          errors.push(...target.runEvents(event))
+        }
+        for (const ancestor of ancestors) {
+          if (event.inner.propagationStopped) {
+            break
+          }
+          visit(ancestor, EventService_1.EventService.CAPTURING_PHASE)
+        }
+        if (!event.inner.propagationStopped) {
+          visit(this, EventService_1.EventService.AT_TARGET)
+        }
+        if (event.bubbles) {
+          for (const ancestor of ancestors.slice().reverse()) {
+            if (event.inner.propagationStopped) {
+              break
+            }
+            visit(ancestor, EventService_1.EventService.BUBBLING_PHASE)
+          }
+        }
+        event.inner.finishDispatch()
+        if (!event.defaultPrevented && typeof this.defaultEvent[event.type] === 'function') {
+          try {
+            this.defaultEvent[event.type](event)
+          } catch (error) {
+            errors.push(error)
+          }
+        }
+        if (errors.length === 1) {
+          throw errors[0]
+        }
+        if (errors.length > 1) {
+          throw Object.assign(new Error(`${errors.length} listeners threw an error while dispatching the ${event.type} event.`), {
+            errors
+          })
         }
-        this.runEvents(event)
         return !event.defaultPrevented
       }
     }
     exports.default = EventTargetService
-  }, { '../classes/PseudoEventListener': 1, './EventService': 12, 'collect-your-stuff/dist/collections/linked-list/LinkedList': 21, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.filter.js': 131, 'core-js/modules/esnext.iterator.find.js': 132, 'core-js/modules/esnext.iterator.for-each.js': 133 }],
+  }, { '../classes/PseudoEventListener': 1, '../functions/getParentNodes': 6, './EventService': 12, 'collect-your-stuff/dist/collections/linked-list/LinkedList': 21, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.filter.js': 131, 'core-js/modules/esnext.iterator.find.js': 132, 'core-js/modules/esnext.iterator.for-each.js': 133, 'core-js/modules/esnext.iterator.map.js': 134, 'core-js/modules/esnext.iterator.some.js': 136 }],
   14: [function (require, module, exports) {
     'use strict'
 
@@ -1402,8 +1535,6 @@
   16: [function (require, module, exports) {
     'use strict'
 
-    require('core-js/modules/esnext.iterator.constructor.js')
-    require('core-js/modules/esnext.iterator.for-each.js')
     const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
       return mod && mod.__esModule
         ? mod
@@ -1421,6 +1552,7 @@
  * @version 1.0.0
  */
     const generateNodeList_1 = __importDefault(require('../factories/generateNodeList'))
+    const TreeLinker_1 = require('collect-your-stuff/dist/collections/linked-tree-list/TreeLinker')
     const EventTargetService_1 = __importDefault(require('./EventTargetService'))
     /**
  * Simulate the behaviour of the Node Class when there is no DOM available.
@@ -1443,8 +1575,7 @@
         this.nodeNameValue = ''
         this.children = (0, generateNodeList_1.default)()
         this.parent = null
-        this.next = null
-        this.prev = null
+        this.listLinker = null
       }
 
       get baseURI () {
@@ -1468,7 +1599,7 @@
       }
 
       get nextSibling () {
-        return this.isConnected ? this.next : null
+        return this.listLinker && this.listLinker.next ? this.listLinker.next.data : null
       }
 
       get nodeName () {
@@ -1500,7 +1631,7 @@
       }
 
       get previousSibling () {
-        return this.isConnected ? this.prev : null
+        return this.listLinker && this.listLinker.prev ? this.listLinker.prev.data : null
       }
 
       get textContent () {
@@ -1512,15 +1643,20 @@
       }
 
       /**
-   *
-   * @param {PseudoNode} childNode
-   * @returns {PseudoNode}
+   * Add a node as the last child of this node (a node which is already in a tree is moved).
+   * @param {PseudoNode} childNode The node to add
+   * @returns {PseudoNode} The added node
    */
       appendChild (childNode) {
-        this.children.append(childNode)
-        return childNode
+        return this.insertBefore(childNode, null)
       }
 
+      /**
+   * 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.
+   * @param {NodeService} child The node which was inserted
+   */
+      childInserted (child) {}
       /**
    * Not implemented yet.
    * @throws {Error}
@@ -1538,11 +1674,19 @@
       }
 
       /**
-   * Not implemented yet.
-   * @throws {Error}
+   * Check whether a node is this node or one of its descendants.
+   * @param {PseudoNode|null} otherNode The node to look for
+   * @returns {boolean}
    */
       contains (otherNode) {
-        throw new Error('NodeService.contains() is not implemented yet.')
+        let current = otherNode
+        while (current) {
+          if (current === this) {
+            return true
+          }
+          current = current.parentNode
+        }
+        return false
       }
 
       getRootNode (options = {
@@ -1556,11 +1700,44 @@
       }
 
       /**
-   * Not implemented yet.
-   * @throws {Error}
+   * 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.
+   * @param {PseudoNode} newNode The node to insert
+   * @param {PseudoNode|null} [referenceNode=null] The child of this node to insert before, or null to insert at the end
+   * @returns {PseudoNode} The inserted node
+   * @throws {Error} When the reference node is not a child of this node, or the new node is this node or contains it
    */
-      insertBefore (newNode, referenceNode) {
-        throw new Error('NodeService.insertBefore() is not implemented yet.')
+      insertBefore (newNode, referenceNode = null) {
+        if (referenceNode !== null && referenceNode.parentNode !== this) {
+          throw new Error('The node before which the new node is to be inserted is not a child of this node.')
+        }
+        if (newNode === referenceNode) {
+          // Inserting a node before itself leaves it where it is
+          return newNode
+        }
+        if (typeof newNode.contains === 'function' && newNode.contains(this)) {
+          throw new Error('The new node cannot be inserted into itself or one of its own descendants.')
+        }
+        if (newNode.nodeType === NodeService.DOCUMENT_FRAGMENT_NODE) {
+          // The children of a fragment are inserted (moved) in order, and the fragment is left empty
+          while (newNode.firstChild) {
+            this.insertBefore(newNode.firstChild, referenceNode)
+          }
+          return newNode
+        }
+        if (newNode.parentNode) {
+          // A node can only be in one place, so it is moved from where it was
+          newNode.parentNode.removeChild(newNode)
+        }
+        const linker = new TreeLinker_1.TreeLinker({
+          data: newNode
+        })
+        this.children.insertBefore(referenceNode ? referenceNode.listLinker : null, linker)
+        const inserted = newNode
+        inserted.parent = this
+        inserted.listLinker = linker
+        this.childInserted(inserted)
+        return newNode
       }
 
       isDefaultNamespace (namespaceURI) {
@@ -1589,31 +1766,44 @@
 
       normalize () {}
       /**
-   * Remove the given child from this node.
-   * @param {PseudoNode} childElement The child node, or its TreeLinker from the children list
-   * @returns {PseudoNode}
+   * Remove a child from this node, it no longer has a parent or siblings afterwards.
+   * @param {PseudoNode} childElement The child node to remove
+   * @returns {PseudoNode} The removed node
    * @throws {Error} When the node is not a child of this node
    */
       removeChild (childElement) {
-        let found = null
-        this.children.forEach(linker => {
-          if (found === null && (linker === childElement || linker.data === childElement)) {
-            found = linker
-          }
-        })
-        if (found === null) {
+        if (!childElement || childElement.parentNode !== this) {
           throw new Error('The node to be removed is not a child of this node.')
         }
-        this.children.remove(found)
-        return found.data
+        const removed = childElement
+        this.children.remove(removed.listLinker)
+        removed.parent = null
+        removed.listLinker = null
+        return childElement
       }
 
       /**
-   * Not implemented yet.
-   * @throws {Error}
+   * Replace a child of this node with another node (which is moved if it is already in a tree).
+   * @param {PseudoNode} newChild The node which takes the place
+   * @param {PseudoNode} oldChild The child of this node to replace
+   * @returns {PseudoNode} The replaced node
+   * @throws {Error} When the old node is not a child of this node
    */
       replaceChild (newChild, oldChild) {
-        throw new Error('NodeService.replaceChild() is not implemented yet.')
+        if (!oldChild || oldChild.parentNode !== this) {
+          throw new Error('The node to be replaced is not a child of this node.')
+        }
+        if (newChild === oldChild) {
+          return oldChild
+        }
+        // The new node goes where the old one was, which is before the old node's next sibling (unless that is the new node)
+        let reference = oldChild.nextSibling
+        if (reference === newChild) {
+          reference = newChild.nextSibling
+        }
+        this.removeChild(oldChild)
+        this.insertBefore(newChild, reference)
+        return oldChild
       }
     }
     exports.NodeService = NodeService
@@ -1630,7 +1820,7 @@
     NodeService.DOCUMENT_TYPE_NODE = 10
     NodeService.DOCUMENT_FRAGMENT_NODE = 11
     NodeService.NOTATION_NODE = 12
-  }, { '../factories/generateNodeList': 5, './EventTargetService': 13, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 133 }],
+  }, { '../factories/generateNodeList': 5, './EventTargetService': 13, 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker': 24 }],
   17: [function (require, module, exports) {
     'use strict'
 
@@ -1649,7 +1839,9 @@
    * @param {*} [data=null] The data to be stored in this element.
    */
       constructor (data = null) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = ArrayElement
+        /** The data stored in this element. */
         this.data = null
         this.data = data
       }
@@ -1662,8 +1854,8 @@
  */
     exports.ArrayElement = ArrayElement
     ArrayElement.make = (element, classType = ArrayElement) => {
-      if (typeof element !== 'object') {
-        // It is not an object, so instantiate the Element with element as the data
+      if (element === null || typeof element !== 'object') {
+        // It is not an object (or it is null), so instantiate the Element with element as the data
         return new classType(element)
       }
       if (element.classType) {
@@ -1719,14 +1911,32 @@
     class Arrayable {
       /**
    * Create the new Arrayable instance, configure the Arrayable class.
+   * @param {ArrayElement} [elementClass=ArrayElement] The class used to wrap given data as elements.
    */
       constructor (elementClass = _ArrayElement.ArrayElement) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = Arrayable
+        /** The array which stores the elements of this Arrayable. */
         this.innerList = []
+        /** Whether the inner list has been initialized (it can only be initialized once). */
         this.initialized = false
         this.elementClass = elementClass
       }
 
+      /**
+   * Find the position of an element which must be in this list.
+   * @param {ArrayElement} node The element to find
+   * @returns {number}
+   * @throws {Error} When the element is not in this list
+   */
+      indexOfElement (node) {
+        const index = this.innerList.indexOf(node)
+        if (index < 0) {
+          throw new Error('The reference element is not in this list.')
+        }
+        return index
+      }
+
       /**
    * Initialize the inner list, should only run once.
    * @param {Array<ArrayElement>} initialList Give the array of elements to start in this Arrayable.
@@ -1743,7 +1953,7 @@
       }
 
       /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {Array<ArrayElement>}
    */
       get list () {
@@ -1752,18 +1962,18 @@
 
       /**
    * Retrieve the first Element from the Arrayable
-   * @returns {ArrayElement}
+   * @returns {ArrayElement|null} The first element, or null when the Arrayable is empty
    */
       get first () {
-        return this.innerList[0]
+        return this.length ? this.innerList[0] : null
       }
 
       /**
    * Retrieve the last Element from the Arrayable
-   * @returns {ArrayElement}
+   * @returns {ArrayElement|null} The last element, or null when the Arrayable is empty
    */
       get last () {
-        return this.innerList[this.length - 1]
+        return this.length ? this.innerList[this.length - 1] : null
       }
 
       /**
@@ -1776,25 +1986,29 @@
 
       /**
    * Insert a new node (or data) after a node.
-   * @param {ArrayElement|*} node The existing node as reference
+   * @param {ArrayElement|null} node The existing node as reference, or null to insert at the start of the list
    * @param {ArrayElement|*} newNode The new node to go after the existing node
    * @returns {Arrayable}
+   * @throws {Error} When the reference node is not in this list
    */
       insertAfter (node, newNode) {
-        const insertAt = this.innerList.indexOf(node)
-        this.innerList.splice(insertAt + 1, 0, this.elementClass.make(newNode))
+        // With no reference element, the new one goes after nothing: at the start of the list
+        const insertAt = node === null || typeof node === 'undefined' ? -1 : this.indexOfElement(node)
+        this.innerList.splice(insertAt + 1, 0, this.elementClass.make(newNode, this.elementClass))
         return this
       }
 
       /**
    * Insert a new node (or data) before a node.
-   * @param {ArrayElement|*} node The existing node as reference
+   * @param {ArrayElement|null} node The existing node as reference, or null to insert at the end of the list
    * @param {ArrayElement|*} newNode The new node to go before the existing node
    * @returns {Arrayable}
+   * @throws {Error} When the reference node is not in this list
    */
       insertBefore (node, newNode) {
-        const insertAt = this.innerList.indexOf(node)
-        this.innerList.splice(insertAt, 0, this.elementClass.make(newNode))
+        // With no reference element, the new one goes before nothing: at the end of the list
+        const insertAt = node === null || typeof node === 'undefined' ? this.length : this.indexOfElement(node)
+        this.innerList.splice(insertAt, 0, this.elementClass.make(newNode, this.elementClass))
         return this
       }
 
@@ -1805,6 +2019,11 @@
    * @returns {Arrayable}
    */
       append (node, after = this.last) {
+        if (after === this.last) {
+          // Adding to the end does not need to search for where that is
+          this.innerList.push(this.elementClass.make(node, this.elementClass))
+          return this
+        }
         return this.insertAfter(after, node)
       }
 
@@ -1815,16 +2034,24 @@
    * @returns {Arrayable}
    */
       prepend (node, before = this.first) {
+        if (before === this.first) {
+          // Adding to the start does not need to search for where that is
+          this.innerList.unshift(this.elementClass.make(node, this.elementClass))
+          return this
+        }
         return this.insertBefore(before, node)
       }
 
       /**
    * Remove an element from this arrayable.
    * @param {ArrayElement} node The node we wish to remove (and it will be returned after removal)
-   * @return {ArrayElement}
+   * @return {ArrayElement|null} The removed node, or null when it was not in this list (nothing is removed)
    */
       remove (node) {
         const deleteAt = this.innerList.indexOf(node)
+        if (deleteAt < 0) {
+          return null
+        }
         this.innerList.splice(deleteAt, 1)
         return node
       }
@@ -1904,7 +2131,7 @@
     class DoubleLinker {
       /**
    * Create the new DoubleLinker instance, provide the data and optionally the next and prev references.
-   * @param {Object} [nodeData={}]
+   * @param {Object} [nodeData={}] The settings for the new linker.
    * @param {*} [nodeData.data=null] The data to be stored in this linker
    * @param {DoubleLinker|null} [nodeData.next=null] The reference to the next linker if any
    * @param {DoubleLinker|null} [nodeData.prev=null] The reference to the previous linker if any
@@ -1914,9 +2141,13 @@
         next = null,
         prev = null
       } = {}) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = DoubleLinker
+        /** The data stored in this linker. */
         this.data = null
+        /** The linker after this one, or null when this is the last. */
         this.next = null
+        /** The linker before this one, or null when this is the first. */
         this.prev = null
         this.data = data
         this.next = next
@@ -1984,11 +2215,19 @@
     class DoublyLinkedList {
       /**
    * Create the new DoublyLinkedList instance.
+   * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
    */
       constructor (linkerClass = _DoubleLinker.DoubleLinker) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = DoublyLinkedList
+        /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
         this.innerList = null
+        /** Whether the inner list has been initialized (it can only be initialized once). */
         this.initialized = false
+        /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+        this.tailCache = null
+        /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+        this.countCache = null
         this.linkerClass = linkerClass
       }
 
@@ -1998,11 +2237,12 @@
    * @return {DoublyLinkedList}
    */
       initialize (initialList) {
+        // Borrowed from LinkedList, which types its return as a LinkedList although it returns whatever list called it
         return _LinkedList.LinkedList.prototype.initialize.call(this, initialList)
       }
 
       /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {DoubleLinker}
    */
       get list () {
@@ -2014,91 +2254,122 @@
    * @returns {DoubleLinker}
    */
       get first () {
-        return this.reset()
+        let head = this.innerList
+        if (head === null) {
+          return null
+        }
+        // innerList is normally the head already, walking back also finds anything linked on before it outside of this list
+        while (head.prev !== null) {
+          head = head.prev
+        }
+        this.innerList = head
+        return head
       }
 
       /**
-   * Retrieve the last DoubleLinker in the list.
+   * Retrieve the last DoubleLinker in the list. The end is remembered, so this does not walk the list.
    * @returns {DoubleLinker}
    */
       get last () {
-        let tail = this.innerList
-        if (tail === null) {
+        if (this.innerList === null) {
           return null
         }
-        let next = tail.next
-        while (next !== null) {
-          tail = next
-          next = tail.next
+        let tail = this.tailCache !== null ? this.tailCache : this.innerList
+        // The remembered tail is normally the end already, walking on from it also finds anything linked on outside of this list
+        while (tail.next !== null) {
+          tail = tail.next
         }
+        this.tailCache = tail
         return tail
       }
 
       /**
-   * Return the length of the list.
+   * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
+   * (call reset() after linkers were changed directly).
    * @returns {number}
    */
       get length () {
-        let current = this.first
-        let length = 0
-        while (current !== null) {
-          ++length
-          current = current.next
+        if (this.countCache === null) {
+          this.reset()
         }
-        return length
+        return this.countCache
       }
 
       /**
    * Insert a new node (or data) after a node.
-   * @param {DoubleLinker|*} node The existing node as reference
+   * @param {DoubleLinker|*} node The existing node as reference (which must be in this list, this is not checked), or null to insert at the start of the list
    * @param {DoubleLinker|*} newNode The new node to go after the existing node
    * @returns {DoublyLinkedList}
    */
       insertAfter (node, newNode) {
-        newNode = this.linkerClass.make(newNode)
-        if (node !== null) {
+        newNode = this.linkerClass.make(newNode, this.linkerClass)
+        if (node === null || typeof node === 'undefined') {
+          // After nothing means at the start of the list
+          const head = this.first
+          newNode.prev = null
+          newNode.next = head
+          if (head) {
+            head.prev = newNode
+          } else {
+            this.tailCache = newNode
+          }
+          this.innerList = newNode
+        } else {
           // Ensure the next reference of this node is assigned to the new node
           newNode.next = node.next
           // Ensure this node is assigned as the prev reference of the new node
           newNode.prev = node
           // Then set this node's next reference to the new node
           node.next = newNode
+          if (newNode.next) {
+            // Update the next reference to ensure circular reference for prev points to the new node
+            newNode.next.prev = newNode
+          } else {
+            this.tailCache = newNode
+          }
         }
-        if (newNode.next) {
-          // Update the next reference to ensure circular reference for prev points to the new node
-          newNode.next.prev = newNode
-        }
-        if (!this.length) {
-          this.innerList = newNode
+        if (this.countCache !== null) {
+          ++this.countCache
         }
-        this.reset()
         return this
       }
 
       /**
    * Insert a new node (or data) before a node.
-   * @param {DoubleLinker|*} node The existing node as reference
+   * @param {DoubleLinker|*} node The existing node as reference (which must be in this list, this is not checked), or null to insert at the end of the list
    * @param {DoubleLinker|*} newNode The new node to go before the existing node
    * @returns {DoublyLinkedList}
    */
       insertBefore (node, newNode) {
-        newNode = this.linkerClass.make(newNode)
-        if (node !== null) {
+        newNode = this.linkerClass.make(newNode, this.linkerClass)
+        if (node === null || typeof node === 'undefined') {
+          // Before nothing means at the end of the list
+          const tail = this.last
+          newNode.next = null
+          newNode.prev = tail
+          if (tail === null) {
+            this.innerList = newNode
+          } else {
+            tail.next = newNode
+          }
+          this.tailCache = newNode
+        } else {
           // The new node will reference this prev node as prev
           newNode.prev = node.prev
           // The new node will reference this node as next
           newNode.next = node
           // This prev will reference the new node
           node.prev = newNode
+          if (newNode.prev) {
+            // Update the prev reference to ensure circular reference for next points to the new node
+            newNode.prev.next = newNode
+          } else {
+            this.innerList = newNode
+          }
         }
-        if (newNode.prev) {
-          // Update the prev reference to ensure circular reference for next points to the new node
-          newNode.prev.next = newNode
+        if (this.countCache !== null) {
+          ++this.countCache
         }
-        if (!this.length) {
-          this.innerList = newNode
-        }
-        this.reset()
         return this
       }
 
@@ -2128,7 +2399,7 @@
    * @return {DoubleLinker}
    */
       remove (node) {
-        if (node === null) {
+        if (node === null || typeof node === 'undefined') {
           return null
         }
         if (node.prev) {
@@ -2144,35 +2415,47 @@
         if (this.innerList === node) {
           this.innerList = node.next || node.prev || null
         }
-        // Update head reference
-        this.reset()
+        if (this.tailCache === node) {
+          this.tailCache = node.prev
+        }
+        if (this.innerList === null) {
+          this.tailCache = null
+        }
+        if (this.countCache !== null) {
+          --this.countCache
+        }
         return node
       }
 
       /**
-   * Refresh all references and return head reference.
-   * @return {DoubleLinker}
+   * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The list's
+   * own methods keep these up to date, so this is only needed after linkers were changed directly.
+   * @return {DoubleLinker|null}
    */
       reset () {
         // Start at the pointer for the list
         let pointer = this.innerList
         if (pointer === null) {
+          this.countCache = 0
+          this.tailCache = null
           return null
         }
-        let next = pointer.next
-        // Follow references till the end
-        while (next !== null) {
-          pointer = next
-          next = pointer.next
+        // Follow references back to the beginning
+        while (pointer.prev !== null) {
+          pointer = pointer.prev
         }
-        let prev = pointer.prev
-        // From final reference, follow references back to the beginning
-        while (prev !== null) {
-          pointer = prev
-          prev = pointer.prev
-        }
-        // All the live references should have been found, and we are pointing to the true head
+        // We are pointing to the true head, now count along to the end to find the tail and the length
         this.innerList = pointer
+        let count = 0
+        let tail = pointer
+        let current = pointer
+        while (current !== null) {
+          ++count
+          tail = current
+          current = current.next
+        }
+        this.countCache = count
+        this.tailCache = tail
         return pointer
       }
 
@@ -2208,6 +2491,7 @@
    * Be able to run forEach on this DoublyLinkedList to iterate over the DoubleLinker Items.
    * @param {forEachCallback} callback The function to call for-each double linker
    * @param {DoublyLinkedList} thisArg Optional, 'this' reference
+   * @return {DoublyLinkedList} The list which was iterated.
    */
       forEach (callback, thisArg = this) {
         return _LinkedList.LinkedList.prototype.forEach.call(this, callback, thisArg)
@@ -2251,11 +2535,19 @@
     class LinkedList {
       /**
    * Create the new LinkedList instance.
+   * @param {Linker} [linkerClass=Linker] The class used to wrap given data as linkers.
    */
       constructor (linkerClass = _Linker.Linker) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = LinkedList
+        /** The first linker of the list (null when the list is empty), from which the whole list is reached. */
         this.innerList = null
+        /** Whether the inner list has been initialized (it can only be initialized once). */
         this.initialized = false
+        /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+        this.tailCache = null
+        /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+        this.countCache = null
         this.linkerClass = linkerClass
       }
 
@@ -2265,11 +2557,12 @@
    * @return {LinkedList}
    */
       initialize (initialList) {
+        // Borrowed from Arrayable, which types its return as an Arrayable although it returns whatever list called it
         return _Arrayable.Arrayable.prototype.initialize.call(this, initialList)
       }
 
       /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {Linker}
    */
       get list () {
@@ -2285,78 +2578,100 @@
       }
 
       /**
-   * Retrieve the last Linker in the list.
+   * Retrieve the last Linker in the list. The end is remembered, so this does not walk the list.
    * @returns {Linker}
    */
       get last () {
-        let tail = this.innerList
-        if (tail === null) {
+        if (this.innerList === null) {
           return null
         }
-        let next = tail.next
-        while (next !== null) {
-          tail = next
-          next = tail.next
+        let tail = this.tailCache !== null ? this.tailCache : this.innerList
+        // The remembered tail is normally the end already, walking on from it also finds anything linked on outside of this list
+        while (tail.next !== null) {
+          tail = tail.next
         }
+        this.tailCache = tail
         return tail
       }
 
       /**
-   * Return the length of the list.
+   * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
+   * (call reset() after linkers were changed directly).
    * @returns {number}
    */
       get length () {
-        let current = this.first
-        let length = 0
-        while (current !== null) {
-          ++length
-          current = current.next
+        if (this.countCache === null) {
+          this.reset()
         }
-        return length
+        return this.countCache
       }
 
       /**
    * Insert a new node (or data) after a node.
-   * @param {Linker|*} node The existing node as reference
+   * @param {Linker|*} node The existing node as reference, or null to insert at the start of the list
    * @param {Linker|*} newNode The new node to go after the existing node
    * @returns {LinkedList}
    */
       insertAfter (node, newNode) {
-        newNode = this.linkerClass.make(newNode)
-        if (node !== null) {
-          // Ensure the next reference of this node is assigned to the new node
+        newNode = this.linkerClass.make(newNode, this.linkerClass)
+        if (node === null || typeof node === 'undefined') {
+          // After nothing means at the start of the list
+          newNode.next = this.innerList
+          if (this.innerList === null) {
+            this.tailCache = newNode
+          }
+          this.innerList = newNode
+        } else {
           newNode.next = node.next
-          // Then set this node's next reference to the new node
           node.next = newNode
+          if (newNode.next === null) {
+            this.tailCache = newNode
+          }
         }
-        if (!this.length) {
-          this.innerList = newNode
+        if (this.countCache !== null) {
+          ++this.countCache
         }
         return this
       }
 
       /**
    * Insert a new node (or data) before a node.
-   * @param {Linker|*} node The existing node as reference
+   * @param {Linker|*} node The existing node as reference, or null to insert at the end of the list
    * @param {Linker|*} newNode The new node to go before the existing node
    * @returns {LinkedList}
+   * @throws {Error} When the reference node is not in this list
    */
       insertBefore (node, newNode) {
-        newNode = this.linkerClass.make(newNode)
-        let prevNode = null
-        let currentNode = this.first
-        while (currentNode !== node) {
-          prevNode = currentNode
-          currentNode = currentNode.next
-        }
-        // The new node will reference this node as next
-        newNode.next = node
-        if (prevNode) {
-          // Ensure the next reference of the previous node is assigned to the new node
-          prevNode.next = newNode
+        newNode = this.linkerClass.make(newNode, this.linkerClass)
+        if (node === null || typeof node === 'undefined') {
+          // Before nothing means at the end of the list
+          const tail = this.last
+          newNode.next = null
+          if (tail === null) {
+            this.innerList = newNode
+          } else {
+            tail.next = newNode
+          }
+          this.tailCache = newNode
+        } else {
+          let prevNode = null
+          let currentNode = this.first
+          while (currentNode !== null && currentNode !== node) {
+            prevNode = currentNode
+            currentNode = currentNode.next
+          }
+          if (currentNode === null) {
+            throw new Error('The reference node is not in this list.')
+          }
+          newNode.next = node
+          if (prevNode) {
+            prevNode.next = newNode
+          } else {
+            this.innerList = newNode
+          }
         }
-        if (node === this.first || node === null) {
-          this.innerList = newNode
+        if (this.countCache !== null) {
+          ++this.countCache
         }
         return this
       }
@@ -2384,26 +2699,58 @@
       /**
    * Remove a linker from this linked list.
    * @param {Linker} node The node we wish to remove (and it will be returned after removal)
-   * @return {Linker}
+   * @return {Linker|null} The removed node, or null when it was not in this list (nothing is removed)
    */
       remove (node) {
+        if (node === null || typeof node === 'undefined') {
+          return null
+        }
         let prevNode = null
         let currentNode = this.first
-        while (currentNode !== node) {
+        while (currentNode !== null && currentNode !== node) {
           prevNode = currentNode
           currentNode = currentNode.next
         }
+        if (currentNode === null) {
+          // The node is not in this list, so there is nothing to remove
+          return null
+        }
         if (prevNode) {
-          // Ensure the next reference of the previous node skips over the removed node
           prevNode.next = node.next
-        }
-        if (node === this.first && node !== null) {
-          // Update list head to point to next if it was this node
+        } else {
           this.innerList = node.next
         }
+        if (this.tailCache === node) {
+          this.tailCache = prevNode
+        }
+        if (this.innerList === null) {
+          this.tailCache = null
+        }
+        if (this.countCache !== null) {
+          --this.countCache
+        }
         return node
       }
 
+      /**
+   * Refresh the remembered end and length of the list by walking it once. The list's own methods keep these up to date,
+   * so this is only needed after linkers were changed directly (for example by setting next on a linker).
+   * @return {Linker|null} The first linker of the list
+   */
+      reset () {
+        let count = 0
+        let tail = null
+        let current = this.innerList
+        while (current !== null) {
+          ++count
+          tail = current
+          current = current.next
+        }
+        this.countCache = count
+        this.tailCache = tail
+        return this.innerList
+      }
+
       /**
    * Retrieve a Linker item from this list by numeric index, otherwise return null.
    * @param {number} index The integer number for retrieving a node by position.
@@ -2486,7 +2833,7 @@
     class Linker {
       /**
    * Create the new Linker instance, provide the data and optionally give the next Linker.
-   * @param {Object} [nodeData={}]
+   * @param {Object} [nodeData={}] The settings for the new linker.
    * @param {*} [nodeData.data=null] The data to be stored in this linker
    * @param {Linker|null} [nodeData.next=null] The reference to the next linker if any
    */
@@ -2494,8 +2841,11 @@
         data = null,
         next = null
       } = {}) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = Linker
+        /** The data stored in this linker. */
         this.data = null
+        /** The linker after this one, or null when this is the last. */
         this.next = null
         this.data = data
         this.next = next
@@ -2509,8 +2859,8 @@
  */
     exports.Linker = Linker
     Linker.make = (linker, classType = Linker) => {
-      if (typeof linker !== 'object') {
-        // It is not an object, so instantiate the Linker with element as the data
+      if (linker === null || typeof linker !== 'object') {
+        // It is not an object (or it is null), so instantiate the Linker with element as the data
         return new classType({
           data: linker
         })
@@ -2519,7 +2869,8 @@
         // Already valid Linker, return as-is
         return linker
       }
-      if (!linker.data) {
+      if (!('data' in linker)) {
+        // Not the settings for a linker (which would have data, even if it is falsy), so it is the data itself
         linker = {
           data: linker
         }
@@ -2533,7 +2884,7 @@
  * @param {IsLinker} [classType=Linker] Provide the type of IsLinker to use.
  * @returns {{head: Linker, tail: Linker}}
  */
-    Linker.fromArray = (values, classType = Linker) => values.reduce((references, linker) => {
+    Linker.fromArray = (values = [], classType = Linker) => values.reduce((references, linker) => {
       const newLinker = classType.make(linker, classType)
       if (references.head === null) {
         // Initialize the head and tail with the new node
@@ -2558,6 +2909,8 @@
       value: true
     })
     exports.LinkedTreeList = void 0
+    require('core-js/modules/esnext.iterator.constructor.js')
+    require('core-js/modules/esnext.iterator.for-each.js')
     const _TreeLinker = require('./TreeLinker')
     const _TreeLinkerIterator = require('../../recipes/TreeLinkerIterator')
     const _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
@@ -2568,6 +2921,13 @@
  * @memberOf module:collect-your-stuff
  */
 
+    /**
+ * Use one of the accessors of DoublyLinkedList (which keeps track of the head, tail and length) for a LinkedTreeList.
+ * @param {string} name The accessor to use
+ * @param {LinkedTreeList} list The list to use it on
+ * @returns {*}
+ */
+    const borrowedGetter = (name, list) => Object.getOwnPropertyDescriptor(_DoublyLinkedList.DoublyLinkedList.prototype, name).get.call(list)
     /**
  * LinkedTreeList represents a collection stored with a root and spreading in branching (tree) formation.
  * @extends DoublyLinkedList
@@ -2575,11 +2935,21 @@
     class LinkedTreeList {
       /**
    * Create the new LinkedTreeList instance, configure the list class.
+   * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
    */
       constructor (linkerClass = _TreeLinker.TreeLinker) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = LinkedTreeList
+        /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
         this.innerList = null
+        /** Whether the inner list has been initialized (it can only be initialized once). */
         this.initialized = false
+        /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+        this.tailCache = null
+        /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+        this.countCache = null
+        /** The node these linkers are the children of, remembered so that it is known even while the list is empty (undefined until it is known). */
+        this.ownerNode = undefined
         this.linkerClass = linkerClass
       }
 
@@ -2599,7 +2969,7 @@
       }
 
       /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {TreeLinker}
    */
       get list () {
@@ -2611,57 +2981,46 @@
    * @returns {TreeLinker}
    */
       get first () {
-        return this.reset()
+        return borrowedGetter('first', this)
       }
 
       /**
-   * Retrieve the last TreeLinker in the list.
+   * Retrieve the last TreeLinker in the list. The end is remembered, so this does not walk the list.
    * @returns {TreeLinker}
    */
       get last () {
-        let tail = this.innerList
-        if (tail === null) {
-          return null
-        }
-        let next = tail.next
-        while (next !== null) {
-          tail = next
-          next = tail.next
-        }
-        return tail
+        return borrowedGetter('last', this)
       }
 
       /**
-   * Return the length of the list.
+   * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
+   * (call reset() after linkers were changed directly).
    * @returns {number}
    */
       get length () {
-        let current = this.first
-        let length = 0
-        while (current !== null) {
-          ++length
-          current = current.next
-        }
-        return length
+        return borrowedGetter('length', this)
       }
 
       /**
-   * Get the parent of this tree list.
-   * @return {TreeLinker}
+   * Get the parent of this tree list: the node these linkers are the children of (remembered even while the list is
+   * empty), or null for the linkers at the top of a tree.
+   * @return {TreeLinker|null}
    */
       get parent () {
-        const first = this.first
-        if (first === null) {
-          return null
+        if (this.ownerNode !== undefined) {
+          return this.ownerNode
         }
-        return this.first.parent
+        const first = this.first
+        return first === null ? null : first.parent
       }
 
       /**
-   * Set the parent of this tree list
-   * @param {TreeLinker} parent The new node to use as the parent for this group of children
+   * Set the parent of this tree list: every linker in it gets the node as its parent, and the node gets this list as its
+   * children. Linkers added to the list later get this parent too.
+   * @param {TreeLinker|null} parent The new node to use as the parent for this group of children
    */
       set parent (parent) {
+        this.ownerNode = parent
         let current = this.first
         while (current !== null) {
           current.parent = parent
@@ -2691,34 +3050,57 @@
 
       /**
    * Set the children on a parent item.
-   * @param {TreeLinker} item The TreeLinker node that will be the parent of the children
-   * @param {LinkedTreeList} children The LinkedTreeList which has the child nodes to use
+   * @param {TreeLinker} item The TreeLinker node (one of the linkers of this list) that will be the parent of the children
+   * @param {LinkedTreeList|null} [children=null] The LinkedTreeList which has the child nodes to use, or null to remove the children of the item
+   * @throws {Error} When the item is not one of the linkers of this list
    */
       setChildren (item, children = null) {
-        if (Array.from(this).indexOf(item) < 0) {
-          console.error('item is not a child of this')
+        // The item must be one of the linkers of this list (only the siblings are checked, not the whole tree)
+        let isChild = false
+        this.forEach(linker => {
+          if (linker === item) {
+            isChild = true
+          }
+        })
+        if (!isChild) {
+          throw new Error('The item is not one of the linkers of this list.')
+        }
+        if (children === null || typeof children === 'undefined') {
+          item.children = null
+          return
         }
         children.parent = item
       }
 
       /**
-   * Insert a new node (or data) after a node.
-   * @param {TreeLinker|*} node The existing node as reference
+   * Make a linker of the given node (or data) and make this list's parent its parent.
+   * @param {TreeLinker|*} newNode The node (or data) which is being added to this list
+   * @returns {TreeLinker}
+   */
+      adopt (newNode) {
+        const linker = this.linkerClass.make(newNode, this.linkerClass)
+        linker.parent = this.parent
+        return linker
+      }
+
+      /**
+   * Insert a new node (or data) after a node. The new node gets the parent of this list.
+   * @param {TreeLinker|*} node The existing node as reference, or null to insert at the start of the list
    * @param {TreeLinker|*} newNode The new node to go after the existing node
    * @returns {LinkedTreeList}
    */
       insertAfter (node, newNode) {
-        return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this, node, newNode)
+        return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this, node, this.adopt(newNode))
       }
 
       /**
-   * Insert a new node (or data) before a node.
-   * @param {TreeLinker|*} node The existing node as reference
+   * Insert a new node (or data) before a node. The new node gets the parent of this list.
+   * @param {TreeLinker|*} node The existing node as reference, or null to insert at the end of the list
    * @param {TreeLinker|*} newNode The new node to go before the existing node
    * @returns {LinkedTreeList}
    */
       insertBefore (node, newNode) {
-        return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this, node, newNode)
+        return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this, node, this.adopt(newNode))
       }
 
       /**
@@ -2742,16 +3124,24 @@
       }
 
       /**
-   * Remove a linker from this linked list.
+   * Remove a linker from this linked list. The removed node no longer has a parent.
    * @param {TreeLinker} node The node we wish to remove (and it will be returned after removal)
-   * @return {TreeLinker}
+   * @return {TreeLinker|null} The removed node, or null when there was nothing to remove
    */
       remove (node) {
-        return _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this, node)
+        const owner = this.parent
+        const removed = _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this, node)
+        if (removed && removed.parent === owner) {
+          // Remember whose children these are (the list may now be empty), the removed node no longer has that parent
+          this.ownerNode = owner
+          removed.parent = null
+        }
+        return removed
       }
 
       /**
-   * Refresh all references and return head reference.
+   * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The
+   * list's own methods keep these up to date, so this is only needed after linkers were changed directly.
    * @return {TreeLinker}
    */
       reset () {
@@ -2771,6 +3161,7 @@
    * Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Items.
    * @param {forEachCallback} callback The function to call for-each tree node
    * @param {LinkedTreeList} thisArg Optional, 'this' reference
+   * @return {LinkedTreeList} The list which was iterated.
    */
       forEach (callback, thisArg = this) {
         let index = 0
@@ -2784,12 +3175,14 @@
       }
 
       /**
-   * Be able to iterate over this class.
+   * Be able to iterate over this class: the linkers of this list and everything below them (left-first). It stays within
+   * this list (it does not start at, or climb up to, the parents), use the parseTree service to parse a whole tree.
    * @returns {Iterator}
    */
       [Symbol.iterator] () {
-        const root = this.rootParent
-        return new _TreeLinkerIterator.TreeLinkerIterator(root)
+        // The linkers of this list and everything below them, left-first. It stays within this list: it does not start at,
+        // or climb up to, the parents (use the parseTree service to parse a whole tree)
+        return new _TreeLinkerIterator.TreeLinkerIterator(this.first, this.parent)
       }
     }
     /**
@@ -2804,7 +3197,7 @@
       const list = new classType(linkerClass)
       return list.initialize(linkerClass.fromArray(values).head)
     }
-  }, { '../../recipes/TreeLinkerIterator': 28, '../doubly-linked-list/DoublyLinkedList': 20, './TreeLinker': 24 }],
+  }, { '../../recipes/TreeLinkerIterator': 28, '../doubly-linked-list/DoublyLinkedList': 20, './TreeLinker': 24, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 133 }],
   24: [function (require, module, exports) {
     'use strict'
 
@@ -2823,7 +3216,7 @@
     class TreeLinker {
       /**
    * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-   * @param {Object} [settings={}]
+   * @param {Object} [settings={}] The settings for the new tree node.
    * @param {*} [settings.data=null] The data to be stored in this tree node
    * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
    * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any
@@ -2839,11 +3232,17 @@
         parent = null,
         listClass = _LinkedTreeList.LinkedTreeList
       } = {}) {
+        /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
         this.classType = TreeLinker
+        /** The data stored in this tree node. */
         this.data = null
+        /** The sibling after this node, or null when this is the last child. */
         this.next = null
+        /** The sibling before this node, or null when this is the first child. */
         this.prev = null
+        /** The node this node is a child of, or null for a root node. */
         this.parent = null
+        /** The list of the children of this node, or null when it has none. */
         this.children = null
         this.data = data
         this.next = next
@@ -2853,7 +3252,9 @@
       }
 
       /**
-   * Create the children for this tree from an array.
+   * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
+   * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
+   * else is the data of the linker.
    * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
    * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
    * @return {LinkedTreeList|null}
@@ -2862,10 +3263,17 @@
         if (children === null) {
           return null
         }
-        // Creates a linked-tree-list to store the children.
-        return listClass.fromArray(children.map(child => Object.assign({}, child, {
-          parent: this
-        })), this.classType)
+        // Every child is made into a tree linker (an existing one is kept as it is, and a plain value is the data) and is
+        // given this node as its parent
+        const nodes = children.map(child => {
+          const linker = this.classType.make(child, this.classType)
+          linker.parent = this
+          return linker
+        })
+        // Creates a linked-tree-list to store the children, which remembers this node as its parent even when it is empty
+        const list = listClass.fromArray(nodes, this.classType)
+        list.parent = this
+        return list
       }
     }
     /**
@@ -2897,11 +3305,21 @@
  * Class ArrayIterator returns the next value when using elements of array type list.
  */
     class ArrayIterator {
+      /**
+   * Create an iterator over the given array.
+   * @param {Array<IsElement>} innerList The elements to iterate over.
+   * @param {number} [index=0] The position to start from.
+   */
       constructor (innerList, index = 0) {
         this.innerList = innerList
         this.index = index
       }
 
+      /**
+   * Get the next element, moving the iterator forward.
+   * @param {*} [value] Not used, present to match the Iterator interface.
+   * @return {IteratorResult<IsElement>} The next element, or done when there are no more.
+   */
       next (value) {
         if (this.index < this.innerList.length) {
           return {
@@ -2928,10 +3346,19 @@
  * Class DoubleLinkerIterator returns the next value when using linkers of linked type lists.
  */
     class DoubleLinkerIterator {
+      /**
+   * Create an iterator starting at the given item.
+   * @param {IsDoubleLinker} current The item to start from.
+   */
       constructor (current) {
         this.current = current
       }
 
+      /**
+   * Get the current item and move on to the following one.
+   * @param {*} [value] Not used, present to match the Iterator interface.
+   * @return {IteratorResult<IsDoubleLinker>} The current item, or done when there are no more.
+   */
       next (value) {
         const result = {
           value: this.current,
@@ -2954,10 +3381,19 @@
  * Class LinkerIterator returns the next value when using linkers of linked type lists.
  */
     class LinkerIterator {
+      /**
+   * Create an iterator starting at the given item.
+   * @param {IsLinker} current The item to start from.
+   */
       constructor (current) {
         this.current = current
       }
 
+      /**
+   * Get the current item and move on to the following one.
+   * @param {*} [value] Not used, present to match the Iterator interface.
+   * @return {IteratorResult<IsLinker>} The current item, or done when there are no more.
+   */
       next (value) {
         const result = {
           value: this.current,
@@ -2981,16 +3417,27 @@
  * Class TreeLinkerIterator returns the next value taking a left-first approach down a tree.
  */
     class TreeLinkerIterator {
-      constructor (current) {
+      /**
+   * Create an iterator starting at the given item.
+   * @param {IsTreeNode} current The item to start from.
+   * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within (null for the top of a tree), the whole tree when not given.
+   */
+      constructor (current, boundaryParent) {
         this.current = current
+        this.boundaryParent = boundaryParent
       }
 
+      /**
+   * Get the current item and move on to the following one (left-first, down each branch).
+   * @param {*} [value] Not used, present to match the Iterator interface.
+   * @return {IteratorResult<IsTreeNode>} The current item, or done when there are no more.
+   */
       next (value) {
         const result = {
           value: this.current,
           done: !this.current
         }
-        this.current = (0, _parseTreeNext.parseTreeNext)(this.current)
+        this.current = (0, _parseTreeNext.parseTreeNext)(this.current, this.boundaryParent)
         return result
       }
     }
@@ -3012,36 +3459,31 @@
  * 5. Repeat 3
  * 6. If no next child, return to parent and repeat 3
  * 7. Stop at root (next is null and parent is null
+ * A boundary can be given to parse only part of a tree: going back up to the parents stops at the boundary, so the
+ * parsing stays within the nodes whose parent is the boundary (and everything below them).
  * @param {IsTreeNode} treeNode Provide a node in a tree and get the next node (left-first approach)
+ * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within, null for the nodes at the top of a tree. When it is not given the whole tree is parsed.
  * @returns {IsTreeNode|null}
  */
-    const parseTreeNext = treeNode => {
+    const parseTreeNext = (treeNode, boundaryParent) => {
       if (!treeNode) {
         return null
       }
-      let test = null
       if (treeNode.children && treeNode.children.length) {
-        // Go down the left side of the tree
-        test = treeNode.children.first
-      }
-      if (!test) {
-        // Reached the bottom, go the next node on the right
-        test = treeNode.next
-      }
-      if (!test && treeNode.parent) {
-        // No more child nodes, return to parent and check parent sibling on the right
-        let parentNext = treeNode.parent.next
-        let parent = treeNode.parent
-        while (parent && !parentNext) {
-          parentNext = parent.next
-          // Keep checking parent next, until there are no more parents, or we find the parent sibling
-          parent = parent.parent
-        }
-        // This may be the parent sibling, or it could be null indicating we are done
-        test = parentNext
-      }
-      // Finally, either use the node we found, or it may be null
-      return test
+        return treeNode.children.first
+      }
+      if (treeNode.next) {
+        return treeNode.next
+      }
+      // Nothing more below or beside this node, so go back up until there is a node which has a next (or the boundary)
+      let parent = treeNode.parent
+      while (parent && parent !== boundaryParent) {
+        if (parent.next) {
+          return parent.next
+        }
+        parent = parent.parent
+      }
+      return null
     }
     exports.parseTreeNext = parseTreeNext
   }, {}],