collect-your-stuff 2.1.1 → 2.1.2

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

@@ -1,83 +1,83 @@
-/**
- * @file queueable item.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { completeResponse, IsRunnable } from '../../recipes/Runnable';
-import { IsLinker } from '../../recipes/IsLinker';
-/**
- * Queueable represents a runnable entry in a queue.
- * @extends Linker
- */
-export declare class Queueable implements IsLinker, IsRunnable {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    readonly classType: typeof Queueable;
-    /** The task (or data) this queueable holds. */
-    data: any;
-    /** The queueable after this one, or null when this is the last. */
-    next: Queueable | null;
-    /** Whether this queueable has been run to completion. */
-    complete: boolean;
-    /** Whether this queueable may run, or a function which answers that when asked. */
-    ready: Function | boolean;
-    /** Whether this queueable is running right now. */
-    running: boolean;
-    /**
-     * Create a queueable item that can be used in a queue.
-     * @param {Object} [queueableData={}] The settings for the new queueable.
-     * @param {*} [queueableData.task=null] The data to be stored in this queueable
-     * @param {Queueable|null} [queueableData.next=null] The reference to the next queueable if any
-     * @param {boolean|Function} [queueableData.ready=false] Indicate if the queueable is ready to run
-     */
-    constructor({ task, next, ready }?: {
-        task?: any;
-        next?: Queueable | null;
-        ready?: boolean | Function;
-    });
-    /**
-     * Check ready state.
-     * @return {boolean}
-     */
-    get isReady(): boolean;
-    /**
-     * Retrieve the data which should be formed as a task.
-     * @return {*}
-     */
-    get task(): any;
-    /**
-     * Set this queueable as completed.
-     * @param {Object} [completeResponse={}] The result to report for the task.
-     * @param {*} [completeResponse.success=true] Indicate when the task failed (use false) or give a success message
-     * @param {*} [completeResponse.error=false] Indicate a task was error-free (use false) or give an error message
-     * @param {*} [completeResponse.context=null] Provide additional data in the response
-     * @return {completeResponse}
-     */
-    markCompleted({ success, error, context }?: {
-        success?: any;
-        error?: any;
-        context?: any;
-    }): completeResponse;
-    /**
-     * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
-     * @return {completeResponse}
-     */
-    run(): completeResponse;
-    /**
-     * Make a new Queueable from the data given if it is not already a valid Queueable.
-     * @param {Queueable|*} queueable Return a valid Queueable instance from given data, or even an already valid one.
-     * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
-     * @return {Queueable}
-     */
-    static make: (queueable: Queueable | any, classType?: any) => IsLinker;
-    /**
-     * Convert an array into Queueable instances, return the head and tail Queueables.
-     * @param {Array} values Provide an array of data that will be converted to a chain of queueable linkers.
-     * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
-     * @returns {{head: Queueable, tail: Queueable}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: IsLinker;
-        tail: IsLinker;
-    };
-}
+/**
+ * @file queueable item.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { completeResponse, IsRunnable } from '../../recipes/Runnable';
+import { IsLinker } from '../../recipes/IsLinker';
+/**
+ * Queueable represents a runnable entry in a queue.
+ * @extends Linker
+ */
+export declare class Queueable implements IsLinker, IsRunnable {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    readonly classType: typeof Queueable;
+    /** The task (or data) this queueable holds. */
+    data: any;
+    /** The queueable after this one, or null when this is the last. */
+    next: Queueable | null;
+    /** Whether this queueable has been run to completion. */
+    complete: boolean;
+    /** Whether this queueable may run, or a function which answers that when asked. */
+    ready: Function | boolean;
+    /** Whether this queueable is running right now. */
+    running: boolean;
+    /**
+     * Create a queueable item that can be used in a queue.
+     * @param {Object} [queueableData={}] The settings for the new queueable.
+     * @param {*} [queueableData.task=null] The data to be stored in this queueable
+     * @param {Queueable|null} [queueableData.next=null] The reference to the next queueable if any
+     * @param {boolean|Function} [queueableData.ready=false] Indicate if the queueable is ready to run
+     */
+    constructor({ task, next, ready }?: {
+        task?: any;
+        next?: Queueable | null;
+        ready?: boolean | Function;
+    });
+    /**
+     * Check ready state.
+     * @return {boolean}
+     */
+    get isReady(): boolean;
+    /**
+     * Retrieve the data which should be formed as a task.
+     * @return {*}
+     */
+    get task(): any;
+    /**
+     * Set this queueable as completed.
+     * @param {Object} [completeResponse={}] The result to report for the task.
+     * @param {*} [completeResponse.success=true] Indicate when the task failed (use false) or give a success message
+     * @param {*} [completeResponse.error=false] Indicate a task was error-free (use false) or give an error message
+     * @param {*} [completeResponse.context=null] Provide additional data in the response
+     * @return {completeResponse}
+     */
+    markCompleted({ success, error, context }?: {
+        success?: any;
+        error?: any;
+        context?: any;
+    }): completeResponse;
+    /**
+     * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
+     * @return {completeResponse}
+     */
+    run(): completeResponse;
+    /**
+     * Make a new Queueable from the data given if it is not already a valid Queueable.
+     * @param {Queueable|*} queueable Return a valid Queueable instance from given data, or even an already valid one.
+     * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
+     * @return {Queueable}
+     */
+    static make: (queueable: Queueable | any, classType?: any) => IsLinker;
+    /**
+     * Convert an array into Queueable instances, return the head and tail Queueables.
+     * @param {Array} values Provide an array of data that will be converted to a chain of queueable linkers.
+     * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
+     * @returns {{head: Queueable, tail: Queueable}}
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: IsLinker;
+        tail: IsLinker;
+    };
+}

package/dist/collections/queue/Queueable.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.Queueable = void 0
-var _Linker = require('../linked-list/Linker')
+const _Linker = require('../linked-list/Linker')
 /**
  * Queueable represents a runnable entry in a queue.
  * @extends Linker
@@ -56,9 +56,11 @@ class Queueable {
     if (typeof this.data === 'function') {
       return this.data
     }
-    return complete => typeof complete === 'function' ? complete({
-      context: this.data
-    }).context : this.data
+    return complete => typeof complete === 'function'
+      ? complete({
+        context: this.data
+      }).context
+      : this.data
   }
 
   /**
@@ -77,9 +79,9 @@ class Queueable {
     this.complete = true
     this.running = false
     return {
-      success: success,
-      error: error,
-      context: context
+      success,
+      error,
+      context
     }
   }
 

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

@@ -1,68 +1,68 @@
-/**
- * @file task queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { Queueable } from './Queueable';
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsLinker } from '../../recipes/IsLinker';
-import { completeResponse } from '../../recipes/Runnable';
-/**
- * Maintain a series of queued tasks (Queueables): dequeue() takes the next task from the front and RUNS it, giving each
- * task in turn a chance to run (a task which is not ready, or which has not finished, is placed at the back again).
- * This is a task scheduler, for a plain first-in-first-out collection of items use Queue.
- */
-export declare class TaskQueue {
-    /** The list which stores the queueables, the first is next to be dequeued. */
-    queuedList: IsArrayable<any>;
-    private listClass;
-    private queueableClass;
-    /**
-     * Instantiate the queue with the given queue list.
-     * @param {Iterable|LinkedList} queuedList Give the list of queueables to start in this queue.
-     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given.
-     * @param {Queueable} [queueableClass=Queueable] The class used to wrap queued items.
-     */
-    constructor(queuedList?: IsArrayable<any>, listClass?: any, queueableClass?: typeof Queueable);
-    /**
-     * Take a queued task from the front of the queue and run it if ready. A task which is not ready yet is kept in the
-     * queue (never dropped), a task which is still running is reported as blocking and left to finish on its own, and
-     * completed tasks are discarded.
-     * @return {completeResponse|*}
-     */
-    dequeue(): completeResponse | any;
-    /**
-     * Return true if the queue is empty (there are no tasks in the queue list)
-     * @return {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Add a queued task to the end of the queue
-     * @param {Queueable} queueable Add a new queueable to the end of the queue
-     */
-    enqueue(queueable: Queueable): void;
-    /**
-     * Take a look at the next queued task
-     * @return {Queueable}
-     */
-    peek(): IsLinker;
-    /**
-     * Remove the next queued item and return it.
-     * @return {Queueable|null}
-     */
-    remove(): Queueable | null;
-    /**
-     * Get the length of the current queue.
-     * @return {number}
-     */
-    size(): number;
-    /**
-     * Convert an array to a TaskQueue.
-     * @param {Array} values An array of values which will be converted to queueables in this queue
-     * @param {Queueable} queueableClass The class to use for each queueable
-     * @param {TaskQueue|Iterable} listClass The class to use to manage the queueables
-     * @returns {TaskQueue}
-     */
-    static fromArray: (values?: Array<any>, queueableClass?: typeof Queueable, listClass?: any) => TaskQueue;
-}
+/**
+ * @file task queue
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { Queueable } from './Queueable';
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsLinker } from '../../recipes/IsLinker';
+import { completeResponse } from '../../recipes/Runnable';
+/**
+ * Maintain a series of queued tasks (Queueables): dequeue() takes the next task from the front and RUNS it, giving each
+ * task in turn a chance to run (a task which is not ready, or which has not finished, is placed at the back again).
+ * This is a task scheduler, for a plain first-in-first-out collection of items use Queue.
+ */
+export declare class TaskQueue {
+    /** The list which stores the queueables, the first is next to be dequeued. */
+    queuedList: IsArrayable<any>;
+    private listClass;
+    private queueableClass;
+    /**
+     * Instantiate the queue with the given queue list.
+     * @param {Iterable|LinkedList} queuedList Give the list of queueables to start in this queue.
+     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given.
+     * @param {Queueable} [queueableClass=Queueable] The class used to wrap queued items.
+     */
+    constructor(queuedList?: IsArrayable<any>, listClass?: any, queueableClass?: typeof Queueable);
+    /**
+     * Take a queued task from the front of the queue and run it if ready. A task which is not ready yet is kept in the
+     * queue (never dropped), a task which is still running is reported as blocking and left to finish on its own, and
+     * completed tasks are discarded.
+     * @return {completeResponse|*}
+     */
+    dequeue(): completeResponse | any;
+    /**
+     * Return true if the queue is empty (there are no tasks in the queue list)
+     * @return {boolean}
+     */
+    empty(): boolean;
+    /**
+     * Add a queued task to the end of the queue
+     * @param {Queueable} queueable Add a new queueable to the end of the queue
+     */
+    enqueue(queueable: Queueable): void;
+    /**
+     * Take a look at the next queued task
+     * @return {Queueable}
+     */
+    peek(): IsLinker;
+    /**
+     * Remove the next queued item and return it.
+     * @return {Queueable|null}
+     */
+    remove(): Queueable | null;
+    /**
+     * Get the length of the current queue.
+     * @return {number}
+     */
+    size(): number;
+    /**
+     * Convert an array to a TaskQueue.
+     * @param {Array} values An array of values which will be converted to queueables in this queue
+     * @param {Queueable} queueableClass The class to use for each queueable
+     * @param {TaskQueue|Iterable} listClass The class to use to manage the queueables
+     * @returns {TaskQueue}
+     */
+    static fromArray: (values?: Array<any>, queueableClass?: typeof Queueable, listClass?: any) => TaskQueue;
+}

package/dist/collections/queue/TaskQueue.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.TaskQueue = void 0
-var _Queueable = require('./Queueable')
-var _LinkedList = require('../linked-list/LinkedList')
+const _Queueable = require('./Queueable')
+const _LinkedList = require('../linked-list/LinkedList')
 /**
  * @file task queue
  * @author Joshua Heagle <joshuaheagle@gmail.com>

package/dist/collections/stack/Stack.d.ts

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

package/dist/collections/stack/Stack.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, '__esModule', {
 exports.Stack = 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 stack.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -101,13 +101,15 @@ class Stack {
     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
+            }
       }
     }
   }

package/dist/collections/stack/Stackable.d.ts

@@ -1,59 +1,59 @@
-/**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { IsRunnable } from '../../recipes/Runnable';
-import { IsLinker } from '../../recipes/IsLinker';
-/**
- * Stackable represents a runnable entry in stack.
- * @extends Linker
- */
-export declare class Stackable implements IsLinker, IsRunnable {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    readonly classType: typeof Stackable;
-    /** The task (or data) this stackable holds. */
-    data: any;
-    /** The stackable below this one, or null when this is the bottom. */
-    next: Stackable | null;
-    /**
-     * Create a stackable item that can be used in a stack.
-     * @param {Object} [stackData={}] The settings for the new stackable.
-     * @param {*} [stackData.task=null] The data to be stored in this stackable
-     * @param {Stackable|null} [stackData.next=null] The reference to the next stackable if any
-     * @param {boolean|Function} [stackData.ready=false] Indicate if the stackable is ready to run
-     */
-    constructor({ task, next, ready }?: {
-        task?: any;
-        next?: Stackable | null;
-        ready?: boolean;
-    });
-    /**
-     * Retrieve the data which should be formed as a task.
-     * @return {*}
-     */
-    get task(): any;
-    /**
-     * Run the stacked task.
-     * @return {*}
-     */
-    run(): any;
-    /**
-     * Make a new Stackable from the data given if it is not already a valid Stackable.
-     * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
-     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
-     * @return {Stackable}
-     */
-    static make: (stackable: Stackable | any, classType?: any) => Stackable;
-    /**
-     * Convert an array into Stackable instances, return the head and tail Stackables.
-     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
-     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
-     * @returns {{head: Stackable, tail: Stackable}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: IsLinker;
-        tail: IsLinker;
-    };
-}
+/**
+ * @file stack.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { IsRunnable } from '../../recipes/Runnable';
+import { IsLinker } from '../../recipes/IsLinker';
+/**
+ * Stackable represents a runnable entry in stack.
+ * @extends Linker
+ */
+export declare class Stackable implements IsLinker, IsRunnable {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    readonly classType: typeof Stackable;
+    /** The task (or data) this stackable holds. */
+    data: any;
+    /** The stackable below this one, or null when this is the bottom. */
+    next: Stackable | null;
+    /**
+     * Create a stackable item that can be used in a stack.
+     * @param {Object} [stackData={}] The settings for the new stackable.
+     * @param {*} [stackData.task=null] The data to be stored in this stackable
+     * @param {Stackable|null} [stackData.next=null] The reference to the next stackable if any
+     * @param {boolean|Function} [stackData.ready=false] Indicate if the stackable is ready to run
+     */
+    constructor({ task, next, ready }?: {
+        task?: any;
+        next?: Stackable | null;
+        ready?: boolean;
+    });
+    /**
+     * Retrieve the data which should be formed as a task.
+     * @return {*}
+     */
+    get task(): any;
+    /**
+     * Run the stacked task.
+     * @return {*}
+     */
+    run(): any;
+    /**
+     * Make a new Stackable from the data given if it is not already a valid Stackable.
+     * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
+     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
+     * @return {Stackable}
+     */
+    static make: (stackable: Stackable | any, classType?: any) => Stackable;
+    /**
+     * Convert an array into Stackable instances, return the head and tail Stackables.
+     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
+     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
+     * @returns {{head: Stackable, tail: Stackable}}
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: IsLinker;
+        tail: IsLinker;
+    };
+}

package/dist/collections/stack/Stackable.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.Stackable = void 0
-var _Linker = require('../linked-list/Linker')
+const _Linker = require('../linked-list/Linker')
 /**
  * Stackable represents a runnable entry in stack.
  * @extends Linker