@svgedit/svgcanvas 7.2.2 → 7.2.3

package/dist/svgcanvas.js

@@ -2130,14 +2130,14 @@ function findPos(obj) {
     top: curtop
   };
 }
-function isObject$a(item) {
+function isObject$c(item) {
   return item && typeof item === 'object' && !Array.isArray(item);
 }
 function mergeDeep(target, source) {
   const output = Object.assign({}, target);
-  if (isObject$a(target) && isObject$a(source)) {
+  if (isObject$c(target) && isObject$c(source)) {
     Object.keys(source).forEach(key => {
-      if (isObject$a(source[key])) {
+      if (isObject$c(source[key])) {
         if (!(key in target)) {
           Object.assign(output, {
             [key]: source[key]
@@ -2163,7 +2163,7 @@ function mergeDeep(target, source) {
  */
 function getClosest(elem, selector) {
   const firstChar = selector.charAt(0);
-  const supports = ('classList' in document.documentElement);
+  const supports = 'classList' in document.documentElement;
   let attribute;
   let value;
   // If selector is a data attribute, split attribute from value
@@ -2259,11 +2259,10 @@ function getParents(elem, selector) {
 function getParentsUntil(elem, parent, selector) {
   const parents = [];
   const parentType = parent?.charAt(0);
-  const selectorType = selector?.selector.charAt(0);
   // Get matches
   for (; elem && elem !== document; elem = elem.parentNode) {
     // Check if parent has been reached
-    if (parent) {
+    {
       // If parent is a class
       if (parentType === '.') {
         if (elem.classList.contains(parent.substr(1))) {
@@ -2287,30 +2286,7 @@ function getParentsUntil(elem, parent, selector) {
         break;
       }
     }
-    if (selector) {
-      // If selector is a class
-      if (selectorType === '.') {
-        if (elem.classList.contains(selector.substr(1))) {
-          parents.push(elem);
-        }
-      }
-      // If selector is an ID
-      if (selectorType === '#') {
-        if (elem.id === selector.substr(1)) {
-          parents.push(elem);
-        }
-      }
-      // If selector is a data attribute
-      if (selectorType === '[') {
-        if (elem.hasAttribute(selector.substr(1, selector.length - 1))) {
-          parents.push(elem);
-        }
-      }
-      // If selector is a tag
-      if (elem.tagName.toLowerCase() === selector) {
-        parents.push(elem);
-      }
-    } else {
+    {
       parents.push(elem);
     }
   }
@@ -7563,6 +7539,16 @@ function findLayerNameInGroup(group) {
   return sel ? sel.textContent : '';
 }
 
+/**
+ * Verify the classList of the given element : if the classList contains 'layer', return true, then return false
+ *
+ * @param {Element} element - The given element
+ * @returns {boolean} Return true if the classList contains 'layer' then return false
+ */
+function isLayerElement(element) {
+  return element.classList.contains('layer');
+}
+
 /**
  * Given a set of names, return a new unique name.
  * @param {string[]} existingLayerNames - Existing layer names.
@@ -7582,69 +7568,69 @@ function getNewLayerName(existingLayerNames) {
  */
 class Drawing {
   /**
-  * @param {SVGSVGElement} svgElem - The SVG DOM Element that this JS object
-  *     encapsulates.  If the svgElem has a se:nonce attribute on it, then
-  *     IDs will use the nonce as they are generated.
-  * @param {string} [optIdPrefix=svg_] - The ID prefix to use.
-  * @throws {Error} If not initialized with an SVG element
-  */
+   * @param {SVGSVGElement} svgElem - The SVG DOM Element that this JS object
+   *     encapsulates.  If the svgElem has a se:nonce attribute on it, then
+   *     IDs will use the nonce as they are generated.
+   * @param {string} [optIdPrefix=svg_] - The ID prefix to use.
+   * @throws {Error} If not initialized with an SVG element
+   */
   constructor(svgElem, optIdPrefix) {
     if (!svgElem || !svgElem.tagName || !svgElem.namespaceURI || svgElem.tagName !== 'svg' || svgElem.namespaceURI !== NS.SVG) {
       throw new Error('Error: svgedit.draw.Drawing instance initialized without a <svg> element');
     }
 
     /**
-    * The SVG DOM Element that represents this drawing.
-    * @type {SVGSVGElement}
-    */
+     * The SVG DOM Element that represents this drawing.
+     * @type {SVGSVGElement}
+     */
     this.svgElem_ = svgElem;
 
     /**
-    * The latest object number used in this drawing.
-    * @type {Integer}
-    */
+     * The latest object number used in this drawing.
+     * @type {Integer}
+     */
     this.obj_num = 0;
 
     /**
-    * The prefix to prepend to each element id in the drawing.
-    * @type {string}
-    */
+     * The prefix to prepend to each element id in the drawing.
+     * @type {string}
+     */
     this.idPrefix = optIdPrefix || 'svg_';
 
     /**
-    * An array of released element ids to immediately reuse.
-    * @type {Integer[]}
-    */
+     * An array of released element ids to immediately reuse.
+     * @type {Integer[]}
+     */
     this.releasedNums = [];
 
     /**
-    * The z-ordered array of Layer objects. Each layer has a name
-    * and group element.
-    * The first layer is the one at the bottom of the rendering.
-    * @type {Layer[]}
-    */
+     * The z-ordered array of Layer objects. Each layer has a name
+     * and group element.
+     * The first layer is the one at the bottom of the rendering.
+     * @type {Layer[]}
+     */
     this.all_layers = [];
 
     /**
-    * Map of all_layers by name.
-    *
-    * Note: Layers are ordered, but referenced externally by name; so, we need both container
-    * types depending on which function is called (i.e. all_layers and layer_map).
-    *
-    * @type {PlainObject<string, Layer>}
-    */
+     * Map of all_layers by name.
+     *
+     * Note: Layers are ordered, but referenced externally by name; so, we need both container
+     * types depending on which function is called (i.e. all_layers and layer_map).
+     *
+     * @type {PlainObject<string, Layer>}
+     */
     this.layer_map = {};
 
     /**
-    * The current layer being used.
-    * @type {Layer}
-    */
+     * The current layer being used.
+     * @type {Layer}
+     */
     this.current_layer = null;
 
     /**
-    * The nonce to use to uniquely identify elements across drawings.
-    * @type {!string}
-    */
+     * The nonce to use to uniquely identify elements across drawings.
+     * @type {!string}
+     */
     this.nonce_ = '';
     const n = this.svgElem_.getAttributeNS(NS.SE, 'nonce');
     // If already set in the DOM, use the nonce throughout the document
@@ -7659,7 +7645,7 @@ class Drawing {
   /**
    * @param {string} id Element ID to retrieve
    * @returns {Element} SVG element within the root SVGSVGElement
-  */
+   */
   getElem_(id) {
     if (this.svgElem_.querySelector) {
       // querySelector lookup
@@ -7753,7 +7739,7 @@ class Drawing {
    * that client code will do this.
    * @param {string} id - The id to release.
    * @returns {boolean} True if the id was valid to be released, false otherwise.
-  */
+   */
   releaseId(id) {
     // confirm if this is a valid id for this Document, else return false
     const front = this.idPrefix + (this.nonce_ ? this.nonce_ + '_' : '');
@@ -7777,7 +7763,7 @@ class Drawing {
   /**
    * Returns the number of layers in the current drawing.
    * @returns {Integer} The number of layers in the current drawing.
-  */
+   */
   getNumLayers() {
     return this.all_layers.length;
   }
@@ -7786,7 +7772,7 @@ class Drawing {
    * Check if layer with given name already exists.
    * @param {string} name - The layer name to check
    * @returns {boolean}
-  */
+   */
   hasLayer(name) {
     return this.layer_map[name] !== undefined;
   }
@@ -7795,7 +7781,7 @@ class Drawing {
    * Returns the name of the ith layer. If the index is out of range, an empty string is returned.
    * @param {Integer} i - The zero-based index of the layer you are querying.
    * @returns {string} The name of the ith layer (or the empty string if none found)
-  */
+   */
   getLayerName(i) {
     return i >= 0 && i < this.getNumLayers() ? this.all_layers[i].getName() : '';
   }
@@ -7821,7 +7807,7 @@ class Drawing {
    * Returns the name of the currently selected layer. If an error occurs, an empty string
    * is returned.
    * @returns {string} The name of the currently active layer (or the empty string if none found).
-  */
+   */
   getCurrentLayerName() {
     return this.current_layer ? this.current_layer.getName() : '';
   }
@@ -7883,9 +7869,9 @@ class Drawing {
   }
 
   /**
-  * @param {module:history.HistoryRecordingService} hrService
-  * @returns {void}
-  */
+   * @param {module:history.HistoryRecordingService} hrService
+   * @returns {void}
+   */
   mergeLayer(hrService) {
     const currentGroup = this.current_layer.getGroup();
     const prevGroup = currentGroup.previousElementSibling;
@@ -7921,9 +7907,9 @@ class Drawing {
   }
 
   /**
-  * @param {module:history.HistoryRecordingService} hrService
-  * @returns {void}
-  */
+   * @param {module:history.HistoryRecordingService} hrService
+   * @returns {void}
+   */
   mergeAllLayers(hrService) {
     // Set the current layer to the last layer.
     this.current_layer = this.all_layers[this.all_layers.length - 1];
@@ -7984,7 +7970,7 @@ class Drawing {
    * Updates layer system and sets the current layer to the
    * top-most layer (last `<g>` child of this drawing).
    * @returns {void}
-  */
+   */
   identifyLayers() {
     this.all_layers = [];
     this.layer_map = {};
@@ -8000,8 +7986,8 @@ class Drawing {
       if (child?.nodeType === 1) {
         if (child.tagName === 'g') {
           childgroups = true;
-          const name = findLayerNameInGroup(child);
-          if (name) {
+          if (isLayerElement(child)) {
+            const name = findLayerNameInGroup(child);
             layernames.push(name);
             layer = new Layer(name, child);
             this.all_layers.push(layer);
@@ -8036,7 +8022,7 @@ class Drawing {
    * @param {module:history.HistoryRecordingService} hrService - History recording service
    * @returns {SVGGElement} The SVGGElement of the new layer, which is
    *     also the current layer of this drawing.
-  */
+   */
   createLayer(name, hrService) {
     if (this.current_layer) {
       this.current_layer.deactivate();
@@ -8066,7 +8052,7 @@ class Drawing {
    * @param {module:history.HistoryRecordingService} hrService - History recording service
    * @returns {SVGGElement} The SVGGElement of the new layer, which is
    *     also the current layer of this drawing.
-  */
+   */
   cloneLayer(name, hrService) {
     if (!this.current_layer) {
       return null;
@@ -8113,7 +8099,7 @@ class Drawing {
    * then this function returns `false`.
    * @param {string} layerName - The name of the layer which you want to query.
    * @returns {boolean} The visibility state of the layer, or `false` if the layer name was invalid.
-  */
+   */
   getLayerVisibility(layerName) {
     const layer = this.layer_map[layerName];
     return layer ? layer.isVisible() : false;
@@ -8127,7 +8113,7 @@ class Drawing {
    * @param {boolean} bVisible - Whether the layer should be visible
    * @returns {?SVGGElement} The SVGGElement representing the layer if the
    *   `layerName` was valid, otherwise `null`.
-  */
+   */
   setLayerVisibility(layerName, bVisible) {
     if (typeof bVisible !== 'boolean') {
       return null;
@@ -8145,7 +8131,7 @@ class Drawing {
    * @param {string} layerName - name of the layer on which to get the opacity
    * @returns {?Float} The opacity value of the given layer.  This will be a value between 0.0 and 1.0, or `null`
    * if `layerName` is not a valid layer
-  */
+   */
   getLayerOpacity(layerName) {
     const layer = this.layer_map[layerName];
     if (!layer) {
@@ -8165,7 +8151,7 @@ class Drawing {
    * @param {string} layerName - Name of the layer on which to set the opacity
    * @param {Float} opacity - A float value in the range 0.0-1.0
    * @returns {void}
-  */
+   */
   setLayerOpacity(layerName, opacity) {
     if (typeof opacity !== 'number' || opacity < 0.0 || opacity > 1.0) {
       return;
@@ -8210,8 +8196,8 @@ const randomizeIds = function (enableRandomization, currentDrawing) {
 // Layer API Functions
 
 /**
-* Group: Layers.
-*/
+ * Group: Layers.
+ */
 
 /**
  * @see {@link https://api.jquery.com/jQuery.data/}
@@ -8231,11 +8217,11 @@ const randomizeIds = function (enableRandomization, currentDrawing) {
  * @function module:draw.DrawCanvasInit#setCurrentGroup
  * @param {Element} cg
  * @returns {void}
-*/
+ */
 /**
  * @function module:draw.DrawCanvasInit#getSelectedElements
  * @returns {Element[]} the array with selected DOM elements
-*/
+ */
 /**
  * @function module:draw.DrawCanvasInit#getSvgContent
  * @returns {SVGSVGElement}
@@ -8248,7 +8234,7 @@ const randomizeIds = function (enableRandomization, currentDrawing) {
  * @function module:draw.DrawCanvasInit#clearSelection
  * @param {boolean} [noCall] - When `true`, does not call the "selected" handler
  * @returns {void}
-*/
+ */
 /**
  * Run the callback function associated with the given event.
  * @function module:draw.DrawCanvasInit#call
@@ -8262,7 +8248,7 @@ const randomizeIds = function (enableRandomization, currentDrawing) {
  * @function module:draw.DrawCanvasInit#addCommandToHistory
  * @param {Command} cmd
  * @returns {void}
-*/
+ */
 /**
  * @function module:draw.DrawCanvasInit#changeSvgContent
  * @returns {void}
@@ -8270,43 +8256,43 @@ const randomizeIds = function (enableRandomization, currentDrawing) {
 
 let svgCanvas$e;
 /**
-* @function module:draw.init
-* @param {module:draw.DrawCanvasInit} canvas
-* @returns {void}
-*/
+ * @function module:draw.init
+ * @param {module:draw.DrawCanvasInit} canvas
+ * @returns {void}
+ */
 const init$f = canvas => {
   svgCanvas$e = canvas;
 };
 
 /**
-* Updates layer system.
-* @function module:draw.identifyLayers
-* @returns {void}
-*/
+ * Updates layer system.
+ * @function module:draw.identifyLayers
+ * @returns {void}
+ */
 const identifyLayers = () => {
   leaveContext();
   svgCanvas$e.getCurrentDrawing().identifyLayers();
 };
 
 /**
-* get current index
-* @function module:draw.identifyLayers
-* @returns {void}
-*/
+ * get current index
+ * @function module:draw.identifyLayers
+ * @returns {void}
+ */
 const indexCurrentLayer = () => {
   return svgCanvas$e.getCurrentDrawing().indexCurrentLayer();
 };
 
 /**
-* Creates a new top-level layer in the drawing with the given name, sets the current layer
-* to it, and then clears the selection. This function then calls the 'changed' handler.
-* This is an undoable action.
-* @function module:draw.createLayer
-* @param {string} name - The given name
-* @param {module:history.HistoryRecordingService} hrService
-* @fires module:svgcanvas.SvgCanvas#event:changed
-* @returns {void}
-*/
+ * Creates a new top-level layer in the drawing with the given name, sets the current layer
+ * to it, and then clears the selection. This function then calls the 'changed' handler.
+ * This is an undoable action.
+ * @function module:draw.createLayer
+ * @param {string} name - The given name
+ * @param {module:history.HistoryRecordingService} hrService
+ * @fires module:svgcanvas.SvgCanvas#event:changed
+ * @returns {void}
+ */
 const createLayer = (name, hrService) => {
   const newLayer = svgCanvas$e.getCurrentDrawing().createLayer(name, historyRecordingService(hrService));
   svgCanvas$e.clearSelection();
@@ -8332,12 +8318,12 @@ const cloneLayer = (name, hrService) => {
 };
 
 /**
-* Deletes the current layer from the drawing and then clears the selection. This function
-* then calls the 'changed' handler. This is an undoable action.
-* @function module:draw.deleteCurrentLayer
-* @fires module:svgcanvas.SvgCanvas#event:changed
-* @returns {boolean} `true` if an old layer group was found to delete
-*/
+ * Deletes the current layer from the drawing and then clears the selection. This function
+ * then calls the 'changed' handler. This is an undoable action.
+ * @function module:draw.deleteCurrentLayer
+ * @fires module:svgcanvas.SvgCanvas#event:changed
+ * @returns {boolean} `true` if an old layer group was found to delete
+ */
 const deleteCurrentLayer = () => {
   const {
     BatchCommand,
@@ -8362,12 +8348,12 @@ const deleteCurrentLayer = () => {
 };
 
 /**
-* Sets the current layer. If the name is not a valid layer name, then this function returns
-* false. Otherwise it returns true. This is not an undo-able action.
-* @function module:draw.setCurrentLayer
-* @param {string} name - The name of the layer you want to switch to.
-* @returns {boolean} true if the current layer was switched, otherwise false
-*/
+ * Sets the current layer. If the name is not a valid layer name, then this function returns
+ * false. Otherwise it returns true. This is not an undo-able action.
+ * @function module:draw.setCurrentLayer
+ * @param {string} name - The name of the layer you want to switch to.
+ * @returns {boolean} true if the current layer was switched, otherwise false
+ */
 const setCurrentLayer = name => {
   const result = svgCanvas$e.getCurrentDrawing().setCurrentLayer(toXml(name));
   if (result) {
@@ -8377,14 +8363,14 @@ const setCurrentLayer = name => {
 };
 
 /**
-* Renames the current layer. If the layer name is not valid (i.e. unique), then this function
-* does nothing and returns `false`, otherwise it returns `true`. This is an undo-able action.
-* @function module:draw.renameCurrentLayer
-* @param {string} newName - the new name you want to give the current layer. This name must
-* be unique among all layer names.
-* @fires module:svgcanvas.SvgCanvas#event:changed
-* @returns {boolean} Whether the rename succeeded
-*/
+ * Renames the current layer. If the layer name is not valid (i.e. unique), then this function
+ * does nothing and returns `false`, otherwise it returns `true`. This is an undo-able action.
+ * @function module:draw.renameCurrentLayer
+ * @param {string} newName - the new name you want to give the current layer. This name must
+ * be unique among all layer names.
+ * @fires module:svgcanvas.SvgCanvas#event:changed
+ * @returns {boolean} Whether the rename succeeded
+ */
 const renameCurrentLayer = newName => {
   const drawing = svgCanvas$e.getCurrentDrawing();
   const layer = drawing.getCurrentLayer();
@@ -8399,14 +8385,14 @@ const renameCurrentLayer = newName => {
 };
 
 /**
-* Changes the position of the current layer to the new value. If the new index is not valid,
-* this function does nothing and returns false, otherwise it returns true. This is an
-* undo-able action.
-* @function module:draw.setCurrentLayerPosition
-* @param {Integer} newPos - The zero-based index of the new position of the layer. This should be between
-* 0 and (number of layers - 1)
-* @returns {boolean} `true` if the current layer position was changed, `false` otherwise.
-*/
+ * Changes the position of the current layer to the new value. If the new index is not valid,
+ * this function does nothing and returns false, otherwise it returns true. This is an
+ * undo-able action.
+ * @function module:draw.setCurrentLayerPosition
+ * @param {Integer} newPos - The zero-based index of the new position of the layer. This should be between
+ * 0 and (number of layers - 1)
+ * @returns {boolean} `true` if the current layer position was changed, `false` otherwise.
+ */
 const setCurrentLayerPosition = newPos => {
   const {
     MoveElementCommand
@@ -8421,13 +8407,13 @@ const setCurrentLayerPosition = newPos => {
 };
 
 /**
-* Sets the visibility of the layer. If the layer name is not valid, this function return
-* `false`, otherwise it returns `true`. This is an undo-able action.
-* @function module:draw.setLayerVisibility
-* @param {string} layerName - The name of the layer to change the visibility
-* @param {boolean} bVisible - Whether the layer should be visible
-* @returns {boolean} true if the layer's visibility was set, false otherwise
-*/
+ * Sets the visibility of the layer. If the layer name is not valid, this function return
+ * `false`, otherwise it returns `true`. This is an undo-able action.
+ * @function module:draw.setLayerVisibility
+ * @param {string} layerName - The name of the layer to change the visibility
+ * @param {boolean} bVisible - Whether the layer should be visible
+ * @returns {boolean} true if the layer's visibility was set, false otherwise
+ */
 const setLayerVisibility = (layerName, bVisible) => {
   const {
     ChangeElementCommand
@@ -8452,12 +8438,12 @@ const setLayerVisibility = (layerName, bVisible) => {
 };
 
 /**
-* Moves the selected elements to layerName. If the name is not a valid layer name, then `false`
-* is returned. Otherwise it returns `true`. This is an undo-able action.
-* @function module:draw.moveSelectedToLayer
-* @param {string} layerName - The name of the layer you want to which you want to move the selected elements
-* @returns {boolean} Whether the selected elements were moved to the layer.
-*/
+ * Moves the selected elements to layerName. If the name is not a valid layer name, then `false`
+ * is returned. Otherwise it returns `true`. This is an undo-able action.
+ * @function module:draw.moveSelectedToLayer
+ * @param {string} layerName - The name of the layer you want to which you want to move the selected elements
+ * @returns {boolean} Whether the selected elements were moved to the layer.
+ */
 const moveSelectedToLayer = layerName => {
   const {
     BatchCommand,
@@ -8490,10 +8476,10 @@ const moveSelectedToLayer = layerName => {
 };
 
 /**
-* @function module:draw.mergeLayer
-* @param {module:history.HistoryRecordingService} hrService
-* @returns {void}
-*/
+ * @function module:draw.mergeLayer
+ * @param {module:history.HistoryRecordingService} hrService
+ * @returns {void}
+ */
 const mergeLayer = hrService => {
   svgCanvas$e.getCurrentDrawing().mergeLayer(historyRecordingService(hrService));
   svgCanvas$e.clearSelection();
@@ -8502,10 +8488,10 @@ const mergeLayer = hrService => {
 };
 
 /**
-* @function module:draw.mergeAllLayers
-* @param {module:history.HistoryRecordingService} hrService
-* @returns {void}
-*/
+ * @function module:draw.mergeAllLayers
+ * @param {module:history.HistoryRecordingService} hrService
+ * @returns {void}
+ */
 const mergeAllLayers = hrService => {
   svgCanvas$e.getCurrentDrawing().mergeAllLayers(historyRecordingService(hrService));
   svgCanvas$e.clearSelection();
@@ -8514,12 +8500,12 @@ const mergeAllLayers = hrService => {
 };
 
 /**
-* Return from a group context to the regular kind, make any previously
-* disabled elements enabled again.
-* @function module:draw.leaveContext
-* @fires module:svgcanvas.SvgCanvas#event:contextset
-* @returns {void}
-*/
+ * Return from a group context to the regular kind, make any previously
+ * disabled elements enabled again.
+ * @function module:draw.leaveContext
+ * @fires module:svgcanvas.SvgCanvas#event:contextset
+ * @returns {void}
+ */
 const leaveContext = () => {
   const len = disabledElems.length;
   const dataStorage = svgCanvas$e.getDataStorage();
@@ -8542,12 +8528,12 @@ const leaveContext = () => {
 };
 
 /**
-* Set the current context (for in-group editing).
-* @function module:draw.setContext
-* @param {Element} elem
-* @fires module:svgcanvas.SvgCanvas#event:contextset
-* @returns {void}
-*/
+ * Set the current context (for in-group editing).
+ * @function module:draw.setContext
+ * @param {Element} elem
+ * @fires module:svgcanvas.SvgCanvas#event:contextset
+ * @returns {void}
+ */
 const setContext = elem => {
   const dataStorage = svgCanvas$e.getDataStorage();
   leaveContext();
@@ -8800,14 +8786,14 @@ const svgRootElement = function (svgdoc, dimensions) {
 
 const NSSVG = 'http://www.w3.org/2000/svg';
 const {
-  userAgent: userAgent$4
+  userAgent: userAgent$6
 } = navigator;
 
 // Note: Browser sniffing should only be used if no other detection method is possible
-const isWebkit_ = userAgent$4.includes('AppleWebKit');
-const isGecko_ = userAgent$4.includes('Gecko/');
-const isChrome_ = userAgent$4.includes('Chrome/');
-userAgent$4.includes('Macintosh');
+const isWebkit_ = userAgent$6.includes('AppleWebKit');
+const isGecko_ = userAgent$6.includes('Gecko/');
+const isChrome_ = userAgent$6.includes('Chrome/');
+userAgent$6.includes('Macintosh');
 
 // text character positioning (for IE9 and now Chrome)
 const supportsGoodTextCharPos_ = function () {
@@ -10743,7 +10729,9 @@ const mouseUpEvent = evt => {
         const width = element.getAttribute('width');
         const height = element.getAttribute('height');
         // Image should be kept regardless of size (use inherit dimensions later)
-        keep = width || height || svgCanvas$9.getCurrentMode() === 'image';
+        const widthNum = Number(width);
+        const heightNum = Number(height);
+        keep = widthNum >= 1 || heightNum >= 1 || svgCanvas$9.getCurrentMode() === 'image';
       }
       break;
     case 'circle':
@@ -10913,8 +10901,8 @@ const mouseUpEvent = evt => {
       if (svgCanvas$9.getCurrentMode() === 'path') {
         svgCanvas$9.pathActions.toEditMode(element);
       } else if (svgCanvas$9.getCurConfig().selectNew) {
-        const modes = ['circle', 'ellipse', 'square', 'rect', 'fhpath', 'line', 'fhellipse', 'fhrect', 'star', 'polygon'];
-        if (modes.indexOf(svgCanvas$9.getCurrentMode()) !== -1) {
+        const modes = ['circle', 'ellipse', 'square', 'rect', 'fhpath', 'line', 'fhellipse', 'fhrect', 'star', 'polygon', 'shapelib'];
+        if (modes.indexOf(svgCanvas$9.getCurrentMode()) !== -1 && !evt.altKey) {
           svgCanvas$9.setMode('select');
         }
         svgCanvas$9.selectOnly([element], true);
@@ -11507,7 +11495,7 @@ const addSVGElementsFromJson = data => {
     assignAttributes(shape, {
       fill: curShape.fill,
       stroke: curShape.stroke,
-      'stroke-width': curShape.strokeWidth,
+      'stroke-width': curShape.stroke_width,
       'stroke-dasharray': curShape.stroke_dasharray,
       'stroke-linejoin': curShape.stroke_linejoin,
       'stroke-linecap': curShape.stroke_linecap,
@@ -15413,7 +15401,7 @@ var flm = /*#__PURE__*/hMap(flt, 9, 0),
 var fdm = /*#__PURE__*/hMap(fdt, 5, 0),
   fdrm = /*#__PURE__*/hMap(fdt, 5, 1);
 // find max of array
-var max$3 = function (a) {
+var max$2 = function (a) {
   var m = a[0];
   for (var i = 1; i < a.length; ++i) {
     if (a[i] > m) m = a[i];
@@ -15437,7 +15425,6 @@ var shft = function (p) {
 // typed array slice - allows garbage collector to free original reference,
 // while being more compatible than .slice
 var slc = function (v, s, e) {
-  if (s == null || s < 0) s = 0;
   if (e == null || e > v.length) e = v.length;
   // can't use .constructor in case user-supplied
   var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);
@@ -15515,7 +15502,7 @@ var inflt = function (dat, buf, st) {
         }
         pos += hcLen * 3;
         // code lengths bits
-        var clb = max$3(clt),
+        var clb = max$2(clt),
           clbmsk = (1 << clb) - 1;
         if (!noSt && pos + tl * (clb + 7) > tbts) break;
         // code lengths map
@@ -15541,9 +15528,9 @@ var inflt = function (dat, buf, st) {
         var lt = ldt.subarray(0, hLit),
           dt = ldt.subarray(hLit);
         // max length bits
-        lbt = max$3(lt);
+        lbt = max$2(lt);
         // max dist bits
-        dbt = max$3(dt);
+        dbt = max$2(dt);
         lm = hMap(lt, lbt, 1);
         dm = hMap(dt, dbt, 1);
       } else throw 'invalid block type';
@@ -15837,8 +15824,6 @@ var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
 };
 // deflate options (nice << 13) | chain
 var deo = /*#__PURE__*/new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
-// empty
-var et$2 = /*#__PURE__*/new u8(0);
 // compresses data into a raw DEFLATE buffer
 var dflt = function (dat, lvl, plvl, pre, post, lst) {
   var s = dat.length;
@@ -15961,8 +15946,6 @@ var dflt = function (dat, lvl, plvl, pre, post, lst) {
       }
     }
     pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
-    // this is the easiest way to avoid needing to maintain state
-    if (!lst) pos = wfblk(w, pos, et$2);
   }
   return slc(o, 0, pre + shft(pos) + post);
 };
@@ -27923,7 +27906,6 @@ function scanSegment(state) {
     for (i = need_params; i > 0; i--) {
       if (is_arc && (i === 3 || i === 4)) scanFlag(state);else scanParam(state);
       if (state.err.length) {
-        finalizeSegment(state);
         return;
       }
       state.data.push(state.param);
@@ -27965,7 +27947,9 @@ var path_parse = function pathParse(svgPath) {
   while (state.index < max && !state.err.length) {
     scanSegment(state);
   }
-  if (state.result.length) {
+  if (state.err.length) {
+    state.result = [];
+  } else if (state.result.length) {
     if ('mM'.indexOf(state.result[0][0]) < 0) {
       state.err = 'SvgPath: string should start with `M` or `m`';
       state.result = [];
@@ -28576,38 +28560,24 @@ SvgPath.prototype.__evaluateStack = function () {
 // Convert processed SVG Path back to string
 //
 SvgPath.prototype.toString = function () {
-  var result = '',
-    prevCmd = '',
-    cmdSkipped = false;
+  var elements = [],
+    skipCmd,
+    cmd;
   this.__evaluateStack();
-  for (var i = 0, len = this.segments.length; i < len; i++) {
-    var segment = this.segments[i];
-    var cmd = segment[0];
-
-    // Command not repeating => store
-    if (cmd !== prevCmd || cmd === 'm' || cmd === 'M') {
-      // workaround for FontForge SVG importing bug, keep space between "z m".
-      if (cmd === 'm' && prevCmd === 'z') result += ' ';
-      result += cmd;
-      cmdSkipped = false;
-    } else {
-      cmdSkipped = true;
-    }
-
-    // Store segment params
-    for (var pos = 1; pos < segment.length; pos++) {
-      var val = segment[pos];
-      // Space can be skipped
-      // 1. After command (always)
-      // 2. For negative value (with '-' at start)
-      if (pos === 1) {
-        if (cmdSkipped && val >= 0) result += ' ';
-      } else if (val >= 0) result += ' ';
-      result += val;
-    }
-    prevCmd = cmd;
-  }
-  return result;
+  for (var i = 0; i < this.segments.length; i++) {
+    // remove repeating commands names
+    cmd = this.segments[i][0];
+    skipCmd = i > 0 && cmd !== 'm' && cmd !== 'M' && cmd === this.segments[i - 1][0];
+    elements = elements.concat(skipCmd ? this.segments[i].slice(1) : this.segments[i]);
+  }
+  return elements.join(' ')
+  // Optimizations: remove spaces around commands & before `-`
+  //
+  // We could also remove leading zeros for `0.5`-like values,
+  // but their count is too small to spend time for.
+  .replace(/ ?([achlmqrstvz]) ?/gi, '$1').replace(/ \-/g, '-')
+  // workaround for FontForge SVG importing bug
+  .replace(/zm/g, 'z m');
 };
 
 // Translate path to (x [, y])
@@ -29278,7 +29248,7 @@ function c$2(t, e, r, i) {
         t(e);
       })).then(s, o);
     }
-    l((i = i.apply(t, e || [])).next());
+    l((i = i.apply(t, [])).next());
   });
 }
 function p$1(t, e) {
@@ -30282,7 +30252,7 @@ var ut = function (t) {
       });
     }, e.prototype.getBoundingBoxCore = function (t) {
       var e = this.getCachedPath(t);
-      if (!e) return [0, 0, 0, 0];
+      if (!e || !e.segments.length) return [0, 0, 0, 0];
       for (var r = Number.POSITIVE_INFINITY, i = Number.POSITIVE_INFINITY, n = Number.NEGATIVE_INFINITY, a = Number.NEGATIVE_INFINITY, s = 0, o = 0, l = 0; l < e.segments.length; l++) {
         var u = e.segments[l];
         (u instanceof C || u instanceof F || u instanceof A) && (s = u.x, o = u.y), u instanceof A ? (r = Math.min(r, s, u.x1, u.x2, u.x), n = Math.max(n, s, u.x1, u.x2, u.x), i = Math.min(i, o, u.y1, u.y2, u.y), a = Math.max(a, o, u.y1, u.y2, u.y)) : (r = Math.min(r, s), n = Math.max(n, s), i = Math.min(i, o), a = Math.max(a, o));
@@ -31443,7 +31413,7 @@ var html2canvas$2 = {exports: {}};
         function step(result) {
           result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+        step((generator = generator.apply(thisArg, [])).next());
       });
     }
     function __generator(thisArg, body) {
@@ -31535,7 +31505,7 @@ var html2canvas$2 = {exports: {}};
       }
     }
     function __spreadArray(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
           if (!ar) ar = Array.prototype.slice.call(from, 0, i);
           ar[i] = from[i];
@@ -35931,7 +35901,7 @@ var html2canvas$2 = {exports: {}};
         return value;
       },
       get SUPPORT_CORS_XHR() {
-        var value = ('withCredentials' in new XMLHttpRequest());
+        var value = 'withCredentials' in new XMLHttpRequest();
         Object.defineProperty(FEATURES, 'SUPPORT_CORS_XHR', {
           value: value
         });
@@ -41102,6 +41072,9 @@ class SvgCanvas {
     this.contentW = this.getResolution().w;
     this.contentH = this.getResolution().h;
     this.clear();
+
+    // creates custom modeEvent for editor
+    this.modeChangeEvent();
   } // End constructor
 
   getSvgOption() {
@@ -41508,6 +41481,11 @@ class SvgCanvas {
     this.textActions.clear();
     this.curProperties = this.selectedElements[0]?.nodeName === 'text' ? this.curText : this.curShape;
     this.currentMode = name;
+
+    // fires modeChange event for the editor
+    if (this.modeEvent) {
+      document.dispatchEvent(this.modeEvent);
+    }
   }
 
   /**
@@ -41946,6 +41924,7 @@ class SvgCanvas {
     this.hasMatrixTransform = hasMatrixTransform;
     this.transformListToTransform = transformListToTransform;
     this.convertToNum = convertToNum;
+    this.convertUnit = convertUnit;
     this.findDefs = findDefs;
     this.getUrlFromAttr = getUrlFromAttr;
     this.getHref = getHref;
@@ -41991,6 +41970,18 @@ class SvgCanvas {
     this.decode64 = decode64;
     this.mergeDeep = mergeDeep;
   }
+
+  /**
+   * Creates modeChange event, adds it as an svgCanvas property
+   * **/
+  modeChangeEvent() {
+    const modeEvent = new CustomEvent('modeChange', {
+      detail: {
+        getMode: () => this.getMode()
+      }
+    });
+    this.modeEvent = modeEvent;
+  }
 } // End class
 
 // attach utilities function to the class that are used by SvgEdit so
@@ -42013,78 +42004,21 @@ SvgCanvas.convertUnit = convertUnit;
 
 var purify$2 = {exports: {}};
 
-/*! @license DOMPurify 2.4.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.4.7/LICENSE */
+/*! @license DOMPurify | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.2.2/LICENSE */
 (function (module, exports) {
   (function (global, factory) {
     module.exports = factory() ;
   })(commonjsGlobal, function () {
 
-    function _typeof(obj) {
-      "@babel/helpers - typeof";
-
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-        return typeof obj;
-      } : function (obj) {
-        return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      }, _typeof(obj);
-    }
-    function _setPrototypeOf(o, p) {
-      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-      };
-      return _setPrototypeOf(o, p);
-    }
-    function _isNativeReflectConstruct() {
-      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-      if (Reflect.construct.sham) return false;
-      if (typeof Proxy === "function") return true;
-      try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-        return true;
-      } catch (e) {
-        return false;
-      }
-    }
-    function _construct(Parent, args, Class) {
-      if (_isNativeReflectConstruct()) {
-        _construct = Reflect.construct;
+    function _toConsumableArray(arr) {
+      if (Array.isArray(arr)) {
+        for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+          arr2[i] = arr[i];
+        }
+        return arr2;
       } else {
-        _construct = function _construct(Parent, args, Class) {
-          var a = [null];
-          a.push.apply(a, args);
-          var Constructor = Function.bind.apply(Parent, a);
-          var instance = new Constructor();
-          if (Class) _setPrototypeOf(instance, Class.prototype);
-          return instance;
-        };
+        return Array.from(arr);
       }
-      return _construct.apply(null, arguments);
-    }
-    function _toConsumableArray(arr) {
-      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-    }
-    function _arrayWithoutHoles(arr) {
-      if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-    }
-    function _iterableToArray(iter) {
-      if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-    }
-    function _unsupportedIterableToArray(o, minLen) {
-      if (!o) return;
-      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-      var n = Object.prototype.toString.call(o).slice(8, -1);
-      if (n === "Object" && o.constructor) n = o.constructor.name;
-      if (n === "Map" || n === "Set") return Array.from(o);
-      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-    }
-    function _arrayLikeToArray(arr, len) {
-      if (len == null || len > arr.length) len = arr.length;
-      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-      return arr2;
-    }
-    function _nonIterableSpread() {
-      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
     }
     var hasOwnProperty = Object.hasOwnProperty,
       setPrototypeOf = Object.setPrototypeOf,
@@ -42115,14 +42049,13 @@ var purify$2 = {exports: {}};
     }
     if (!construct) {
       construct = function construct(Func, args) {
-        return _construct(Func, _toConsumableArray(args));
+        return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))();
       };
     }
     var arrayForEach = unapply(Array.prototype.forEach);
     var arrayPop = unapply(Array.prototype.pop);
     var arrayPush = unapply(Array.prototype.push);
     var stringToLowerCase = unapply(String.prototype.toLowerCase);
-    var stringToString = unapply(String.prototype.toString);
     var stringMatch = unapply(String.prototype.match);
     var stringReplace = unapply(String.prototype.replace);
     var stringIndexOf = unapply(String.prototype.indexOf);
@@ -42131,7 +42064,7 @@ var purify$2 = {exports: {}};
     var typeErrorCreate = unconstruct(TypeError);
     function unapply(func) {
       return function (thisArg) {
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
           args[_key - 1] = arguments[_key];
         }
         return apply(func, thisArg, args);
@@ -42139,17 +42072,15 @@ var purify$2 = {exports: {}};
     }
     function unconstruct(func) {
       return function () {
-        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
           args[_key2] = arguments[_key2];
         }
         return construct(func, args);
       };
     }
-    /* Add properties to a lookup table */
 
-    function addToSet(set, array, transformCaseFunc) {
-      var _transformCaseFunc;
-      transformCaseFunc = (_transformCaseFunc = transformCaseFunc) !== null && _transformCaseFunc !== void 0 ? _transformCaseFunc : stringToLowerCase;
+    /* Add properties to a lookup table */
+    function addToSet(set, array) {
       if (setPrototypeOf) {
         // Make 'in' and truthy checks like Boolean(set.constructor)
         // independent of any properties defined on Object.prototype.
@@ -42160,7 +42091,7 @@ var purify$2 = {exports: {}};
       while (l--) {
         var element = array[l];
         if (typeof element === 'string') {
-          var lcElement = transformCaseFunc(element);
+          var lcElement = stringToLowerCase(element);
           if (lcElement !== element) {
             // Config presets (e.g. tags.js, attrs.js) are immutable.
             if (!isFrozen(array)) {
@@ -42173,23 +42104,23 @@ var purify$2 = {exports: {}};
       }
       return set;
     }
-    /* Shallow clone an object */
 
+    /* Shallow clone an object */
     function clone(object) {
       var newObject = create(null);
-      var property;
+      var property = void 0;
       for (property in object) {
-        if (apply(hasOwnProperty, object, [property]) === true) {
+        if (apply(hasOwnProperty, object, [property])) {
           newObject[property] = object[property];
         }
       }
       return newObject;
     }
+
     /* IE10 doesn't support __lookupGetter__ so lets'
      * simulate it. It also automatically checks
      * if the prop is function or getter and behaves
      * accordingly. */
-
     function lookupGetter(object, prop) {
       while (object !== null) {
         var desc = getOwnPropertyDescriptor(object, prop);
@@ -42203,47 +42134,59 @@ var purify$2 = {exports: {}};
         }
         object = getPrototypeOf(object);
       }
-      function fallbackValue(element) {
-        console.warn('fallback value for', element);
-        return null;
-      }
-      return fallbackValue;
+      return null;
     }
-    var html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']); // SVG
+    var html = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
+
+    // SVG
+    var svg = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
+    var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
 
-    var svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
-    var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']); // List of SVG elements that are disallowed by default.
+    // List of SVG elements that are disallowed by default.
     // We still need to know them so that we can do namespace
     // checks properly in case one wants to add them to
     // allow-list.
+    var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'feimage', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
+    var mathMl = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']);
 
-    var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
-    var mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']); // Similarly to SVG, we want to know all MathML elements,
+    // Similarly to SVG, we want to know all MathML elements,
     // even those that we disallow by default.
-
     var mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
     var text = freeze(['#text']);
-    var html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns', 'slot']);
-    var svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
-    var mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
+    var html$1 = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns']);
+    var svg$1 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+    var mathMl$1 = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
     var xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
-    var MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
 
-    var ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
-    var TMPLIT_EXPR = seal(/\${[\w\W]*}/gm);
+    // eslint-disable-next-line unicorn/better-regex
+    var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+    var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm);
     var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/); // eslint-disable-line no-useless-escape
-
     var ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
-
     var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
     );
     var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
     var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
     );
-    var DOCTYPE_NAME = seal(/^html$/i);
+    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+    function _toConsumableArray$1(arr) {
+      if (Array.isArray(arr)) {
+        for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+          arr2[i] = arr[i];
+        }
+        return arr2;
+      } else {
+        return Array.from(arr);
+      }
+    }
     var getGlobal = function getGlobal() {
       return typeof window === 'undefined' ? null : window;
     };
+
     /**
      * Creates a no-op policy for internal use only.
      * Don't export this function outside this module!
@@ -42252,14 +42195,14 @@ var purify$2 = {exports: {}};
      * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types
      * are not supported).
      */
-
     var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {
-      if (_typeof(trustedTypes) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
+      if ((typeof trustedTypes === 'undefined' ? 'undefined' : _typeof(trustedTypes)) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
         return null;
-      } // Allow the callers to control the unique policy name
+      }
+
+      // Allow the callers to control the unique policy name
       // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
       // Policy creation with duplicate names throws in Trusted Types.
-
       var suffix = null;
       var ATTR_NAME = 'data-tt-policy-suffix';
       if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {
@@ -42268,11 +42211,8 @@ var purify$2 = {exports: {}};
       var policyName = 'dompurify' + (suffix ? '#' + suffix : '');
       try {
         return trustedTypes.createPolicy(policyName, {
-          createHTML: function createHTML(html) {
-            return html;
-          },
-          createScriptURL: function createScriptURL(scriptUrl) {
-            return scriptUrl;
+          createHTML: function createHTML(html$$1) {
+            return html$$1;
           }
         });
       } catch (_) {
@@ -42288,17 +42228,17 @@ var purify$2 = {exports: {}};
       var DOMPurify = function DOMPurify(root) {
         return createDOMPurify(root);
       };
+
       /**
        * Version label, exposed for easier checks
        * if DOMPurify is up to date or not
        */
+      DOMPurify.version = '2.2.6';
 
-      DOMPurify.version = '2.4.7';
       /**
        * Array of elements that DOMPurify removed during sanitation.
        * Empty if nothing was removed.
        */
-
       DOMPurify.removed = [];
       if (!window || !window.document || window.document.nodeType !== 9) {
         // Not running in a browser, provide a factory function
@@ -42314,21 +42254,23 @@ var purify$2 = {exports: {}};
         Element = window.Element,
         NodeFilter = window.NodeFilter,
         _window$NamedNodeMap = window.NamedNodeMap,
-        NamedNodeMap = _window$NamedNodeMap === void 0 ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,
-        HTMLFormElement = window.HTMLFormElement,
+        NamedNodeMap = _window$NamedNodeMap === undefined ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,
+        Text = window.Text,
+        Comment = window.Comment,
         DOMParser = window.DOMParser,
         trustedTypes = window.trustedTypes;
       var ElementPrototype = Element.prototype;
       var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
       var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
       var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
-      var getParentNode = lookupGetter(ElementPrototype, 'parentNode'); // As per issue #47, the web-components registry is inherited by a
+      var getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+
+      // As per issue #47, the web-components registry is inherited by a
       // new document created via createHTMLDocument. As per the spec
       // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
       // a new empty registry is used when creating a template contents owner
       // document, so we use that as our parent document to ensure nothing
       // is inherited.
-
       if (typeof HTMLTemplateElement === 'function') {
         var template = document.createElement('template');
         if (template.content && template.content.ownerDocument) {
@@ -42336,31 +42278,31 @@ var purify$2 = {exports: {}};
         }
       }
       var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
-      var emptyHTML = trustedTypesPolicy ? trustedTypesPolicy.createHTML('') : '';
+      var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML('') : '';
       var _document = document,
         implementation = _document.implementation,
         createNodeIterator = _document.createNodeIterator,
-        createDocumentFragment = _document.createDocumentFragment,
-        getElementsByTagName = _document.getElementsByTagName;
+        getElementsByTagName = _document.getElementsByTagName,
+        createDocumentFragment = _document.createDocumentFragment;
       var importNode = originalDocument.importNode;
       var documentMode = {};
       try {
         documentMode = clone(document).documentMode ? document.documentMode : {};
       } catch (_) {}
       var hooks = {};
+
       /**
        * Expose whether this browser supports running the full DOMPurify.
        */
+      DOMPurify.isSupported = implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9;
+      var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR,
+        ERB_EXPR$$1 = ERB_EXPR,
+        DATA_ATTR$$1 = DATA_ATTR,
+        ARIA_ATTR$$1 = ARIA_ATTR,
+        IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA,
+        ATTR_WHITESPACE$$1 = ATTR_WHITESPACE;
+      var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI;
 
-      DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined && documentMode !== 9;
-      var MUSTACHE_EXPR$1 = MUSTACHE_EXPR,
-        ERB_EXPR$1 = ERB_EXPR,
-        TMPLIT_EXPR$1 = TMPLIT_EXPR,
-        DATA_ATTR$1 = DATA_ATTR,
-        ARIA_ATTR$1 = ARIA_ATTR,
-        IS_SCRIPT_OR_DATA$1 = IS_SCRIPT_OR_DATA,
-        ATTR_WHITESPACE$1 = ATTR_WHITESPACE;
-      var IS_ALLOWED_URI$1 = IS_ALLOWED_URI;
       /**
        * We consider the elements and attributes below to be safe. Ideally
        * don't add any new ones but feel free to remove unwanted ones.
@@ -42369,337 +42311,227 @@ var purify$2 = {exports: {}};
       /* allowed element names */
 
       var ALLOWED_TAGS = null;
-      var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray(html$1), _toConsumableArray(svg$1), _toConsumableArray(svgFilters), _toConsumableArray(mathMl$1), _toConsumableArray(text)));
-      /* Allowed attribute names */
+      var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text)));
 
+      /* Allowed attribute names */
       var ALLOWED_ATTR = null;
-      var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray(html), _toConsumableArray(svg), _toConsumableArray(mathMl), _toConsumableArray(xml)));
-      /*
-       * Configure how DOMPUrify should handle custom elements and their attributes as well as customized built-in elements.
-       * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
-       * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
-       * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
-       */
+      var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml)));
 
-      var CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {
-        tagNameCheck: {
-          writable: true,
-          configurable: false,
-          enumerable: true,
-          value: null
-        },
-        attributeNameCheck: {
-          writable: true,
-          configurable: false,
-          enumerable: true,
-          value: null
-        },
-        allowCustomizedBuiltInElements: {
-          writable: true,
-          configurable: false,
-          enumerable: true,
-          value: false
-        }
-      }));
       /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
-
       var FORBID_TAGS = null;
-      /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
 
+      /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
       var FORBID_ATTR = null;
-      /* Decide if ARIA attributes are okay */
 
+      /* Decide if ARIA attributes are okay */
       var ALLOW_ARIA_ATTR = true;
-      /* Decide if custom data attributes are okay */
 
+      /* Decide if custom data attributes are okay */
       var ALLOW_DATA_ATTR = true;
-      /* Decide if unknown protocols are okay */
 
+      /* Decide if unknown protocols are okay */
       var ALLOW_UNKNOWN_PROTOCOLS = false;
-      /* Decide if self-closing tags in attributes are allowed.
-       * Usually removed due to a mXSS issue in jQuery 3.0 */
 
-      var ALLOW_SELF_CLOSE_IN_ATTR = true;
       /* Output should be safe for common template engines.
        * This means, DOMPurify removes data attributes, mustaches and ERB
        */
-
       var SAFE_FOR_TEMPLATES = false;
-      /* Decide if document with <html>... should be returned */
 
+      /* Decide if document with <html>... should be returned */
       var WHOLE_DOCUMENT = false;
-      /* Track whether config is already set on this instance of DOMPurify. */
 
+      /* Track whether config is already set on this instance of DOMPurify. */
       var SET_CONFIG = false;
+
       /* Decide if all elements (e.g. style, script) must be children of
        * document.body. By default, browsers might move them to document.head */
-
       var FORCE_BODY = false;
+
       /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
        * string (or a TrustedHTML object if Trusted Types are supported).
        * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
        */
-
       var RETURN_DOM = false;
+
       /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
        * string  (or a TrustedHTML object if Trusted Types are supported) */
-
       var RETURN_DOM_FRAGMENT = false;
+
+      /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM
+       * `Node` is imported into the current `Document`. If this flag is not enabled the
+       * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by
+       * DOMPurify.
+       *
+       * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false`
+       * might cause XSS from attacks hidden in closed shadowroots in case the browser
+       * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/
+       */
+      var RETURN_DOM_IMPORT = true;
+
       /* Try to return a Trusted Type object instead of a string, return a string in
        * case Trusted Types are not supported  */
-
       var RETURN_TRUSTED_TYPE = false;
-      /* Output should be free from DOM clobbering attacks?
-       * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
-       */
 
+      /* Output should be free from DOM clobbering attacks? */
       var SANITIZE_DOM = true;
-      /* Achieve full DOM Clobbering protection by isolating the namespace of named
-       * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
-       *
-       * HTML/DOM spec rules that enable DOM Clobbering:
-       *   - Named Access on Window (§7.3.3)
-       *   - DOM Tree Accessors (§3.1.5)
-       *   - Form Element Parent-Child Relations (§4.10.3)
-       *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)
-       *   - HTMLCollection (§4.2.10.2)
-       *
-       * Namespace isolation is implemented by prefixing `id` and `name` attributes
-       * with a constant string, i.e., `user-content-`
-       */
 
-      var SANITIZE_NAMED_PROPS = false;
-      var SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
       /* Keep element content when removing element? */
-
       var KEEP_CONTENT = true;
+
       /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
        * of importing it into a new Document and returning a sanitized copy */
-
       var IN_PLACE = false;
-      /* Allow usage of profiles like html, svg and mathMl */
 
+      /* Allow usage of profiles like html, svg and mathMl */
       var USE_PROFILES = {};
+
       /* Tags to ignore content of when KEEP_CONTENT is true */
+      var FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
 
-      var FORBID_CONTENTS = null;
-      var DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
       /* Tags that are safe for data: URIs */
-
       var DATA_URI_TAGS = null;
       var DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
-      /* Attributes safe for values like "javascript:" */
 
+      /* Attributes safe for values like "javascript:" */
       var URI_SAFE_ATTRIBUTES = null;
-      var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
-      var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
-      var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
-      var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
-      /* Document namespace */
-
-      var NAMESPACE = HTML_NAMESPACE;
-      var IS_EMPTY_INPUT = false;
-      /* Allowed XHTML+XML namespaces */
-
-      var ALLOWED_NAMESPACES = null;
-      var DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
-      /* Parsing of strict XHTML documents */
+      var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'summary', 'title', 'value', 'style', 'xmlns']);
 
-      var PARSER_MEDIA_TYPE;
-      var SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
-      var DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
-      var transformCaseFunc;
       /* Keep a reference to config to pass to hooks */
-
       var CONFIG = null;
-      /* Ideally, do not touch anything below this line */
 
+      /* Ideally, do not touch anything below this line */
       /* ______________________________________________ */
 
       var formElement = document.createElement('form');
-      var isRegexOrFunction = function isRegexOrFunction(testValue) {
-        return testValue instanceof RegExp || testValue instanceof Function;
-      };
+
       /**
        * _parseConfig
        *
        * @param  {Object} cfg optional config literal
        */
       // eslint-disable-next-line complexity
-
       var _parseConfig = function _parseConfig(cfg) {
         if (CONFIG && CONFIG === cfg) {
           return;
         }
-        /* Shield configuration object from tampering */
 
-        if (!cfg || _typeof(cfg) !== 'object') {
+        /* Shield configuration object from tampering */
+        if (!cfg || (typeof cfg === 'undefined' ? 'undefined' : _typeof(cfg)) !== 'object') {
           cfg = {};
         }
-        /* Shield configuration object from prototype pollution */
 
+        /* Shield configuration object from prototype pollution */
         cfg = clone(cfg);
-        PARSER_MEDIA_TYPE =
-        // eslint-disable-next-line unicorn/prefer-includes
-        SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? PARSER_MEDIA_TYPE = DEFAULT_PARSER_MEDIA_TYPE : PARSER_MEDIA_TYPE = cfg.PARSER_MEDIA_TYPE; // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
 
-        transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;
         /* Set configuration parameters */
-
-        ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
-        ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
-        ALLOWED_NAMESPACES = 'ALLOWED_NAMESPACES' in cfg ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
-        URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES),
-        // eslint-disable-line indent
-        cfg.ADD_URI_SAFE_ATTR,
-        // eslint-disable-line indent
-        transformCaseFunc // eslint-disable-line indent
-        ) // eslint-disable-line indent
-        : DEFAULT_URI_SAFE_ATTRIBUTES;
-        DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS),
-        // eslint-disable-line indent
-        cfg.ADD_DATA_URI_TAGS,
-        // eslint-disable-line indent
-        transformCaseFunc // eslint-disable-line indent
-        ) // eslint-disable-line indent
-        : DEFAULT_DATA_URI_TAGS;
-        FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
-        FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};
-        FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};
+        ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;
+        ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;
+        URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;
+        DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;
+        FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};
+        FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};
         USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;
         ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
-
         ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
-
         ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
-
-        ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true
-
         SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
-
         WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
-
         RETURN_DOM = cfg.RETURN_DOM || false; // Default false
-
         RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
-
+        RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; // Default true
         RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
-
         FORCE_BODY = cfg.FORCE_BODY || false; // Default false
-
         SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
-
-        SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false
-
         KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
-
         IN_PLACE = cfg.IN_PLACE || false; // Default false
-
-        IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$1;
-        NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
-        CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
-        if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
-          CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
-        }
-        if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
-          CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
-        }
-        if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {
-          CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
-        }
+        IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1;
         if (SAFE_FOR_TEMPLATES) {
           ALLOW_DATA_ATTR = false;
         }
         if (RETURN_DOM_FRAGMENT) {
           RETURN_DOM = true;
         }
-        /* Parse profile info */
 
+        /* Parse profile info */
         if (USE_PROFILES) {
-          ALLOWED_TAGS = addToSet({}, _toConsumableArray(text));
+          ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text)));
           ALLOWED_ATTR = [];
           if (USE_PROFILES.html === true) {
-            addToSet(ALLOWED_TAGS, html$1);
-            addToSet(ALLOWED_ATTR, html);
+            addToSet(ALLOWED_TAGS, html);
+            addToSet(ALLOWED_ATTR, html$1);
           }
           if (USE_PROFILES.svg === true) {
-            addToSet(ALLOWED_TAGS, svg$1);
-            addToSet(ALLOWED_ATTR, svg);
+            addToSet(ALLOWED_TAGS, svg);
+            addToSet(ALLOWED_ATTR, svg$1);
             addToSet(ALLOWED_ATTR, xml);
           }
           if (USE_PROFILES.svgFilters === true) {
             addToSet(ALLOWED_TAGS, svgFilters);
-            addToSet(ALLOWED_ATTR, svg);
+            addToSet(ALLOWED_ATTR, svg$1);
             addToSet(ALLOWED_ATTR, xml);
           }
           if (USE_PROFILES.mathMl === true) {
-            addToSet(ALLOWED_TAGS, mathMl$1);
-            addToSet(ALLOWED_ATTR, mathMl);
+            addToSet(ALLOWED_TAGS, mathMl);
+            addToSet(ALLOWED_ATTR, mathMl$1);
             addToSet(ALLOWED_ATTR, xml);
           }
         }
-        /* Merge configuration parameters */
 
+        /* Merge configuration parameters */
         if (cfg.ADD_TAGS) {
           if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
             ALLOWED_TAGS = clone(ALLOWED_TAGS);
           }
-          addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+          addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);
         }
         if (cfg.ADD_ATTR) {
           if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
             ALLOWED_ATTR = clone(ALLOWED_ATTR);
           }
-          addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+          addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);
         }
         if (cfg.ADD_URI_SAFE_ATTR) {
-          addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+          addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);
         }
-        if (cfg.FORBID_CONTENTS) {
-          if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
-            FORBID_CONTENTS = clone(FORBID_CONTENTS);
-          }
-          addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
-        }
-        /* Add #text in case KEEP_CONTENT is set to true */
 
+        /* Add #text in case KEEP_CONTENT is set to true */
         if (KEEP_CONTENT) {
           ALLOWED_TAGS['#text'] = true;
         }
-        /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
 
+        /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
         if (WHOLE_DOCUMENT) {
           addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
         }
-        /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
 
+        /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
         if (ALLOWED_TAGS.table) {
           addToSet(ALLOWED_TAGS, ['tbody']);
           delete FORBID_TAGS.tbody;
-        } // Prevent further manipulation of configuration.
-        // Not available in IE8, Safari 5, etc.
+        }
 
+        // Prevent further manipulation of configuration.
+        // Not available in IE8, Safari 5, etc.
         if (freeze) {
           freeze(cfg);
         }
         CONFIG = cfg;
       };
       var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
-      var HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']); // Certain elements are allowed in both SVG and HTML
-      // namespace. We need to specify them explicitly
-      // so that they don't get erroneously deleted from
-      // HTML namespace.
+      var HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']);
 
-      var COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
       /* Keep track of all possible SVG and MathML tags
        * so that we can perform the namespace checks
        * correctly. */
-
-      var ALL_SVG_TAGS = addToSet({}, svg$1);
+      var ALL_SVG_TAGS = addToSet({}, svg);
       addToSet(ALL_SVG_TAGS, svgFilters);
       addToSet(ALL_SVG_TAGS, svgDisallowed);
-      var ALL_MATHML_TAGS = addToSet({}, mathMl$1);
+      var ALL_MATHML_TAGS = addToSet({}, mathMl);
       addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
+      var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+      var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+      var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+
       /**
        *
        *
@@ -42708,37 +42540,36 @@ var purify$2 = {exports: {}};
        *  namespace that a spec-compliant parser would never
        *  return. Return true otherwise.
        */
-
       var _checkValidNamespace = function _checkValidNamespace(element) {
-        var parent = getParentNode(element); // In JSDOM, if we're inside shadow DOM, then parentNode
-        // can be null. We just simulate parent in this case.
+        var parent = getParentNode(element);
 
+        // In JSDOM, if we're inside shadow DOM, then parentNode
+        // can be null. We just simulate parent in this case.
         if (!parent || !parent.tagName) {
           parent = {
-            namespaceURI: NAMESPACE,
+            namespaceURI: HTML_NAMESPACE,
             tagName: 'template'
           };
         }
         var tagName = stringToLowerCase(element.tagName);
         var parentTagName = stringToLowerCase(parent.tagName);
-        if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
-          return false;
-        }
         if (element.namespaceURI === SVG_NAMESPACE) {
           // The only way to switch from HTML namespace to SVG
           // is via <svg>. If it happens via any other tag, then
           // it should be killed.
           if (parent.namespaceURI === HTML_NAMESPACE) {
             return tagName === 'svg';
-          } // The only way to switch from MathML to SVG is via`
+          }
+
+          // The only way to switch from MathML to SVG is via
           // svg if parent is either <annotation-xml> or MathML
           // text integration points.
-
           if (parent.namespaceURI === MATHML_NAMESPACE) {
             return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
-          } // We only allow elements that are defined in SVG
-          // spec. All others are disallowed in SVG namespace.
+          }
 
+          // We only allow elements that are defined in SVG
+          // spec. All others are disallowed in SVG namespace.
           return Boolean(ALL_SVG_TAGS[tagName]);
         }
         if (element.namespaceURI === MATHML_NAMESPACE) {
@@ -42747,14 +42578,16 @@ var purify$2 = {exports: {}};
           // it should be killed.
           if (parent.namespaceURI === HTML_NAMESPACE) {
             return tagName === 'math';
-          } // The only way to switch from SVG to MathML is via
-          // <math> and HTML integration points
+          }
 
+          // The only way to switch from SVG to MathML is via
+          // <math> and HTML integration points
           if (parent.namespaceURI === SVG_NAMESPACE) {
             return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
-          } // We only allow elements that are defined in MathML
-          // spec. All others are disallowed in MathML namespace.
+          }
 
+          // We only allow elements that are defined in MathML
+          // spec. All others are disallowed in MathML namespace.
           return Boolean(ALL_MATHML_TAGS[tagName]);
         }
         if (element.namespaceURI === HTML_NAMESPACE) {
@@ -42766,33 +42599,35 @@ var purify$2 = {exports: {}};
           }
           if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
             return false;
-          } // We disallow tags that are specific for MathML
-          // or SVG and should never appear in HTML namespace
+          }
 
-          return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
-        } // For XHTML and XML documents that support custom namespaces
+          // Certain elements are allowed in both SVG and HTML
+          // namespace. We need to specify them explicitly
+          // so that they don't get erronously deleted from
+          // HTML namespace.
+          var commonSvgAndHTMLElements = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
 
-        if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {
-          return true;
-        } // The code should never reach this place (this means
-        // that the element somehow got namespace that is not
-        // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
-        // Return false just in case.
+          // We disallow tags that are specific for MathML
+          // or SVG and should never appear in HTML namespace
+          return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]);
+        }
 
+        // The code should never reach this place (this means
+        // that the element somehow got namespace that is not
+        // HTML, SVG or MathML). Return false just in case.
         return false;
       };
+
       /**
        * _forceRemove
        *
        * @param  {Node} node a DOM node
        */
-
       var _forceRemove = function _forceRemove(node) {
         arrayPush(DOMPurify.removed, {
           element: node
         });
         try {
-          // eslint-disable-next-line unicorn/prefer-dom-node-remove
           node.parentNode.removeChild(node);
         } catch (_) {
           try {
@@ -42802,13 +42637,13 @@ var purify$2 = {exports: {}};
           }
         }
       };
+
       /**
        * _removeAttribute
        *
        * @param  {String} name an Attribute name
        * @param  {Node} node a DOM node
        */
-
       var _removeAttribute = function _removeAttribute(name, node) {
         try {
           arrayPush(DOMPurify.removed, {
@@ -42821,31 +42656,19 @@ var purify$2 = {exports: {}};
             from: node
           });
         }
-        node.removeAttribute(name); // We void attribute values for unremovable "is"" attributes
-
-        if (name === 'is' && !ALLOWED_ATTR[name]) {
-          if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
-            try {
-              _forceRemove(node);
-            } catch (_) {}
-          } else {
-            try {
-              node.setAttribute(name, '');
-            } catch (_) {}
-          }
-        }
+        node.removeAttribute(name);
       };
+
       /**
        * _initDocument
        *
        * @param  {String} dirty a string of dirty markup
        * @return {Document} a DOM, filled with the dirty markup
        */
-
       var _initDocument = function _initDocument(dirty) {
         /* Create a HTML document */
-        var doc;
-        var leadingWhitespace;
+        var doc = void 0;
+        var leadingWhitespace = void 0;
         if (FORCE_BODY) {
           dirty = '<remove></remove>' + dirty;
         } else {
@@ -42853,73 +42676,66 @@ var purify$2 = {exports: {}};
           var matches = stringMatch(dirty, /^[\r\n\t ]+/);
           leadingWhitespace = matches && matches[0];
         }
-        if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {
-          // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
-          dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
-        }
         var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
-        /*
-         * Use the DOMParser API by default, fallback later if needs be
-         * DOMParser not work for svg when has multiple root element.
-         */
+        /* Use the DOMParser API by default, fallback later if needs be */
+        try {
+          doc = new DOMParser().parseFromString(dirtyPayload, 'text/html');
+        } catch (_) {}
 
-        if (NAMESPACE === HTML_NAMESPACE) {
-          try {
-            doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
-          } catch (_) {}
-        }
         /* Use createHTMLDocument in case DOMParser is not available */
-
         if (!doc || !doc.documentElement) {
-          doc = implementation.createDocument(NAMESPACE, 'template', null);
-          try {
-            doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
-          } catch (_) {// Syntax error if dirtyPayload is invalid xml
-          }
+          doc = implementation.createHTMLDocument('');
+          var _doc = doc,
+            body = _doc.body;
+          body.parentNode.removeChild(body.parentNode.firstElementChild);
+          body.outerHTML = dirtyPayload;
         }
-        var body = doc.body || doc.documentElement;
         if (dirty && leadingWhitespace) {
-          body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+          doc.body.insertBefore(document.createTextNode(leadingWhitespace), doc.body.childNodes[0] || null);
         }
-        /* Work on whole document or just its body */
 
-        if (NAMESPACE === HTML_NAMESPACE) {
-          return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
-        }
-        return WHOLE_DOCUMENT ? doc.documentElement : body;
+        /* Work on whole document or just its body */
+        return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
       };
+
       /**
        * _createIterator
        *
        * @param  {Document} root document/fragment to create iterator for
        * @return {Iterator} iterator instance
        */
-
       var _createIterator = function _createIterator(root) {
-        return createNodeIterator.call(root.ownerDocument || root, root,
-        // eslint-disable-next-line no-bitwise
-        NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, null, false);
+        return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, function () {
+          return NodeFilter.FILTER_ACCEPT;
+        }, false);
       };
+
       /**
        * _isClobbered
        *
        * @param  {Node} elm element to check for clobbering attacks
        * @return {Boolean} true if clobbered, false if safe
        */
-
       var _isClobbered = function _isClobbered(elm) {
-        return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function');
+        if (elm instanceof Text || elm instanceof Comment) {
+          return false;
+        }
+        if (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function') {
+          return true;
+        }
+        return false;
       };
+
       /**
        * _isNode
        *
        * @param  {Node} obj object to check whether it's a DOM node
        * @return {Boolean} true is object is a DOM node
        */
-
       var _isNode = function _isNode(object) {
-        return _typeof(Node) === 'object' ? object instanceof Node : object && _typeof(object) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
+        return (typeof Node === 'undefined' ? 'undefined' : _typeof(Node)) === 'object' ? object instanceof Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
       };
+
       /**
        * _executeHook
        * Execute user configurable hooks
@@ -42928,7 +42744,6 @@ var purify$2 = {exports: {}};
        * @param  {Node} currentNode node to work on with the hook
        * @param  {Object} data additional hook parameters
        */
-
       var _executeHook = function _executeHook(entryPoint, currentNode, data) {
         if (!hooks[entryPoint]) {
           return;
@@ -42937,6 +42752,7 @@ var purify$2 = {exports: {}};
           hook.call(DOMPurify, currentNode, data, CONFIG);
         });
       };
+
       /**
        * _sanitizeElements
        *
@@ -42947,88 +42763,70 @@ var purify$2 = {exports: {}};
        * @param   {Node} currentNode to check for permission to exist
        * @return  {Boolean} true if node was killed, false if left alive
        */
-
       var _sanitizeElements = function _sanitizeElements(currentNode) {
-        var content;
-        /* Execute a hook if present */
+        var content = void 0;
 
+        /* Execute a hook if present */
         _executeHook('beforeSanitizeElements', currentNode, null);
-        /* Check if element is clobbered or can clobber */
 
+        /* Check if element is clobbered or can clobber */
         if (_isClobbered(currentNode)) {
           _forceRemove(currentNode);
           return true;
         }
-        /* Check if tagname contains Unicode */
 
-        if (regExpTest(/[\u0080-\uFFFF]/, currentNode.nodeName)) {
+        /* Check if tagname contains Unicode */
+        if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) {
           _forceRemove(currentNode);
           return true;
         }
+
         /* Now let's check the element's type and name */
+        var tagName = stringToLowerCase(currentNode.nodeName);
 
-        var tagName = transformCaseFunc(currentNode.nodeName);
         /* Execute a hook if present */
-
         _executeHook('uponSanitizeElement', currentNode, {
           tagName: tagName,
           allowedTags: ALLOWED_TAGS
         });
-        /* Detect mXSS attempts abusing namespace confusion */
 
-        if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+        /* Detect mXSS attempts abusing namespace confusion */
+        if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
           _forceRemove(currentNode);
           return true;
         }
-        /* Mitigate a problem with templates inside select */
 
-        if (tagName === 'select' && regExpTest(/<template/i, currentNode.innerHTML)) {
-          _forceRemove(currentNode);
-          return true;
-        }
         /* Remove element if anything forbids its presence */
-
         if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
-          /* Check if we have a custom element to handle */
-          if (!FORBID_TAGS[tagName] && _basicCustomElementTest(tagName)) {
-            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
-            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) return false;
-          }
           /* Keep content except for bad-listed elements */
-
           if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
-            var parentNode = getParentNode(currentNode) || currentNode.parentNode;
-            var childNodes = getChildNodes(currentNode) || currentNode.childNodes;
-            if (childNodes && parentNode) {
-              var childCount = childNodes.length;
-              for (var i = childCount - 1; i >= 0; --i) {
-                parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
-              }
+            var parentNode = getParentNode(currentNode);
+            var childNodes = getChildNodes(currentNode);
+            var childCount = childNodes.length;
+            for (var i = childCount - 1; i >= 0; --i) {
+              parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
             }
           }
           _forceRemove(currentNode);
           return true;
         }
-        /* Check whether element has a valid namespace */
 
+        /* Check whether element has a valid namespace */
         if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
           _forceRemove(currentNode);
           return true;
         }
-        /* Make sure that older browsers don't get fallback-tag mXSS */
-
-        if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+        if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
           _forceRemove(currentNode);
           return true;
         }
-        /* Sanitize element content to be template-safe */
 
+        /* Sanitize element content to be template-safe */
         if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
           /* Get the element's text content */
           content = currentNode.textContent;
-          content = stringReplace(content, MUSTACHE_EXPR$1, ' ');
-          content = stringReplace(content, ERB_EXPR$1, ' ');
-          content = stringReplace(content, TMPLIT_EXPR$1, ' ');
+          content = stringReplace(content, MUSTACHE_EXPR$$1, ' ');
+          content = stringReplace(content, ERB_EXPR$$1, ' ');
           if (currentNode.textContent !== content) {
             arrayPush(DOMPurify.removed, {
               element: currentNode.cloneNode()
@@ -43036,11 +42834,12 @@ var purify$2 = {exports: {}};
             currentNode.textContent = content;
           }
         }
-        /* Execute a hook if present */
 
+        /* Execute a hook if present */
         _executeHook('afterSanitizeElements', currentNode, null);
         return false;
       };
+
       /**
        * _isValidAttribute
        *
@@ -43050,44 +42849,26 @@ var purify$2 = {exports: {}};
        * @return {Boolean} Returns true if `value` is valid, otherwise false.
        */
       // eslint-disable-next-line complexity
-
       var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
         /* Make sure attribute cannot clobber */
         if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
           return false;
         }
+
         /* Allow valid data-* attributes: At least one character after "-"
             (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
             XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
             We don't need to check the value; it's always URI safe. */
+        if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$$1, lcName)) ;else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) ;else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+          return false;
 
-        if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$1, lcName)) ;else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName)) ;else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
-          if (
-          // First condition does a very basic check if a) it's basically a valid custom element tagname AND
-          // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
-          // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
-          _basicCustomElementTest(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||
-          // Alternative, second condition checks if it's an `is`-attribute, AND
-          // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
-          lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ;else {
-            return false;
-          }
           /* Check value is safe. First, is attr inert? If so, is safe */
-        } else if (URI_SAFE_ATTRIBUTES[lcName]) ;else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, ''))) ;else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ;else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, ''))) ;else if (value) {
+        } else if (URI_SAFE_ATTRIBUTES[lcName]) ;else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ;else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ;else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ;else if (!value) ;else {
           return false;
-        } else ;
+        }
         return true;
       };
-      /**
-       * _basicCustomElementCheck
-       * checks if at least one dash is included in tagName, and it's not the first char
-       * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
-       * @param {string} tagName name of the tag of the node to sanitize
-       */
 
-      var _basicCustomElementTest = function _basicCustomElementTest(tagName) {
-        return tagName.indexOf('-') > 0;
-      };
       /**
        * _sanitizeAttributes
        *
@@ -43098,16 +42879,15 @@ var purify$2 = {exports: {}};
        *
        * @param  {Node} currentNode to sanitize
        */
-
       var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
-        var attr;
-        var value;
-        var lcName;
-        var l;
+        var attr = void 0;
+        var value = void 0;
+        var lcName = void 0;
+        var l = void 0;
         /* Execute a hook if present */
-
         _executeHook('beforeSanitizeAttributes', currentNode, null);
         var attributes = currentNode.attributes;
+
         /* Check if we have attributes; if not we might have a text node */
 
         if (!attributes) {
@@ -43120,86 +42900,55 @@ var purify$2 = {exports: {}};
           allowedAttributes: ALLOWED_ATTR
         };
         l = attributes.length;
-        /* Go backwards over all attributes; safely remove bad ones */
 
+        /* Go backwards over all attributes; safely remove bad ones */
         while (l--) {
           attr = attributes[l];
           var _attr = attr,
             name = _attr.name,
             namespaceURI = _attr.namespaceURI;
-          value = name === 'value' ? attr.value : stringTrim(attr.value);
-          lcName = transformCaseFunc(name);
-          /* Execute a hook if present */
+          value = stringTrim(attr.value);
+          lcName = stringToLowerCase(name);
 
+          /* Execute a hook if present */
           hookEvent.attrName = lcName;
           hookEvent.attrValue = value;
           hookEvent.keepAttr = true;
           hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
-
           _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
           value = hookEvent.attrValue;
           /* Did the hooks approve of the attribute? */
-
           if (hookEvent.forceKeepAttr) {
             continue;
           }
-          /* Remove attribute */
 
+          /* Remove attribute */
           _removeAttribute(name, currentNode);
-          /* Did the hooks approve of the attribute? */
 
+          /* Did the hooks approve of the attribute? */
           if (!hookEvent.keepAttr) {
             continue;
           }
-          /* Work around a security issue in jQuery 3.0 */
 
-          if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+          /* Work around a security issue in jQuery 3.0 */
+          if (regExpTest(/\/>/i, value)) {
             _removeAttribute(name, currentNode);
             continue;
           }
-          /* Sanitize attribute content to be template-safe */
 
+          /* Sanitize attribute content to be template-safe */
           if (SAFE_FOR_TEMPLATES) {
-            value = stringReplace(value, MUSTACHE_EXPR$1, ' ');
-            value = stringReplace(value, ERB_EXPR$1, ' ');
-            value = stringReplace(value, TMPLIT_EXPR$1, ' ');
+            value = stringReplace(value, MUSTACHE_EXPR$$1, ' ');
+            value = stringReplace(value, ERB_EXPR$$1, ' ');
           }
-          /* Is `value` valid for this attribute? */
 
-          var lcTag = transformCaseFunc(currentNode.nodeName);
+          /* Is `value` valid for this attribute? */
+          var lcTag = currentNode.nodeName.toLowerCase();
           if (!_isValidAttribute(lcTag, lcName, value)) {
             continue;
           }
-          /* Full DOM Clobbering protection via namespace isolation,
-           * Prefix id and name attributes with `user-content-`
-           */
-
-          if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
-            // Remove the attribute with this value
-            _removeAttribute(name, currentNode); // Prefix the value and later re-create the attribute with the sanitized value
-
-            value = SANITIZE_NAMED_PROPS_PREFIX + value;
-          }
-          /* Handle attributes that require Trusted Types */
 
-          if (trustedTypesPolicy && _typeof(trustedTypes) === 'object' && typeof trustedTypes.getAttributeType === 'function') {
-            if (namespaceURI) ;else {
-              switch (trustedTypes.getAttributeType(lcTag, lcName)) {
-                case 'TrustedHTML':
-                  {
-                    value = trustedTypesPolicy.createHTML(value);
-                    break;
-                  }
-                case 'TrustedScriptURL':
-                  {
-                    value = trustedTypesPolicy.createScriptURL(value);
-                    break;
-                  }
-              }
-            }
-          }
           /* Handle invalid data-* attribute set by try-catching it */
-
           try {
             if (namespaceURI) {
               currentNode.setAttributeNS(namespaceURI, name, value);
@@ -43210,43 +42959,44 @@ var purify$2 = {exports: {}};
             arrayPop(DOMPurify.removed);
           } catch (_) {}
         }
-        /* Execute a hook if present */
 
+        /* Execute a hook if present */
         _executeHook('afterSanitizeAttributes', currentNode, null);
       };
+
       /**
        * _sanitizeShadowDOM
        *
        * @param  {DocumentFragment} fragment to iterate over recursively
        */
-
       var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
-        var shadowNode;
+        var shadowNode = void 0;
         var shadowIterator = _createIterator(fragment);
-        /* Execute a hook if present */
 
+        /* Execute a hook if present */
         _executeHook('beforeSanitizeShadowDOM', fragment, null);
         while (shadowNode = shadowIterator.nextNode()) {
           /* Execute a hook if present */
           _executeHook('uponSanitizeShadowNode', shadowNode, null);
-          /* Sanitize tags and elements */
 
+          /* Sanitize tags and elements */
           if (_sanitizeElements(shadowNode)) {
             continue;
           }
-          /* Deep shadow DOM detected */
 
+          /* Deep shadow DOM detected */
           if (shadowNode.content instanceof DocumentFragment) {
             _sanitizeShadowDOM(shadowNode.content);
           }
-          /* Check attributes, sanitize if necessary */
 
+          /* Check attributes, sanitize if necessary */
           _sanitizeAttributes(shadowNode);
         }
-        /* Execute a hook if present */
 
+        /* Execute a hook if present */
         _executeHook('afterSanitizeShadowDOM', fragment, null);
       };
+
       /**
        * Sanitize
        * Public method providing core sanitation functionality
@@ -43255,36 +43005,33 @@ var purify$2 = {exports: {}};
        * @param {Object} configuration object
        */
       // eslint-disable-next-line complexity
-
-      DOMPurify.sanitize = function (dirty) {
-        var cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-        var body;
-        var importedNode;
-        var currentNode;
-        var oldNode;
-        var returnNode;
+      DOMPurify.sanitize = function (dirty, cfg) {
+        var body = void 0;
+        var importedNode = void 0;
+        var currentNode = void 0;
+        var oldNode = void 0;
+        var returnNode = void 0;
         /* Make sure we have a string to sanitize.
           DO NOT return early, as this will return the wrong type if
           the user has requested a DOM object rather than a string */
-
-        IS_EMPTY_INPUT = !dirty;
-        if (IS_EMPTY_INPUT) {
+        if (!dirty) {
           dirty = '<!-->';
         }
-        /* Stringify, in case dirty is an object */
 
+        /* Stringify, in case dirty is an object */
         if (typeof dirty !== 'string' && !_isNode(dirty)) {
-          if (typeof dirty.toString === 'function') {
+          // eslint-disable-next-line no-negated-condition
+          if (typeof dirty.toString !== 'function') {
+            throw typeErrorCreate('toString is not a function');
+          } else {
             dirty = dirty.toString();
             if (typeof dirty !== 'string') {
               throw typeErrorCreate('dirty is not a string, aborting');
             }
-          } else {
-            throw typeErrorCreate('toString is not a function');
           }
         }
-        /* Check we can run. Otherwise fall back or ignore */
 
+        /* Check we can run. Otherwise fall back or ignore */
         if (!DOMPurify.isSupported) {
           if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {
             if (typeof dirty === 'string') {
@@ -43296,28 +43043,20 @@ var purify$2 = {exports: {}};
           }
           return dirty;
         }
-        /* Assign config vars */
 
+        /* Assign config vars */
         if (!SET_CONFIG) {
           _parseConfig(cfg);
         }
-        /* Clean up removed elements */
 
+        /* Clean up removed elements */
         DOMPurify.removed = [];
-        /* Check if dirty is correctly typed for IN_PLACE */
 
+        /* Check if dirty is correctly typed for IN_PLACE */
         if (typeof dirty === 'string') {
           IN_PLACE = false;
         }
-        if (IN_PLACE) {
-          /* Do some early pre-sanitization to avoid unsafe root nodes */
-          if (dirty.nodeName) {
-            var tagName = transformCaseFunc(dirty.nodeName);
-            if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
-              throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
-            }
-          }
-        } else if (dirty instanceof Node) {
+        if (IN_PLACE) ;else if (dirty instanceof Node) {
           /* If dirty is a DOM element, append to an empty document to avoid
              elements being stripped by the parser */
           body = _initDocument('<!---->');
@@ -43328,7 +43067,7 @@ var purify$2 = {exports: {}};
           } else if (importedNode.nodeName === 'HTML') {
             body = importedNode;
           } else {
-            // eslint-disable-next-line unicorn/prefer-dom-node-append
+            // eslint-disable-next-line unicorn/prefer-node-append
             body.appendChild(importedNode);
           }
         } else {
@@ -43338,64 +43077,64 @@ var purify$2 = {exports: {}};
           dirty.indexOf('<') === -1) {
             return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
           }
-          /* Initialize the document to work on */
 
+          /* Initialize the document to work on */
           body = _initDocument(dirty);
-          /* Check we have a DOM node from the data */
 
+          /* Check we have a DOM node from the data */
           if (!body) {
-            return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
+            return RETURN_DOM ? null : emptyHTML;
           }
         }
-        /* Remove first element node (ours) if FORCE_BODY is set */
 
+        /* Remove first element node (ours) if FORCE_BODY is set */
         if (body && FORCE_BODY) {
           _forceRemove(body.firstChild);
         }
-        /* Get node iterator */
 
+        /* Get node iterator */
         var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
-        /* Now start iterating over the created document */
 
+        /* Now start iterating over the created document */
         while (currentNode = nodeIterator.nextNode()) {
           /* Fix IE's strange behavior with manipulated textNodes #89 */
           if (currentNode.nodeType === 3 && currentNode === oldNode) {
             continue;
           }
-          /* Sanitize tags and elements */
 
+          /* Sanitize tags and elements */
           if (_sanitizeElements(currentNode)) {
             continue;
           }
-          /* Shadow DOM detected, sanitize it */
 
+          /* Shadow DOM detected, sanitize it */
           if (currentNode.content instanceof DocumentFragment) {
             _sanitizeShadowDOM(currentNode.content);
           }
-          /* Check attributes, sanitize if necessary */
 
+          /* Check attributes, sanitize if necessary */
           _sanitizeAttributes(currentNode);
           oldNode = currentNode;
         }
         oldNode = null;
-        /* If we sanitized `dirty` in-place, return it. */
 
+        /* If we sanitized `dirty` in-place, return it. */
         if (IN_PLACE) {
           return dirty;
         }
-        /* Return sanitized string or DOM */
 
+        /* Return sanitized string or DOM */
         if (RETURN_DOM) {
           if (RETURN_DOM_FRAGMENT) {
             returnNode = createDocumentFragment.call(body.ownerDocument);
             while (body.firstChild) {
-              // eslint-disable-next-line unicorn/prefer-dom-node-append
+              // eslint-disable-next-line unicorn/prefer-node-append
               returnNode.appendChild(body.firstChild);
             }
           } else {
             returnNode = body;
           }
-          if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmod) {
+          if (RETURN_DOM_IMPORT) {
             /*
               AdoptNode() is not used because internal state is not reset
               (e.g. the past names map of a HTMLFormElement), this is safe
@@ -43408,41 +43147,36 @@ var purify$2 = {exports: {}};
           return returnNode;
         }
         var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
-        /* Serialize doctype if allowed */
 
-        if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
-          serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
-        }
         /* Sanitize final string template-safe */
-
         if (SAFE_FOR_TEMPLATES) {
-          serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$1, ' ');
-          serializedHTML = stringReplace(serializedHTML, ERB_EXPR$1, ' ');
-          serializedHTML = stringReplace(serializedHTML, TMPLIT_EXPR$1, ' ');
+          serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, ' ');
+          serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, ' ');
         }
         return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
       };
+
       /**
        * Public method to set the configuration once
        * setConfig
        *
        * @param {Object} cfg configuration object
        */
-
       DOMPurify.setConfig = function (cfg) {
         _parseConfig(cfg);
         SET_CONFIG = true;
       };
+
       /**
        * Public method to remove the configuration
        * clearConfig
        *
        */
-
       DOMPurify.clearConfig = function () {
         CONFIG = null;
         SET_CONFIG = false;
       };
+
       /**
        * Public method to check if an attribute value is valid.
        * Uses last set config, if any. Otherwise, uses config defaults.
@@ -43453,16 +43187,16 @@ var purify$2 = {exports: {}};
        * @param  {string} value Attribute value.
        * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.
        */
-
       DOMPurify.isValidAttribute = function (tag, attr, value) {
         /* Initialize shared config vars if necessary. */
         if (!CONFIG) {
           _parseConfig({});
         }
-        var lcTag = transformCaseFunc(tag);
-        var lcName = transformCaseFunc(attr);
+        var lcTag = stringToLowerCase(tag);
+        var lcName = stringToLowerCase(attr);
         return _isValidAttribute(lcTag, lcName, value);
       };
+
       /**
        * AddHook
        * Public method to add DOMPurify hooks
@@ -43470,7 +43204,6 @@ var purify$2 = {exports: {}};
        * @param {String} entryPoint entry point for the hook to add
        * @param {Function} hookFunction function to execute
        */
-
       DOMPurify.addHook = function (entryPoint, hookFunction) {
         if (typeof hookFunction !== 'function') {
           return;
@@ -43478,38 +43211,37 @@ var purify$2 = {exports: {}};
         hooks[entryPoint] = hooks[entryPoint] || [];
         arrayPush(hooks[entryPoint], hookFunction);
       };
+
       /**
        * RemoveHook
        * Public method to remove a DOMPurify hook at a given entryPoint
        * (pops it from the stack of hooks if more are present)
        *
        * @param {String} entryPoint entry point for the hook to remove
-       * @return {Function} removed(popped) hook
        */
-
       DOMPurify.removeHook = function (entryPoint) {
         if (hooks[entryPoint]) {
-          return arrayPop(hooks[entryPoint]);
+          arrayPop(hooks[entryPoint]);
         }
       };
+
       /**
        * RemoveHooks
        * Public method to remove all DOMPurify hooks at a given entryPoint
        *
        * @param  {String} entryPoint entry point for the hooks to remove
        */
-
       DOMPurify.removeHooks = function (entryPoint) {
         if (hooks[entryPoint]) {
           hooks[entryPoint] = [];
         }
       };
+
       /**
        * RemoveAllHooks
        * Public method to remove all DOMPurify hooks
        *
        */
-
       DOMPurify.removeAllHooks = function () {
         hooks = {};
       };
@@ -43532,7 +43264,7 @@ var check = function (it) {
 };
 
 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
-var global$l =
+var globalThis_1 =
   // eslint-disable-next-line es/no-global-this -- safe
   check(typeof globalThis == 'object' && globalThis) ||
   check(typeof window == 'object' && window) ||
@@ -43594,7 +43326,7 @@ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
   return !!descriptor && descriptor.enumerable;
 } : $propertyIsEnumerable;
 
-var createPropertyDescriptor$4 = function (bitmap, value) {
+var createPropertyDescriptor$3 = function (bitmap, value) {
   return {
     enumerable: !(bitmap & 1),
     configurable: !(bitmap & 2),
@@ -43615,21 +43347,21 @@ var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) {
   };
 };
 
-var uncurryThis$p = functionUncurryThis;
+var uncurryThis$o = functionUncurryThis;
 
-var toString$b = uncurryThis$p({}.toString);
-var stringSlice$7 = uncurryThis$p(''.slice);
+var toString$b = uncurryThis$o({}.toString);
+var stringSlice$7 = uncurryThis$o(''.slice);
 
 var classofRaw$2 = function (it) {
   return stringSlice$7(toString$b(it), 8, -1);
 };
 
-var uncurryThis$o = functionUncurryThis;
+var uncurryThis$n = functionUncurryThis;
 var fails$i = fails$l;
 var classof$8 = classofRaw$2;
 
 var $Object$4 = Object;
-var split = uncurryThis$o(''.split);
+var split = uncurryThis$n(''.split);
 
 // fallback for non-array-like ES3 and non-enumerable old V8 strings
 var indexedObject = fails$i(function () {
@@ -43652,75 +43384,64 @@ var $TypeError$f = TypeError;
 
 // `RequireObjectCoercible` abstract operation
 // https://tc39.es/ecma262/#sec-requireobjectcoercible
-var requireObjectCoercible$a = function (it) {
+var requireObjectCoercible$b = function (it) {
   if (isNullOrUndefined$6(it)) throw new $TypeError$f("Can't call method on " + it);
   return it;
 };
 
 // toObject with fallback for non-array-like ES3 strings
 var IndexedObject$1 = indexedObject;
-var requireObjectCoercible$9 = requireObjectCoercible$a;
+var requireObjectCoercible$a = requireObjectCoercible$b;
 
 var toIndexedObject$5 = function (it) {
-  return IndexedObject$1(requireObjectCoercible$9(it));
+  return IndexedObject$1(requireObjectCoercible$a(it));
 };
 
-var documentAll$2 = typeof document == 'object' && document.all;
-
 // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
-// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
-var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined;
-
-var documentAll_1 = {
-  all: documentAll$2,
-  IS_HTMLDDA: IS_HTMLDDA
-};
-
-var $documentAll$1 = documentAll_1;
-
-var documentAll$1 = $documentAll$1.all;
+var documentAll = typeof document == 'object' && document.all;
 
 // `IsCallable` abstract operation
 // https://tc39.es/ecma262/#sec-iscallable
-var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) {
-  return typeof argument == 'function' || argument === documentAll$1;
+// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+var isCallable$l = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+  return typeof argument == 'function' || argument === documentAll;
 } : function (argument) {
   return typeof argument == 'function';
 };
 
-var isCallable$l = isCallable$m;
-var $documentAll = documentAll_1;
+var isCallable$k = isCallable$l;
 
-var documentAll = $documentAll.all;
-
-var isObject$9 = $documentAll.IS_HTMLDDA ? function (it) {
-  return typeof it == 'object' ? it !== null : isCallable$l(it) || it === documentAll;
-} : function (it) {
-  return typeof it == 'object' ? it !== null : isCallable$l(it);
+var isObject$b = function (it) {
+  return typeof it == 'object' ? it !== null : isCallable$k(it);
 };
 
-var global$k = global$l;
-var isCallable$k = isCallable$m;
+var globalThis$m = globalThis_1;
+var isCallable$j = isCallable$l;
 
 var aFunction = function (argument) {
-  return isCallable$k(argument) ? argument : undefined;
+  return isCallable$j(argument) ? argument : undefined;
 };
 
 var getBuiltIn$7 = function (namespace, method) {
-  return arguments.length < 2 ? aFunction(global$k[namespace]) : global$k[namespace] && global$k[namespace][method];
+  return arguments.length < 2 ? aFunction(globalThis$m[namespace]) : globalThis$m[namespace] && globalThis$m[namespace][method];
 };
 
-var uncurryThis$n = functionUncurryThis;
+var uncurryThis$m = functionUncurryThis;
+
+var objectIsPrototypeOf = uncurryThis$m({}.isPrototypeOf);
 
-var objectIsPrototypeOf = uncurryThis$n({}.isPrototypeOf);
+var globalThis$l = globalThis_1;
 
-var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
+var navigator$1 = globalThis$l.navigator;
+var userAgent$5 = navigator$1 && navigator$1.userAgent;
 
-var global$j = global$l;
-var userAgent$3 = engineUserAgent;
+var environmentUserAgent = userAgent$5 ? String(userAgent$5) : '';
 
-var process$4 = global$j.process;
-var Deno$1 = global$j.Deno;
+var globalThis$k = globalThis_1;
+var userAgent$4 = environmentUserAgent;
+
+var process$4 = globalThis$k.process;
+var Deno$1 = globalThis$k.Deno;
 var versions = process$4 && process$4.versions || Deno$1 && Deno$1.version;
 var v8 = versions && versions.v8;
 var match, version;
@@ -43734,22 +43455,22 @@ if (v8) {
 
 // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
 // so check `userAgent` even if `.v8` exists, but 0
-if (!version && userAgent$3) {
-  match = userAgent$3.match(/Edge\/(\d+)/);
+if (!version && userAgent$4) {
+  match = userAgent$4.match(/Edge\/(\d+)/);
   if (!match || match[1] >= 74) {
-    match = userAgent$3.match(/Chrome\/(\d+)/);
+    match = userAgent$4.match(/Chrome\/(\d+)/);
     if (match) version = +match[1];
   }
 }
 
-var engineV8Version = version;
+var environmentV8Version = version;
 
 /* eslint-disable es/no-symbol -- required for testing */
-var V8_VERSION$1 = engineV8Version;
+var V8_VERSION$1 = environmentV8Version;
 var fails$h = fails$l;
-var global$i = global$l;
+var globalThis$j = globalThis_1;
 
-var $String$5 = global$i.String;
+var $String$5 = globalThis$j.String;
 
 // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
 var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$h(function () {
@@ -43771,7 +43492,7 @@ var useSymbolAsUid = NATIVE_SYMBOL$1
   && typeof Symbol.iterator == 'symbol';
 
 var getBuiltIn$6 = getBuiltIn$7;
-var isCallable$j = isCallable$m;
+var isCallable$i = isCallable$l;
 var isPrototypeOf$3 = objectIsPrototypeOf;
 var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
 
@@ -43781,7 +43502,7 @@ var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
   return typeof it == 'symbol';
 } : function (it) {
   var $Symbol = getBuiltIn$6('Symbol');
-  return isCallable$j($Symbol) && isPrototypeOf$3($Symbol.prototype, $Object$3(it));
+  return isCallable$i($Symbol) && isPrototypeOf$3($Symbol.prototype, $Object$3(it));
 };
 
 var $String$4 = String;
@@ -43794,14 +43515,14 @@ var tryToString$4 = function (argument) {
   }
 };
 
-var isCallable$i = isCallable$m;
+var isCallable$h = isCallable$l;
 var tryToString$3 = tryToString$4;
 
 var $TypeError$e = TypeError;
 
 // `Assert: IsCallable(argument) is true`
 var aCallable$9 = function (argument) {
-  if (isCallable$i(argument)) return argument;
+  if (isCallable$h(argument)) return argument;
   throw new $TypeError$e(tryToString$3(argument) + ' is not a function');
 };
 
@@ -43816,8 +43537,8 @@ var getMethod$6 = function (V, P) {
 };
 
 var call$h = functionCall;
-var isCallable$h = isCallable$m;
-var isObject$8 = isObject$9;
+var isCallable$g = isCallable$l;
+var isObject$a = isObject$b;
 
 var $TypeError$d = TypeError;
 
@@ -43825,63 +43546,63 @@ var $TypeError$d = TypeError;
 // https://tc39.es/ecma262/#sec-ordinarytoprimitive
 var ordinaryToPrimitive$1 = function (input, pref) {
   var fn, val;
-  if (pref === 'string' && isCallable$h(fn = input.toString) && !isObject$8(val = call$h(fn, input))) return val;
-  if (isCallable$h(fn = input.valueOf) && !isObject$8(val = call$h(fn, input))) return val;
-  if (pref !== 'string' && isCallable$h(fn = input.toString) && !isObject$8(val = call$h(fn, input))) return val;
+  if (pref === 'string' && isCallable$g(fn = input.toString) && !isObject$a(val = call$h(fn, input))) return val;
+  if (isCallable$g(fn = input.valueOf) && !isObject$a(val = call$h(fn, input))) return val;
+  if (pref !== 'string' && isCallable$g(fn = input.toString) && !isObject$a(val = call$h(fn, input))) return val;
   throw new $TypeError$d("Can't convert object to primitive value");
 };
 
-var shared$4 = {exports: {}};
+var sharedStore = {exports: {}};
 
-var global$h = global$l;
+var globalThis$i = globalThis_1;
 
 // eslint-disable-next-line es/no-object-defineproperty -- safe
 var defineProperty$5 = Object.defineProperty;
 
 var defineGlobalProperty$3 = function (key, value) {
   try {
-    defineProperty$5(global$h, key, { value: value, configurable: true, writable: true });
+    defineProperty$5(globalThis$i, key, { value: value, configurable: true, writable: true });
   } catch (error) {
-    global$h[key] = value;
+    globalThis$i[key] = value;
   } return value;
 };
 
-var global$g = global$l;
+var globalThis$h = globalThis_1;
 var defineGlobalProperty$2 = defineGlobalProperty$3;
 
 var SHARED = '__core-js_shared__';
-var store$3 = global$g[SHARED] || defineGlobalProperty$2(SHARED, {});
-
-var sharedStore = store$3;
+var store$3 = sharedStore.exports = globalThis$h[SHARED] || defineGlobalProperty$2(SHARED, {});
 
-var store$2 = sharedStore;
-
-(shared$4.exports = function (key, value) {
-  return store$2[key] || (store$2[key] = value !== undefined ? value : {});
-})('versions', []).push({
-  version: '3.34.0',
+(store$3.versions || (store$3.versions = [])).push({
+  version: '3.38.0',
   mode: 'global',
-  copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',
-  license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',
+  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
+  license: 'https://github.com/zloirock/core-js/blob/v3.38.0/LICENSE',
   source: 'https://github.com/zloirock/core-js'
 });
 
-var sharedExports = shared$4.exports;
+var sharedStoreExports = sharedStore.exports;
+
+var store$2 = sharedStoreExports;
 
-var requireObjectCoercible$8 = requireObjectCoercible$a;
+var shared$4 = function (key, value) {
+  return store$2[key] || (store$2[key] = value || {});
+};
+
+var requireObjectCoercible$9 = requireObjectCoercible$b;
 
 var $Object$2 = Object;
 
 // `ToObject` abstract operation
 // https://tc39.es/ecma262/#sec-toobject
 var toObject$4 = function (argument) {
-  return $Object$2(requireObjectCoercible$8(argument));
+  return $Object$2(requireObjectCoercible$9(argument));
 };
 
-var uncurryThis$m = functionUncurryThis;
+var uncurryThis$l = functionUncurryThis;
 var toObject$3 = toObject$4;
 
-var hasOwnProperty = uncurryThis$m({}.hasOwnProperty);
+var hasOwnProperty = uncurryThis$l({}.hasOwnProperty);
 
 // `HasOwnProperty` abstract operation
 // https://tc39.es/ecma262/#sec-hasownproperty
@@ -43890,24 +43611,24 @@ var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
   return hasOwnProperty(toObject$3(it), key);
 };
 
-var uncurryThis$l = functionUncurryThis;
+var uncurryThis$k = functionUncurryThis;
 
 var id$1 = 0;
 var postfix = Math.random();
-var toString$a = uncurryThis$l(1.0.toString);
+var toString$a = uncurryThis$k(1.0.toString);
 
 var uid$2 = function (key) {
   return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$a(++id$1 + postfix, 36);
 };
 
-var global$f = global$l;
-var shared$3 = sharedExports;
+var globalThis$g = globalThis_1;
+var shared$3 = shared$4;
 var hasOwn$a = hasOwnProperty_1;
 var uid$1 = uid$2;
 var NATIVE_SYMBOL = symbolConstructorDetection;
 var USE_SYMBOL_AS_UID = useSymbolAsUid;
 
-var Symbol$1 = global$f.Symbol;
+var Symbol$1 = globalThis$g.Symbol;
 var WellKnownSymbolsStore = shared$3('wks');
 var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
 
@@ -43920,7 +43641,7 @@ var wellKnownSymbol$i = function (name) {
 };
 
 var call$g = functionCall;
-var isObject$7 = isObject$9;
+var isObject$9 = isObject$b;
 var isSymbol$1 = isSymbol$2;
 var getMethod$5 = getMethod$6;
 var ordinaryToPrimitive = ordinaryToPrimitive$1;
@@ -43931,57 +43652,57 @@ var TO_PRIMITIVE = wellKnownSymbol$h('toPrimitive');
 
 // `ToPrimitive` abstract operation
 // https://tc39.es/ecma262/#sec-toprimitive
-var toPrimitive$1 = function (input, pref) {
-  if (!isObject$7(input) || isSymbol$1(input)) return input;
+var toPrimitive$2 = function (input, pref) {
+  if (!isObject$9(input) || isSymbol$1(input)) return input;
   var exoticToPrim = getMethod$5(input, TO_PRIMITIVE);
   var result;
   if (exoticToPrim) {
     if (pref === undefined) pref = 'default';
     result = call$g(exoticToPrim, input, pref);
-    if (!isObject$7(result) || isSymbol$1(result)) return result;
+    if (!isObject$9(result) || isSymbol$1(result)) return result;
     throw new $TypeError$c("Can't convert object to primitive value");
   }
   if (pref === undefined) pref = 'number';
   return ordinaryToPrimitive(input, pref);
 };
 
-var toPrimitive = toPrimitive$1;
+var toPrimitive$1 = toPrimitive$2;
 var isSymbol = isSymbol$2;
 
 // `ToPropertyKey` abstract operation
 // https://tc39.es/ecma262/#sec-topropertykey
 var toPropertyKey$3 = function (argument) {
-  var key = toPrimitive(argument, 'string');
+  var key = toPrimitive$1(argument, 'string');
   return isSymbol(key) ? key : key + '';
 };
 
-var global$e = global$l;
-var isObject$6 = isObject$9;
+var globalThis$f = globalThis_1;
+var isObject$8 = isObject$b;
 
-var document$3 = global$e.document;
+var document$3 = globalThis$f.document;
 // typeof document.createElement is 'object' in old IE
-var EXISTS$1 = isObject$6(document$3) && isObject$6(document$3.createElement);
+var EXISTS$1 = isObject$8(document$3) && isObject$8(document$3.createElement);
 
 var documentCreateElement$2 = function (it) {
   return EXISTS$1 ? document$3.createElement(it) : {};
 };
 
-var DESCRIPTORS$9 = descriptors;
+var DESCRIPTORS$a = descriptors;
 var fails$g = fails$l;
 var createElement$1 = documentCreateElement$2;
 
 // Thanks to IE8 for its funny defineProperty
-var ie8DomDefine = !DESCRIPTORS$9 && !fails$g(function () {
+var ie8DomDefine = !DESCRIPTORS$a && !fails$g(function () {
   // eslint-disable-next-line es/no-object-defineproperty -- required for testing
   return Object.defineProperty(createElement$1('div'), 'a', {
     get: function () { return 7; }
   }).a !== 7;
 });
 
-var DESCRIPTORS$8 = descriptors;
+var DESCRIPTORS$9 = descriptors;
 var call$f = functionCall;
 var propertyIsEnumerableModule = objectPropertyIsEnumerable;
-var createPropertyDescriptor$3 = createPropertyDescriptor$4;
+var createPropertyDescriptor$2 = createPropertyDescriptor$3;
 var toIndexedObject$4 = toIndexedObject$5;
 var toPropertyKey$2 = toPropertyKey$3;
 var hasOwn$9 = hasOwnProperty_1;
@@ -43992,23 +43713,23 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
 
 // `Object.getOwnPropertyDescriptor` method
 // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
-objectGetOwnPropertyDescriptor.f = DESCRIPTORS$8 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
+objectGetOwnPropertyDescriptor.f = DESCRIPTORS$9 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
   O = toIndexedObject$4(O);
   P = toPropertyKey$2(P);
   if (IE8_DOM_DEFINE$1) try {
     return $getOwnPropertyDescriptor$1(O, P);
   } catch (error) { /* empty */ }
-  if (hasOwn$9(O, P)) return createPropertyDescriptor$3(!call$f(propertyIsEnumerableModule.f, O, P), O[P]);
+  if (hasOwn$9(O, P)) return createPropertyDescriptor$2(!call$f(propertyIsEnumerableModule.f, O, P), O[P]);
 };
 
 var objectDefineProperty = {};
 
-var DESCRIPTORS$7 = descriptors;
+var DESCRIPTORS$8 = descriptors;
 var fails$f = fails$l;
 
 // V8 ~ Chrome 36-
 // https://bugs.chromium.org/p/v8/issues/detail?id=3334
-var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$f(function () {
+var v8PrototypeDefineBug = DESCRIPTORS$8 && fails$f(function () {
   // eslint-disable-next-line es/no-object-defineproperty -- required for testing
   return Object.defineProperty(function () { /* empty */ }, 'prototype', {
     value: 42,
@@ -44016,21 +43737,21 @@ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$f(function () {
   }).prototype !== 42;
 });
 
-var isObject$5 = isObject$9;
+var isObject$7 = isObject$b;
 
 var $String$3 = String;
 var $TypeError$b = TypeError;
 
 // `Assert: Type(argument) is Object`
-var anObject$g = function (argument) {
-  if (isObject$5(argument)) return argument;
+var anObject$f = function (argument) {
+  if (isObject$7(argument)) return argument;
   throw new $TypeError$b($String$3(argument) + ' is not an object');
 };
 
-var DESCRIPTORS$6 = descriptors;
+var DESCRIPTORS$7 = descriptors;
 var IE8_DOM_DEFINE = ie8DomDefine;
 var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
-var anObject$f = anObject$g;
+var anObject$e = anObject$f;
 var toPropertyKey$1 = toPropertyKey$3;
 
 var $TypeError$a = TypeError;
@@ -44044,10 +43765,10 @@ var WRITABLE = 'writable';
 
 // `Object.defineProperty` method
 // https://tc39.es/ecma262/#sec-object.defineproperty
-objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
-  anObject$f(O);
+objectDefineProperty.f = DESCRIPTORS$7 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
+  anObject$e(O);
   P = toPropertyKey$1(P);
-  anObject$f(Attributes);
+  anObject$e(Attributes);
   if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
     var current = $getOwnPropertyDescriptor(O, P);
     if (current && current[WRITABLE]) {
@@ -44060,9 +43781,9 @@ objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
     }
   } return $defineProperty(O, P, Attributes);
 } : $defineProperty : function defineProperty(O, P, Attributes) {
-  anObject$f(O);
+  anObject$e(O);
   P = toPropertyKey$1(P);
-  anObject$f(Attributes);
+  anObject$e(Attributes);
   if (IE8_DOM_DEFINE) try {
     return $defineProperty(O, P, Attributes);
   } catch (error) { /* empty */ }
@@ -44071,12 +43792,12 @@ objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
   return O;
 };
 
-var DESCRIPTORS$5 = descriptors;
-var definePropertyModule$4 = objectDefineProperty;
-var createPropertyDescriptor$2 = createPropertyDescriptor$4;
+var DESCRIPTORS$6 = descriptors;
+var definePropertyModule$3 = objectDefineProperty;
+var createPropertyDescriptor$1 = createPropertyDescriptor$3;
 
-var createNonEnumerableProperty$5 = DESCRIPTORS$5 ? function (object, key, value) {
-  return definePropertyModule$4.f(object, key, createPropertyDescriptor$2(1, value));
+var createNonEnumerableProperty$5 = DESCRIPTORS$6 ? function (object, key, value) {
+  return definePropertyModule$3.f(object, key, createPropertyDescriptor$1(1, value));
 } : function (object, key, value) {
   object[key] = value;
   return object;
@@ -44084,17 +43805,17 @@ var createNonEnumerableProperty$5 = DESCRIPTORS$5 ? function (object, key, value
 
 var makeBuiltIn$3 = {exports: {}};
 
-var DESCRIPTORS$4 = descriptors;
+var DESCRIPTORS$5 = descriptors;
 var hasOwn$8 = hasOwnProperty_1;
 
 var FunctionPrototype$1 = Function.prototype;
 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-var getDescriptor = DESCRIPTORS$4 && Object.getOwnPropertyDescriptor;
+var getDescriptor = DESCRIPTORS$5 && Object.getOwnPropertyDescriptor;
 
 var EXISTS = hasOwn$8(FunctionPrototype$1, 'name');
 // additional protection from minified / mangled / dropped function names
 var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
-var CONFIGURABLE = EXISTS && (!DESCRIPTORS$4 || (DESCRIPTORS$4 && getDescriptor(FunctionPrototype$1, 'name').configurable));
+var CONFIGURABLE = EXISTS && (!DESCRIPTORS$5 || (DESCRIPTORS$5 && getDescriptor(FunctionPrototype$1, 'name').configurable));
 
 var functionName = {
   EXISTS: EXISTS,
@@ -44102,14 +43823,14 @@ var functionName = {
   CONFIGURABLE: CONFIGURABLE
 };
 
-var uncurryThis$k = functionUncurryThis;
-var isCallable$g = isCallable$m;
-var store$1 = sharedStore;
+var uncurryThis$j = functionUncurryThis;
+var isCallable$f = isCallable$l;
+var store$1 = sharedStoreExports;
 
-var functionToString = uncurryThis$k(Function.toString);
+var functionToString = uncurryThis$j(Function.toString);
 
 // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
-if (!isCallable$g(store$1.inspectSource)) {
+if (!isCallable$f(store$1.inspectSource)) {
   store$1.inspectSource = function (it) {
     return functionToString(it);
   };
@@ -44117,14 +43838,14 @@ if (!isCallable$g(store$1.inspectSource)) {
 
 var inspectSource$3 = store$1.inspectSource;
 
-var global$d = global$l;
-var isCallable$f = isCallable$m;
+var globalThis$e = globalThis_1;
+var isCallable$e = isCallable$l;
 
-var WeakMap$2 = global$d.WeakMap;
+var WeakMap$2 = globalThis$e.WeakMap;
 
-var weakMapBasicDetection = isCallable$f(WeakMap$2) && /native code/.test(String(WeakMap$2));
+var weakMapBasicDetection = isCallable$e(WeakMap$2) && /native code/.test(String(WeakMap$2));
 
-var shared$2 = sharedExports;
+var shared$2 = shared$4;
 var uid = uid$2;
 
 var keys = shared$2('keys');
@@ -44136,17 +43857,17 @@ var sharedKey$3 = function (key) {
 var hiddenKeys$4 = {};
 
 var NATIVE_WEAK_MAP = weakMapBasicDetection;
-var global$c = global$l;
-var isObject$4 = isObject$9;
+var globalThis$d = globalThis_1;
+var isObject$6 = isObject$b;
 var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
 var hasOwn$7 = hasOwnProperty_1;
-var shared$1 = sharedStore;
+var shared$1 = sharedStoreExports;
 var sharedKey$2 = sharedKey$3;
 var hiddenKeys$3 = hiddenKeys$4;
 
 var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
-var TypeError$2 = global$c.TypeError;
-var WeakMap$1 = global$c.WeakMap;
+var TypeError$2 = globalThis$d.TypeError;
+var WeakMap$1 = globalThis$d.WeakMap;
 var set$1, get, has;
 
 var enforce = function (it) {
@@ -44156,7 +43877,7 @@ var enforce = function (it) {
 var getterFor = function (TYPE) {
   return function (it) {
     var state;
-    if (!isObject$4(it) || (state = get(it)).type !== TYPE) {
+    if (!isObject$6(it) || (state = get(it)).type !== TYPE) {
       throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required');
     } return state;
   };
@@ -44206,11 +43927,11 @@ var internalState = {
   getterFor: getterFor
 };
 
-var uncurryThis$j = functionUncurryThis;
+var uncurryThis$i = functionUncurryThis;
 var fails$e = fails$l;
-var isCallable$e = isCallable$m;
+var isCallable$d = isCallable$l;
 var hasOwn$6 = hasOwnProperty_1;
-var DESCRIPTORS$3 = descriptors;
+var DESCRIPTORS$4 = descriptors;
 var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
 var inspectSource$2 = inspectSource$3;
 var InternalStateModule$2 = internalState;
@@ -44220,11 +43941,11 @@ var getInternalState$2 = InternalStateModule$2.get;
 var $String$2 = String;
 // eslint-disable-next-line es/no-object-defineproperty -- safe
 var defineProperty$4 = Object.defineProperty;
-var stringSlice$6 = uncurryThis$j(''.slice);
-var replace$3 = uncurryThis$j(''.replace);
-var join = uncurryThis$j([].join);
+var stringSlice$6 = uncurryThis$i(''.slice);
+var replace$3 = uncurryThis$i(''.replace);
+var join = uncurryThis$i([].join);
 
-var CONFIGURABLE_LENGTH = DESCRIPTORS$3 && !fails$e(function () {
+var CONFIGURABLE_LENGTH = DESCRIPTORS$4 && !fails$e(function () {
   return defineProperty$4(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
 });
 
@@ -44232,12 +43953,12 @@ var TEMPLATE = String(String).split('String');
 
 var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
   if (stringSlice$6($String$2(name), 0, 7) === 'Symbol(') {
-    name = '[' + replace$3($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']';
+    name = '[' + replace$3($String$2(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
   }
   if (options && options.getter) name = 'get ' + name;
   if (options && options.setter) name = 'set ' + name;
   if (!hasOwn$6(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
-    if (DESCRIPTORS$3) defineProperty$4(value, 'name', { value: name, configurable: true });
+    if (DESCRIPTORS$4) defineProperty$4(value, 'name', { value: name, configurable: true });
     else value.name = name;
   }
   if (CONFIGURABLE_LENGTH && options && hasOwn$6(options, 'arity') && value.length !== options.arity) {
@@ -44245,7 +43966,7 @@ var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
   }
   try {
     if (options && hasOwn$6(options, 'constructor') && options.constructor) {
-      if (DESCRIPTORS$3) defineProperty$4(value, 'prototype', { writable: false });
+      if (DESCRIPTORS$4) defineProperty$4(value, 'prototype', { writable: false });
     // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
     } else if (value.prototype) value.prototype = undefined;
   } catch (error) { /* empty */ }
@@ -44258,13 +43979,13 @@ var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
 // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
 // eslint-disable-next-line no-extend-native -- required
 Function.prototype.toString = makeBuiltIn$2(function toString() {
-  return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this);
+  return isCallable$d(this) && getInternalState$2(this).source || inspectSource$2(this);
 }, 'toString');
 
 var makeBuiltInExports = makeBuiltIn$3.exports;
 
-var isCallable$d = isCallable$m;
-var definePropertyModule$3 = objectDefineProperty;
+var isCallable$c = isCallable$l;
+var definePropertyModule$2 = objectDefineProperty;
 var makeBuiltIn$1 = makeBuiltInExports;
 var defineGlobalProperty$1 = defineGlobalProperty$3;
 
@@ -44272,7 +43993,7 @@ var defineBuiltIn$7 = function (O, key, value, options) {
   if (!options) options = {};
   var simple = options.enumerable;
   var name = options.name !== undefined ? options.name : key;
-  if (isCallable$d(value)) makeBuiltIn$1(value, name, options);
+  if (isCallable$c(value)) makeBuiltIn$1(value, name, options);
   if (options.global) {
     if (simple) O[key] = value;
     else defineGlobalProperty$1(key, value);
@@ -44282,7 +44003,7 @@ var defineBuiltIn$7 = function (O, key, value, options) {
       else if (O[key]) simple = true;
     } catch (error) { /* empty */ }
     if (simple) O[key] = value;
-    else definePropertyModule$3.f(O, key, {
+    else definePropertyModule$2.f(O, key, {
       value: value,
       enumerable: false,
       configurable: !options.nonConfigurable,
@@ -44316,15 +44037,15 @@ var toIntegerOrInfinity$4 = function (argument) {
 
 var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
 
-var max$2 = Math.max;
+var max$1 = Math.max;
 var min$5 = Math.min;
 
 // Helper for a popular repeating case of the spec:
 // Let integer be ? ToInteger(index).
 // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
-var toAbsoluteIndex$2 = function (index, length) {
+var toAbsoluteIndex$1 = function (index, length) {
   var integer = toIntegerOrInfinity$3(index);
-  return integer < 0 ? max$2(integer + length, 0) : min$5(integer, length);
+  return integer < 0 ? max$1(integer + length, 0) : min$5(integer, length);
 };
 
 var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
@@ -44334,27 +44055,29 @@ var min$4 = Math.min;
 // `ToLength` abstract operation
 // https://tc39.es/ecma262/#sec-tolength
 var toLength$6 = function (argument) {
-  return argument > 0 ? min$4(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+  var len = toIntegerOrInfinity$2(argument);
+  return len > 0 ? min$4(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
 };
 
 var toLength$5 = toLength$6;
 
 // `LengthOfArrayLike` abstract operation
 // https://tc39.es/ecma262/#sec-lengthofarraylike
-var lengthOfArrayLike$4 = function (obj) {
+var lengthOfArrayLike$3 = function (obj) {
   return toLength$5(obj.length);
 };
 
 var toIndexedObject$3 = toIndexedObject$5;
-var toAbsoluteIndex$1 = toAbsoluteIndex$2;
-var lengthOfArrayLike$3 = lengthOfArrayLike$4;
+var toAbsoluteIndex = toAbsoluteIndex$1;
+var lengthOfArrayLike$2 = lengthOfArrayLike$3;
 
 // `Array.prototype.{ indexOf, includes }` methods implementation
 var createMethod$3 = function (IS_INCLUDES) {
   return function ($this, el, fromIndex) {
     var O = toIndexedObject$3($this);
-    var length = lengthOfArrayLike$3(O);
-    var index = toAbsoluteIndex$1(fromIndex, length);
+    var length = lengthOfArrayLike$2(O);
+    if (length === 0) return !IS_INCLUDES && -1;
+    var index = toAbsoluteIndex(fromIndex, length);
     var value;
     // Array#includes uses SameValueZero equality algorithm
     // eslint-disable-next-line no-self-compare -- NaN check
@@ -44378,13 +44101,13 @@ var arrayIncludes = {
   indexOf: createMethod$3(false)
 };
 
-var uncurryThis$i = functionUncurryThis;
+var uncurryThis$h = functionUncurryThis;
 var hasOwn$5 = hasOwnProperty_1;
 var toIndexedObject$2 = toIndexedObject$5;
 var indexOf$1 = arrayIncludes.indexOf;
 var hiddenKeys$2 = hiddenKeys$4;
 
-var push$2 = uncurryThis$i([].push);
+var push$2 = uncurryThis$h([].push);
 
 var objectKeysInternal = function (object, names) {
   var O = toIndexedObject$2(object);
@@ -44428,16 +44151,16 @@ var objectGetOwnPropertySymbols = {};
 objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
 
 var getBuiltIn$5 = getBuiltIn$7;
-var uncurryThis$h = functionUncurryThis;
+var uncurryThis$g = functionUncurryThis;
 var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
 var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
-var anObject$e = anObject$g;
+var anObject$d = anObject$f;
 
-var concat$1 = uncurryThis$h([].concat);
+var concat$1 = uncurryThis$g([].concat);
 
 // all object keys, includes non-enumerable and symbols
 var ownKeys$4 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) {
-  var keys = getOwnPropertyNamesModule.f(anObject$e(it));
+  var keys = getOwnPropertyNamesModule.f(anObject$d(it));
   var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
   return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
 };
@@ -44445,11 +44168,11 @@ var ownKeys$4 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) {
 var hasOwn$4 = hasOwnProperty_1;
 var ownKeys$3 = ownKeys$4;
 var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
-var definePropertyModule$2 = objectDefineProperty;
+var definePropertyModule$1 = objectDefineProperty;
 
 var copyConstructorProperties$1 = function (target, source, exceptions) {
   var keys = ownKeys$3(source);
-  var defineProperty = definePropertyModule$2.f;
+  var defineProperty = definePropertyModule$1.f;
   var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
   for (var i = 0; i < keys.length; i++) {
     var key = keys[i];
@@ -44460,7 +44183,7 @@ var copyConstructorProperties$1 = function (target, source, exceptions) {
 };
 
 var fails$d = fails$l;
-var isCallable$c = isCallable$m;
+var isCallable$b = isCallable$l;
 
 var replacement = /#|\.prototype\./;
 
@@ -44468,7 +44191,7 @@ var isForced$2 = function (feature, detection) {
   var value = data[normalize(feature)];
   return value === POLYFILL ? true
     : value === NATIVE ? false
-    : isCallable$c(detection) ? fails$d(detection)
+    : isCallable$b(detection) ? fails$d(detection)
     : !!detection;
 };
 
@@ -44482,7 +44205,7 @@ var POLYFILL = isForced$2.POLYFILL = 'P';
 
 var isForced_1 = isForced$2;
 
-var global$b = global$l;
+var globalThis$c = globalThis_1;
 var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f;
 var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
 var defineBuiltIn$6 = defineBuiltIn$7;
@@ -44511,11 +44234,11 @@ var _export = function (options, source) {
   var STATIC = options.stat;
   var FORCED, target, key, targetProperty, sourceProperty, descriptor;
   if (GLOBAL) {
-    target = global$b;
+    target = globalThis$c;
   } else if (STATIC) {
-    target = global$b[TARGET] || defineGlobalProperty(TARGET, {});
+    target = globalThis$c[TARGET] || defineGlobalProperty(TARGET, {});
   } else {
-    target = (global$b[TARGET] || {}).prototype;
+    target = globalThis$c[TARGET] && globalThis$c[TARGET].prototype;
   }
   if (target) for (key in source) {
     sourceProperty = source[key];
@@ -44537,34 +44260,61 @@ var _export = function (options, source) {
   }
 };
 
-var global$a = global$l;
+/* global Bun, Deno -- detection */
+var globalThis$b = globalThis_1;
+var userAgent$3 = environmentUserAgent;
 var classof$7 = classofRaw$2;
 
-var engineIsNode = classof$7(global$a.process) === 'process';
+var userAgentStartsWith = function (string) {
+  return userAgent$3.slice(0, string.length) === string;
+};
 
-var uncurryThis$g = functionUncurryThis;
+var environment = (function () {
+  if (userAgentStartsWith('Bun/')) return 'BUN';
+  if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
+  if (userAgentStartsWith('Deno/')) return 'DENO';
+  if (userAgentStartsWith('Node.js/')) return 'NODE';
+  if (globalThis$b.Bun && typeof Bun.version == 'string') return 'BUN';
+  if (globalThis$b.Deno && typeof Deno.version == 'object') return 'DENO';
+  if (classof$7(globalThis$b.process) === 'process') return 'NODE';
+  if (globalThis$b.window && globalThis$b.document) return 'BROWSER';
+  return 'REST';
+})();
+
+var ENVIRONMENT$1 = environment;
+
+var environmentIsNode = ENVIRONMENT$1 === 'NODE';
+
+var uncurryThis$f = functionUncurryThis;
 var aCallable$7 = aCallable$9;
 
 var functionUncurryThisAccessor = function (object, key, method) {
   try {
     // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-    return uncurryThis$g(aCallable$7(Object.getOwnPropertyDescriptor(object, key)[method]));
+    return uncurryThis$f(aCallable$7(Object.getOwnPropertyDescriptor(object, key)[method]));
   } catch (error) { /* empty */ }
 };
 
-var isCallable$b = isCallable$m;
+var isObject$5 = isObject$b;
+
+var isPossiblePrototype$1 = function (argument) {
+  return isObject$5(argument) || argument === null;
+};
+
+var isPossiblePrototype = isPossiblePrototype$1;
 
 var $String$1 = String;
 var $TypeError$9 = TypeError;
 
 var aPossiblePrototype$1 = function (argument) {
-  if (typeof argument == 'object' || isCallable$b(argument)) return argument;
+  if (isPossiblePrototype(argument)) return argument;
   throw new $TypeError$9("Can't set " + $String$1(argument) + ' as a prototype');
 };
 
 /* eslint-disable no-proto -- safe */
 var uncurryThisAccessor = functionUncurryThisAccessor;
-var anObject$d = anObject$g;
+var isObject$4 = isObject$b;
+var requireObjectCoercible$8 = requireObjectCoercible$b;
 var aPossiblePrototype = aPossiblePrototype$1;
 
 // `Object.setPrototypeOf` method
@@ -44581,8 +44331,9 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
     CORRECT_SETTER = test instanceof Array;
   } catch (error) { /* empty */ }
   return function setPrototypeOf(O, proto) {
-    anObject$d(O);
+    requireObjectCoercible$8(O);
     aPossiblePrototype(proto);
+    if (!isObject$4(O)) return O;
     if (CORRECT_SETTER) setter(O, proto);
     else O.__proto__ = proto;
     return O;
@@ -44614,14 +44365,14 @@ var defineBuiltInAccessor$1 = function (target, name, descriptor) {
 var getBuiltIn$4 = getBuiltIn$7;
 var defineBuiltInAccessor = defineBuiltInAccessor$1;
 var wellKnownSymbol$f = wellKnownSymbol$i;
-var DESCRIPTORS$2 = descriptors;
+var DESCRIPTORS$3 = descriptors;
 
 var SPECIES$3 = wellKnownSymbol$f('species');
 
 var setSpecies$1 = function (CONSTRUCTOR_NAME) {
   var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME);
 
-  if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$3]) {
+  if (DESCRIPTORS$3 && Constructor && !Constructor[SPECIES$3]) {
     defineBuiltInAccessor(Constructor, SPECIES$3, {
       configurable: true,
       get: function () { return this; }
@@ -44648,7 +44399,7 @@ test$1[TO_STRING_TAG$1] = 'z';
 var toStringTagSupport = String(test$1) === '[object z]';
 
 var TO_STRING_TAG_SUPPORT = toStringTagSupport;
-var isCallable$a = isCallable$m;
+var isCallable$a = isCallable$l;
 var classofRaw$1 = classofRaw$2;
 var wellKnownSymbol$d = wellKnownSymbol$i;
 
@@ -44677,24 +44428,23 @@ var classof$6 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
     : (result = classofRaw$1(O)) === 'Object' && isCallable$a(O.callee) ? 'Arguments' : result;
 };
 
-var uncurryThis$f = functionUncurryThis;
+var uncurryThis$e = functionUncurryThis;
 var fails$c = fails$l;
-var isCallable$9 = isCallable$m;
+var isCallable$9 = isCallable$l;
 var classof$5 = classof$6;
 var getBuiltIn$3 = getBuiltIn$7;
 var inspectSource$1 = inspectSource$3;
 
 var noop$1 = function () { /* empty */ };
-var empty = [];
 var construct = getBuiltIn$3('Reflect', 'construct');
 var constructorRegExp = /^\s*(?:class|function)\b/;
-var exec$2 = uncurryThis$f(constructorRegExp.exec);
+var exec$1 = uncurryThis$e(constructorRegExp.exec);
 var INCORRECT_TO_STRING = !constructorRegExp.test(noop$1);
 
 var isConstructorModern = function isConstructor(argument) {
   if (!isCallable$9(argument)) return false;
   try {
-    construct(noop$1, empty, argument);
+    construct(noop$1, [], argument);
     return true;
   } catch (error) {
     return false;
@@ -44712,7 +44462,7 @@ var isConstructorLegacy = function isConstructor(argument) {
     // we can't check .prototype since constructors produced by .bind haven't it
     // `Function#toString` throws on some built-it function in some legacy engines
     // (for example, `DOMQuad` and similar in FF41-)
-    return INCORRECT_TO_STRING || !!exec$2(constructorRegExp, inspectSource$1(argument));
+    return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument));
   } catch (error) {
     return true;
   }
@@ -44741,7 +44491,7 @@ var aConstructor$1 = function (argument) {
   throw new $TypeError$7(tryToString$2(argument) + ' is not a constructor');
 };
 
-var anObject$c = anObject$g;
+var anObject$c = anObject$f;
 var aConstructor = aConstructor$1;
 var isNullOrUndefined$4 = isNullOrUndefined$7;
 var wellKnownSymbol$c = wellKnownSymbol$i;
@@ -44759,29 +44509,29 @@ var speciesConstructor$2 = function (O, defaultConstructor) {
 var NATIVE_BIND$1 = functionBindNative;
 
 var FunctionPrototype = Function.prototype;
-var apply$3 = FunctionPrototype.apply;
+var apply$2 = FunctionPrototype.apply;
 var call$e = FunctionPrototype.call;
 
 // eslint-disable-next-line es/no-reflect -- safe
-var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$e.bind(apply$3) : function () {
-  return call$e.apply(apply$3, arguments);
+var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$e.bind(apply$2) : function () {
+  return call$e.apply(apply$2, arguments);
 });
 
 var classofRaw = classofRaw$2;
-var uncurryThis$e = functionUncurryThis;
+var uncurryThis$d = functionUncurryThis;
 
 var functionUncurryThisClause = function (fn) {
   // Nashorn bug:
   //   https://github.com/zloirock/core-js/issues/1128
   //   https://github.com/zloirock/core-js/issues/1130
-  if (classofRaw(fn) === 'Function') return uncurryThis$e(fn);
+  if (classofRaw(fn) === 'Function') return uncurryThis$d(fn);
 };
 
-var uncurryThis$d = functionUncurryThisClause;
+var uncurryThis$c = functionUncurryThisClause;
 var aCallable$6 = aCallable$9;
 var NATIVE_BIND = functionBindNative;
 
-var bind$4 = uncurryThis$d(uncurryThis$d.bind);
+var bind$4 = uncurryThis$c(uncurryThis$c.bind);
 
 // optional / simple context binding
 var functionBindContext = function (fn, that) {
@@ -44795,9 +44545,9 @@ var getBuiltIn$2 = getBuiltIn$7;
 
 var html$2 = getBuiltIn$2('document', 'documentElement');
 
-var uncurryThis$c = functionUncurryThis;
+var uncurryThis$b = functionUncurryThis;
 
-var arraySlice$2 = uncurryThis$c([].slice);
+var arraySlice$1 = uncurryThis$b([].slice);
 
 var $TypeError$6 = TypeError;
 
@@ -44806,31 +44556,31 @@ var validateArgumentsLength$1 = function (passed, required) {
   return passed;
 };
 
-var userAgent$2 = engineUserAgent;
+var userAgent$2 = environmentUserAgent;
 
 // eslint-disable-next-line redos/no-vulnerable -- safe
-var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
+var environmentIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
 
-var global$9 = global$l;
-var apply$2 = functionApply;
+var globalThis$a = globalThis_1;
+var apply$1 = functionApply;
 var bind$3 = functionBindContext;
-var isCallable$8 = isCallable$m;
+var isCallable$8 = isCallable$l;
 var hasOwn$2 = hasOwnProperty_1;
 var fails$b = fails$l;
 var html$1 = html$2;
-var arraySlice$1 = arraySlice$2;
+var arraySlice = arraySlice$1;
 var createElement = documentCreateElement$2;
 var validateArgumentsLength = validateArgumentsLength$1;
-var IS_IOS$1 = engineIsIos;
-var IS_NODE$4 = engineIsNode;
-
-var set = global$9.setImmediate;
-var clear = global$9.clearImmediate;
-var process$3 = global$9.process;
-var Dispatch = global$9.Dispatch;
-var Function$1 = global$9.Function;
-var MessageChannel = global$9.MessageChannel;
-var String$1 = global$9.String;
+var IS_IOS$1 = environmentIsIos;
+var IS_NODE$3 = environmentIsNode;
+
+var set = globalThis$a.setImmediate;
+var clear = globalThis$a.clearImmediate;
+var process$3 = globalThis$a.process;
+var Dispatch = globalThis$a.Dispatch;
+var Function$1 = globalThis$a.Function;
+var MessageChannel = globalThis$a.MessageChannel;
+var String$1 = globalThis$a.String;
 var counter = 0;
 var queue$3 = {};
 var ONREADYSTATECHANGE = 'onreadystatechange';
@@ -44838,7 +44588,7 @@ var $location, defer, channel, port;
 
 fails$b(function () {
   // Deno throws a ReferenceError on `location` access without `--location` flag
-  $location = global$9.location;
+  $location = globalThis$a.location;
 });
 
 var run = function (id) {
@@ -44861,7 +44611,7 @@ var eventListener = function (event) {
 
 var globalPostMessageDefer = function (id) {
   // old engines have not location.origin
-  global$9.postMessage(String$1(id), $location.protocol + '//' + $location.host);
+  globalThis$a.postMessage(String$1(id), $location.protocol + '//' + $location.host);
 };
 
 // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
@@ -44869,9 +44619,9 @@ if (!set || !clear) {
   set = function setImmediate(handler) {
     validateArgumentsLength(arguments.length, 1);
     var fn = isCallable$8(handler) ? handler : Function$1(handler);
-    var args = arraySlice$1(arguments, 1);
+    var args = arraySlice(arguments, 1);
     queue$3[++counter] = function () {
-      apply$2(fn, undefined, args);
+      apply$1(fn, undefined, args);
     };
     defer(counter);
     return counter;
@@ -44880,7 +44630,7 @@ if (!set || !clear) {
     delete queue$3[id];
   };
   // Node.js 0.8-
-  if (IS_NODE$4) {
+  if (IS_NODE$3) {
     defer = function (id) {
       process$3.nextTick(runner(id));
     };
@@ -44899,14 +44649,14 @@ if (!set || !clear) {
   // Browsers with postMessage, skip WebWorkers
   // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
   } else if (
-    global$9.addEventListener &&
-    isCallable$8(global$9.postMessage) &&
-    !global$9.importScripts &&
+    globalThis$a.addEventListener &&
+    isCallable$8(globalThis$a.postMessage) &&
+    !globalThis$a.importScripts &&
     $location && $location.protocol !== 'file:' &&
     !fails$b(globalPostMessageDefer)
   ) {
     defer = globalPostMessageDefer;
-    global$9.addEventListener('message', eventListener, false);
+    globalThis$a.addEventListener('message', eventListener, false);
   // IE8-
   } else if (ONREADYSTATECHANGE in createElement('script')) {
     defer = function (id) {
@@ -44928,6 +44678,19 @@ var task$1 = {
   clear: clear
 };
 
+var globalThis$9 = globalThis_1;
+var DESCRIPTORS$2 = descriptors;
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
+
+// Avoid NodeJS experimental warning
+var safeGetBuiltIn$1 = function (name) {
+  if (!DESCRIPTORS$2) return globalThis$9[name];
+  var descriptor = getOwnPropertyDescriptor$2(globalThis$9, name);
+  return descriptor && descriptor.value;
+};
+
 var Queue$2 = function () {
   this.head = null;
   this.tail = null;
@@ -44953,31 +44716,29 @@ Queue$2.prototype = {
 
 var queue$2 = Queue$2;
 
-var userAgent$1 = engineUserAgent;
+var userAgent$1 = environmentUserAgent;
 
-var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined';
+var environmentIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined';
 
-var userAgent = engineUserAgent;
+var userAgent = environmentUserAgent;
 
-var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
+var environmentIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
 
-var global$8 = global$l;
+var globalThis$8 = globalThis_1;
+var safeGetBuiltIn = safeGetBuiltIn$1;
 var bind$2 = functionBindContext;
-var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
 var macrotask = task$1.set;
 var Queue$1 = queue$2;
-var IS_IOS = engineIsIos;
-var IS_IOS_PEBBLE = engineIsIosPebble;
-var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
-var IS_NODE$3 = engineIsNode;
-
-var MutationObserver$1 = global$8.MutationObserver || global$8.WebKitMutationObserver;
-var document$2 = global$8.document;
-var process$2 = global$8.process;
-var Promise$1 = global$8.Promise;
-// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
-var queueMicrotaskDescriptor = getOwnPropertyDescriptor$2(global$8, 'queueMicrotask');
-var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
+var IS_IOS = environmentIsIos;
+var IS_IOS_PEBBLE = environmentIsIosPebble;
+var IS_WEBOS_WEBKIT = environmentIsWebosWebkit;
+var IS_NODE$2 = environmentIsNode;
+
+var MutationObserver$1 = globalThis$8.MutationObserver || globalThis$8.WebKitMutationObserver;
+var document$2 = globalThis$8.document;
+var process$2 = globalThis$8.process;
+var Promise$1 = globalThis$8.Promise;
+var microtask$1 = safeGetBuiltIn('queueMicrotask');
 var notify$1, toggle, node$1, promise, then;
 
 // modern engines have queueMicrotask method
@@ -44986,7 +44747,7 @@ if (!microtask$1) {
 
   var flush = function () {
     var parent, fn;
-    if (IS_NODE$3 && (parent = process$2.domain)) parent.exit();
+    if (IS_NODE$2 && (parent = process$2.domain)) parent.exit();
     while (fn = queue$1.get()) try {
       fn();
     } catch (error) {
@@ -44998,7 +44759,7 @@ if (!microtask$1) {
 
   // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
   // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
-  if (!IS_IOS && !IS_NODE$3 && !IS_WEBOS_WEBKIT && MutationObserver$1 && document$2) {
+  if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver$1 && document$2) {
     toggle = true;
     node$1 = document$2.createTextNode('');
     new MutationObserver$1(flush).observe(node$1, { characterData: true });
@@ -45016,7 +44777,7 @@ if (!microtask$1) {
       then(flush);
     };
   // Node.js without promises
-  } else if (IS_NODE$3) {
+  } else if (IS_NODE$2) {
     notify$1 = function () {
       process$2.nextTick(flush);
     };
@@ -45028,7 +44789,7 @@ if (!microtask$1) {
   // - setTimeout
   } else {
     // `webpack` dev server bug on IE global methods - use bind(fn, global)
-    macrotask = bind$2(macrotask, global$8);
+    macrotask = bind$2(macrotask, globalThis$8);
     notify$1 = function () {
       macrotask(flush);
     };
@@ -45057,34 +44818,23 @@ var perform$3 = function (exec) {
   }
 };
 
-var global$7 = global$l;
-
-var promiseNativeConstructor = global$7.Promise;
-
-/* global Deno -- Deno case */
-var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
+var globalThis$7 = globalThis_1;
 
-var IS_DENO$1 = engineIsDeno;
-var IS_NODE$2 = engineIsNode;
+var promiseNativeConstructor = globalThis$7.Promise;
 
-var engineIsBrowser = !IS_DENO$1 && !IS_NODE$2
-  && typeof window == 'object'
-  && typeof document == 'object';
-
-var global$6 = global$l;
+var globalThis$6 = globalThis_1;
 var NativePromiseConstructor$3 = promiseNativeConstructor;
-var isCallable$7 = isCallable$m;
+var isCallable$7 = isCallable$l;
 var isForced = isForced_1;
 var inspectSource = inspectSource$3;
 var wellKnownSymbol$b = wellKnownSymbol$i;
-var IS_BROWSER = engineIsBrowser;
-var IS_DENO = engineIsDeno;
-var V8_VERSION = engineV8Version;
+var ENVIRONMENT = environment;
+var V8_VERSION = environmentV8Version;
 
 NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
 var SPECIES$1 = wellKnownSymbol$b('species');
 var SUBCLASSING = false;
-var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$6.PromiseRejectionEvent);
+var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(globalThis$6.PromiseRejectionEvent);
 
 var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () {
   var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3);
@@ -45107,7 +44857,7 @@ var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () {
     SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
     if (!SUBCLASSING) return true;
   // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
-  } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
+  } return !GLOBAL_CORE_JS_PROMISE && (ENVIRONMENT === 'BROWSER' || ENVIRONMENT === 'DENO') && !NATIVE_PROMISE_REJECTION_EVENT$1;
 });
 
 var promiseConstructorDetection = {
@@ -45140,16 +44890,16 @@ newPromiseCapability$2.f = function (C) {
 };
 
 var $$e = _export;
-var IS_NODE$1 = engineIsNode;
-var global$5 = global$l;
+var IS_NODE$1 = environmentIsNode;
+var globalThis$5 = globalThis_1;
 var call$d = functionCall;
 var defineBuiltIn$5 = defineBuiltIn$7;
 var setPrototypeOf$1 = objectSetPrototypeOf;
 var setToStringTag$3 = setToStringTag$4;
 var setSpecies = setSpecies$1;
 var aCallable$4 = aCallable$9;
-var isCallable$6 = isCallable$m;
-var isObject$3 = isObject$9;
+var isCallable$6 = isCallable$l;
+var isObject$3 = isObject$b;
 var anInstance = anInstance$1;
 var speciesConstructor$1 = speciesConstructor$2;
 var task = task$1.set;
@@ -45171,13 +44921,13 @@ var setInternalState$1 = InternalStateModule$1.set;
 var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype;
 var PromiseConstructor = NativePromiseConstructor$2;
 var PromisePrototype = NativePromisePrototype$1;
-var TypeError$1 = global$5.TypeError;
-var document$1 = global$5.document;
-var process$1 = global$5.process;
+var TypeError$1 = globalThis$5.TypeError;
+var document$1 = globalThis$5.document;
+var process$1 = globalThis$5.process;
 var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
 var newGenericPromiseCapability = newPromiseCapability$1;
 
-var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$5.dispatchEvent);
+var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && globalThis$5.dispatchEvent);
 var UNHANDLED_REJECTION = 'unhandledrejection';
 var REJECTION_HANDLED = 'rejectionhandled';
 var PENDING = 0;
@@ -45250,14 +45000,14 @@ var dispatchEvent = function (name, promise, reason) {
     event.promise = promise;
     event.reason = reason;
     event.initEvent(name, false, true);
-    global$5.dispatchEvent(event);
+    globalThis$5.dispatchEvent(event);
   } else event = { promise: promise, reason: reason };
-  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$5['on' + name])) handler(event);
+  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis$5['on' + name])) handler(event);
   else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
 };
 
 var onUnhandled = function (state) {
-  call$d(task, global$5, function () {
+  call$d(task, globalThis$5, function () {
     var promise = state.facade;
     var value = state.value;
     var IS_UNHANDLED = isUnhandled(state);
@@ -45280,7 +45030,7 @@ var isUnhandled = function (state) {
 };
 
 var onHandleUnhandled = function (state) {
-  call$d(task, global$5, function () {
+  call$d(task, globalThis$5, function () {
     var promise = state.facade;
     if (IS_NODE$1) {
       process$1.emit('rejectionHandled', promise);
@@ -45455,7 +45205,7 @@ var getIteratorMethod$2 = function (it) {
 
 var call$c = functionCall;
 var aCallable$3 = aCallable$9;
-var anObject$b = anObject$g;
+var anObject$b = anObject$f;
 var tryToString$1 = tryToString$4;
 var getIteratorMethod$1 = getIteratorMethod$2;
 
@@ -45468,7 +45218,7 @@ var getIterator$1 = function (argument, usingIterator) {
 };
 
 var call$b = functionCall;
-var anObject$a = anObject$g;
+var anObject$a = anObject$f;
 var getMethod$3 = getMethod$6;
 
 var iteratorClose$1 = function (iterator, kind, value) {
@@ -45493,10 +45243,10 @@ var iteratorClose$1 = function (iterator, kind, value) {
 
 var bind = functionBindContext;
 var call$a = functionCall;
-var anObject$9 = anObject$g;
+var anObject$9 = anObject$f;
 var tryToString = tryToString$4;
 var isArrayIteratorMethod = isArrayIteratorMethod$1;
-var lengthOfArrayLike$2 = lengthOfArrayLike$4;
+var lengthOfArrayLike$1 = lengthOfArrayLike$3;
 var isPrototypeOf$1 = objectIsPrototypeOf;
 var getIterator = getIterator$1;
 var getIteratorMethod = getIteratorMethod$2;
@@ -45541,7 +45291,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
     if (!iterFn) throw new $TypeError$3(tryToString(iterable) + ' is not iterable');
     // optimisation for array iterators
     if (isArrayIteratorMethod(iterFn)) {
-      for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) {
+      for (index = 0, length = lengthOfArrayLike$1(iterable); length > index; index++) {
         result = callFn(iterable[index]);
         if (result && isPrototypeOf$1(ResultPrototype, result)) return result;
       } return new Result(false);
@@ -45652,7 +45402,7 @@ var $$c = _export;
 var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
 var NativePromiseConstructor = promiseNativeConstructor;
 var getBuiltIn$1 = getBuiltIn$7;
-var isCallable$5 = isCallable$m;
+var isCallable$5 = isCallable$l;
 var defineBuiltIn$4 = defineBuiltIn$7;
 
 var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
@@ -45700,7 +45450,6 @@ $$b({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
 });
 
 var $$a = _export;
-var call$7 = functionCall;
 var newPromiseCapabilityModule = newPromiseCapability$2;
 var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
 
@@ -45709,13 +45458,14 @@ var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
 $$a({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
   reject: function reject(r) {
     var capability = newPromiseCapabilityModule.f(this);
-    call$7(capability.reject, undefined, r);
+    var capabilityReject = capability.reject;
+    capabilityReject(r);
     return capability.promise;
   }
 });
 
-var anObject$8 = anObject$g;
-var isObject$2 = isObject$9;
+var anObject$8 = anObject$f;
+var isObject$2 = isObject$b;
 var newPromiseCapability = newPromiseCapability$2;
 
 var promiseResolve$1 = function (C, x) {
@@ -45742,33 +45492,28 @@ $$9({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
   }
 });
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
   try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
   }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
 }
-function _asyncToGenerator(fn) {
+function _asyncToGenerator(n) {
   return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
       }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
       }
-      _next(undefined);
+      _next(void 0);
     });
   };
 }
@@ -45782,7 +45527,7 @@ var toString$9 = function (argument) {
   return $String(argument);
 };
 
-var anObject$7 = anObject$g;
+var anObject$7 = anObject$f;
 
 // `RegExp.prototype.flags` getter implementation
 // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
@@ -45801,10 +45546,10 @@ var regexpFlags$1 = function () {
 };
 
 var fails$a = fails$l;
-var global$4 = global$l;
+var globalThis$4 = globalThis_1;
 
 // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
-var $RegExp$2 = global$4.RegExp;
+var $RegExp$2 = globalThis$4.RegExp;
 
 var UNSUPPORTED_Y$2 = fails$a(function () {
   var re = $RegExp$2('a', 'y');
@@ -45845,8 +45590,8 @@ var objectKeys$1 = Object.keys || function keys(O) {
 
 var DESCRIPTORS$1 = descriptors;
 var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
-var definePropertyModule$1 = objectDefineProperty;
-var anObject$6 = anObject$g;
+var definePropertyModule = objectDefineProperty;
+var anObject$6 = anObject$f;
 var toIndexedObject$1 = toIndexedObject$5;
 var objectKeys = objectKeys$1;
 
@@ -45860,12 +45605,12 @@ objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.de
   var length = keys.length;
   var index = 0;
   var key;
-  while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
+  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
   return O;
 };
 
 /* global ActiveXObject -- old IE, WSH */
-var anObject$5 = anObject$g;
+var anObject$5 = anObject$f;
 var definePropertiesModule = objectDefineProperties;
 var enumBugKeys = enumBugKeys$3;
 var hiddenKeys = hiddenKeys$4;
@@ -45890,7 +45635,8 @@ var NullProtoObjectViaActiveX = function (activeXDocument) {
   activeXDocument.write(scriptTag(''));
   activeXDocument.close();
   var temp = activeXDocument.parentWindow.Object;
-  activeXDocument = null; // avoid memory leak
+  // eslint-disable-next-line no-useless-assignment -- avoid memory leak
+  activeXDocument = null;
   return temp;
 };
 
@@ -45949,10 +45695,10 @@ var objectCreate = Object.create || function create(O, Properties) {
 };
 
 var fails$9 = fails$l;
-var global$3 = global$l;
+var globalThis$3 = globalThis_1;
 
 // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
-var $RegExp$1 = global$3.RegExp;
+var $RegExp$1 = globalThis$3.RegExp;
 
 var regexpUnsupportedDotAll = fails$9(function () {
   var re = $RegExp$1('.', 's');
@@ -45960,10 +45706,10 @@ var regexpUnsupportedDotAll = fails$9(function () {
 });
 
 var fails$8 = fails$l;
-var global$2 = global$l;
+var globalThis$2 = globalThis_1;
 
 // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
-var $RegExp = global$2.RegExp;
+var $RegExp = globalThis$2.RegExp;
 
 var regexpUnsupportedNcg = fails$8(function () {
   var re = $RegExp('(?<a>b)', 'g');
@@ -45973,12 +45719,12 @@ var regexpUnsupportedNcg = fails$8(function () {
 
 /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
 /* eslint-disable regexp/no-useless-quantifier -- testing */
-var call$6 = functionCall;
-var uncurryThis$b = functionUncurryThis;
+var call$7 = functionCall;
+var uncurryThis$a = functionUncurryThis;
 var toString$8 = toString$9;
 var regexpFlags = regexpFlags$1;
 var stickyHelpers$1 = regexpStickyHelpers;
-var shared = sharedExports;
+var shared = shared$4;
 var create$2 = objectCreate;
 var getInternalState$1 = internalState.get;
 var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
@@ -45987,16 +45733,16 @@ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
 var nativeReplace = shared('native-string-replace', String.prototype.replace);
 var nativeExec = RegExp.prototype.exec;
 var patchedExec = nativeExec;
-var charAt$3 = uncurryThis$b(''.charAt);
-var indexOf = uncurryThis$b(''.indexOf);
-var replace$2 = uncurryThis$b(''.replace);
-var stringSlice$5 = uncurryThis$b(''.slice);
+var charAt$3 = uncurryThis$a(''.charAt);
+var indexOf = uncurryThis$a(''.indexOf);
+var replace$2 = uncurryThis$a(''.replace);
+var stringSlice$5 = uncurryThis$a(''.slice);
 
 var UPDATES_LAST_INDEX_WRONG = (function () {
   var re1 = /a/;
   var re2 = /b*/g;
-  call$6(nativeExec, re1, 'a');
-  call$6(nativeExec, re2, 'a');
+  call$7(nativeExec, re1, 'a');
+  call$7(nativeExec, re2, 'a');
   return re1.lastIndex !== 0 || re2.lastIndex !== 0;
 })();
 
@@ -46017,14 +45763,14 @@ if (PATCH) {
 
     if (raw) {
       raw.lastIndex = re.lastIndex;
-      result = call$6(patchedExec, raw, str);
+      result = call$7(patchedExec, raw, str);
       re.lastIndex = raw.lastIndex;
       return result;
     }
 
     var groups = state.groups;
     var sticky = UNSUPPORTED_Y$1 && re.sticky;
-    var flags = call$6(regexpFlags, re);
+    var flags = call$7(regexpFlags, re);
     var source = re.source;
     var charsAdded = 0;
     var strCopy = str;
@@ -46052,7 +45798,7 @@ if (PATCH) {
     }
     if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
 
-    match = call$6(nativeExec, sticky ? reCopy : re, strCopy);
+    match = call$7(nativeExec, sticky ? reCopy : re, strCopy);
 
     if (sticky) {
       if (match) {
@@ -46067,7 +45813,7 @@ if (PATCH) {
     if (NPCG_INCLUDED && match && match.length > 1) {
       // Fix browsers whose `exec` methods don't consistently return `undefined`
       // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
-      call$6(nativeReplace, match[0], reCopy, function () {
+      call$7(nativeReplace, match[0], reCopy, function () {
         for (i = 1; i < arguments.length - 2; i++) {
           if (arguments[i] === undefined) match[i] = undefined;
         }
@@ -46086,22 +45832,22 @@ if (PATCH) {
   };
 }
 
-var regexpExec$3 = patchedExec;
+var regexpExec$2 = patchedExec;
 
 var $$8 = _export;
-var exec$1 = regexpExec$3;
+var exec = regexpExec$2;
 
 // `RegExp.prototype.exec` method
 // https://tc39.es/ecma262/#sec-regexp.prototype.exec
-$$8({ target: 'RegExp', proto: true, forced: /./.exec !== exec$1 }, {
-  exec: exec$1
+$$8({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
+  exec: exec
 });
 
 // TODO: Remove from `core-js@4` since it's moved to entry points
 
-var uncurryThis$a = functionUncurryThisClause;
+var call$6 = functionCall;
 var defineBuiltIn$3 = defineBuiltIn$7;
-var regexpExec$2 = regexpExec$3;
+var regexpExec$1 = regexpExec$2;
 var fails$7 = fails$l;
 var wellKnownSymbol$7 = wellKnownSymbol$i;
 var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
@@ -46113,7 +45859,7 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
   var SYMBOL = wellKnownSymbol$7(KEY);
 
   var DELEGATES_TO_SYMBOL = !fails$7(function () {
-    // String methods call symbol-named RegEp methods
+    // String methods call symbol-named RegExp methods
     var O = {};
     O[SYMBOL] = function () { return 7; };
     return ''[KEY](O) !== 7;
@@ -46151,18 +45897,17 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
     !DELEGATES_TO_EXEC ||
     FORCED
   ) {
-    var uncurriedNativeRegExpMethod = uncurryThis$a(/./[SYMBOL]);
+    var nativeRegExpMethod = /./[SYMBOL];
     var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
-      var uncurriedNativeMethod = uncurryThis$a(nativeMethod);
       var $exec = regexp.exec;
-      if ($exec === regexpExec$2 || $exec === RegExpPrototype$2.exec) {
+      if ($exec === regexpExec$1 || $exec === RegExpPrototype$2.exec) {
         if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
           // The native String method already delegates to @@method (this
           // polyfilled function), leasing to infinite recursion.
           // We avoid it by directly calling the native @@method method.
-          return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };
+          return { done: true, value: call$6(nativeRegExpMethod, regexp, str, arg2) };
         }
-        return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };
+        return { done: true, value: call$6(nativeMethod, str, regexp, arg2) };
       }
       return { done: false };
     });
@@ -46177,7 +45922,7 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
 var uncurryThis$9 = functionUncurryThis;
 var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
 var toString$7 = toString$9;
-var requireObjectCoercible$7 = requireObjectCoercible$a;
+var requireObjectCoercible$7 = requireObjectCoercible$b;
 
 var charAt$2 = uncurryThis$9(''.charAt);
 var charCodeAt = uncurryThis$9(''.charCodeAt);
@@ -46220,10 +45965,10 @@ var advanceStringIndex$3 = function (S, index, unicode) {
 };
 
 var call$5 = functionCall;
-var anObject$4 = anObject$g;
-var isCallable$4 = isCallable$m;
+var anObject$4 = anObject$f;
+var isCallable$4 = isCallable$l;
 var classof$2 = classofRaw$2;
-var regexpExec$1 = regexpExec$3;
+var regexpExec = regexpExec$2;
 
 var $TypeError$2 = TypeError;
 
@@ -46236,20 +45981,20 @@ var regexpExecAbstract = function (R, S) {
     if (result !== null) anObject$4(result);
     return result;
   }
-  if (classof$2(R) === 'RegExp') return call$5(regexpExec$1, R, S);
+  if (classof$2(R) === 'RegExp') return call$5(regexpExec, R, S);
   throw new $TypeError$2('RegExp#exec called on incompatible receiver');
 };
 
 var call$4 = functionCall;
 var fixRegExpWellKnownSymbolLogic$2 = fixRegexpWellKnownSymbolLogic;
-var anObject$3 = anObject$g;
+var anObject$3 = anObject$f;
 var isNullOrUndefined$2 = isNullOrUndefined$7;
 var toLength$4 = toLength$6;
 var toString$6 = toString$9;
-var requireObjectCoercible$6 = requireObjectCoercible$a;
+var requireObjectCoercible$6 = requireObjectCoercible$b;
 var getMethod$2 = getMethod$6;
 var advanceStringIndex$2 = advanceStringIndex$3;
-var regExpExec$1 = regexpExecAbstract;
+var regExpExec$2 = regexpExecAbstract;
 
 // @@match logic
 fixRegExpWellKnownSymbolLogic$2('match', function (MATCH, nativeMatch, maybeCallNative) {
@@ -46270,14 +46015,14 @@ fixRegExpWellKnownSymbolLogic$2('match', function (MATCH, nativeMatch, maybeCall
 
       if (res.done) return res.value;
 
-      if (!rx.global) return regExpExec$1(rx, S);
+      if (!rx.global) return regExpExec$2(rx, S);
 
       var fullUnicode = rx.unicode;
       rx.lastIndex = 0;
       var A = [];
       var n = 0;
       var result;
-      while ((result = regExpExec$1(rx, S)) !== null) {
+      while ((result = regExpExec$2(rx, S)) !== null) {
         var matchStr = toString$6(result[0]);
         A[n] = matchStr;
         if (matchStr === '') rx.lastIndex = advanceStringIndex$2(S, toLength$4(rx.lastIndex), fullUnicode);
@@ -46334,26 +46079,26 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
   });
 };
 
-var apply$1 = functionApply;
+var apply = functionApply;
 var call$3 = functionCall;
 var uncurryThis$7 = functionUncurryThis;
 var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
 var fails$6 = fails$l;
-var anObject$2 = anObject$g;
-var isCallable$3 = isCallable$m;
+var anObject$2 = anObject$f;
+var isCallable$3 = isCallable$l;
 var isNullOrUndefined$1 = isNullOrUndefined$7;
 var toIntegerOrInfinity = toIntegerOrInfinity$4;
 var toLength$3 = toLength$6;
 var toString$5 = toString$9;
-var requireObjectCoercible$5 = requireObjectCoercible$a;
+var requireObjectCoercible$5 = requireObjectCoercible$b;
 var advanceStringIndex$1 = advanceStringIndex$3;
 var getMethod$1 = getMethod$6;
 var getSubstitution = getSubstitution$1;
-var regExpExec = regexpExecAbstract;
+var regExpExec$1 = regexpExecAbstract;
 var wellKnownSymbol$6 = wellKnownSymbol$i;
 
 var REPLACE = wellKnownSymbol$6('replace');
-var max$1 = Math.max;
+var max = Math.max;
 var min$3 = Math.min;
 var concat = uncurryThis$7([].concat);
 var push$1 = uncurryThis$7([].push);
@@ -46432,7 +46177,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
       var results = [];
       var result;
       while (true) {
-        result = regExpExec(rx, S);
+        result = regExpExec$1(rx, S);
         if (result === null) break;
 
         push$1(results, result);
@@ -46448,7 +46193,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
         result = results[i];
 
         var matched = toString$5(result[0]);
-        var position = max$1(min$3(toIntegerOrInfinity(result.index), S.length), 0);
+        var position = max(min$3(toIntegerOrInfinity(result.index), S.length), 0);
         var captures = [];
         var replacement;
         // NOTE: This is equivalent to
@@ -46461,7 +46206,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
         if (functionalReplace) {
           var replacerArgs = concat([matched], captures, position, S);
           if (namedCaptures !== undefined) push$1(replacerArgs, namedCaptures);
-          replacement = toString$5(apply$1(replaceValue, undefined, replacerArgs));
+          replacement = toString$5(apply(replaceValue, undefined, replacerArgs));
         } else {
           replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
         }
@@ -46476,7 +46221,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
   ];
 }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
 
-var isObject$1 = isObject$9;
+var isObject$1 = isObject$b;
 var classof$1 = classofRaw$2;
 var wellKnownSymbol$5 = wellKnownSymbol$i;
 
@@ -46489,12 +46234,12 @@ var isRegexp = function (it) {
   return isObject$1(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) === 'RegExp');
 };
 
-var isRegExp$1 = isRegexp;
+var isRegExp = isRegexp;
 
 var $TypeError$1 = TypeError;
 
 var notARegexp = function (it) {
-  if (isRegExp$1(it)) {
+  if (isRegExp(it)) {
     throw new $TypeError$1("The method doesn't accept regular expressions");
   } return it;
 };
@@ -46521,11 +46266,9 @@ var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
 var toLength$2 = toLength$6;
 var toString$4 = toString$9;
 var notARegExp$2 = notARegexp;
-var requireObjectCoercible$4 = requireObjectCoercible$a;
+var requireObjectCoercible$4 = requireObjectCoercible$b;
 var correctIsRegExpLogic$2 = correctIsRegexpLogic;
 
-// eslint-disable-next-line es/no-string-prototype-startswith -- safe
-var nativeStartsWith = uncurryThis$6(''.startsWith);
 var stringSlice$1 = uncurryThis$6(''.slice);
 var min$2 = Math.min;
 
@@ -46544,9 +46287,7 @@ $$7({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG$1 && !CORRECT_IS_
     notARegExp$2(searchString);
     var index = toLength$2(min$2(arguments.length > 1 ? arguments[1] : undefined, that.length));
     var search = toString$4(searchString);
-    return nativeStartsWith
-      ? nativeStartsWith(that, search, index)
-      : stringSlice$1(that, index, index + search.length) === search;
+    return stringSlice$1(that, index, index + search.length) === search;
   }
 });
 
@@ -46581,7 +46322,7 @@ var correctPrototypeGetter = !fails$5(function () {
 });
 
 var hasOwn$1 = hasOwnProperty_1;
-var isCallable$2 = isCallable$m;
+var isCallable$2 = isCallable$l;
 var toObject$1 = toObject$4;
 var sharedKey = sharedKey$3;
 var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
@@ -46603,8 +46344,8 @@ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : f
 };
 
 var fails$4 = fails$l;
-var isCallable$1 = isCallable$m;
-var isObject = isObject$9;
+var isCallable$1 = isCallable$l;
+var isObject = isObject$b;
 var getPrototypeOf$1 = objectGetPrototypeOf;
 var defineBuiltIn$2 = defineBuiltIn$7;
 var wellKnownSymbol$2 = wellKnownSymbol$i;
@@ -46650,7 +46391,7 @@ var iteratorsCore = {
 
 var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
 var create = objectCreate;
-var createPropertyDescriptor$1 = createPropertyDescriptor$4;
+var createPropertyDescriptor = createPropertyDescriptor$3;
 var setToStringTag$2 = setToStringTag$4;
 var Iterators$2 = iterators;
 
@@ -46658,7 +46399,7 @@ var returnThis$1 = function () { return this; };
 
 var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
   var TO_STRING_TAG = NAME + ' Iterator';
-  IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) });
+  IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
   setToStringTag$2(IteratorConstructor, TO_STRING_TAG, false);
   Iterators$2[TO_STRING_TAG] = returnThis$1;
   return IteratorConstructor;
@@ -46667,7 +46408,7 @@ var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUME
 var $$6 = _export;
 var call$2 = functionCall;
 var FunctionName = functionName;
-var isCallable = isCallable$m;
+var isCallable = isCallable$l;
 var createIteratorConstructor = iteratorCreateConstructor;
 var getPrototypeOf = objectGetPrototypeOf;
 var setPrototypeOf = objectSetPrototypeOf;
@@ -46875,7 +46616,7 @@ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.co
 
 var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
 
-var global$1 = global$l;
+var globalThis$1 = globalThis_1;
 var DOMIterables = domIterables;
 var DOMTokenListPrototype = domTokenListPrototype;
 var ArrayIteratorMethods = es_array_iterator;
@@ -46907,56 +46648,53 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
 };
 
 for (var COLLECTION_NAME in DOMIterables) {
-  handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype, COLLECTION_NAME);
+  handlePrototype(globalThis$1[COLLECTION_NAME] && globalThis$1[COLLECTION_NAME].prototype, COLLECTION_NAME);
 }
 
 handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
 
-function _toPrimitive(input, hint) {
-  if (_typeof$1(input) !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (_typeof$1(res) !== "object") return res;
+function toPrimitive(t, r) {
+  if ("object" != _typeof$1(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof$1(i)) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
 
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return _typeof$1(key) === "symbol" ? key : String(key);
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof$1(i) ? i : i + "";
 }
 
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
 }
 
 var aCallable = aCallable$9;
 var toObject = toObject$4;
 var IndexedObject = indexedObject;
-var lengthOfArrayLike$1 = lengthOfArrayLike$4;
+var lengthOfArrayLike = lengthOfArrayLike$3;
 
 var $TypeError = TypeError;
 
+var REDUCE_EMPTY = 'Reduce of empty array with no initial value';
+
 // `Array.prototype.{ reduce, reduceRight }` methods implementation
 var createMethod$1 = function (IS_RIGHT) {
   return function (that, callbackfn, argumentsLength, memo) {
     var O = toObject(that);
     var self = IndexedObject(O);
-    var length = lengthOfArrayLike$1(O);
+    var length = lengthOfArrayLike(O);
     aCallable(callbackfn);
+    if (length === 0 && argumentsLength < 2) throw new $TypeError(REDUCE_EMPTY);
     var index = IS_RIGHT ? length - 1 : 0;
     var i = IS_RIGHT ? -1 : 1;
     if (argumentsLength < 2) while (true) {
@@ -46967,7 +46705,7 @@ var createMethod$1 = function (IS_RIGHT) {
       }
       index += i;
       if (IS_RIGHT ? index < 0 : length <= index) {
-        throw new $TypeError('Reduce of empty array with no initial value');
+        throw new $TypeError(REDUCE_EMPTY);
       }
     }
     for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
@@ -46999,8 +46737,8 @@ var arrayMethodIsStrict$2 = function (METHOD_NAME, argument) {
 var $$5 = _export;
 var $reduce = arrayReduce.left;
 var arrayMethodIsStrict$1 = arrayMethodIsStrict$2;
-var CHROME_VERSION = engineV8Version;
-var IS_NODE = engineIsNode;
+var CHROME_VERSION = environmentV8Version;
+var IS_NODE = environmentIsNode;
 
 // Chrome 80-82 has a critical bug
 // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
@@ -47022,11 +46760,9 @@ var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
 var toLength$1 = toLength$6;
 var toString$3 = toString$9;
 var notARegExp$1 = notARegexp;
-var requireObjectCoercible$3 = requireObjectCoercible$a;
+var requireObjectCoercible$3 = requireObjectCoercible$b;
 var correctIsRegExpLogic$1 = correctIsRegexpLogic;
 
-// eslint-disable-next-line es/no-string-prototype-endswith -- safe
-var nativeEndsWith = uncurryThis$5(''.endsWith);
 var slice = uncurryThis$5(''.slice);
 var min$1 = Math.min;
 
@@ -47047,65 +46783,29 @@ $$4({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_RE
     var len = that.length;
     var end = endPosition === undefined ? len : min$1(toLength$1(endPosition), len);
     var search = toString$3(searchString);
-    return nativeEndsWith
-      ? nativeEndsWith(that, search, end)
-      : slice(that, end - search.length, end) === search;
+    return slice(that, end - search.length, end) === search;
   }
 });
 
-var toPropertyKey = toPropertyKey$3;
-var definePropertyModule = objectDefineProperty;
-var createPropertyDescriptor = createPropertyDescriptor$4;
-
-var createProperty$1 = function (object, key, value) {
-  var propertyKey = toPropertyKey(key);
-  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
-  else object[propertyKey] = value;
-};
-
-var toAbsoluteIndex = toAbsoluteIndex$2;
-var lengthOfArrayLike = lengthOfArrayLike$4;
-var createProperty = createProperty$1;
-
-var $Array = Array;
-var max = Math.max;
-
-var arraySliceSimple = function (O, start, end) {
-  var length = lengthOfArrayLike(O);
-  var k = toAbsoluteIndex(start, length);
-  var fin = toAbsoluteIndex(end === undefined ? length : end, length);
-  var result = $Array(max(fin - k, 0));
-  var n = 0;
-  for (; k < fin; k++, n++) createProperty(result, n, O[k]);
-  result.length = n;
-  return result;
-};
-
-var apply = functionApply;
 var call$1 = functionCall;
 var uncurryThis$4 = functionUncurryThis;
 var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
-var anObject$1 = anObject$g;
+var anObject$1 = anObject$f;
 var isNullOrUndefined = isNullOrUndefined$7;
-var isRegExp = isRegexp;
-var requireObjectCoercible$2 = requireObjectCoercible$a;
+var requireObjectCoercible$2 = requireObjectCoercible$b;
 var speciesConstructor = speciesConstructor$2;
 var advanceStringIndex = advanceStringIndex$3;
 var toLength = toLength$6;
 var toString$2 = toString$9;
 var getMethod = getMethod$6;
-var arraySlice = arraySliceSimple;
-var callRegExpExec = regexpExecAbstract;
-var regexpExec = regexpExec$3;
+var regExpExec = regexpExecAbstract;
 var stickyHelpers = regexpStickyHelpers;
 var fails$2 = fails$l;
 
 var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
 var MAX_UINT32 = 0xFFFFFFFF;
 var min = Math.min;
-var $push = [].push;
-var exec = uncurryThis$4(/./.exec);
-var push = uncurryThis$4($push);
+var push = uncurryThis$4([].push);
 var stringSlice = uncurryThis$4(''.slice);
 
 // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
@@ -47119,60 +46819,20 @@ var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails$2(function () {
   return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
 });
 
+var BUGGY = 'abbc'.split(/(b)*/)[1] === 'c' ||
+  // eslint-disable-next-line regexp/no-empty-group -- required for testing
+  'test'.split(/(?:)/, -1).length !== 4 ||
+  'ab'.split(/(?:ab)*/).length !== 2 ||
+  '.'.split(/(.?)(.?)/).length !== 4 ||
+  // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
+  '.'.split(/()()/).length > 1 ||
+  ''.split(/.?/).length;
+
 // @@split logic
 fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
-  var internalSplit;
-  if (
-    'abbc'.split(/(b)*/)[1] === 'c' ||
-    // eslint-disable-next-line regexp/no-empty-group -- required for testing
-    'test'.split(/(?:)/, -1).length !== 4 ||
-    'ab'.split(/(?:ab)*/).length !== 2 ||
-    '.'.split(/(.?)(.?)/).length !== 4 ||
-    // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
-    '.'.split(/()()/).length > 1 ||
-    ''.split(/.?/).length
-  ) {
-    // based on es5-shim implementation, need to rework it
-    internalSplit = function (separator, limit) {
-      var string = toString$2(requireObjectCoercible$2(this));
-      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
-      if (lim === 0) return [];
-      if (separator === undefined) return [string];
-      // If `separator` is not a regex, use native split
-      if (!isRegExp(separator)) {
-        return call$1(nativeSplit, string, separator, lim);
-      }
-      var output = [];
-      var flags = (separator.ignoreCase ? 'i' : '') +
-                  (separator.multiline ? 'm' : '') +
-                  (separator.unicode ? 'u' : '') +
-                  (separator.sticky ? 'y' : '');
-      var lastLastIndex = 0;
-      // Make `global` and avoid `lastIndex` issues by working with a copy
-      var separatorCopy = new RegExp(separator.source, flags + 'g');
-      var match, lastIndex, lastLength;
-      while (match = call$1(regexpExec, separatorCopy, string)) {
-        lastIndex = separatorCopy.lastIndex;
-        if (lastIndex > lastLastIndex) {
-          push(output, stringSlice(string, lastLastIndex, match.index));
-          if (match.length > 1 && match.index < string.length) apply($push, output, arraySlice(match, 1));
-          lastLength = match[0].length;
-          lastLastIndex = lastIndex;
-          if (output.length >= lim) break;
-        }
-        if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
-      }
-      if (lastLastIndex === string.length) {
-        if (lastLength || !exec(separatorCopy, '')) push(output, '');
-      } else push(output, stringSlice(string, lastLastIndex));
-      return output.length > lim ? arraySlice(output, 0, lim) : output;
-    };
-  // Chakra, V8
-  } else if ('0'.split(undefined, 0).length) {
-    internalSplit = function (separator, limit) {
-      return separator === undefined && limit === 0 ? [] : call$1(nativeSplit, this, separator, limit);
-    };
-  } else internalSplit = nativeSplit;
+  var internalSplit = '0'.split(undefined, 0).length ? function (separator, limit) {
+    return separator === undefined && limit === 0 ? [] : call$1(nativeSplit, this, separator, limit);
+  } : nativeSplit;
 
   return [
     // `String.prototype.split` method
@@ -47192,30 +46852,30 @@ fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNa
     function (string, limit) {
       var rx = anObject$1(this);
       var S = toString$2(string);
-      var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
 
-      if (res.done) return res.value;
+      if (!BUGGY) {
+        var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
+        if (res.done) return res.value;
+      }
 
       var C = speciesConstructor(rx, RegExp);
-
       var unicodeMatching = rx.unicode;
       var flags = (rx.ignoreCase ? 'i' : '') +
                   (rx.multiline ? 'm' : '') +
                   (rx.unicode ? 'u' : '') +
                   (UNSUPPORTED_Y ? 'g' : 'y');
-
       // ^(? + rx + ) is needed, in combination with some S slicing, to
       // simulate the 'y' flag.
       var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
       var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
       if (lim === 0) return [];
-      if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
+      if (S.length === 0) return regExpExec(splitter, S) === null ? [S] : [];
       var p = 0;
       var q = 0;
       var A = [];
       while (q < S.length) {
         splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
-        var z = callRegExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
+        var z = regExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
         var e;
         if (
           z === null ||
@@ -47236,7 +46896,7 @@ fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNa
       return A;
     }
   ];
-}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
+}, BUGGY || !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
 
 var raf$1 = {exports: {}};
 
@@ -47356,7 +47016,7 @@ var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u200
   '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
 
 var uncurryThis$3 = functionUncurryThis;
-var requireObjectCoercible$1 = requireObjectCoercible$a;
+var requireObjectCoercible$1 = requireObjectCoercible$b;
 var toString$1 = toString$9;
 var whitespaces$1 = whitespaces$2;
 
@@ -47708,7 +47368,7 @@ $$2({ target: 'Array', proto: true, forced: FORCED }, {
 var $$1 = _export;
 var uncurryThis$1 = functionUncurryThis;
 var notARegExp = notARegexp;
-var requireObjectCoercible = requireObjectCoercible$a;
+var requireObjectCoercible = requireObjectCoercible$b;
 var toString = toString$9;
 var correctIsRegExpLogic = correctIsRegexpLogic;
 
@@ -47850,7 +47510,6 @@ function p(t, r, e, i) {
     u = 6 * (o - n),
     h = 3 * n;
   return Math.abs(s) < a ? [-h / u] : function (t, r, e) {
-    void 0 === e && (e = 1e-6);
     var i = t * t / 4 - r;
     if (i < -e) return [];
     if (i <= e) return [-t / 2];
@@ -48275,7 +47934,7 @@ var regexpGetFlags = function (R) {
 
 var PROPER_FUNCTION_NAME = functionName.PROPER;
 var defineBuiltIn = defineBuiltIn$7;
-var anObject = anObject$g;
+var anObject = anObject$f;
 var $toString = toString$9;
 var fails = fails$l;
 var getRegExpFlags = regexpGetFlags;
@@ -48291,7 +47950,7 @@ var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
 // `RegExp.prototype.toString` method
 // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
 if (NOT_GENERIC || INCORRECT_NAME) {
-  defineBuiltIn(RegExp.prototype, TO_STRING, function toString() {
+  defineBuiltIn(RegExpPrototype, TO_STRING, function toString() {
     var R = anObject(this);
     var pattern = $toString(R.source);
     var flags = $toString(getRegExpFlags(R));