collect-your-stuff 1.3.2 → 2.0.0

package/dist/collections/arrayable/Arrayable.d.ts

@@ -79,14 +79,14 @@ export declare class Arrayable implements IsArrayable<ArrayElement>, Iterable<Ar
      * @param {ArrayElement} after The existing last node
      * @returns {Arrayable}
      */
-    append(node: ArrayElement | any, after?: ArrayElement): Arrayable;
+    append(node: ArrayElement | any, after?: ArrayElement | null): Arrayable;
     /**
      * Add a node (or data) before the given (or first) node in the list.
      * @param {ArrayElement|*} node The new node to add to the start of the list
      * @param {ArrayElement} before The existing first node
      * @returns {Arrayable}
      */
-    prepend(node: ArrayElement | any, before?: ArrayElement): Arrayable;
+    prepend(node: ArrayElement | any, before?: ArrayElement | null): Arrayable;
     /**
      * Remove an element from this arrayable.
      * @param {ArrayElement} node The node we wish to remove (and it will be returned after removal)

package/dist/collections/arrayable/Arrayable.js

@@ -127,6 +127,11 @@ class Arrayable {
    * @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)
   }
 
@@ -137,6 +142,11 @@ class Arrayable {
    * @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)
   }
 

package/dist/collections/arrayable/Arrayable.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Arrayable=void 0;var _ArrayElement=require("./ArrayElement"),_ArrayIterator=require("../../recipes/ArrayIterator");class Arrayable{constructor(e=_ArrayElement.ArrayElement){this.classType=Arrayable,this.innerList=[],this.initialized=!1,this.elementClass=e}indexOfElement(e){const t=this.innerList.indexOf(e);if(t<0)throw new Error("The reference element is not in this list.");return t}initialize(e){return this.initialized?(console.warn("Attempt to initialize non-empty list."),this):(this.initialized=!0,this.innerList=e,this)}get list(){return this.innerList}get first(){return this.length?this.innerList[0]:null}get last(){return this.length?this.innerList[this.length-1]:null}get length(){return this.innerList.length}insertAfter(e,t){const r=null==e?-1:this.indexOfElement(e);return this.innerList.splice(r+1,0,this.elementClass.make(t,this.elementClass)),this}insertBefore(e,t){const r=null==e?this.length:this.indexOfElement(e);return this.innerList.splice(r,0,this.elementClass.make(t,this.elementClass)),this}append(e,t=this.last){return this.insertAfter(t,e)}prepend(e,t=this.first){return this.insertBefore(t,e)}remove(e){const t=this.innerList.indexOf(e);return t<0?null:(this.innerList.splice(t,1),e)}item(e){if(e>=this.length)return null;if(e>=0)return this.innerList[e];const t=this.length+e;return t<0?null:this.innerList[t]}forEach(e,t=this){for(let r=0;r<t.length;++r)e(t.item(r),r,t);return t}[Symbol.iterator](){return new _ArrayIterator.ArrayIterator(this.innerList,0)}}exports.Arrayable=Arrayable,Arrayable.fromArray=(e=[],t=_ArrayElement.ArrayElement,r=Arrayable)=>new r(t).initialize(t.fromArray(e).head);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Arrayable=void 0;var _ArrayElement=require("./ArrayElement"),_ArrayIterator=require("../../recipes/ArrayIterator");class Arrayable{constructor(e=_ArrayElement.ArrayElement){this.classType=Arrayable,this.innerList=[],this.initialized=!1,this.elementClass=e}indexOfElement(e){const t=this.innerList.indexOf(e);if(t<0)throw new Error("The reference element is not in this list.");return t}initialize(e){return this.initialized?(console.warn("Attempt to initialize non-empty list."),this):(this.initialized=!0,this.innerList=e,this)}get list(){return this.innerList}get first(){return this.length?this.innerList[0]:null}get last(){return this.length?this.innerList[this.length-1]:null}get length(){return this.innerList.length}insertAfter(e,t){const i=null==e?-1:this.indexOfElement(e);return this.innerList.splice(i+1,0,this.elementClass.make(t,this.elementClass)),this}insertBefore(e,t){const i=null==e?this.length:this.indexOfElement(e);return this.innerList.splice(i,0,this.elementClass.make(t,this.elementClass)),this}append(e,t=this.last){return t===this.last?(this.innerList.push(this.elementClass.make(e,this.elementClass)),this):this.insertAfter(t,e)}prepend(e,t=this.first){return t===this.first?(this.innerList.unshift(this.elementClass.make(e,this.elementClass)),this):this.insertBefore(t,e)}remove(e){const t=this.innerList.indexOf(e);return t<0?null:(this.innerList.splice(t,1),e)}item(e){if(e>=this.length)return null;if(e>=0)return this.innerList[e];const t=this.length+e;return t<0?null:this.innerList[t]}forEach(e,t=this){for(let i=0;i<t.length;++i)e(t.item(i),i,t);return t}[Symbol.iterator](){return new _ArrayIterator.ArrayIterator(this.innerList,0)}}exports.Arrayable=Arrayable,Arrayable.fromArray=(e=[],t=_ArrayElement.ArrayElement,i=Arrayable)=>new i(t).initialize(t.fromArray(e).head);

package/dist/collections/doubly-linked-list/DoublyLinkedList.d.ts

@@ -20,6 +20,10 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
     initialized: boolean;
     /** The class used to wrap the data given to this list as linkers. */
     linkerClass: typeof DoubleLinker;
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    private tailCache;
+    /** 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). */
+    private countCache;
     /**
      * Create the new DoublyLinkedList instance.
      * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
@@ -40,14 +44,15 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
      * Retrieve the first DoubleLinker in the list.
      * @returns {DoubleLinker}
      */
-    get first(): DoubleLinker;
+    get first(): DoubleLinker | null;
     /**
-     * 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(): DoubleLinker;
+    get last(): DoubleLinker | null;
     /**
-     * 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(): number;
@@ -84,12 +89,13 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
      * @param {DoubleLinker} node The node we wish to remove (and it will be returned after removal)
      * @return {DoubleLinker}
      */
-    remove(node: DoubleLinker): DoubleLinker;
+    remove(node: DoubleLinker | null): DoubleLinker | null;
     /**
-     * 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(): DoubleLinker;
+    reset(): DoubleLinker | null;
     /**
      * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
      * @param {number} index The integer number for retrieving a node by position.

package/dist/collections/doubly-linked-list/DoublyLinkedList.js

@@ -32,6 +32,10 @@ class DoublyLinkedList {
     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
   }
 
@@ -58,38 +62,45 @@ class DoublyLinkedList {
    * @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
   }
 
   /**
@@ -103,24 +114,31 @@ class DoublyLinkedList {
     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
-      return this
+    } 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
+      }
     }
-    // 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
+    if (this.countCache !== null) {
+      ++this.countCache
     }
-    this.reset()
     return this
   }
 
@@ -135,26 +153,31 @@ class DoublyLinkedList {
     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
-        newNode.prev = tail
       }
-      this.reset()
-      return this
+      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
+      }
     }
-    // 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
+    if (this.countCache !== null) {
+      ++this.countCache
     }
-    this.reset()
     return this
   }
 
@@ -184,7 +207,7 @@ class DoublyLinkedList {
    * @return {DoubleLinker}
    */
   remove (node) {
-    if (node === null) {
+    if (node === null || typeof node === 'undefined') {
       return null
     }
     if (node.prev) {
@@ -200,35 +223,47 @@ class DoublyLinkedList {
     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
-    }
-    let prev = pointer.prev
-    // From final reference, follow references back to the beginning
-    while (prev !== null) {
-      pointer = prev
-      prev = pointer.prev
+    // Follow references back to the beginning
+    while (pointer.prev !== null) {
+      pointer = 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
   }
 

package/dist/collections/doubly-linked-list/DoublyLinkedList.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DoublyLinkedList=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.for-each.js");var _DoubleLinker=require("./DoubleLinker"),_DoubleLinkerIterator=require("../../recipes/DoubleLinkerIterator"),_LinkedList=require("../linked-list/LinkedList");class DoublyLinkedList{constructor(e=_DoubleLinker.DoubleLinker){this.classType=DoublyLinkedList,this.innerList=null,this.initialized=!1,this.linkerClass=e}initialize(e){return _LinkedList.LinkedList.prototype.initialize.call(this,e)}get list(){return this.innerList}get first(){return this.reset()}get last(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;return e}get length(){let e=this.first,t=0;for(;null!==e;)++t,e=e.next;return t}insertAfter(e,t){if(t=this.linkerClass.make(t,this.linkerClass),null==e){const e=this.first;return t.next=e,e&&(e.prev=t),this.innerList=t,this}return t.next=e.next,t.prev=e,e.next=t,t.next&&(t.next.prev=t),this.reset(),this}insertBefore(e,t){if(t=this.linkerClass.make(t,this.linkerClass),null==e){const e=this.last;return null===e?this.innerList=t:(e.next=t,t.prev=e),this.reset(),this}return t.prev=e.prev,t.next=e,e.prev=t,t.prev&&(t.prev.next=t),this.reset(),this}append(e,t=this.last){return this.insertAfter(t,e)}prepend(e,t=this.first){return this.insertBefore(t,e)}remove(e){return null===e?null:(e.prev&&(e.prev.next=e.next),e.next&&(e.next.prev=e.prev),this.innerList===e&&(this.innerList=e.next||e.prev||null),this.reset(),e)}reset(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;let r=e.prev;for(;null!==r;)e=r,r=e.prev;return this.innerList=e,e}item(e){if(e>=0){let t=this.first,r=-1;for(;++r<e&&null!==t;)t=t.next;return r===e?t:null}let t=this.last,r=this.length;const i=this.length+e;if(i<0)return null;for(;--r>i&&null!==t;)t=t.prev;return r===i?t:null}forEach(e,t=this){return _LinkedList.LinkedList.prototype.forEach.call(this,e,t)}[Symbol.iterator](){let e=this.first;return new _DoubleLinkerIterator.DoubleLinkerIterator(e)}}exports.DoublyLinkedList=DoublyLinkedList,DoublyLinkedList.fromArray=(e=[],t=_DoubleLinker.DoubleLinker,r=DoublyLinkedList)=>_LinkedList.LinkedList.fromArray(e,t,r);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DoublyLinkedList=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.for-each.js");var _DoubleLinker=require("./DoubleLinker"),_DoubleLinkerIterator=require("../../recipes/DoubleLinkerIterator"),_LinkedList=require("../linked-list/LinkedList");class DoublyLinkedList{constructor(e=_DoubleLinker.DoubleLinker){this.classType=DoublyLinkedList,this.innerList=null,this.initialized=!1,this.tailCache=null,this.countCache=null,this.linkerClass=e}initialize(e){return _LinkedList.LinkedList.prototype.initialize.call(this,e)}get list(){return this.innerList}get first(){let e=this.innerList;if(null===e)return null;for(;null!==e.prev;)e=e.prev;return this.innerList=e,e}get last(){if(null===this.innerList)return null;let e=null!==this.tailCache?this.tailCache:this.innerList;for(;null!==e.next;)e=e.next;return this.tailCache=e,e}get length(){return null===this.countCache&&this.reset(),this.countCache}insertAfter(e,t){if(t=this.linkerClass.make(t,this.linkerClass),null==e){const e=this.first;t.prev=null,t.next=e,e?e.prev=t:this.tailCache=t,this.innerList=t}else t.next=e.next,t.prev=e,e.next=t,t.next?t.next.prev=t:this.tailCache=t;return null!==this.countCache&&++this.countCache,this}insertBefore(e,t){if(t=this.linkerClass.make(t,this.linkerClass),null==e){const e=this.last;t.next=null,t.prev=e,null===e?this.innerList=t:e.next=t,this.tailCache=t}else t.prev=e.prev,t.next=e,e.prev=t,t.prev?t.prev.next=t:this.innerList=t;return null!==this.countCache&&++this.countCache,this}append(e,t=this.last){return this.insertAfter(t,e)}prepend(e,t=this.first){return this.insertBefore(t,e)}remove(e){return null==e?null:(e.prev&&(e.prev.next=e.next),e.next&&(e.next.prev=e.prev),this.innerList===e&&(this.innerList=e.next||e.prev||null),this.tailCache===e&&(this.tailCache=e.prev),null===this.innerList&&(this.tailCache=null),null!==this.countCache&&--this.countCache,e)}reset(){let e=this.innerList;if(null===e)return this.countCache=0,this.tailCache=null,null;for(;null!==e.prev;)e=e.prev;this.innerList=e;let t=0,i=e,n=e;for(;null!==n;)++t,i=n,n=n.next;return this.countCache=t,this.tailCache=i,e}item(e){if(e>=0){let t=this.first,i=-1;for(;++i<e&&null!==t;)t=t.next;return i===e?t:null}let t=this.last,i=this.length;const n=this.length+e;if(n<0)return null;for(;--i>n&&null!==t;)t=t.prev;return i===n?t:null}forEach(e,t=this){return _LinkedList.LinkedList.prototype.forEach.call(this,e,t)}[Symbol.iterator](){let e=this.first;return new _DoubleLinkerIterator.DoubleLinkerIterator(e)}}exports.DoublyLinkedList=DoublyLinkedList,DoublyLinkedList.fromArray=(e=[],t=_DoubleLinker.DoubleLinker,i=DoublyLinkedList)=>_LinkedList.LinkedList.fromArray(e,t,i);

package/dist/collections/linked-list/LinkedList.d.ts

@@ -20,6 +20,10 @@ export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker>
     initialized: boolean;
     /** The class used to wrap the data given to this list as linkers. */
     linkerClass: typeof Linker;
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    private tailCache;
+    /** 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). */
+    private countCache;
     /**
      * Create the new LinkedList instance.
      * @param {Linker} [linkerClass=Linker] The class used to wrap given data as linkers.
@@ -42,12 +46,13 @@ export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker>
      */
     get first(): Linker;
     /**
-     * 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(): Linker;
+    get last(): Linker | null;
     /**
-     * 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(): number;
@@ -86,6 +91,12 @@ export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker>
      * @return {Linker|null} The removed node, or null when it was not in this list (nothing is removed)
      */
     remove(node: Linker | null): Linker | null;
+    /**
+     * 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(): Linker | null;
     /**
      * 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.

package/dist/collections/linked-list/LinkedList.js

@@ -23,6 +23,10 @@ class LinkedList {
     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
   }
 
@@ -53,34 +57,32 @@ class LinkedList {
   }
 
   /**
-   * 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
   }
 
   /**
@@ -94,11 +96,20 @@ class LinkedList {
     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
-      return this
+    } else {
+      newNode.next = node.next
+      node.next = newNode
+      if (newNode.next === null) {
+        this.tailCache = newNode
+      }
+    }
+    if (this.countCache !== null) {
+      ++this.countCache
     }
-    newNode.next = node.next
-    node.next = newNode
     return this
   }
 
@@ -114,27 +125,32 @@ class LinkedList {
     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
       }
-      return this
-    }
-    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
+      this.tailCache = newNode
     } else {
-      this.innerList = newNode
+      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 (this.countCache !== null) {
+      ++this.countCache
     }
     return this
   }
@@ -183,9 +199,37 @@ class LinkedList {
     } 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.

package/dist/collections/linked-list/LinkedList.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedList=void 0;var _Linker=require("./Linker"),_LinkerIterator=require("../../recipes/LinkerIterator"),_Arrayable=require("../arrayable/Arrayable");class LinkedList{constructor(t=_Linker.Linker){this.classType=LinkedList,this.innerList=null,this.initialized=!1,this.linkerClass=t}initialize(t){return _Arrayable.Arrayable.prototype.initialize.call(this,t)}get list(){return this.innerList}get first(){return this.innerList}get last(){let t=this.innerList;if(null===t)return null;let e=t.next;for(;null!==e;)t=e,e=t.next;return t}get length(){let t=this.first,e=0;for(;null!==t;)++e,t=t.next;return e}insertAfter(t,e){return e=this.linkerClass.make(e,this.linkerClass),null==t?(e.next=this.innerList,this.innerList=e,this):(e.next=t.next,t.next=e,this)}insertBefore(t,e){if(e=this.linkerClass.make(e,this.linkerClass),null==t){const t=this.last;return null===t?this.innerList=e:t.next=e,this}let r=null,i=this.first;for(;null!==i&&i!==t;)r=i,i=i.next;if(null===i)throw new Error("The reference node is not in this list.");return e.next=t,r?r.next=e:this.innerList=e,this}append(t,e=this.last){return this.insertAfter(e,t)}prepend(t,e=this.first){return this.insertBefore(e,t)}remove(t){if(null==t)return null;let e=null,r=this.first;for(;null!==r&&r!==t;)e=r,r=r.next;return null===r?null:(e?e.next=t.next:this.innerList=t.next,t)}item(t){if(t>=0){let e=this.first,r=-1;for(;++r<t&&null!==e;)e=e.next;return r===t?e:null}let e=this.first,r=0;const i=this.length+t;if(i<0)return null;for(;r<i&&null!==e;)e=e.next,++r;return r===i?e:null}forEach(t,e=this){let r=0,i=e.first;for(;null!==i;)t(i,r,e),i=i.next,++r;return e}[Symbol.iterator](){return new _LinkerIterator.LinkerIterator(this.first)}}exports.LinkedList=LinkedList,LinkedList.fromArray=(t=[],e=_Linker.Linker,r=LinkedList)=>new r(e).initialize(e.fromArray(t).head);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedList=void 0;var _Linker=require("./Linker"),_LinkerIterator=require("../../recipes/LinkerIterator"),_Arrayable=require("../arrayable/Arrayable");class LinkedList{constructor(t=_Linker.Linker){this.classType=LinkedList,this.innerList=null,this.initialized=!1,this.tailCache=null,this.countCache=null,this.linkerClass=t}initialize(t){return _Arrayable.Arrayable.prototype.initialize.call(this,t)}get list(){return this.innerList}get first(){return this.innerList}get last(){if(null===this.innerList)return null;let t=null!==this.tailCache?this.tailCache:this.innerList;for(;null!==t.next;)t=t.next;return this.tailCache=t,t}get length(){return null===this.countCache&&this.reset(),this.countCache}insertAfter(t,e){return e=this.linkerClass.make(e,this.linkerClass),null==t?(e.next=this.innerList,null===this.innerList&&(this.tailCache=e),this.innerList=e):(e.next=t.next,t.next=e,null===e.next&&(this.tailCache=e)),null!==this.countCache&&++this.countCache,this}insertBefore(t,e){if(e=this.linkerClass.make(e,this.linkerClass),null==t){const t=this.last;e.next=null,null===t?this.innerList=e:t.next=e,this.tailCache=e}else{let i=null,n=this.first;for(;null!==n&&n!==t;)i=n,n=n.next;if(null===n)throw new Error("The reference node is not in this list.");e.next=t,i?i.next=e:this.innerList=e}return null!==this.countCache&&++this.countCache,this}append(t,e=this.last){return this.insertAfter(e,t)}prepend(t,e=this.first){return this.insertBefore(e,t)}remove(t){if(null==t)return null;let e=null,i=this.first;for(;null!==i&&i!==t;)e=i,i=i.next;return null===i?null:(e?e.next=t.next:this.innerList=t.next,this.tailCache===t&&(this.tailCache=e),null===this.innerList&&(this.tailCache=null),null!==this.countCache&&--this.countCache,t)}reset(){let t=0,e=null,i=this.innerList;for(;null!==i;)++t,e=i,i=i.next;return this.countCache=t,this.tailCache=e,this.innerList}item(t){if(t>=0){let e=this.first,i=-1;for(;++i<t&&null!==e;)e=e.next;return i===t?e:null}let e=this.first,i=0;const n=this.length+t;if(n<0)return null;for(;i<n&&null!==e;)e=e.next,++i;return i===n?e:null}forEach(t,e=this){let i=0,n=e.first;for(;null!==n;)t(n,i,e),n=n.next,++i;return e}[Symbol.iterator](){return new _LinkerIterator.LinkerIterator(this.first)}}exports.LinkedList=LinkedList,LinkedList.fromArray=(t=[],e=_Linker.Linker,i=LinkedList)=>new i(e).initialize(e.fromArray(t).head);

package/dist/collections/linked-tree-list/LinkedTreeList.d.ts

@@ -21,6 +21,10 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
     initialized: boolean;
     /** The class used to wrap the data given to this list as tree linkers. */
     linkerClass: typeof TreeLinker;
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    private tailCache;
+    /** 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). */
+    private countCache;
     /**
      * Create the new LinkedTreeList instance, configure the list class.
      * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
@@ -43,12 +47,13 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     get first(): TreeLinker;
     /**
-     * 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(): TreeLinker;
     /**
-     * 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(): number;
@@ -108,7 +113,8 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     remove(node: TreeLinker): TreeLinker;
     /**
-     * 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(): TreeLinker;