collect-your-stuff 2.1.1 → 2.1.2

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

@@ -1,122 +1,122 @@
-/**
- * @file arrayable list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { ArrayElement } from './ArrayElement';
-import { forEachCallback, IsArrayable } from '../../recipes/IsArrayable';
-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.
-     * @return {Arrayable}
-     */
-    initialize(initialList: Array<ArrayElement>): Arrayable;
-    /**
-     * 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|null} The first element, or null when the Arrayable is empty
-     */
-    get first(): ArrayElement | null;
-    /**
-     * Retrieve the last Element from the Arrayable
-     * @returns {ArrayElement|null} The last element, or null when the Arrayable is empty
-     */
-    get last(): ArrayElement | null;
-    /**
-     * Return the length of the list.
-     * @returns {number}
-     */
-    get length(): number;
-    /**
-     * Insert a new node (or data) after a node.
-     * @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 | null, newNode: ArrayElement | any): Arrayable;
-    /**
-     * Insert a new node (or data) before a node.
-     * @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 | 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
-     * @param {ArrayElement} after The existing last node
-     * @returns {Arrayable}
-     */
-    append(node: ArrayElement | any, after?: ArrayElement | null): Arrayable;
-    /**
-     * Add a node (or data) before the given (or first) node in the list.
-     * @param {ArrayElement|*} node The new node to add to the start of the list
-     * @param {ArrayElement} before The existing first node
-     * @returns {Arrayable}
-     */
-    prepend(node: ArrayElement | any, before?: ArrayElement | null): 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|null} The removed node, or null when it was not in this list (nothing is removed)
-     */
-    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.
-     * @return {ArrayElement|null}
-     */
-    item(index: number): ArrayElement | null;
-    /**
-     * Be able to run forEach on this Arrayable to iterate over the elements.
-     * @param {forEachCallback} callback The function to call for-each element
-     * @param {Arrayable} thisArg Optional, 'this' reference
-     * @returns {Arrayable}
-     */
-    forEach(callback: forEachCallback, thisArg?: Arrayable): Arrayable;
-    /**
-     * Be able to iterate over this class.
-     * @returns {Iterator}
-     */
-    [Symbol.iterator](): Iterator<ArrayElement>;
-    /**
-     * Convert an array to an Arrayable.
-     * @param {Array} values An array of values which will be converted to elements in this arrayable
-     * @param {IsElement} [elementClass=ArrayElement] The class to use for each element
-     * @param {IsArrayable<ArrayElement>} [classType=Arrayable] Provide the type of IsArrayable to use.
-     * @returns {Arrayable}
-     */
-    static fromArray: (values?: Array<any>, elementClass?: typeof ArrayElement, classType?: any) => IsArrayable<IsElement>;
-}
+/**
+ * @file arrayable list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { ArrayElement } from './ArrayElement';
+import { forEachCallback, IsArrayable } from '../../recipes/IsArrayable';
+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.
+     * @return {Arrayable}
+     */
+    initialize(initialList: Array<ArrayElement>): Arrayable;
+    /**
+     * 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|null} The first element, or null when the Arrayable is empty
+     */
+    get first(): ArrayElement | null;
+    /**
+     * Retrieve the last Element from the Arrayable
+     * @returns {ArrayElement|null} The last element, or null when the Arrayable is empty
+     */
+    get last(): ArrayElement | null;
+    /**
+     * Return the length of the list.
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * Insert a new node (or data) after a node.
+     * @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 | null, newNode: ArrayElement | any): Arrayable;
+    /**
+     * Insert a new node (or data) before a node.
+     * @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 | 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
+     * @param {ArrayElement} after The existing last node
+     * @returns {Arrayable}
+     */
+    append(node: ArrayElement | any, after?: ArrayElement | null): Arrayable;
+    /**
+     * Add a node (or data) before the given (or first) node in the list.
+     * @param {ArrayElement|*} node The new node to add to the start of the list
+     * @param {ArrayElement} before The existing first node
+     * @returns {Arrayable}
+     */
+    prepend(node: ArrayElement | any, before?: ArrayElement | null): 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|null} The removed node, or null when it was not in this list (nothing is removed)
+     */
+    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.
+     * @return {ArrayElement|null}
+     */
+    item(index: number): ArrayElement | null;
+    /**
+     * Be able to run forEach on this Arrayable to iterate over the elements.
+     * @param {forEachCallback} callback The function to call for-each element
+     * @param {Arrayable} thisArg Optional, 'this' reference
+     * @returns {Arrayable}
+     */
+    forEach(callback: forEachCallback, thisArg?: Arrayable): Arrayable;
+    /**
+     * Be able to iterate over this class.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator](): Iterator<ArrayElement>;
+    /**
+     * Convert an array to an Arrayable.
+     * @param {Array} values An array of values which will be converted to elements in this arrayable
+     * @param {IsElement} [elementClass=ArrayElement] The class to use for each element
+     * @param {IsArrayable<ArrayElement>} [classType=Arrayable] Provide the type of IsArrayable to use.
+     * @returns {Arrayable}
+     */
+    static fromArray: (values?: Array<any>, elementClass?: typeof ArrayElement, classType?: any) => IsArrayable<IsElement>;
+}

package/dist/collections/arrayable/Arrayable.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.Arrayable = void 0
-var _ArrayElement = require('./ArrayElement')
-var _ArrayIterator = require('../../recipes/ArrayIterator')
+const _ArrayElement = require('./ArrayElement')
+const _ArrayIterator = require('../../recipes/ArrayIterator')
 /**
  * @file arrayable list.
  * @author Joshua Heagle <joshuaheagle@gmail.com>

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

@@ -1,50 +1,50 @@
-/**
- * @file doubly linked list item.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { IsDoubleLinker } from '../../recipes/IsDoubleLinker';
-/**
- * DoubleLinker represents a node in a DoublyLinkedList which is chained by next and prev.
- * @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={}] 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
-     */
-    constructor({ data, next, prev }?: {
-        data?: any;
-        next?: DoubleLinker | null;
-        prev?: DoubleLinker | null;
-    });
-    /**
-     * Make a new DoubleLinker from the data given if it is not already a valid Linker.
-     * @param {DoubleLinker|*} linker Return a valid Linker instance from given data, or even an already valid one.
-     * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
-     * @return {DoubleLinker}
-     */
-    static make: (linker: DoubleLinker | any, classType?: any) => IsDoubleLinker | any;
-    /**
-     * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
-     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of linkers.
-     * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
-     * @returns {{head: DoubleLinker, tail: DoubleLinker}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: DoubleLinker | any;
-        tail: DoubleLinker | any;
-    };
-}
+/**
+ * @file doubly linked list item.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { IsDoubleLinker } from '../../recipes/IsDoubleLinker';
+/**
+ * DoubleLinker represents a node in a DoublyLinkedList which is chained by next and prev.
+ * @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={}] 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
+     */
+    constructor({ data, next, prev }?: {
+        data?: any;
+        next?: DoubleLinker | null;
+        prev?: DoubleLinker | null;
+    });
+    /**
+     * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+     * @param {DoubleLinker|*} linker Return a valid Linker instance from given data, or even an already valid one.
+     * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
+     * @return {DoubleLinker}
+     */
+    static make: (linker: DoubleLinker | any, classType?: any) => IsDoubleLinker | any;
+    /**
+     * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of linkers.
+     * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
+     * @returns {{head: DoubleLinker, tail: DoubleLinker}}
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: DoubleLinker | any;
+        tail: DoubleLinker | any;
+    };
+}

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, '__esModule', {
 exports.DoubleLinker = void 0
 require('core-js/modules/esnext.iterator.constructor.js')
 require('core-js/modules/esnext.iterator.reduce.js')
-var _Linker = require('../linked-list/Linker')
+const _Linker = require('../linked-list/Linker')
 /**
  * DoubleLinker represents a node in a DoublyLinkedList which is chained by next and prev.
  * @extends Linker

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

@@ -1,125 +1,125 @@
-/**
- * @file doubly linked list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { DoubleLinker } from './DoubleLinker';
-import { forEachCallback, IsArrayable } from '../../recipes/IsArrayable';
-import { IsDoubleLinker } from '../../recipes/IsDoubleLinker';
-/**
- * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
- * @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;
-    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
-    private tailCache;
-    /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
-    private countCache;
-    /**
-     * Create the new DoublyLinkedList instance.
-     * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
-     */
-    constructor(linkerClass?: typeof DoubleLinker);
-    /**
-     * Initialize the inner list, should only run once.
-     * @param {DoubleLinker} initialList Give the list of double-linkers to start in this doubly linked-list.
-     * @return {DoublyLinkedList}
-     */
-    initialize(initialList: DoubleLinker): DoublyLinkedList;
-    /**
-     * Retrieve the innerList used (the list itself, not a copy).
-     * @returns {DoubleLinker}
-     */
-    get list(): DoubleLinker;
-    /**
-     * Retrieve the first DoubleLinker in the list.
-     * @returns {DoubleLinker}
-     */
-    get first(): DoubleLinker | null;
-    /**
-     * Retrieve the last DoubleLinker in the list. The end is remembered, so this does not walk the list.
-     * @returns {DoubleLinker}
-     */
-    get last(): DoubleLinker | null;
-    /**
-     * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
-     * (call reset() after linkers were changed directly).
-     * @returns {number}
-     */
-    get length(): number;
-    /**
-     * Insert a new node (or data) after a node.
-     * @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 | null, newNode: DoubleLinker | any): DoublyLinkedList;
-    /**
-     * Insert a new node (or data) before a node.
-     * @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 | 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
-     * @param {DoubleLinker} after The existing last node
-     * @returns {DoubleLinker}
-     */
-    append(node: DoubleLinker | any, after?: DoubleLinker): DoublyLinkedList;
-    /**
-     * Add a node (or data) before the given (or first) node in the list.
-     * @param {DoubleLinker|*} node The new node to add to the start of the list
-     * @param {DoubleLinker} before The existing first node
-     * @returns {DoubleLinker}
-     */
-    prepend(node: DoubleLinker | any, before?: DoubleLinker): DoublyLinkedList;
-    /**
-     * Remove a linker from this linked list.
-     * @param {DoubleLinker} node The node we wish to remove (and it will be returned after removal)
-     * @return {DoubleLinker}
-     */
-    remove(node: DoubleLinker | null): DoubleLinker | null;
-    /**
-     * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The list's
-     * own methods keep these up to date, so this is only needed after linkers were changed directly.
-     * @return {DoubleLinker|null}
-     */
-    reset(): DoubleLinker | null;
-    /**
-     * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
-     * @param {number} index The integer number for retrieving a node by position.
-     * @returns {DoubleLinker|null}
-     */
-    item(index: number): DoubleLinker;
-    /**
-     * 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;
-    /**
-     * Be able to iterate over this class.
-     * @returns {Iterator}
-     */
-    [Symbol.iterator](): Iterator<DoubleLinker>;
-    /**
-     * Convert an array into a DoublyLinkedList instance, return the new instance.
-     * @param {Array} [values=[]] An array of values which will be converted to linkers in this doubly-linked-list
-     * @param {IsDoubleLinker} [linkerClass=DoubleLinker] The class to use for each linker
-     * @param {IsArrayable<IsDoubleLinker>} [classType=LinkedList] Provide the type of IsArrayable to use.
-     * @returns {DoublyLinkedList}
-     */
-    static fromArray: (values?: Array<any>, linkerClass?: typeof DoubleLinker, classType?: any) => IsArrayable<IsDoubleLinker> | any;
-}
+/**
+ * @file doubly linked list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { DoubleLinker } from './DoubleLinker';
+import { forEachCallback, IsArrayable } from '../../recipes/IsArrayable';
+import { IsDoubleLinker } from '../../recipes/IsDoubleLinker';
+/**
+ * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
+ * @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;
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    private tailCache;
+    /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+    private countCache;
+    /**
+     * Create the new DoublyLinkedList instance.
+     * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
+     */
+    constructor(linkerClass?: typeof DoubleLinker);
+    /**
+     * Initialize the inner list, should only run once.
+     * @param {DoubleLinker} initialList Give the list of double-linkers to start in this doubly linked-list.
+     * @return {DoublyLinkedList}
+     */
+    initialize(initialList: DoubleLinker): DoublyLinkedList;
+    /**
+     * Retrieve the innerList used (the list itself, not a copy).
+     * @returns {DoubleLinker}
+     */
+    get list(): DoubleLinker;
+    /**
+     * Retrieve the first DoubleLinker in the list.
+     * @returns {DoubleLinker}
+     */
+    get first(): DoubleLinker | null;
+    /**
+     * Retrieve the last DoubleLinker in the list. The end is remembered, so this does not walk the list.
+     * @returns {DoubleLinker}
+     */
+    get last(): DoubleLinker | null;
+    /**
+     * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
+     * (call reset() after linkers were changed directly).
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * Insert a new node (or data) after a node.
+     * @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 | null, newNode: DoubleLinker | any): DoublyLinkedList;
+    /**
+     * Insert a new node (or data) before a node.
+     * @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 | 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
+     * @param {DoubleLinker} after The existing last node
+     * @returns {DoubleLinker}
+     */
+    append(node: DoubleLinker | any, after?: DoubleLinker): DoublyLinkedList;
+    /**
+     * Add a node (or data) before the given (or first) node in the list.
+     * @param {DoubleLinker|*} node The new node to add to the start of the list
+     * @param {DoubleLinker} before The existing first node
+     * @returns {DoubleLinker}
+     */
+    prepend(node: DoubleLinker | any, before?: DoubleLinker): DoublyLinkedList;
+    /**
+     * Remove a linker from this linked list.
+     * @param {DoubleLinker} node The node we wish to remove (and it will be returned after removal)
+     * @return {DoubleLinker}
+     */
+    remove(node: DoubleLinker | null): DoubleLinker | null;
+    /**
+     * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The list's
+     * own methods keep these up to date, so this is only needed after linkers were changed directly.
+     * @return {DoubleLinker|null}
+     */
+    reset(): DoubleLinker | null;
+    /**
+     * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
+     * @param {number} index The integer number for retrieving a node by position.
+     * @returns {DoubleLinker|null}
+     */
+    item(index: number): DoubleLinker;
+    /**
+     * 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;
+    /**
+     * Be able to iterate over this class.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator](): Iterator<DoubleLinker>;
+    /**
+     * Convert an array into a DoublyLinkedList instance, return the new instance.
+     * @param {Array} [values=[]] An array of values which will be converted to linkers in this doubly-linked-list
+     * @param {IsDoubleLinker} [linkerClass=DoubleLinker] The class to use for each linker
+     * @param {IsArrayable<IsDoubleLinker>} [classType=LinkedList] Provide the type of IsArrayable to use.
+     * @returns {DoublyLinkedList}
+     */
+    static fromArray: (values?: Array<any>, linkerClass?: typeof DoubleLinker, classType?: any) => IsArrayable<IsDoubleLinker> | any;
+}

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

@@ -6,9 +6,9 @@ Object.defineProperty(exports, '__esModule', {
 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')
-var _DoubleLinkerIterator = require('../../recipes/DoubleLinkerIterator')
-var _LinkedList = require('../linked-list/LinkedList')
+const _DoubleLinker = require('./DoubleLinker')
+const _DoubleLinkerIterator = require('../../recipes/DoubleLinkerIterator')
+const _LinkedList = require('../linked-list/LinkedList')
 /**
  * @file doubly linked list.
  * @author Joshua Heagle <joshuaheagle@gmail.com>