collect-your-stuff 1.2.9 → 1.3.2

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

@@ -9,7 +9,9 @@ import { IsElement } from '../../recipes/IsElement';
  * Element represents a node in an Arrayable.
  */
 export declare class ArrayElement implements IsElement {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof ArrayElement;
+    /** The data stored in this element. */
     data: any;
     /**
      * Create the new Element instance, provide the data and optionally configure the type of Element.

package/dist/collections/arrayable/ArrayElement.js

@@ -15,7 +15,9 @@ class ArrayElement {
    * @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
   }
@@ -28,8 +30,8 @@ class ArrayElement {
  */
 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) {

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ArrayElement=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");class ArrayElement{constructor(e=null){this.classType=ArrayElement,this.data=null,this.data=e}}exports.ArrayElement=ArrayElement,ArrayElement.make=(e,r=ArrayElement)=>"object"!=typeof e?new r(e):e.classType?e:new r(e),ArrayElement.fromArray=(e=[],r=ArrayElement)=>e.reduce(((e,t)=>{const a=r.make(t,r);return e.head.length?(e.head.push(a),e.tail=a,e):{head:[a],tail:a}}),{head:[],tail:null});
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ArrayElement=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");class ArrayElement{constructor(e=null){this.classType=ArrayElement,this.data=null,this.data=e}}exports.ArrayElement=ArrayElement,ArrayElement.make=(e,r=ArrayElement)=>null===e||"object"!=typeof e?new r(e):e.classType?e:new r(e),ArrayElement.fromArray=(e=[],r=ArrayElement)=>e.reduce(((e,t)=>{const a=r.make(t,r);return e.head.length?(e.head.push(a),e.tail=a,e):{head:[a],tail:a}}),{head:[],tail:null});

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

@@ -11,14 +11,26 @@ import { IsElement } from '../../recipes/IsElement';
  * Arrayable represents a collection stored as an array.
  */
 export declare class Arrayable implements IsArrayable<ArrayElement>, Iterable<ArrayElement> {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof Arrayable;
+    /** The array which stores the elements of this Arrayable. */
     innerList: Array<ArrayElement>;
+    /** Whether the inner list has been initialized (it can only be initialized once). */
     initialized: boolean;
+    /** The class used to wrap the data given to this Arrayable as elements. */
     elementClass: typeof ArrayElement;
     /**
      * Create the new Arrayable instance, configure the Arrayable class.
+     * @param {ArrayElement} [elementClass=ArrayElement] The class used to wrap given data as elements.
      */
     constructor(elementClass?: typeof ArrayElement);
+    /**
+     * 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
+     */
+    private indexOfElement;
     /**
      * Initialize the inner list, should only run once.
      * @param {Array<ArrayElement>} initialList Give the array of elements to start in this Arrayable.
@@ -26,20 +38,20 @@ export declare class Arrayable implements IsArrayable<ArrayElement>, Iterable<Ar
      */
     initialize(initialList: Array<ArrayElement>): Arrayable;
     /**
-     * Retrieve a copy of the innerList used.
+     * Retrieve the innerList used (the list itself, not a copy).
      * @returns {Array<ArrayElement>}
      */
     get list(): Array<ArrayElement>;
     /**
      * Retrieve the first Element from the Arrayable
-     * @returns {ArrayElement}
+     * @returns {ArrayElement|null} The first element, or null when the Arrayable is empty
      */
-    get first(): ArrayElement;
+    get first(): ArrayElement | 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(): ArrayElement;
+    get last(): ArrayElement | null;
     /**
      * Return the length of the list.
      * @returns {number}
@@ -47,18 +59,20 @@ export declare class Arrayable implements IsArrayable<ArrayElement>, Iterable<Ar
     get length(): number;
     /**
      * 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: ArrayElement, newNode: ArrayElement | any): Arrayable;
+    insertAfter(node: ArrayElement | null, newNode: ArrayElement | any): Arrayable;
     /**
      * 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: ArrayElement, newNode: ArrayElement | any): Arrayable;
+    insertBefore(node: ArrayElement | null, newNode: ArrayElement | any): Arrayable;
     /**
      * Add a node (or data) after the given (or last) node in the list.
      * @param {ArrayElement|*} node The new node to add to the end of the list
@@ -76,9 +90,9 @@ export declare class Arrayable implements IsArrayable<ArrayElement>, Iterable<Ar
     /**
      * 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: ArrayElement): ArrayElement;
+    remove(node: ArrayElement): ArrayElement | null;
     /**
      * Retrieve an ArrayElement 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/arrayable/Arrayable.js

@@ -19,14 +19,32 @@ var _ArrayIterator = require('../../recipes/ArrayIterator')
 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.
@@ -43,7 +61,7 @@ class Arrayable {
   }
 
   /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {Array<ArrayElement>}
    */
   get list () {
@@ -52,18 +70,18 @@ class Arrayable {
 
   /**
    * 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
   }
 
   /**
@@ -76,25 +94,29 @@ class Arrayable {
 
   /**
    * 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
   }
 
@@ -121,10 +143,13 @@ class Arrayable {
   /**
    * 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
   }

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(t=_ArrayElement.ArrayElement){this.classType=Arrayable,this.innerList=[],this.initialized=!1,this.elementClass=t}initialize(t){return this.initialized?(console.warn("Attempt to initialize non-empty list."),this):(this.initialized=!0,this.innerList=t,this)}get list(){return this.innerList}get first(){return this.innerList[0]}get last(){return this.innerList[this.length-1]}get length(){return this.innerList.length}insertAfter(t,e){const r=this.innerList.indexOf(t);return this.innerList.splice(r+1,0,this.elementClass.make(e)),this}insertBefore(t,e){const r=this.innerList.indexOf(t);return this.innerList.splice(r,0,this.elementClass.make(e)),this}append(t,e=this.last){return this.insertAfter(e,t)}prepend(t,e=this.first){return this.insertBefore(e,t)}remove(t){const e=this.innerList.indexOf(t);return this.innerList.splice(e,1),t}item(t){if(t>=this.length)return null;if(t>=0)return this.innerList[t];const e=this.length+t;return e<0?null:this.innerList[e]}forEach(t,e=this){for(let r=0;r<e.length;++r)t(e.item(r),r,e);return e}[Symbol.iterator](){return new _ArrayIterator.ArrayIterator(this.innerList,0)}}exports.Arrayable=Arrayable,Arrayable.fromArray=(t=[],e=_ArrayElement.ArrayElement,r=Arrayable)=>new r(e).initialize(e.fromArray(t).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 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);

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

@@ -10,13 +10,17 @@ import { IsDoubleLinker } from '../../recipes/IsDoubleLinker';
  * @extends Linker
  */
 export declare class DoubleLinker implements IsDoubleLinker {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof DoubleLinker;
+    /** The data stored in this linker. */
     data: any;
+    /** The linker after this one, or null when this is the last. */
     next: DoubleLinker | null;
+    /** The linker before this one, or null when this is the first. */
     prev: DoubleLinker | null;
     /**
      * 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

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

@@ -14,7 +14,7 @@ var _Linker = require('../linked-list/Linker')
 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
@@ -24,9 +24,13 @@ class DoubleLinker {
     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

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

@@ -12,12 +12,17 @@ import { IsDoubleLinker } from '../../recipes/IsDoubleLinker';
  * @extends LinkedList
  */
 export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iterable<DoubleLinker> {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof DoublyLinkedList;
+    /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
     innerList: DoubleLinker;
+    /** Whether the inner list has been initialized (it can only be initialized once). */
     initialized: boolean;
+    /** The class used to wrap the data given to this list as linkers. */
     linkerClass: typeof DoubleLinker;
     /**
      * Create the new DoublyLinkedList instance.
+     * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
      */
     constructor(linkerClass?: typeof DoubleLinker);
     /**
@@ -27,7 +32,7 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
      */
     initialize(initialList: DoubleLinker): DoublyLinkedList;
     /**
-     * Retrieve a copy of the innerList used.
+     * Retrieve the innerList used (the list itself, not a copy).
      * @returns {DoubleLinker}
      */
     get list(): DoubleLinker;
@@ -48,18 +53,18 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
     get length(): number;
     /**
      * 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: DoubleLinker, newNode: DoubleLinker | any): DoublyLinkedList;
+    insertAfter(node: DoubleLinker | null, newNode: DoubleLinker | any): DoublyLinkedList;
     /**
      * 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: DoubleLinker, newNode: DoubleLinker | any): DoublyLinkedList;
+    insertBefore(node: DoubleLinker | null, newNode: DoubleLinker | any): DoublyLinkedList;
     /**
      * Add a node (or data) after the given (or last) node in the list.
      * @param {DoubleLinker|*} node The new node to add to the end of the list
@@ -95,6 +100,7 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
      * 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: forEachCallback, thisArg?: DoublyLinkedList): DoublyLinkedList;
     /**

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

@@ -23,10 +23,14 @@ var _LinkedList = require('../linked-list/LinkedList')
 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
     this.linkerClass = linkerClass
   }
@@ -37,11 +41,12 @@ class DoublyLinkedList {
    * @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 () {
@@ -89,54 +94,66 @@ class DoublyLinkedList {
 
   /**
    * 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) {
-      // 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
+    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.next = head
+      if (head) {
+        head.prev = newNode
+      }
+      this.innerList = newNode
+      return this
     }
+    // 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.length) {
-      this.innerList = newNode
-    }
     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) {
-      // 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
+    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
+      if (tail === null) {
+        this.innerList = newNode
+      } else {
+        tail.next = newNode
+        newNode.prev = tail
+      }
+      this.reset()
+      return this
     }
+    // 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.length) {
-      this.innerList = newNode
-    }
     this.reset()
     return this
   }
@@ -247,6 +264,7 @@ class DoublyLinkedList {
    * 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)

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){return t=this.linkerClass.make(t),null!==e&&(t.next=e.next,t.prev=e,e.next=t),t.next&&(t.next.prev=t),this.length||(this.innerList=t),this.reset(),this}insertBefore(e,t){return t=this.linkerClass.make(t),null!==e&&(t.prev=e.prev,t.next=e,e.prev=t),t.prev&&(t.prev.next=t),this.length||(this.innerList=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.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);

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

@@ -12,12 +12,17 @@ import { Linker } from './Linker';
  * @extends Arrayable
  */
 export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker> {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof LinkedList;
+    /** The first linker of the list (null when the list is empty), from which the whole list is reached. */
     innerList: Linker;
+    /** Whether the inner list has been initialized (it can only be initialized once). */
     initialized: boolean;
+    /** The class used to wrap the data given to this list as linkers. */
     linkerClass: typeof Linker;
     /**
      * Create the new LinkedList instance.
+     * @param {Linker} [linkerClass=Linker] The class used to wrap given data as linkers.
      */
     constructor(linkerClass?: typeof Linker);
     /**
@@ -27,7 +32,7 @@ export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker>
      */
     initialize(initialList: Linker): LinkedList;
     /**
-     * Retrieve a copy of the innerList used.
+     * Retrieve the innerList used (the list itself, not a copy).
      * @returns {Linker}
      */
     get list(): IsLinker;
@@ -48,18 +53,19 @@ export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker>
     get length(): number;
     /**
      * 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: IsLinker, newNode: Linker | any): LinkedList;
+    insertAfter(node: IsLinker | null, newNode: Linker | any): LinkedList;
     /**
      * 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: IsLinker, newNode: Linker | any): LinkedList;
+    insertBefore(node: IsLinker | null, newNode: Linker | any): LinkedList;
     /**
      * Add a node (or data) after the given (or last) node in the list.
      * @param {Linker|*} node The new node to add to the end of the list
@@ -77,9 +83,9 @@ export declare class LinkedList implements IsArrayable<Linker>, Iterable<Linker>
     /**
      * 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: Linker): Linker;
+    remove(node: Linker | null): 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.