collect-your-stuff 1.1.9 → 1.2.0

package/README.md

@@ -66,6 +66,47 @@ Data allocation and manipulation.
 </dd>
 </dl>
 
+## Members
+
+<dl>
+<dt><a href="#Stackable">Stackable</a> ⇒ <code><a href="#Stackable">Stackable</a></code></dt>
+<dd><p>Make a new Stackable from the data given if it is not already a valid Stackable.</p>
+</dd>
+<dt><a href="#Stack">Stack</a> ⇒ <code><a href="#Stack">Stack</a></code></dt>
+<dd><p>Convert an array to a Stack.</p>
+</dd>
+<dt><a href="#Queueable">Queueable</a> ⇒ <code><a href="#Queueable">Queueable</a></code></dt>
+<dd><p>Make a new Queueable from the data given if it is not already a valid Queueable.</p>
+</dd>
+<dt><a href="#Queue">Queue</a> ⇒ <code><a href="#Queue">Queue</a></code></dt>
+<dd><p>Convert an array to a Queue.</p>
+</dd>
+<dt><a href="#TreeLinker">TreeLinker</a> ⇒ <code><a href="#TreeLinker">TreeLinker</a></code></dt>
+<dd><p>Make a new DoubleLinker from the data given if it is not already a valid Linker.</p>
+</dd>
+<dt><a href="#LinkedTreeList">LinkedTreeList</a> ⇒ <code><a href="#LinkedTreeList">LinkedTreeList</a></code></dt>
+<dd><p>Convert an array into a LinkedTreeList instance, return the new instance.</p>
+</dd>
+<dt><a href="#Linker">Linker</a> ⇒ <code><a href="#Linker">Linker</a></code></dt>
+<dd><p>Make a new Linker from the data given if it is not already a valid Linker.</p>
+</dd>
+<dt><a href="#LinkedList">LinkedList</a> ⇒ <code><a href="#LinkedList">LinkedList</a></code></dt>
+<dd><p>Convert an array to a LinkedList.</p>
+</dd>
+<dt><a href="#DoublyLinkedList">DoublyLinkedList</a> ⇒ <code><a href="#DoublyLinkedList">DoublyLinkedList</a></code></dt>
+<dd><p>Convert an array into a DoublyLinkedList instance, return the new instance.</p>
+</dd>
+<dt><a href="#DoubleLinker">DoubleLinker</a> ⇒ <code><a href="#DoubleLinker">DoubleLinker</a></code></dt>
+<dd><p>Make a new DoubleLinker from the data given if it is not already a valid Linker.</p>
+</dd>
+<dt><a href="#Arrayable">Arrayable</a> ⇒ <code><a href="#Arrayable">Arrayable</a></code></dt>
+<dd><p>Convert an array to an Arrayable.</p>
+</dd>
+<dt><a href="#ArrayElement">ArrayElement</a> ⇒ <code><a href="#ArrayElement">ArrayElement</a></code></dt>
+<dd><p>Make a new Element from the data given if it is not already a valid Element.</p>
+</dd>
+</dl>
+
 ## Constants
 
 <dl>
@@ -196,7 +237,6 @@ Stackable represents a runnable entry in stack.
         * [.task](#Stackable+task) ⇒ <code>\*</code>
         * [.run()](#Stackable+run) ⇒ <code>\*</code>
     * _static_
-        * [.make(stackable, [classType])](#Stackable.make) ⇒ [<code>Stackable</code>](#Stackable)
         * [.fromArray([values], [classType])](#Stackable.fromArray) ⇒ <code>Object</code>
 
 <a name="new_Stackable_new"></a>
@@ -224,18 +264,6 @@ Retrieve the data which should be formed as a task.
 Run the stacked task.
 
 **Kind**: instance method of [<code>Stackable</code>](#Stackable)  
-<a name="Stackable.make"></a>
-
-### Stackable.make(stackable, [classType]) ⇒ [<code>Stackable</code>](#Stackable)
-Make a new Stackable from the data given if it is not already a valid Stackable.
-
-**Kind**: static method of [<code>Stackable</code>](#Stackable)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| stackable | [<code>Stackable</code>](#Stackable) \| <code>\*</code> |  | Return a valid Stackable instance from given data, or even an already valid one. |
-| [classType] | <code>IsLinker</code> | <code>Stackable</code> | Provide the type of IsLinker to use. |
-
 <a name="Stackable.fromArray"></a>
 
 ### Stackable.fromArray([values], [classType]) ⇒ <code>Object</code>
@@ -257,15 +285,12 @@ Store a collection of items which can only be inserted and removed from the top.
 
 * [Stack](#Stack)
     * [new Stack(stackedList, listClass, stackableClass)](#new_Stack_new)
-    * _instance_
-        * [.empty()](#Stack+empty) ⇒ <code>boolean</code>
-        * [.top()](#Stack+top) ⇒ [<code>Stackable</code>](#Stackable)
-        * [.pop()](#Stack+pop) ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
-        * [.push(stackable)](#Stack+push)
-        * [.remove()](#Stack+remove) ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
-        * [.size()](#Stack+size) ⇒ <code>number</code>
-    * _static_
-        * [.fromArray(values, stackableClass, listClass)](#Stack.fromArray) ⇒ [<code>Stack</code>](#Stack)
+    * [.empty()](#Stack+empty) ⇒ <code>boolean</code>
+    * [.top()](#Stack+top) ⇒ [<code>Stackable</code>](#Stackable)
+    * [.pop()](#Stack+pop) ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
+    * [.push(stackable)](#Stack+push)
+    * [.remove()](#Stack+remove) ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
+    * [.size()](#Stack+size) ⇒ <code>number</code>
 
 <a name="new_Stack_new"></a>
 
@@ -320,19 +345,6 @@ Remove the next stacked task and return it.
 Get the size of the current stack.
 
 **Kind**: instance method of [<code>Stack</code>](#Stack)  
-<a name="Stack.fromArray"></a>
-
-### Stack.fromArray(values, stackableClass, listClass) ⇒ [<code>Stack</code>](#Stack)
-Convert an array to a Stack.
-
-**Kind**: static method of [<code>Stack</code>](#Stack)  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| values | <code>Array</code> | An array of values which will be converted to stackables in this queue |
-| stackableClass | [<code>Stackable</code>](#Stackable) | The class to use for each stackable |
-| listClass | [<code>Stack</code>](#Stack) \| <code>Iterable</code> | The class to use to manage the stackables |
-
 <a name="Queueable"></a>
 
 ## Queueable ⇐ [<code>Linker</code>](#Linker)
@@ -349,7 +361,6 @@ Queueable represents a runnable entry in a queue.
         * [.markCompleted(completeResponse)](#Queueable+markCompleted) ⇒ <code>completeResponse</code>
         * [.run()](#Queueable+run) ⇒ <code>completeResponse</code>
     * _static_
-        * [.make(queueable, [classType])](#Queueable.make) ⇒ [<code>Queueable</code>](#Queueable)
         * [.fromArray(values, [classType])](#Queueable.fromArray) ⇒ <code>Object</code>
 
 <a name="new_Queueable_new"></a>
@@ -397,18 +408,6 @@ Set this queueable as completed.
 Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
 
 **Kind**: instance method of [<code>Queueable</code>](#Queueable)  
-<a name="Queueable.make"></a>
-
-### Queueable.make(queueable, [classType]) ⇒ [<code>Queueable</code>](#Queueable)
-Make a new Queueable from the data given if it is not already a valid Queueable.
-
-**Kind**: static method of [<code>Queueable</code>](#Queueable)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| queueable | [<code>Queueable</code>](#Queueable) \| <code>\*</code> |  | Return a valid Queueable instance from given data, or even an already valid one. |
-| [classType] | <code>IsLinker</code> | <code>Queueable</code> | Provide the type of IsLinker to use. |
-
 <a name="Queueable.fromArray"></a>
 
 ### Queueable.fromArray(values, [classType]) ⇒ <code>Object</code>
@@ -430,15 +429,12 @@ Maintain a series of queued items.
 
 * [Queue](#Queue)
     * [new Queue(queuedList, listClass, queueableClass)](#new_Queue_new)
-    * _instance_
-        * [.dequeue()](#Queue+dequeue) ⇒ <code>completeResponse</code> \| <code>\*</code>
-        * [.empty()](#Queue+empty) ⇒ <code>boolean</code>
-        * [.enqueue(queueable)](#Queue+enqueue)
-        * [.peek()](#Queue+peek) ⇒ [<code>Queueable</code>](#Queueable)
-        * [.remove()](#Queue+remove) ⇒ [<code>Queueable</code>](#Queueable) \| <code>null</code>
-        * [.size()](#Queue+size) ⇒ <code>number</code>
-    * _static_
-        * [.fromArray(values, queueableClass, listClass)](#Queue.fromArray) ⇒ [<code>Queue</code>](#Queue)
+    * [.dequeue()](#Queue+dequeue) ⇒ <code>completeResponse</code> \| <code>\*</code>
+    * [.empty()](#Queue+empty) ⇒ <code>boolean</code>
+    * [.enqueue(queueable)](#Queue+enqueue)
+    * [.peek()](#Queue+peek) ⇒ [<code>Queueable</code>](#Queueable)
+    * [.remove()](#Queue+remove) ⇒ [<code>Queueable</code>](#Queueable) \| <code>null</code>
+    * [.size()](#Queue+size) ⇒ <code>number</code>
 
 <a name="new_Queue_new"></a>
 
@@ -493,19 +489,6 @@ Remove the next queued item and return it.
 Get the length of the current queue.
 
 **Kind**: instance method of [<code>Queue</code>](#Queue)  
-<a name="Queue.fromArray"></a>
-
-### Queue.fromArray(values, queueableClass, listClass) ⇒ [<code>Queue</code>](#Queue)
-Convert an array to a Queue.
-
-**Kind**: static method of [<code>Queue</code>](#Queue)  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| values | <code>Array</code> | An array of values which will be converted to queueables in this queue |
-| queueableClass | [<code>Queueable</code>](#Queueable) | The class to use for each queueable |
-| listClass | [<code>Queue</code>](#Queue) \| <code>Iterable</code> | The class to use to manage the queueables |
-
 <a name="TreeLinker"></a>
 
 ## TreeLinker ⇐ [<code>DoubleLinker</code>](#DoubleLinker)
@@ -519,7 +502,6 @@ TreeLinker represents a node in a LinkedTreeList having a parent (or root) and c
     * _instance_
         * [.childrenFromArray(children, listClass)](#TreeLinker+childrenFromArray) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList) \| <code>null</code>
     * _static_
-        * [.make(linker, [classType])](#TreeLinker.make) ⇒ [<code>TreeLinker</code>](#TreeLinker)
         * [.fromArray([values], [classType])](#TreeLinker.fromArray) ⇒ <code>Object</code>
 
 <a name="new_TreeLinker_new"></a>
@@ -550,18 +532,6 @@ Create the children for this tree from an array.
 | children | <code>Array</code> \| <code>null</code> | Provide an array of data / linker references to be children of this tree node. |
 | listClass | <code>IsArrayable.&lt;IsTreeNode&gt;</code> | Give the type of list to use for storing the children |
 
-<a name="TreeLinker.make"></a>
-
-### TreeLinker.make(linker, [classType]) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-Make a new DoubleLinker from the data given if it is not already a valid Linker.
-
-**Kind**: static method of [<code>TreeLinker</code>](#TreeLinker)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| linker | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> |  | Return a valid TreeLinker instance from given data, or even an already valid one. |
-| [classType] | <code>IsTreeNode</code> | <code>TreeLinker</code> | Provide the type of IsTreeNode to use. |
-
 <a name="TreeLinker.fromArray"></a>
 
 ### TreeLinker.fromArray([values], [classType]) ⇒ <code>Object</code>
@@ -584,26 +554,23 @@ LinkedTreeList represents a collection stored with a root and spreading in branc
 
 * [LinkedTreeList](#LinkedTreeList) ⇐ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
     * [new LinkedTreeList()](#new_LinkedTreeList_new)
-    * _instance_
-        * [.list](#LinkedTreeList+list) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.first](#LinkedTreeList+first) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.last](#LinkedTreeList+last) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.length](#LinkedTreeList+length) ⇒ <code>number</code>
-        * [.parent](#LinkedTreeList+parent) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.parent](#LinkedTreeList+parent)
-        * [.rootParent](#LinkedTreeList+rootParent) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.initialize(initialList)](#LinkedTreeList+initialize) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
-        * [.setChildren(item, children)](#LinkedTreeList+setChildren)
-        * [.insertAfter(node, newNode)](#LinkedTreeList+insertAfter) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
-        * [.insertBefore(node, newNode)](#LinkedTreeList+insertBefore) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
-        * [.append(node, after)](#LinkedTreeList+append) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.prepend(node, before)](#LinkedTreeList+prepend) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.remove(node)](#LinkedTreeList+remove) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.reset()](#LinkedTreeList+reset) ⇒ [<code>TreeLinker</code>](#TreeLinker)
-        * [.item(index)](#LinkedTreeList+item) ⇒ [<code>TreeLinker</code>](#TreeLinker) \| <code>null</code>
-        * [.forEach(callback, thisArg)](#LinkedTreeList+forEach)
-    * _static_
-        * [.fromArray([values], [linkerClass], [classType])](#LinkedTreeList.fromArray) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.list](#LinkedTreeList+list) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.first](#LinkedTreeList+first) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.last](#LinkedTreeList+last) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.length](#LinkedTreeList+length) ⇒ <code>number</code>
+    * [.parent](#LinkedTreeList+parent) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.parent](#LinkedTreeList+parent)
+    * [.rootParent](#LinkedTreeList+rootParent) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.initialize(initialList)](#LinkedTreeList+initialize) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.setChildren(item, children)](#LinkedTreeList+setChildren)
+    * [.insertAfter(node, newNode)](#LinkedTreeList+insertAfter) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.insertBefore(node, newNode)](#LinkedTreeList+insertBefore) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.append(node, after)](#LinkedTreeList+append) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.prepend(node, before)](#LinkedTreeList+prepend) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.remove(node)](#LinkedTreeList+remove) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.reset()](#LinkedTreeList+reset) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.item(index)](#LinkedTreeList+item) ⇒ [<code>TreeLinker</code>](#TreeLinker) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#LinkedTreeList+forEach)
 
 <a name="new_LinkedTreeList_new"></a>
 
@@ -781,19 +748,6 @@ Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Ite
 | callback | <code>forEachCallback</code> | The function to call for-each tree node |
 | thisArg | [<code>LinkedTreeList</code>](#LinkedTreeList) | Optional, 'this' reference |
 
-<a name="LinkedTreeList.fromArray"></a>
-
-### LinkedTreeList.fromArray([values], [linkerClass], [classType]) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
-Convert an array into a LinkedTreeList instance, return the new instance.
-
-**Kind**: static method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [values] | <code>Array</code> | <code>[]</code> | An array of values which will be converted to nodes in this tree-list |
-| [linkerClass] | [<code>TreeLinker</code>](#TreeLinker) | <code>TreeLinker</code> | The class to use for each node |
-| [classType] | [<code>IsArrayable.&lt;TreeLinker&gt;</code>](#TreeLinker) | <code>LinkedTreeList</code> | Provide the type of IsArrayable to use. |
-
 <a name="Linker"></a>
 
 ## Linker ⇐ [<code>ArrayElement</code>](#ArrayElement)
@@ -804,7 +758,6 @@ Linker represents a node in a LinkedList.
 
 * [Linker](#Linker) ⇐ [<code>ArrayElement</code>](#ArrayElement)
     * [new Linker([nodeData])](#new_Linker_new)
-    * [.make(linker, [classType])](#Linker.make) ⇒ [<code>Linker</code>](#Linker)
     * [.fromArray([values], [classType])](#Linker.fromArray) ⇒ <code>Object</code>
 
 <a name="new_Linker_new"></a>
@@ -819,18 +772,6 @@ Create the new Linker instance, provide the data and optionally give the next Li
 | [nodeData.data] | <code>\*</code> | <code></code> | The data to be stored in this linker |
 | [nodeData.next] | [<code>Linker</code>](#Linker) \| <code>null</code> | <code></code> | The reference to the next linker if any |
 
-<a name="Linker.make"></a>
-
-### Linker.make(linker, [classType]) ⇒ [<code>Linker</code>](#Linker)
-Make a new Linker from the data given if it is not already a valid Linker.
-
-**Kind**: static method of [<code>Linker</code>](#Linker)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| linker | [<code>Linker</code>](#Linker) \| <code>\*</code> |  | Return a valid Linker instance from given data, or even an already valid one. |
-| [classType] | <code>IsLinker</code> | <code>Linker</code> | Provide the type of IsLinker to use. |
-
 <a name="Linker.fromArray"></a>
 
 ### Linker.fromArray([values], [classType]) ⇒ <code>Object</code>
@@ -853,21 +794,18 @@ LinkedList represents a collection stored as a LinkedList with next references.
 
 * [LinkedList](#LinkedList) ⇐ [<code>Arrayable</code>](#Arrayable)
     * [new LinkedList()](#new_LinkedList_new)
-    * _instance_
-        * [.list](#LinkedList+list) ⇒ [<code>Linker</code>](#Linker)
-        * [.first](#LinkedList+first) ⇒ [<code>Linker</code>](#Linker)
-        * [.last](#LinkedList+last) ⇒ [<code>Linker</code>](#Linker)
-        * [.length](#LinkedList+length) ⇒ <code>number</code>
-        * [.initialize(initialList)](#LinkedList+initialize) ⇒ [<code>LinkedList</code>](#LinkedList)
-        * [.insertAfter(node, newNode)](#LinkedList+insertAfter) ⇒ [<code>LinkedList</code>](#LinkedList)
-        * [.insertBefore(node, newNode)](#LinkedList+insertBefore) ⇒ [<code>LinkedList</code>](#LinkedList)
-        * [.append(node, after)](#LinkedList+append) ⇒ [<code>Linker</code>](#Linker)
-        * [.prepend(node, before)](#LinkedList+prepend) ⇒ [<code>Linker</code>](#Linker)
-        * [.remove(node)](#LinkedList+remove) ⇒ [<code>Linker</code>](#Linker)
-        * [.item(index)](#LinkedList+item) ⇒ [<code>Linker</code>](#Linker) \| <code>null</code>
-        * [.forEach(callback, thisArg)](#LinkedList+forEach) ⇒ [<code>LinkedList</code>](#LinkedList)
-    * _static_
-        * [.fromArray(values, linkerClass, [classType])](#LinkedList.fromArray) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.list](#LinkedList+list) ⇒ [<code>Linker</code>](#Linker)
+    * [.first](#LinkedList+first) ⇒ [<code>Linker</code>](#Linker)
+    * [.last](#LinkedList+last) ⇒ [<code>Linker</code>](#Linker)
+    * [.length](#LinkedList+length) ⇒ <code>number</code>
+    * [.initialize(initialList)](#LinkedList+initialize) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.insertAfter(node, newNode)](#LinkedList+insertAfter) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.insertBefore(node, newNode)](#LinkedList+insertBefore) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.append(node, after)](#LinkedList+append) ⇒ [<code>Linker</code>](#Linker)
+    * [.prepend(node, before)](#LinkedList+prepend) ⇒ [<code>Linker</code>](#Linker)
+    * [.remove(node)](#LinkedList+remove) ⇒ [<code>Linker</code>](#Linker)
+    * [.item(index)](#LinkedList+item) ⇒ [<code>Linker</code>](#Linker) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#LinkedList+forEach) ⇒ [<code>LinkedList</code>](#LinkedList)
 
 <a name="new_LinkedList_new"></a>
 
@@ -1003,19 +941,6 @@ Be able to run forEach on this LinkedList to iterate over the linkers.
 | callback | <code>forEachCallback</code> | The function to call for-each linker |
 | thisArg | [<code>LinkedList</code>](#LinkedList) | Optional, 'this' reference |
 
-<a name="LinkedList.fromArray"></a>
-
-### LinkedList.fromArray(values, linkerClass, [classType]) ⇒ [<code>LinkedList</code>](#LinkedList)
-Convert an array to a LinkedList.
-
-**Kind**: static method of [<code>LinkedList</code>](#LinkedList)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| values | <code>Array</code> |  | An array of values which will be converted to linkers in this linked-list |
-| linkerClass | <code>IsLinker</code> |  | The class to use for each linker |
-| [classType] | [<code>IsArrayable.&lt;Linker&gt;</code>](#Linker) | <code>LinkedList</code> | Provide the type of IsArrayable to use. |
-
 <a name="DoublyLinkedList"></a>
 
 ## DoublyLinkedList ⇐ [<code>LinkedList</code>](#LinkedList)
@@ -1026,22 +951,19 @@ DoublyLinkedList represents a collection stored as a LinkedList with prev and ne
 
 * [DoublyLinkedList](#DoublyLinkedList) ⇐ [<code>LinkedList</code>](#LinkedList)
     * [new DoublyLinkedList()](#new_DoublyLinkedList_new)
-    * _instance_
-        * [.list](#DoublyLinkedList+list) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.first](#DoublyLinkedList+first) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.last](#DoublyLinkedList+last) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.length](#DoublyLinkedList+length) ⇒ <code>number</code>
-        * [.initialize(initialList)](#DoublyLinkedList+initialize) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
-        * [.insertAfter(node, newNode)](#DoublyLinkedList+insertAfter) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
-        * [.insertBefore(node, newNode)](#DoublyLinkedList+insertBefore) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
-        * [.append(node, after)](#DoublyLinkedList+append) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.prepend(node, before)](#DoublyLinkedList+prepend) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.remove(node)](#DoublyLinkedList+remove) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.reset()](#DoublyLinkedList+reset) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-        * [.item(index)](#DoublyLinkedList+item) ⇒ [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code>
-        * [.forEach(callback, thisArg)](#DoublyLinkedList+forEach)
-    * _static_
-        * [.fromArray([values], [linkerClass], [classType])](#DoublyLinkedList.fromArray) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.list](#DoublyLinkedList+list) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.first](#DoublyLinkedList+first) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.last](#DoublyLinkedList+last) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.length](#DoublyLinkedList+length) ⇒ <code>number</code>
+    * [.initialize(initialList)](#DoublyLinkedList+initialize) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.insertAfter(node, newNode)](#DoublyLinkedList+insertAfter) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.insertBefore(node, newNode)](#DoublyLinkedList+insertBefore) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.append(node, after)](#DoublyLinkedList+append) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.prepend(node, before)](#DoublyLinkedList+prepend) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.remove(node)](#DoublyLinkedList+remove) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.reset()](#DoublyLinkedList+reset) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.item(index)](#DoublyLinkedList+item) ⇒ [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#DoublyLinkedList+forEach)
 
 <a name="new_DoublyLinkedList_new"></a>
 
@@ -1183,19 +1105,6 @@ Be able to run forEach on this DoublyLinkedList to iterate over the DoubleLinker
 | callback | <code>forEachCallback</code> | The function to call for-each double linker |
 | thisArg | [<code>DoublyLinkedList</code>](#DoublyLinkedList) | Optional, 'this' reference |
 
-<a name="DoublyLinkedList.fromArray"></a>
-
-### DoublyLinkedList.fromArray([values], [linkerClass], [classType]) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
-Convert an array into a DoublyLinkedList instance, return the new instance.
-
-**Kind**: static method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [values] | <code>Array</code> | <code>[]</code> | An array of values which will be converted to linkers in this doubly-linked-list |
-| [linkerClass] | <code>IsDoubleLinker</code> | <code>DoubleLinker</code> | The class to use for each linker |
-| [classType] | <code>IsArrayable.&lt;IsDoubleLinker&gt;</code> | <code>LinkedList</code> | Provide the type of IsArrayable to use. |
-
 <a name="DoubleLinker"></a>
 
 ## DoubleLinker ⇐ [<code>Linker</code>](#Linker)
@@ -1206,7 +1115,6 @@ DoubleLinker represents a node in a DoublyLinkedList which is chained by next an
 
 * [DoubleLinker](#DoubleLinker) ⇐ [<code>Linker</code>](#Linker)
     * [new DoubleLinker([nodeData])](#new_DoubleLinker_new)
-    * [.make(linker, [classType])](#DoubleLinker.make) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
     * [.fromArray([values], [classType])](#DoubleLinker.fromArray) ⇒ <code>Object</code>
 
 <a name="new_DoubleLinker_new"></a>
@@ -1222,18 +1130,6 @@ Create the new DoubleLinker instance, provide the data and optionally the next a
 | [nodeData.next] | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code> | <code></code> | The reference to the next linker if any |
 | [nodeData.prev] | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code> | <code></code> | The reference to the previous linker if any |
 
-<a name="DoubleLinker.make"></a>
-
-### DoubleLinker.make(linker, [classType]) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
-Make a new DoubleLinker from the data given if it is not already a valid Linker.
-
-**Kind**: static method of [<code>DoubleLinker</code>](#DoubleLinker)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| linker | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> |  | Return a valid Linker instance from given data, or even an already valid one. |
-| [classType] | <code>IsDoubleLinker</code> | <code>DoubleLinker</code> | Provide the type of IsDoubleLinker to use. |
-
 <a name="DoubleLinker.fromArray"></a>
 
 ### DoubleLinker.fromArray([values], [classType]) ⇒ <code>Object</code>
@@ -1255,21 +1151,18 @@ Arrayable represents a collection stored as an array.
 
 * [Arrayable](#Arrayable)
     * [new Arrayable()](#new_Arrayable_new)
-    * _instance_
-        * [.list](#Arrayable+list) ⇒ [<code>Array.&lt;ArrayElement&gt;</code>](#ArrayElement)
-        * [.first](#Arrayable+first) ⇒ [<code>ArrayElement</code>](#ArrayElement)
-        * [.last](#Arrayable+last) ⇒ [<code>ArrayElement</code>](#ArrayElement)
-        * [.length](#Arrayable+length) ⇒ <code>number</code>
-        * [.initialize(initialList)](#Arrayable+initialize) ⇒ [<code>Arrayable</code>](#Arrayable)
-        * [.insertAfter(node, newNode)](#Arrayable+insertAfter) ⇒ [<code>Arrayable</code>](#Arrayable)
-        * [.insertBefore(node, newNode)](#Arrayable+insertBefore) ⇒ [<code>Arrayable</code>](#Arrayable)
-        * [.append(node, after)](#Arrayable+append) ⇒ [<code>Arrayable</code>](#Arrayable)
-        * [.prepend(node, before)](#Arrayable+prepend) ⇒ [<code>Arrayable</code>](#Arrayable)
-        * [.remove(node)](#Arrayable+remove) ⇒ [<code>ArrayElement</code>](#ArrayElement)
-        * [.item(index)](#Arrayable+item) ⇒ [<code>ArrayElement</code>](#ArrayElement) \| <code>null</code>
-        * [.forEach(callback, thisArg)](#Arrayable+forEach) ⇒ [<code>Arrayable</code>](#Arrayable)
-    * _static_
-        * [.fromArray(values, [elementClass], [classType])](#Arrayable.fromArray) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.list](#Arrayable+list) ⇒ [<code>Array.&lt;ArrayElement&gt;</code>](#ArrayElement)
+    * [.first](#Arrayable+first) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [.last](#Arrayable+last) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [.length](#Arrayable+length) ⇒ <code>number</code>
+    * [.initialize(initialList)](#Arrayable+initialize) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.insertAfter(node, newNode)](#Arrayable+insertAfter) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.insertBefore(node, newNode)](#Arrayable+insertBefore) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.append(node, after)](#Arrayable+append) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.prepend(node, before)](#Arrayable+prepend) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.remove(node)](#Arrayable+remove) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [.item(index)](#Arrayable+item) ⇒ [<code>ArrayElement</code>](#ArrayElement) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#Arrayable+forEach) ⇒ [<code>Arrayable</code>](#Arrayable)
 
 <a name="new_Arrayable_new"></a>
 
@@ -1393,19 +1286,6 @@ Be able to run forEach on this Arrayable to iterate over the elements.
 | callback | <code>forEachCallback</code> | The function to call for-each element |
 | thisArg | [<code>Arrayable</code>](#Arrayable) | Optional, 'this' reference |
 
-<a name="Arrayable.fromArray"></a>
-
-### Arrayable.fromArray(values, [elementClass], [classType]) ⇒ [<code>Arrayable</code>](#Arrayable)
-Convert an array to an Arrayable.
-
-**Kind**: static method of [<code>Arrayable</code>](#Arrayable)  
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| values | <code>Array</code> |  | An array of values which will be converted to elements in this arrayable |
-| [elementClass] | <code>IsElement</code> | <code>ArrayElement</code> | The class to use for each element |
-| [classType] | [<code>IsArrayable.&lt;ArrayElement&gt;</code>](#ArrayElement) | <code>Arrayable</code> | Provide the type of IsArrayable to use. |
-
 <a name="ArrayElement"></a>
 
 ## ArrayElement
@@ -1415,7 +1295,6 @@ Element represents a node in an Arrayable.
 
 * [ArrayElement](#ArrayElement)
     * [new ArrayElement([data])](#new_ArrayElement_new)
-    * [.make(element, [classType])](#ArrayElement.make) ⇒ [<code>ArrayElement</code>](#ArrayElement)
     * [.fromArray([values], [classType])](#ArrayElement.fromArray) ⇒ <code>Object</code>
 
 <a name="new_ArrayElement_new"></a>
@@ -1428,18 +1307,1172 @@ Create the new Element instance, provide the data and optionally configure the t
 | --- | --- | --- | --- |
 | [data] | <code>\*</code> | <code></code> | The data to be stored in this element. |
 
-<a name="ArrayElement.make"></a>
+<a name="ArrayElement.fromArray"></a>
 
-### ArrayElement.make(element, [classType]) ⇒ [<code>ArrayElement</code>](#ArrayElement)
-Make a new Element from the data given if it is not already a valid Element.
+### ArrayElement.fromArray([values], [classType]) ⇒ <code>Object</code>
+Convert an array into Element instances, return the head and tail Elements.
 
 **Kind**: static method of [<code>ArrayElement</code>](#ArrayElement)  
 
 | Param | Type | Default | Description |
 | --- | --- | --- | --- |
-| element | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> |  | Return a valid ArrayElement instance from given data, or even an already valid one. |
+| [values] | <code>Array.&lt;IsElement&gt;</code> | <code>[]</code> | Provide an array of data that will be converted to array of elements. |
 | [classType] | <code>IsElement</code> | <code>ArrayElement</code> | Provide the type of IsElement to use. |
 
+<a name="Stackable"></a>
+
+## Stackable ⇒ [<code>Stackable</code>](#Stackable)
+Make a new Stackable from the data given if it is not already a valid Stackable.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| stackable | [<code>Stackable</code>](#Stackable) \| <code>\*</code> |  | Return a valid Stackable instance from given data, or even an already valid one. |
+| [classType] | <code>IsLinker</code> | <code>Stackable</code> | Provide the type of IsLinker to use. |
+
+
+* [Stackable](#Stackable) ⇒ [<code>Stackable</code>](#Stackable)
+    * [new Stackable([stackData])](#new_Stackable_new)
+    * _instance_
+        * [.task](#Stackable+task) ⇒ <code>\*</code>
+        * [.run()](#Stackable+run) ⇒ <code>\*</code>
+    * _static_
+        * [.fromArray([values], [classType])](#Stackable.fromArray) ⇒ <code>Object</code>
+
+<a name="new_Stackable_new"></a>
+
+### new Stackable([stackData])
+Create a stackable item that can be used in a stack.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [stackData] | <code>Object</code> | <code>{}</code> |  |
+| [stackData.task] | <code>\*</code> | <code></code> | The data to be stored in this stackable |
+| [stackData.next] | [<code>Stackable</code>](#Stackable) \| <code>null</code> | <code></code> | The reference to the next stackable if any |
+| [stackData.ready] | <code>boolean</code> \| <code>function</code> | <code>false</code> | Indicate if the stackable is ready to run |
+
+<a name="Stackable+task"></a>
+
+### stackable.task ⇒ <code>\*</code>
+Retrieve the data which should be formed as a task.
+
+**Kind**: instance property of [<code>Stackable</code>](#Stackable)  
+<a name="Stackable+run"></a>
+
+### stackable.run() ⇒ <code>\*</code>
+Run the stacked task.
+
+**Kind**: instance method of [<code>Stackable</code>](#Stackable)  
+<a name="Stackable.fromArray"></a>
+
+### Stackable.fromArray([values], [classType]) ⇒ <code>Object</code>
+Convert an array into Stackable instances, return the head and tail Stackables.
+
+**Kind**: static method of [<code>Stackable</code>](#Stackable)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [values] | <code>Array</code> | <code>[]</code> | Provide an array of data that will be converted to a chain of stackable linkers. |
+| [classType] | <code>IsLinker</code> | <code>Stackable</code> | Provide the type of IsLinker to use. |
+
+<a name="Stack"></a>
+
+## Stack ⇒ [<code>Stack</code>](#Stack)
+Convert an array to a Stack.
+
+**Kind**: global variable  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| values | <code>Array</code> | An array of values which will be converted to stackables in this queue |
+| stackableClass | [<code>Stackable</code>](#Stackable) | The class to use for each stackable |
+| listClass | [<code>Stack</code>](#Stack) \| <code>Iterable</code> | The class to use to manage the stackables |
+
+
+* [Stack](#Stack) ⇒ [<code>Stack</code>](#Stack)
+    * [new Stack(stackedList, listClass, stackableClass)](#new_Stack_new)
+    * [.empty()](#Stack+empty) ⇒ <code>boolean</code>
+    * [.top()](#Stack+top) ⇒ [<code>Stackable</code>](#Stackable)
+    * [.pop()](#Stack+pop) ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
+    * [.push(stackable)](#Stack+push)
+    * [.remove()](#Stack+remove) ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
+    * [.size()](#Stack+size) ⇒ <code>number</code>
+
+<a name="new_Stack_new"></a>
+
+### new Stack(stackedList, listClass, stackableClass)
+Instantiate the state with the starter stacked list.
+
+
+| Param | Type |
+| --- | --- |
+| stackedList | <code>Iterable</code> \| [<code>LinkedList</code>](#LinkedList) | 
+| listClass | <code>IsArrayable</code> | 
+| stackableClass | [<code>Stackable</code>](#Stackable) | 
+
+<a name="Stack+empty"></a>
+
+### stack.empty() ⇒ <code>boolean</code>
+Return true if the stack is empty (there are no tasks in the stacked list)
+
+**Kind**: instance method of [<code>Stack</code>](#Stack)  
+<a name="Stack+top"></a>
+
+### stack.top() ⇒ [<code>Stackable</code>](#Stackable)
+Take a look at the next stacked task
+
+**Kind**: instance method of [<code>Stack</code>](#Stack)  
+<a name="Stack+pop"></a>
+
+### stack.pop() ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
+Remove the next stacked task and return it.
+
+**Kind**: instance method of [<code>Stack</code>](#Stack)  
+<a name="Stack+push"></a>
+
+### stack.push(stackable)
+Push a stackable task to the top of the stack.
+
+**Kind**: instance method of [<code>Stack</code>](#Stack)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| stackable | [<code>Stackable</code>](#Stackable) \| <code>\*</code> | Add a new stackable to the top of the stack |
+
+<a name="Stack+remove"></a>
+
+### stack.remove() ⇒ [<code>Stackable</code>](#Stackable) \| <code>null</code>
+Remove the next stacked task and return it.
+
+**Kind**: instance method of [<code>Stack</code>](#Stack)  
+<a name="Stack+size"></a>
+
+### stack.size() ⇒ <code>number</code>
+Get the size of the current stack.
+
+**Kind**: instance method of [<code>Stack</code>](#Stack)  
+<a name="Queueable"></a>
+
+## Queueable ⇒ [<code>Queueable</code>](#Queueable)
+Make a new Queueable from the data given if it is not already a valid Queueable.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| queueable | [<code>Queueable</code>](#Queueable) \| <code>\*</code> |  | Return a valid Queueable instance from given data, or even an already valid one. |
+| [classType] | <code>IsLinker</code> | <code>Queueable</code> | Provide the type of IsLinker to use. |
+
+
+* [Queueable](#Queueable) ⇒ [<code>Queueable</code>](#Queueable)
+    * [new Queueable([queueableData])](#new_Queueable_new)
+    * _instance_
+        * [.isReady](#Queueable+isReady) ⇒ <code>boolean</code>
+        * [.task](#Queueable+task) ⇒ <code>\*</code>
+        * [.markCompleted(completeResponse)](#Queueable+markCompleted) ⇒ <code>completeResponse</code>
+        * [.run()](#Queueable+run) ⇒ <code>completeResponse</code>
+    * _static_
+        * [.fromArray(values, [classType])](#Queueable.fromArray) ⇒ <code>Object</code>
+
+<a name="new_Queueable_new"></a>
+
+### new Queueable([queueableData])
+Create a queueable item that can be used in a queue.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [queueableData] | <code>Object</code> | <code>{}</code> |  |
+| [queueableData.task] | <code>\*</code> | <code></code> | The data to be stored in this queueable |
+| [queueableData.next] | [<code>Queueable</code>](#Queueable) \| <code>null</code> | <code></code> | The reference to the next queueable if any |
+| [queueableData.ready] | <code>boolean</code> \| <code>function</code> | <code>false</code> | Indicate if the queueable is ready to run |
+
+<a name="Queueable+isReady"></a>
+
+### queueable.isReady ⇒ <code>boolean</code>
+Check ready state.
+
+**Kind**: instance property of [<code>Queueable</code>](#Queueable)  
+<a name="Queueable+task"></a>
+
+### queueable.task ⇒ <code>\*</code>
+Retrieve the data which should be formed as a task.
+
+**Kind**: instance property of [<code>Queueable</code>](#Queueable)  
+<a name="Queueable+markCompleted"></a>
+
+### queueable.markCompleted(completeResponse) ⇒ <code>completeResponse</code>
+Set this queueable as completed.
+
+**Kind**: instance method of [<code>Queueable</code>](#Queueable)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| completeResponse | <code>Object</code> |  |  |
+| [completeResponse.success] | <code>\*</code> | <code>true</code> | Indicate when the task failed (use false) or give a success message |
+| [completeResponse.error] | <code>\*</code> | <code>false</code> | Indicate a task was error-free (use false) or give an error message |
+| [completeResponse.context] | <code>\*</code> | <code></code> | Provide additional data in the response |
+
+<a name="Queueable+run"></a>
+
+### queueable.run() ⇒ <code>completeResponse</code>
+Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
+
+**Kind**: instance method of [<code>Queueable</code>](#Queueable)  
+<a name="Queueable.fromArray"></a>
+
+### Queueable.fromArray(values, [classType]) ⇒ <code>Object</code>
+Convert an array into Queueable instances, return the head and tail Queueables.
+
+**Kind**: static method of [<code>Queueable</code>](#Queueable)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| values | <code>Array</code> |  | Provide an array of data that will be converted to a chain of queueable linkers. |
+| [classType] | <code>IsLinker</code> | <code>Queueable</code> | Provide the type of IsLinker to use. |
+
+<a name="Queue"></a>
+
+## Queue ⇒ [<code>Queue</code>](#Queue)
+Convert an array to a Queue.
+
+**Kind**: global variable  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| values | <code>Array</code> | An array of values which will be converted to queueables in this queue |
+| queueableClass | [<code>Queueable</code>](#Queueable) | The class to use for each queueable |
+| listClass | [<code>Queue</code>](#Queue) \| <code>Iterable</code> | The class to use to manage the queueables |
+
+
+* [Queue](#Queue) ⇒ [<code>Queue</code>](#Queue)
+    * [new Queue(queuedList, listClass, queueableClass)](#new_Queue_new)
+    * [.dequeue()](#Queue+dequeue) ⇒ <code>completeResponse</code> \| <code>\*</code>
+    * [.empty()](#Queue+empty) ⇒ <code>boolean</code>
+    * [.enqueue(queueable)](#Queue+enqueue)
+    * [.peek()](#Queue+peek) ⇒ [<code>Queueable</code>](#Queueable)
+    * [.remove()](#Queue+remove) ⇒ [<code>Queueable</code>](#Queueable) \| <code>null</code>
+    * [.size()](#Queue+size) ⇒ <code>number</code>
+
+<a name="new_Queue_new"></a>
+
+### new Queue(queuedList, listClass, queueableClass)
+Instantiate the queue with the given queue list.
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| queuedList | <code>Iterable</code> \| [<code>LinkedList</code>](#LinkedList) | Give the list of queueables to start in this queue. |
+| listClass | <code>IsArrayable</code> |  |
+| queueableClass | [<code>Queueable</code>](#Queueable) |  |
+
+<a name="Queue+dequeue"></a>
+
+### queue.dequeue() ⇒ <code>completeResponse</code> \| <code>\*</code>
+Take a queued task from the front of the queue and run it if ready.
+
+**Kind**: instance method of [<code>Queue</code>](#Queue)  
+<a name="Queue+empty"></a>
+
+### queue.empty() ⇒ <code>boolean</code>
+Return true if the queue is empty (there are no tasks in the queue list)
+
+**Kind**: instance method of [<code>Queue</code>](#Queue)  
+<a name="Queue+enqueue"></a>
+
+### queue.enqueue(queueable)
+Add a queued task to the end of the queue
+
+**Kind**: instance method of [<code>Queue</code>](#Queue)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| queueable | [<code>Queueable</code>](#Queueable) | Add a new queueable to the end of the queue |
+
+<a name="Queue+peek"></a>
+
+### queue.peek() ⇒ [<code>Queueable</code>](#Queueable)
+Take a look at the next queued task
+
+**Kind**: instance method of [<code>Queue</code>](#Queue)  
+<a name="Queue+remove"></a>
+
+### queue.remove() ⇒ [<code>Queueable</code>](#Queueable) \| <code>null</code>
+Remove the next queued item and return it.
+
+**Kind**: instance method of [<code>Queue</code>](#Queue)  
+<a name="Queue+size"></a>
+
+### queue.size() ⇒ <code>number</code>
+Get the length of the current queue.
+
+**Kind**: instance method of [<code>Queue</code>](#Queue)  
+<a name="TreeLinker"></a>
+
+## TreeLinker ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Make a new DoubleLinker from the data given if it is not already a valid Linker.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| linker | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> |  | Return a valid TreeLinker instance from given data, or even an already valid one. |
+| [classType] | <code>IsTreeNode</code> | <code>TreeLinker</code> | Provide the type of IsTreeNode to use. |
+
+
+* [TreeLinker](#TreeLinker) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [new TreeLinker([settings], listClass)](#new_TreeLinker_new)
+    * _instance_
+        * [.childrenFromArray(children, listClass)](#TreeLinker+childrenFromArray) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList) \| <code>null</code>
+    * _static_
+        * [.fromArray([values], [classType])](#TreeLinker.fromArray) ⇒ <code>Object</code>
+
+<a name="new_TreeLinker_new"></a>
+
+### new TreeLinker([settings], listClass)
+Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [settings] | <code>Object</code> | <code>{}</code> |  |
+| [settings.data] | <code>\*</code> | <code></code> | The data to be stored in this tree node |
+| [settings.next] | [<code>TreeLinker</code>](#TreeLinker) | <code></code> | The reference to the next linker if any |
+| [settings.prev] | [<code>TreeLinker</code>](#TreeLinker) | <code></code> | The reference to the previous linker if any |
+| [settings.children] | [<code>LinkedTreeList</code>](#LinkedTreeList) | <code></code> | The references to child linkers if any |
+| [settings.parent] | [<code>TreeLinker</code>](#TreeLinker) | <code></code> | The reference to a parent linker if any |
+| listClass | <code>IsArrayable.&lt;IsTreeNode&gt;</code> |  | Give the type of list to use for storing the children |
+
+<a name="TreeLinker+childrenFromArray"></a>
+
+### treeLinker.childrenFromArray(children, listClass) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList) \| <code>null</code>
+Create the children for this tree from an array.
+
+**Kind**: instance method of [<code>TreeLinker</code>](#TreeLinker)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| children | <code>Array</code> \| <code>null</code> | Provide an array of data / linker references to be children of this tree node. |
+| listClass | <code>IsArrayable.&lt;IsTreeNode&gt;</code> | Give the type of list to use for storing the children |
+
+<a name="TreeLinker.fromArray"></a>
+
+### TreeLinker.fromArray([values], [classType]) ⇒ <code>Object</code>
+Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+
+**Kind**: static method of [<code>TreeLinker</code>](#TreeLinker)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [values] | <code>Array</code> | <code>[]</code> | Provide an array of data that will be converted to a chain of tree-linkers. |
+| [classType] | <code>IsTreeNode</code> | <code>TreeLinker</code> | Provide the type of IsTreeNode to use. |
+
+<a name="LinkedTreeList"></a>
+
+## LinkedTreeList ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+Convert an array into a LinkedTreeList instance, return the new instance.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [values] | <code>Array</code> | <code>[]</code> | An array of values which will be converted to nodes in this tree-list |
+| [linkerClass] | [<code>TreeLinker</code>](#TreeLinker) | <code>TreeLinker</code> | The class to use for each node |
+| [classType] | [<code>IsArrayable.&lt;TreeLinker&gt;</code>](#TreeLinker) | <code>LinkedTreeList</code> | Provide the type of IsArrayable to use. |
+
+
+* [LinkedTreeList](#LinkedTreeList) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [new LinkedTreeList()](#new_LinkedTreeList_new)
+    * [.list](#LinkedTreeList+list) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.first](#LinkedTreeList+first) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.last](#LinkedTreeList+last) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.length](#LinkedTreeList+length) ⇒ <code>number</code>
+    * [.parent](#LinkedTreeList+parent) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.parent](#LinkedTreeList+parent)
+    * [.rootParent](#LinkedTreeList+rootParent) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.initialize(initialList)](#LinkedTreeList+initialize) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.setChildren(item, children)](#LinkedTreeList+setChildren)
+    * [.insertAfter(node, newNode)](#LinkedTreeList+insertAfter) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.insertBefore(node, newNode)](#LinkedTreeList+insertBefore) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+    * [.append(node, after)](#LinkedTreeList+append) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.prepend(node, before)](#LinkedTreeList+prepend) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.remove(node)](#LinkedTreeList+remove) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.reset()](#LinkedTreeList+reset) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+    * [.item(index)](#LinkedTreeList+item) ⇒ [<code>TreeLinker</code>](#TreeLinker) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#LinkedTreeList+forEach)
+
+<a name="new_LinkedTreeList_new"></a>
+
+### new LinkedTreeList()
+Create the new LinkedTreeList instance, configure the list class.
+
+<a name="LinkedTreeList+list"></a>
+
+### linkedTreeList.list ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Retrieve a copy of the innerList used.
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>list</code>](#DoublyLinkedList+list)  
+<a name="LinkedTreeList+first"></a>
+
+### linkedTreeList.first ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Retrieve the first TreeLinker in the list.
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>first</code>](#DoublyLinkedList+first)  
+<a name="LinkedTreeList+last"></a>
+
+### linkedTreeList.last ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Retrieve the last TreeLinker in the list.
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>last</code>](#DoublyLinkedList+last)  
+<a name="LinkedTreeList+length"></a>
+
+### linkedTreeList.length ⇒ <code>number</code>
+Return the length of the list.
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>length</code>](#DoublyLinkedList+length)  
+<a name="LinkedTreeList+parent"></a>
+
+### linkedTreeList.parent ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Get the parent of this tree list.
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+<a name="LinkedTreeList+parent"></a>
+
+### linkedTreeList.parent
+Set the parent of this tree list
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| parent | [<code>TreeLinker</code>](#TreeLinker) | The new node to use as the parent for this group of children |
+
+<a name="LinkedTreeList+rootParent"></a>
+
+### linkedTreeList.rootParent ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Return the root parent of the entire tree.
+
+**Kind**: instance property of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+<a name="LinkedTreeList+initialize"></a>
+
+### linkedTreeList.initialize(initialList) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+Initialize the inner list, should only run once.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>initialize</code>](#DoublyLinkedList+initialize)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| initialList | [<code>TreeLinker</code>](#TreeLinker) | Give the list of tree-linkers to start in this linked-tree-list. |
+
+<a name="LinkedTreeList+setChildren"></a>
+
+### linkedTreeList.setChildren(item, children)
+Set the children on a parent item.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| item | [<code>TreeLinker</code>](#TreeLinker) | The TreeLinker node that will be the parent of the children |
+| children | [<code>LinkedTreeList</code>](#LinkedTreeList) | The LinkedTreeList which has the child nodes to use |
+
+<a name="LinkedTreeList+insertAfter"></a>
+
+### linkedTreeList.insertAfter(node, newNode) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+Insert a new node (or data) after a node.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>insertAfter</code>](#DoublyLinkedList+insertAfter)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> | The new node to go after the existing node |
+
+<a name="LinkedTreeList+insertBefore"></a>
+
+### linkedTreeList.insertBefore(node, newNode) ⇒ [<code>LinkedTreeList</code>](#LinkedTreeList)
+Insert a new node (or data) before a node.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>insertBefore</code>](#DoublyLinkedList+insertBefore)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> | The new node to go before the existing node |
+
+<a name="LinkedTreeList+append"></a>
+
+### linkedTreeList.append(node, after) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Add a node (or data) after the given (or last) node in the list.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>append</code>](#DoublyLinkedList+append)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> | The new node to add to the end of the list |
+| after | [<code>TreeLinker</code>](#TreeLinker) | The existing last node |
+
+<a name="LinkedTreeList+prepend"></a>
+
+### linkedTreeList.prepend(node, before) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Add a node (or data) before the given (or first) node in the list.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>prepend</code>](#DoublyLinkedList+prepend)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>TreeLinker</code>](#TreeLinker) \| <code>\*</code> | The new node to add to the start of the list |
+| before | [<code>TreeLinker</code>](#TreeLinker) | The existing first node |
+
+<a name="LinkedTreeList+remove"></a>
+
+### linkedTreeList.remove(node) ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Remove a linker from this linked list.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>remove</code>](#DoublyLinkedList+remove)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>TreeLinker</code>](#TreeLinker) | The node we wish to remove (and it will be returned after removal) |
+
+<a name="LinkedTreeList+reset"></a>
+
+### linkedTreeList.reset() ⇒ [<code>TreeLinker</code>](#TreeLinker)
+Refresh all references and return head reference.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>reset</code>](#DoublyLinkedList+reset)  
+<a name="LinkedTreeList+item"></a>
+
+### linkedTreeList.item(index) ⇒ [<code>TreeLinker</code>](#TreeLinker) \| <code>null</code>
+Retrieve a TreeLinker item from this list by numeric index, otherwise return null.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>item</code>](#DoublyLinkedList+item)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| index | <code>number</code> | The integer number for retrieving a node by position. |
+
+<a name="LinkedTreeList+forEach"></a>
+
+### linkedTreeList.forEach(callback, thisArg)
+Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Items.
+
+**Kind**: instance method of [<code>LinkedTreeList</code>](#LinkedTreeList)  
+**Overrides**: [<code>forEach</code>](#DoublyLinkedList+forEach)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| callback | <code>forEachCallback</code> | The function to call for-each tree node |
+| thisArg | [<code>LinkedTreeList</code>](#LinkedTreeList) | Optional, 'this' reference |
+
+<a name="Linker"></a>
+
+## Linker ⇒ [<code>Linker</code>](#Linker)
+Make a new Linker from the data given if it is not already a valid Linker.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| linker | [<code>Linker</code>](#Linker) \| <code>\*</code> |  | Return a valid Linker instance from given data, or even an already valid one. |
+| [classType] | <code>IsLinker</code> | <code>Linker</code> | Provide the type of IsLinker to use. |
+
+
+* [Linker](#Linker) ⇒ [<code>Linker</code>](#Linker)
+    * [new Linker([nodeData])](#new_Linker_new)
+    * [.fromArray([values], [classType])](#Linker.fromArray) ⇒ <code>Object</code>
+
+<a name="new_Linker_new"></a>
+
+### new Linker([nodeData])
+Create the new Linker instance, provide the data and optionally give the next Linker.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [nodeData] | <code>Object</code> | <code>{}</code> |  |
+| [nodeData.data] | <code>\*</code> | <code></code> | The data to be stored in this linker |
+| [nodeData.next] | [<code>Linker</code>](#Linker) \| <code>null</code> | <code></code> | The reference to the next linker if any |
+
+<a name="Linker.fromArray"></a>
+
+### Linker.fromArray([values], [classType]) ⇒ <code>Object</code>
+Convert an array into Linker instances, return the head and tail Linkers.
+
+**Kind**: static method of [<code>Linker</code>](#Linker)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [values] | <code>Array</code> | <code>[]</code> | Provide an array of data that will be converted to a chain of linkers. |
+| [classType] | <code>IsLinker</code> | <code>Linker</code> | Provide the type of IsLinker to use. |
+
+<a name="LinkedList"></a>
+
+## LinkedList ⇒ [<code>LinkedList</code>](#LinkedList)
+Convert an array to a LinkedList.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| values | <code>Array</code> |  | An array of values which will be converted to linkers in this linked-list |
+| linkerClass | <code>IsLinker</code> |  | The class to use for each linker |
+| [classType] | [<code>IsArrayable.&lt;Linker&gt;</code>](#Linker) | <code>LinkedList</code> | Provide the type of IsArrayable to use. |
+
+
+* [LinkedList](#LinkedList) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [new LinkedList()](#new_LinkedList_new)
+    * [.list](#LinkedList+list) ⇒ [<code>Linker</code>](#Linker)
+    * [.first](#LinkedList+first) ⇒ [<code>Linker</code>](#Linker)
+    * [.last](#LinkedList+last) ⇒ [<code>Linker</code>](#Linker)
+    * [.length](#LinkedList+length) ⇒ <code>number</code>
+    * [.initialize(initialList)](#LinkedList+initialize) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.insertAfter(node, newNode)](#LinkedList+insertAfter) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.insertBefore(node, newNode)](#LinkedList+insertBefore) ⇒ [<code>LinkedList</code>](#LinkedList)
+    * [.append(node, after)](#LinkedList+append) ⇒ [<code>Linker</code>](#Linker)
+    * [.prepend(node, before)](#LinkedList+prepend) ⇒ [<code>Linker</code>](#Linker)
+    * [.remove(node)](#LinkedList+remove) ⇒ [<code>Linker</code>](#Linker)
+    * [.item(index)](#LinkedList+item) ⇒ [<code>Linker</code>](#Linker) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#LinkedList+forEach) ⇒ [<code>LinkedList</code>](#LinkedList)
+
+<a name="new_LinkedList_new"></a>
+
+### new LinkedList()
+Create the new LinkedList instance.
+
+<a name="LinkedList+list"></a>
+
+### linkedList.list ⇒ [<code>Linker</code>](#Linker)
+Retrieve a copy of the innerList used.
+
+**Kind**: instance property of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>list</code>](#Arrayable+list)  
+<a name="LinkedList+first"></a>
+
+### linkedList.first ⇒ [<code>Linker</code>](#Linker)
+Retrieve the first Linker in the list.
+
+**Kind**: instance property of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>first</code>](#Arrayable+first)  
+<a name="LinkedList+last"></a>
+
+### linkedList.last ⇒ [<code>Linker</code>](#Linker)
+Retrieve the last Linker in the list.
+
+**Kind**: instance property of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>last</code>](#Arrayable+last)  
+<a name="LinkedList+length"></a>
+
+### linkedList.length ⇒ <code>number</code>
+Return the length of the list.
+
+**Kind**: instance property of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>length</code>](#Arrayable+length)  
+<a name="LinkedList+initialize"></a>
+
+### linkedList.initialize(initialList) ⇒ [<code>LinkedList</code>](#LinkedList)
+Initialize the inner list, should only run once.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>initialize</code>](#Arrayable+initialize)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| initialList | [<code>Linker</code>](#Linker) \| <code>Array</code> | Give the list of linkers to start in this linked-list. |
+
+<a name="LinkedList+insertAfter"></a>
+
+### linkedList.insertAfter(node, newNode) ⇒ [<code>LinkedList</code>](#LinkedList)
+Insert a new node (or data) after a node.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>insertAfter</code>](#Arrayable+insertAfter)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>Linker</code>](#Linker) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>Linker</code>](#Linker) \| <code>\*</code> | The new node to go after the existing node |
+
+<a name="LinkedList+insertBefore"></a>
+
+### linkedList.insertBefore(node, newNode) ⇒ [<code>LinkedList</code>](#LinkedList)
+Insert a new node (or data) before a node.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>insertBefore</code>](#Arrayable+insertBefore)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>Linker</code>](#Linker) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>Linker</code>](#Linker) \| <code>\*</code> | The new node to go before the existing node |
+
+<a name="LinkedList+append"></a>
+
+### linkedList.append(node, after) ⇒ [<code>Linker</code>](#Linker)
+Add a node (or data) after the given (or last) node in the list.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>append</code>](#Arrayable+append)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>Linker</code>](#Linker) \| <code>\*</code> | The new node to add to the end of the list |
+| after | [<code>Linker</code>](#Linker) | The existing last node |
+
+<a name="LinkedList+prepend"></a>
+
+### linkedList.prepend(node, before) ⇒ [<code>Linker</code>](#Linker)
+Add a node (or data) before the given (or first) node in the list.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>prepend</code>](#Arrayable+prepend)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>Linker</code>](#Linker) \| <code>\*</code> | The new node to add to the start of the list |
+| before | [<code>Linker</code>](#Linker) | The existing first node |
+
+<a name="LinkedList+remove"></a>
+
+### linkedList.remove(node) ⇒ [<code>Linker</code>](#Linker)
+Remove a linker from this linked list.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>remove</code>](#Arrayable+remove)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>Linker</code>](#Linker) | The node we wish to remove (and it will be returned after removal) |
+
+<a name="LinkedList+item"></a>
+
+### linkedList.item(index) ⇒ [<code>Linker</code>](#Linker) \| <code>null</code>
+Retrieve a Linker item from this list by numeric index, otherwise return null.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>item</code>](#Arrayable+item)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| index | <code>number</code> | The integer number for retrieving a node by position. |
+
+<a name="LinkedList+forEach"></a>
+
+### linkedList.forEach(callback, thisArg) ⇒ [<code>LinkedList</code>](#LinkedList)
+Be able to run forEach on this LinkedList to iterate over the linkers.
+
+**Kind**: instance method of [<code>LinkedList</code>](#LinkedList)  
+**Overrides**: [<code>forEach</code>](#Arrayable+forEach)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| callback | <code>forEachCallback</code> | The function to call for-each linker |
+| thisArg | [<code>LinkedList</code>](#LinkedList) | Optional, 'this' reference |
+
+<a name="DoublyLinkedList"></a>
+
+## DoublyLinkedList ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+Convert an array into a DoublyLinkedList instance, return the new instance.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [values] | <code>Array</code> | <code>[]</code> | An array of values which will be converted to linkers in this doubly-linked-list |
+| [linkerClass] | <code>IsDoubleLinker</code> | <code>DoubleLinker</code> | The class to use for each linker |
+| [classType] | <code>IsArrayable.&lt;IsDoubleLinker&gt;</code> | <code>LinkedList</code> | Provide the type of IsArrayable to use. |
+
+
+* [DoublyLinkedList](#DoublyLinkedList) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [new DoublyLinkedList()](#new_DoublyLinkedList_new)
+    * [.list](#DoublyLinkedList+list) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.first](#DoublyLinkedList+first) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.last](#DoublyLinkedList+last) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.length](#DoublyLinkedList+length) ⇒ <code>number</code>
+    * [.initialize(initialList)](#DoublyLinkedList+initialize) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.insertAfter(node, newNode)](#DoublyLinkedList+insertAfter) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.insertBefore(node, newNode)](#DoublyLinkedList+insertBefore) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+    * [.append(node, after)](#DoublyLinkedList+append) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.prepend(node, before)](#DoublyLinkedList+prepend) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.remove(node)](#DoublyLinkedList+remove) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.reset()](#DoublyLinkedList+reset) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [.item(index)](#DoublyLinkedList+item) ⇒ [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#DoublyLinkedList+forEach)
+
+<a name="new_DoublyLinkedList_new"></a>
+
+### new DoublyLinkedList()
+Create the new DoublyLinkedList instance.
+
+<a name="DoublyLinkedList+list"></a>
+
+### doublyLinkedList.list ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Retrieve a copy of the innerList used.
+
+**Kind**: instance property of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>list</code>](#LinkedList+list)  
+<a name="DoublyLinkedList+first"></a>
+
+### doublyLinkedList.first ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Retrieve the first DoubleLinker in the list.
+
+**Kind**: instance property of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>first</code>](#LinkedList+first)  
+<a name="DoublyLinkedList+last"></a>
+
+### doublyLinkedList.last ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Retrieve the last DoubleLinker in the list.
+
+**Kind**: instance property of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>last</code>](#LinkedList+last)  
+<a name="DoublyLinkedList+length"></a>
+
+### doublyLinkedList.length ⇒ <code>number</code>
+Return the length of the list.
+
+**Kind**: instance property of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>length</code>](#LinkedList+length)  
+<a name="DoublyLinkedList+initialize"></a>
+
+### doublyLinkedList.initialize(initialList) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+Initialize the inner list, should only run once.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>initialize</code>](#LinkedList+initialize)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| initialList | [<code>DoubleLinker</code>](#DoubleLinker) | Give the list of double-linkers to start in this doubly linked-list. |
+
+<a name="DoublyLinkedList+insertAfter"></a>
+
+### doublyLinkedList.insertAfter(node, newNode) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+Insert a new node (or data) after a node.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>insertAfter</code>](#LinkedList+insertAfter)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> | The new node to go after the existing node |
+
+<a name="DoublyLinkedList+insertBefore"></a>
+
+### doublyLinkedList.insertBefore(node, newNode) ⇒ [<code>DoublyLinkedList</code>](#DoublyLinkedList)
+Insert a new node (or data) before a node.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>insertBefore</code>](#LinkedList+insertBefore)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> | The new node to go before the existing node |
+
+<a name="DoublyLinkedList+append"></a>
+
+### doublyLinkedList.append(node, after) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Add a node (or data) after the given (or last) node in the list.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>append</code>](#LinkedList+append)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> | The new node to add to the end of the list |
+| after | [<code>DoubleLinker</code>](#DoubleLinker) | The existing last node |
+
+<a name="DoublyLinkedList+prepend"></a>
+
+### doublyLinkedList.prepend(node, before) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Add a node (or data) before the given (or first) node in the list.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>prepend</code>](#LinkedList+prepend)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> | The new node to add to the start of the list |
+| before | [<code>DoubleLinker</code>](#DoubleLinker) | The existing first node |
+
+<a name="DoublyLinkedList+remove"></a>
+
+### doublyLinkedList.remove(node) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Remove a linker from this linked list.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>remove</code>](#LinkedList+remove)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>DoubleLinker</code>](#DoubleLinker) | The node we wish to remove (and it will be returned after removal) |
+
+<a name="DoublyLinkedList+reset"></a>
+
+### doublyLinkedList.reset() ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Refresh all references and return head reference.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+<a name="DoublyLinkedList+item"></a>
+
+### doublyLinkedList.item(index) ⇒ [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code>
+Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>item</code>](#LinkedList+item)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| index | <code>number</code> | The integer number for retrieving a node by position. |
+
+<a name="DoublyLinkedList+forEach"></a>
+
+### doublyLinkedList.forEach(callback, thisArg)
+Be able to run forEach on this DoublyLinkedList to iterate over the DoubleLinker Items.
+
+**Kind**: instance method of [<code>DoublyLinkedList</code>](#DoublyLinkedList)  
+**Overrides**: [<code>forEach</code>](#LinkedList+forEach)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| callback | <code>forEachCallback</code> | The function to call for-each double linker |
+| thisArg | [<code>DoublyLinkedList</code>](#DoublyLinkedList) | Optional, 'this' reference |
+
+<a name="DoubleLinker"></a>
+
+## DoubleLinker ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+Make a new DoubleLinker from the data given if it is not already a valid Linker.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| linker | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>\*</code> |  | Return a valid Linker instance from given data, or even an already valid one. |
+| [classType] | <code>IsDoubleLinker</code> | <code>DoubleLinker</code> | Provide the type of IsDoubleLinker to use. |
+
+
+* [DoubleLinker](#DoubleLinker) ⇒ [<code>DoubleLinker</code>](#DoubleLinker)
+    * [new DoubleLinker([nodeData])](#new_DoubleLinker_new)
+    * [.fromArray([values], [classType])](#DoubleLinker.fromArray) ⇒ <code>Object</code>
+
+<a name="new_DoubleLinker_new"></a>
+
+### new DoubleLinker([nodeData])
+Create the new DoubleLinker instance, provide the data and optionally the next and prev references.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [nodeData] | <code>Object</code> | <code>{}</code> |  |
+| [nodeData.data] | <code>\*</code> | <code></code> | The data to be stored in this linker |
+| [nodeData.next] | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code> | <code></code> | The reference to the next linker if any |
+| [nodeData.prev] | [<code>DoubleLinker</code>](#DoubleLinker) \| <code>null</code> | <code></code> | The reference to the previous linker if any |
+
+<a name="DoubleLinker.fromArray"></a>
+
+### DoubleLinker.fromArray([values], [classType]) ⇒ <code>Object</code>
+Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+
+**Kind**: static method of [<code>DoubleLinker</code>](#DoubleLinker)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [values] | <code>Array</code> | <code>[]</code> | Provide an array of data that will be converted to a chain of linkers. |
+| [classType] | <code>IsDoubleLinker</code> | <code>DoubleLinker</code> | Provide the type of IsDoubleLinker to use. |
+
+<a name="Arrayable"></a>
+
+## Arrayable ⇒ [<code>Arrayable</code>](#Arrayable)
+Convert an array to an Arrayable.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| values | <code>Array</code> |  | An array of values which will be converted to elements in this arrayable |
+| [elementClass] | <code>IsElement</code> | <code>ArrayElement</code> | The class to use for each element |
+| [classType] | [<code>IsArrayable.&lt;ArrayElement&gt;</code>](#ArrayElement) | <code>Arrayable</code> | Provide the type of IsArrayable to use. |
+
+
+* [Arrayable](#Arrayable) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [new Arrayable()](#new_Arrayable_new)
+    * [.list](#Arrayable+list) ⇒ [<code>Array.&lt;ArrayElement&gt;</code>](#ArrayElement)
+    * [.first](#Arrayable+first) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [.last](#Arrayable+last) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [.length](#Arrayable+length) ⇒ <code>number</code>
+    * [.initialize(initialList)](#Arrayable+initialize) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.insertAfter(node, newNode)](#Arrayable+insertAfter) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.insertBefore(node, newNode)](#Arrayable+insertBefore) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.append(node, after)](#Arrayable+append) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.prepend(node, before)](#Arrayable+prepend) ⇒ [<code>Arrayable</code>](#Arrayable)
+    * [.remove(node)](#Arrayable+remove) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [.item(index)](#Arrayable+item) ⇒ [<code>ArrayElement</code>](#ArrayElement) \| <code>null</code>
+    * [.forEach(callback, thisArg)](#Arrayable+forEach) ⇒ [<code>Arrayable</code>](#Arrayable)
+
+<a name="new_Arrayable_new"></a>
+
+### new Arrayable()
+Create the new Arrayable instance, configure the Arrayable class.
+
+<a name="Arrayable+list"></a>
+
+### arrayable.list ⇒ [<code>Array.&lt;ArrayElement&gt;</code>](#ArrayElement)
+Retrieve a copy of the innerList used.
+
+**Kind**: instance property of [<code>Arrayable</code>](#Arrayable)  
+<a name="Arrayable+first"></a>
+
+### arrayable.first ⇒ [<code>ArrayElement</code>](#ArrayElement)
+Retrieve the first Element from the Arrayable
+
+**Kind**: instance property of [<code>Arrayable</code>](#Arrayable)  
+<a name="Arrayable+last"></a>
+
+### arrayable.last ⇒ [<code>ArrayElement</code>](#ArrayElement)
+Retrieve the last Element from the Arrayable
+
+**Kind**: instance property of [<code>Arrayable</code>](#Arrayable)  
+<a name="Arrayable+length"></a>
+
+### arrayable.length ⇒ <code>number</code>
+Return the length of the list.
+
+**Kind**: instance property of [<code>Arrayable</code>](#Arrayable)  
+<a name="Arrayable+initialize"></a>
+
+### arrayable.initialize(initialList) ⇒ [<code>Arrayable</code>](#Arrayable)
+Initialize the inner list, should only run once.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| initialList | [<code>Array.&lt;ArrayElement&gt;</code>](#ArrayElement) | Give the array of elements to start in this Arrayable. |
+
+<a name="Arrayable+insertAfter"></a>
+
+### arrayable.insertAfter(node, newNode) ⇒ [<code>Arrayable</code>](#Arrayable)
+Insert a new node (or data) after a node.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> | The new node to go after the existing node |
+
+<a name="Arrayable+insertBefore"></a>
+
+### arrayable.insertBefore(node, newNode) ⇒ [<code>Arrayable</code>](#Arrayable)
+Insert a new node (or data) before a node.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> | The existing node as reference |
+| newNode | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> | The new node to go before the existing node |
+
+<a name="Arrayable+append"></a>
+
+### arrayable.append(node, after) ⇒ [<code>Arrayable</code>](#Arrayable)
+Add a node (or data) after the given (or last) node in the list.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> | The new node to add to the end of the list |
+| after | [<code>ArrayElement</code>](#ArrayElement) | The existing last node |
+
+<a name="Arrayable+prepend"></a>
+
+### arrayable.prepend(node, before) ⇒ [<code>Arrayable</code>](#Arrayable)
+Add a node (or data) before the given (or first) node in the list.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> | The new node to add to the start of the list |
+| before | [<code>ArrayElement</code>](#ArrayElement) | The existing first node |
+
+<a name="Arrayable+remove"></a>
+
+### arrayable.remove(node) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+Remove an element from this arrayable.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| node | [<code>ArrayElement</code>](#ArrayElement) | The node we wish to remove (and it will be returned after removal) |
+
+<a name="Arrayable+item"></a>
+
+### arrayable.item(index) ⇒ [<code>ArrayElement</code>](#ArrayElement) \| <code>null</code>
+Retrieve an ArrayElement item from this list by numeric index, otherwise return null.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| index | <code>number</code> | The integer number for retrieving a node by position. |
+
+<a name="Arrayable+forEach"></a>
+
+### arrayable.forEach(callback, thisArg) ⇒ [<code>Arrayable</code>](#Arrayable)
+Be able to run forEach on this Arrayable to iterate over the elements.
+
+**Kind**: instance method of [<code>Arrayable</code>](#Arrayable)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| callback | <code>forEachCallback</code> | The function to call for-each element |
+| thisArg | [<code>Arrayable</code>](#Arrayable) | Optional, 'this' reference |
+
+<a name="ArrayElement"></a>
+
+## ArrayElement ⇒ [<code>ArrayElement</code>](#ArrayElement)
+Make a new Element from the data given if it is not already a valid Element.
+
+**Kind**: global variable  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| element | [<code>ArrayElement</code>](#ArrayElement) \| <code>\*</code> |  | Return a valid ArrayElement instance from given data, or even an already valid one. |
+| [classType] | <code>IsElement</code> | <code>ArrayElement</code> | Provide the type of IsElement to use. |
+
+
+* [ArrayElement](#ArrayElement) ⇒ [<code>ArrayElement</code>](#ArrayElement)
+    * [new ArrayElement([data])](#new_ArrayElement_new)
+    * [.fromArray([values], [classType])](#ArrayElement.fromArray) ⇒ <code>Object</code>
+
+<a name="new_ArrayElement_new"></a>
+
+### new ArrayElement([data])
+Create the new Element instance, provide the data and optionally configure the type of Element.
+
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [data] | <code>\*</code> | <code></code> | The data to be stored in this element. |
+
 <a name="ArrayElement.fromArray"></a>
 
 ### ArrayElement.fromArray([values], [classType]) ⇒ <code>Object</code>