collect-your-stuff 2.1.0 → 2.1.2

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

@@ -1,159 +1,159 @@
-/**
- * @file doubly linked tree list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { TreeLinker } from './TreeLinker';
-import { forEachCallback } from '../../recipes/IsArrayable';
-import { IsTree } from '../../recipes/IsTree';
-import { IsTreeNode } from '../../recipes/IsTreeNode';
-/**
- * LinkedTreeList represents a collection stored with a root and spreading in branching (tree) formation.
- * @extends DoublyLinkedList
- */
-export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    readonly classType: typeof LinkedTreeList;
-    /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
-    innerList: IsTreeNode | any;
-    /** 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 tree linkers. */
-    linkerClass: typeof TreeLinker;
-    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
-    private tailCache;
-    /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
-    private countCache;
-    /** The node these linkers are the children of, remembered so that it is known even while the list is empty (undefined until it is known). */
-    private ownerNode;
-    /**
-     * Create the new LinkedTreeList instance, configure the list class.
-     * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
-     */
-    constructor(linkerClass?: typeof TreeLinker);
-    /**
-     * Initialize the inner list, should only run once.
-     * @param {TreeLinker} initialList Give the list of tree-linkers to start in this linked-tree-list.
-     * @return {LinkedTreeList}
-     */
-    initialize(initialList: TreeLinker): LinkedTreeList;
-    /**
-     * Retrieve the innerList used (the list itself, not a copy).
-     * @returns {TreeLinker}
-     */
-    get list(): TreeLinker;
-    /**
-     * Retrieve the first TreeLinker in the list.
-     * @returns {TreeLinker}
-     */
-    get first(): TreeLinker;
-    /**
-     * Retrieve the last TreeLinker in the list. The end is remembered, so this does not walk the list.
-     * @returns {TreeLinker}
-     */
-    get last(): TreeLinker;
-    /**
-     * Return the length of the list. 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;
-    /**
-     * Get the parent of this tree list: the node these linkers are the children of (remembered even while the list is
-     * empty), or null for the linkers at the top of a tree.
-     * @return {TreeLinker|null}
-     */
-    get parent(): TreeLinker | null;
-    /**
-     * Set the parent of this tree list: every linker in it gets the node as its parent, and the node gets this list as its
-     * children. Linkers added to the list later get this parent too.
-     * @param {TreeLinker|null} parent The new node to use as the parent for this group of children
-     */
-    set parent(parent: TreeLinker | null);
-    /**
-     * Return the root parent of the entire tree.
-     * @return {TreeLinker}
-     */
-    get rootParent(): TreeLinker;
-    /**
-     * Set the children on a parent item.
-     * @param {TreeLinker} item The TreeLinker node (one of the linkers of this list) that will be the parent of the children
-     * @param {LinkedTreeList|null} [children=null] The LinkedTreeList which has the child nodes to use, or null to remove the children of the item
-     * @throws {Error} When the item is not one of the linkers of this list
-     */
-    setChildren(item: TreeLinker, children?: LinkedTreeList | null): void;
-    /**
-     * Make a linker of the given node (or data) and make this list's parent its parent.
-     * @param {TreeLinker|*} newNode The node (or data) which is being added to this list
-     * @returns {TreeLinker}
-     */
-    private adopt;
-    /**
-     * Insert a new node (or data) after a node. The new node gets the parent of this list.
-     * @param {TreeLinker|*} node The existing node as reference, or null to insert at the start of the list
-     * @param {TreeLinker|*} newNode The new node to go after the existing node
-     * @returns {LinkedTreeList}
-     */
-    insertAfter(node: TreeLinker | null, newNode: TreeLinker | any): LinkedTreeList;
-    /**
-     * Insert a new node (or data) before a node. The new node gets the parent of this list.
-     * @param {TreeLinker|*} node The existing node as reference, or null to insert at the end of the list
-     * @param {TreeLinker|*} newNode The new node to go before the existing node
-     * @returns {LinkedTreeList}
-     */
-    insertBefore(node: TreeLinker | null, newNode: TreeLinker | any): LinkedTreeList;
-    /**
-     * Add a node (or data) after the given (or last) node in the list.
-     * @param {TreeLinker|*} node The new node to add to the end of the list
-     * @param {TreeLinker} after The existing last node
-     * @returns {TreeLinker}
-     */
-    append(node: TreeLinker | any, after?: TreeLinker): LinkedTreeList;
-    /**
-     * Add a node (or data) before the given (or first) node in the list.
-     * @param {TreeLinker|*} node The new node to add to the start of the list
-     * @param {TreeLinker} before The existing first node
-     * @returns {TreeLinker}
-     */
-    prepend(node: TreeLinker | any, before?: TreeLinker): LinkedTreeList;
-    /**
-     * Remove a linker from this linked list. The removed node no longer has a parent.
-     * @param {TreeLinker} node The node we wish to remove (and it will be returned after removal)
-     * @return {TreeLinker|null} The removed node, or null when there was nothing to remove
-     */
-    remove(node: TreeLinker): TreeLinker | 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 {TreeLinker}
-     */
-    reset(): TreeLinker;
-    /**
-     * Retrieve a TreeLinker item from this list by numeric index, otherwise return null.
-     * @param {number} index The integer number for retrieving a node by position.
-     * @returns {TreeLinker|null}
-     */
-    item(index: number): TreeLinker;
-    /**
-     * Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Items.
-     * @param {forEachCallback} callback The function to call for-each tree node
-     * @param {LinkedTreeList} thisArg Optional, 'this' reference
-     * @return {LinkedTreeList} The list which was iterated.
-     */
-    forEach(callback: forEachCallback, thisArg?: LinkedTreeList): LinkedTreeList;
-    /**
-     * Be able to iterate over this class: the linkers of this list and everything below them (left-first). It stays within
-     * this list (it does not start at, or climb up to, the parents), use the parseTree service to parse a whole tree.
-     * @returns {Iterator}
-     */
-    [Symbol.iterator](): Iterator<TreeLinker>;
-    /**
-     * Convert an array into a LinkedTreeList instance, return the new instance.
-     * @param {Array} [values=[]] An array of values which will be converted to nodes in this tree-list
-     * @param {TreeLinker} [linkerClass=TreeLinker] The class to use for each node
-     * @param {IsArrayable<TreeLinker>} [classType=LinkedTreeList] Provide the type of IsArrayable to use.
-     * @returns {LinkedTreeList}
-     */
-    static fromArray: (values?: Array<any>, linkerClass?: typeof TreeLinker, classType?: any) => IsTree | any;
-}
+/**
+ * @file doubly linked tree list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { TreeLinker } from './TreeLinker';
+import { forEachCallback } from '../../recipes/IsArrayable';
+import { IsTree } from '../../recipes/IsTree';
+import { IsTreeNode } from '../../recipes/IsTreeNode';
+/**
+ * LinkedTreeList represents a collection stored with a root and spreading in branching (tree) formation.
+ * @extends DoublyLinkedList
+ */
+export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    readonly classType: typeof LinkedTreeList;
+    /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
+    innerList: IsTreeNode | any;
+    /** 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 tree linkers. */
+    linkerClass: typeof TreeLinker;
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    private tailCache;
+    /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+    private countCache;
+    /** The node these linkers are the children of, remembered so that it is known even while the list is empty (undefined until it is known). */
+    private ownerNode;
+    /**
+     * Create the new LinkedTreeList instance, configure the list class.
+     * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
+     */
+    constructor(linkerClass?: typeof TreeLinker);
+    /**
+     * Initialize the inner list, should only run once.
+     * @param {TreeLinker} initialList Give the list of tree-linkers to start in this linked-tree-list.
+     * @return {LinkedTreeList}
+     */
+    initialize(initialList: TreeLinker): LinkedTreeList;
+    /**
+     * Retrieve the innerList used (the list itself, not a copy).
+     * @returns {TreeLinker}
+     */
+    get list(): TreeLinker;
+    /**
+     * Retrieve the first TreeLinker in the list.
+     * @returns {TreeLinker}
+     */
+    get first(): TreeLinker;
+    /**
+     * Retrieve the last TreeLinker in the list. The end is remembered, so this does not walk the list.
+     * @returns {TreeLinker}
+     */
+    get last(): TreeLinker;
+    /**
+     * Return the length of the list. 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;
+    /**
+     * Get the parent of this tree list: the node these linkers are the children of (remembered even while the list is
+     * empty), or null for the linkers at the top of a tree.
+     * @return {TreeLinker|null}
+     */
+    get parent(): TreeLinker | null;
+    /**
+     * Set the parent of this tree list: every linker in it gets the node as its parent, and the node gets this list as its
+     * children. Linkers added to the list later get this parent too.
+     * @param {TreeLinker|null} parent The new node to use as the parent for this group of children
+     */
+    set parent(parent: TreeLinker | null);
+    /**
+     * Return the root parent of the entire tree.
+     * @return {TreeLinker}
+     */
+    get rootParent(): TreeLinker;
+    /**
+     * Set the children on a parent item.
+     * @param {TreeLinker} item The TreeLinker node (one of the linkers of this list) that will be the parent of the children
+     * @param {LinkedTreeList|null} [children=null] The LinkedTreeList which has the child nodes to use, or null to remove the children of the item
+     * @throws {Error} When the item is not one of the linkers of this list
+     */
+    setChildren(item: TreeLinker, children?: LinkedTreeList | null): void;
+    /**
+     * Make a linker of the given node (or data) and make this list's parent its parent.
+     * @param {TreeLinker|*} newNode The node (or data) which is being added to this list
+     * @returns {TreeLinker}
+     */
+    private adopt;
+    /**
+     * Insert a new node (or data) after a node. The new node gets the parent of this list.
+     * @param {TreeLinker|*} node The existing node as reference, or null to insert at the start of the list
+     * @param {TreeLinker|*} newNode The new node to go after the existing node
+     * @returns {LinkedTreeList}
+     */
+    insertAfter(node: TreeLinker | null, newNode: TreeLinker | any): LinkedTreeList;
+    /**
+     * Insert a new node (or data) before a node. The new node gets the parent of this list.
+     * @param {TreeLinker|*} node The existing node as reference, or null to insert at the end of the list
+     * @param {TreeLinker|*} newNode The new node to go before the existing node
+     * @returns {LinkedTreeList}
+     */
+    insertBefore(node: TreeLinker | null, newNode: TreeLinker | any): LinkedTreeList;
+    /**
+     * Add a node (or data) after the given (or last) node in the list.
+     * @param {TreeLinker|*} node The new node to add to the end of the list
+     * @param {TreeLinker} after The existing last node
+     * @returns {TreeLinker}
+     */
+    append(node: TreeLinker | any, after?: TreeLinker): LinkedTreeList;
+    /**
+     * Add a node (or data) before the given (or first) node in the list.
+     * @param {TreeLinker|*} node The new node to add to the start of the list
+     * @param {TreeLinker} before The existing first node
+     * @returns {TreeLinker}
+     */
+    prepend(node: TreeLinker | any, before?: TreeLinker): LinkedTreeList;
+    /**
+     * Remove a linker from this linked list. The removed node no longer has a parent.
+     * @param {TreeLinker} node The node we wish to remove (and it will be returned after removal)
+     * @return {TreeLinker|null} The removed node, or null when there was nothing to remove
+     */
+    remove(node: TreeLinker): TreeLinker | 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 {TreeLinker}
+     */
+    reset(): TreeLinker;
+    /**
+     * Retrieve a TreeLinker item from this list by numeric index, otherwise return null.
+     * @param {number} index The integer number for retrieving a node by position.
+     * @returns {TreeLinker|null}
+     */
+    item(index: number): TreeLinker;
+    /**
+     * Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Items.
+     * @param {forEachCallback} callback The function to call for-each tree node
+     * @param {LinkedTreeList} thisArg Optional, 'this' reference
+     * @return {LinkedTreeList} The list which was iterated.
+     */
+    forEach(callback: forEachCallback, thisArg?: LinkedTreeList): LinkedTreeList;
+    /**
+     * Be able to iterate over this class: the linkers of this list and everything below them (left-first). It stays within
+     * this list (it does not start at, or climb up to, the parents), use the parseTree service to parse a whole tree.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator](): Iterator<TreeLinker>;
+    /**
+     * Convert an array into a LinkedTreeList instance, return the new instance.
+     * @param {Array} [values=[]] An array of values which will be converted to nodes in this tree-list
+     * @param {TreeLinker} [linkerClass=TreeLinker] The class to use for each node
+     * @param {IsArrayable<TreeLinker>} [classType=LinkedTreeList] Provide the type of IsArrayable to use.
+     * @returns {LinkedTreeList}
+     */
+    static fromArray: (values?: Array<any>, linkerClass?: typeof TreeLinker, classType?: any) => IsTree | any;
+}

package/dist/collections/linked-tree-list/LinkedTreeList.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, '__esModule', {
 exports.LinkedTreeList = void 0
 require('core-js/modules/esnext.iterator.constructor.js')
 require('core-js/modules/esnext.iterator.for-each.js')
-var _TreeLinker = require('./TreeLinker')
-var _TreeLinkerIterator = require('../../recipes/TreeLinkerIterator')
-var _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
+const _TreeLinker = require('./TreeLinker')
+const _TreeLinkerIterator = require('../../recipes/TreeLinkerIterator')
+const _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
 /**
  * @file doubly linked tree list.
  * @author Joshua Heagle <joshuaheagle@gmail.com>

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

@@ -1,71 +1,71 @@
-/**
- * @file doubly linked tree node.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsTreeNode } from '../../recipes/IsTreeNode';
-import { IsTree } from '../../recipes/IsTree';
-/**
- * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
- * @extends DoubleLinker
- */
-export declare class TreeLinker implements IsTreeNode {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    readonly classType: typeof TreeLinker;
-    /** The data stored in this tree node. */
-    data: any;
-    /** The sibling after this node, or null when this is the last child. */
-    next: IsTreeNode | null;
-    /** The sibling before this node, or null when this is the first child. */
-    prev: IsTreeNode | null;
-    /** The node this node is a child of, or null for a root node. */
-    parent: IsTreeNode;
-    /** The list of the children of this node, or null when it has none. */
-    children: IsArrayable<IsTreeNode>;
-    /**
-     * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-     * @param {Object} [settings={}] The settings for the new tree node.
-     * @param {*} [settings.data=null] The data to be stored in this tree node
-     * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
-     * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any
-     * @param {LinkedTreeList} [settings.children=null] The references to child linkers if any
-     * @param {TreeLinker} [settings.parent=null] The reference to a parent linker if any
-     * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-     */
-    constructor({ data, next, prev, children, parent, listClass }?: {
-        data?: any;
-        next?: IsTreeNode;
-        prev?: IsTreeNode;
-        children?: Array<any>;
-        parent?: IsTreeNode;
-        listClass?: any;
-    });
-    /**
-     * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
-     * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
-     * else is the data of the linker.
-     * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
-     * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-     * @return {LinkedTreeList|null}
-     */
-    childrenFromArray(children?: Array<any> | null, listClass?: any): IsTree | any;
-    /**
-     * Make a new DoubleLinker from the data given if it is not already a valid Linker.
-     * @param {TreeLinker|*} linker Return a valid TreeLinker instance from given data, or even an already valid one.
-     * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
-     * @return {TreeLinker}
-     */
-    static make: (linker: TreeLinker | any, classType?: any) => IsTreeNode | 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 tree-linkers.
-     * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
-     * @returns {{head: TreeLinker, tail: TreeLinker}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: TreeLinker | any;
-        tail: TreeLinker | any;
-    };
-}
+/**
+ * @file doubly linked tree node.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsTreeNode } from '../../recipes/IsTreeNode';
+import { IsTree } from '../../recipes/IsTree';
+/**
+ * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
+ * @extends DoubleLinker
+ */
+export declare class TreeLinker implements IsTreeNode {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    readonly classType: typeof TreeLinker;
+    /** The data stored in this tree node. */
+    data: any;
+    /** The sibling after this node, or null when this is the last child. */
+    next: IsTreeNode | null;
+    /** The sibling before this node, or null when this is the first child. */
+    prev: IsTreeNode | null;
+    /** The node this node is a child of, or null for a root node. */
+    parent: IsTreeNode;
+    /** The list of the children of this node, or null when it has none. */
+    children: IsArrayable<IsTreeNode>;
+    /**
+     * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
+     * @param {Object} [settings={}] The settings for the new tree node.
+     * @param {*} [settings.data=null] The data to be stored in this tree node
+     * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
+     * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any
+     * @param {LinkedTreeList} [settings.children=null] The references to child linkers if any
+     * @param {TreeLinker} [settings.parent=null] The reference to a parent linker if any
+     * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
+     */
+    constructor({ data, next, prev, children, parent, listClass }?: {
+        data?: any;
+        next?: IsTreeNode;
+        prev?: IsTreeNode;
+        children?: Array<any>;
+        parent?: IsTreeNode;
+        listClass?: any;
+    });
+    /**
+     * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
+     * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
+     * else is the data of the linker.
+     * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
+     * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
+     * @return {LinkedTreeList|null}
+     */
+    childrenFromArray(children?: Array<any> | null, listClass?: any): IsTree | any;
+    /**
+     * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+     * @param {TreeLinker|*} linker Return a valid TreeLinker instance from given data, or even an already valid one.
+     * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
+     * @return {TreeLinker}
+     */
+    static make: (linker: TreeLinker | any, classType?: any) => IsTreeNode | 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 tree-linkers.
+     * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
+     * @returns {{head: TreeLinker, tail: TreeLinker}}
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: TreeLinker | any;
+        tail: TreeLinker | any;
+    };
+}

package/dist/collections/linked-tree-list/TreeLinker.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, '__esModule', {
 exports.TreeLinker = void 0
 require('core-js/modules/esnext.iterator.constructor.js')
 require('core-js/modules/esnext.iterator.map.js')
-var _DoubleLinker = require('../doubly-linked-list/DoubleLinker')
-var _LinkedTreeList = require('./LinkedTreeList')
+const _DoubleLinker = require('../doubly-linked-list/DoubleLinker')
+const _LinkedTreeList = require('./LinkedTreeList')
 /**
  * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
  * @extends DoubleLinker

package/dist/collections/queue/Queue.d.ts

@@ -1,59 +1,59 @@
-import { Linker } from '../linked-list/Linker';
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsQueue } from '../../recipes/IsQueue';
-/**
- * A first-in-first-out collection: items are added to the back with enqueue and taken from the front with dequeue.
- * Any value can be queued (it is stored as it is, whether it is a function, an object or null), and adding and taking
- * are constant time. To queue tasks which are run as they are taken use TaskQueue.
- */
-export declare class Queue<T = any> implements IsQueue<T>, Iterable<T> {
-    /** The list which stores the queued items, the first is next to be dequeued. */
-    queuedList: IsArrayable<any>;
-    private readonly linkerClass;
-    /**
-     * Instantiate the queue, optionally with a list of items to start from.
-     * @param {IsArrayable|null} [queuedList=null] The list of linkers to start in this queue (the first is the front)
-     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given
-     * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
-     */
-    constructor(queuedList?: IsArrayable<any> | null, listClass?: any, linkerClass?: typeof Linker);
-    /**
-     * Take the item from the front of the queue.
-     * @return {*|null} The item, or null when the queue is empty
-     */
-    dequeue(): T | null;
-    /**
-     * Check whether the queue has no items.
-     * @return {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Add an item to the back of the queue.
-     * @param {*} data The item to add
-     * @return {Queue} This queue, so that adding can be chained
-     */
-    enqueue(data: T): this;
-    /**
-     * Look at the item at the front of the queue, without removing it.
-     * @return {*|null} The item, or null when the queue is empty
-     */
-    peek(): T | null;
-    /**
-     * Count the items in the queue.
-     * @return {number}
-     */
-    size(): number;
-    /**
-     * Iterate over the items from the front of the queue to the back, without removing them.
-     * @return {Iterator}
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * Convert an array to a Queue, the first value is at the front.
-     * @param {Array} [values=[]] The items to queue
-     * @param {IsArrayable} [listClass=LinkedList] The type of list used to store the items
-     * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
-     * @returns {Queue}
-     */
-    static fromArray: <T_1 = any>(values?: Array<T_1>, listClass?: any, linkerClass?: typeof Linker) => Queue<T_1>;
-}
+import { Linker } from '../linked-list/Linker';
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsQueue } from '../../recipes/IsQueue';
+/**
+ * A first-in-first-out collection: items are added to the back with enqueue and taken from the front with dequeue.
+ * Any value can be queued (it is stored as it is, whether it is a function, an object or null), and adding and taking
+ * are constant time. To queue tasks which are run as they are taken use TaskQueue.
+ */
+export declare class Queue<T = any> implements IsQueue<T>, Iterable<T> {
+    /** The list which stores the queued items, the first is next to be dequeued. */
+    queuedList: IsArrayable<any>;
+    private readonly linkerClass;
+    /**
+     * Instantiate the queue, optionally with a list of items to start from.
+     * @param {IsArrayable|null} [queuedList=null] The list of linkers to start in this queue (the first is the front)
+     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given
+     * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
+     */
+    constructor(queuedList?: IsArrayable<any> | null, listClass?: any, linkerClass?: typeof Linker);
+    /**
+     * Take the item from the front of the queue.
+     * @return {*|null} The item, or null when the queue is empty
+     */
+    dequeue(): T | null;
+    /**
+     * Check whether the queue has no items.
+     * @return {boolean}
+     */
+    empty(): boolean;
+    /**
+     * Add an item to the back of the queue.
+     * @param {*} data The item to add
+     * @return {Queue} This queue, so that adding can be chained
+     */
+    enqueue(data: T): this;
+    /**
+     * Look at the item at the front of the queue, without removing it.
+     * @return {*|null} The item, or null when the queue is empty
+     */
+    peek(): T | null;
+    /**
+     * Count the items in the queue.
+     * @return {number}
+     */
+    size(): number;
+    /**
+     * Iterate over the items from the front of the queue to the back, without removing them.
+     * @return {Iterator}
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Convert an array to a Queue, the first value is at the front.
+     * @param {Array} [values=[]] The items to queue
+     * @param {IsArrayable} [listClass=LinkedList] The type of list used to store the items
+     * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
+     * @returns {Queue}
+     */
+    static fromArray: <T_1 = any>(values?: Array<T_1>, listClass?: any, linkerClass?: typeof Linker) => Queue<T_1>;
+}

package/dist/collections/queue/Queue.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, '__esModule', {
 exports.Queue = void 0
 require('core-js/modules/esnext.iterator.constructor.js')
 require('core-js/modules/esnext.iterator.for-each.js')
-var _LinkedList = require('../linked-list/LinkedList')
-var _Linker = require('../linked-list/Linker')
+const _LinkedList = require('../linked-list/LinkedList')
+const _Linker = require('../linked-list/Linker')
 /**
  * @file queue
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -93,13 +93,15 @@ class Queue {
     return {
       next: () => {
         const result = linkers.next()
-        return result.done ? {
-          done: true,
-          value: undefined
-        } : {
-          done: false,
-          value: result.value.data
-        }
+        return result.done
+          ? {
+              done: true,
+              value: undefined
+            }
+          : {
+              done: false,
+              value: result.value.data
+            }
       }
     }
   }