collect-your-stuff 1.0.0

package/dist/collections/arrayable/ArrayElement.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/esnext.async-iterator.reduce.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+/**
+ * @file linked list item.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * Element represents a node in an Arrayable.
+ */
+class ArrayElement {
+  data = null;
+  classType;
+
+  /**
+   * Create the new Element instance, provide the data and optionally configure the type of Element.
+   * @param {*} [data=null]
+   * @param {ArrayElement} [elementClass=Element]
+   */
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let elementClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ArrayElement;
+    this.classType = elementClass;
+    this.data = data;
+  }
+
+  /**
+   * Return the type of class used for Element.
+   
+   * @return {ArrayElement}
+   */
+  get classType() {
+    return this.classType;
+  }
+}
+
+/**
+ * Make a new Element from the data given if it is not already a valid Element.
+ * @methodof ArrayElement
+ * @param {ArrayElement|*} element
+ * @param {ArrayElement} [elementClass=Element]
+ * @return {ArrayElement}
+ */
+ArrayElement.make = function (element) {
+  let elementClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ArrayElement;
+  if (typeof element !== 'object') {
+    // It is not an object, so instantiate the Element with element as the data
+    return new elementClass(element);
+  }
+  if (element.classType) {
+    // Already valid Element, return as-is
+    return element;
+  }
+  // Create the new node as the configured #classType
+  return new elementClass(element, elementClass);
+};
+
+/**
+ * Convert an array into Element instances, return the head and tail Elements.
+ * @methodof ArrayElement
+ * @param {Array} [values=[]]
+ * @param {ArrayElement} [elementClass=Element]
+ * @returns {{head: ArrayElement, tail: ArrayElement}}
+ */
+ArrayElement.fromArray = function () {
+  let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let elementClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ArrayElement;
+  return values.reduce((references, element) => {
+    const newElement = elementClass.make(element);
+    if (!references.head.length) {
+      // Initialize the head and tail with the new node
+      return {
+        head: [newElement],
+        tail: newElement
+      };
+    }
+    // Only update the tail once head has been set, tail is always the most recent node
+    references.head.push(newElement);
+    references.tail = newElement;
+    return references;
+  }, {
+    head: [],
+    tail: null
+  });
+};
+var _default = exports.default = ArrayElement;

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

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

package/dist/collections/arrayable/Arrayable.js

@@ -0,0 +1,253 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ArrayElement = _interopRequireDefault(require("./ArrayElement"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @file doubly linked list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
+ */
+class Arrayable {
+  classType = null;
+  initialized = false;
+  innerList = [];
+
+  /**
+   * Create the new Arrayable instance, configure the Arrayable class.
+   * @param {Arrayable|Iterable} classType
+   */
+  constructor() {
+    let classType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Arrayable;
+    this.classType = classType;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the inner list, should only run once.
+   * @method
+   * @param {ArrayElement|Array} initialList
+   * @return {Arrayable}
+   */
+  initialize(initialList) {
+    if (this.initialized) {
+      console.warn('Attempt to initialize Arrayable which is not empty.');
+      return this;
+    }
+    this.initialized = true;
+    this.innerList = initialList;
+    return this;
+  }
+
+  /**
+   * Return the type of class used for Arrayable.
+   
+   * @returns {Arrayable}
+   */
+  get classType() {
+    return this.classType;
+  }
+
+  /**
+   * Detect if the inner list has been initialized.
+   
+   * @returns {boolean}
+   */
+  get initialized() {
+    return this.initialized;
+  }
+
+  /**
+   * Retrieve a copy of the innerList used.
+   
+   * @returns {Array}
+   */
+  get innerList() {
+    return this.innerList;
+  }
+
+  /**
+   * Retrieve the first Element from the Arrayable
+   
+   * @returns {ArrayElement}
+   */
+  get first() {
+    return this.innerList[0];
+  }
+
+  /**
+   * Retrieve the last Element from the Arrayable
+   
+   * @returns {ArrayElement}
+   */
+  get last() {
+    return this.innerList[this.length - 1];
+  }
+
+  /**
+   * Return the length of the list.
+   
+   * @returns {number}
+   */
+  get length() {
+    return this.innerList.length;
+  }
+
+  /**
+   * Insert a new node (or data) after a node.
+   * @method
+   * @param {ArrayElement|*} node
+   * @param {ArrayElement|*} newNode
+   * @returns {Arrayable}
+   */
+  insertAfter(node, newNode) {
+    const insertAt = this.innerList.indexOf(node);
+    this.innerList.splice(insertAt + 1, 0, node.classType.make(newNode));
+    return this;
+  }
+
+  /**
+   * Insert a new node (or data) before a node.
+   * @method
+   * @param {ArrayElement|*} node
+   * @param {ArrayElement|*} newNode
+   * @returns {Arrayable}
+   */
+  insertBefore(node, newNode) {
+    const insertAt = this.innerList.indexOf(node);
+    this.innerList.splice(insertAt, 0, node.classType.make(newNode));
+    return this;
+  }
+
+  /**
+   * Add a node (or data) after the given (or last) node in the list.
+   * @method
+   * @param {ArrayElement|*} node
+   * @param {ArrayElement} after
+   * @returns {Arrayable}
+   */
+  append(node) {
+    let after = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.last;
+    this.insertAfter(after, node);
+    return this;
+  }
+
+  /**
+   * Add a node (or data) before the given (or first) node in the list.
+   * @method
+   * @param {ArrayElement|*} node
+   * @param {ArrayElement} before
+   * @returns {Arrayable}
+   */
+  prepend(node) {
+    let before = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.first;
+    this.insertBefore(before, node);
+    return this;
+  }
+
+  /**
+   * Remove an element from this arrayable.
+   * @method
+   * @param {ArrayElement} node
+   * @return {ArrayElement}
+   */
+  remove(node) {
+    const deleteAt = this.innerList.indexOf(node);
+    this.innerList.splice(deleteAt, 1);
+    return node;
+  }
+
+  /**
+   * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
+   * @method
+   * @param {number} index
+   * @return {ArrayElement|null}
+   */
+  item(index) {
+    if (index >= this.innerList.length) {
+      // index is beyond array limit
+      return null;
+    }
+    if (index >= 0) {
+      // use the positive index at nth position from the beginning of the array
+      return this.innerList[index];
+    }
+    const calculatedIndex = this.length + index;
+    if (calculatedIndex < 0) {
+      // negative index is beyond array limit (minus direction)
+      return null;
+    }
+    // Return the item at nth position from the end of the array
+    return this.innerList[calculatedIndex];
+  }
+
+  /**
+   * Run this function for each element in this arrayable.
+   * @callback forEachCallback
+   * @param {ArrayElement} element
+   * @param {number} index
+   * @param {Arrayable} thisArg
+   * @returns void
+   */
+
+  /**
+   * Be able to run forEach on this Arrayable to iterate over the elements.
+   * @param {forEachCallback} callback
+   * @param {Arrayable} thisArg
+   * @returns {Arrayable}
+   */
+  forEach(callback) {
+    let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
+    for (let i = 0; i < thisArg.length; ++i) {
+      callback(thisArg.item(i), i, thisArg);
+    }
+    return thisArg;
+  }
+
+  /**
+   * Be able to iterate over this class.
+   * @method
+   * @returns {Iterator}
+   */
+  [Symbol.iterator]() {
+    let index = 0;
+    return {
+      next: () => {
+        if (index < this.innerList.length) {
+          return {
+            value: this.innerList[index++],
+            done: false
+          };
+        }
+        return {
+          done: true
+        };
+      }
+    };
+  }
+}
+
+/**
+ * Convert an array to an Arrayable.
+ * @methodof Arrayable
+ * @param {Array} values
+ * @param {ArrayElement} elementClass
+ * @param {Arrayable|Iterable} classType
+ * @returns {Arrayable}
+ */
+Arrayable.fromArray = function () {
+  let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let elementClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _ArrayElement.default;
+  let classType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Arrayable;
+  const list = new classType(elementClass);
+  return list.initialize(elementClass.fromArray(values, elementClass).head);
+};
+var _default = exports.default = Arrayable;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _ArrayElement=_interopRequireDefault(require("./ArrayElement"));function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}class Arrayable{classType=null;initialized=!1;innerList=[];constructor(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:Arrayable;this.classType=t,this.initialized=!1}initialize(t){return this.initialized?(console.warn("Attempt to initialize Arrayable which is not empty."),this):(this.initialized=!0,this.innerList=t,this)}get classType(){return this.classType}get initialized(){return this.initialized}get innerList(){return this.innerList}get first(){return this.innerList[0]}get last(){return this.innerList[this.length-1]}get length(){return this.innerList.length}insertAfter(t,e){const i=this.innerList.indexOf(t);return this.innerList.splice(i+1,0,t.classType.make(e)),this}insertBefore(t,e){const i=this.innerList.indexOf(t);return this.innerList.splice(i,0,t.classType.make(e)),this}append(t){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:this.last;return this.insertAfter(e,t),this}prepend(t){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:this.first;return this.insertBefore(e,t),this}remove(t){const e=this.innerList.indexOf(t);return this.innerList.splice(e,1),t}item(t){if(t>=this.innerList.length)return null;if(t>=0)return this.innerList[t];const e=this.length+t;return e<0?null:this.innerList[e]}forEach(t){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:this;for(let i=0;i<e.length;++i)t(e.item(i),i,e);return e}[Symbol.iterator](){let t=0;return{next:()=>t<this.innerList.length?{value:this.innerList[t++],done:!1}:{done:!0}}}}Arrayable.fromArray=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:_ArrayElement.default;return new(arguments.length>2&&void 0!==arguments[2]?arguments[2]:Arrayable)(e).initialize(e.fromArray(t,e).head)};var _default=exports.default=Arrayable;

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

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/esnext.async-iterator.reduce.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _Linker = _interopRequireDefault(require("../linked-list/Linker"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @file doubly linked list item.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * DoubleLinker represents a node in a DoublyLinkedList.
+ * @extends Linker
+ */
+class DoubleLinker extends _Linker.default {
+  prev = null;
+
+  /**
+   * Create the new DoubleLinker instance, provide the data and optionally configure the type of Linker.
+   * @param {Object} [nodeData={}]
+   * @param {*} [nodeData.data=null]
+   * @param {DoubleLinker|null} [nodeData.prev=null]
+   * @param {DoubleLinker|null} [nodeData.next=null]
+   * @param {DoubleLinker} [linkerClass=DoubleLinker]
+   */
+  constructor() {
+    let {
+      data = null,
+      prev = null,
+      next = null
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker;
+    super({
+      data: data,
+      next: next
+    }, linkerClass);
+    this.prev = prev;
+  }
+}
+
+/**
+ * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+ * @methodof DoubleLinker
+ * @param {DoubleLinker|*} linker
+ * @param {DoubleLinker} [linkerClass=DoubleLinker]
+ * @return {Linker}
+ */
+DoubleLinker.make = function (linker) {
+  let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker;
+  return _Linker.default.make(linker, linkerClass);
+};
+
+/**
+ * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+ * @methodof DoubleLinker
+ * @param {Array} [values=[]]
+ * @param {DoubleLinker} [linkerClass=DoubleLinker]
+ * @returns {{head: DoubleLinker, tail: DoubleLinker}}
+ */
+DoubleLinker.fromArray = function () {
+  let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker;
+  return values.reduce((references, linker) => {
+    const newLinker = linkerClass.make(linker);
+    if (references.head === null) {
+      // Initialize the head and tail with the new node
+      return {
+        head: newLinker,
+        tail: newLinker
+      };
+    }
+    newLinker.prev = references.tail;
+    // Only update the tail once head has been set, tail is always the most recent node
+    references.tail.next = newLinker;
+    references.tail = newLinker;
+    return references;
+  }, {
+    head: null,
+    tail: null
+  });
+};
+var _default = exports.default = DoubleLinker;

package/dist/collections/doubly-linked-llist/DoubleLinker.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0,require("core-js/modules/esnext.async-iterator.reduce.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");var _Linker=_interopRequireDefault(require("../linked-list/Linker"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}class DoubleLinker extends _Linker.default{prev=null;constructor(){let{data:e=null,prev:r=null,next:t=null}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};super({data:e,next:t},arguments.length>1&&void 0!==arguments[1]?arguments[1]:DoubleLinker),this.prev=r}}DoubleLinker.make=function(e){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:DoubleLinker;return _Linker.default.make(e,r)},DoubleLinker.fromArray=function(){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:DoubleLinker;return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:[]).reduce(((r,t)=>{const l=e.make(t);return null===r.head?{head:l,tail:l}:(l.prev=r.tail,r.tail.next=l,r.tail=l,r)}),{head:null,tail:null})};var _default=exports.default=DoubleLinker;

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

@@ -0,0 +1,234 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+var _DoubleLinker = _interopRequireDefault(require('./DoubleLinker'))
+var _LinkedList = _interopRequireDefault(require('../linked-list/LinkedList'))
+function _interopRequireDefault (obj) { return obj && obj.__esModule ? obj : { default: obj } }
+/**
+ * @file doubly linked list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
+ * @extends LinkedList
+ */
+class DoublyLinkedList extends _LinkedList.default {
+  /**
+   * Create the new DoublyLinkedList instance, configure the Linker and List classes.
+   * @param {DoublyLinkedList|Iterable} [listClass=DoublyLinkedList]
+   */
+  constructor () {
+    const listClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DoublyLinkedList
+    super(listClass)
+  }
+
+  /**
+   * Retrieve the first DoubleLinker in the list.
+     * @returns {DoubleLinker}
+   */
+  get first () {
+    return this.reset()
+  }
+
+  /**
+   * Retrieve the last DoubleLinker in the list.
+     * @returns {DoubleLinker}
+   */
+  get last () {
+    let tail = this.innerList
+    let next = tail.next
+    while (next !== null) {
+      tail = next
+      next = tail.next
+    }
+    return tail
+  }
+
+  /**
+   * Return the length of the list.
+     * @returns {number}
+   */
+  get length () {
+    let current = this.first
+    let length = 0
+    while (current !== null) {
+      ++length
+      current = current.next
+    }
+    return length
+  }
+
+  /**
+   * Insert a new node (or data) after a node.
+   * @method
+   * @param {DoubleLinker|*} node
+   * @param {DoubleLinker|*} newNode
+   * @returns {DoublyLinkedList}
+   */
+  insertAfter (node, newNode) {
+    newNode = node.classType.make(newNode)
+    // Ensure the next reference of this node is assigned to the new node
+    newNode.next = node.next
+    // Ensure this node is assigned as the prev reference of the new node
+    newNode.prev = node
+    // Then set this node's next reference to the new node
+    node.next = newNode
+    if (newNode.next) {
+      // Update the next reference to ensure circular reference for prev points to the new node
+      newNode.next.prev = newNode
+    }
+    this.reset()
+    return this
+  }
+
+  /**
+   * Insert a new node (or data) before a node.
+   * @method
+   * @param {DoubleLinker|*} node
+   * @param {DoubleLinker|*} newNode
+   * @returns {DoublyLinkedList}
+   */
+  insertBefore (node, newNode) {
+    newNode = node.classType.make(newNode)
+    // The new node will reference this prev node as prev
+    newNode.prev = node.prev
+    // The new node will reference this node as next
+    newNode.next = node
+    // This prev will reference the new node
+    node.prev = newNode
+    if (newNode.prev) {
+      // Update the prev reference to ensure circular reference for next points to the new node
+      newNode.prev.next = newNode
+    }
+    this.reset()
+    return this
+  }
+
+  /**
+   * Remove a linker from this linked list.
+   * @method
+   * @param {DoubleLinker} node
+   * @return {DoubleLinker}
+   */
+  remove (node) {
+    if (node.prev) {
+      // The previous node will reference this next node
+      node.prev.next = node.next
+    }
+    if (node.next) {
+      // The next node will reference this previous node
+      node.next.prev = node.prev
+    }
+    // Update head reference
+    this.reset()
+    return node
+  }
+
+  /**
+   * Refresh all references and return head reference.
+   * @return {DoubleLinker}
+   */
+  reset () {
+    // Start at the pointer for the list
+    let pointer = this.innerList
+    let next = pointer.next
+    // Follow references till the end
+    while (next !== null) {
+      pointer = next
+      next = pointer.next
+    }
+    let prev = pointer.prev
+    // From final reference, follow references back to the beginning
+    while (prev !== null) {
+      pointer = prev
+      prev = pointer.prev
+    }
+    // All the live references should have been found and we are pointing to the true head
+    this.innerList = pointer
+    return pointer
+  }
+
+  /**
+   * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
+   * @method
+   * @param {number} index
+   * @returns {DoubleLinker|null}
+   */
+  item (index) {
+    if (index >= 0) {
+      let current = this.first
+      let currentIndex = -1
+      while (++currentIndex < index && current !== null) {
+        current = current.next
+      }
+      return currentIndex === index ? current : null
+    }
+    let current = this.last
+    let currentIndex = this.length
+    const calculatedIndex = this.length + index
+    if (calculatedIndex < 0) {
+      return null
+    }
+    while (--currentIndex > calculatedIndex && current !== null) {
+      current = current.prev
+    }
+    return currentIndex === calculatedIndex ? current : null
+  }
+
+  /**
+   * Be able to run forEach on this DoublyLinkedList ot iterate over the DoubleLinker Items.
+   * @param {forEachCallback} callback
+   * @param {DoublyLinkedList} thisArg
+   */
+  forEach (callback) {
+    const thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this
+    let index = 0
+    let current = thisArg.first
+    while (current !== null) {
+      callback(current, index, thisArg)
+      current = current.next
+      ++index
+    }
+  }
+
+  /**
+   * Be able to iterate over this class.
+   * @method
+   * @returns {Iterator}
+   */
+  [Symbol.iterator] () {
+    let current = this.first
+    return {
+      next: () => {
+        const result = {
+          value: current,
+          done: !current
+        }
+        current = current ? current.next : null
+        return result
+      }
+    }
+  }
+}
+
+/**
+ * Convert an array into a DoublyLinkedList instance, return the new instance.
+ * @methodof DoublyLinkedList
+ * @param {Array} [values=[]]
+ * @param {DoubleLinker} [linkerClass=DoubleLinker]
+ * @param {DoublyLinkedList} [listClass=DoublyLinkedList]
+ * @returns {DoublyLinkedList}
+ */
+DoublyLinkedList.fromArray = function () {
+  const values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []
+  const linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _DoubleLinker.default
+  const listClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DoublyLinkedList
+  return _LinkedList.default.fromArray(values, linkerClass, listClass)
+}
+var _default = exports.default = DoublyLinkedList

package/dist/collections/doubly-linked-llist/DoublyLinkedList.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _DoubleLinker=_interopRequireDefault(require("./DoubleLinker")),_LinkedList=_interopRequireDefault(require("../linked-list/LinkedList"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}class DoublyLinkedList extends _LinkedList.default{constructor(){super(arguments.length>0&&void 0!==arguments[0]?arguments[0]:DoublyLinkedList)}get first(){return this.reset()}get last(){let e=this.innerList,t=e.next;for(;null!==t;)e=t,t=e.next;return e}get length(){let e=this.first,t=0;for(;null!==e;)++t,e=e.next;return t}insertAfter(e,t){return(t=e.classType.make(t)).next=e.next,t.prev=e,e.next=t,t.next&&(t.next.prev=t),this.reset(),this}insertBefore(e,t){return(t=e.classType.make(t)).prev=e.prev,t.next=e,e.prev=t,t.prev&&(t.prev.next=t),this.reset(),this}remove(e){return e.prev&&(e.prev.next=e.next),e.next&&(e.next.prev=e.prev),this.reset(),e}reset(){let e=this.innerList,t=e.next;for(;null!==t;)e=t,t=e.next;let r=e.prev;for(;null!==r;)e=r,r=e.prev;return this.innerList=e,e}item(e){if(e>=0){let t=this.first,r=-1;for(;++r<e&&null!==t;)t=t.next;return r===e?t:null}let t=this.last,r=this.length;const n=this.length+e;if(n<0)return null;for(;--r>n&&null!==t;)t=t.prev;return r===n?t:null}forEach(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:this,r=0,n=t.first;for(;null!==n;)e(n,r,t),n=n.next,++r}[Symbol.iterator](){let e=this.first;return{next:()=>{const t={value:e,done:!e};return e=e?e.next:null,t}}}}DoublyLinkedList.fromArray=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:_DoubleLinker.default,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:DoublyLinkedList;return _LinkedList.default.fromArray(e,t,r)};var _default=exports.default=DoublyLinkedList;