collect-your-stuff 2.1.2 → 2.2.0

package/browser/collect-your-stuff.js

@@ -14,7 +14,7 @@
     class ArrayElement {
       /**
    * Create the new Element instance, provide the data and optionally configure the type of Element.
-   * @param {*} [data=null] The data to be stored in this element.
+   * @param data The data to be stored in this element.
    */
       constructor (data = null) {
         /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
@@ -26,9 +26,8 @@
     }
     /**
  * Make a new Element from the data given if it is not already a valid Element.
- * @param {ArrayElement|*} element Return a valid ArrayElement instance from given data, or even an already valid one.
- * @param {IsElement} [classType=ArrayElement] Provide the type of IsElement to use.
- * @return {ArrayElement}
+ * @param element Return a valid ArrayElement instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsElement to use.
  */
     exports.ArrayElement = ArrayElement
     ArrayElement.make = (element, classType = ArrayElement) => {
@@ -45,9 +44,8 @@
     }
     /**
  * Convert an array into Element instances, return the head and tail Elements.
- * @param {Array<IsElement>} [values=[]] Provide an array of data that will be converted to array of elements.
- * @param {IsElement} [classType=ArrayElement] Provide the type of IsElement to use.
- * @returns {{head: ArrayElement[], tail: ArrayElement}}
+ * @param values Provide an array of data that will be converted to array of elements.
+ * @param classType Provide the type of IsElement to use.
  */
     ArrayElement.fromArray = (values = [], classType = ArrayElement) => values.reduce((references, element) => {
       const newElement = classType.make(element, classType)
@@ -66,7 +64,7 @@
       head: [],
       tail: null
     })
-  }, { 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.reduce.js': 125 }],
+  }, { 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.reduce.js': 133 }],
   2: [function (require, module, exports) {
     'use strict'
 
@@ -77,10 +75,7 @@
     const _ArrayElement = require('./ArrayElement')
     const _ArrayIterator = require('../../recipes/ArrayIterator')
     /**
- * @file arrayable list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * arrayable list.
  */
 
     /**
@@ -89,7 +84,7 @@
     class Arrayable {
       /**
    * Create the new Arrayable instance, configure the Arrayable class.
-   * @param {ArrayElement} [elementClass=ArrayElement] The class used to wrap given data as elements.
+   * @param elementClass The class used to wrap given data as elements.
    */
       constructor (elementClass = _ArrayElement.ArrayElement) {
         /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
@@ -103,8 +98,7 @@
 
       /**
    * Find the position of an element which must be in this list.
-   * @param {ArrayElement} node The element to find
-   * @returns {number}
+   * @param node The element to find
    * @throws {Error} When the element is not in this list
    */
       indexOfElement (node) {
@@ -117,8 +111,7 @@
 
       /**
    * Initialize the inner list, should only run once.
-   * @param {Array<ArrayElement>} initialList Give the array of elements to start in this Arrayable.
-   * @return {Arrayable}
+   * @param initialList Give the array of elements to start in this Arrayable.
    */
       initialize (initialList) {
         if (this.initialized) {
@@ -132,7 +125,6 @@
 
       /**
    * Retrieve the innerList used (the list itself, not a copy).
-   * @returns {Array<ArrayElement>}
    */
       get list () {
         return this.innerList
@@ -140,7 +132,7 @@
 
       /**
    * Retrieve the first Element from the Arrayable
-   * @returns {ArrayElement|null} The first element, or null when the Arrayable is empty
+   * @returns The first element, or null when the Arrayable is empty
    */
       get first () {
         return this.length ? this.innerList[0] : null
@@ -148,7 +140,7 @@
 
       /**
    * Retrieve the last Element from the Arrayable
-   * @returns {ArrayElement|null} The last element, or null when the Arrayable is empty
+   * @returns The last element, or null when the Arrayable is empty
    */
       get last () {
         return this.length ? this.innerList[this.length - 1] : null
@@ -156,7 +148,6 @@
 
       /**
    * Return the length of the list.
-   * @returns {number}
    */
       get length () {
         return this.innerList.length
@@ -164,9 +155,8 @@
 
       /**
    * Insert a new node (or data) after a node.
-   * @param {ArrayElement|null} node The existing node as reference, or null to insert at the start of the list
-   * @param {ArrayElement|*} newNode The new node to go after the existing node
-   * @returns {Arrayable}
+   * @param node The existing node as reference, or null to insert at the start of the list
+   * @param newNode The new node to go after the existing node
    * @throws {Error} When the reference node is not in this list
    */
       insertAfter (node, newNode) {
@@ -178,9 +168,8 @@
 
       /**
    * Insert a new node (or data) before a node.
-   * @param {ArrayElement|null} node The existing node as reference, or null to insert at the end of the list
-   * @param {ArrayElement|*} newNode The new node to go before the existing node
-   * @returns {Arrayable}
+   * @param node The existing node as reference, or null to insert at the end of the list
+   * @param newNode The new node to go before the existing node
    * @throws {Error} When the reference node is not in this list
    */
       insertBefore (node, newNode) {
@@ -192,9 +181,8 @@
 
       /**
    * Add a node (or data) after the given (or last) node in the list.
-   * @param {ArrayElement|*} node The new node to add to the end of the list
-   * @param {ArrayElement} after The existing last node
-   * @returns {Arrayable}
+   * @param node The new node to add to the end of the list
+   * @param after The existing last node
    */
       append (node, after = this.last) {
         if (after === this.last) {
@@ -207,9 +195,8 @@
 
       /**
    * Add a node (or data) before the given (or first) node in the list.
-   * @param {ArrayElement|*} node The new node to add to the start of the list
-   * @param {ArrayElement} before The existing first node
-   * @returns {Arrayable}
+   * @param node The new node to add to the start of the list
+   * @param before The existing first node
    */
       prepend (node, before = this.first) {
         if (before === this.first) {
@@ -222,8 +209,8 @@
 
       /**
    * Remove an element from this arrayable.
-   * @param {ArrayElement} node The node we wish to remove (and it will be returned after removal)
-   * @return {ArrayElement|null} The removed node, or null when it was not in this list (nothing is removed)
+   * @param node The node we wish to remove (and it will be returned after removal)
+   * @returns The removed node, or null when it was not in this list (nothing is removed)
    */
       remove (node) {
         const deleteAt = this.innerList.indexOf(node)
@@ -236,8 +223,7 @@
 
       /**
    * Retrieve an ArrayElement item from this list by numeric index, otherwise return null.
-   * @param {number} index The integer number for retrieving a node by position.
-   * @return {ArrayElement|null}
+   * @param index The integer number for retrieving a node by position.
    */
       item (index) {
         if (index >= this.length) {
@@ -259,9 +245,8 @@
 
       /**
    * Be able to run forEach on this Arrayable to iterate over the elements.
-   * @param {forEachCallback} callback The function to call for-each element
-   * @param {Arrayable} thisArg Optional, 'this' reference
-   * @returns {Arrayable}
+   * @param callback The function to call for-each element
+   * @param thisArg Optional, 'this' reference
    */
       forEach (callback, thisArg = this) {
         for (let i = 0; i < thisArg.length; ++i) {
@@ -272,7 +257,6 @@
 
       /**
    * Be able to iterate over this class.
-   * @returns {Iterator}
    */
       [Symbol.iterator] () {
         const index = 0
@@ -281,17 +265,16 @@
     }
     /**
  * Convert an array to an Arrayable.
- * @param {Array} values An array of values which will be converted to elements in this arrayable
- * @param {IsElement} [elementClass=ArrayElement] The class to use for each element
- * @param {IsArrayable<ArrayElement>} [classType=Arrayable] Provide the type of IsArrayable to use.
- * @returns {Arrayable}
+ * @param values An array of values which will be converted to elements in this arrayable
+ * @param elementClass The class to use for each element
+ * @param classType Provide the type of IsArrayable to use.
  */
     exports.Arrayable = Arrayable
     Arrayable.fromArray = (values = [], elementClass = _ArrayElement.ArrayElement, classType = Arrayable) => {
       const list = new classType(elementClass)
       return list.initialize(elementClass.fromArray(values).head)
     }
-  }, { '../../recipes/ArrayIterator': 16, './ArrayElement': 1 }],
+  }, { '../../recipes/ArrayIterator': 17, './ArrayElement': 1 }],
   3: [function (require, module, exports) {
     'use strict'
 
@@ -309,10 +292,10 @@
     class DoubleLinker {
       /**
    * Create the new DoubleLinker instance, provide the data and optionally the next and prev references.
-   * @param {Object} [nodeData={}] The settings for the new linker.
-   * @param {*} [nodeData.data=null] The data to be stored in this linker
-   * @param {DoubleLinker|null} [nodeData.next=null] The reference to the next linker if any
-   * @param {DoubleLinker|null} [nodeData.prev=null] The reference to the previous linker if any
+   * @param nodeData The settings for the new linker.
+   * @param nodeData.data The data to be stored in this linker
+   * @param nodeData.next The reference to the next linker if any
+   * @param nodeData.prev The reference to the previous linker if any
    */
       constructor ({
         data = null,
@@ -334,9 +317,8 @@
     }
     /**
  * Make a new DoubleLinker from the data given if it is not already a valid Linker.
- * @param {DoubleLinker|*} linker Return a valid Linker instance from given data, or even an already valid one.
- * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
- * @return {DoubleLinker}
+ * @param linker Return a valid Linker instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsDoubleLinker to use.
  */
     exports.DoubleLinker = DoubleLinker
     DoubleLinker.make = (linker, classType = DoubleLinker) => {
@@ -344,9 +326,8 @@
     }
     /**
  * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
- * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of linkers.
- * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
- * @returns {{head: DoubleLinker, tail: DoubleLinker}}
+ * @param values Provide an array of data that will be converted to a chain of linkers.
+ * @param classType Provide the type of IsDoubleLinker to use.
  */
     DoubleLinker.fromArray = (values = [], classType = DoubleLinker) => values.reduce((references, linker) => {
       const newLinker = classType.make(linker, classType)
@@ -366,7 +347,7 @@
       head: null,
       tail: null
     })
-  }, { '../linked-list/Linker': 6, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.reduce.js': 125 }],
+  }, { '../linked-list/Linker': 6, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.reduce.js': 133 }],
   4: [function (require, module, exports) {
     'use strict'
 
@@ -380,10 +361,7 @@
     const _DoubleLinkerIterator = require('../../recipes/DoubleLinkerIterator')
     const _LinkedList = require('../linked-list/LinkedList')
     /**
- * @file doubly linked list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * doubly linked list.
  */
 
     /**
@@ -393,7 +371,7 @@
     class DoublyLinkedList {
       /**
    * Create the new DoublyLinkedList instance.
-   * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
+   * @param linkerClass The class used to wrap given data as linkers.
    */
       constructor (linkerClass = _DoubleLinker.DoubleLinker) {
         /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
@@ -411,8 +389,7 @@
 
       /**
    * Initialize the inner list, should only run once.
-   * @param {DoubleLinker} initialList Give the list of double-linkers to start in this doubly linked-list.
-   * @return {DoublyLinkedList}
+   * @param initialList Give the list of double-linkers to start in this doubly linked-list.
    */
       initialize (initialList) {
         // Borrowed from LinkedList, which types its return as a LinkedList although it returns whatever list called it
@@ -421,7 +398,6 @@
 
       /**
    * Retrieve the innerList used (the list itself, not a copy).
-   * @returns {DoubleLinker}
    */
       get list () {
         return this.innerList
@@ -429,7 +405,6 @@
 
       /**
    * Retrieve the first DoubleLinker in the list.
-   * @returns {DoubleLinker}
    */
       get first () {
         let head = this.innerList
@@ -446,7 +421,6 @@
 
       /**
    * Retrieve the last DoubleLinker in the list. The end is remembered, so this does not walk the list.
-   * @returns {DoubleLinker}
    */
       get last () {
         if (this.innerList === null) {
@@ -464,7 +438,6 @@
       /**
    * 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 () {
         if (this.countCache === null) {
@@ -475,9 +448,8 @@
 
       /**
    * Insert a new node (or data) after a node.
-   * @param {DoubleLinker|*} node The existing node as reference (which must be in this list, this is not checked), or null to insert at the start of the list
-   * @param {DoubleLinker|*} newNode The new node to go after the existing node
-   * @returns {DoublyLinkedList}
+   * @param node The existing node as reference (which must be in this list, this is not checked), or null to insert at the start of the list
+   * @param newNode The new node to go after the existing node
    */
       insertAfter (node, newNode) {
         newNode = this.linkerClass.make(newNode, this.linkerClass)
@@ -514,9 +486,8 @@
 
       /**
    * Insert a new node (or data) before a node.
-   * @param {DoubleLinker|*} node The existing node as reference (which must be in this list, this is not checked), or null to insert at the end of the list
-   * @param {DoubleLinker|*} newNode The new node to go before the existing node
-   * @returns {DoublyLinkedList}
+   * @param node The existing node as reference (which must be in this list, this is not checked), or null to insert at the end of the list
+   * @param newNode The new node to go before the existing node
    */
       insertBefore (node, newNode) {
         newNode = this.linkerClass.make(newNode, this.linkerClass)
@@ -553,9 +524,8 @@
 
       /**
    * Add a node (or data) after the given (or last) node in the list.
-   * @param {DoubleLinker|*} node The new node to add to the end of the list
-   * @param {DoubleLinker} after The existing last node
-   * @returns {DoubleLinker}
+   * @param node The new node to add to the end of the list
+   * @param after The existing last node
    */
       append (node, after = this.last) {
         return this.insertAfter(after, node)
@@ -563,9 +533,8 @@
 
       /**
    * Add a node (or data) before the given (or first) node in the list.
-   * @param {DoubleLinker|*} node The new node to add to the start of the list
-   * @param {DoubleLinker} before The existing first node
-   * @returns {DoubleLinker}
+   * @param node The new node to add to the start of the list
+   * @param before The existing first node
    */
       prepend (node, before = this.first) {
         return this.insertBefore(before, node)
@@ -573,8 +542,7 @@
 
       /**
    * Remove a linker from this linked list.
-   * @param {DoubleLinker} node The node we wish to remove (and it will be returned after removal)
-   * @return {DoubleLinker}
+   * @param node The node we wish to remove (and it will be returned after removal)
    */
       remove (node) {
         if (node === null || typeof node === 'undefined') {
@@ -608,7 +576,6 @@
       /**
    * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The list's
    * own methods keep these up to date, so this is only needed after linkers were changed directly.
-   * @return {DoubleLinker|null}
    */
       reset () {
         // Start at the pointer for the list
@@ -639,8 +606,7 @@
 
       /**
    * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
-   * @param {number} index The integer number for retrieving a node by position.
-   * @returns {DoubleLinker|null}
+   * @param index The integer number for retrieving a node by position.
    */
       item (index) {
         if (index >= 0) {
@@ -667,9 +633,9 @@
 
       /**
    * Be able to run forEach on this DoublyLinkedList to iterate over the DoubleLinker Items.
-   * @param {forEachCallback} callback The function to call for-each double linker
-   * @param {DoublyLinkedList} thisArg Optional, 'this' reference
-   * @return {DoublyLinkedList} The list which was iterated.
+   * @param callback The function to call for-each double linker
+   * @param thisArg Optional, 'this' reference
+   * @returns The list which was iterated.
    */
       forEach (callback, thisArg = this) {
         return _LinkedList.LinkedList.prototype.forEach.call(this, callback, thisArg)
@@ -677,7 +643,6 @@
 
       /**
    * Be able to iterate over this class.
-   * @returns {Iterator}
    */
       [Symbol.iterator] () {
         const current = this.first
@@ -686,16 +651,15 @@
     }
     /**
  * Convert an array into a DoublyLinkedList instance, return the new instance.
- * @param {Array} [values=[]] An array of values which will be converted to linkers in this doubly-linked-list
- * @param {IsDoubleLinker} [linkerClass=DoubleLinker] The class to use for each linker
- * @param {IsArrayable<IsDoubleLinker>} [classType=LinkedList] Provide the type of IsArrayable to use.
- * @returns {DoublyLinkedList}
+ * @param values An array of values which will be converted to linkers in this doubly-linked-list
+ * @param linkerClass The class to use for each linker
+ * @param classType Provide the type of IsArrayable to use.
  */
     exports.DoublyLinkedList = DoublyLinkedList
     DoublyLinkedList.fromArray = (values = [], linkerClass = _DoubleLinker.DoubleLinker, classType = DoublyLinkedList) => {
       return _LinkedList.LinkedList.fromArray(values, linkerClass, classType)
     }
-  }, { '../../recipes/DoubleLinkerIterator': 17, '../linked-list/LinkedList': 5, './DoubleLinker': 3, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.for-each.js': 123 }],
+  }, { '../../recipes/DoubleLinkerIterator': 18, '../linked-list/LinkedList': 5, './DoubleLinker': 3, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 131 }],
   5: [function (require, module, exports) {
     'use strict'
 
@@ -713,7 +677,7 @@
     class LinkedList {
       /**
    * Create the new LinkedList instance.
-   * @param {Linker} [linkerClass=Linker] The class used to wrap given data as linkers.
+   * @param linkerClass The class used to wrap given data as linkers.
    */
       constructor (linkerClass = _Linker.Linker) {
         /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
@@ -731,8 +695,7 @@
 
       /**
    * Initialize the inner list, should only run once.
-   * @param {Linker|Array} initialList Give the list of linkers to start in this linked-list.
-   * @return {LinkedList}
+   * @param initialList Give the list of linkers to start in this linked-list.
    */
       initialize (initialList) {
         // Borrowed from Arrayable, which types its return as an Arrayable although it returns whatever list called it
@@ -741,7 +704,6 @@
 
       /**
    * Retrieve the innerList used (the list itself, not a copy).
-   * @returns {Linker}
    */
       get list () {
         return this.innerList
@@ -749,7 +711,6 @@
 
       /**
    * Retrieve the first Linker in the list.
-   * @returns {Linker}
    */
       get first () {
         return this.innerList
@@ -757,7 +718,6 @@
 
       /**
    * Retrieve the last Linker in the list. The end is remembered, so this does not walk the list.
-   * @returns {Linker}
    */
       get last () {
         if (this.innerList === null) {
@@ -775,7 +735,6 @@
       /**
    * 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 () {
         if (this.countCache === null) {
@@ -786,9 +745,8 @@
 
       /**
    * Insert a new node (or data) after a node.
-   * @param {Linker|*} node The existing node as reference, or null to insert at the start of the list
-   * @param {Linker|*} newNode The new node to go after the existing node
-   * @returns {LinkedList}
+   * @param node The existing node as reference, or null to insert at the start of the list
+   * @param newNode The new node to go after the existing node
    */
       insertAfter (node, newNode) {
         newNode = this.linkerClass.make(newNode, this.linkerClass)
@@ -814,9 +772,8 @@
 
       /**
    * Insert a new node (or data) before a node.
-   * @param {Linker|*} node The existing node as reference, or null to insert at the end of the list
-   * @param {Linker|*} newNode The new node to go before the existing node
-   * @returns {LinkedList}
+   * @param node The existing node as reference, or null to insert at the end of the list
+   * @param newNode The new node to go before the existing node
    * @throws {Error} When the reference node is not in this list
    */
       insertBefore (node, newNode) {
@@ -856,9 +813,8 @@
 
       /**
    * Add a node (or data) after the given (or last) node in the list.
-   * @param {Linker|*} node The new node to add to the end of the list
-   * @param {Linker} after The existing last node
-   * @returns {Linker}
+   * @param node The new node to add to the end of the list
+   * @param after The existing last node
    */
       append (node, after = this.last) {
         return this.insertAfter(after, node)
@@ -866,9 +822,8 @@
 
       /**
    * Add a node (or data) before the given (or first) node in the list.
-   * @param {Linker|*} node The new node to add to the start of the list
-   * @param {Linker} before The existing first node
-   * @returns {Linker}
+   * @param node The new node to add to the start of the list
+   * @param before The existing first node
    */
       prepend (node, before = this.first) {
         return this.insertBefore(before, node)
@@ -876,8 +831,8 @@
 
       /**
    * Remove a linker from this linked list.
-   * @param {Linker} node The node we wish to remove (and it will be returned after removal)
-   * @return {Linker|null} The removed node, or null when it was not in this list (nothing is removed)
+   * @param node The node we wish to remove (and it will be returned after removal)
+   * @returns The removed node, or null when it was not in this list (nothing is removed)
    */
       remove (node) {
         if (node === null || typeof node === 'undefined') {
@@ -913,7 +868,7 @@
       /**
    * Refresh the remembered end and length of the list by walking it once. The list's own methods keep these up to date,
    * so this is only needed after linkers were changed directly (for example by setting next on a linker).
-   * @return {Linker|null} The first linker of the list
+   * @returns The first linker of the list
    */
       reset () {
         let count = 0
@@ -931,8 +886,7 @@
 
       /**
    * Retrieve a Linker item from this list by numeric index, otherwise return null.
-   * @param {number} index The integer number for retrieving a node by position.
-   * @returns {Linker|null}
+   * @param index The integer number for retrieving a node by position.
    */
       item (index) {
         if (index >= 0) {
@@ -958,9 +912,8 @@
 
       /**
    * Be able to run forEach on this LinkedList to iterate over the linkers.
-   * @param {forEachCallback} callback The function to call for-each linker
-   * @param {LinkedList} thisArg Optional, 'this' reference
-   * @returns {LinkedList}
+   * @param callback The function to call for-each linker
+   * @param thisArg Optional, 'this' reference
    */
       forEach (callback, thisArg = this) {
         let index = 0
@@ -975,7 +928,6 @@
 
       /**
    * Be able to iterate over this class.
-   * @returns {Iterator}
    */
       [Symbol.iterator] () {
         return new _LinkerIterator.LinkerIterator(this.first)
@@ -983,17 +935,16 @@
     }
     /**
  * Convert an array to a LinkedList.
- * @param {Array} values An array of values which will be converted to linkers in this linked-list
- * @param {IsLinker} linkerClass The class to use for each linker
- * @param {IsArrayable<Linker>} [classType=LinkedList] Provide the type of IsArrayable to use.
- * @returns {LinkedList}
+ * @param values An array of values which will be converted to linkers in this linked-list
+ * @param linkerClass The class to use for each linker
+ * @param classType Provide the type of IsArrayable to use.
  */
     exports.LinkedList = LinkedList
     LinkedList.fromArray = (values = [], linkerClass = _Linker.Linker, classType = LinkedList) => {
       const list = new classType(linkerClass)
       return list.initialize(linkerClass.fromArray(values).head)
     }
-  }, { '../../recipes/LinkerIterator': 18, '../arrayable/Arrayable': 2, './Linker': 6 }],
+  }, { '../../recipes/LinkerIterator': 19, '../arrayable/Arrayable': 2, './Linker': 6 }],
   6: [function (require, module, exports) {
     'use strict'
 
@@ -1011,9 +962,9 @@
     class Linker {
       /**
    * Create the new Linker instance, provide the data and optionally give the next Linker.
-   * @param {Object} [nodeData={}] The settings for the new linker.
-   * @param {*} [nodeData.data=null] The data to be stored in this linker
-   * @param {Linker|null} [nodeData.next=null] The reference to the next linker if any
+   * @param nodeData The settings for the new linker.
+   * @param nodeData.data The data to be stored in this linker
+   * @param nodeData.next The reference to the next linker if any
    */
       constructor ({
         data = null,
@@ -1031,9 +982,8 @@
     }
     /**
  * Make a new Linker from the data given if it is not already a valid Linker.
- * @param {Linker|*} linker Return a valid Linker instance from given data, or even an already valid one.
- * @param {IsLinker} [classType=Linker] Provide the type of IsLinker to use.
- * @return {Linker}
+ * @param linker Return a valid Linker instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsLinker to use.
  */
     exports.Linker = Linker
     Linker.make = (linker, classType = Linker) => {
@@ -1058,9 +1008,8 @@
     }
     /**
  * Convert an array into Linker instances, return the head and tail Linkers.
- * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of linkers.
- * @param {IsLinker} [classType=Linker] Provide the type of IsLinker to use.
- * @returns {{head: Linker, tail: Linker}}
+ * @param values Provide an array of data that will be converted to a chain of linkers.
+ * @param classType Provide the type of IsLinker to use.
  */
     Linker.fromArray = (values = [], classType = Linker) => values.reduce((references, linker) => {
       const newLinker = classType.make(linker, classType)
@@ -1079,7 +1028,7 @@
       head: null,
       tail: null
     })
-  }, { '../arrayable/ArrayElement': 1, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.reduce.js': 125 }],
+  }, { '../arrayable/ArrayElement': 1, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.reduce.js': 133 }],
   7: [function (require, module, exports) {
     'use strict'
 
@@ -1093,17 +1042,13 @@
     const _TreeLinkerIterator = require('../../recipes/TreeLinkerIterator')
     const _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
     /**
- * @file doubly linked tree list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * doubly linked tree list.
  */
 
     /**
  * Use one of the accessors of DoublyLinkedList (which keeps track of the head, tail and length) for a LinkedTreeList.
- * @param {string} name The accessor to use
- * @param {LinkedTreeList} list The list to use it on
- * @returns {*}
+ * @param name The accessor to use
+ * @param list The list to use it on
  */
     const borrowedGetter = (name, list) => Object.getOwnPropertyDescriptor(_DoublyLinkedList.DoublyLinkedList.prototype, name).get.call(list)
     /**
@@ -1113,7 +1058,7 @@
     class LinkedTreeList {
       /**
    * Create the new LinkedTreeList instance, configure the list class.
-   * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
+   * @param linkerClass The class used to wrap given data as tree linkers.
    */
       constructor (linkerClass = _TreeLinker.TreeLinker) {
         /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
@@ -1133,8 +1078,7 @@
 
       /**
    * 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}
+   * @param initialList Give the list of tree-linkers to start in this linked-tree-list.
    */
       initialize (initialList) {
         if (this.initialized) {
@@ -1148,7 +1092,6 @@
 
       /**
    * Retrieve the innerList used (the list itself, not a copy).
-   * @returns {TreeLinker}
    */
       get list () {
         return this.innerList
@@ -1156,7 +1099,6 @@
 
       /**
    * Retrieve the first TreeLinker in the list.
-   * @returns {TreeLinker}
    */
       get first () {
         return borrowedGetter('first', this)
@@ -1164,7 +1106,6 @@
 
       /**
    * Retrieve the last TreeLinker in the list. The end is remembered, so this does not walk the list.
-   * @returns {TreeLinker}
    */
       get last () {
         return borrowedGetter('last', this)
@@ -1173,7 +1114,6 @@
       /**
    * 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 () {
         return borrowedGetter('length', this)
@@ -1182,7 +1122,6 @@
       /**
    * 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 () {
         if (this.ownerNode !== undefined) {
@@ -1195,7 +1134,7 @@
       /**
    * 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
+   * @param parent The new node to use as the parent for this group of children
    */
       set parent (parent) {
         this.ownerNode = parent
@@ -1211,7 +1150,6 @@
 
       /**
    * Return the root parent of the entire tree.
-   * @return {TreeLinker}
    */
       get rootParent () {
         let current = this.first
@@ -1228,8 +1166,8 @@
 
       /**
    * 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
+   * @param item The TreeLinker node (one of the linkers of this list) that will be the parent of the children
+   * @param children 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, children = null) {
@@ -1252,8 +1190,7 @@
 
       /**
    * 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}
+   * @param newNode The node (or data) which is being added to this list
    */
       adopt (newNode) {
         const linker = this.linkerClass.make(newNode, this.linkerClass)
@@ -1263,9 +1200,8 @@
 
       /**
    * 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}
+   * @param node The existing node as reference, or null to insert at the start of the list
+   * @param newNode The new node to go after the existing node
    */
       insertAfter (node, newNode) {
         return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this, node, this.adopt(newNode))
@@ -1273,9 +1209,8 @@
 
       /**
    * 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}
+   * @param node The existing node as reference, or null to insert at the end of the list
+   * @param newNode The new node to go before the existing node
    */
       insertBefore (node, newNode) {
         return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this, node, this.adopt(newNode))
@@ -1283,9 +1218,8 @@
 
       /**
    * 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}
+   * @param node The new node to add to the end of the list
+   * @param after The existing last node
    */
       append (node, after = this.last) {
         return _DoublyLinkedList.DoublyLinkedList.prototype.append.call(this, node, after)
@@ -1293,9 +1227,8 @@
 
       /**
    * 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}
+   * @param node The new node to add to the start of the list
+   * @param before The existing first node
    */
       prepend (node, before = this.first) {
         return _DoublyLinkedList.DoublyLinkedList.prototype.prepend.call(this, node, before)
@@ -1303,8 +1236,8 @@
 
       /**
    * 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
+   * @param node The node we wish to remove (and it will be returned after removal)
+   * @returns The removed node, or null when there was nothing to remove
    */
       remove (node) {
         const owner = this.parent
@@ -1320,7 +1253,6 @@
       /**
    * 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 () {
         return _DoublyLinkedList.DoublyLinkedList.prototype.reset.call(this)
@@ -1328,8 +1260,7 @@
 
       /**
    * 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}
+   * @param index The integer number for retrieving a node by position.
    */
       item (index) {
         return _DoublyLinkedList.DoublyLinkedList.prototype.item.call(this, index)
@@ -1337,9 +1268,9 @@
 
       /**
    * 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.
+   * @param callback The function to call for-each tree node
+   * @param thisArg Optional, 'this' reference
+   * @returns The list which was iterated.
    */
       forEach (callback, thisArg = this) {
         let index = 0
@@ -1355,7 +1286,6 @@
       /**
    * 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] () {
         // The linkers of this list and everything below them, left-first. It stays within this list: it does not start at,
@@ -1365,17 +1295,16 @@
     }
     /**
  * 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}
+ * @param values An array of values which will be converted to nodes in this tree-list
+ * @param linkerClass The class to use for each node
+ * @param classType Provide the type of IsArrayable to use.
  */
     exports.LinkedTreeList = LinkedTreeList
     LinkedTreeList.fromArray = (values = [], linkerClass = _TreeLinker.TreeLinker, classType = LinkedTreeList) => {
       const list = new classType(linkerClass)
       return list.initialize(linkerClass.fromArray(values).head)
     }
-  }, { '../../recipes/TreeLinkerIterator': 20, '../doubly-linked-list/DoublyLinkedList': 4, './TreeLinker': 8, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.for-each.js': 123 }],
+  }, { '../../recipes/TreeLinkerIterator': 21, '../doubly-linked-list/DoublyLinkedList': 4, './TreeLinker': 8, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 131 }],
   8: [function (require, module, exports) {
     'use strict'
 
@@ -1394,13 +1323,13 @@
     class TreeLinker {
       /**
    * 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
+   * @param settings The settings for the new tree node.
+   * @param settings.data The data to be stored in this tree node
+   * @param settings.next The reference to the next linker if any
+   * @param settings.prev The reference to the previous linker if any
+   * @param settings.children The references to child linkers if any
+   * @param settings.parent The reference to a parent linker if any
+   * @param listClass Give the type of list to use for storing the children
    */
       constructor ({
         data = null,
@@ -1433,9 +1362,8 @@
    * 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}
+   * @param children Provide an array of data / linker references to be children of this tree node.
+   * @param listClass Give the type of list to use for storing the children
    */
       childrenFromArray (children = null, listClass = _LinkedTreeList.LinkedTreeList) {
         if (children === null) {
@@ -1456,9 +1384,8 @@
     }
     /**
  * 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}
+ * @param linker Return a valid TreeLinker instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsTreeNode to use.
  */
     exports.TreeLinker = TreeLinker
     TreeLinker.make = (linker, classType = TreeLinker) => {
@@ -1466,12 +1393,11 @@
     }
     /**
  * 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}}
+ * @param values Provide an array of data that will be converted to a chain of tree-linkers.
+ * @param classType Provide the type of IsTreeNode to use.
  */
     TreeLinker.fromArray = (values = [], classType = TreeLinker) => _DoubleLinker.DoubleLinker.fromArray(values, classType)
-  }, { '../doubly-linked-list/DoubleLinker': 3, './LinkedTreeList': 7, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.map.js': 124 }],
+  }, { '../doubly-linked-list/DoubleLinker': 3, './LinkedTreeList': 7, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.map.js': 132 }],
   9: [function (require, module, exports) {
     'use strict'
 
@@ -1484,10 +1410,7 @@
     const _LinkedList = require('../linked-list/LinkedList')
     const _Linker = require('../linked-list/Linker')
     /**
- * @file queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 2.0.0
- * @memberOf module:collect-your-stuff
+ * queue
  */
 
     /**
@@ -1498,9 +1421,9 @@
     class Queue {
       /**
    * 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
+   * @param queuedList The list of linkers to start in this queue (the first is the front)
+   * @param listClass The type of list to create when no queued list is given
+   * @param linkerClass The class used to hold each queued item
    */
       constructor (queuedList = null, listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) {
         this.linkerClass = linkerClass
@@ -1509,7 +1432,7 @@
 
       /**
    * Take the item from the front of the queue.
-   * @return {*|null} The item, or null when the queue is empty
+   * @returns The item, or null when the queue is empty
    */
       dequeue () {
         const front = this.queuedList.first
@@ -1522,7 +1445,6 @@
 
       /**
    * Check whether the queue has no items.
-   * @return {boolean}
    */
       empty () {
         return this.size() <= 0
@@ -1530,8 +1452,8 @@
 
       /**
    * 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
+   * @param data The item to add
+   * @returns This queue, so that adding can be chained
    */
       enqueue (data) {
         // The item is wrapped here rather than left to the list, since the list treats objects that look like a linker's
@@ -1544,7 +1466,7 @@
 
       /**
    * Look at the item at the front of the queue, without removing it.
-   * @return {*|null} The item, or null when the queue is empty
+   * @returns The item, or null when the queue is empty
    */
       peek () {
         const front = this.queuedList.first
@@ -1553,7 +1475,6 @@
 
       /**
    * Count the items in the queue.
-   * @return {number}
    */
       size () {
         return this.queuedList.length
@@ -1561,7 +1482,6 @@
 
       /**
    * Iterate over the items from the front of the queue to the back, without removing them.
-   * @return {Iterator}
    */
       [Symbol.iterator] () {
         const linkers = this.queuedList[Symbol.iterator]()
@@ -1583,10 +1503,9 @@
     }
     /**
  * 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}
+ * @param values The items to queue
+ * @param listClass The type of list used to store the items
+ * @param linkerClass The class used to hold each queued item
  */
     exports.Queue = Queue
     Queue.fromArray = (values = [], listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) => {
@@ -1594,7 +1513,7 @@
       values.forEach(value => queue.enqueue(value))
       return queue
     }
-  }, { '../linked-list/LinkedList': 5, '../linked-list/Linker': 6, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.for-each.js': 123 }],
+  }, { '../linked-list/LinkedList': 5, '../linked-list/Linker': 6, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 131 }],
   10: [function (require, module, exports) {
     'use strict'
 
@@ -1610,10 +1529,10 @@
     class Queueable {
       /**
    * 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
+   * @param queueableData The settings for the new queueable.
+   * @param queueableData.task The data to be stored in this queueable
+   * @param queueableData.next The reference to the next queueable if any
+   * @param queueableData.ready Indicate if the queueable is ready to run
    */
       constructor ({
         task = null,
@@ -1640,7 +1559,6 @@
 
       /**
    * Check ready state.
-   * @return {boolean}
    */
       get isReady () {
         return typeof this.ready === 'function' ? this.ready() : this.ready
@@ -1648,7 +1566,6 @@
 
       /**
    * Retrieve the data which should be formed as a task.
-   * @return {*}
    */
       get task () {
         if (typeof this.data === 'function') {
@@ -1663,11 +1580,10 @@
 
       /**
    * 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}
+   * @param completeResponse The result to report for the task.
+   * @param completeResponse.success Indicate when the task failed (use false) or give a success message
+   * @param completeResponse.error Indicate a task was error-free (use false) or give an error message
+   * @param completeResponse.context Provide additional data in the response
    */
       markCompleted ({
         success = true,
@@ -1685,7 +1601,6 @@
 
       /**
    * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
-   * @return {completeResponse}
    */
       run () {
         if (!this.isReady) {
@@ -1711,9 +1626,8 @@
     }
     /**
  * 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}
+ * @param queueable Return a valid Queueable instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsLinker to use.
  */
     exports.Queueable = Queueable
     Queueable.make = (queueable, classType = Queueable) => {
@@ -1739,9 +1653,8 @@
     }
     /**
  * 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}}
+ * @param values Provide an array of data that will be converted to a chain of queueable linkers.
+ * @param classType Provide the type of IsLinker to use.
  */
     Queueable.fromArray = (values = [], classType = Queueable) => _Linker.Linker.fromArray(values, classType)
   }, { '../linked-list/Linker': 6 }],
@@ -1755,10 +1668,7 @@
     const _Queueable = require('./Queueable')
     const _LinkedList = require('../linked-list/LinkedList')
     /**
- * @file task queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * task queue
  */
 
     /**
@@ -1769,9 +1679,9 @@
     class TaskQueue {
       /**
    * 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.
+   * @param queuedList Give the list of queueables to start in this queue.
+   * @param listClass The type of list to create when no queued list is given.
+   * @param queueableClass The class used to wrap queued items.
    */
       constructor (queuedList = null, listClass = _LinkedList.LinkedList, queueableClass = _Queueable.Queueable) {
         this.listClass = listClass
@@ -1786,7 +1696,6 @@
    * 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 () {
         let next = this.remove()
@@ -1829,7 +1738,6 @@
 
       /**
    * Return true if the queue is empty (there are no tasks in the queue list)
-   * @return {boolean}
    */
       empty () {
         return this.size() <= 0
@@ -1837,7 +1745,7 @@
 
       /**
    * Add a queued task to the end of the queue
-   * @param {Queueable} queueable Add a new queueable to the end of the queue
+   * @param queueable Add a new queueable to the end of the queue
    */
       enqueue (queueable) {
         this.queuedList.append(queueable)
@@ -1845,7 +1753,6 @@
 
       /**
    * Take a look at the next queued task
-   * @return {Queueable}
    */
       peek () {
         return this.queuedList.first
@@ -1853,7 +1760,6 @@
 
       /**
    * Remove the next queued item and return it.
-   * @return {Queueable|null}
    */
       remove () {
         if (this.empty()) {
@@ -1864,7 +1770,6 @@
 
       /**
    * Get the length of the current queue.
-   * @return {number}
    */
       size () {
         return this.queuedList.length
@@ -1872,10 +1777,9 @@
     }
     /**
  * 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}
+ * @param values An array of values which will be converted to queueables in this queue
+ * @param queueableClass The class to use for each queueable
+ * @param listClass The class to use to manage the queueables
  */
     exports.TaskQueue = TaskQueue
     TaskQueue.fromArray = (values = [], queueableClass = _Queueable.Queueable, listClass = _LinkedList.LinkedList) => {
@@ -1887,6 +1791,89 @@
   12: [function (require, module, exports) {
     'use strict'
 
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.ScopedCollection = void 0
+    require('core-js/modules/esnext.map.delete-all.js')
+    require('core-js/modules/esnext.map.every.js')
+    require('core-js/modules/esnext.map.filter.js')
+    require('core-js/modules/esnext.map.find.js')
+    require('core-js/modules/esnext.map.find-key.js')
+    require('core-js/modules/esnext.map.includes.js')
+    require('core-js/modules/esnext.map.key-of.js')
+    require('core-js/modules/esnext.map.map-keys.js')
+    require('core-js/modules/esnext.map.map-values.js')
+    require('core-js/modules/esnext.map.merge.js')
+    require('core-js/modules/esnext.map.reduce.js')
+    require('core-js/modules/esnext.map.some.js')
+    require('core-js/modules/esnext.map.update.js')
+    require('core-js/modules/esnext.weak-map.delete-all.js')
+    /**
+ * A keyed collection, partitioned by an arbitrary scope object: values are stored and looked up by key, with a
+ * separate key space per scope. Scopes are held by a WeakMap, so a scope that nothing else references any more
+ * takes its whole key space with it - useful anywhere state needs to be tracked per instance of something (a
+ * tree's root, a session) without that something needing to hold the state itself.
+ */
+    class ScopedCollection {
+      constructor () {
+        this.scopes = new WeakMap()
+      }
+
+      /**
+   * Remove a key from a scope's key space.
+   * @param scope The scope to remove the key from
+   * @param key The key to remove
+   * @returns Whether a value was actually removed
+   */
+      delete (scope, key) {
+        const keyedValues = this.scopes.get(scope)
+        return typeof keyedValues === 'undefined' ? false : keyedValues.delete(key)
+      }
+
+      /**
+   * Look up a value by key within a scope.
+   * @param scope The scope to look within
+   * @param key The key to look up
+   * @returns The value, or undefined when the scope or key is not present
+   */
+      get (scope, key) {
+        let _a
+        return (_a = this.scopes.get(scope)) === null || _a === void 0 ? void 0 : _a.get(key)
+      }
+
+      /**
+   * Check whether a key exists within a scope.
+   * @param scope The scope to look within
+   * @param key The key to check
+   */
+      has (scope, key) {
+        let _a, _b
+        return (_b = (_a = this.scopes.get(scope)) === null || _a === void 0 ? void 0 : _a.has(key)) !== null && _b !== void 0 ? _b : false
+      }
+
+      /**
+   * Store a value under a key within a scope.
+   * @param scope The scope to store the key within
+   * @param key The key to store the value under
+   * @param value The value to store
+   * @returns This collection, so that setting can be chained
+   */
+      set (scope, key, value) {
+        let keyedValues = this.scopes.get(scope)
+        if (typeof keyedValues === 'undefined') {
+          keyedValues = new Map()
+          this.scopes.set(scope, keyedValues)
+        }
+        keyedValues.set(key, value)
+        return this
+      }
+    }
+    exports.ScopedCollection = ScopedCollection
+  }, { 'core-js/modules/esnext.map.delete-all.js': 134, 'core-js/modules/esnext.map.every.js': 135, 'core-js/modules/esnext.map.filter.js': 136, 'core-js/modules/esnext.map.find-key.js': 137, 'core-js/modules/esnext.map.find.js': 138, 'core-js/modules/esnext.map.includes.js': 139, 'core-js/modules/esnext.map.key-of.js': 140, 'core-js/modules/esnext.map.map-keys.js': 141, 'core-js/modules/esnext.map.map-values.js': 142, 'core-js/modules/esnext.map.merge.js': 143, 'core-js/modules/esnext.map.reduce.js': 144, 'core-js/modules/esnext.map.some.js': 145, 'core-js/modules/esnext.map.update.js': 146, 'core-js/modules/esnext.weak-map.delete-all.js': 147 }],
+  13: [function (require, module, exports) {
+    'use strict'
+
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
@@ -1896,10 +1883,7 @@
     const _LinkedList = require('../linked-list/LinkedList')
     const _Linker = require('../linked-list/Linker')
     /**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 2.0.0
- * @memberOf module:collect-your-stuff
+ * stack.
  */
 
     /**
@@ -1910,9 +1894,9 @@
     class Stack {
       /**
    * 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
+   * @param stackedList The list of linkers to start in this stack (the first is the top)
+   * @param listClass The type of list to create when no stacked list is given
+   * @param linkerClass The class used to hold each stacked item
    */
       constructor (stackedList = null, listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) {
         this.linkerClass = linkerClass
@@ -1921,7 +1905,6 @@
 
       /**
    * Check whether the stack has no items.
-   * @return {boolean}
    */
       empty () {
         return this.size() <= 0
@@ -1929,7 +1912,7 @@
 
       /**
    * Look at the item on the top of the stack, without removing it.
-   * @return {*|null} The item, or null when the stack is empty
+   * @returns The item, or null when the stack is empty
    */
       peek () {
         const top = this.stackedList.first
@@ -1938,7 +1921,7 @@
 
       /**
    * Take the item from the top of the stack.
-   * @return {*|null} The item, or null when the stack is empty
+   * @returns The item, or null when the stack is empty
    */
       pop () {
         const top = this.stackedList.first
@@ -1951,8 +1934,8 @@
 
       /**
    * 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
+   * @param data The item to add
+   * @returns This stack, so that adding can be chained
    */
       push (data) {
         // The item is wrapped here rather than left to the list, since the list treats objects that look like a linker's
@@ -1965,7 +1948,6 @@
 
       /**
    * Count the items in the stack.
-   * @return {number}
    */
       size () {
         return this.stackedList.length
@@ -1973,7 +1955,7 @@
 
       /**
    * The item on the top of the stack (the same as peek).
-   * @return {*|null} The item, or null when the stack is empty
+   * @returns The item, or null when the stack is empty
    */
       top () {
         return this.peek()
@@ -1981,7 +1963,6 @@
 
       /**
    * Iterate over the items from the top of the stack to the bottom, without removing them.
-   * @return {Iterator}
    */
       [Symbol.iterator] () {
         const linkers = this.stackedList[Symbol.iterator]()
@@ -2003,10 +1984,9 @@
     }
     /**
  * 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}
+ * @param values The items to stack
+ * @param listClass The type of list used to store the items
+ * @param linkerClass The class used to hold each stacked item
  */
     exports.Stack = Stack
     Stack.fromArray = (values = [], listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) => {
@@ -2014,8 +1994,8 @@
       values.forEach(value => stack.push(value))
       return stack
     }
-  }, { '../linked-list/LinkedList': 5, '../linked-list/Linker': 6, 'core-js/modules/esnext.iterator.constructor.js': 122, 'core-js/modules/esnext.iterator.for-each.js': 123 }],
-  13: [function (require, module, exports) {
+  }, { '../linked-list/LinkedList': 5, '../linked-list/Linker': 6, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 131 }],
+  14: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2030,10 +2010,10 @@
     class Stackable {
       /**
    * 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
+   * @param stackData The settings for the new stackable.
+   * @param stackData.task The data to be stored in this stackable
+   * @param stackData.next The reference to the next stackable if any
+   * @param stackData.ready Indicate if the stackable is ready to run
    */
       constructor ({
         task = null,
@@ -2051,7 +2031,6 @@
 
       /**
    * Retrieve the data which should be formed as a task.
-   * @return {*}
    */
       get task () {
         if (typeof this.data === 'function') {
@@ -2062,7 +2041,6 @@
 
       /**
    * Run the stacked task.
-   * @return {*}
    */
       run () {
         return this.task()
@@ -2070,9 +2048,8 @@
     }
     /**
  * 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}
+ * @param stackable Return a valid Stackable instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsLinker to use.
  */
     exports.Stackable = Stackable
     Stackable.make = (stackable, classType = Stackable) => {
@@ -2096,13 +2073,12 @@
     }
     /**
  * 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}}
+ * @param values Provide an array of data that will be converted to a chain of stackable linkers.
+ * @param classType Provide the type of IsLinker to use.
  */
     Stackable.fromArray = (values = [], classType = Stackable) => _Linker.Linker.fromArray(values, classType)
   }, { '../linked-list/Linker': 6 }],
-  14: [function (require, module, exports) {
+  15: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2112,10 +2088,7 @@
     const _Stackable = require('./Stackable')
     const _LinkedList = require('../linked-list/LinkedList')
     /**
- * @file task stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @memberOf module:collect-your-stuff
+ * task stack.
  */
 
     /**
@@ -2125,9 +2098,9 @@
     class TaskStack {
       /**
    * Instantiate the state with the starter stacked list.
-   * @param {Iterable|LinkedList} [stackedList=null] The list of stackables to start in this stack.
-   * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no stacked list is given.
-   * @param {Stackable} [stackableClass=Stackable] The class used to wrap stacked items.
+   * @param stackedList The list of stackables to start in this stack.
+   * @param listClass The type of list to create when no stacked list is given.
+   * @param stackableClass The class used to wrap stacked items.
    */
       constructor (stackedList = null, listClass = _LinkedList.LinkedList, stackableClass = _Stackable.Stackable) {
         this.listClass = listClass
@@ -2140,7 +2113,6 @@
 
       /**
    * Return true if the stack is empty (there are no tasks in the stacked list)
-   * @return {boolean}
    */
       empty () {
         return this.size() <= 0
@@ -2148,7 +2120,6 @@
 
       /**
    * Take a look at the next stacked task
-   * @return {Stackable}
    */
       top () {
         return this.stackedList.first
@@ -2156,7 +2127,6 @@
 
       /**
    * Remove the next stacked task and return it.
-   * @return {Stackable|null}
    */
       pop () {
         const next = this.remove()
@@ -2172,7 +2142,7 @@
 
       /**
    * Push a stackable task to the top of the stack.
-   * @param {Stackable|*} stackable Add a new stackable to the top of the stack
+   * @param stackable Add a new stackable to the top of the stack
    */
       push (stackable) {
         this.stackedList.prepend(stackable)
@@ -2180,7 +2150,6 @@
 
       /**
    * Remove the next stacked task and return it.
-   * @return {Stackable|null}
    */
       remove () {
         if (this.empty()) {
@@ -2191,7 +2160,6 @@
 
       /**
    * Get the size of the current stack.
-   * @return {number}
    */
       size () {
         return this.stackedList.length
@@ -2199,10 +2167,9 @@
     }
     /**
  * Convert an array to a TaskStack.
- * @param {Array} values An array of values which will be converted to stackables in this queue
- * @param {Stackable} stackableClass The class to use for each stackable
- * @param {TaskStack|Iterable} listClass The class to use to manage the stackables
- * @returns {TaskStack}
+ * @param values An array of values which will be converted to stackables in this queue
+ * @param stackableClass The class to use for each stackable
+ * @param listClass The class to use to manage the stackables
  */
     exports.TaskStack = TaskStack
     TaskStack.fromArray = (values = [], stackableClass = _Stackable.Stackable, listClass = _LinkedList.LinkedList) => {
@@ -2210,8 +2177,8 @@
       list.initialize(stackableClass.fromArray(values, stackableClass).head)
       return new TaskStack(list, listClass, stackableClass)
     }
-  }, { '../linked-list/LinkedList': 5, './Stackable': 13 }],
-  15: [function (require, module, exports) {
+  }, { '../linked-list/LinkedList': 5, './Stackable': 14 }],
+  16: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2271,6 +2238,12 @@
         return _Queueable.Queueable
       }
     })
+    Object.defineProperty(exports, 'ScopedCollection', {
+      enumerable: true,
+      get: function () {
+        return _ScopedCollection.ScopedCollection
+      }
+    })
     Object.defineProperty(exports, 'Stack', {
       enumerable: true,
       get: function () {
@@ -2325,6 +2298,7 @@
     var _Queueable = require('./collections/queue/Queueable')
     var _Queue = require('./collections/queue/Queue')
     var _TaskQueue = require('./collections/queue/TaskQueue')
+    var _ScopedCollection = require('./collections/scoped-collection/ScopedCollection')
     var _Stackable = require('./collections/stack/Stackable')
     var _Stack = require('./collections/stack/Stack')
     var _TaskStack = require('./collections/stack/TaskStack')
@@ -2332,10 +2306,6 @@
     var _services = require('./services/services')
     /**
  * All of the collections available.
- * @file
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @module collect-your-stuff
  */
 
     /**
@@ -2363,6 +2333,7 @@
       Queueable: _Queueable.Queueable,
       Queue: _Queue.Queue,
       TaskQueue: _TaskQueue.TaskQueue,
+      ScopedCollection: _ScopedCollection.ScopedCollection,
       Stackable: _Stackable.Stackable,
       Stack: _Stack.Stack,
       TaskStack: _TaskStack.TaskStack,
@@ -2377,8 +2348,8 @@
       // @ts-ignore
       window.collectYourStuff = collectYourStuff
     }
-  }, { './collections/arrayable/ArrayElement': 1, './collections/arrayable/Arrayable': 2, './collections/doubly-linked-list/DoubleLinker': 3, './collections/doubly-linked-list/DoublyLinkedList': 4, './collections/linked-list/LinkedList': 5, './collections/linked-list/Linker': 6, './collections/linked-tree-list/LinkedTreeList': 7, './collections/linked-tree-list/TreeLinker': 8, './collections/queue/Queue': 9, './collections/queue/Queueable': 10, './collections/queue/TaskQueue': 11, './collections/stack/Stack': 12, './collections/stack/Stackable': 13, './collections/stack/TaskStack': 14, './recipes/recipes': 21, './services/services': 24 }],
-  16: [function (require, module, exports) {
+  }, { './collections/arrayable/ArrayElement': 1, './collections/arrayable/Arrayable': 2, './collections/doubly-linked-list/DoubleLinker': 3, './collections/doubly-linked-list/DoublyLinkedList': 4, './collections/linked-list/LinkedList': 5, './collections/linked-list/Linker': 6, './collections/linked-tree-list/LinkedTreeList': 7, './collections/linked-tree-list/TreeLinker': 8, './collections/queue/Queue': 9, './collections/queue/Queueable': 10, './collections/queue/TaskQueue': 11, './collections/scoped-collection/ScopedCollection': 12, './collections/stack/Stack': 13, './collections/stack/Stackable': 14, './collections/stack/TaskStack': 15, './recipes/recipes': 22, './services/services': 25 }],
+  17: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2391,8 +2362,8 @@
     class ArrayIterator {
       /**
    * Create an iterator over the given array.
-   * @param {Array<IsElement>} innerList The elements to iterate over.
-   * @param {number} [index=0] The position to start from.
+   * @param innerList The elements to iterate over.
+   * @param index The position to start from.
    */
       constructor (innerList, index = 0) {
         this.innerList = innerList
@@ -2401,8 +2372,8 @@
 
       /**
    * Get the next element, moving the iterator forward.
-   * @param {*} [value] Not used, present to match the Iterator interface.
-   * @return {IteratorResult<IsElement>} The next element, or done when there are no more.
+   * @param value Not used, present to match the Iterator interface.
+   * @returns The next element, or done when there are no more.
    */
       next (value) {
         if (this.index < this.innerList.length) {
@@ -2419,7 +2390,7 @@
     }
     exports.ArrayIterator = ArrayIterator
   }, {}],
-  17: [function (require, module, exports) {
+  18: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2432,7 +2403,7 @@
     class DoubleLinkerIterator {
       /**
    * Create an iterator starting at the given item.
-   * @param {IsDoubleLinker} current The item to start from.
+   * @param current The item to start from.
    */
       constructor (current) {
         this.current = current
@@ -2440,8 +2411,8 @@
 
       /**
    * Get the current item and move on to the following one.
-   * @param {*} [value] Not used, present to match the Iterator interface.
-   * @return {IteratorResult<IsDoubleLinker>} The current item, or done when there are no more.
+   * @param value Not used, present to match the Iterator interface.
+   * @returns The current item, or done when there are no more.
    */
       next (value) {
         const result = {
@@ -2454,7 +2425,7 @@
     }
     exports.DoubleLinkerIterator = DoubleLinkerIterator
   }, {}],
-  18: [function (require, module, exports) {
+  19: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2467,7 +2438,7 @@
     class LinkerIterator {
       /**
    * Create an iterator starting at the given item.
-   * @param {IsLinker} current The item to start from.
+   * @param current The item to start from.
    */
       constructor (current) {
         this.current = current
@@ -2475,8 +2446,8 @@
 
       /**
    * Get the current item and move on to the following one.
-   * @param {*} [value] Not used, present to match the Iterator interface.
-   * @return {IteratorResult<IsLinker>} The current item, or done when there are no more.
+   * @param value Not used, present to match the Iterator interface.
+   * @returns The current item, or done when there are no more.
    */
       next (value) {
         const result = {
@@ -2489,7 +2460,7 @@
     }
     exports.LinkerIterator = LinkerIterator
   }, {}],
-  19: [function (require, module, exports) {
+  20: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2497,10 +2468,7 @@
     })
     exports.Runnable = void 0
     /**
- * @file Runnable class recipe.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @memberOf module:collect-your-stuff
+ * Runnable class recipe.
  */
     /**
  * Identify a class that can be run.
@@ -2508,7 +2476,7 @@
     class Runnable {
       /**
    * Instantiate a Runnable class.
-   * @param {*} [data=null] The task (a function) or the data which the task returns.
+   * @param data The task (a function) or the data which the task returns.
    */
       constructor (data = null) {
         /** The task (or data) this runnable holds. */
@@ -2518,7 +2486,6 @@
 
       /**
    * Retrieve the data which should be formed as a task.
-   * @return {Function}
    */
       get task () {
         if (typeof this.data === 'function') {
@@ -2529,7 +2496,6 @@
 
       /**
    * Run the runnable task.
-   * @return {*}
    */
       run () {
         return this.task()
@@ -2538,8 +2504,7 @@
       /**
    * Check if a given thing is Runnable
    * @memberof Runnable
-   * @param {*} thing The value to check, or nothing to check whether this class is Runnable.
-   * @return {boolean}
+   * @param thing The value to check, or nothing to check whether this class is Runnable.
    */
       static isRunnable (thing) {
         if (typeof thing === 'undefined') {
@@ -2560,7 +2525,7 @@
     }
     exports.Runnable = Runnable
   }, {}],
-  20: [function (require, module, exports) {
+  21: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2574,8 +2539,8 @@
     class TreeLinkerIterator {
       /**
    * Create an iterator starting at the given item.
-   * @param {IsTreeNode} current The item to start from.
-   * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within (null for the top of a tree), the whole tree when not given.
+   * @param current The item to start from.
+   * @param boundaryParent The parent of the nodes to stay within (null for the top of a tree), the whole tree when not given.
    */
       constructor (current, boundaryParent) {
         this.current = current
@@ -2584,8 +2549,8 @@
 
       /**
    * Get the current item and move on to the following one (left-first, down each branch).
-   * @param {*} [value] Not used, present to match the Iterator interface.
-   * @return {IteratorResult<IsTreeNode>} The current item, or done when there are no more.
+   * @param value Not used, present to match the Iterator interface.
+   * @returns The current item, or done when there are no more.
    */
       next (value) {
         const result = {
@@ -2597,8 +2562,8 @@
       }
     }
     exports.TreeLinkerIterator = TreeLinkerIterator
-  }, { '../services/parseTreeNext': 23 }],
-  21: [function (require, module, exports) {
+  }, { '../services/parseTreeNext': 24 }],
+  22: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2608,10 +2573,7 @@
     const _ArrayIterator = require('./ArrayIterator')
     const _Runnable = require('./Runnable')
     /**
- * @file sample classes which follow a pattern (have certain members or methods).
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @memberOf module:collect-your-stuff
+ * sample classes which follow a pattern (have certain members or methods).
  */
 
     /**
@@ -2621,8 +2583,8 @@
       ArrayIterator: _ArrayIterator.ArrayIterator,
       Runnable: _Runnable.Runnable
     }
-  }, { './ArrayIterator': 16, './Runnable': 19 }],
-  22: [function (require, module, exports) {
+  }, { './ArrayIterator': 17, './Runnable': 20 }],
+  23: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2632,9 +2594,8 @@
     const _parseTreeNext = require('./parseTreeNext')
     /**
  * Loop over all the nodes in a tree starting from left and apply a callback for each
- * @param {IsArrayable<IsTreeNode>} tree
- * @param {forEachCallback} callback
- * @returns {IsArrayable<IsTreeNode>}
+ * @param tree
+ * @param callback
  */
     const parseTree = (tree, callback) => {
       let index = 0
@@ -2647,8 +2608,8 @@
       return tree
     }
     exports.parseTree = parseTree
-  }, { './parseTreeNext': 23 }],
-  23: [function (require, module, exports) {
+  }, { './parseTreeNext': 24 }],
+  24: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2666,9 +2627,8 @@
  * 7. Stop at root (next is null and parent is null
  * A boundary can be given to parse only part of a tree: going back up to the parents stops at the boundary, so the
  * parsing stays within the nodes whose parent is the boundary (and everything below them).
- * @param {IsTreeNode} treeNode Provide a node in a tree and get the next node (left-first approach)
- * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within, null for the nodes at the top of a tree. When it is not given the whole tree is parsed.
- * @returns {IsTreeNode|null}
+ * @param treeNode Provide a node in a tree and get the next node (left-first approach)
+ * @param boundaryParent The parent of the nodes to stay within, null for the nodes at the top of a tree. When it is not given the whole tree is parsed.
  */
     const parseTreeNext = (treeNode, boundaryParent) => {
       if (!treeNode) {
@@ -2692,7 +2652,7 @@
     }
     exports.parseTreeNext = parseTreeNext
   }, {}],
-  24: [function (require, module, exports) {
+  25: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2702,10 +2662,7 @@
     const _parseTree = require('./parseTree')
     const _parseTreeNext = require('./parseTreeNext')
     /**
- * @file some useful resources when working with collections.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * some useful resources when working with collections.
  */
 
     /**
@@ -2715,8 +2672,8 @@
       parseTree: _parseTree.parseTree,
       parseTreeNext: _parseTreeNext.parseTreeNext
     }
-  }, { './parseTree': 22, './parseTreeNext': 23 }],
-  25: [function (require, module, exports) {
+  }, { './parseTree': 23, './parseTreeNext': 24 }],
+  26: [function (require, module, exports) {
     'use strict'
     const isCallable = require('../internals/is-callable')
     const tryToString = require('../internals/try-to-string')
@@ -2728,8 +2685,28 @@
       if (isCallable(argument)) return argument
       throw new $TypeError(tryToString(argument) + ' is not a function')
     }
-  }, { '../internals/is-callable': 69, '../internals/try-to-string': 112 }],
-  26: [function (require, module, exports) {
+  }, { '../internals/is-callable': 72, '../internals/try-to-string': 119 }],
+  27: [function (require, module, exports) {
+    'use strict'
+    const has = require('../internals/map-helpers').has
+
+    // Perform ? RequireInternalSlot(M, [[MapData]])
+    module.exports = function (it) {
+      has(it)
+      return it
+    }
+  }, { '../internals/map-helpers': 90 }],
+  28: [function (require, module, exports) {
+    'use strict'
+    const has = require('../internals/weak-map-helpers').has
+
+    // Perform ? RequireInternalSlot(M, [[WeakMapData]])
+    module.exports = function (it) {
+      has(it)
+      return it
+    }
+  }, { '../internals/weak-map-helpers': 124 }],
+  29: [function (require, module, exports) {
     'use strict'
     const isPrototypeOf = require('../internals/object-is-prototype-of')
 
@@ -2739,8 +2716,8 @@
       if (isPrototypeOf(Prototype, it)) return it
       throw new $TypeError('Incorrect invocation')
     }
-  }, { '../internals/object-is-prototype-of': 94 }],
-  27: [function (require, module, exports) {
+  }, { '../internals/object-is-prototype-of': 100 }],
+  30: [function (require, module, exports) {
     'use strict'
     const isObject = require('../internals/is-object')
 
@@ -2752,8 +2729,8 @@
       if (isObject(argument)) return argument
       throw new $TypeError($String(argument) + ' is not an object')
     }
-  }, { '../internals/is-object': 72 }],
-  28: [function (require, module, exports) {
+  }, { '../internals/is-object': 75 }],
+  31: [function (require, module, exports) {
     'use strict'
     const toIndexedObject = require('../internals/to-indexed-object')
     const toAbsoluteIndex = require('../internals/to-absolute-index')
@@ -2792,8 +2769,8 @@
       // https://tc39.es/ecma262/#sec-array.prototype.indexof
       indexOf: createMethod(false)
     }
-  }, { '../internals/length-of-array-like': 84, '../internals/to-absolute-index': 105, '../internals/to-indexed-object': 106 }],
-  29: [function (require, module, exports) {
+  }, { '../internals/length-of-array-like': 88, '../internals/to-absolute-index': 112, '../internals/to-indexed-object': 113 }],
+  32: [function (require, module, exports) {
     'use strict'
     const anObject = require('../internals/an-object')
     const iteratorClose = require('../internals/iterator-close')
@@ -2806,8 +2783,8 @@
         iteratorClose(iterator, 'throw', error)
       }
     }
-  }, { '../internals/an-object': 27, '../internals/iterator-close': 78 }],
-  30: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/iterator-close': 82 }],
+  33: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
 
@@ -2817,8 +2794,8 @@
     module.exports = function (it) {
       return stringSlice(toString(it), 8, -1)
     }
-  }, { '../internals/function-uncurry-this': 54 }],
-  31: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 57 }],
+  34: [function (require, module, exports) {
     'use strict'
     const hasOwn = require('../internals/has-own-property')
     const ownKeys = require('../internals/own-keys')
@@ -2836,8 +2813,8 @@
         }
       }
     }
-  }, { '../internals/has-own-property': 61, '../internals/object-define-property': 89, '../internals/object-get-own-property-descriptor': 90, '../internals/own-keys': 99 }],
-  32: [function (require, module, exports) {
+  }, { '../internals/has-own-property': 64, '../internals/object-define-property': 95, '../internals/object-get-own-property-descriptor': 96, '../internals/own-keys': 105 }],
+  35: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
 
@@ -2847,8 +2824,8 @@
       // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
       return Object.getPrototypeOf(new F()) !== F.prototype
     })
-  }, { '../internals/fails': 47 }],
-  33: [function (require, module, exports) {
+  }, { '../internals/fails': 50 }],
+  36: [function (require, module, exports) {
     'use strict'
     // `CreateIterResultObject` abstract operation
     // https://tc39.es/ecma262/#sec-createiterresultobject
@@ -2856,7 +2833,7 @@
       return { value, done }
     }
   }, {}],
-  34: [function (require, module, exports) {
+  37: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const definePropertyModule = require('../internals/object-define-property')
@@ -2870,8 +2847,8 @@
         object[key] = value
         return object
       }
-  }, { '../internals/create-property-descriptor': 35, '../internals/descriptors': 41, '../internals/object-define-property': 89 }],
-  35: [function (require, module, exports) {
+  }, { '../internals/create-property-descriptor': 38, '../internals/descriptors': 44, '../internals/object-define-property': 95 }],
+  38: [function (require, module, exports) {
     'use strict'
     module.exports = function (bitmap, value) {
       return {
@@ -2882,7 +2859,7 @@
       }
     }
   }, {}],
-  36: [function (require, module, exports) {
+  39: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const definePropertyModule = require('../internals/object-define-property')
@@ -2892,8 +2869,8 @@
       if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value))
       else object[key] = value
     }
-  }, { '../internals/create-property-descriptor': 35, '../internals/descriptors': 41, '../internals/object-define-property': 89 }],
-  37: [function (require, module, exports) {
+  }, { '../internals/create-property-descriptor': 38, '../internals/descriptors': 44, '../internals/object-define-property': 95 }],
+  40: [function (require, module, exports) {
     'use strict'
     const makeBuiltIn = require('../internals/make-built-in')
     const defineProperty = require('../internals/object-define-property')
@@ -2903,8 +2880,8 @@
       if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true })
       return defineProperty.f(target, name, descriptor)
     }
-  }, { '../internals/make-built-in': 85, '../internals/object-define-property': 89 }],
-  38: [function (require, module, exports) {
+  }, { '../internals/make-built-in': 89, '../internals/object-define-property': 95 }],
+  41: [function (require, module, exports) {
     'use strict'
     const isCallable = require('../internals/is-callable')
     const definePropertyModule = require('../internals/object-define-property')
@@ -2935,8 +2912,8 @@
         }
       } return O
     }
-  }, { '../internals/define-global-property': 40, '../internals/is-callable': 69, '../internals/make-built-in': 85, '../internals/object-define-property': 89 }],
-  39: [function (require, module, exports) {
+  }, { '../internals/define-global-property': 43, '../internals/is-callable': 72, '../internals/make-built-in': 89, '../internals/object-define-property': 95 }],
+  42: [function (require, module, exports) {
     'use strict'
     const defineBuiltIn = require('../internals/define-built-in')
 
@@ -2944,8 +2921,8 @@
       for (const key in src) defineBuiltIn(target, key, src[key], options)
       return target
     }
-  }, { '../internals/define-built-in': 38 }],
-  40: [function (require, module, exports) {
+  }, { '../internals/define-built-in': 41 }],
+  43: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
 
@@ -2959,8 +2936,8 @@
         globalThis[key] = value
       } return value
     }
-  }, { '../internals/global-this': 60 }],
-  41: [function (require, module, exports) {
+  }, { '../internals/global-this': 63 }],
+  44: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
 
@@ -2969,8 +2946,8 @@
       // eslint-disable-next-line es/no-object-defineproperty -- required for testing
       return Object.defineProperty({}, 1, { get: function () { return 7 } })[1] !== 7
     })
-  }, { '../internals/fails': 47 }],
-  42: [function (require, module, exports) {
+  }, { '../internals/fails': 50 }],
+  45: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const isObject = require('../internals/is-object')
@@ -2982,8 +2959,8 @@
     module.exports = function (it) {
       return EXISTS ? document.createElement(it) : {}
     }
-  }, { '../internals/global-this': 60, '../internals/is-object': 72 }],
-  43: [function (require, module, exports) {
+  }, { '../internals/global-this': 63, '../internals/is-object': 75 }],
+  46: [function (require, module, exports) {
     'use strict'
     // IE8- don't enum bug keys
     module.exports = [
@@ -2996,7 +2973,7 @@
       'valueOf'
     ]
   }, {}],
-  44: [function (require, module, exports) {
+  47: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
 
@@ -3004,8 +2981,8 @@
     const userAgent = navigator && navigator.userAgent
 
     module.exports = userAgent ? String(userAgent) : ''
-  }, { '../internals/global-this': 60 }],
-  45: [function (require, module, exports) {
+  }, { '../internals/global-this': 63 }],
+  48: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const userAgent = require('../internals/environment-user-agent')
@@ -3034,8 +3011,8 @@
     }
 
     module.exports = version
-  }, { '../internals/environment-user-agent': 44, '../internals/global-this': 60 }],
-  46: [function (require, module, exports) {
+  }, { '../internals/environment-user-agent': 47, '../internals/global-this': 63 }],
+  49: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f
@@ -3093,8 +3070,8 @@
         }
       }
     }
-  }, { '../internals/copy-constructor-properties': 31, '../internals/create-non-enumerable-property': 34, '../internals/define-built-in': 38, '../internals/define-global-property': 40, '../internals/global-this': 60, '../internals/is-forced': 70, '../internals/object-get-own-property-descriptor': 90 }],
-  47: [function (require, module, exports) {
+  }, { '../internals/copy-constructor-properties': 34, '../internals/create-non-enumerable-property': 37, '../internals/define-built-in': 41, '../internals/define-global-property': 43, '../internals/global-this': 63, '../internals/is-forced': 73, '../internals/object-get-own-property-descriptor': 96 }],
+  50: [function (require, module, exports) {
     'use strict'
     module.exports = function (exec) {
       try {
@@ -3104,7 +3081,7 @@
       }
     }
   }, {}],
-  48: [function (require, module, exports) {
+  51: [function (require, module, exports) {
     'use strict'
     const NATIVE_BIND = require('../internals/function-bind-native')
 
@@ -3118,8 +3095,8 @@
       : function () {
         return call.apply(apply, arguments)
       })
-  }, { '../internals/function-bind-native': 50 }],
-  49: [function (require, module, exports) {
+  }, { '../internals/function-bind-native': 53 }],
+  52: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this-clause')
     const aCallable = require('../internals/a-callable')
@@ -3134,8 +3111,8 @@
         return fn.apply(that, arguments)
       }
     }
-  }, { '../internals/a-callable': 25, '../internals/function-bind-native': 50, '../internals/function-uncurry-this-clause': 53 }],
-  50: [function (require, module, exports) {
+  }, { '../internals/a-callable': 26, '../internals/function-bind-native': 53, '../internals/function-uncurry-this-clause': 56 }],
+  53: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
 
@@ -3145,8 +3122,8 @@
       // eslint-disable-next-line no-prototype-builtins -- safe
       return typeof test !== 'function' || test.hasOwnProperty('prototype')
     })
-  }, { '../internals/fails': 47 }],
-  51: [function (require, module, exports) {
+  }, { '../internals/fails': 50 }],
+  54: [function (require, module, exports) {
     'use strict'
     const NATIVE_BIND = require('../internals/function-bind-native')
 
@@ -3157,8 +3134,8 @@
       : function () {
         return call.apply(call, arguments)
       }
-  }, { '../internals/function-bind-native': 50 }],
-  52: [function (require, module, exports) {
+  }, { '../internals/function-bind-native': 53 }],
+  55: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const hasOwn = require('../internals/has-own-property')
@@ -3177,8 +3154,8 @@
       PROPER,
       CONFIGURABLE
     }
-  }, { '../internals/descriptors': 41, '../internals/has-own-property': 61 }],
-  53: [function (require, module, exports) {
+  }, { '../internals/descriptors': 44, '../internals/has-own-property': 64 }],
+  56: [function (require, module, exports) {
     'use strict'
     const classofRaw = require('../internals/classof-raw')
     const uncurryThis = require('../internals/function-uncurry-this')
@@ -3189,8 +3166,8 @@
       //   https://github.com/zloirock/core-js/issues/1130
       if (classofRaw(fn) === 'Function') return uncurryThis(fn)
     }
-  }, { '../internals/classof-raw': 30, '../internals/function-uncurry-this': 54 }],
-  54: [function (require, module, exports) {
+  }, { '../internals/classof-raw': 33, '../internals/function-uncurry-this': 57 }],
+  57: [function (require, module, exports) {
     'use strict'
     const NATIVE_BIND = require('../internals/function-bind-native')
 
@@ -3206,8 +3183,8 @@
           return call.apply(fn, arguments)
         }
       }
-  }, { '../internals/function-bind-native': 50 }],
-  55: [function (require, module, exports) {
+  }, { '../internals/function-bind-native': 53 }],
+  58: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const isCallable = require('../internals/is-callable')
@@ -3219,8 +3196,8 @@
     module.exports = function (namespace, method) {
       return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method]
     }
-  }, { '../internals/global-this': 60, '../internals/is-callable': 69 }],
-  56: [function (require, module, exports) {
+  }, { '../internals/global-this': 63, '../internals/is-callable': 72 }],
+  59: [function (require, module, exports) {
     'use strict'
     // `GetIteratorDirect(obj)` abstract operation
     // https://tc39.es/ecma262/#sec-getiteratordirect
@@ -3232,7 +3209,7 @@
       }
     }
   }, {}],
-  57: [function (require, module, exports) {
+  60: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const isCallable = require('../internals/is-callable')
@@ -3247,8 +3224,8 @@
       if (isCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument))
       throw new $TypeError(tryToString(argument) + ' is not iterable')
     }
-  }, { '../internals/an-object': 27, '../internals/function-call': 51, '../internals/get-iterator-method-internal': 58, '../internals/is-callable': 69, '../internals/try-to-string': 112 }],
-  58: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/function-call': 54, '../internals/get-iterator-method-internal': 61, '../internals/is-callable': 72, '../internals/try-to-string': 119 }],
+  61: [function (require, module, exports) {
     'use strict'
     const classof = require('../internals/classof-raw')
     const isNullOrUndefined = require('../internals/is-null-or-undefined')
@@ -3265,8 +3242,8 @@
     (classof(it) === 'Arguments' ? ArrayPrototype[ITERATOR] : undefined)
       }
     }
-  }, { '../internals/classof-raw': 30, '../internals/get-method': 59, '../internals/is-null-or-undefined': 71, '../internals/well-known-symbol': 117 }],
-  59: [function (require, module, exports) {
+  }, { '../internals/classof-raw': 33, '../internals/get-method': 62, '../internals/is-null-or-undefined': 74, '../internals/well-known-symbol': 125 }],
+  62: [function (require, module, exports) {
     'use strict'
     const aCallable = require('../internals/a-callable')
     const isNullOrUndefined = require('../internals/is-null-or-undefined')
@@ -3277,8 +3254,8 @@
       const func = V[P]
       return isNullOrUndefined(func) ? undefined : aCallable(func)
     }
-  }, { '../internals/a-callable': 25, '../internals/is-null-or-undefined': 71 }],
-  60: [function (require, module, exports) {
+  }, { '../internals/a-callable': 26, '../internals/is-null-or-undefined': 74 }],
+  63: [function (require, module, exports) {
     (function (global) {
       (function () {
         'use strict'
@@ -3300,7 +3277,7 @@
       }).call(this)
     }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})
   }, {}],
-  61: [function (require, module, exports) {
+  64: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const toObject = require('../internals/to-object')
@@ -3313,18 +3290,18 @@
     module.exports = Object.hasOwn || function hasOwn (it, key) {
       return hasOwnProperty(toObject(it), key)
     }
-  }, { '../internals/function-uncurry-this': 54, '../internals/to-object': 109 }],
-  62: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 57, '../internals/to-object': 116 }],
+  65: [function (require, module, exports) {
     'use strict'
     module.exports = {}
   }, {}],
-  63: [function (require, module, exports) {
+  66: [function (require, module, exports) {
     'use strict'
     const getBuiltIn = require('../internals/get-built-in')
 
     module.exports = getBuiltIn('document', 'documentElement')
-  }, { '../internals/get-built-in': 55 }],
-  64: [function (require, module, exports) {
+  }, { '../internals/get-built-in': 58 }],
+  67: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const fails = require('../internals/fails')
@@ -3337,8 +3314,8 @@
         get: function () { return 7 }
       }).a !== 7
     })
-  }, { '../internals/descriptors': 41, '../internals/document-create-element': 42, '../internals/fails': 47 }],
-  65: [function (require, module, exports) {
+  }, { '../internals/descriptors': 44, '../internals/document-create-element': 45, '../internals/fails': 50 }],
+  68: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const fails = require('../internals/fails')
@@ -3355,8 +3332,8 @@
     }) ? function (it) {
         return classof(it) === 'String' ? split(it, '') : $Object(it)
       } : $Object
-  }, { '../internals/classof-raw': 30, '../internals/fails': 47, '../internals/function-uncurry-this': 54 }],
-  66: [function (require, module, exports) {
+  }, { '../internals/classof-raw': 33, '../internals/fails': 50, '../internals/function-uncurry-this': 57 }],
+  69: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const isCallable = require('../internals/is-callable')
@@ -3372,8 +3349,8 @@
     }
 
     module.exports = store.inspectSource
-  }, { '../internals/function-uncurry-this': 54, '../internals/is-callable': 69, '../internals/shared-store': 102 }],
-  67: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 57, '../internals/is-callable': 72, '../internals/shared-store': 109 }],
+  70: [function (require, module, exports) {
     'use strict'
     const NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection')
     const globalThis = require('../internals/global-this')
@@ -3445,8 +3422,8 @@
       enforce,
       getterFor
     }
-  }, { '../internals/create-non-enumerable-property': 34, '../internals/global-this': 60, '../internals/has-own-property': 61, '../internals/hidden-keys': 62, '../internals/is-object': 72, '../internals/shared-key': 101, '../internals/shared-store': 102, '../internals/weak-map-basic-detection': 116 }],
-  68: [function (require, module, exports) {
+  }, { '../internals/create-non-enumerable-property': 37, '../internals/global-this': 63, '../internals/has-own-property': 64, '../internals/hidden-keys': 65, '../internals/is-object': 75, '../internals/shared-key': 108, '../internals/shared-store': 109, '../internals/weak-map-basic-detection': 123 }],
+  71: [function (require, module, exports) {
     'use strict'
     const wellKnownSymbol = require('../internals/well-known-symbol')
     const Iterators = require('../internals/iterators')
@@ -3458,8 +3435,8 @@
     module.exports = function (it) {
       return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it)
     }
-  }, { '../internals/iterators': 83, '../internals/well-known-symbol': 117 }],
-  69: [function (require, module, exports) {
+  }, { '../internals/iterators': 87, '../internals/well-known-symbol': 125 }],
+  72: [function (require, module, exports) {
     'use strict'
     // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
     const documentAll = typeof document === 'object' && document.all
@@ -3475,7 +3452,7 @@
         return typeof argument === 'function'
       }
   }, {}],
-  70: [function (require, module, exports) {
+  73: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
     const isCallable = require('../internals/is-callable')
@@ -3502,8 +3479,8 @@
     var POLYFILL = isForced.POLYFILL = 'P'
 
     module.exports = isForced
-  }, { '../internals/fails': 47, '../internals/is-callable': 69 }],
-  71: [function (require, module, exports) {
+  }, { '../internals/fails': 50, '../internals/is-callable': 72 }],
+  74: [function (require, module, exports) {
     'use strict'
     // we can't use just `it == null` since of `document.all` special case
     // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
@@ -3511,19 +3488,19 @@
       return it === null || it === undefined
     }
   }, {}],
-  72: [function (require, module, exports) {
+  75: [function (require, module, exports) {
     'use strict'
     const isCallable = require('../internals/is-callable')
 
     module.exports = function (it) {
       return typeof it === 'object' ? it !== null : isCallable(it)
     }
-  }, { '../internals/is-callable': 69 }],
-  73: [function (require, module, exports) {
+  }, { '../internals/is-callable': 72 }],
+  76: [function (require, module, exports) {
     'use strict'
     module.exports = false
   }, {}],
-  74: [function (require, module, exports) {
+  77: [function (require, module, exports) {
     'use strict'
     const getBuiltIn = require('../internals/get-built-in')
     const isCallable = require('../internals/is-callable')
@@ -3540,8 +3517,22 @@
         const $Symbol = getBuiltIn('Symbol')
         return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it))
       }
-  }, { '../internals/get-built-in': 55, '../internals/is-callable': 69, '../internals/object-is-prototype-of': 94, '../internals/use-symbol-as-uid': 114 }],
-  75: [function (require, module, exports) {
+  }, { '../internals/get-built-in': 58, '../internals/is-callable': 72, '../internals/object-is-prototype-of': 100, '../internals/use-symbol-as-uid': 121 }],
+  78: [function (require, module, exports) {
+    'use strict'
+    const call = require('../internals/function-call')
+
+    module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
+      const iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator
+      const next = record.next
+      let step, result
+      while (!(step = call(next, iterator)).done) {
+        result = fn(step.value)
+        if (result !== undefined) return result
+      }
+    }
+  }, { '../internals/function-call': 54 }],
+  79: [function (require, module, exports) {
     'use strict'
     const bind = require('../internals/function-bind-context')
     const call = require('../internals/function-call')
@@ -3616,8 +3607,8 @@
         if (typeof result === 'object' && result && isPrototypeOf(ResultPrototype, result)) return result
       } return new Result(false)
     }
-  }, { '../internals/an-object': 27, '../internals/function-bind-context': 49, '../internals/function-call': 51, '../internals/get-iterator-internal': 57, '../internals/get-iterator-method-internal': 58, '../internals/is-array-iterator-method': 68, '../internals/iterator-close': 78, '../internals/length-of-array-like': 84, '../internals/object-is-prototype-of': 94, '../internals/try-to-string': 112 }],
-  76: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/function-bind-context': 52, '../internals/function-call': 54, '../internals/get-iterator-internal': 60, '../internals/get-iterator-method-internal': 61, '../internals/is-array-iterator-method': 71, '../internals/iterator-close': 82, '../internals/length-of-array-like': 88, '../internals/object-is-prototype-of': 100, '../internals/try-to-string': 119 }],
+  80: [function (require, module, exports) {
     'use strict'
     // release references held by exhausted / closed iterator helpers to allow GC of the source chain
     module.exports = function (state) {
@@ -3625,7 +3616,7 @@
     state.iterables = state.iters = state.openIters = state.padding = state.finishResults = state.buffer = null
     }
   }, {}],
-  77: [function (require, module, exports) {
+  81: [function (require, module, exports) {
     'use strict'
     const iteratorClose = require('../internals/iterator-close')
 
@@ -3642,8 +3633,8 @@
       if (kind === 'throw') throw value
       return value
     }
-  }, { '../internals/iterator-close': 78 }],
-  78: [function (require, module, exports) {
+  }, { '../internals/iterator-close': 82 }],
+  82: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const anObject = require('../internals/an-object')
@@ -3668,8 +3659,8 @@
       anObject(innerResult)
       return value
     }
-  }, { '../internals/an-object': 27, '../internals/function-call': 51, '../internals/get-method': 59 }],
-  79: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/function-call': 54, '../internals/get-method': 62 }],
+  83: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const create = require('../internals/object-create')
@@ -3769,8 +3760,8 @@
 
       return IteratorProxy
     }
-  }, { '../internals/create-iter-result-object': 33, '../internals/create-non-enumerable-property': 34, '../internals/define-built-ins': 39, '../internals/function-call': 51, '../internals/get-method': 59, '../internals/internal-state': 67, '../internals/iterator-cleanup-state': 76, '../internals/iterator-close': 78, '../internals/iterator-close-all': 77, '../internals/iterators-core': 82, '../internals/object-create': 87, '../internals/well-known-symbol': 117 }],
-  80: [function (require, module, exports) {
+  }, { '../internals/create-iter-result-object': 36, '../internals/create-non-enumerable-property': 37, '../internals/define-built-ins': 42, '../internals/function-call': 54, '../internals/get-method': 62, '../internals/internal-state': 70, '../internals/iterator-cleanup-state': 80, '../internals/iterator-close': 82, '../internals/iterator-close-all': 81, '../internals/iterators-core': 86, '../internals/object-create': 93, '../internals/well-known-symbol': 125 }],
+  84: [function (require, module, exports) {
     'use strict'
     // Should throw an error on invalid iterator
     // https://issues.chromium.org/issues/336839115
@@ -3786,7 +3777,7 @@
       }
     }
   }, {}],
-  81: [function (require, module, exports) {
+  85: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
 
@@ -3812,8 +3803,8 @@
 
       if (!CLOSED) return method
     }
-  }, { '../internals/global-this': 60 }],
-  82: [function (require, module, exports) {
+  }, { '../internals/global-this': 63 }],
+  86: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
     const isCallable = require('../internals/is-callable')
@@ -3863,12 +3854,12 @@
       IteratorPrototype,
       BUGGY_SAFARI_ITERATORS
     }
-  }, { '../internals/define-built-in': 38, '../internals/fails': 47, '../internals/is-callable': 69, '../internals/is-object': 72, '../internals/is-pure': 73, '../internals/object-create': 87, '../internals/object-get-prototype-of': 93, '../internals/well-known-symbol': 117 }],
-  83: [function (require, module, exports) {
+  }, { '../internals/define-built-in': 41, '../internals/fails': 50, '../internals/is-callable': 72, '../internals/is-object': 75, '../internals/is-pure': 76, '../internals/object-create': 93, '../internals/object-get-prototype-of': 99, '../internals/well-known-symbol': 125 }],
+  87: [function (require, module, exports) {
     'use strict'
     module.exports = Object.create ? Object.create(null) : {}
   }, {}],
-  84: [function (require, module, exports) {
+  88: [function (require, module, exports) {
     'use strict'
     const toLength = require('../internals/to-length')
 
@@ -3877,8 +3868,8 @@
     module.exports = function (obj) {
       return toLength(obj.length)
     }
-  }, { '../internals/to-length': 108 }],
-  85: [function (require, module, exports) {
+  }, { '../internals/to-length': 115 }],
+  89: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const fails = require('../internals/fails')
@@ -3934,8 +3925,45 @@
     Function.prototype.toString = makeBuiltIn(function toString () {
       return isCallable(this) && getInternalState(this).source || inspectSource(this)
     }, 'toString')
-  }, { '../internals/descriptors': 41, '../internals/fails': 47, '../internals/function-name': 52, '../internals/function-uncurry-this': 54, '../internals/has-own-property': 61, '../internals/inspect-source': 66, '../internals/internal-state': 67, '../internals/is-callable': 69 }],
-  86: [function (require, module, exports) {
+  }, { '../internals/descriptors': 44, '../internals/fails': 50, '../internals/function-name': 55, '../internals/function-uncurry-this': 57, '../internals/has-own-property': 64, '../internals/inspect-source': 69, '../internals/internal-state': 70, '../internals/is-callable': 72 }],
+  90: [function (require, module, exports) {
+    'use strict'
+    const uncurryThis = require('../internals/function-uncurry-this')
+
+    // eslint-disable-next-line es/no-map -- safe
+    const MapPrototype = Map.prototype
+
+    module.exports = {
+      // eslint-disable-next-line es/no-map -- safe
+      Map,
+      set: uncurryThis(MapPrototype.set),
+      get: uncurryThis(MapPrototype.get),
+      has: uncurryThis(MapPrototype.has),
+      remove: uncurryThis(MapPrototype.delete),
+      proto: MapPrototype
+    }
+  }, { '../internals/function-uncurry-this': 57 }],
+  91: [function (require, module, exports) {
+    'use strict'
+    const uncurryThis = require('../internals/function-uncurry-this')
+    const iterateSimple = require('../internals/iterate-simple')
+    const MapHelpers = require('../internals/map-helpers')
+
+    const Map = MapHelpers.Map
+    const MapPrototype = MapHelpers.proto
+    const forEach = uncurryThis(MapPrototype.forEach)
+    const entries = uncurryThis(MapPrototype.entries)
+    const next = entries(new Map()).next
+
+    module.exports = function (map, fn, interruptible) {
+      return interruptible
+        ? iterateSimple({ iterator: entries(map), next }, function (entry) {
+          return fn(entry[1], entry[0])
+        })
+        : forEach(map, fn)
+    }
+  }, { '../internals/function-uncurry-this': 57, '../internals/iterate-simple': 78, '../internals/map-helpers': 90 }],
+  92: [function (require, module, exports) {
     'use strict'
     const ceil = Math.ceil
     const floor = Math.floor
@@ -3948,7 +3976,7 @@
       return (n > 0 ? floor : ceil)(n)
     }
   }, {}],
-  87: [function (require, module, exports) {
+  93: [function (require, module, exports) {
     'use strict'
     /* global ActiveXObject -- old IE, WSH */
     const anObject = require('../internals/an-object')
@@ -4034,8 +4062,8 @@
       } else result = NullProtoObject()
       return Properties === undefined ? result : definePropertiesModule.f(result, Properties)
     }
-  }, { '../internals/an-object': 27, '../internals/document-create-element': 42, '../internals/enum-bug-keys': 43, '../internals/hidden-keys': 62, '../internals/html': 63, '../internals/object-define-properties': 88, '../internals/shared-key': 101 }],
-  88: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/document-create-element': 45, '../internals/enum-bug-keys': 46, '../internals/hidden-keys': 65, '../internals/html': 66, '../internals/object-define-properties': 94, '../internals/shared-key': 108 }],
+  94: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug')
@@ -4059,8 +4087,8 @@
         while (length > index) definePropertyModule.f(O, key = keys[index++], props[key])
         return O
       }
-  }, { '../internals/an-object': 27, '../internals/descriptors': 41, '../internals/object-define-property': 89, '../internals/object-keys': 96, '../internals/to-indexed-object': 106, '../internals/v8-prototype-define-bug': 115 }],
-  89: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/descriptors': 44, '../internals/object-define-property': 95, '../internals/object-keys': 102, '../internals/to-indexed-object': 113, '../internals/v8-prototype-define-bug': 122 }],
+  95: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const IE8_DOM_DEFINE = require('../internals/ie8-dom-define')
@@ -4109,8 +4137,8 @@
       if ('value' in Attributes) O[P] = Attributes.value
       return O
     }
-  }, { '../internals/an-object': 27, '../internals/descriptors': 41, '../internals/ie8-dom-define': 64, '../internals/to-property-key': 111, '../internals/v8-prototype-define-bug': 115 }],
-  90: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/descriptors': 44, '../internals/ie8-dom-define': 67, '../internals/to-property-key': 118, '../internals/v8-prototype-define-bug': 122 }],
+  96: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const call = require('../internals/function-call')
@@ -4136,8 +4164,8 @@
       }
       if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P])
     }
-  }, { '../internals/create-property-descriptor': 35, '../internals/descriptors': 41, '../internals/function-call': 51, '../internals/has-own-property': 61, '../internals/ie8-dom-define': 64, '../internals/object-property-is-enumerable': 97, '../internals/to-indexed-object': 106, '../internals/to-property-key': 111 }],
-  91: [function (require, module, exports) {
+  }, { '../internals/create-property-descriptor': 38, '../internals/descriptors': 44, '../internals/function-call': 54, '../internals/has-own-property': 64, '../internals/ie8-dom-define': 67, '../internals/object-property-is-enumerable': 103, '../internals/to-indexed-object': 113, '../internals/to-property-key': 118 }],
+  97: [function (require, module, exports) {
     'use strict'
     const internalObjectKeys = require('../internals/object-keys-internal')
     const enumBugKeys = require('../internals/enum-bug-keys')
@@ -4150,13 +4178,13 @@
     exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames (O) {
       return internalObjectKeys(O, hiddenKeys)
     }
-  }, { '../internals/enum-bug-keys': 43, '../internals/object-keys-internal': 95 }],
-  92: [function (require, module, exports) {
+  }, { '../internals/enum-bug-keys': 46, '../internals/object-keys-internal': 101 }],
+  98: [function (require, module, exports) {
     'use strict'
     // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
     exports.f = Object.getOwnPropertySymbols
   }, {}],
-  93: [function (require, module, exports) {
+  99: [function (require, module, exports) {
     'use strict'
     const hasOwn = require('../internals/has-own-property')
     const isCallable = require('../internals/is-callable')
@@ -4181,14 +4209,14 @@
           return constructor.prototype
         } return object instanceof $Object ? ObjectPrototype : null
       }
-  }, { '../internals/correct-prototype-getter': 32, '../internals/has-own-property': 61, '../internals/is-callable': 69, '../internals/shared-key': 101, '../internals/to-object': 109 }],
-  94: [function (require, module, exports) {
+  }, { '../internals/correct-prototype-getter': 35, '../internals/has-own-property': 64, '../internals/is-callable': 72, '../internals/shared-key': 108, '../internals/to-object': 116 }],
+  100: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
 
     module.exports = uncurryThis({}.isPrototypeOf)
-  }, { '../internals/function-uncurry-this': 54 }],
-  95: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 57 }],
+  101: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const hasOwn = require('../internals/has-own-property')
@@ -4212,8 +4240,8 @@
       }
       return result
     }
-  }, { '../internals/array-includes': 28, '../internals/function-uncurry-this': 54, '../internals/has-own-property': 61, '../internals/hidden-keys': 62, '../internals/to-indexed-object': 106 }],
-  96: [function (require, module, exports) {
+  }, { '../internals/array-includes': 31, '../internals/function-uncurry-this': 57, '../internals/has-own-property': 64, '../internals/hidden-keys': 65, '../internals/to-indexed-object': 113 }],
+  102: [function (require, module, exports) {
     'use strict'
     const internalObjectKeys = require('../internals/object-keys-internal')
     const enumBugKeys = require('../internals/enum-bug-keys')
@@ -4224,8 +4252,8 @@
     module.exports = Object.keys || function keys (O) {
       return internalObjectKeys(O, enumBugKeys)
     }
-  }, { '../internals/enum-bug-keys': 43, '../internals/object-keys-internal': 95 }],
-  97: [function (require, module, exports) {
+  }, { '../internals/enum-bug-keys': 46, '../internals/object-keys-internal': 101 }],
+  103: [function (require, module, exports) {
     'use strict'
     const $propertyIsEnumerable = {}.propertyIsEnumerable
     // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -4243,7 +4271,7 @@
       }
       : $propertyIsEnumerable
   }, {}],
-  98: [function (require, module, exports) {
+  104: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const isCallable = require('../internals/is-callable')
@@ -4260,8 +4288,8 @@
       if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val
       throw new $TypeError("Can't convert object to primitive value")
     }
-  }, { '../internals/function-call': 51, '../internals/is-callable': 69, '../internals/is-object': 72 }],
-  99: [function (require, module, exports) {
+  }, { '../internals/function-call': 54, '../internals/is-callable': 72, '../internals/is-object': 75 }],
+  105: [function (require, module, exports) {
     'use strict'
     const getBuiltIn = require('../internals/get-built-in')
     const uncurryThis = require('../internals/function-uncurry-this')
@@ -4277,8 +4305,8 @@
       const getOwnPropertySymbols = getOwnPropertySymbolsModule.f
       return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys
     }
-  }, { '../internals/an-object': 27, '../internals/function-uncurry-this': 54, '../internals/get-built-in': 55, '../internals/object-get-own-property-names': 91, '../internals/object-get-own-property-symbols': 92 }],
-  100: [function (require, module, exports) {
+  }, { '../internals/an-object': 30, '../internals/function-uncurry-this': 57, '../internals/get-built-in': 58, '../internals/object-get-own-property-names': 97, '../internals/object-get-own-property-symbols': 98 }],
+  106: [function (require, module, exports) {
     'use strict'
     const isNullOrUndefined = require('../internals/is-null-or-undefined')
 
@@ -4290,8 +4318,17 @@
       if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it)
       return it
     }
-  }, { '../internals/is-null-or-undefined': 71 }],
-  101: [function (require, module, exports) {
+  }, { '../internals/is-null-or-undefined': 74 }],
+  107: [function (require, module, exports) {
+    'use strict'
+    // `SameValueZero` abstract operation
+    // https://tc39.es/ecma262/#sec-samevaluezero
+    module.exports = function (x, y) {
+      // eslint-disable-next-line no-self-compare -- NaN check
+      return x === y || x !== x && y !== y
+    }
+  }, {}],
+  108: [function (require, module, exports) {
     'use strict'
     const shared = require('../internals/shared')
     const uid = require('../internals/uid')
@@ -4301,8 +4338,8 @@
     module.exports = function (key) {
       return keys[key] || (keys[key] = uid(key))
     }
-  }, { '../internals/shared': 103, '../internals/uid': 113 }],
-  102: [function (require, module, exports) {
+  }, { '../internals/shared': 110, '../internals/uid': 120 }],
+  109: [function (require, module, exports) {
     'use strict'
     const IS_PURE = require('../internals/is-pure')
     const globalThis = require('../internals/global-this')
@@ -4318,8 +4355,8 @@
       license: 'https://github.com/zloirock/core-js/blob/v3.50.0/LICENSE',
       source: 'https://github.com/zloirock/core-js'
     })
-  }, { '../internals/define-global-property': 40, '../internals/global-this': 60, '../internals/is-pure': 73 }],
-  103: [function (require, module, exports) {
+  }, { '../internals/define-global-property': 43, '../internals/global-this': 63, '../internals/is-pure': 76 }],
+  110: [function (require, module, exports) {
     'use strict'
     const store = require('../internals/shared-store')
     // eslint-disable-next-line es/no-object-create -- safe
@@ -4328,8 +4365,8 @@
     module.exports = function (key, value) {
       return store[key] || (store[key] = value || create(null))
     }
-  }, { '../internals/shared-store': 102 }],
-  104: [function (require, module, exports) {
+  }, { '../internals/shared-store': 109 }],
+  111: [function (require, module, exports) {
     'use strict'
     /* eslint-disable es/no-symbol -- required for testing */
     const V8_VERSION = require('../internals/environment-v8-version')
@@ -4349,8 +4386,8 @@
     // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
     !Symbol.sham && V8_VERSION && V8_VERSION < 41
     })
-  }, { '../internals/environment-v8-version': 45, '../internals/fails': 47, '../internals/global-this': 60 }],
-  105: [function (require, module, exports) {
+  }, { '../internals/environment-v8-version': 48, '../internals/fails': 50, '../internals/global-this': 63 }],
+  112: [function (require, module, exports) {
     'use strict'
     const toIntegerOrInfinity = require('../internals/to-integer-or-infinity')
 
@@ -4364,8 +4401,8 @@
       const integer = toIntegerOrInfinity(index)
       return integer < 0 ? max(integer + length, 0) : min(integer, length)
     }
-  }, { '../internals/to-integer-or-infinity': 107 }],
-  106: [function (require, module, exports) {
+  }, { '../internals/to-integer-or-infinity': 114 }],
+  113: [function (require, module, exports) {
     'use strict'
     // toObject with fallback for non-array-like ES3 strings
     const IndexedObject = require('../internals/indexed-object')
@@ -4374,8 +4411,8 @@
     module.exports = function (it) {
       return IndexedObject(requireObjectCoercible(it))
     }
-  }, { '../internals/indexed-object': 65, '../internals/require-object-coercible': 100 }],
-  107: [function (require, module, exports) {
+  }, { '../internals/indexed-object': 68, '../internals/require-object-coercible': 106 }],
+  114: [function (require, module, exports) {
     'use strict'
     const trunc = require('../internals/math-trunc')
 
@@ -4386,8 +4423,8 @@
       // eslint-disable-next-line no-self-compare -- NaN check
       return number !== number || number === 0 ? 0 : trunc(number)
     }
-  }, { '../internals/math-trunc': 86 }],
-  108: [function (require, module, exports) {
+  }, { '../internals/math-trunc': 92 }],
+  115: [function (require, module, exports) {
     'use strict'
     const toIntegerOrInfinity = require('../internals/to-integer-or-infinity')
 
@@ -4399,8 +4436,8 @@
       const len = toIntegerOrInfinity(argument)
       return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0 // 2 ** 53 - 1 == 9007199254740991
     }
-  }, { '../internals/to-integer-or-infinity': 107 }],
-  109: [function (require, module, exports) {
+  }, { '../internals/to-integer-or-infinity': 114 }],
+  116: [function (require, module, exports) {
     'use strict'
     const requireObjectCoercible = require('../internals/require-object-coercible')
 
@@ -4411,8 +4448,8 @@
     module.exports = function (argument) {
       return $Object(requireObjectCoercible(argument))
     }
-  }, { '../internals/require-object-coercible': 100 }],
-  110: [function (require, module, exports) {
+  }, { '../internals/require-object-coercible': 106 }],
+  117: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const isObject = require('../internals/is-object')
@@ -4439,8 +4476,8 @@
       if (pref === undefined) pref = 'number'
       return ordinaryToPrimitive(input, pref)
     }
-  }, { '../internals/function-call': 51, '../internals/get-method': 59, '../internals/is-object': 72, '../internals/is-symbol': 74, '../internals/ordinary-to-primitive': 98, '../internals/well-known-symbol': 117 }],
-  111: [function (require, module, exports) {
+  }, { '../internals/function-call': 54, '../internals/get-method': 62, '../internals/is-object': 75, '../internals/is-symbol': 77, '../internals/ordinary-to-primitive': 104, '../internals/well-known-symbol': 125 }],
+  118: [function (require, module, exports) {
     'use strict'
     const toPrimitive = require('../internals/to-primitive')
     const isSymbol = require('../internals/is-symbol')
@@ -4451,8 +4488,8 @@
       const key = toPrimitive(argument, 'string')
       return isSymbol(key) ? key : key + ''
     }
-  }, { '../internals/is-symbol': 74, '../internals/to-primitive': 110 }],
-  112: [function (require, module, exports) {
+  }, { '../internals/is-symbol': 77, '../internals/to-primitive': 117 }],
+  119: [function (require, module, exports) {
     'use strict'
     const $String = String
 
@@ -4464,7 +4501,7 @@
       }
     }
   }, {}],
-  113: [function (require, module, exports) {
+  120: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
 
@@ -4475,8 +4512,8 @@
     module.exports = function (key) {
       return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36)
     }
-  }, { '../internals/function-uncurry-this': 54 }],
-  114: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 57 }],
+  121: [function (require, module, exports) {
     'use strict'
     /* eslint-disable es/no-symbol -- required for testing */
     const NATIVE_SYMBOL = require('../internals/symbol-constructor-detection')
@@ -4484,8 +4521,8 @@
     module.exports = NATIVE_SYMBOL &&
   !Symbol.sham &&
   typeof Symbol.iterator === 'symbol'
-  }, { '../internals/symbol-constructor-detection': 104 }],
-  115: [function (require, module, exports) {
+  }, { '../internals/symbol-constructor-detection': 111 }],
+  122: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const fails = require('../internals/fails')
@@ -4499,8 +4536,8 @@
         writable: false
       }).prototype !== 42
     })
-  }, { '../internals/descriptors': 41, '../internals/fails': 47 }],
-  116: [function (require, module, exports) {
+  }, { '../internals/descriptors': 44, '../internals/fails': 50 }],
+  123: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const isCallable = require('../internals/is-callable')
@@ -4508,8 +4545,24 @@
     const WeakMap = globalThis.WeakMap
 
     module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap))
-  }, { '../internals/global-this': 60, '../internals/is-callable': 69 }],
-  117: [function (require, module, exports) {
+  }, { '../internals/global-this': 63, '../internals/is-callable': 72 }],
+  124: [function (require, module, exports) {
+    'use strict'
+    const uncurryThis = require('../internals/function-uncurry-this')
+
+    // eslint-disable-next-line es/no-weak-map -- safe
+    const WeakMapPrototype = WeakMap.prototype
+
+    module.exports = {
+      // eslint-disable-next-line es/no-weak-map -- safe
+      WeakMap,
+      set: uncurryThis(WeakMapPrototype.set),
+      get: uncurryThis(WeakMapPrototype.get),
+      has: uncurryThis(WeakMapPrototype.has),
+      remove: uncurryThis(WeakMapPrototype.delete)
+    }
+  }, { '../internals/function-uncurry-this': 57 }],
+  125: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const shared = require('../internals/shared')
@@ -4529,8 +4582,8 @@
           : createWellKnownSymbol('Symbol.' + name)
       } return WellKnownSymbolsStore[name]
     }
-  }, { '../internals/global-this': 60, '../internals/has-own-property': 61, '../internals/shared': 103, '../internals/symbol-constructor-detection': 104, '../internals/uid': 113, '../internals/use-symbol-as-uid': 114 }],
-  118: [function (require, module, exports) {
+  }, { '../internals/global-this': 63, '../internals/has-own-property': 64, '../internals/shared': 110, '../internals/symbol-constructor-detection': 111, '../internals/uid': 120, '../internals/use-symbol-as-uid': 121 }],
+  126: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const globalThis = require('../internals/global-this')
@@ -4596,8 +4649,8 @@
     $({ global: true, constructor: true, forced: FORCED }, {
       Iterator: IteratorConstructor
     })
-  }, { '../internals/an-instance': 26, '../internals/an-object': 27, '../internals/create-property': 36, '../internals/define-built-in-accessor': 37, '../internals/descriptors': 41, '../internals/export': 46, '../internals/fails': 47, '../internals/global-this': 60, '../internals/has-own-property': 61, '../internals/is-callable': 69, '../internals/is-pure': 73, '../internals/iterators-core': 82, '../internals/object-get-prototype-of': 93, '../internals/well-known-symbol': 117 }],
-  119: [function (require, module, exports) {
+  }, { '../internals/an-instance': 29, '../internals/an-object': 30, '../internals/create-property': 39, '../internals/define-built-in-accessor': 40, '../internals/descriptors': 44, '../internals/export': 49, '../internals/fails': 50, '../internals/global-this': 63, '../internals/has-own-property': 64, '../internals/is-callable': 72, '../internals/is-pure': 76, '../internals/iterators-core': 86, '../internals/object-get-prototype-of': 99, '../internals/well-known-symbol': 125 }],
+  127: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -4630,8 +4683,8 @@
         }, { IS_RECORD: true })
       }
     })
-  }, { '../internals/a-callable': 25, '../internals/an-object': 27, '../internals/export': 46, '../internals/function-call': 51, '../internals/get-iterator-direct': 56, '../internals/iterate': 75, '../internals/iterator-close': 78, '../internals/iterator-helper-without-closing-on-early-error': 81 }],
-  120: [function (require, module, exports) {
+  }, { '../internals/a-callable': 26, '../internals/an-object': 30, '../internals/export': 49, '../internals/function-call': 54, '../internals/get-iterator-direct': 59, '../internals/iterate': 79, '../internals/iterator-close': 82, '../internals/iterator-helper-without-closing-on-early-error': 85 }],
+  128: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -4676,8 +4729,8 @@
         })
       }
     })
-  }, { '../internals/a-callable': 25, '../internals/an-object': 27, '../internals/call-with-safe-iteration-closing': 29, '../internals/export': 46, '../internals/function-call': 51, '../internals/get-iterator-direct': 56, '../internals/is-pure': 73, '../internals/iterator-close': 78, '../internals/iterator-create-proxy': 79, '../internals/iterator-helper-throws-on-invalid-iterator': 80, '../internals/iterator-helper-without-closing-on-early-error': 81 }],
-  121: [function (require, module, exports) {
+  }, { '../internals/a-callable': 26, '../internals/an-object': 30, '../internals/call-with-safe-iteration-closing': 32, '../internals/export': 49, '../internals/function-call': 54, '../internals/get-iterator-direct': 59, '../internals/is-pure': 76, '../internals/iterator-close': 82, '../internals/iterator-create-proxy': 83, '../internals/iterator-helper-throws-on-invalid-iterator': 84, '../internals/iterator-helper-without-closing-on-early-error': 85 }],
+  129: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const iterate = require('../internals/iterate')
@@ -4730,25 +4783,335 @@
         return accumulator
       }
     })
-  }, { '../internals/a-callable': 25, '../internals/an-object': 27, '../internals/export': 46, '../internals/fails': 47, '../internals/function-apply': 48, '../internals/get-iterator-direct': 56, '../internals/iterate': 75, '../internals/iterator-close': 78, '../internals/iterator-helper-without-closing-on-early-error': 81 }],
-  122: [function (require, module, exports) {
+  }, { '../internals/a-callable': 26, '../internals/an-object': 30, '../internals/export': 49, '../internals/fails': 50, '../internals/function-apply': 51, '../internals/get-iterator-direct': 59, '../internals/iterate': 79, '../internals/iterator-close': 82, '../internals/iterator-helper-without-closing-on-early-error': 85 }],
+  130: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.constructor')
-  }, { '../modules/es.iterator.constructor': 118 }],
-  123: [function (require, module, exports) {
+  }, { '../modules/es.iterator.constructor': 126 }],
+  131: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.for-each')
-  }, { '../modules/es.iterator.for-each': 119 }],
-  124: [function (require, module, exports) {
+  }, { '../modules/es.iterator.for-each': 127 }],
+  132: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.map')
-  }, { '../modules/es.iterator.map': 120 }],
-  125: [function (require, module, exports) {
+  }, { '../modules/es.iterator.map': 128 }],
+  133: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.reduce')
-  }, { '../modules/es.iterator.reduce': 121 }]
-}, {}, [15])
+  }, { '../modules/es.iterator.reduce': 129 }],
+  134: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const aMap = require('../internals/a-map')
+    const remove = require('../internals/map-helpers').remove
+
+    // `Map.prototype.deleteAll` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      deleteAll: function deleteAll (/* ...elements */) {
+        const collection = aMap(this)
+        let allDeleted = true
+        let wasDeleted
+        for (let k = 0, len = arguments.length; k < len; k++) {
+          wasDeleted = remove(collection, arguments[k])
+          allDeleted = allDeleted && wasDeleted
+        } return !!allDeleted
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/map-helpers': 90 }],
+  135: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    // `Map.prototype.every` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      every: function every (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        return iterate(map, function (value, key) {
+          if (!boundFunction(value, key, map)) return false
+        }, true) !== false
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-iterate': 91 }],
+  136: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const MapHelpers = require('../internals/map-helpers')
+    const iterate = require('../internals/map-iterate')
+
+    const Map = MapHelpers.Map
+    const set = MapHelpers.set
+
+    // `Map.prototype.filter` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      filter: function filter (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        const newMap = new Map()
+        iterate(map, function (value, key) {
+          if (boundFunction(value, key, map)) set(newMap, key, value)
+        })
+        return newMap
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-helpers': 90, '../internals/map-iterate': 91 }],
+  137: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    // `Map.prototype.findKey` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      findKey: function findKey (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        const result = iterate(map, function (value, key) {
+          if (boundFunction(value, key, map)) return { key }
+        }, true)
+        return result && result.key
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-iterate': 91 }],
+  138: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    // `Map.prototype.find` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      find: function find (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        const result = iterate(map, function (value, key) {
+          if (boundFunction(value, key, map)) return { value }
+        }, true)
+        return result && result.value
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-iterate': 91 }],
+  139: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const sameValueZero = require('../internals/same-value-zero')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    // `Map.prototype.includes` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      includes: function includes (searchElement) {
+        return iterate(aMap(this), function (value) {
+          if (sameValueZero(value, searchElement)) return true
+        }, true) === true
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/map-iterate': 91, '../internals/same-value-zero': 107 }],
+  140: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    // `Map.prototype.keyOf` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      keyOf: function keyOf (searchElement) {
+        const result = iterate(aMap(this), function (value, key) {
+          if (value === searchElement) return { key }
+        }, true)
+        return result && result.key
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/map-iterate': 91 }],
+  141: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const MapHelpers = require('../internals/map-helpers')
+    const iterate = require('../internals/map-iterate')
+
+    const Map = MapHelpers.Map
+    const set = MapHelpers.set
+
+    // `Map.prototype.mapKeys` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      mapKeys: function mapKeys (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        const newMap = new Map()
+        iterate(map, function (value, key) {
+          set(newMap, boundFunction(value, key, map), value)
+        })
+        return newMap
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-helpers': 90, '../internals/map-iterate': 91 }],
+  142: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const MapHelpers = require('../internals/map-helpers')
+    const iterate = require('../internals/map-iterate')
+
+    const Map = MapHelpers.Map
+    const set = MapHelpers.set
+
+    // `Map.prototype.mapValues` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      mapValues: function mapValues (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        const newMap = new Map()
+        iterate(map, function (value, key) {
+          set(newMap, key, boundFunction(value, key, map))
+        })
+        return newMap
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-helpers': 90, '../internals/map-iterate': 91 }],
+  143: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/iterate')
+    const set = require('../internals/map-helpers').set
+
+    // `Map.prototype.merge` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, arity: 1, forced: true }, {
+      // eslint-disable-next-line no-unused-vars -- required for `.length`
+      merge: function merge (iterable /* ...iterables */) {
+        const map = aMap(this)
+        const argumentsLength = arguments.length
+        let i = 0
+        while (i < argumentsLength) {
+          iterate(arguments[i++], function (key, value) {
+            set(map, key, value)
+          }, { AS_ENTRIES: true })
+        }
+        return map
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/iterate': 79, '../internals/map-helpers': 90 }],
+  144: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const aCallable = require('../internals/a-callable')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    const $TypeError = TypeError
+
+    // `Map.prototype.reduce` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      reduce: function reduce (callbackfn /* , initialValue */) {
+        const map = aMap(this)
+        let noInitial = arguments.length < 2
+        let accumulator = noInitial ? undefined : arguments[1]
+        aCallable(callbackfn)
+        iterate(map, function (value, key) {
+          if (noInitial) {
+            noInitial = false
+            accumulator = value
+          } else {
+            accumulator = callbackfn(accumulator, value, key, map)
+          }
+        })
+        if (noInitial) throw new $TypeError('Reduce of empty map with no initial value')
+        return accumulator
+      }
+    })
+  }, { '../internals/a-callable': 26, '../internals/a-map': 27, '../internals/export': 49, '../internals/map-iterate': 91 }],
+  145: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const bind = require('../internals/function-bind-context')
+    const aMap = require('../internals/a-map')
+    const iterate = require('../internals/map-iterate')
+
+    // `Map.prototype.some` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      some: function some (callbackfn /* , thisArg */) {
+        const map = aMap(this)
+        const boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined)
+        return iterate(map, function (value, key) {
+          if (boundFunction(value, key, map)) return true
+        }, true) === true
+      }
+    })
+  }, { '../internals/a-map': 27, '../internals/export': 49, '../internals/function-bind-context': 52, '../internals/map-iterate': 91 }],
+  146: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const aCallable = require('../internals/a-callable')
+    const aMap = require('../internals/a-map')
+    const MapHelpers = require('../internals/map-helpers')
+
+    const $TypeError = TypeError
+    const get = MapHelpers.get
+    const has = MapHelpers.has
+    const set = MapHelpers.set
+
+    // `Map.prototype.update` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'Map', proto: true, real: true, forced: true }, {
+      update: function update (key, callback /* , thunk */) {
+        const map = aMap(this)
+        const length = arguments.length
+        aCallable(callback)
+        const isPresentInMap = has(map, key)
+        if (!isPresentInMap && length < 3) {
+          throw new $TypeError('Updating absent value')
+        }
+        const value = isPresentInMap ? get(map, key) : aCallable(length > 2 ? arguments[2] : undefined)(key, map)
+        set(map, key, callback(value, key, map))
+        return map
+      }
+    })
+  }, { '../internals/a-callable': 26, '../internals/a-map': 27, '../internals/export': 49, '../internals/map-helpers': 90 }],
+  147: [function (require, module, exports) {
+    'use strict'
+    const $ = require('../internals/export')
+    const aWeakMap = require('../internals/a-weak-map')
+    const remove = require('../internals/weak-map-helpers').remove
+
+    // `WeakMap.prototype.deleteAll` method
+    // https://github.com/tc39/proposal-collection-methods
+    $({ target: 'WeakMap', proto: true, real: true, forced: true }, {
+      deleteAll: function deleteAll (/* ...elements */) {
+        const collection = aWeakMap(this)
+        let allDeleted = true
+        let wasDeleted
+        for (let k = 0, len = arguments.length; k < len; k++) {
+          wasDeleted = remove(collection, arguments[k])
+          allDeleted = allDeleted && wasDeleted
+        } return !!allDeleted
+      }
+    })
+  }, { '../internals/a-weak-map': 28, '../internals/export': 49, '../internals/weak-map-helpers': 124 }]
+}, {}, [16])