collect-your-stuff 1.0.0

package/dist/collections/linked-list/LinkedList.js

@@ -0,0 +1,256 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+var _Linker = _interopRequireDefault(require('./Linker'))
+var _Arrayable = _interopRequireDefault(require('../arrayable/Arrayable'))
+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
+ */
+
+/**
+ * LinkedList represents a collection stored as a LinkedList with next references.
+ * @extends Arrayable
+ */
+class LinkedList extends _Arrayable.default {
+  /**
+   * Create the new LinkedList instance, configure the Linker and List classes.
+   * @param {LinkedList|Iterable} listClass
+   */
+  constructor () {
+    const listClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : LinkedList
+    super(listClass)
+  }
+
+  /**
+   * Initialize the inner list, should only run once.
+   * @method
+   * @param {Linker|Array} initialList
+   * @return {LinkedList}
+   */
+  initialize (initialList) {
+    if (this.initialized) {
+      console.warn('Attempt to initialize LinkedList which is not empty.')
+      return this
+    }
+    this.initialized = true
+    this.innerList = initialList
+    return this
+  }
+
+  /**
+   * Retrieve the first Linker in the list.
+     * @returns {Linker}
+   */
+  get first () {
+    return this.innerList
+  }
+
+  /**
+   * Retrieve the last Linker in the list.
+     * @returns {Linker}
+   */
+  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 {Linker|*} node
+   * @param {Linker|*} newNode
+   * @returns {LinkedList}
+   */
+  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
+    // Then set this node's next reference to the new node
+    node.next = newNode
+    return this
+  }
+
+  /**
+   * Insert a new node (or data) before a node.
+   * @method
+   * @param {Linker|*} node
+   * @param {Linker|*} newNode
+   * @returns {LinkedList}
+   */
+  insertBefore (node, newNode) {
+    newNode = node.classType.make(newNode)
+    let prevNode = null
+    let currentNode = this.first
+    while (currentNode !== node) {
+      prevNode = currentNode
+      currentNode = currentNode.next
+    }
+    // The new node will reference this node as next
+    newNode.next = node
+    if (prevNode) {
+      // Ensure the next reference of the previous node is assigned to the new node
+      prevNode.next = newNode
+    }
+    if (node === this.first) {
+      this.innerList = newNode
+    }
+    return this
+  }
+
+  /**
+   * Add a node (or data) after the given (or last) node in the list.
+   * @method
+   * @param {Linker|*} node
+   * @param {Linker} after
+   * @returns {Linker}
+   */
+  append (node) {
+    const 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 {Linker|*} node
+   * @param {Linker} before
+   * @returns {Linker}
+   */
+  prepend (node) {
+    const before = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.first
+    this.insertBefore(before, node)
+    return this
+  }
+
+  /**
+   * Remove a linker from this linked list.
+   * @method
+   * @param {Linker} node
+   * @return {Linker}
+   */
+  remove (node) {
+    let prevNode = null
+    let currentNode = this.first
+    while (currentNode !== node) {
+      prevNode = currentNode
+      currentNode = currentNode.next
+    }
+    if (prevNode) {
+      // Ensure the next reference of the previous node skips over the removed node
+      prevNode.next = node.next
+    }
+    if (node === this.first) {
+      // Update list head to point to next if it was this node
+      this.innerList = node.next
+    }
+    return node
+  }
+
+  /**
+   * Retrieve a Linker item from this list by numeric index, otherwise return null.
+   * @method
+   * @param {number} index
+   * @returns {Linker|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.first
+    let currentIndex = 0
+    const calculatedIndex = this.length + index
+    if (calculatedIndex < 0) {
+      return null
+    }
+    while (currentIndex < calculatedIndex && current !== null) {
+      current = current.next
+      ++currentIndex
+    }
+    return currentIndex === calculatedIndex ? current : null
+  }
+
+  /**
+   * Be able to run forEach on this LinkedList to iterate over the linkers.
+   * @param {forEachCallback} callback
+   * @param {LinkedList|Arrayable} thisArg
+   * @returns {LinkedList}
+   */
+  forEach (callback) {
+    const thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this
+    let index = 0
+    let current = this.first
+    while (current !== null) {
+      callback(current, index, thisArg)
+      current = current.next
+      ++index
+    }
+    return thisArg
+  }
+
+  /**
+   * 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 to a LinkedList.
+ * @methodof LinkedList
+ * @param {Array} values
+ * @param {Linker} linkerClass
+ * @param {LinkedList|Iterable} listClass
+ * @returns {LinkedList}
+ */
+LinkedList.fromArray = function () {
+  const values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []
+  const linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Linker.default
+  const listClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : LinkedList
+  return _Arrayable.default.fromArray(values, linkerClass, listClass)
+}
+var _default = exports.default = LinkedList

package/dist/collections/linked-list/LinkedList.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _Linker=_interopRequireDefault(require("./Linker")),_Arrayable=_interopRequireDefault(require("../arrayable/Arrayable"));function _interopRequireDefault(t){return t&&t.__esModule?t:{default:t}}class LinkedList extends _Arrayable.default{constructor(){super(arguments.length>0&&void 0!==arguments[0]?arguments[0]:LinkedList)}initialize(t){return this.initialized?(console.warn("Attempt to initialize LinkedList which is not empty."),this):(this.initialized=!0,this.innerList=t,this)}get first(){return this.innerList}get last(){let t=this.innerList,e=t.next;for(;null!==e;)t=e,e=t.next;return t}get length(){let t=this.first,e=0;for(;null!==t;)++e,t=t.next;return e}insertAfter(t,e){return(e=t.classType.make(e)).next=t.next,t.next=e,this}insertBefore(t,e){e=t.classType.make(e);let r=null,i=this.first;for(;i!==t;)r=i,i=i.next;return e.next=t,r&&(r.next=e),t===this.first&&(this.innerList=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){let e=null,r=this.first;for(;r!==t;)e=r,r=r.next;return e&&(e.next=t.next),t===this.first&&(this.innerList=t.next),t}item(t){if(t>=0){let e=this.first,r=-1;for(;++r<t&&null!==e;)e=e.next;return r===t?e:null}let e=this.first,r=0;const i=this.length+t;if(i<0)return null;for(;r<i&&null!==e;)e=e.next,++r;return r===i?e:null}forEach(t){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:this,r=0,i=this.first;for(;null!==i;)t(i,r,e),i=i.next,++r;return e}[Symbol.iterator](){let t=this.first;return{next:()=>{const e={value:t,done:!t};return t=t?t.next:null,e}}}}LinkedList.fromArray=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:_Linker.default,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:LinkedList;return _Arrayable.default.fromArray(t,e,r)};var _default=exports.default=LinkedList;

package/dist/collections/linked-list/Linker.js

@@ -0,0 +1,100 @@
+"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 _ArrayElement = _interopRequireDefault(require("../arrayable/ArrayElement"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @file linked list item.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * Linker represents a node in a LinkedList.
+ * @extends ArrayElement
+ */
+class Linker extends _ArrayElement.default {
+  next = null;
+
+  /**
+   * Create the new Linker instance, provide the data and optionally configure the type of Linker.
+   * @param {Object} [nodeData={}]
+   * @param {*} [nodeData.data=null]
+   * @param {Linker|null} [nodeData.next=null]
+   * @param {Linker} [linkerClass=Linker]
+   */
+  constructor() {
+    let {
+      data = null,
+      next = null
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Linker;
+    super(data, linkerClass);
+    this.next = next;
+  }
+}
+
+/**
+ * Make a new Linker from the data given if it is not already a valid Linker.
+ * @methodof Linker
+ * @param {Linker|*} linker
+ * @param {Linker} [linkerClass=Linker]
+ * @return {Linker}
+ */
+Linker.make = function (linker) {
+  let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Linker;
+  if (typeof linker !== 'object') {
+    // It is not an object, so instantiate the Linker with linker as the data
+    return new linkerClass({
+      data: linker
+    });
+  }
+  if (linker.classType) {
+    // Already valid Linker, return as-is
+    return linker;
+  }
+  if (!linker.data) {
+    linker = {
+      data: linker
+    };
+  }
+  // Create the new node as the configured linkerClass
+  return new linkerClass(linker, linkerClass);
+};
+
+/**
+ * Convert an array into Linker instances, return the head and tail Linkers.
+ * @methodof Linker
+ * @param {Array} [values=[]]
+ * @param {Linker} [linkerClass=Linker]
+ * @returns {{head: Linker, tail: Linker}}
+ */
+Linker.fromArray = function () {
+  let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Linker;
+  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
+      };
+    }
+    // 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 = Linker;

package/dist/collections/linked-list/Linker.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 _ArrayElement=_interopRequireDefault(require("../arrayable/ArrayElement"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}class Linker extends _ArrayElement.default{next=null;constructor(){let{data:e=null,next:t=null}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};super(e,arguments.length>1&&void 0!==arguments[1]?arguments[1]:Linker),this.next=t}}Linker.make=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Linker;return"object"!=typeof e?new t({data:e}):e.classType?e:(e.data||(e={data:e}),new t(e,t))},Linker.fromArray=function(){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Linker;return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:[]).reduce(((t,r)=>{const n=e.make(r);return null===t.head?{head:n,tail:n}:(t.tail.next=n,t.tail=n,t)}),{head:null,tail:null})};var _default=exports.default=Linker;

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

@@ -0,0 +1,96 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+var _DoublyLinkedList = _interopRequireDefault(require('../doubly-linked-llist/DoublyLinkedList'))
+var _TreeLinker = _interopRequireDefault(require('./TreeLinker'))
+function _interopRequireDefault (obj) { return obj && obj.__esModule ? obj : { default: obj } }
+/**
+ * @file doubly linked tree list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * LinkedTreeList represents a collection stored with a root and spreading in branching (tree) formation..
+ * @extends DoublyLinkedList
+ */
+class LinkedTreeList extends _DoublyLinkedList.default {
+  /**
+   * Create the new LinkedTreeList instance, configure the list class.
+   * @param {LinkedTreeList|Iterable} [listClass=LinkedTreeList]
+   */
+  constructor () {
+    const listClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : LinkedTreeList
+    super(listClass)
+  }
+
+  /**
+   * Get the parent of this tree list.
+   * @return {TreeLinker}
+   */
+  get parent () {
+    return this.first.parent
+  }
+
+  /**
+   * Set the parent of this tree list
+   * @param {TreeLinker} parent
+   */
+  set parent (parent) {
+    let current = this.first
+    while (current !== null) {
+      current.parent = parent
+      current = current.next
+    }
+    if (parent) {
+      parent.children = this
+    }
+  }
+
+  /**
+   * Return the root parent of the entire tree.
+   * @return {TreeLinker}
+   */
+  get rootParent () {
+    let current = this.first
+    let parent = this.first.parent
+    while (parent !== null) {
+      current = parent
+      parent = current.parent
+    }
+    return current
+  }
+
+  /**
+   * Set the children on a parent item.
+   * @param {TreeLinker} item
+   * @param {LinkedTreeList} children
+   */
+  setChildren (item) {
+    const children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null
+    if (Array.from(this).indexOf(item) < 0) {
+      console.error('item is not a child of this')
+    }
+    children.parent = item
+  }
+}
+
+/**
+ * Create an instance of LinkedTreeList from an array
+ * @memberof LinkedTreeList
+ * @param {Array} [values=[]]
+ * @param {TreeLinker} [linkerClass=TreeLinker]
+ * @param {LinkedTreeList} [listClass=LinkedTreeList]
+ * @returns {DoublyLinkedList}
+ */
+LinkedTreeList.fromArray = function () {
+  const values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []
+  const linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _TreeLinker.default
+  const listClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : LinkedTreeList
+  return _DoublyLinkedList.default.fromArray(values, linkerClass, listClass)
+}
+var _default = exports.default = LinkedTreeList

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _DoublyLinkedList=_interopRequireDefault(require("../doubly-linked-llist/DoublyLinkedList")),_TreeLinker=_interopRequireDefault(require("./TreeLinker"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}class LinkedTreeList extends _DoublyLinkedList.default{constructor(){super(arguments.length>0&&void 0!==arguments[0]?arguments[0]:LinkedTreeList)}get parent(){return this.first.parent}set parent(e){let t=this.first;for(;null!==t;)t.parent=e,t=t.next;e&&(e.children=this)}get rootParent(){let e=this.first,t=this.first.parent;for(;null!==t;)e=t,t=e.parent;return e}setChildren(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;Array.from(this).indexOf(e)<0&&console.error("item is not a child of this"),t.parent=e}}LinkedTreeList.fromArray=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:_TreeLinker.default,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:LinkedTreeList;return _DoublyLinkedList.default.fromArray(e,t,r)};var _default=exports.default=LinkedTreeList;

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

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.iterator.map.js");
+var _DoubleLinker = _interopRequireDefault(require("../doubly-linked-llist/DoubleLinker"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @file doubly linked tree item.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * TreeLinker represents a node in a LinkedTreeList.
+ * @extends DoubleLinker
+ */
+class TreeLinker extends _DoubleLinker.default {
+  parent = null;
+  children = null;
+
+  /**
+   * Create the new TreeLinker instance, provide the data and optionally configure the type of Linker.
+   * @param {Object} [settings={}]
+   * @param {*} [settings.data=null]
+   * @param {TreeLinker} [settings.prev=null]
+   * @param {TreeLinker} [settings.next=null]
+   * @param {LinkedTreeList} [settings.children=null]
+   * @param {TreeLinker} [settings.parent=null]
+   * @param {TreeLinker} [linkerClass=TreeLinker]
+   */
+  constructor() {
+    let {
+      data = null,
+      prev = null,
+      next = null,
+      children = null,
+      parent = null
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TreeLinker;
+    super({
+      data,
+      prev,
+      next
+    }, linkerClass);
+    this.parent = parent;
+    this.children = this.childrenFromArray(children, linkerClass);
+  }
+
+  /**
+   * Return the parent of this Tree Linker.
+   * @return {TreeLinker|null}
+   */
+  get parent() {
+    return this.parent;
+  }
+
+  /**
+   * Return the children of this Tree Linker.
+   * @return {LinkedTreeList|null}
+   */
+  get children() {
+    return this.children;
+  }
+
+  /**
+   * Create the children for this tree from an array.
+   * @param {Array|null} children
+   * @param {TreeLinker} linkerClass
+   * @return {DoubleLinker|null}
+   */
+  childrenFromArray() {
+    let children = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TreeLinker;
+    if (children === null) {
+      return null;
+    }
+    return _DoubleLinker.default.fromArray.apply(this, [children.map(child => Object.assign({}, child, {
+      parent: this
+    })), linkerClass]).tail;
+  }
+}
+
+/**
+ * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+ * @methodof TreeLinker
+ * @param {TreeLinker|*} linker
+ * @param {TreeLinker} [linkerClass=TreeLinker]
+ * @return {Linker}
+ */
+TreeLinker.make = function (linker) {
+  let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TreeLinker;
+  return _DoubleLinker.default.make(linker, linkerClass);
+};
+
+/**
+ * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+ * @methodof TreeLinker
+ * @param {Array} [values=[]]
+ * @param {TreeLinker} [linkerClass=TreeLinker]
+ * @returns {{head: TreeLinker, tail: TreeLinker}}
+ */
+TreeLinker.fromArray = function () {
+  let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let linkerClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TreeLinker;
+  return _DoubleLinker.default.fromArray(values, linkerClass);
+};
+var _default = exports.default = TreeLinker;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0,require("core-js/modules/esnext.async-iterator.map.js"),require("core-js/modules/esnext.iterator.map.js");var _DoubleLinker=_interopRequireDefault(require("../doubly-linked-llist/DoubleLinker"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}class TreeLinker extends _DoubleLinker.default{parent=null;children=null;constructor(){let{data:e=null,prev:r=null,next:t=null,children:n=null,parent:l=null}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:TreeLinker;super({data:e,prev:r,next:t},i),this.parent=l,this.children=this.childrenFromArray(n,i)}get parent(){return this.parent}get children(){return this.children}childrenFromArray(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:TreeLinker;return null===e?null:_DoubleLinker.default.fromArray.apply(this,[e.map((e=>Object.assign({},e,{parent:this}))),r]).tail}}TreeLinker.make=function(e){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:TreeLinker;return _DoubleLinker.default.make(e,r)},TreeLinker.fromArray=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:TreeLinker;return _DoubleLinker.default.fromArray(e,r)};var _default=exports.default=TreeLinker;