pseudo-dom 0.2.0 → 0.4.0

package/browser/pseudo-dom.js

@@ -20,6 +20,13 @@
  * @property {boolean} isDefault
  */
     class PseudoEventListener {
+      /**
+   * @param {string} eventType The type of event this listens for
+   * @param {Object} [options] The capture, once and passive options
+   * @param {Function} handleEvent The function which is called with the event, already bound to what it should run as
+   * @param {Function} [originalCallback=handleEvent] The function (or object) which was given when registering, used to find this listener again
+   * @constructor
+   */
       constructor (eventType, {
         capture = false,
         once = false,
@@ -32,6 +39,7 @@
         }
         this.eventType = ''
         this.defaultListener = false
+        this.isRemoved = false
         this.eventOptions = {
           capture,
           once,
@@ -49,6 +57,11 @@
         return this.originalCallback
       }
 
+      /** Whether this listener listens in the capture phase (and at the target) rather than in the bubble phase. */
+      get capture () {
+        return this.eventOptions.capture
+      }
+
       get isDefault () {
         return this.defaultListener
       }
@@ -57,6 +70,20 @@
         return this.eventOptions.once
       }
 
+      /** Whether the listener promises not to prevent the default (preventDefault does nothing while it runs). */
+      get passive () {
+        return this.eventOptions.passive
+      }
+
+      /** Whether this listener has been removed, a removed listener does not run even if the event already started. */
+      get removed () {
+        return this.isRemoved
+      }
+
+      set removed (removed) {
+        this.isRemoved = removed
+      }
+
       /**
    * @method
    * @name PseudoEventListener#handleEvent
@@ -68,6 +95,7 @@
       }
 
       /**
+   * A capture listener runs while the event travels down to the target.
    * @method
    * @name PseudoEventListener#doCapturePhase
    * @param {PseudoEvent} event
@@ -78,6 +106,7 @@
       }
 
       /**
+   * Every listener of the target itself runs, capture listeners first.
    * @method
    * @name PseudoEventListener#doTargetPhase
    * @param {PseudoEvent} event
@@ -88,13 +117,14 @@
       }
 
       /**
+   * A listener which is not a capture listener runs while the event travels back up (when it bubbles).
    * @method
    * @name PseudoEventListener#doBubblePhase
    * @param {PseudoEvent} event
-   * @returns {boolean|*}
+   * @returns {boolean}
    */
       doBubblePhase (event) {
-        return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && (event.bubbles || !this.eventOptions.capture)
+        return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && !this.eventOptions.capture
       }
 
       /**
@@ -108,47 +138,20 @@
       }
 
       /**
-   * @method
-   * @name PseudoEventListener#skipDefault
-   * @param {PseudoEvent} event
-   * @returns {boolean|*}
-   */
-      skipDefault (event) {
-        return this.isDefault && event.defaultPrevented
-      }
-
-      /**
-   * @method
-   * @name PseudoEventListener#stopPropagation
-   * @param {PseudoEvent} event
-   * @returns {boolean}
-   */
-      stopPropagation (event) {
-        return !this.doTargetPhase(event) && event.inner.propagationStopped
-      }
-
-      /**
-   * @method
-   * @name PseudoEventListener#nonPassiveHalt
-   * @param {PseudoEvent} event
-   * @returns {boolean|*}
-   */
-      nonPassiveHalt (event) {
-        return !this.eventOptions.passive && (this.skipDefault(event) || event.inner.immediatePropagationStopped || this.stopPropagation(event))
-      }
-
-      /**
+   * Whether this listener should not run for the event as it is now (it was removed, or it is for another phase).
+   * Stopping propagation is handled by the dispatching, since it stops other targets and not the listeners of the
+   * current one.
    * @method
    * @name PseudoEventListener#rejectEvent
    * @param {PseudoEvent} event
-   * @returns {*|boolean}
+   * @returns {boolean}
    */
       rejectEvent (event) {
-        return this.nonPassiveHalt(event) || this.skipPhase(event)
+        return this.isRemoved || this.skipPhase(event)
       }
     }
     exports.default = PseudoEventListener
-  }, { '../services/EventService': 12 }],
+  }, { '../services/EventService': 17 }],
   2: [function (require, module, exports) {
     'use strict'
 
@@ -216,7 +219,7 @@
       }
     }
     exports.default = PseudoHTMLDocument
-  }, { '../services/HTMLElementService': 14 }],
+  }, { '../services/HTMLElementService': 20 }],
   3: [function (require, module, exports) {
     'use strict'
 
@@ -289,10 +292,175 @@
       }
     }
     exports.PseudoNodeList = PseudoNodeList
-  }, { 'collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList': 23, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.map.js': 134 }],
+  }, { 'collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList': 35, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.map.js': 148 }],
   4: [function (require, module, exports) {
     'use strict'
 
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.createEvent = void 0
+    const EventService_1 = require('../services/EventService')
+    const UIEventService_1 = require('../services/UIEventService')
+    const MouseEventService_1 = require('../services/MouseEventService')
+    const PointerEventService_1 = require('../services/PointerEventService')
+    const KeyboardEventService_1 = require('../services/KeyboardEventService')
+    const FocusEventService_1 = require('../services/FocusEventService')
+    const InputEventService_1 = require('../services/InputEventService')
+    const CustomEventService_1 = require('../services/CustomEventService')
+    const eventDefaults_1 = require('./eventDefaults')
+    const eventClasses = {
+      Event: EventService_1.EventService,
+      UIEvent: UIEventService_1.UIEventService,
+      MouseEvent: MouseEventService_1.MouseEventService,
+      PointerEvent: PointerEventService_1.PointerEventService,
+      KeyboardEvent: KeyboardEventService_1.KeyboardEventService,
+      FocusEvent: FocusEventService_1.FocusEventService,
+      InputEvent: InputEventService_1.InputEventService,
+      CustomEvent: CustomEventService_1.CustomEventService
+    }
+    /**
+ * Create an event of the kind which suits its type (a click is a MouseEvent, a keydown a KeyboardEvent, ...).
+ * By default this is like using the constructor of the event in a script: nothing bubbles or can be cancelled unless
+ * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
+ * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
+ * real user action (isTrusted).
+ * @function createEvent
+ * @param {string} type The type of the event, such as click
+ * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
+ * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
+ * @returns {EventService}
+ */
+    const createEvent = (type, init = {}, {
+      browser = false,
+      trusted = false
+    } = {}) => {
+      const definition = eventDefaults_1.eventDefaults[type]
+      const options = browser && definition
+        ? Object.assign({
+          bubbles: definition.bubbles,
+          cancelable: definition.cancelable,
+          composed: definition.composed
+        }, init)
+        : init
+      const EventClass = eventClasses[definition ? definition.interface : 'Event']
+      const event = new EventClass(type, options)
+      event.inner.trusted = trusted
+      return event
+    }
+    exports.createEvent = createEvent
+    exports.default = exports.createEvent
+  }, { '../services/CustomEventService': 14, '../services/EventService': 17, '../services/FocusEventService': 19, '../services/InputEventService': 21, '../services/KeyboardEventService': 22, '../services/MouseEventService': 23, '../services/PointerEventService': 26, '../services/UIEventService': 27, './eventDefaults': 5 }],
+  5: [function (require, module, exports) {
+    'use strict'
+
+    /**
+ * @file The standard event types of the browser, and how the browser creates them.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.eventDefaults = void 0
+    const define = (bubbles, cancelable, composed, eventInterface = 'Event') => ({
+      bubbles,
+      cancelable,
+      composed,
+      interface: eventInterface
+    })
+    /**
+ * The events which the browser itself creates (for a user action, or for something like element.click()) have these
+ * options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
+ * for them, which is why createEvent only uses this table when it is told the browser is creating the event.
+ * The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.
+ * @type {Object.<string, EventDefinition>}
+ */
+    exports.eventDefaults = {
+      // Mouse (UI Events)
+      click: define(true, true, true, 'MouseEvent'),
+      auxclick: define(true, true, true, 'MouseEvent'),
+      dblclick: define(true, true, true, 'MouseEvent'),
+      contextmenu: define(true, true, true, 'MouseEvent'),
+      mousedown: define(true, true, true, 'MouseEvent'),
+      mouseup: define(true, true, true, 'MouseEvent'),
+      mousemove: define(true, true, true, 'MouseEvent'),
+      mouseover: define(true, true, true, 'MouseEvent'),
+      mouseout: define(true, true, true, 'MouseEvent'),
+      mouseenter: define(false, false, true, 'MouseEvent'),
+      mouseleave: define(false, false, true, 'MouseEvent'),
+      wheel: define(true, true, true, 'MouseEvent'),
+      // Pointer (Pointer Events)
+      pointerdown: define(true, true, true, 'PointerEvent'),
+      pointerup: define(true, true, true, 'PointerEvent'),
+      pointermove: define(true, true, true, 'PointerEvent'),
+      pointerover: define(true, true, true, 'PointerEvent'),
+      pointerout: define(true, true, true, 'PointerEvent'),
+      pointerenter: define(false, false, true, 'PointerEvent'),
+      pointerleave: define(false, false, true, 'PointerEvent'),
+      pointercancel: define(true, false, true, 'PointerEvent'),
+      gotpointercapture: define(true, false, true, 'PointerEvent'),
+      lostpointercapture: define(true, false, true, 'PointerEvent'),
+      // Keyboard (UI Events)
+      keydown: define(true, true, true, 'KeyboardEvent'),
+      keypress: define(true, true, true, 'KeyboardEvent'),
+      keyup: define(true, true, true, 'KeyboardEvent'),
+      // Focus (UI Events): focus and blur do not bubble, focusin and focusout do
+      focus: define(false, false, true, 'FocusEvent'),
+      blur: define(false, false, true, 'FocusEvent'),
+      focusin: define(true, false, true, 'FocusEvent'),
+      focusout: define(true, false, true, 'FocusEvent'),
+      // Forms (HTML, Input Events)
+      beforeinput: define(true, true, true, 'InputEvent'),
+      input: define(true, false, true, 'InputEvent'),
+      change: define(true, false, false),
+      select: define(true, false, false),
+      submit: define(true, true, false),
+      reset: define(true, true, false),
+      invalid: define(false, true, false),
+      toggle: define(false, false, false),
+      // Loading and the page (HTML)
+      load: define(false, false, false),
+      error: define(false, false, false),
+      abort: define(false, false, false),
+      scroll: define(false, false, false),
+      scrollend: define(false, false, false),
+      resize: define(false, false, false),
+      DOMContentLoaded: define(true, false, false),
+      readystatechange: define(false, false, false),
+      visibilitychange: define(true, false, false),
+      // Clipboard
+      copy: define(true, true, true),
+      cut: define(true, true, true),
+      paste: define(true, true, true),
+      // Drag and drop
+      drag: define(true, true, true, 'MouseEvent'),
+      dragstart: define(true, true, true, 'MouseEvent'),
+      dragend: define(true, false, true, 'MouseEvent'),
+      dragenter: define(true, true, true, 'MouseEvent'),
+      dragover: define(true, true, true, 'MouseEvent'),
+      dragleave: define(true, false, true, 'MouseEvent'),
+      drop: define(true, true, true, 'MouseEvent'),
+      // Touch
+      touchstart: define(true, true, true, 'UIEvent'),
+      touchmove: define(true, true, true, 'UIEvent'),
+      touchend: define(true, true, true, 'UIEvent'),
+      touchcancel: define(true, false, true, 'UIEvent'),
+      // Animations and transitions (CSS)
+      animationstart: define(true, false, false),
+      animationiteration: define(true, false, false),
+      animationend: define(true, false, false),
+      animationcancel: define(true, false, false),
+      transitionrun: define(true, false, false),
+      transitionstart: define(true, false, false),
+      transitionend: define(true, false, false),
+      transitioncancel: define(true, false, false)
+    }
+    exports.default = exports.eventDefaults
+  }, {}],
+  6: [function (require, module, exports) {
+    'use strict'
+
     const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
       return mod && mod.__esModule
         ? mod
@@ -356,8 +524,8 @@
       return context ? Object.assign(context, newWindow) : Object.assign(root, newWindow)
     }
     exports.default = generateDocument
-  }, { '../classes/PseudoHTMLDocument': 2, '../services/ElementService': 11, '../services/EventTargetService': 13, '../services/HTMLElementService': 14, '../services/NodeService': 16 }],
-  5: [function (require, module, exports) {
+  }, { '../classes/PseudoHTMLDocument': 2, '../services/ElementService': 16, '../services/EventTargetService': 18, '../services/HTMLElementService': 20, '../services/NodeService': 25 }],
+  7: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -372,7 +540,42 @@
     const generateNodeList = (innerList = null) => new PseudoNodeList_1.PseudoNodeList().initialize(innerList)
     exports.default = generateNodeList
   }, { '../classes/PseudoNodeList': 3 }],
-  6: [function (require, module, exports) {
+  8: [function (require, module, exports) {
+    'use strict'
+
+    require('core-js/modules/esnext.weak-map.delete-all.js')
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.setActiveElement = exports.getActiveElement = void 0
+    /**
+ * The element which has the focus, kept for each tree (the root node of the tree it is in), like document.activeElement.
+ */
+    const focused = new WeakMap()
+    /**
+ * Find the element which has the focus in a tree.
+ * @function getActiveElement
+ * @param {Object} root The root node of the tree
+ * @returns {Object|null}
+ */
+    const getActiveElement = root => focused.get(root) || null
+    exports.getActiveElement = getActiveElement
+    /**
+ * Remember the element which has the focus in a tree.
+ * @function setActiveElement
+ * @param {Object} root The root node of the tree
+ * @param {Object|null} element The element which now has the focus, or null when nothing has it
+ */
+    const setActiveElement = (root, element) => {
+      if (element === null) {
+        focused.delete(root)
+      } else {
+        focused.set(root, element)
+      }
+    }
+    exports.setActiveElement = setActiveElement
+  }, { 'core-js/modules/esnext.weak-map.delete-all.js': 151 }],
+  9: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -396,7 +599,7 @@
     }
     exports.default = getParentNodes
   }, {}],
-  7: [function (require, module, exports) {
+  10: [function (require, module, exports) {
     'use strict'
 
     require('core-js/modules/esnext.iterator.constructor.js')
@@ -426,8 +629,51 @@
       return (0, getParentNodes_1.default)(node).filter(parent => (parent[attr] || false) === value)
     }
     exports.default = getParentNodesFromAttribute
-  }, { './getParentNodes': 6, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.filter.js': 131 }],
-  8: [function (require, module, exports) {
+  }, { './getParentNodes': 9, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.filter.js': 145 }],
+  11: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.modifierState = exports.modifierKeys = void 0
+    /**
+ * Pick the modifier keys out of the init object of an event.
+ * @function modifierKeys
+ * @param {Object} [init={}] The init of an event
+ * @returns {ModifierKeys}
+ */
+    const modifierKeys = (init = {}) => ({
+      ctrlKey: !!init.ctrlKey,
+      shiftKey: !!init.shiftKey,
+      altKey: !!init.altKey,
+      metaKey: !!init.metaKey
+    })
+    exports.modifierKeys = modifierKeys
+    /**
+ * Answer getModifierState for a set of held modifier keys.
+ * @function modifierState
+ * @param {ModifierKeys} keys The modifier keys which were held down
+ * @param {string} key The name of the modifier (Control, Shift, Alt or Meta)
+ * @returns {boolean}
+ */
+    const modifierState = (keys, key) => {
+      switch (key) {
+        case 'Control':
+          return keys.ctrlKey
+        case 'Shift':
+          return keys.shiftKey
+        case 'Alt':
+          return keys.altKey
+        case 'Meta':
+          return keys.metaKey
+        default:
+          return false
+      }
+    }
+    exports.modifierState = modifierState
+  }, {}],
+  12: [function (require, module, exports) {
     'use strict'
 
     /**
@@ -445,7 +691,7 @@
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
-    exports.PseudoHTMLDocument = exports.PseudoHTMLElement = exports.PseudoElement = exports.PseudoNode = exports.PseudoEventTarget = exports.PseudoEvent = exports.generateDocument = void 0
+    exports.PseudoHTMLDocument = exports.PseudoHTMLElement = exports.PseudoElement = exports.PseudoNode = exports.PseudoEventTarget = exports.PseudoCustomEvent = exports.PseudoInputEvent = exports.PseudoFocusEvent = exports.PseudoKeyboardEvent = exports.PseudoPointerEvent = exports.PseudoMouseEvent = exports.PseudoUIEvent = exports.PseudoEvent = exports.simulate = exports.eventDefaults = exports.createEvent = exports.generateDocument = void 0
     const EventService_1 = require('./services/EventService')
     Object.defineProperty(exports, 'PseudoEvent', {
       enumerable: true,
@@ -480,6 +726,61 @@
     exports.PseudoHTMLDocument = PseudoHTMLDocument_1.default
     const generateDocument_1 = __importDefault(require('./factories/generateDocument'))
     exports.generateDocument = generateDocument_1.default
+    const createEvent_1 = __importDefault(require('./factories/createEvent'))
+    exports.createEvent = createEvent_1.default
+    const eventDefaults_1 = __importDefault(require('./factories/eventDefaults'))
+    exports.eventDefaults = eventDefaults_1.default
+    const UIEventService_1 = require('./services/UIEventService')
+    Object.defineProperty(exports, 'PseudoUIEvent', {
+      enumerable: true,
+      get: function () {
+        return UIEventService_1.UIEventService
+      }
+    })
+    const MouseEventService_1 = require('./services/MouseEventService')
+    Object.defineProperty(exports, 'PseudoMouseEvent', {
+      enumerable: true,
+      get: function () {
+        return MouseEventService_1.MouseEventService
+      }
+    })
+    const PointerEventService_1 = require('./services/PointerEventService')
+    Object.defineProperty(exports, 'PseudoPointerEvent', {
+      enumerable: true,
+      get: function () {
+        return PointerEventService_1.PointerEventService
+      }
+    })
+    const KeyboardEventService_1 = require('./services/KeyboardEventService')
+    Object.defineProperty(exports, 'PseudoKeyboardEvent', {
+      enumerable: true,
+      get: function () {
+        return KeyboardEventService_1.KeyboardEventService
+      }
+    })
+    const FocusEventService_1 = require('./services/FocusEventService')
+    Object.defineProperty(exports, 'PseudoFocusEvent', {
+      enumerable: true,
+      get: function () {
+        return FocusEventService_1.FocusEventService
+      }
+    })
+    const InputEventService_1 = require('./services/InputEventService')
+    Object.defineProperty(exports, 'PseudoInputEvent', {
+      enumerable: true,
+      get: function () {
+        return InputEventService_1.InputEventService
+      }
+    })
+    const CustomEventService_1 = require('./services/CustomEventService')
+    Object.defineProperty(exports, 'PseudoCustomEvent', {
+      enumerable: true,
+      get: function () {
+        return CustomEventService_1.CustomEventService
+      }
+    })
+    const simulate_1 = __importDefault(require('./simulate'))
+    exports.simulate = simulate_1.default
     /**
  * All methods exported from this module are encapsulated within pseudoDom.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -488,7 +789,17 @@
  */
     const pseudoDom = {
       generateDocument: generateDocument_1.default,
+      createEvent: createEvent_1.default,
+      eventDefaults: eventDefaults_1.default,
+      simulate: simulate_1.default,
       PseudoEvent: EventService_1.EventService,
+      PseudoUIEvent: UIEventService_1.UIEventService,
+      PseudoMouseEvent: MouseEventService_1.MouseEventService,
+      PseudoPointerEvent: PointerEventService_1.PointerEventService,
+      PseudoKeyboardEvent: KeyboardEventService_1.KeyboardEventService,
+      PseudoFocusEvent: FocusEventService_1.FocusEventService,
+      PseudoInputEvent: InputEventService_1.InputEventService,
+      PseudoCustomEvent: CustomEventService_1.CustomEventService,
       PseudoEventTarget: EventTargetService_1.default,
       PseudoNode: NodeService_1.NodeService,
       PseudoElement: ElementService_1.ElementService,
@@ -503,8 +814,8 @@
       // @ts-ignore
       window.pseudoDom = pseudoDom
     }
-  }, { './classes/PseudoHTMLDocument': 2, './factories/generateDocument': 4, './services/ElementService': 11, './services/EventService': 12, './services/EventTargetService': 13, './services/HTMLElementService': 14, './services/NodeService': 16 }],
-  9: [function (require, module, exports) {
+  }, { './classes/PseudoHTMLDocument': 2, './factories/createEvent': 4, './factories/eventDefaults': 5, './factories/generateDocument': 6, './services/CustomEventService': 14, './services/ElementService': 16, './services/EventService': 17, './services/EventTargetService': 18, './services/FocusEventService': 19, './services/HTMLElementService': 20, './services/InputEventService': 21, './services/KeyboardEventService': 22, './services/MouseEventService': 23, './services/NodeService': 25, './services/PointerEventService': 26, './services/UIEventService': 27, './simulate': 28 }],
+  13: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -562,8 +873,45 @@
       }
     }
     exports.AttrService = AttrService
-  }, { './NodeService': 16 }],
-  10: [function (require, module, exports) {
+  }, { './NodeService': 25 }],
+  14: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.CustomEventService = void 0
+    /**
+ * @file Substitute for the DOM CustomEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const EventService_1 = require('./EventService')
+    /**
+ * Simulate the behaviour of the CustomEvent Class when there is no DOM available: an event which carries data.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments EventService
+ * @property {*} detail
+ */
+    class CustomEventService extends EventService_1.EventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {CustomEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.eventDetail = typeof init.detail === 'undefined' ? null : init.detail
+      }
+
+      get detail () {
+        return this.eventDetail
+      }
+    }
+    exports.CustomEventService = CustomEventService
+  }, { './EventService': 17 }],
+  15: [function (require, module, exports) {
     'use strict'
 
     require('core-js/modules/esnext.iterator.constructor.js')
@@ -681,8 +1029,8 @@
       }
     }
     exports.DOMTokenListService = DOMTokenListService
-  }, { 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.filter.js': 131, 'core-js/modules/esnext.iterator.for-each.js': 133, 'core-js/modules/esnext.iterator.map.js': 134 }],
-  11: [function (require, module, exports) {
+  }, { 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.filter.js': 145, 'core-js/modules/esnext.iterator.for-each.js': 147, 'core-js/modules/esnext.iterator.map.js': 148 }],
+  16: [function (require, module, exports) {
     'use strict'
 
     require('core-js/modules/esnext.iterator.constructor.js')
@@ -701,6 +1049,7 @@
       value: true
     })
     exports.ElementService = void 0
+    const createEvent_1 = __importDefault(require('../factories/createEvent'))
     const NodeService_1 = require('./NodeService')
     const AttrService_1 = require('./AttrService')
     const DOMTokenListService_1 = require('./DOMTokenListService')
@@ -737,6 +1086,7 @@
         children = []
       } = {}) {
         super()
+        this.defaultEventApplied = false
         this.tokenList = new DOMTokenListService_1.DOMTokenListService()
         this.tag = tagName
         this.attributeList = attributes.concat([{
@@ -802,21 +1152,26 @@
    */
       applyDefaultEvent () {
         let callback = event => undefined
+        if (this.defaultEventApplied) {
+          return callback
+        }
         switch (this.tagName) {
-          case 'form':
-            this.addEventListener('submit', callback)
-            break
           case 'button':
           case 'input':
-            if (/^(submit|image)$/i.test(this.type || '')) {
-              callback = event => {
-                const forms = (0, getParentNodesFromAttribute_1.default)('tagName', 'form', this)
-                if (forms.length) {
-                  forms[0].submit()
-                }
+            // Clicking a submit button submits the form it is in: the form gets a submit event, which can be cancelled
+            callback = event => {
+              const type = String(this.getAttribute('type') || this.type || '').toLowerCase()
+              const submits = this.tagName === 'button' ? type !== 'button' && type !== 'reset' : /^(submit|image)$/.test(type)
+              const forms = (0, getParentNodesFromAttribute_1.default)('tagName', 'form', this)
+              if (submits && forms.length && !this.hasAttribute('disabled')) {
+                forms[forms.length - 1].dispatchEvent((0, createEvent_1.default)('submit', {}, {
+                  browser: true,
+                  trusted: event.isTrusted
+                }))
               }
-              super.setDefaultEvent('click', callback)
             }
+            super.setDefaultEvent('click', callback)
+            this.defaultEventApplied = true
         }
         return callback
       }
@@ -892,8 +1247,8 @@
       }
     }
     exports.ElementService = ElementService
-  }, { '../functions/getParentNodesFromAttribute': 7, './AttrService': 9, './DOMTokenListService': 10, './NamedNodeMapService': 15, './NodeService': 16, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.find.js': 132, 'core-js/modules/esnext.iterator.for-each.js': 133, 'core-js/modules/esnext.iterator.map.js': 134, 'core-js/modules/esnext.iterator.some.js': 136 }],
-  12: [function (require, module, exports) {
+  }, { '../factories/createEvent': 4, '../functions/getParentNodesFromAttribute': 10, './AttrService': 13, './DOMTokenListService': 15, './NamedNodeMapService': 24, './NodeService': 25, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.find.js': 146, 'core-js/modules/esnext.iterator.for-each.js': 147, 'core-js/modules/esnext.iterator.map.js': 148, 'core-js/modules/esnext.iterator.some.js': 150 }],
+  17: [function (require, module, exports) {
     'use strict'
 
     /**
@@ -901,18 +1256,10 @@
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @version 1.0.0
  */
-    const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-      return mod && mod.__esModule
-        ? mod
-        : {
-            default: mod
-          }
-    }
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
     exports.EventService = void 0
-    const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
     /**
  * Simulate the behaviour of the Event Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -947,20 +1294,20 @@
    *
    * @param {string} typeArg
    * @param {Object} [eventOptions={}]
-   * @param {boolean} [eventOptions.bubbles=true]
-   * @param {boolean} [eventOptions.cancelable=true]
-   * @param {boolean} [eventOptions.composed=true]
+   * @param {boolean} [eventOptions.bubbles=false]
+   * @param {boolean} [eventOptions.cancelable=false]
+   * @param {boolean} [eventOptions.composed=false]
    * @constructor
    */
       constructor (typeArg = '', {
-        bubbles = true,
-        cancelable = true,
-        composed = true
+        bubbles = false,
+        cancelable = false,
+        composed = false
       } = {}) {
         this.properties = {
-          bubbles: true,
-          cancelable: true,
-          composed: true,
+          bubbles: false,
+          cancelable: false,
+          composed: false,
           currentTarget: null,
           defaultPrevented: false,
           immediatePropagationStopped: false,
@@ -969,7 +1316,10 @@
           target: null,
           timeStamp: Math.floor(Date.now() / 1000),
           type: '',
-          isTrusted: true
+          isTrusted: false,
+          dispatching: false,
+          inPassiveListener: false,
+          path: []
         }
         this.setReadOnlyProperties({
           type: typeArg,
@@ -1026,12 +1376,21 @@
       get inner () {
         const self = this
         return {
+          get currentTarget () {
+            return self.properties.currentTarget
+          },
           set currentTarget (target) {
             self.properties.currentTarget = target
           },
+          get eventPhase () {
+            return self.properties.eventPhase
+          },
           set eventPhase (phase) {
             self.properties.eventPhase = phase
           },
+          get target () {
+            return self.properties.target
+          },
           set target (target) {
             self.properties.target = target
           },
@@ -1040,6 +1399,41 @@
           },
           get propagationStopped () {
             return self.properties.propagationStopped
+          },
+          get trusted () {
+            return self.properties.isTrusted
+          },
+          set trusted (trusted) {
+            self.properties.isTrusted = trusted
+          },
+          get dispatching () {
+            return self.properties.dispatching
+          },
+          set dispatching (dispatching) {
+            self.properties.dispatching = dispatching
+          },
+          get inPassiveListener () {
+            return self.properties.inPassiveListener
+          },
+          set inPassiveListener (passive) {
+            self.properties.inPassiveListener = passive
+          },
+          get path () {
+            return self.properties.path
+          },
+          set path (path) {
+            self.properties.path = path
+          },
+          finishDispatch () {
+            self.setReadOnlyProperties({
+              currentTarget: null,
+              eventPhase: EventService.NONE,
+              path: [],
+              dispatching: false,
+              inPassiveListener: false,
+              propagationStopped: false,
+              immediatePropagationStopped: false
+            })
           }
         }
       }
@@ -1050,16 +1444,8 @@
    * @returns {Array.<PseudoEventTarget>}
    */
       composedPath () {
-        switch (this.eventPhase) {
-          case EventService.CAPTURING_PHASE:
-            return (0, getParentNodes_1.default)(this.target)
-          case EventService.BUBBLING_PHASE:
-            return (0, getParentNodes_1.default)(this.target).slice().reverse()
-          case EventService.AT_TARGET:
-            return [this.target]
-          default:
-            return []
-        }
+        // While the event is being dispatched this is every target it travels through, the target first and the root last
+        return this.properties.dispatching ? this.properties.path.slice() : []
       }
 
       /**
@@ -1068,9 +1454,12 @@
    * @returns {null}
    */
       preventDefault () {
-        this.setReadOnlyProperties({
-          defaultPrevented: true
-        })
+        // Only an event which can be cancelled can be prevented, and a passive listener cannot prevent the default
+        if (this.cancelable && !this.properties.inPassiveListener) {
+          this.setReadOnlyProperties({
+            defaultPrevented: true
+          })
+        }
         return null
       }
 
@@ -1110,14 +1499,16 @@
     EventService.CAPTURING_PHASE = 1
     EventService.AT_TARGET = 2
     EventService.BUBBLING_PHASE = 3
-  }, { '../functions/getParentNodes': 6 }],
-  13: [function (require, module, exports) {
+  }, {}],
+  18: [function (require, module, exports) {
     'use strict'
 
     require('core-js/modules/esnext.iterator.constructor.js')
     require('core-js/modules/esnext.iterator.filter.js')
     require('core-js/modules/esnext.iterator.find.js')
     require('core-js/modules/esnext.iterator.for-each.js')
+    require('core-js/modules/esnext.iterator.map.js')
+    require('core-js/modules/esnext.iterator.some.js')
     const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
       return mod && mod.__esModule
         ? mod
@@ -1135,9 +1526,13 @@
  */
     const EventService_1 = require('./EventService')
     const PseudoEventListener_1 = __importDefault(require('../classes/PseudoEventListener'))
+    const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
     const LinkedList_1 = require('collect-your-stuff/dist/collections/linked-list/LinkedList')
     /**
  * Simulate the behaviour of the EventTarget Class when there is no DOM available.
+ * Dispatching an event sends it through the tree the way the DOM does: down from the root to the target (capture
+ * listeners), to the target itself, then back up to the root (the listeners which are not capture listeners, when the
+ * event bubbles).
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @class
  * @property {Object.<string, Array.<PseudoEventListener>>} listeners
@@ -1167,33 +1562,51 @@
       }
 
       /**
-   * Run each of the listeners registered on this target for the type of the event.
-   * Listeners which do not apply to the event's phase are skipped, running stops once immediate propagation is stopped,
-   * and listeners added or removed while running do not change which ones run for this event.
-   * @param {EventService} event
-   * @returns {*} true when there was nothing registered, otherwise the last value returned from a handler (null when none ran)
+   * Run the listeners registered on this target for the type of the event which apply to the phase the event is in
+   * (at the target, the capture listeners run before the others). Listeners which are added while this runs do not run
+   * for this event, and listeners which are removed while it runs no longer do. Running stops as soon as immediate
+   * propagation is stopped. A listener which throws does not stop the others.
+   * @param {EventService} event The event, which is at a phase and has a current target
+   * @returns {Array<*>} The errors which the listeners threw
    */
       runEvents (event) {
+        const errors = []
         if (!(event.type in this.listeners)) {
-          return true
+          return errors
         }
-        const listeners = this.listeners[event.type]
-        let eventReturn = null
-        // Work from a copy of the linkers so that removing a listener (for example a once listener) does not disturb the walk
-        for (const linker of Array.from(listeners)) {
-          const listener = linker.data
+        const listeners = Array.from(this.listeners[event.type]).map(linker => linker.data)
+        // At the target the capture listeners come first, otherwise the order is the order they were added
+        const ordered = event.eventPhase === EventService_1.EventService.AT_TARGET ? listeners.filter(listener => listener.capture).concat(listeners.filter(listener => !listener.capture)) : listeners
+        for (const listener of ordered) {
           if (event.inner.immediatePropagationStopped) {
             break
           }
           if (listener.rejectEvent(event)) {
             continue
           }
-          eventReturn = listener.handleEvent(event)
           if (listener.once) {
-            listeners.remove(linker)
+            this.removeListener(event.type, listener)
+          }
+          event.inner.inPassiveListener = listener.passive
+          try {
+            listener.handleEvent(event)
+          } catch (error) {
+            errors.push(error)
           }
+          event.inner.inPassiveListener = false
         }
-        return eventReturn
+        return errors
+      }
+
+      /**
+   * Take a listener out of the registered listeners, so that it does not run again.
+   * @param {string} type
+   * @param {PseudoEventListener} listener
+   */
+      removeListener (type, listener) {
+        listener.removed = true
+        const registered = this.listeners[type]
+        Array.from(registered).filter(linker => linker.data === listener).forEach(linker => registered.remove(linker))
       }
 
       /**
@@ -1206,48 +1619,34 @@
         this.defaultEvent[type] = callback
       }
 
-      runDefaultEvent (event) {
-        if (event.defaultPrevented) {
-          return false
-        }
-        this.defaultEvent[event.type](event)
-        return true
-      }
-
-      startEvents (eventType) {
-        const event = new EventService_1.EventService(eventType)
-        event.inner.target = this;
-        [EventService_1.EventService.CAPTURING_PHASE, EventService_1.EventService.AT_TARGET, EventService_1.EventService.BUBBLING_PHASE].forEach(phase => {
-          let continueEvents = null
-          if (phase === EventService_1.EventService.AT_TARGET || !event.inner.propagationStopped) {
-            event.inner.eventPhase = phase
-            event.composedPath().forEach(target => {
-              event.inner.currentTarget = target
-              continueEvents = event.currentTarget.runEvents(event)
-            })
-          }
-          if (event.eventPhase === EventService_1.EventService.AT_TARGET && typeof continueEvents !== 'boolean' && this.defaultEvent[eventType]) {
-            this.runDefaultEvent(event)
-          }
-        })
-        return true
-      }
-
+      /**
+   * Registers an event handler of a specific event type. Adding the same handler again for the same type and phase does
+   * nothing, like the DOM.
+   * @param {string} type The type of event to listen for
+   * @param {Function|Object} callback The function to call (or an object with a handleEvent function)
+   * @param {Object|boolean} [useCapture=false] Listen while the event travels down to the target (true), or an object with capture, once and passive
+   */
       addEventListener (type, callback, useCapture = false) {
         let options = {
           capture: false,
           once: false,
           passive: false
         }
-        if (typeof useCapture === 'object') {
+        if (typeof useCapture === 'object' && useCapture !== null) {
           // Originally useCapture was a single boolean flag, later optional other flags can be used
           // Here we take all the given flags from the object and assign them as the options
           options = Object.assign(options, useCapture)
         } else {
-          options.capture = useCapture
+          options.capture = !!useCapture
         }
-        const listener = new PseudoEventListener_1.default(type, options, (callback.handleEvent || callback).bind(this), callback)
         const listeners = this.listenersFor(type)
+        const alreadyAdded = Array.from(listeners).some(linker => linker.data.callback === callback && linker.data.capture === options.capture)
+        if (alreadyAdded) {
+          return
+        }
+        // A function runs with this target as this, an object runs its handleEvent as itself
+        const handler = typeof callback === 'function' ? callback.bind(this) : callback.handleEvent.bind(callback)
+        const listener = new PseudoEventListener_1.default(type, options, handler, callback)
         // Listeners run in the order they were added, except that listeners which are not defaults always come before the defaults
         const firstDefault = Array.from(listeners).find(linker => linker.data.isDefault)
         if (firstDefault && !listener.isDefault) {
@@ -1257,33 +1656,138 @@
         }
       }
 
-      removeEventListener (type, callback) {
+      /**
+   * Removes an event listener, the one which was added with the same type, handler and phase.
+   * @param {string} type The type of event
+   * @param {Function|Object} callback The handler which was added
+   * @param {Object|boolean} [options=false] Whether the listener was a capture listener (true), or an object with capture
+   */
+      removeEventListener (type, callback, options = false) {
         if (!(type in this.listeners)) {
           return
         }
-        const listeners = this.listeners[type]
-        Array.from(listeners).filter(linker => !linker.data.isDefault && linker.data.callback === callback).forEach(linker => listeners.remove(linker))
-      }
-
-      dispatchEvent (event, target = this) {
-        event.inner.target = target
-        if (!(event.type in this.listeners)) {
-          return true
+        const capture = typeof options === 'object' && options !== null ? !!options.capture : !!options
+        Array.from(this.listeners[type]).map(linker => linker.data).filter(listener => !listener.isDefault && listener.callback === callback && listener.capture === capture).forEach(listener => this.removeListener(type, listener))
+      }
+
+      /**
+   * Dispatches an event to this target and through the tree: capture listeners of the ancestors from the root down,
+   * then the listeners of this target, then (when the event bubbles) the other listeners of the ancestors from the
+   * parent up to the root. stopPropagation() stops it reaching further targets, stopImmediatePropagation() also stops
+   * the remaining listeners of the current target. Afterwards, unless the default was prevented, the default action
+   * of this target (see setDefaultEvent) runs. The event can be dispatched again afterwards.
+   * @param {EventService} event The event to dispatch
+   * @returns {boolean} False when the event was cancelable and a listener prevented the default, otherwise true
+   * @throws {Error} When the event is already being dispatched, or (after the whole dispatch has finished) the error
+   * which a listener threw (an error with all of them in its errors property when several did)
+   */
+      dispatchEvent (event) {
+        if (event.inner.dispatching) {
+          throw new Error('The event is already being dispatched.')
+        }
+        event.inner.dispatching = true
+        event.inner.target = this
+        // The ancestors, the root first, which can have listeners
+        const ancestors = (0, getParentNodes_1.default)(this).filter(node => node instanceof EventTargetService)
+        event.inner.path = [this].concat(ancestors.slice().reverse())
+        const errors = []
+        const visit = (target, phase) => {
+          event.inner.eventPhase = phase
+          event.inner.currentTarget = target
+          errors.push(...target.runEvents(event))
+        }
+        for (const ancestor of ancestors) {
+          if (event.inner.propagationStopped) {
+            break
+          }
+          visit(ancestor, EventService_1.EventService.CAPTURING_PHASE)
+        }
+        if (!event.inner.propagationStopped) {
+          visit(this, EventService_1.EventService.AT_TARGET)
+        }
+        if (event.bubbles) {
+          for (const ancestor of ancestors.slice().reverse()) {
+            if (event.inner.propagationStopped) {
+              break
+            }
+            visit(ancestor, EventService_1.EventService.BUBBLING_PHASE)
+          }
+        }
+        event.inner.finishDispatch()
+        if (!event.defaultPrevented && typeof this.defaultEvent[event.type] === 'function') {
+          try {
+            this.defaultEvent[event.type](event)
+          } catch (error) {
+            errors.push(error)
+          }
+        }
+        if (errors.length === 1) {
+          throw errors[0]
+        }
+        if (errors.length > 1) {
+          throw Object.assign(new Error(`${errors.length} listeners threw an error while dispatching the ${event.type} event.`), {
+            errors
+          })
         }
-        this.runEvents(event)
         return !event.defaultPrevented
       }
     }
     exports.default = EventTargetService
-  }, { '../classes/PseudoEventListener': 1, './EventService': 12, 'collect-your-stuff/dist/collections/linked-list/LinkedList': 21, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.filter.js': 131, 'core-js/modules/esnext.iterator.find.js': 132, 'core-js/modules/esnext.iterator.for-each.js': 133 }],
-  14: [function (require, module, exports) {
+  }, { '../classes/PseudoEventListener': 1, '../functions/getParentNodes': 9, './EventService': 17, 'collect-your-stuff/dist/collections/linked-list/LinkedList': 33, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.filter.js': 145, 'core-js/modules/esnext.iterator.find.js': 146, 'core-js/modules/esnext.iterator.for-each.js': 147, 'core-js/modules/esnext.iterator.map.js': 148, 'core-js/modules/esnext.iterator.some.js': 150 }],
+  19: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.FocusEventService = void 0
+    /**
+ * @file Substitute for the DOM FocusEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const UIEventService_1 = require('./UIEventService')
+    /**
+ * Simulate the behaviour of the FocusEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {PseudoEventTarget|null} relatedTarget
+ */
+    class FocusEventService extends UIEventService_1.UIEventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {FocusEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.related = init.relatedTarget || null
+      }
+
+      get relatedTarget () {
+        return this.related
+      }
+    }
+    exports.FocusEventService = FocusEventService
+  }, { './UIEventService': 27 }],
+  20: [function (require, module, exports) {
     'use strict'
 
+    const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+      return mod && mod.__esModule
+        ? mod
+        : {
+            default: mod
+          }
+    }
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
     exports.HTMLElementService = void 0
     const ElementService_1 = require('./ElementService')
+    const createEvent_1 = __importDefault(require('../factories/createEvent'))
+    const activeElement_1 = require('../functions/activeElement')
     /**
  * Simulate the behaviour of the HTMLElement Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -1343,10 +1847,343 @@
           children
         })
       }
+
+      /**
+   * Whether this element can have the focus: form controls and links which are not disabled, and anything with a tabindex.
+   * @returns {boolean}
+   */
+      get canFocus () {
+        if (this.hasAttribute('disabled')) {
+          return false
+        }
+        switch (this.tagName) {
+          case 'button':
+          case 'select':
+          case 'textarea':
+            return true
+          case 'input':
+            return String(this.getAttribute('type') || '').toLowerCase() !== 'hidden'
+          case 'a':
+            return this.hasAttribute('href') || this.hasAttribute('tabindex')
+          default:
+            return this.hasAttribute('tabindex')
+        }
+      }
+
+      /**
+   * Click the element: a click event is sent to it, which bubbles and can be cancelled, like one from a user but a
+   * script made it (so it is not trusted). A disabled element does nothing.
+   */
+      click () {
+        if (this.hasAttribute('disabled')) {
+          return
+        }
+        this.dispatchEvent((0, createEvent_1.default)('click', {}, {
+          browser: true
+        }))
+      }
+
+      /**
+   * Give the element the focus. The element which had it gets blur then focusout, and this one gets focus then
+   * focusin (blur and focus do not bubble, focusin and focusout do). Nothing happens when the element cannot have the
+   * focus or already has it.
+   */
+      focus () {
+        const root = this.getRootNode()
+        const previous = (0, activeElement_1.getActiveElement)(root)
+        if (!this.canFocus || previous === this) {
+          return
+        }
+        const send = (target, type, relatedTarget) => {
+          target.dispatchEvent((0, createEvent_1.default)(type, {
+            relatedTarget
+          }, {
+            browser: true,
+            trusted: true
+          }))
+        }
+        if (previous) {
+          send(previous, 'blur', this)
+          send(previous, 'focusout', this)
+        }
+        (0, activeElement_1.setActiveElement)(root, this)
+        send(this, 'focus', previous)
+        send(this, 'focusin', previous)
+      }
+
+      /**
+   * Take the focus away from the element, when it has it: it gets blur then focusout.
+   */
+      blur () {
+        const root = this.getRootNode()
+        if ((0, activeElement_1.getActiveElement)(root) !== this) {
+          return
+        }
+        (0, activeElement_1.setActiveElement)(root, null)
+        this.dispatchEvent((0, createEvent_1.default)('blur', {
+          relatedTarget: null
+        }, {
+          browser: true,
+          trusted: true
+        }))
+        this.dispatchEvent((0, createEvent_1.default)('focusout', {
+          relatedTarget: null
+        }, {
+          browser: true,
+          trusted: true
+        }))
+      }
     }
     exports.HTMLElementService = HTMLElementService
-  }, { './ElementService': 11 }],
-  15: [function (require, module, exports) {
+  }, { '../factories/createEvent': 4, '../functions/activeElement': 8, './ElementService': 16 }],
+  21: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.InputEventService = void 0
+    /**
+ * @file Substitute for the DOM InputEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const UIEventService_1 = require('./UIEventService')
+    /**
+ * Simulate the behaviour of the InputEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string|null} data
+ * @property {string} inputType
+ * @property {boolean} isComposing
+ */
+    class InputEventService extends UIEventService_1.UIEventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {InputEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.inputData = typeof init.data === 'string' ? init.data : null
+        this.kind = init.inputType || ''
+        this.composing = !!init.isComposing
+      }
+
+      get data () {
+        return this.inputData
+      }
+
+      get inputType () {
+        return this.kind
+      }
+
+      get isComposing () {
+        return this.composing
+      }
+    }
+    exports.InputEventService = InputEventService
+  }, { './UIEventService': 27 }],
+  22: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.KeyboardEventService = void 0
+    /**
+ * @file Substitute for the DOM KeyboardEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const UIEventService_1 = require('./UIEventService')
+    const modifierState_1 = require('../functions/modifierState')
+    /**
+ * Simulate the behaviour of the KeyboardEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string} key
+ * @property {string} code
+ * @property {number} location
+ * @property {boolean} repeat
+ * @property {boolean} isComposing
+ */
+    class KeyboardEventService extends UIEventService_1.UIEventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {KeyboardEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.keyValue = init.key || ''
+        this.keyCode = init.code || ''
+        this.keyLocation = init.location || 0
+        this.held = !!init.repeat
+        this.composing = !!init.isComposing
+        this.modifiers = (0, modifierState_1.modifierKeys)(init)
+      }
+
+      get key () {
+        return this.keyValue
+      }
+
+      get code () {
+        return this.keyCode
+      }
+
+      get location () {
+        return this.keyLocation
+      }
+
+      get repeat () {
+        return this.held
+      }
+
+      get isComposing () {
+        return this.composing
+      }
+
+      get ctrlKey () {
+        return this.modifiers.ctrlKey
+      }
+
+      get shiftKey () {
+        return this.modifiers.shiftKey
+      }
+
+      get altKey () {
+        return this.modifiers.altKey
+      }
+
+      get metaKey () {
+        return this.modifiers.metaKey
+      }
+
+      /**
+   * Whether a modifier key was held down when the event happened.
+   * @param {string} key Control, Shift, Alt or Meta
+   * @returns {boolean}
+   */
+      getModifierState (key) {
+        return (0, modifierState_1.modifierState)(this.modifiers, key)
+      }
+    }
+    exports.KeyboardEventService = KeyboardEventService
+  }, { '../functions/modifierState': 11, './UIEventService': 27 }],
+  23: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.MouseEventService = void 0
+    /**
+ * @file Substitute for the DOM MouseEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const UIEventService_1 = require('./UIEventService')
+    const modifierState_1 = require('../functions/modifierState')
+    /**
+ * Simulate the behaviour of the MouseEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {number} screenX
+ * @property {number} screenY
+ * @property {number} clientX
+ * @property {number} clientY
+ * @property {number} button
+ * @property {number} buttons
+ * @property {PseudoEventTarget|null} relatedTarget
+ */
+    class MouseEventService extends UIEventService_1.UIEventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {MouseEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.position = {
+          screenX: init.screenX || 0,
+          screenY: init.screenY || 0,
+          clientX: init.clientX || 0,
+          clientY: init.clientY || 0
+        }
+        this.modifiers = (0, modifierState_1.modifierKeys)(init)
+        this.buttonPressed = init.button || 0
+        this.buttonsDown = init.buttons || 0
+        this.related = init.relatedTarget || null
+      }
+
+      get screenX () {
+        return this.position.screenX
+      }
+
+      get screenY () {
+        return this.position.screenY
+      }
+
+      get clientX () {
+        return this.position.clientX
+      }
+
+      get clientY () {
+        return this.position.clientY
+      }
+
+      get x () {
+        return this.position.clientX
+      }
+
+      get y () {
+        return this.position.clientY
+      }
+
+      get ctrlKey () {
+        return this.modifiers.ctrlKey
+      }
+
+      get shiftKey () {
+        return this.modifiers.shiftKey
+      }
+
+      get altKey () {
+        return this.modifiers.altKey
+      }
+
+      get metaKey () {
+        return this.modifiers.metaKey
+      }
+
+      get button () {
+        return this.buttonPressed
+      }
+
+      get buttons () {
+        return this.buttonsDown
+      }
+
+      get relatedTarget () {
+        return this.related
+      }
+
+      /**
+   * Whether a modifier key was held down when the event happened.
+   * @param {string} key Control, Shift, Alt or Meta
+   * @returns {boolean}
+   */
+      getModifierState (key) {
+        return (0, modifierState_1.modifierState)(this.modifiers, key)
+      }
+    }
+    exports.MouseEventService = MouseEventService
+  }, { '../functions/modifierState': 11, './UIEventService': 27 }],
+  24: [function (require, module, exports) {
     'use strict'
 
     require('core-js/modules/esnext.iterator.constructor.js')
@@ -1424,8 +2261,8 @@
       }
     }
     exports.NamedNodeMapService = NamedNodeMapService
-  }, { 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.find.js': 132 }],
-  16: [function (require, module, exports) {
+  }, { 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.find.js': 146 }],
+  25: [function (require, module, exports) {
     'use strict'
 
     const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
@@ -1713,8 +2550,238 @@
     NodeService.DOCUMENT_TYPE_NODE = 10
     NodeService.DOCUMENT_FRAGMENT_NODE = 11
     NodeService.NOTATION_NODE = 12
-  }, { '../factories/generateNodeList': 5, './EventTargetService': 13, 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker': 24 }],
-  17: [function (require, module, exports) {
+  }, { '../factories/generateNodeList': 7, './EventTargetService': 18, 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker': 36 }],
+  26: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.PointerEventService = void 0
+    /**
+ * @file Substitute for the DOM PointerEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const MouseEventService_1 = require('./MouseEventService')
+    /**
+ * Simulate the behaviour of the PointerEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments MouseEventService
+ * @property {number} pointerId
+ * @property {number} width
+ * @property {number} height
+ * @property {number} pressure
+ * @property {string} pointerType
+ * @property {boolean} isPrimary
+ */
+    class PointerEventService extends MouseEventService_1.MouseEventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {PointerEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.pointer = {
+          pointerId: init.pointerId || 0,
+          width: typeof init.width === 'number' ? init.width : 1,
+          height: typeof init.height === 'number' ? init.height : 1,
+          pressure: init.pressure || 0,
+          pointerType: init.pointerType || '',
+          isPrimary: !!init.isPrimary
+        }
+      }
+
+      get pointerId () {
+        return this.pointer.pointerId
+      }
+
+      get width () {
+        return this.pointer.width
+      }
+
+      get height () {
+        return this.pointer.height
+      }
+
+      get pressure () {
+        return this.pointer.pressure
+      }
+
+      get pointerType () {
+        return this.pointer.pointerType
+      }
+
+      get isPrimary () {
+        return this.pointer.isPrimary
+      }
+    }
+    exports.PointerEventService = PointerEventService
+  }, { './MouseEventService': 23 }],
+  27: [function (require, module, exports) {
+    'use strict'
+
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.UIEventService = void 0
+    /**
+ * @file Substitute for the DOM UIEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+    const EventService_1 = require('./EventService')
+    /**
+ * Simulate the behaviour of the UIEvent Class when there is no DOM available: the events which come from a user
+ * interface (the mouse, the keyboard, focus and input).
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments EventService
+ * @property {number} detail
+ * @property {*} view
+ */
+    class UIEventService extends EventService_1.EventService {
+      /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {UIEventInit} [init={}] The options for the event
+   * @constructor
+   */
+      constructor (typeArg = '', init = {}) {
+        super(typeArg, init)
+        this.uiDetail = init.detail || 0
+        this.uiView = init.view || null
+      }
+
+      get detail () {
+        return this.uiDetail
+      }
+
+      get view () {
+        return this.uiView
+      }
+    }
+    exports.UIEventService = UIEventService
+  }, { './EventService': 17 }],
+  28: [function (require, module, exports) {
+    'use strict'
+
+    const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+      return mod && mod.__esModule
+        ? mod
+        : {
+            default: mod
+          }
+    }
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    })
+    exports.keyPress = exports.click = void 0
+    /**
+ * @file Simulate what a user does, with the events the browser sends for it.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module pseudoDom/simulate
+ */
+    const createEvent_1 = __importDefault(require('./factories/createEvent'))
+    const activeElement_1 = require('./functions/activeElement')
+    const send = (target, type, init) => target.dispatchEvent((0, createEvent_1.default)(type, init, {
+      browser: true,
+      trusted: true
+    }))
+    /**
+ * The nearest element (starting with the element itself) which can have the focus.
+ * @param {*} element Where to start
+ * @returns {*|null}
+ */
+    const focusableFrom = element => {
+      let current = element
+      while (current) {
+        if (current.canFocus) {
+          return current
+        }
+        current = current.parentNode
+      }
+      return null
+    }
+    /**
+ * Click an element the way a user does: pointerdown and mousedown, then the focus moves to the nearest element which
+ * can have it (or is taken away from the one which had it) unless mousedown was cancelled, then pointerup, mouseup
+ * and finally click. Every event is trusted and has the options the browser gives it. A disabled element gets nothing.
+ * @function click
+ * @param {*} element The element to click
+ * @param {Object} [init={}] Options for the events (for example clientX, clientY, shiftKey)
+ * @returns {boolean} False when the click was cancelled (or the element is disabled), so its default action did not happen
+ */
+    const click = (element, init = {}) => {
+      if (element.hasAttribute && element.hasAttribute('disabled')) {
+        return false
+      }
+      const pointer = Object.assign({
+        pointerId: 1,
+        pointerType: 'mouse',
+        isPrimary: true,
+        button: 0
+      }, init)
+      send(element, 'pointerdown', Object.assign({
+        buttons: 1
+      }, pointer))
+      if (send(element, 'mousedown', Object.assign({
+        buttons: 1,
+        detail: 1
+      }, init, {
+        button: 0
+      }))) {
+        const focusable = focusableFrom(element)
+        if (focusable) {
+          focusable.focus()
+        } else {
+          const active = (0, activeElement_1.getActiveElement)(element.getRootNode())
+          if (active) {
+            active.blur()
+          }
+        }
+      }
+      send(element, 'pointerup', Object.assign({
+        buttons: 0
+      }, pointer))
+      send(element, 'mouseup', Object.assign({
+        buttons: 0,
+        detail: 1
+      }, init, {
+        button: 0
+      }))
+      return send(element, 'click', Object.assign({
+        detail: 1
+      }, init, {
+        button: 0
+      }))
+    }
+    exports.click = click
+    /**
+ * Press and release a key on an element (the element which has the focus, or one given): keydown and then keyup.
+ * @function keyPress
+ * @param {*} element The element which gets the key
+ * @param {string} key The value of the key, such as a or Enter
+ * @param {Object} [init={}] Options for the events (for example code, shiftKey)
+ * @returns {boolean} False when keydown was cancelled, so its default action did not happen
+ */
+    const keyPress = (element, key, init = {}) => {
+      const options = Object.assign({
+        key
+      }, init)
+      const proceeded = send(element, 'keydown', options)
+      send(element, 'keyup', options)
+      return proceeded
+    }
+    exports.keyPress = keyPress
+    exports.default = {
+      click: exports.click,
+      keyPress: exports.keyPress
+    }
+  }, { './factories/createEvent': 4, './functions/activeElement': 8 }],
+  29: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -1781,8 +2848,8 @@
       head: [],
       tail: null
     })
-  }, { 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.reduce.js': 135 }],
-  18: [function (require, module, exports) {
+  }, { 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.reduce.js': 149 }],
+  30: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2006,8 +3073,8 @@
       const list = new classType(elementClass)
       return list.initialize(elementClass.fromArray(values).head)
     }
-  }, { '../../recipes/ArrayIterator': 25, './ArrayElement': 17 }],
-  19: [function (require, module, exports) {
+  }, { '../../recipes/ArrayIterator': 37, './ArrayElement': 29 }],
+  31: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2081,8 +3148,8 @@
       head: null,
       tail: null
     })
-  }, { '../linked-list/Linker': 22, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.reduce.js': 135 }],
-  20: [function (require, module, exports) {
+  }, { '../linked-list/Linker': 34, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.reduce.js': 149 }],
+  32: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2410,8 +3477,8 @@
     DoublyLinkedList.fromArray = (values = [], linkerClass = _DoubleLinker.DoubleLinker, classType = DoublyLinkedList) => {
       return _LinkedList.LinkedList.fromArray(values, linkerClass, classType)
     }
-  }, { '../../recipes/DoubleLinkerIterator': 26, '../linked-list/LinkedList': 21, './DoubleLinker': 19, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 133 }],
-  21: [function (require, module, exports) {
+  }, { '../../recipes/DoubleLinkerIterator': 38, '../linked-list/LinkedList': 33, './DoubleLinker': 31, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.for-each.js': 147 }],
+  33: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2708,8 +3775,8 @@
       const list = new classType(linkerClass)
       return list.initialize(linkerClass.fromArray(values).head)
     }
-  }, { '../../recipes/LinkerIterator': 27, '../arrayable/Arrayable': 18, './Linker': 22 }],
-  22: [function (require, module, exports) {
+  }, { '../../recipes/LinkerIterator': 39, '../arrayable/Arrayable': 30, './Linker': 34 }],
+  34: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -2794,8 +3861,8 @@
       head: null,
       tail: null
     })
-  }, { '../arrayable/ArrayElement': 17, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.reduce.js': 135 }],
-  23: [function (require, module, exports) {
+  }, { '../arrayable/ArrayElement': 29, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.reduce.js': 149 }],
+  35: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3090,8 +4157,8 @@
       const list = new classType(linkerClass)
       return list.initialize(linkerClass.fromArray(values).head)
     }
-  }, { '../../recipes/TreeLinkerIterator': 28, '../doubly-linked-list/DoublyLinkedList': 20, './TreeLinker': 24, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.for-each.js': 133 }],
-  24: [function (require, module, exports) {
+  }, { '../../recipes/TreeLinkerIterator': 40, '../doubly-linked-list/DoublyLinkedList': 32, './TreeLinker': 36, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.for-each.js': 147 }],
+  36: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3186,8 +4253,8 @@
  * @returns {{head: TreeLinker, tail: TreeLinker}}
  */
     TreeLinker.fromArray = (values = [], classType = TreeLinker) => _DoubleLinker.DoubleLinker.fromArray(values, classType)
-  }, { '../doubly-linked-list/DoubleLinker': 19, './LinkedTreeList': 23, 'core-js/modules/esnext.iterator.constructor.js': 130, 'core-js/modules/esnext.iterator.map.js': 134 }],
-  25: [function (require, module, exports) {
+  }, { '../doubly-linked-list/DoubleLinker': 31, './LinkedTreeList': 35, 'core-js/modules/esnext.iterator.constructor.js': 144, 'core-js/modules/esnext.iterator.map.js': 148 }],
+  37: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3228,7 +4295,7 @@
     }
     exports.ArrayIterator = ArrayIterator
   }, {}],
-  26: [function (require, module, exports) {
+  38: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3263,7 +4330,7 @@
     }
     exports.DoubleLinkerIterator = DoubleLinkerIterator
   }, {}],
-  27: [function (require, module, exports) {
+  39: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3298,7 +4365,7 @@
     }
     exports.LinkerIterator = LinkerIterator
   }, {}],
-  28: [function (require, module, exports) {
+  40: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3335,8 +4402,8 @@
       }
     }
     exports.TreeLinkerIterator = TreeLinkerIterator
-  }, { '../services/parseTreeNext': 29 }],
-  29: [function (require, module, exports) {
+  }, { '../services/parseTreeNext': 41 }],
+  41: [function (require, module, exports) {
     'use strict'
 
     Object.defineProperty(exports, '__esModule', {
@@ -3380,7 +4447,7 @@
     }
     exports.parseTreeNext = parseTreeNext
   }, {}],
-  30: [function (require, module, exports) {
+  42: [function (require, module, exports) {
     'use strict'
     const isCallable = require('../internals/is-callable')
     const tryToString = require('../internals/try-to-string')
@@ -3392,8 +4459,18 @@
       if (isCallable(argument)) return argument
       throw new $TypeError(tryToString(argument) + ' is not a function')
     }
-  }, { '../internals/is-callable': 74, '../internals/try-to-string': 117 }],
-  31: [function (require, module, exports) {
+  }, { '../internals/is-callable': 87, '../internals/try-to-string': 130 }],
+  43: [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': 135 }],
+  44: [function (require, module, exports) {
     'use strict'
     const isPrototypeOf = require('../internals/object-is-prototype-of')
 
@@ -3403,8 +4480,8 @@
       if (isPrototypeOf(Prototype, it)) return it
       throw new $TypeError('Incorrect invocation')
     }
-  }, { '../internals/object-is-prototype-of': 99 }],
-  32: [function (require, module, exports) {
+  }, { '../internals/object-is-prototype-of': 112 }],
+  45: [function (require, module, exports) {
     'use strict'
     const isObject = require('../internals/is-object')
 
@@ -3416,8 +4493,8 @@
       if (isObject(argument)) return argument
       throw new $TypeError($String(argument) + ' is not an object')
     }
-  }, { '../internals/is-object': 77 }],
-  33: [function (require, module, exports) {
+  }, { '../internals/is-object': 90 }],
+  46: [function (require, module, exports) {
     'use strict'
     const toIndexedObject = require('../internals/to-indexed-object')
     const toAbsoluteIndex = require('../internals/to-absolute-index')
@@ -3456,8 +4533,8 @@
       // https://tc39.es/ecma262/#sec-array.prototype.indexof
       indexOf: createMethod(false)
     }
-  }, { '../internals/length-of-array-like': 89, '../internals/to-absolute-index': 110, '../internals/to-indexed-object': 111 }],
-  34: [function (require, module, exports) {
+  }, { '../internals/length-of-array-like': 102, '../internals/to-absolute-index': 123, '../internals/to-indexed-object': 124 }],
+  47: [function (require, module, exports) {
     'use strict'
     const anObject = require('../internals/an-object')
     const iteratorClose = require('../internals/iterator-close')
@@ -3470,8 +4547,8 @@
         iteratorClose(iterator, 'throw', error)
       }
     }
-  }, { '../internals/an-object': 32, '../internals/iterator-close': 83 }],
-  35: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/iterator-close': 96 }],
+  48: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
 
@@ -3481,8 +4558,8 @@
     module.exports = function (it) {
       return stringSlice(toString(it), 8, -1)
     }
-  }, { '../internals/function-uncurry-this': 59 }],
-  36: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 72 }],
+  49: [function (require, module, exports) {
     'use strict'
     const hasOwn = require('../internals/has-own-property')
     const ownKeys = require('../internals/own-keys')
@@ -3500,8 +4577,8 @@
         }
       }
     }
-  }, { '../internals/has-own-property': 66, '../internals/object-define-property': 94, '../internals/object-get-own-property-descriptor': 95, '../internals/own-keys': 104 }],
-  37: [function (require, module, exports) {
+  }, { '../internals/has-own-property': 79, '../internals/object-define-property': 107, '../internals/object-get-own-property-descriptor': 108, '../internals/own-keys': 117 }],
+  50: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
 
@@ -3511,8 +4588,8 @@
       // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
       return Object.getPrototypeOf(new F()) !== F.prototype
     })
-  }, { '../internals/fails': 52 }],
-  38: [function (require, module, exports) {
+  }, { '../internals/fails': 65 }],
+  51: [function (require, module, exports) {
     'use strict'
     // `CreateIterResultObject` abstract operation
     // https://tc39.es/ecma262/#sec-createiterresultobject
@@ -3520,7 +4597,7 @@
       return { value, done }
     }
   }, {}],
-  39: [function (require, module, exports) {
+  52: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const definePropertyModule = require('../internals/object-define-property')
@@ -3534,8 +4611,8 @@
         object[key] = value
         return object
       }
-  }, { '../internals/create-property-descriptor': 40, '../internals/descriptors': 46, '../internals/object-define-property': 94 }],
-  40: [function (require, module, exports) {
+  }, { '../internals/create-property-descriptor': 53, '../internals/descriptors': 59, '../internals/object-define-property': 107 }],
+  53: [function (require, module, exports) {
     'use strict'
     module.exports = function (bitmap, value) {
       return {
@@ -3546,7 +4623,7 @@
       }
     }
   }, {}],
-  41: [function (require, module, exports) {
+  54: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const definePropertyModule = require('../internals/object-define-property')
@@ -3556,8 +4633,8 @@
       if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value))
       else object[key] = value
     }
-  }, { '../internals/create-property-descriptor': 40, '../internals/descriptors': 46, '../internals/object-define-property': 94 }],
-  42: [function (require, module, exports) {
+  }, { '../internals/create-property-descriptor': 53, '../internals/descriptors': 59, '../internals/object-define-property': 107 }],
+  55: [function (require, module, exports) {
     'use strict'
     const makeBuiltIn = require('../internals/make-built-in')
     const defineProperty = require('../internals/object-define-property')
@@ -3567,8 +4644,8 @@
       if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true })
       return defineProperty.f(target, name, descriptor)
     }
-  }, { '../internals/make-built-in': 90, '../internals/object-define-property': 94 }],
-  43: [function (require, module, exports) {
+  }, { '../internals/make-built-in': 103, '../internals/object-define-property': 107 }],
+  56: [function (require, module, exports) {
     'use strict'
     const isCallable = require('../internals/is-callable')
     const definePropertyModule = require('../internals/object-define-property')
@@ -3599,8 +4676,8 @@
         }
       } return O
     }
-  }, { '../internals/define-global-property': 45, '../internals/is-callable': 74, '../internals/make-built-in': 90, '../internals/object-define-property': 94 }],
-  44: [function (require, module, exports) {
+  }, { '../internals/define-global-property': 58, '../internals/is-callable': 87, '../internals/make-built-in': 103, '../internals/object-define-property': 107 }],
+  57: [function (require, module, exports) {
     'use strict'
     const defineBuiltIn = require('../internals/define-built-in')
 
@@ -3608,8 +4685,8 @@
       for (const key in src) defineBuiltIn(target, key, src[key], options)
       return target
     }
-  }, { '../internals/define-built-in': 43 }],
-  45: [function (require, module, exports) {
+  }, { '../internals/define-built-in': 56 }],
+  58: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
 
@@ -3623,8 +4700,8 @@
         globalThis[key] = value
       } return value
     }
-  }, { '../internals/global-this': 65 }],
-  46: [function (require, module, exports) {
+  }, { '../internals/global-this': 78 }],
+  59: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
 
@@ -3633,8 +4710,8 @@
       // eslint-disable-next-line es/no-object-defineproperty -- required for testing
       return Object.defineProperty({}, 1, { get: function () { return 7 } })[1] !== 7
     })
-  }, { '../internals/fails': 52 }],
-  47: [function (require, module, exports) {
+  }, { '../internals/fails': 65 }],
+  60: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const isObject = require('../internals/is-object')
@@ -3646,8 +4723,8 @@
     module.exports = function (it) {
       return EXISTS ? document.createElement(it) : {}
     }
-  }, { '../internals/global-this': 65, '../internals/is-object': 77 }],
-  48: [function (require, module, exports) {
+  }, { '../internals/global-this': 78, '../internals/is-object': 90 }],
+  61: [function (require, module, exports) {
     'use strict'
     // IE8- don't enum bug keys
     module.exports = [
@@ -3660,7 +4737,7 @@
       'valueOf'
     ]
   }, {}],
-  49: [function (require, module, exports) {
+  62: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
 
@@ -3668,8 +4745,8 @@
     const userAgent = navigator && navigator.userAgent
 
     module.exports = userAgent ? String(userAgent) : ''
-  }, { '../internals/global-this': 65 }],
-  50: [function (require, module, exports) {
+  }, { '../internals/global-this': 78 }],
+  63: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const userAgent = require('../internals/environment-user-agent')
@@ -3698,8 +4775,8 @@
     }
 
     module.exports = version
-  }, { '../internals/environment-user-agent': 49, '../internals/global-this': 65 }],
-  51: [function (require, module, exports) {
+  }, { '../internals/environment-user-agent': 62, '../internals/global-this': 78 }],
+  64: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f
@@ -3757,8 +4834,8 @@
         }
       }
     }
-  }, { '../internals/copy-constructor-properties': 36, '../internals/create-non-enumerable-property': 39, '../internals/define-built-in': 43, '../internals/define-global-property': 45, '../internals/global-this': 65, '../internals/is-forced': 75, '../internals/object-get-own-property-descriptor': 95 }],
-  52: [function (require, module, exports) {
+  }, { '../internals/copy-constructor-properties': 49, '../internals/create-non-enumerable-property': 52, '../internals/define-built-in': 56, '../internals/define-global-property': 58, '../internals/global-this': 78, '../internals/is-forced': 88, '../internals/object-get-own-property-descriptor': 108 }],
+  65: [function (require, module, exports) {
     'use strict'
     module.exports = function (exec) {
       try {
@@ -3768,7 +4845,7 @@
       }
     }
   }, {}],
-  53: [function (require, module, exports) {
+  66: [function (require, module, exports) {
     'use strict'
     const NATIVE_BIND = require('../internals/function-bind-native')
 
@@ -3782,8 +4859,8 @@
       : function () {
         return call.apply(apply, arguments)
       })
-  }, { '../internals/function-bind-native': 55 }],
-  54: [function (require, module, exports) {
+  }, { '../internals/function-bind-native': 68 }],
+  67: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this-clause')
     const aCallable = require('../internals/a-callable')
@@ -3798,8 +4875,8 @@
         return fn.apply(that, arguments)
       }
     }
-  }, { '../internals/a-callable': 30, '../internals/function-bind-native': 55, '../internals/function-uncurry-this-clause': 58 }],
-  55: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/function-bind-native': 68, '../internals/function-uncurry-this-clause': 71 }],
+  68: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
 
@@ -3809,8 +4886,8 @@
       // eslint-disable-next-line no-prototype-builtins -- safe
       return typeof test !== 'function' || test.hasOwnProperty('prototype')
     })
-  }, { '../internals/fails': 52 }],
-  56: [function (require, module, exports) {
+  }, { '../internals/fails': 65 }],
+  69: [function (require, module, exports) {
     'use strict'
     const NATIVE_BIND = require('../internals/function-bind-native')
 
@@ -3821,8 +4898,8 @@
       : function () {
         return call.apply(call, arguments)
       }
-  }, { '../internals/function-bind-native': 55 }],
-  57: [function (require, module, exports) {
+  }, { '../internals/function-bind-native': 68 }],
+  70: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const hasOwn = require('../internals/has-own-property')
@@ -3841,8 +4918,8 @@
       PROPER,
       CONFIGURABLE
     }
-  }, { '../internals/descriptors': 46, '../internals/has-own-property': 66 }],
-  58: [function (require, module, exports) {
+  }, { '../internals/descriptors': 59, '../internals/has-own-property': 79 }],
+  71: [function (require, module, exports) {
     'use strict'
     const classofRaw = require('../internals/classof-raw')
     const uncurryThis = require('../internals/function-uncurry-this')
@@ -3853,8 +4930,8 @@
       //   https://github.com/zloirock/core-js/issues/1130
       if (classofRaw(fn) === 'Function') return uncurryThis(fn)
     }
-  }, { '../internals/classof-raw': 35, '../internals/function-uncurry-this': 59 }],
-  59: [function (require, module, exports) {
+  }, { '../internals/classof-raw': 48, '../internals/function-uncurry-this': 72 }],
+  72: [function (require, module, exports) {
     'use strict'
     const NATIVE_BIND = require('../internals/function-bind-native')
 
@@ -3870,8 +4947,8 @@
           return call.apply(fn, arguments)
         }
       }
-  }, { '../internals/function-bind-native': 55 }],
-  60: [function (require, module, exports) {
+  }, { '../internals/function-bind-native': 68 }],
+  73: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const isCallable = require('../internals/is-callable')
@@ -3883,8 +4960,8 @@
     module.exports = function (namespace, method) {
       return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method]
     }
-  }, { '../internals/global-this': 65, '../internals/is-callable': 74 }],
-  61: [function (require, module, exports) {
+  }, { '../internals/global-this': 78, '../internals/is-callable': 87 }],
+  74: [function (require, module, exports) {
     'use strict'
     // `GetIteratorDirect(obj)` abstract operation
     // https://tc39.es/ecma262/#sec-getiteratordirect
@@ -3896,7 +4973,7 @@
       }
     }
   }, {}],
-  62: [function (require, module, exports) {
+  75: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const isCallable = require('../internals/is-callable')
@@ -3911,8 +4988,8 @@
       if (isCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument))
       throw new $TypeError(tryToString(argument) + ' is not iterable')
     }
-  }, { '../internals/an-object': 32, '../internals/function-call': 56, '../internals/get-iterator-method-internal': 63, '../internals/is-callable': 74, '../internals/try-to-string': 117 }],
-  63: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/function-call': 69, '../internals/get-iterator-method-internal': 76, '../internals/is-callable': 87, '../internals/try-to-string': 130 }],
+  76: [function (require, module, exports) {
     'use strict'
     const classof = require('../internals/classof-raw')
     const isNullOrUndefined = require('../internals/is-null-or-undefined')
@@ -3929,8 +5006,8 @@
     (classof(it) === 'Arguments' ? ArrayPrototype[ITERATOR] : undefined)
       }
     }
-  }, { '../internals/classof-raw': 35, '../internals/get-method': 64, '../internals/is-null-or-undefined': 76, '../internals/well-known-symbol': 122 }],
-  64: [function (require, module, exports) {
+  }, { '../internals/classof-raw': 48, '../internals/get-method': 77, '../internals/is-null-or-undefined': 89, '../internals/well-known-symbol': 136 }],
+  77: [function (require, module, exports) {
     'use strict'
     const aCallable = require('../internals/a-callable')
     const isNullOrUndefined = require('../internals/is-null-or-undefined')
@@ -3941,8 +5018,8 @@
       const func = V[P]
       return isNullOrUndefined(func) ? undefined : aCallable(func)
     }
-  }, { '../internals/a-callable': 30, '../internals/is-null-or-undefined': 76 }],
-  65: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/is-null-or-undefined': 89 }],
+  78: [function (require, module, exports) {
     (function (global) {
       (function () {
         'use strict'
@@ -3964,7 +5041,7 @@
       }).call(this)
     }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})
   }, {}],
-  66: [function (require, module, exports) {
+  79: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const toObject = require('../internals/to-object')
@@ -3977,18 +5054,18 @@
     module.exports = Object.hasOwn || function hasOwn (it, key) {
       return hasOwnProperty(toObject(it), key)
     }
-  }, { '../internals/function-uncurry-this': 59, '../internals/to-object': 114 }],
-  67: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 72, '../internals/to-object': 127 }],
+  80: [function (require, module, exports) {
     'use strict'
     module.exports = {}
   }, {}],
-  68: [function (require, module, exports) {
+  81: [function (require, module, exports) {
     'use strict'
     const getBuiltIn = require('../internals/get-built-in')
 
     module.exports = getBuiltIn('document', 'documentElement')
-  }, { '../internals/get-built-in': 60 }],
-  69: [function (require, module, exports) {
+  }, { '../internals/get-built-in': 73 }],
+  82: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const fails = require('../internals/fails')
@@ -4001,8 +5078,8 @@
         get: function () { return 7 }
       }).a !== 7
     })
-  }, { '../internals/descriptors': 46, '../internals/document-create-element': 47, '../internals/fails': 52 }],
-  70: [function (require, module, exports) {
+  }, { '../internals/descriptors': 59, '../internals/document-create-element': 60, '../internals/fails': 65 }],
+  83: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const fails = require('../internals/fails')
@@ -4019,8 +5096,8 @@
     }) ? function (it) {
         return classof(it) === 'String' ? split(it, '') : $Object(it)
       } : $Object
-  }, { '../internals/classof-raw': 35, '../internals/fails': 52, '../internals/function-uncurry-this': 59 }],
-  71: [function (require, module, exports) {
+  }, { '../internals/classof-raw': 48, '../internals/fails': 65, '../internals/function-uncurry-this': 72 }],
+  84: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const isCallable = require('../internals/is-callable')
@@ -4036,8 +5113,8 @@
     }
 
     module.exports = store.inspectSource
-  }, { '../internals/function-uncurry-this': 59, '../internals/is-callable': 74, '../internals/shared-store': 107 }],
-  72: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 72, '../internals/is-callable': 87, '../internals/shared-store': 120 }],
+  85: [function (require, module, exports) {
     'use strict'
     const NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection')
     const globalThis = require('../internals/global-this')
@@ -4109,8 +5186,8 @@
       enforce,
       getterFor
     }
-  }, { '../internals/create-non-enumerable-property': 39, '../internals/global-this': 65, '../internals/has-own-property': 66, '../internals/hidden-keys': 67, '../internals/is-object': 77, '../internals/shared-key': 106, '../internals/shared-store': 107, '../internals/weak-map-basic-detection': 121 }],
-  73: [function (require, module, exports) {
+  }, { '../internals/create-non-enumerable-property': 52, '../internals/global-this': 78, '../internals/has-own-property': 79, '../internals/hidden-keys': 80, '../internals/is-object': 90, '../internals/shared-key': 119, '../internals/shared-store': 120, '../internals/weak-map-basic-detection': 134 }],
+  86: [function (require, module, exports) {
     'use strict'
     const wellKnownSymbol = require('../internals/well-known-symbol')
     const Iterators = require('../internals/iterators')
@@ -4122,8 +5199,8 @@
     module.exports = function (it) {
       return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it)
     }
-  }, { '../internals/iterators': 88, '../internals/well-known-symbol': 122 }],
-  74: [function (require, module, exports) {
+  }, { '../internals/iterators': 101, '../internals/well-known-symbol': 136 }],
+  87: [function (require, module, exports) {
     'use strict'
     // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
     const documentAll = typeof document === 'object' && document.all
@@ -4139,7 +5216,7 @@
         return typeof argument === 'function'
       }
   }, {}],
-  75: [function (require, module, exports) {
+  88: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
     const isCallable = require('../internals/is-callable')
@@ -4166,8 +5243,8 @@
     var POLYFILL = isForced.POLYFILL = 'P'
 
     module.exports = isForced
-  }, { '../internals/fails': 52, '../internals/is-callable': 74 }],
-  76: [function (require, module, exports) {
+  }, { '../internals/fails': 65, '../internals/is-callable': 87 }],
+  89: [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
@@ -4175,19 +5252,19 @@
       return it === null || it === undefined
     }
   }, {}],
-  77: [function (require, module, exports) {
+  90: [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': 74 }],
-  78: [function (require, module, exports) {
+  }, { '../internals/is-callable': 87 }],
+  91: [function (require, module, exports) {
     'use strict'
     module.exports = false
   }, {}],
-  79: [function (require, module, exports) {
+  92: [function (require, module, exports) {
     'use strict'
     const getBuiltIn = require('../internals/get-built-in')
     const isCallable = require('../internals/is-callable')
@@ -4204,8 +5281,8 @@
         const $Symbol = getBuiltIn('Symbol')
         return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it))
       }
-  }, { '../internals/get-built-in': 60, '../internals/is-callable': 74, '../internals/object-is-prototype-of': 99, '../internals/use-symbol-as-uid': 119 }],
-  80: [function (require, module, exports) {
+  }, { '../internals/get-built-in': 73, '../internals/is-callable': 87, '../internals/object-is-prototype-of': 112, '../internals/use-symbol-as-uid': 132 }],
+  93: [function (require, module, exports) {
     'use strict'
     const bind = require('../internals/function-bind-context')
     const call = require('../internals/function-call')
@@ -4280,8 +5357,8 @@
         if (typeof result === 'object' && result && isPrototypeOf(ResultPrototype, result)) return result
       } return new Result(false)
     }
-  }, { '../internals/an-object': 32, '../internals/function-bind-context': 54, '../internals/function-call': 56, '../internals/get-iterator-internal': 62, '../internals/get-iterator-method-internal': 63, '../internals/is-array-iterator-method': 73, '../internals/iterator-close': 83, '../internals/length-of-array-like': 89, '../internals/object-is-prototype-of': 99, '../internals/try-to-string': 117 }],
-  81: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/function-bind-context': 67, '../internals/function-call': 69, '../internals/get-iterator-internal': 75, '../internals/get-iterator-method-internal': 76, '../internals/is-array-iterator-method': 86, '../internals/iterator-close': 96, '../internals/length-of-array-like': 102, '../internals/object-is-prototype-of': 112, '../internals/try-to-string': 130 }],
+  94: [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) {
@@ -4289,7 +5366,7 @@
     state.iterables = state.iters = state.openIters = state.padding = state.finishResults = state.buffer = null
     }
   }, {}],
-  82: [function (require, module, exports) {
+  95: [function (require, module, exports) {
     'use strict'
     const iteratorClose = require('../internals/iterator-close')
 
@@ -4306,8 +5383,8 @@
       if (kind === 'throw') throw value
       return value
     }
-  }, { '../internals/iterator-close': 83 }],
-  83: [function (require, module, exports) {
+  }, { '../internals/iterator-close': 96 }],
+  96: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const anObject = require('../internals/an-object')
@@ -4332,8 +5409,8 @@
       anObject(innerResult)
       return value
     }
-  }, { '../internals/an-object': 32, '../internals/function-call': 56, '../internals/get-method': 64 }],
-  84: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/function-call': 69, '../internals/get-method': 77 }],
+  97: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const create = require('../internals/object-create')
@@ -4433,8 +5510,8 @@
 
       return IteratorProxy
     }
-  }, { '../internals/create-iter-result-object': 38, '../internals/create-non-enumerable-property': 39, '../internals/define-built-ins': 44, '../internals/function-call': 56, '../internals/get-method': 64, '../internals/internal-state': 72, '../internals/iterator-cleanup-state': 81, '../internals/iterator-close': 83, '../internals/iterator-close-all': 82, '../internals/iterators-core': 87, '../internals/object-create': 92, '../internals/well-known-symbol': 122 }],
-  85: [function (require, module, exports) {
+  }, { '../internals/create-iter-result-object': 51, '../internals/create-non-enumerable-property': 52, '../internals/define-built-ins': 57, '../internals/function-call': 69, '../internals/get-method': 77, '../internals/internal-state': 85, '../internals/iterator-cleanup-state': 94, '../internals/iterator-close': 96, '../internals/iterator-close-all': 95, '../internals/iterators-core': 100, '../internals/object-create': 105, '../internals/well-known-symbol': 136 }],
+  98: [function (require, module, exports) {
     'use strict'
     // Should throw an error on invalid iterator
     // https://issues.chromium.org/issues/336839115
@@ -4450,7 +5527,7 @@
       }
     }
   }, {}],
-  86: [function (require, module, exports) {
+  99: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
 
@@ -4476,8 +5553,8 @@
 
       if (!CLOSED) return method
     }
-  }, { '../internals/global-this': 65 }],
-  87: [function (require, module, exports) {
+  }, { '../internals/global-this': 78 }],
+  100: [function (require, module, exports) {
     'use strict'
     const fails = require('../internals/fails')
     const isCallable = require('../internals/is-callable')
@@ -4527,12 +5604,12 @@
       IteratorPrototype,
       BUGGY_SAFARI_ITERATORS
     }
-  }, { '../internals/define-built-in': 43, '../internals/fails': 52, '../internals/is-callable': 74, '../internals/is-object': 77, '../internals/is-pure': 78, '../internals/object-create': 92, '../internals/object-get-prototype-of': 98, '../internals/well-known-symbol': 122 }],
-  88: [function (require, module, exports) {
+  }, { '../internals/define-built-in': 56, '../internals/fails': 65, '../internals/is-callable': 87, '../internals/is-object': 90, '../internals/is-pure': 91, '../internals/object-create': 105, '../internals/object-get-prototype-of': 111, '../internals/well-known-symbol': 136 }],
+  101: [function (require, module, exports) {
     'use strict'
     module.exports = Object.create ? Object.create(null) : {}
   }, {}],
-  89: [function (require, module, exports) {
+  102: [function (require, module, exports) {
     'use strict'
     const toLength = require('../internals/to-length')
 
@@ -4541,8 +5618,8 @@
     module.exports = function (obj) {
       return toLength(obj.length)
     }
-  }, { '../internals/to-length': 113 }],
-  90: [function (require, module, exports) {
+  }, { '../internals/to-length': 126 }],
+  103: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const fails = require('../internals/fails')
@@ -4598,8 +5675,8 @@
     Function.prototype.toString = makeBuiltIn(function toString () {
       return isCallable(this) && getInternalState(this).source || inspectSource(this)
     }, 'toString')
-  }, { '../internals/descriptors': 46, '../internals/fails': 52, '../internals/function-name': 57, '../internals/function-uncurry-this': 59, '../internals/has-own-property': 66, '../internals/inspect-source': 71, '../internals/internal-state': 72, '../internals/is-callable': 74 }],
-  91: [function (require, module, exports) {
+  }, { '../internals/descriptors': 59, '../internals/fails': 65, '../internals/function-name': 70, '../internals/function-uncurry-this': 72, '../internals/has-own-property': 79, '../internals/inspect-source': 84, '../internals/internal-state': 85, '../internals/is-callable': 87 }],
+  104: [function (require, module, exports) {
     'use strict'
     const ceil = Math.ceil
     const floor = Math.floor
@@ -4612,7 +5689,7 @@
       return (n > 0 ? floor : ceil)(n)
     }
   }, {}],
-  92: [function (require, module, exports) {
+  105: [function (require, module, exports) {
     'use strict'
     /* global ActiveXObject -- old IE, WSH */
     const anObject = require('../internals/an-object')
@@ -4698,8 +5775,8 @@
       } else result = NullProtoObject()
       return Properties === undefined ? result : definePropertiesModule.f(result, Properties)
     }
-  }, { '../internals/an-object': 32, '../internals/document-create-element': 47, '../internals/enum-bug-keys': 48, '../internals/hidden-keys': 67, '../internals/html': 68, '../internals/object-define-properties': 93, '../internals/shared-key': 106 }],
-  93: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/document-create-element': 60, '../internals/enum-bug-keys': 61, '../internals/hidden-keys': 80, '../internals/html': 81, '../internals/object-define-properties': 106, '../internals/shared-key': 119 }],
+  106: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug')
@@ -4723,8 +5800,8 @@
         while (length > index) definePropertyModule.f(O, key = keys[index++], props[key])
         return O
       }
-  }, { '../internals/an-object': 32, '../internals/descriptors': 46, '../internals/object-define-property': 94, '../internals/object-keys': 101, '../internals/to-indexed-object': 111, '../internals/v8-prototype-define-bug': 120 }],
-  94: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/descriptors': 59, '../internals/object-define-property': 107, '../internals/object-keys': 114, '../internals/to-indexed-object': 124, '../internals/v8-prototype-define-bug': 133 }],
+  107: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const IE8_DOM_DEFINE = require('../internals/ie8-dom-define')
@@ -4773,8 +5850,8 @@
       if ('value' in Attributes) O[P] = Attributes.value
       return O
     }
-  }, { '../internals/an-object': 32, '../internals/descriptors': 46, '../internals/ie8-dom-define': 69, '../internals/to-property-key': 116, '../internals/v8-prototype-define-bug': 120 }],
-  95: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/descriptors': 59, '../internals/ie8-dom-define': 82, '../internals/to-property-key': 129, '../internals/v8-prototype-define-bug': 133 }],
+  108: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const call = require('../internals/function-call')
@@ -4800,8 +5877,8 @@
       }
       if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P])
     }
-  }, { '../internals/create-property-descriptor': 40, '../internals/descriptors': 46, '../internals/function-call': 56, '../internals/has-own-property': 66, '../internals/ie8-dom-define': 69, '../internals/object-property-is-enumerable': 102, '../internals/to-indexed-object': 111, '../internals/to-property-key': 116 }],
-  96: [function (require, module, exports) {
+  }, { '../internals/create-property-descriptor': 53, '../internals/descriptors': 59, '../internals/function-call': 69, '../internals/has-own-property': 79, '../internals/ie8-dom-define': 82, '../internals/object-property-is-enumerable': 115, '../internals/to-indexed-object': 124, '../internals/to-property-key': 129 }],
+  109: [function (require, module, exports) {
     'use strict'
     const internalObjectKeys = require('../internals/object-keys-internal')
     const enumBugKeys = require('../internals/enum-bug-keys')
@@ -4814,13 +5891,13 @@
     exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames (O) {
       return internalObjectKeys(O, hiddenKeys)
     }
-  }, { '../internals/enum-bug-keys': 48, '../internals/object-keys-internal': 100 }],
-  97: [function (require, module, exports) {
+  }, { '../internals/enum-bug-keys': 61, '../internals/object-keys-internal': 113 }],
+  110: [function (require, module, exports) {
     'use strict'
     // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
     exports.f = Object.getOwnPropertySymbols
   }, {}],
-  98: [function (require, module, exports) {
+  111: [function (require, module, exports) {
     'use strict'
     const hasOwn = require('../internals/has-own-property')
     const isCallable = require('../internals/is-callable')
@@ -4845,14 +5922,14 @@
           return constructor.prototype
         } return object instanceof $Object ? ObjectPrototype : null
       }
-  }, { '../internals/correct-prototype-getter': 37, '../internals/has-own-property': 66, '../internals/is-callable': 74, '../internals/shared-key': 106, '../internals/to-object': 114 }],
-  99: [function (require, module, exports) {
+  }, { '../internals/correct-prototype-getter': 50, '../internals/has-own-property': 79, '../internals/is-callable': 87, '../internals/shared-key': 119, '../internals/to-object': 127 }],
+  112: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
 
     module.exports = uncurryThis({}.isPrototypeOf)
-  }, { '../internals/function-uncurry-this': 59 }],
-  100: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 72 }],
+  113: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
     const hasOwn = require('../internals/has-own-property')
@@ -4876,8 +5953,8 @@
       }
       return result
     }
-  }, { '../internals/array-includes': 33, '../internals/function-uncurry-this': 59, '../internals/has-own-property': 66, '../internals/hidden-keys': 67, '../internals/to-indexed-object': 111 }],
-  101: [function (require, module, exports) {
+  }, { '../internals/array-includes': 46, '../internals/function-uncurry-this': 72, '../internals/has-own-property': 79, '../internals/hidden-keys': 80, '../internals/to-indexed-object': 124 }],
+  114: [function (require, module, exports) {
     'use strict'
     const internalObjectKeys = require('../internals/object-keys-internal')
     const enumBugKeys = require('../internals/enum-bug-keys')
@@ -4888,8 +5965,8 @@
     module.exports = Object.keys || function keys (O) {
       return internalObjectKeys(O, enumBugKeys)
     }
-  }, { '../internals/enum-bug-keys': 48, '../internals/object-keys-internal': 100 }],
-  102: [function (require, module, exports) {
+  }, { '../internals/enum-bug-keys': 61, '../internals/object-keys-internal': 113 }],
+  115: [function (require, module, exports) {
     'use strict'
     const $propertyIsEnumerable = {}.propertyIsEnumerable
     // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -4907,7 +5984,7 @@
       }
       : $propertyIsEnumerable
   }, {}],
-  103: [function (require, module, exports) {
+  116: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const isCallable = require('../internals/is-callable')
@@ -4924,8 +6001,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': 56, '../internals/is-callable': 74, '../internals/is-object': 77 }],
-  104: [function (require, module, exports) {
+  }, { '../internals/function-call': 69, '../internals/is-callable': 87, '../internals/is-object': 90 }],
+  117: [function (require, module, exports) {
     'use strict'
     const getBuiltIn = require('../internals/get-built-in')
     const uncurryThis = require('../internals/function-uncurry-this')
@@ -4941,8 +6018,8 @@
       const getOwnPropertySymbols = getOwnPropertySymbolsModule.f
       return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys
     }
-  }, { '../internals/an-object': 32, '../internals/function-uncurry-this': 59, '../internals/get-built-in': 60, '../internals/object-get-own-property-names': 96, '../internals/object-get-own-property-symbols': 97 }],
-  105: [function (require, module, exports) {
+  }, { '../internals/an-object': 45, '../internals/function-uncurry-this': 72, '../internals/get-built-in': 73, '../internals/object-get-own-property-names': 109, '../internals/object-get-own-property-symbols': 110 }],
+  118: [function (require, module, exports) {
     'use strict'
     const isNullOrUndefined = require('../internals/is-null-or-undefined')
 
@@ -4954,8 +6031,8 @@
       if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it)
       return it
     }
-  }, { '../internals/is-null-or-undefined': 76 }],
-  106: [function (require, module, exports) {
+  }, { '../internals/is-null-or-undefined': 89 }],
+  119: [function (require, module, exports) {
     'use strict'
     const shared = require('../internals/shared')
     const uid = require('../internals/uid')
@@ -4965,8 +6042,8 @@
     module.exports = function (key) {
       return keys[key] || (keys[key] = uid(key))
     }
-  }, { '../internals/shared': 108, '../internals/uid': 118 }],
-  107: [function (require, module, exports) {
+  }, { '../internals/shared': 121, '../internals/uid': 131 }],
+  120: [function (require, module, exports) {
     'use strict'
     const IS_PURE = require('../internals/is-pure')
     const globalThis = require('../internals/global-this')
@@ -4982,8 +6059,8 @@
       license: 'https://github.com/zloirock/core-js/blob/v3.50.0/LICENSE',
       source: 'https://github.com/zloirock/core-js'
     })
-  }, { '../internals/define-global-property': 45, '../internals/global-this': 65, '../internals/is-pure': 78 }],
-  108: [function (require, module, exports) {
+  }, { '../internals/define-global-property': 58, '../internals/global-this': 78, '../internals/is-pure': 91 }],
+  121: [function (require, module, exports) {
     'use strict'
     const store = require('../internals/shared-store')
     // eslint-disable-next-line es/no-object-create -- safe
@@ -4992,8 +6069,8 @@
     module.exports = function (key, value) {
       return store[key] || (store[key] = value || create(null))
     }
-  }, { '../internals/shared-store': 107 }],
-  109: [function (require, module, exports) {
+  }, { '../internals/shared-store': 120 }],
+  122: [function (require, module, exports) {
     'use strict'
     /* eslint-disable es/no-symbol -- required for testing */
     const V8_VERSION = require('../internals/environment-v8-version')
@@ -5013,8 +6090,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': 50, '../internals/fails': 52, '../internals/global-this': 65 }],
-  110: [function (require, module, exports) {
+  }, { '../internals/environment-v8-version': 63, '../internals/fails': 65, '../internals/global-this': 78 }],
+  123: [function (require, module, exports) {
     'use strict'
     const toIntegerOrInfinity = require('../internals/to-integer-or-infinity')
 
@@ -5028,8 +6105,8 @@
       const integer = toIntegerOrInfinity(index)
       return integer < 0 ? max(integer + length, 0) : min(integer, length)
     }
-  }, { '../internals/to-integer-or-infinity': 112 }],
-  111: [function (require, module, exports) {
+  }, { '../internals/to-integer-or-infinity': 125 }],
+  124: [function (require, module, exports) {
     'use strict'
     // toObject with fallback for non-array-like ES3 strings
     const IndexedObject = require('../internals/indexed-object')
@@ -5038,8 +6115,8 @@
     module.exports = function (it) {
       return IndexedObject(requireObjectCoercible(it))
     }
-  }, { '../internals/indexed-object': 70, '../internals/require-object-coercible': 105 }],
-  112: [function (require, module, exports) {
+  }, { '../internals/indexed-object': 83, '../internals/require-object-coercible': 118 }],
+  125: [function (require, module, exports) {
     'use strict'
     const trunc = require('../internals/math-trunc')
 
@@ -5050,8 +6127,8 @@
       // eslint-disable-next-line no-self-compare -- NaN check
       return number !== number || number === 0 ? 0 : trunc(number)
     }
-  }, { '../internals/math-trunc': 91 }],
-  113: [function (require, module, exports) {
+  }, { '../internals/math-trunc': 104 }],
+  126: [function (require, module, exports) {
     'use strict'
     const toIntegerOrInfinity = require('../internals/to-integer-or-infinity')
 
@@ -5063,8 +6140,8 @@
       const len = toIntegerOrInfinity(argument)
       return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0 // 2 ** 53 - 1 == 9007199254740991
     }
-  }, { '../internals/to-integer-or-infinity': 112 }],
-  114: [function (require, module, exports) {
+  }, { '../internals/to-integer-or-infinity': 125 }],
+  127: [function (require, module, exports) {
     'use strict'
     const requireObjectCoercible = require('../internals/require-object-coercible')
 
@@ -5075,8 +6152,8 @@
     module.exports = function (argument) {
       return $Object(requireObjectCoercible(argument))
     }
-  }, { '../internals/require-object-coercible': 105 }],
-  115: [function (require, module, exports) {
+  }, { '../internals/require-object-coercible': 118 }],
+  128: [function (require, module, exports) {
     'use strict'
     const call = require('../internals/function-call')
     const isObject = require('../internals/is-object')
@@ -5103,8 +6180,8 @@
       if (pref === undefined) pref = 'number'
       return ordinaryToPrimitive(input, pref)
     }
-  }, { '../internals/function-call': 56, '../internals/get-method': 64, '../internals/is-object': 77, '../internals/is-symbol': 79, '../internals/ordinary-to-primitive': 103, '../internals/well-known-symbol': 122 }],
-  116: [function (require, module, exports) {
+  }, { '../internals/function-call': 69, '../internals/get-method': 77, '../internals/is-object': 90, '../internals/is-symbol': 92, '../internals/ordinary-to-primitive': 116, '../internals/well-known-symbol': 136 }],
+  129: [function (require, module, exports) {
     'use strict'
     const toPrimitive = require('../internals/to-primitive')
     const isSymbol = require('../internals/is-symbol')
@@ -5115,8 +6192,8 @@
       const key = toPrimitive(argument, 'string')
       return isSymbol(key) ? key : key + ''
     }
-  }, { '../internals/is-symbol': 79, '../internals/to-primitive': 115 }],
-  117: [function (require, module, exports) {
+  }, { '../internals/is-symbol': 92, '../internals/to-primitive': 128 }],
+  130: [function (require, module, exports) {
     'use strict'
     const $String = String
 
@@ -5128,7 +6205,7 @@
       }
     }
   }, {}],
-  118: [function (require, module, exports) {
+  131: [function (require, module, exports) {
     'use strict'
     const uncurryThis = require('../internals/function-uncurry-this')
 
@@ -5139,8 +6216,8 @@
     module.exports = function (key) {
       return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36)
     }
-  }, { '../internals/function-uncurry-this': 59 }],
-  119: [function (require, module, exports) {
+  }, { '../internals/function-uncurry-this': 72 }],
+  132: [function (require, module, exports) {
     'use strict'
     /* eslint-disable es/no-symbol -- required for testing */
     const NATIVE_SYMBOL = require('../internals/symbol-constructor-detection')
@@ -5148,8 +6225,8 @@
     module.exports = NATIVE_SYMBOL &&
   !Symbol.sham &&
   typeof Symbol.iterator === 'symbol'
-  }, { '../internals/symbol-constructor-detection': 109 }],
-  120: [function (require, module, exports) {
+  }, { '../internals/symbol-constructor-detection': 122 }],
+  133: [function (require, module, exports) {
     'use strict'
     const DESCRIPTORS = require('../internals/descriptors')
     const fails = require('../internals/fails')
@@ -5163,8 +6240,8 @@
         writable: false
       }).prototype !== 42
     })
-  }, { '../internals/descriptors': 46, '../internals/fails': 52 }],
-  121: [function (require, module, exports) {
+  }, { '../internals/descriptors': 59, '../internals/fails': 65 }],
+  134: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const isCallable = require('../internals/is-callable')
@@ -5172,8 +6249,24 @@
     const WeakMap = globalThis.WeakMap
 
     module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap))
-  }, { '../internals/global-this': 65, '../internals/is-callable': 74 }],
-  122: [function (require, module, exports) {
+  }, { '../internals/global-this': 78, '../internals/is-callable': 87 }],
+  135: [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': 72 }],
+  136: [function (require, module, exports) {
     'use strict'
     const globalThis = require('../internals/global-this')
     const shared = require('../internals/shared')
@@ -5193,8 +6286,8 @@
           : createWellKnownSymbol('Symbol.' + name)
       } return WellKnownSymbolsStore[name]
     }
-  }, { '../internals/global-this': 65, '../internals/has-own-property': 66, '../internals/shared': 108, '../internals/symbol-constructor-detection': 109, '../internals/uid': 118, '../internals/use-symbol-as-uid': 119 }],
-  123: [function (require, module, exports) {
+  }, { '../internals/global-this': 78, '../internals/has-own-property': 79, '../internals/shared': 121, '../internals/symbol-constructor-detection': 122, '../internals/uid': 131, '../internals/use-symbol-as-uid': 132 }],
+  137: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const globalThis = require('../internals/global-this')
@@ -5260,8 +6353,8 @@
     $({ global: true, constructor: true, forced: FORCED }, {
       Iterator: IteratorConstructor
     })
-  }, { '../internals/an-instance': 31, '../internals/an-object': 32, '../internals/create-property': 41, '../internals/define-built-in-accessor': 42, '../internals/descriptors': 46, '../internals/export': 51, '../internals/fails': 52, '../internals/global-this': 65, '../internals/has-own-property': 66, '../internals/is-callable': 74, '../internals/is-pure': 78, '../internals/iterators-core': 87, '../internals/object-get-prototype-of': 98, '../internals/well-known-symbol': 122 }],
-  124: [function (require, module, exports) {
+  }, { '../internals/an-instance': 44, '../internals/an-object': 45, '../internals/create-property': 54, '../internals/define-built-in-accessor': 55, '../internals/descriptors': 59, '../internals/export': 64, '../internals/fails': 65, '../internals/global-this': 78, '../internals/has-own-property': 79, '../internals/is-callable': 87, '../internals/is-pure': 91, '../internals/iterators-core': 100, '../internals/object-get-prototype-of': 111, '../internals/well-known-symbol': 136 }],
+  138: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -5313,8 +6406,8 @@
         })
       }
     })
-  }, { '../internals/a-callable': 30, '../internals/an-object': 32, '../internals/call-with-safe-iteration-closing': 34, '../internals/export': 51, '../internals/function-call': 56, '../internals/get-iterator-direct': 61, '../internals/is-pure': 78, '../internals/iterator-close': 83, '../internals/iterator-create-proxy': 84, '../internals/iterator-helper-throws-on-invalid-iterator': 85, '../internals/iterator-helper-without-closing-on-early-error': 86 }],
-  125: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/an-object': 45, '../internals/call-with-safe-iteration-closing': 47, '../internals/export': 64, '../internals/function-call': 69, '../internals/get-iterator-direct': 74, '../internals/is-pure': 91, '../internals/iterator-close': 96, '../internals/iterator-create-proxy': 97, '../internals/iterator-helper-throws-on-invalid-iterator': 98, '../internals/iterator-helper-without-closing-on-early-error': 99 }],
+  139: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -5347,8 +6440,8 @@
         }, { IS_RECORD: true, INTERRUPTED: true }).result
       }
     })
-  }, { '../internals/a-callable': 30, '../internals/an-object': 32, '../internals/export': 51, '../internals/function-call': 56, '../internals/get-iterator-direct': 61, '../internals/iterate': 80, '../internals/iterator-close': 83, '../internals/iterator-helper-without-closing-on-early-error': 86 }],
-  126: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/an-object': 45, '../internals/export': 64, '../internals/function-call': 69, '../internals/get-iterator-direct': 74, '../internals/iterate': 93, '../internals/iterator-close': 96, '../internals/iterator-helper-without-closing-on-early-error': 99 }],
+  140: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -5381,8 +6474,8 @@
         }, { IS_RECORD: true })
       }
     })
-  }, { '../internals/a-callable': 30, '../internals/an-object': 32, '../internals/export': 51, '../internals/function-call': 56, '../internals/get-iterator-direct': 61, '../internals/iterate': 80, '../internals/iterator-close': 83, '../internals/iterator-helper-without-closing-on-early-error': 86 }],
-  127: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/an-object': 45, '../internals/export': 64, '../internals/function-call': 69, '../internals/get-iterator-direct': 74, '../internals/iterate': 93, '../internals/iterator-close': 96, '../internals/iterator-helper-without-closing-on-early-error': 99 }],
+  141: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -5427,8 +6520,8 @@
         })
       }
     })
-  }, { '../internals/a-callable': 30, '../internals/an-object': 32, '../internals/call-with-safe-iteration-closing': 34, '../internals/export': 51, '../internals/function-call': 56, '../internals/get-iterator-direct': 61, '../internals/is-pure': 78, '../internals/iterator-close': 83, '../internals/iterator-create-proxy': 84, '../internals/iterator-helper-throws-on-invalid-iterator': 85, '../internals/iterator-helper-without-closing-on-early-error': 86 }],
-  128: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/an-object': 45, '../internals/call-with-safe-iteration-closing': 47, '../internals/export': 64, '../internals/function-call': 69, '../internals/get-iterator-direct': 74, '../internals/is-pure': 91, '../internals/iterator-close': 96, '../internals/iterator-create-proxy': 97, '../internals/iterator-helper-throws-on-invalid-iterator': 98, '../internals/iterator-helper-without-closing-on-early-error': 99 }],
+  142: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const iterate = require('../internals/iterate')
@@ -5481,8 +6574,8 @@
         return accumulator
       }
     })
-  }, { '../internals/a-callable': 30, '../internals/an-object': 32, '../internals/export': 51, '../internals/fails': 52, '../internals/function-apply': 53, '../internals/get-iterator-direct': 61, '../internals/iterate': 80, '../internals/iterator-close': 83, '../internals/iterator-helper-without-closing-on-early-error': 86 }],
-  129: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/an-object': 45, '../internals/export': 64, '../internals/fails': 65, '../internals/function-apply': 66, '../internals/get-iterator-direct': 74, '../internals/iterate': 93, '../internals/iterator-close': 96, '../internals/iterator-helper-without-closing-on-early-error': 99 }],
+  143: [function (require, module, exports) {
     'use strict'
     const $ = require('../internals/export')
     const call = require('../internals/function-call')
@@ -5515,40 +6608,60 @@
         }, { IS_RECORD: true, INTERRUPTED: true }).stopped
       }
     })
-  }, { '../internals/a-callable': 30, '../internals/an-object': 32, '../internals/export': 51, '../internals/function-call': 56, '../internals/get-iterator-direct': 61, '../internals/iterate': 80, '../internals/iterator-close': 83, '../internals/iterator-helper-without-closing-on-early-error': 86 }],
-  130: [function (require, module, exports) {
+  }, { '../internals/a-callable': 42, '../internals/an-object': 45, '../internals/export': 64, '../internals/function-call': 69, '../internals/get-iterator-direct': 74, '../internals/iterate': 93, '../internals/iterator-close': 96, '../internals/iterator-helper-without-closing-on-early-error': 99 }],
+  144: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.constructor')
-  }, { '../modules/es.iterator.constructor': 123 }],
-  131: [function (require, module, exports) {
+  }, { '../modules/es.iterator.constructor': 137 }],
+  145: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.filter')
-  }, { '../modules/es.iterator.filter': 124 }],
-  132: [function (require, module, exports) {
+  }, { '../modules/es.iterator.filter': 138 }],
+  146: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.find')
-  }, { '../modules/es.iterator.find': 125 }],
-  133: [function (require, module, exports) {
+  }, { '../modules/es.iterator.find': 139 }],
+  147: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.for-each')
-  }, { '../modules/es.iterator.for-each': 126 }],
-  134: [function (require, module, exports) {
+  }, { '../modules/es.iterator.for-each': 140 }],
+  148: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.map')
-  }, { '../modules/es.iterator.map': 127 }],
-  135: [function (require, module, exports) {
+  }, { '../modules/es.iterator.map': 141 }],
+  149: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.reduce')
-  }, { '../modules/es.iterator.reduce': 128 }],
-  136: [function (require, module, exports) {
+  }, { '../modules/es.iterator.reduce': 142 }],
+  150: [function (require, module, exports) {
     'use strict'
     // TODO: Remove from `core-js@4`
     require('../modules/es.iterator.some')
-  }, { '../modules/es.iterator.some': 129 }]
-}, {}, [8])
+  }, { '../modules/es.iterator.some': 143 }],
+  151: [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': 43, '../internals/export': 64, '../internals/weak-map-helpers': 135 }]
+}, {}, [12])