@scratch/scratch-render 12.1.0-login-from-editor → 12.1.0-membership-program

package/dist/node/scratch-render.js

@@ -25090,7 +25090,7 @@ var __WEBPACK_AMD_DEFINE_RESULT__;;(function (globalScope) {
 /***/ ((module) => {
 
 "use strict";
-/*! @license DOMPurify 3.2.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.7/LICENSE */
+/*! @license DOMPurify 3.3.0 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.0/LICENSE */
 
 
 
@@ -25278,7 +25278,7 @@ function lookupGetter(object, prop) {
 }
 
 const 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', 'search', 'section', 'select', 'shadow', 'slot', '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']);
-const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'enterkeyhint', 'exportparts', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'inputmode', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'part', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'slot', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
+const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'enterkeyhint', 'exportparts', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'inputmode', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'part', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
 const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', '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.
 // We still need to know them so that we can do namespace
@@ -25292,7 +25292,7 @@ const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongd
 const text = freeze(['#text']);
 
 const 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', 'exportparts', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inert', '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', 'part', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'slot', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
-const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', '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', 'exponent', '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', 'intercept', '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', 'slope', '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', 'tablevalues', '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']);
+const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', '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', 'exponent', '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', 'intercept', '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', 'mask-type', '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', 'slope', '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', 'tablevalues', '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']);
 const 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']);
 const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
 
@@ -25399,7 +25399,7 @@ const _createHooksMap = function _createHooksMap() {
 function createDOMPurify() {
   let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
   const DOMPurify = root => createDOMPurify(root);
-  DOMPurify.version = '3.2.7';
+  DOMPurify.version = '3.3.0';
   DOMPurify.removed = [];
   if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
     // Not running in a browser, provide a factory function
@@ -25510,6 +25510,21 @@ function createDOMPurify() {
   let FORBID_TAGS = null;
   /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
   let FORBID_ATTR = null;
+  /* Config object to store ADD_TAGS/ADD_ATTR functions (when used as functions) */
+  const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+    tagCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    }
+  }));
   /* Decide if ARIA attributes are okay */
   let ALLOW_ARIA_ATTR = true;
   /* Decide if custom data attributes are okay */
@@ -25702,16 +25717,24 @@ function createDOMPurify() {
     }
     /* Merge configuration parameters */
     if (cfg.ADD_TAGS) {
-      if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
-        ALLOWED_TAGS = clone(ALLOWED_TAGS);
+      if (typeof cfg.ADD_TAGS === 'function') {
+        EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+      } else {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone(ALLOWED_TAGS);
+        }
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
       }
-      addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
     }
     if (cfg.ADD_ATTR) {
-      if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
-        ALLOWED_ATTR = clone(ALLOWED_ATTR);
+      if (typeof cfg.ADD_ATTR === 'function') {
+        EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+      } else {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone(ALLOWED_ATTR);
+        }
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
       }
-      addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
     }
     if (cfg.ADD_URI_SAFE_ATTR) {
       addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
@@ -26019,7 +26042,7 @@ function createDOMPurify() {
       return true;
     }
     /* Remove element if anything forbids its presence */
-    if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+    if (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName])) {
       /* Check if we have a custom element to handle */
       if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
         if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
@@ -26091,7 +26114,7 @@ function createDOMPurify() {
         (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 && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag)) ; 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
@@ -142357,471 +142380,6 @@ module.exports = class VirtualConsole extends EventEmitter {
 "use strict";
 module.exports = /*#__PURE__*/JSON.parse('{"name":"jsdom","version":"26.1.0","description":"A JavaScript implementation of many web standards","keywords":["dom","html","whatwg","w3c"],"maintainers":["Elijah Insua <tmpvar@gmail.com> (http://tmpvar.com)","Domenic Denicola <d@domenic.me> (https://domenic.me/)","Sebastian Mayr <sebmaster16@gmail.com> (https://blog.smayr.name/)","Joris van der Wel <joris@jorisvanderwel.com>","Timothy Gu <timothygu99@gmail.com> (https://timothygu.me/)","Magne Andersson <code@zirro.se> (https://zirro.se/)","Pierre-Marie Dartus <dartus.pierremarie@gmail.com>"],"license":"MIT","repository":{"type":"git","url":"git+https://github.com/jsdom/jsdom.git"},"dependencies":{"cssstyle":"^4.2.1","data-urls":"^5.0.0","decimal.js":"^10.5.0","html-encoding-sniffer":"^4.0.0","http-proxy-agent":"^7.0.2","https-proxy-agent":"^7.0.6","is-potential-custom-element-name":"^1.0.1","nwsapi":"^2.2.16","parse5":"^7.2.1","rrweb-cssom":"^0.8.0","saxes":"^6.0.0","symbol-tree":"^3.2.4","tough-cookie":"^5.1.1","w3c-xmlserializer":"^5.0.0","webidl-conversions":"^7.0.0","whatwg-encoding":"^3.1.1","whatwg-mimetype":"^4.0.0","whatwg-url":"^14.1.1","ws":"^8.18.0","xml-name-validator":"^5.0.0"},"peerDependencies":{"canvas":"^3.0.0"},"peerDependenciesMeta":{"canvas":{"optional":true}},"devDependencies":{"@domenic/eslint-config":"^4.0.1","benchmark":"^2.1.4","eslint":"^9.20.0","eslint-plugin-html":"^8.1.2","globals":"^15.14.0","js-yaml":"^4.1.0","minimatch":"^9.0.5","mocha":"^11.1.0","mocha-sugar-free":"^1.4.0","pngjs":"^7.0.0","server-destroy":"^1.0.1","webidl2js":"^18.0.0","yargs":"^17.7.2"},"scripts":{"prepare":"npm run convert-idl && npm run generate-js-globals","pretest":"npm run prepare && npm run init-wpt","test-wpt":"mocha test/web-platform-tests/run-wpts.js","test-tuwpt":"mocha test/web-platform-tests/run-tuwpts.js","test-mocha":"mocha","test-api":"mocha test/api","test":"mocha test/index.js","lint":"eslint --cache","init-wpt":"git submodule update --init --recursive","reset-wpt":"rm -rf ./test/web-platform-tests/tests && npm run init-wpt","update-wpt":"git submodule update --init --recursive --remote && cd test/web-platform-tests/tests && python wpt.py manifest --path ../wpt-manifest.json","update-authors":"git log --format=\\"%aN <%aE>\\" | sort -f | uniq > AUTHORS.txt","benchmark":"node ./benchmark/runner","convert-idl":"node ./scripts/webidl/convert.js","generate-js-globals":"node ./scripts/generate-js-globals.js"},"main":"./lib/api.js","type":"commonjs","engines":{"node":">=18"}}');
 
-/***/ }),
-
-/***/ "../../node_modules/isomorphic-dompurify/node_modules/punycode/punycode.es6.js":
-/*!*************************************************************************************!*\
-  !*** ../../node_modules/isomorphic-dompurify/node_modules/punycode/punycode.es6.js ***!
-  \*************************************************************************************/
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   decode: () => (/* binding */ decode),
-/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
-/* harmony export */   encode: () => (/* binding */ encode),
-/* harmony export */   toASCII: () => (/* binding */ toASCII),
-/* harmony export */   toUnicode: () => (/* binding */ toUnicode),
-/* harmony export */   ucs2decode: () => (/* binding */ ucs2decode),
-/* harmony export */   ucs2encode: () => (/* binding */ ucs2encode)
-/* harmony export */ });
-
-
-/** Highest positive signed 32-bit float value */
-const maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
-
-/** Bootstring parameters */
-const base = 36;
-const tMin = 1;
-const tMax = 26;
-const skew = 38;
-const damp = 700;
-const initialBias = 72;
-const initialN = 128; // 0x80
-const delimiter = '-'; // '\x2D'
-
-/** Regular expressions */
-const regexPunycode = /^xn--/;
-const regexNonASCII = /[^\0-\x7F]/; // Note: U+007F DEL is excluded too.
-const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
-
-/** Error messages */
-const errors = {
-	'overflow': 'Overflow: input needs wider integers to process',
-	'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
-	'invalid-input': 'Invalid input'
-};
-
-/** Convenience shortcuts */
-const baseMinusTMin = base - tMin;
-const floor = Math.floor;
-const stringFromCharCode = String.fromCharCode;
-
-/*--------------------------------------------------------------------------*/
-
-/**
- * A generic error utility function.
- * @private
- * @param {String} type The error type.
- * @returns {Error} Throws a `RangeError` with the applicable error message.
- */
-function error(type) {
-	throw new RangeError(errors[type]);
-}
-
-/**
- * A generic `Array#map` utility function.
- * @private
- * @param {Array} array The array to iterate over.
- * @param {Function} callback The function that gets called for every array
- * item.
- * @returns {Array} A new array of values returned by the callback function.
- */
-function map(array, callback) {
-	const result = [];
-	let length = array.length;
-	while (length--) {
-		result[length] = callback(array[length]);
-	}
-	return result;
-}
-
-/**
- * A simple `Array#map`-like wrapper to work with domain name strings or email
- * addresses.
- * @private
- * @param {String} domain The domain name or email address.
- * @param {Function} callback The function that gets called for every
- * character.
- * @returns {String} A new string of characters returned by the callback
- * function.
- */
-function mapDomain(domain, callback) {
-	const parts = domain.split('@');
-	let result = '';
-	if (parts.length > 1) {
-		// In email addresses, only the domain name should be punycoded. Leave
-		// the local part (i.e. everything up to `@`) intact.
-		result = parts[0] + '@';
-		domain = parts[1];
-	}
-	// Avoid `split(regex)` for IE8 compatibility. See #17.
-	domain = domain.replace(regexSeparators, '\x2E');
-	const labels = domain.split('.');
-	const encoded = map(labels, callback).join('.');
-	return result + encoded;
-}
-
-/**
- * Creates an array containing the numeric code points of each Unicode
- * character in the string. While JavaScript uses UCS-2 internally,
- * this function will convert a pair of surrogate halves (each of which
- * UCS-2 exposes as separate characters) into a single code point,
- * matching UTF-16.
- * @see `punycode.ucs2.encode`
- * @see <https://mathiasbynens.be/notes/javascript-encoding>
- * @memberOf punycode.ucs2
- * @name decode
- * @param {String} string The Unicode input string (UCS-2).
- * @returns {Array} The new array of code points.
- */
-function ucs2decode(string) {
-	const output = [];
-	let counter = 0;
-	const length = string.length;
-	while (counter < length) {
-		const value = string.charCodeAt(counter++);
-		if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-			// It's a high surrogate, and there is a next character.
-			const extra = string.charCodeAt(counter++);
-			if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
-				output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-			} else {
-				// It's an unmatched surrogate; only append this code unit, in case the
-				// next code unit is the high surrogate of a surrogate pair.
-				output.push(value);
-				counter--;
-			}
-		} else {
-			output.push(value);
-		}
-	}
-	return output;
-}
-
-/**
- * Creates a string based on an array of numeric code points.
- * @see `punycode.ucs2.decode`
- * @memberOf punycode.ucs2
- * @name encode
- * @param {Array} codePoints The array of numeric code points.
- * @returns {String} The new Unicode string (UCS-2).
- */
-const ucs2encode = codePoints => String.fromCodePoint(...codePoints);
-
-/**
- * Converts a basic code point into a digit/integer.
- * @see `digitToBasic()`
- * @private
- * @param {Number} codePoint The basic numeric code point value.
- * @returns {Number} The numeric value of a basic code point (for use in
- * representing integers) in the range `0` to `base - 1`, or `base` if
- * the code point does not represent a value.
- */
-const basicToDigit = function(codePoint) {
-	if (codePoint >= 0x30 && codePoint < 0x3A) {
-		return 26 + (codePoint - 0x30);
-	}
-	if (codePoint >= 0x41 && codePoint < 0x5B) {
-		return codePoint - 0x41;
-	}
-	if (codePoint >= 0x61 && codePoint < 0x7B) {
-		return codePoint - 0x61;
-	}
-	return base;
-};
-
-/**
- * Converts a digit/integer into a basic code point.
- * @see `basicToDigit()`
- * @private
- * @param {Number} digit The numeric value of a basic code point.
- * @returns {Number} The basic code point whose value (when used for
- * representing integers) is `digit`, which needs to be in the range
- * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
- * used; else, the lowercase form is used. The behavior is undefined
- * if `flag` is non-zero and `digit` has no uppercase form.
- */
-const digitToBasic = function(digit, flag) {
-	//  0..25 map to ASCII a..z or A..Z
-	// 26..35 map to ASCII 0..9
-	return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-};
-
-/**
- * Bias adaptation function as per section 3.4 of RFC 3492.
- * https://tools.ietf.org/html/rfc3492#section-3.4
- * @private
- */
-const adapt = function(delta, numPoints, firstTime) {
-	let k = 0;
-	delta = firstTime ? floor(delta / damp) : delta >> 1;
-	delta += floor(delta / numPoints);
-	for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
-		delta = floor(delta / baseMinusTMin);
-	}
-	return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
-};
-
-/**
- * Converts a Punycode string of ASCII-only symbols to a string of Unicode
- * symbols.
- * @memberOf punycode
- * @param {String} input The Punycode string of ASCII-only symbols.
- * @returns {String} The resulting string of Unicode symbols.
- */
-const decode = function(input) {
-	// Don't use UCS-2.
-	const output = [];
-	const inputLength = input.length;
-	let i = 0;
-	let n = initialN;
-	let bias = initialBias;
-
-	// Handle the basic code points: let `basic` be the number of input code
-	// points before the last delimiter, or `0` if there is none, then copy
-	// the first basic code points to the output.
-
-	let basic = input.lastIndexOf(delimiter);
-	if (basic < 0) {
-		basic = 0;
-	}
-
-	for (let j = 0; j < basic; ++j) {
-		// if it's not a basic code point
-		if (input.charCodeAt(j) >= 0x80) {
-			error('not-basic');
-		}
-		output.push(input.charCodeAt(j));
-	}
-
-	// Main decoding loop: start just after the last delimiter if any basic code
-	// points were copied; start at the beginning otherwise.
-
-	for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
-
-		// `index` is the index of the next character to be consumed.
-		// Decode a generalized variable-length integer into `delta`,
-		// which gets added to `i`. The overflow checking is easier
-		// if we increase `i` as we go, then subtract off its starting
-		// value at the end to obtain `delta`.
-		const oldi = i;
-		for (let w = 1, k = base; /* no condition */; k += base) {
-
-			if (index >= inputLength) {
-				error('invalid-input');
-			}
-
-			const digit = basicToDigit(input.charCodeAt(index++));
-
-			if (digit >= base) {
-				error('invalid-input');
-			}
-			if (digit > floor((maxInt - i) / w)) {
-				error('overflow');
-			}
-
-			i += digit * w;
-			const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-
-			if (digit < t) {
-				break;
-			}
-
-			const baseMinusT = base - t;
-			if (w > floor(maxInt / baseMinusT)) {
-				error('overflow');
-			}
-
-			w *= baseMinusT;
-
-		}
-
-		const out = output.length + 1;
-		bias = adapt(i - oldi, out, oldi == 0);
-
-		// `i` was supposed to wrap around from `out` to `0`,
-		// incrementing `n` each time, so we'll fix that now:
-		if (floor(i / out) > maxInt - n) {
-			error('overflow');
-		}
-
-		n += floor(i / out);
-		i %= out;
-
-		// Insert `n` at position `i` of the output.
-		output.splice(i++, 0, n);
-
-	}
-
-	return String.fromCodePoint(...output);
-};
-
-/**
- * Converts a string of Unicode symbols (e.g. a domain name label) to a
- * Punycode string of ASCII-only symbols.
- * @memberOf punycode
- * @param {String} input The string of Unicode symbols.
- * @returns {String} The resulting Punycode string of ASCII-only symbols.
- */
-const encode = function(input) {
-	const output = [];
-
-	// Convert the input in UCS-2 to an array of Unicode code points.
-	input = ucs2decode(input);
-
-	// Cache the length.
-	const inputLength = input.length;
-
-	// Initialize the state.
-	let n = initialN;
-	let delta = 0;
-	let bias = initialBias;
-
-	// Handle the basic code points.
-	for (const currentValue of input) {
-		if (currentValue < 0x80) {
-			output.push(stringFromCharCode(currentValue));
-		}
-	}
-
-	const basicLength = output.length;
-	let handledCPCount = basicLength;
-
-	// `handledCPCount` is the number of code points that have been handled;
-	// `basicLength` is the number of basic code points.
-
-	// Finish the basic string with a delimiter unless it's empty.
-	if (basicLength) {
-		output.push(delimiter);
-	}
-
-	// Main encoding loop:
-	while (handledCPCount < inputLength) {
-
-		// All non-basic code points < n have been handled already. Find the next
-		// larger one:
-		let m = maxInt;
-		for (const currentValue of input) {
-			if (currentValue >= n && currentValue < m) {
-				m = currentValue;
-			}
-		}
-
-		// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
-		// but guard against overflow.
-		const handledCPCountPlusOne = handledCPCount + 1;
-		if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
-			error('overflow');
-		}
-
-		delta += (m - n) * handledCPCountPlusOne;
-		n = m;
-
-		for (const currentValue of input) {
-			if (currentValue < n && ++delta > maxInt) {
-				error('overflow');
-			}
-			if (currentValue === n) {
-				// Represent delta as a generalized variable-length integer.
-				let q = delta;
-				for (let k = base; /* no condition */; k += base) {
-					const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-					if (q < t) {
-						break;
-					}
-					const qMinusT = q - t;
-					const baseMinusT = base - t;
-					output.push(
-						stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
-					);
-					q = floor(qMinusT / baseMinusT);
-				}
-
-				output.push(stringFromCharCode(digitToBasic(q, 0)));
-				bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
-				delta = 0;
-				++handledCPCount;
-			}
-		}
-
-		++delta;
-		++n;
-
-	}
-	return output.join('');
-};
-
-/**
- * Converts a Punycode string representing a domain name or an email address
- * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
- * it doesn't matter if you call it on a string that has already been
- * converted to Unicode.
- * @memberOf punycode
- * @param {String} input The Punycoded domain name or email address to
- * convert to Unicode.
- * @returns {String} The Unicode representation of the given Punycode
- * string.
- */
-const toUnicode = function(input) {
-	return mapDomain(input, function(string) {
-		return regexPunycode.test(string)
-			? decode(string.slice(4).toLowerCase())
-			: string;
-	});
-};
-
-/**
- * Converts a Unicode string representing a domain name or an email address to
- * Punycode. Only the non-ASCII parts of the domain name will be converted,
- * i.e. it doesn't matter if you call it with a domain that's already in
- * ASCII.
- * @memberOf punycode
- * @param {String} input The domain name or email address to convert, as a
- * Unicode string.
- * @returns {String} The Punycode representation of the given domain name or
- * email address.
- */
-const toASCII = function(input) {
-	return mapDomain(input, function(string) {
-		return regexNonASCII.test(string)
-			? 'xn--' + encode(string)
-			: string;
-	});
-};
-
-/*--------------------------------------------------------------------------*/
-
-/** Define the public API */
-const punycode = {
-	/**
-	 * A string representing the current Punycode.js version number.
-	 * @memberOf punycode
-	 * @type String
-	 */
-	'version': '2.3.1',
-	/**
-	 * An object of methods to convert from JavaScript's internal character
-	 * representation (UCS-2) to Unicode code points, and back.
-	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
-	 * @memberOf punycode
-	 * @type Object
-	 */
-	'ucs2': {
-		'decode': ucs2decode,
-		'encode': ucs2encode
-	},
-	'decode': decode,
-	'encode': encode,
-	'toASCII': toASCII,
-	'toUnicode': toUnicode
-};
-
-
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (punycode);
-
-
 /***/ }),
 
 /***/ "../../node_modules/isomorphic-dompurify/node_modules/saxes/saxes.js":
@@ -148321,7 +147879,7 @@ exports.version = '5.1.2';
 "use strict";
 
 
-const punycode = __webpack_require__(/*! punycode/ */ "../../node_modules/isomorphic-dompurify/node_modules/punycode/punycode.es6.js");
+const punycode = __webpack_require__(/*! punycode/ */ "../../node_modules/punycode/punycode.es6.js");
 const regexes = __webpack_require__(/*! ./lib/regexes.js */ "../../node_modules/isomorphic-dompurify/node_modules/tr46/lib/regexes.js");
 const mappingTable = __webpack_require__(/*! ./lib/mappingTable.json */ "../../node_modules/isomorphic-dompurify/node_modules/tr46/lib/mappingTable.json");
 const { STATUS_MAPPING } = __webpack_require__(/*! ./lib/statusMapping.js */ "../../node_modules/isomorphic-dompurify/node_modules/tr46/lib/statusMapping.js");
@@ -170413,6 +169971,471 @@ exports.xmlDecodeTree = new Uint16Array(
     .map((c) => c.charCodeAt(0)));
 //# sourceMappingURL=decode-data-xml.js.map
 
+/***/ }),
+
+/***/ "../../node_modules/punycode/punycode.es6.js":
+/*!***************************************************!*\
+  !*** ../../node_modules/punycode/punycode.es6.js ***!
+  \***************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   decode: () => (/* binding */ decode),
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   encode: () => (/* binding */ encode),
+/* harmony export */   toASCII: () => (/* binding */ toASCII),
+/* harmony export */   toUnicode: () => (/* binding */ toUnicode),
+/* harmony export */   ucs2decode: () => (/* binding */ ucs2decode),
+/* harmony export */   ucs2encode: () => (/* binding */ ucs2encode)
+/* harmony export */ });
+
+
+/** Highest positive signed 32-bit float value */
+const maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
+
+/** Bootstring parameters */
+const base = 36;
+const tMin = 1;
+const tMax = 26;
+const skew = 38;
+const damp = 700;
+const initialBias = 72;
+const initialN = 128; // 0x80
+const delimiter = '-'; // '\x2D'
+
+/** Regular expressions */
+const regexPunycode = /^xn--/;
+const regexNonASCII = /[^\0-\x7F]/; // Note: U+007F DEL is excluded too.
+const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
+
+/** Error messages */
+const errors = {
+	'overflow': 'Overflow: input needs wider integers to process',
+	'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+	'invalid-input': 'Invalid input'
+};
+
+/** Convenience shortcuts */
+const baseMinusTMin = base - tMin;
+const floor = Math.floor;
+const stringFromCharCode = String.fromCharCode;
+
+/*--------------------------------------------------------------------------*/
+
+/**
+ * A generic error utility function.
+ * @private
+ * @param {String} type The error type.
+ * @returns {Error} Throws a `RangeError` with the applicable error message.
+ */
+function error(type) {
+	throw new RangeError(errors[type]);
+}
+
+/**
+ * A generic `Array#map` utility function.
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} callback The function that gets called for every array
+ * item.
+ * @returns {Array} A new array of values returned by the callback function.
+ */
+function map(array, callback) {
+	const result = [];
+	let length = array.length;
+	while (length--) {
+		result[length] = callback(array[length]);
+	}
+	return result;
+}
+
+/**
+ * A simple `Array#map`-like wrapper to work with domain name strings or email
+ * addresses.
+ * @private
+ * @param {String} domain The domain name or email address.
+ * @param {Function} callback The function that gets called for every
+ * character.
+ * @returns {String} A new string of characters returned by the callback
+ * function.
+ */
+function mapDomain(domain, callback) {
+	const parts = domain.split('@');
+	let result = '';
+	if (parts.length > 1) {
+		// In email addresses, only the domain name should be punycoded. Leave
+		// the local part (i.e. everything up to `@`) intact.
+		result = parts[0] + '@';
+		domain = parts[1];
+	}
+	// Avoid `split(regex)` for IE8 compatibility. See #17.
+	domain = domain.replace(regexSeparators, '\x2E');
+	const labels = domain.split('.');
+	const encoded = map(labels, callback).join('.');
+	return result + encoded;
+}
+
+/**
+ * Creates an array containing the numeric code points of each Unicode
+ * character in the string. While JavaScript uses UCS-2 internally,
+ * this function will convert a pair of surrogate halves (each of which
+ * UCS-2 exposes as separate characters) into a single code point,
+ * matching UTF-16.
+ * @see `punycode.ucs2.encode`
+ * @see <https://mathiasbynens.be/notes/javascript-encoding>
+ * @memberOf punycode.ucs2
+ * @name decode
+ * @param {String} string The Unicode input string (UCS-2).
+ * @returns {Array} The new array of code points.
+ */
+function ucs2decode(string) {
+	const output = [];
+	let counter = 0;
+	const length = string.length;
+	while (counter < length) {
+		const value = string.charCodeAt(counter++);
+		if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+			// It's a high surrogate, and there is a next character.
+			const extra = string.charCodeAt(counter++);
+			if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
+				output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+			} else {
+				// It's an unmatched surrogate; only append this code unit, in case the
+				// next code unit is the high surrogate of a surrogate pair.
+				output.push(value);
+				counter--;
+			}
+		} else {
+			output.push(value);
+		}
+	}
+	return output;
+}
+
+/**
+ * Creates a string based on an array of numeric code points.
+ * @see `punycode.ucs2.decode`
+ * @memberOf punycode.ucs2
+ * @name encode
+ * @param {Array} codePoints The array of numeric code points.
+ * @returns {String} The new Unicode string (UCS-2).
+ */
+const ucs2encode = codePoints => String.fromCodePoint(...codePoints);
+
+/**
+ * Converts a basic code point into a digit/integer.
+ * @see `digitToBasic()`
+ * @private
+ * @param {Number} codePoint The basic numeric code point value.
+ * @returns {Number} The numeric value of a basic code point (for use in
+ * representing integers) in the range `0` to `base - 1`, or `base` if
+ * the code point does not represent a value.
+ */
+const basicToDigit = function(codePoint) {
+	if (codePoint >= 0x30 && codePoint < 0x3A) {
+		return 26 + (codePoint - 0x30);
+	}
+	if (codePoint >= 0x41 && codePoint < 0x5B) {
+		return codePoint - 0x41;
+	}
+	if (codePoint >= 0x61 && codePoint < 0x7B) {
+		return codePoint - 0x61;
+	}
+	return base;
+};
+
+/**
+ * Converts a digit/integer into a basic code point.
+ * @see `basicToDigit()`
+ * @private
+ * @param {Number} digit The numeric value of a basic code point.
+ * @returns {Number} The basic code point whose value (when used for
+ * representing integers) is `digit`, which needs to be in the range
+ * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+ * used; else, the lowercase form is used. The behavior is undefined
+ * if `flag` is non-zero and `digit` has no uppercase form.
+ */
+const digitToBasic = function(digit, flag) {
+	//  0..25 map to ASCII a..z or A..Z
+	// 26..35 map to ASCII 0..9
+	return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+};
+
+/**
+ * Bias adaptation function as per section 3.4 of RFC 3492.
+ * https://tools.ietf.org/html/rfc3492#section-3.4
+ * @private
+ */
+const adapt = function(delta, numPoints, firstTime) {
+	let k = 0;
+	delta = firstTime ? floor(delta / damp) : delta >> 1;
+	delta += floor(delta / numPoints);
+	for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+		delta = floor(delta / baseMinusTMin);
+	}
+	return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+};
+
+/**
+ * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+ * symbols.
+ * @memberOf punycode
+ * @param {String} input The Punycode string of ASCII-only symbols.
+ * @returns {String} The resulting string of Unicode symbols.
+ */
+const decode = function(input) {
+	// Don't use UCS-2.
+	const output = [];
+	const inputLength = input.length;
+	let i = 0;
+	let n = initialN;
+	let bias = initialBias;
+
+	// Handle the basic code points: let `basic` be the number of input code
+	// points before the last delimiter, or `0` if there is none, then copy
+	// the first basic code points to the output.
+
+	let basic = input.lastIndexOf(delimiter);
+	if (basic < 0) {
+		basic = 0;
+	}
+
+	for (let j = 0; j < basic; ++j) {
+		// if it's not a basic code point
+		if (input.charCodeAt(j) >= 0x80) {
+			error('not-basic');
+		}
+		output.push(input.charCodeAt(j));
+	}
+
+	// Main decoding loop: start just after the last delimiter if any basic code
+	// points were copied; start at the beginning otherwise.
+
+	for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+		// `index` is the index of the next character to be consumed.
+		// Decode a generalized variable-length integer into `delta`,
+		// which gets added to `i`. The overflow checking is easier
+		// if we increase `i` as we go, then subtract off its starting
+		// value at the end to obtain `delta`.
+		const oldi = i;
+		for (let w = 1, k = base; /* no condition */; k += base) {
+
+			if (index >= inputLength) {
+				error('invalid-input');
+			}
+
+			const digit = basicToDigit(input.charCodeAt(index++));
+
+			if (digit >= base) {
+				error('invalid-input');
+			}
+			if (digit > floor((maxInt - i) / w)) {
+				error('overflow');
+			}
+
+			i += digit * w;
+			const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+			if (digit < t) {
+				break;
+			}
+
+			const baseMinusT = base - t;
+			if (w > floor(maxInt / baseMinusT)) {
+				error('overflow');
+			}
+
+			w *= baseMinusT;
+
+		}
+
+		const out = output.length + 1;
+		bias = adapt(i - oldi, out, oldi == 0);
+
+		// `i` was supposed to wrap around from `out` to `0`,
+		// incrementing `n` each time, so we'll fix that now:
+		if (floor(i / out) > maxInt - n) {
+			error('overflow');
+		}
+
+		n += floor(i / out);
+		i %= out;
+
+		// Insert `n` at position `i` of the output.
+		output.splice(i++, 0, n);
+
+	}
+
+	return String.fromCodePoint(...output);
+};
+
+/**
+ * Converts a string of Unicode symbols (e.g. a domain name label) to a
+ * Punycode string of ASCII-only symbols.
+ * @memberOf punycode
+ * @param {String} input The string of Unicode symbols.
+ * @returns {String} The resulting Punycode string of ASCII-only symbols.
+ */
+const encode = function(input) {
+	const output = [];
+
+	// Convert the input in UCS-2 to an array of Unicode code points.
+	input = ucs2decode(input);
+
+	// Cache the length.
+	const inputLength = input.length;
+
+	// Initialize the state.
+	let n = initialN;
+	let delta = 0;
+	let bias = initialBias;
+
+	// Handle the basic code points.
+	for (const currentValue of input) {
+		if (currentValue < 0x80) {
+			output.push(stringFromCharCode(currentValue));
+		}
+	}
+
+	const basicLength = output.length;
+	let handledCPCount = basicLength;
+
+	// `handledCPCount` is the number of code points that have been handled;
+	// `basicLength` is the number of basic code points.
+
+	// Finish the basic string with a delimiter unless it's empty.
+	if (basicLength) {
+		output.push(delimiter);
+	}
+
+	// Main encoding loop:
+	while (handledCPCount < inputLength) {
+
+		// All non-basic code points < n have been handled already. Find the next
+		// larger one:
+		let m = maxInt;
+		for (const currentValue of input) {
+			if (currentValue >= n && currentValue < m) {
+				m = currentValue;
+			}
+		}
+
+		// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+		// but guard against overflow.
+		const handledCPCountPlusOne = handledCPCount + 1;
+		if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+			error('overflow');
+		}
+
+		delta += (m - n) * handledCPCountPlusOne;
+		n = m;
+
+		for (const currentValue of input) {
+			if (currentValue < n && ++delta > maxInt) {
+				error('overflow');
+			}
+			if (currentValue === n) {
+				// Represent delta as a generalized variable-length integer.
+				let q = delta;
+				for (let k = base; /* no condition */; k += base) {
+					const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+					if (q < t) {
+						break;
+					}
+					const qMinusT = q - t;
+					const baseMinusT = base - t;
+					output.push(
+						stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+					);
+					q = floor(qMinusT / baseMinusT);
+				}
+
+				output.push(stringFromCharCode(digitToBasic(q, 0)));
+				bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+				delta = 0;
+				++handledCPCount;
+			}
+		}
+
+		++delta;
+		++n;
+
+	}
+	return output.join('');
+};
+
+/**
+ * Converts a Punycode string representing a domain name or an email address
+ * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+ * it doesn't matter if you call it on a string that has already been
+ * converted to Unicode.
+ * @memberOf punycode
+ * @param {String} input The Punycoded domain name or email address to
+ * convert to Unicode.
+ * @returns {String} The Unicode representation of the given Punycode
+ * string.
+ */
+const toUnicode = function(input) {
+	return mapDomain(input, function(string) {
+		return regexPunycode.test(string)
+			? decode(string.slice(4).toLowerCase())
+			: string;
+	});
+};
+
+/**
+ * Converts a Unicode string representing a domain name or an email address to
+ * Punycode. Only the non-ASCII parts of the domain name will be converted,
+ * i.e. it doesn't matter if you call it with a domain that's already in
+ * ASCII.
+ * @memberOf punycode
+ * @param {String} input The domain name or email address to convert, as a
+ * Unicode string.
+ * @returns {String} The Punycode representation of the given domain name or
+ * email address.
+ */
+const toASCII = function(input) {
+	return mapDomain(input, function(string) {
+		return regexNonASCII.test(string)
+			? 'xn--' + encode(string)
+			: string;
+	});
+};
+
+/*--------------------------------------------------------------------------*/
+
+/** Define the public API */
+const punycode = {
+	/**
+	 * A string representing the current Punycode.js version number.
+	 * @memberOf punycode
+	 * @type String
+	 */
+	'version': '2.3.1',
+	/**
+	 * An object of methods to convert from JavaScript's internal character
+	 * representation (UCS-2) to Unicode code points, and back.
+	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+	 * @memberOf punycode
+	 * @type Object
+	 */
+	'ucs2': {
+		'decode': ucs2decode,
+		'encode': ucs2encode
+	},
+	'decode': decode,
+	'encode': encode,
+	'toASCII': toASCII,
+	'toUnicode': toUnicode
+};
+
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (punycode);
+
+
 /***/ }),
 
 /***/ "../../node_modules/rrweb-cssom/lib/CSSConditionRule.js":
@@ -188577,8 +188600,8 @@ var base64js = __webpack_require__(/*! base64-js */ "../../node_modules/base64-j
  */
 var BitmapAdapter = /*#__PURE__*/function () {
   /**
-   * @param {?function} makeImage HTML image constructor. Tests can provide this.
-   * @param {?function} makeCanvas HTML canvas constructor. Tests can provide this.
+   * @param {?Function} makeImage HTML image constructor. Tests can provide this.
+   * @param {?Function} makeCanvas HTML canvas constructor. Tests can provide this.
    */
   function BitmapAdapter(makeImage, makeCanvas) {
     _classCallCheck(this, BitmapAdapter);
@@ -188625,7 +188648,7 @@ var BitmapAdapter = /*#__PURE__*/function () {
      * to resolution 2 bitmaps. Therefore, converting a resolution 1 bitmap means doubling
      * it in width and height.
      * @param {!string} dataURI Base 64 encoded image data of the bitmap
-     * @param {!function} callback Node-style callback that returns updated dataURI if conversion succeeded
+     * @param {!Function} callback Node-style callback that returns updated dataURI if conversion succeeded
      */
   }, {
     key: "convertResolution1Bitmap",
@@ -188646,7 +188669,7 @@ var BitmapAdapter = /*#__PURE__*/function () {
      * to in Scratch 3.0
      * @param {!number} oldWidth original width
      * @param {!number} oldHeight original height
-     * @return {object} Array of new width, new height
+     * @returns {object} Array of new width, new height
      */
   }, {
     key: "getResizedWidthHeight",
@@ -188840,7 +188863,7 @@ module.exports = function (svgString) {
 /**
  * Given an SVG, replace Scratch 2.0 fonts with new 3.0 fonts. Add defaults where there are none.
  * @param {SVGElement} svgTag The SVG dom object
- * @return {void}
+ * @returns {void}
  */
 var convertFonts = function convertFonts(svgTag) {
   // Collect all text elements into a list.
@@ -188899,7 +188922,7 @@ var getFonts = __webpack_require__(/*! scratch-render-fonts */ "../../node_modul
  *   // Using a <link> or <style>@import</style> to link to font-family
  *   // injected into the document: no effect.
  * @param {string} svgString The string representation of the svg to modify
- * @return {string} The svg with any needed fonts inlined
+ * @returns {string} The svg with any needed fonts inlined
  */
 var inlineSvgFonts = function inlineSvgFonts(svgString) {
   var FONTS = getFonts();
@@ -188992,7 +189015,7 @@ var _require = __webpack_require__(/*! ./sanitize-svg */ "../scratch-svg-rendere
 /**
  * @param {SVGElement} svgTag the tag to search within
  * @param {string} [tagName] svg tag to search for (or collect all elements if not given)
- * @return {Array} a list of elements with the given tagname
+ * @returns {Array} a list of elements with the given tagname
  */
 var collectElements = function collectElements(svgTag, tagName) {
   var elts = [];
@@ -189173,7 +189196,7 @@ var transformText = function transformText(svgTag) {
  * This is used to enlarge the computed bounding box, which doesn't take
  * stroke width into account.
  * @param {SVGSVGElement} rootNode The root SVG node to traverse.
- * @return {number} The largest stroke width in the SVG.
+ * @returns {number} The largest stroke width in the SVG.
  */
 var findLargestStrokeWidth = function findLargestStrokeWidth(rootNode) {
   var largestStrokeWidth = 0;
@@ -189315,7 +189338,7 @@ var normalizeSvg = function normalizeSvg(svgTag, fromVersion2) {
  * mimic Scratch 2.0's SVG rendering.
  * @param {!string} svgString String of SVG data to draw in quirks-mode.
  * @param {boolean} [fromVersion2] True if we should perform conversion from version 2 to version 3 svg.
- * @return {SVGSVGElement} The normalized SVG element.
+ * @returns {SVGSVGElement} The normalized SVG element.
  */
 var loadSvgString = function loadSvgString(svgString, fromVersion2) {
   // Parse string into SVG XML.
@@ -189430,7 +189453,7 @@ var _TextDecoder;
 var _TextEncoder;
 if (typeof TextDecoder === 'undefined' || typeof TextEncoder === 'undefined') {
   // Wait to require the text encoding polyfill until we know it's needed.
-  // eslint-disable-next-line global-require
+
   var encoding = __webpack_require__(/*! fastestsmallesttextencoderdecoder */ "../../node_modules/fastestsmallesttextencoderdecoder/NodeJS/EncoderAndDecoderNodeJS.min.mjs");
   _TextDecoder = encoding.TextDecoder;
   _TextEncoder = encoding.TextEncoder;
@@ -189442,7 +189465,7 @@ if (typeof TextDecoder === 'undefined' || typeof TextEncoder === 'undefined') {
 /**
  * Load an SVG Uint8Array of bytes and "sanitize" it
  * @param {!Uint8Array} rawData unsanitized SVG daata
- * @return {Uint8Array} sanitized SVG data
+ * @returns {Uint8Array} sanitized SVG data
  */
 sanitizeSvg.sanitizeByteStream = function (rawData) {
   var decoder = new _TextDecoder();
@@ -189456,7 +189479,7 @@ sanitizeSvg.sanitizeByteStream = function (rawData) {
  * fixup-svg-string.js, and thus more risky; there are known examples of SVGs that
  * it will clobber. We use DOMPurify's svg profile, which restricts many types of tag.
  * @param {!string} rawSvgText unsanitized SVG string
- * @return {string} sanitized SVG text
+ * @returns {string} sanitized SVG text
  */
 sanitizeSvg.sanitizeSvgText = function (rawSvgText) {
   var sanitizedText = DOMPurify.sanitize(rawSvgText, {
@@ -189631,7 +189654,7 @@ var SvgRenderer = /*#__PURE__*/function () {
    * Create a quirks-mode SVG renderer for a particular canvas.
    * @param {HTMLCanvasElement} [canvas] An optional canvas element to draw to. If this is not provided, the renderer
    * will create a new canvas.
-   * @constructor
+   * @class
    */
   function SvgRenderer(canvas) {
     _classCallCheck(this, SvgRenderer);
@@ -189688,7 +189711,7 @@ var SvgRenderer = /*#__PURE__*/function () {
     }
 
     /**
-     * @return {Array<number>} the natural size, in Scratch units, of this SVG.
+     * @returns {Array<number>} the natural size, in Scratch units, of this SVG.
      */
   }, {
     key: "size",
@@ -189697,7 +189720,7 @@ var SvgRenderer = /*#__PURE__*/function () {
     }
 
     /**
-     * @return {Array<number>} the offset (upper left corner) of the SVG's view box.
+     * @returns {Array<number>} the offset (upper left corner) of the SVG's view box.
      */
   }, {
     key: "viewOffset",
@@ -189785,7 +189808,7 @@ var SvgRenderer = /*#__PURE__*/function () {
     /**
      * Draw to the canvas from a loaded image element.
      * @param {number} [scale] - Optionally, also scale the image by this factor.
-     **/
+     */
   }, {
     key: "_drawFromImage",
     value: function _drawFromImage(scale) {
@@ -190359,14 +190382,13 @@ var _parseUrl = function _parseUrl(value, windowRef) {
  * on groups down to the leaf level and averaging out the stroke width
  * around the shapes. Note that this doens't just change stroke widths, it
  * changes path data and attributes throughout the SVG.
- *
  * @param {SVGElement} svgTag The SVG dom object
  * @param {Window} windowRef The window to use. Need to pass in for
  *     tests to work, as they get angry at even the mention of window.
  * @param {object} bboxForTesting The bounds to use. Need to pass in for
  *     tests only, because getBBox doesn't work in Node. This should
  *     be the bounds of the svgTag without including stroke width or transforms.
- * @return {void}
+ * @returns {void}
  */
 var transformStrokeWidths = function transformStrokeWidths(svgTag, windowRef, bboxForTesting) {
   var inherited = Matrix.identity();
@@ -190535,7 +190557,7 @@ var Skin = __webpack_require__(/*! ./Skin */ "./src/Skin.js");
 var BitmapSkin = /*#__PURE__*/function (_Skin) {
   /**
    * Create a new Bitmap Skin.
-   * @extends Skin
+   * @augments Skin
    * @param {!int} id - The ID for this Skin.
    * @param {!RenderWebGL} renderer - The renderer which will use this skin.
    */
@@ -190570,7 +190592,7 @@ var BitmapSkin = /*#__PURE__*/function (_Skin) {
     }
 
     /**
-     * @return {Array<number>} the "native" size, in texels, of this skin.
+     * @returns {Array<number>} the "native" size, in texels, of this skin.
      */
   }, {
     key: "size",
@@ -190580,7 +190602,7 @@ var BitmapSkin = /*#__PURE__*/function (_Skin) {
 
     /**
      * @param {Array<number>} scale - The scaling factors to be used.
-     * @return {WebGLTexture} The GL texture representation of this skin when drawing at the given scale.
+     * @returns {WebGLTexture} The GL texture representation of this skin when drawing at the given scale.
      */
     // eslint-disable-next-line no-unused-vars
   }, {
@@ -190592,7 +190614,7 @@ var BitmapSkin = /*#__PURE__*/function (_Skin) {
     /**
      * Set the contents of this skin to a snapshot of the provided bitmap data.
      * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} bitmapData - new contents for this skin.
-     * @param {int} [costumeResolution=1] - The resolution to use for this bitmap.
+     * @param {int} [costumeResolution] - The resolution to use for this bitmap.
      * @param {Array<number>} [rotationCenter] - Optional rotation center for the bitmap. If not supplied, it will be
      * calculated from the bounding box
      * @fires Skin.event:WasAltered
@@ -190691,10 +190713,9 @@ var FLOATING_POINT_ERROR_ALLOWANCE = 1e-6;
  * internal __isTouchingPosition as a return value, so this should be copied
  * if you ever need to get two local positions and store both.  Requires that
  * the drawable inverseMatrix is up to date.
- *
  * @param {Drawable} drawable The drawable to get the inverse matrix and uniforms from
  * @param {twgl.v3} vec [x,y] scratch space vector
- * @return {twgl.v3} [x,y] texture space float vector - transformed by effects and matrix
+ * @returns {twgl.v3} [x,y] texture space float vector - transformed by effects and matrix
  */
 var getLocalPosition = function getLocalPosition(drawable, vec) {
   // Transfrom from world coordinates to Drawable coordinates.
@@ -190726,7 +190747,7 @@ var Drawable = /*#__PURE__*/function () {
    * An object which can be drawn by the renderer.
    * @todo double-buffer all rendering state (position, skin, effects, etc.)
    * @param {!int} id - This Drawable's unique ID.
-   * @constructor
+   * @class
    */
   function Drawable(id) {
     _classCallCheck(this, Drawable);
@@ -190774,9 +190795,10 @@ var Drawable = /*#__PURE__*/function () {
     this._inverseTransformDirty = true;
     this._visible = true;
 
-    /** A bitmask identifying which effects are currently in use.
+    /**
+     * A bitmask identifying which effects are currently in use.
      * @readonly
-     * @type {int} */
+      @type {int} */
     this.enabledEffects = 0;
 
     /** @todo move convex hull functionality, maybe bounds functionality overall, to Skin classes */
@@ -191130,7 +191152,7 @@ var Drawable = /*#__PURE__*/function () {
 
     /**
      * Whether the Drawable needs convex hull points provided by the renderer.
-     * @return {boolean} True when no convex hull known, or it's dirty.
+     * @returns {boolean} True when no convex hull known, or it's dirty.
      */
   }, {
     key: "needsConvexHullPoints",
@@ -191174,7 +191196,7 @@ var Drawable = /*#__PURE__*/function () {
      * The caller is responsible for ensuring this drawable's inverse matrix & its skin's silhouette are up-to-date.
      * @see updateCPURenderAttributes
      * @param {twgl.v3} vec World coordinate vector.
-     * @return {boolean} True if the world position touches the skin.
+     * @returns {boolean} True if the world position touches the skin.
      */
 
     // `updateCPURenderAttributes` sets this Drawable instance's `isTouching` method
@@ -191207,7 +191229,7 @@ var Drawable = /*#__PURE__*/function () {
      * and then finds the minimum box along the axes.
      * Before calling this, ensure the renderer has updated convex hull points.
      * @param {?Rectangle} result optional destination for bounds calculation
-     * @return {!Rectangle} Bounds for a tight box around the Drawable.
+     * @returns {!Rectangle} Bounds for a tight box around the Drawable.
      */
   }, {
     key: "getBounds",
@@ -191230,7 +191252,7 @@ var Drawable = /*#__PURE__*/function () {
      * Used for calculating where to position a text bubble.
      * Before calling this, ensure the renderer has updated convex hull points.
      * @param {?Rectangle} result optional destination for bounds calculation
-     * @return {!Rectangle} Bounds for a tight box around a slice of the Drawable.
+     * @returns {!Rectangle} Bounds for a tight box around a slice of the Drawable.
      */
   }, {
     key: "getBoundsForBubble",
@@ -191263,7 +191285,7 @@ var Drawable = /*#__PURE__*/function () {
      * `getAABB` returns a much less accurate bounding box, but will be much
      * faster to calculate so may be desired for quick checks/optimizations.
      * @param {?Rectangle} result optional destination for bounds calculation
-     * @return {!Rectangle} Rough axis-aligned bounding box for Drawable.
+     * @returns {!Rectangle} Rough axis-aligned bounding box for Drawable.
      */
   }, {
     key: "getAABB",
@@ -191282,7 +191304,7 @@ var Drawable = /*#__PURE__*/function () {
      * I.e., returns the tight bounding box when the convex hull points are already
      * known, but otherwise return the rough AABB of the Drawable.
      * @param {?Rectangle} result optional destination for bounds calculation
-     * @return {!Rectangle} Bounds for the Drawable.
+     * @returns {!Rectangle} Bounds for the Drawable.
      */
   }, {
     key: "getFastBounds",
@@ -191297,7 +191319,7 @@ var Drawable = /*#__PURE__*/function () {
      * Transform all the convex hull points by the current Drawable's
      * transform. This allows us to skip recalculating the convex hull
      * for many Drawable updates, including translation, rotation, scaling.
-     * @return {!Array.<!Array.number>} Array of glPoints which are Array<x, y>
+     * @returns {!Array.<!Array.number>} Array of glPoints which are Array<x, y>
      * @private
      */
   }, {
@@ -191463,7 +191485,7 @@ function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r),
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /**
- * @fileoverview
+ * @file
  * A utility to transform a texture coordinate to another texture coordinate
  * representing how the shaders apply effects.
  */
@@ -191476,13 +191498,13 @@ var ShaderManager = __webpack_require__(/*! ./ShaderManager */ "./src/ShaderMana
 
 /**
  * A texture coordinate is between 0 and 1. 0.5 is the center position.
- * @const {number}
+ * @constant {number}
  */
 var CENTER_X = 0.5;
 
 /**
  * A texture coordinate is between 0 and 1. 0.5 is the center position.
- * @const {number}
+ * @constant {number}
  */
 var CENTER_Y = 0.5;
 
@@ -191585,7 +191607,7 @@ var EffectTransform = /*#__PURE__*/function () {
      * @param {Drawable} drawable The drawable whose effects to emulate.
      * @param {twgl.v3} vec The texture coordinate to transform.
      * @param {twgl.v3} dst A place to store the output coordinate.
-     * @return {twgl.v3} dst - The coordinate after being transform by effects.
+     * @returns {twgl.v3} dst - The coordinate after being transform by effects.
      */
   }, {
     key: "transformPoint",
@@ -191705,7 +191727,7 @@ var ShaderManager = __webpack_require__(/*! ./ShaderManager */ "./src/ShaderMana
  * @type {PenSkin#PenAttributes}
  * @memberof PenSkin
  * @private
- * @const
+ * @constant
  */
 var DefaultPenAttributes = {
   color4f: [0, 0, 1, 1],
@@ -191722,7 +191744,7 @@ var PenSkin = /*#__PURE__*/function (_Skin) {
    * Create a Skin which implements a Scratch pen layer.
    * @param {int} id - The unique ID for this Skin.
    * @param {RenderWebGL} renderer - The renderer which will use this Skin.
-   * @extends Skin
+   * @augments Skin
    * @listens RenderWebGL#event:NativeSizeChanged
    */
   function PenSkin(id, renderer) {
@@ -191801,7 +191823,7 @@ var PenSkin = /*#__PURE__*/function (_Skin) {
     }
 
     /**
-     * @return {Array<number>} the "native" size, in texels, of this skin. [width, height]
+     * @returns {Array<number>} the "native" size, in texels, of this skin. [width, height]
      */
   }, {
     key: "size",
@@ -191818,7 +191840,7 @@ var PenSkin = /*#__PURE__*/function (_Skin) {
 
     /**
      * @param {Array<number>} scale The X and Y scaling factors to be used, as percentages of this skin's "native" size.
-     * @return {WebGLTexture} The GL texture representation of this skin when drawing at the given size.
+     * @returns {WebGLTexture} The GL texture representation of this skin when drawing at the given size.
      */
     // eslint-disable-next-line no-unused-vars
   }, {
@@ -192051,7 +192073,7 @@ var Rectangle = /*#__PURE__*/function () {
    * A utility for creating and comparing axis-aligned rectangles.
    * Rectangles are always initialized to the "largest possible rectangle";
    * use one of the init* methods below to set up a particular rectangle.
-   * @constructor
+   * @class
    */
   function Rectangle() {
     _classCallCheck(this, Rectangle);
@@ -192138,7 +192160,7 @@ var Rectangle = /*#__PURE__*/function () {
      * Note that this is a comparison assuming the Rectangle was
      * initialized with Scratch-space bounds or points.
      * @param {!Rectangle} other Rectangle to check if intersecting.
-     * @return {boolean} True if this Rectangle intersects other.
+     * @returns {boolean} True if this Rectangle intersects other.
      */
   }, {
     key: "intersects",
@@ -192151,7 +192173,7 @@ var Rectangle = /*#__PURE__*/function () {
      * Note that this is a comparison assuming the Rectangle was
      * initialized with Scratch-space bounds or points.
      * @param {!Rectangle} other Rectangle to check if fully contained.
-     * @return {boolean} True if this Rectangle fully contains other.
+     * @returns {boolean} True if this Rectangle fully contains other.
      */
   }, {
     key: "contains",
@@ -192205,7 +192227,7 @@ var Rectangle = /*#__PURE__*/function () {
     get:
     /**
      * Width of the Rectangle.
-     * @return {number} Width of rectangle.
+     * @returns {number} Width of rectangle.
      */
     function get() {
       return Math.abs(this.left - this.right);
@@ -192213,7 +192235,7 @@ var Rectangle = /*#__PURE__*/function () {
 
     /**
      * Height of the Rectangle.
-     * @return {number} Height of rectangle.
+     * @returns {number} Height of rectangle.
      */
   }, {
     key: "height",
@@ -192271,13 +192293,13 @@ module.exports = Rectangle;
 module.exports = {
   /**
    * The ID value to use for "no item" or when an object has been disposed.
-   * @const {int}
+   * @constant {int}
    */
   ID_NONE: -1,
   /**
    * Optimize for fewer than this number of Drawables sharing the same Skin.
    * Going above this may cause middleware warnings or a performance penalty but should otherwise behave correctly.
-   * @const {int}
+   * @constant {int}
    */
   SKIN_SHARE_SOFT_LIMIT: 301,
   /**
@@ -192286,7 +192308,6 @@ module.exports = {
   Events: {
     /**
      * NativeSizeChanged event
-     *
      * @event RenderWebGL#event:NativeSizeChanged
      * @type {object}
      * @property {Array<int>} newSize - the new size of the renderer
@@ -192353,7 +192374,7 @@ var __cpuTouchingColorPixelCount = 4e4;
 /**
  * @callback RenderWebGL#idFilterFunc
  * @param {int} drawableID The ID to filter.
- * @return {bool} True if the ID passes the filter, otherwise false.
+ * @returns {bool} True if the ID passes the filter, otherwise false.
  */
 
 /**
@@ -192419,11 +192440,11 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
    * @see RenderWebGL#setStageSize
    * @see RenderWebGL#resize
    * @param {canvas} canvas The canvas to draw onto.
-   * @param {int} [xLeft=-240] The x-coordinate of the left edge.
-   * @param {int} [xRight=240] The x-coordinate of the right edge.
-   * @param {int} [yBottom=-180] The y-coordinate of the bottom edge.
-   * @param {int} [yTop=180] The y-coordinate of the top edge.
-   * @constructor
+   * @param {int} [xLeft] The x-coordinate of the left edge.
+   * @param {int} [xRight] The x-coordinate of the right edge.
+   * @param {int} [yBottom] The y-coordinate of the bottom edge.
+   * @param {int} [yTop] The y-coordinate of the top edge.
+   * @class
    * @listens RenderWebGL#event:NativeSizeChanged
    */
   function RenderWebGL(canvas, xLeft, xRight, yBottom, yTop) {
@@ -192451,7 +192472,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
 
     // A list of layer group names in the order they should appear
     // from furthest back to furthest in front.
-    /** @type {Array<String>} */
+    /** @type {Array<string>} */
     _this._groupOrdering = [];
 
     /**
@@ -192621,7 +192642,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     }
 
     /**
-     * @return {Array<int>} the "native" size of the stage, which is used for pen, query renders, etc.
+     * @returns {Array<int>} the "native" size of the stage, which is used for pen, query renders, etc.
      */
   }, {
     key: "getNativeSize",
@@ -192648,7 +192669,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Create a new bitmap skin from a snapshot of the provided bitmap data.
      * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} bitmapData - new contents for this skin.
-     * @param {!int} [costumeResolution=1] - The resolution to use for this bitmap.
+     * @param {!int} [costumeResolution] - The resolution to use for this bitmap.
      * @param {?Array<number>} [rotationCenter] Optional: rotation center of the skin. If not supplied, the center of
      * the skin will be used.
      * @returns {!int} the ID for the new skin.
@@ -192919,7 +192940,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * Returns the position of the given drawableID in the draw list. This is
      * the absolute position irrespective of layer group.
      * @param {number} drawableID The drawable ID to find.
-     * @return {number} The postion of the given drawable ID.
+     * @returns {number} The postion of the given drawable ID.
      */
   }, {
     key: "getDrawableOrder",
@@ -192941,7 +192962,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * of the layer group.
      * @param {boolean=} optIsRelative If set, `order` refers to a relative change.
      * @param {number=} optMin If set, order constrained to be at least `optMin`.
-     * @return {?number} New order if changed, or null.
+     * @returns {?number} New order if changed, or null.
      */
   }, {
     key: "setDrawableOrder",
@@ -193011,7 +193032,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Get the precise bounds for a Drawable.
      * @param {int} drawableID ID of Drawable to get bounds for.
-     * @return {object} Bounds for a tight box around the Drawable.
+     * @returns {object} Bounds for a tight box around the Drawable.
      */
   }, {
     key: "getBounds",
@@ -193041,7 +193062,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * Get the precise bounds for a Drawable around the top slice.
      * Used for positioning speech bubbles more closely to the sprite.
      * @param {int} drawableID ID of Drawable to get bubble bounds for.
-     * @return {object} Bounds for a tight box around the Drawable top slice.
+     * @returns {object} Bounds for a tight box around the Drawable top slice.
      */
   }, {
     key: "getBoundsForBubble",
@@ -193070,7 +193091,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Get the current skin (costume) size of a Drawable.
      * @param {int} drawableID The ID of the Drawable to measure.
-     * @return {Array<number>} Skin size, width and height.
+     * @returns {Array<number>} Skin size, width and height.
      */
   }, {
     key: "getCurrentSkinSize",
@@ -193082,7 +193103,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Get the size of a skin by ID.
      * @param {int} skinID The ID of the Skin to measure.
-     * @return {Array<number>} Skin size, width and height.
+     * @returns {Array<number>} Skin size, width and height.
      */
   }, {
     key: "getSkinSize",
@@ -193094,7 +193115,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Get the rotation center of a skin by ID.
      * @param {int} skinID The ID of the Skin
-     * @return {Array<number>} The rotationCenterX and rotationCenterY
+     * @returns {Array<number>} The rotationCenterX and rotationCenterY
      */
   }, {
     key: "getSkinRotationCenter",
@@ -193338,7 +193359,6 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * Convert a client based x/y position on the canvas to a Scratch 3 world space
      * Rectangle.  This creates recangles with a radius to cover selecting multiple
      * scratch pixels with touch / small render areas.
-     *
      * @param {int} centerX The client x coordinate of the picking location.
      * @param {int} centerY The client y coordinate of the picking location.
      * @param {int} [width] The client width of the touch event (optional).
@@ -193372,7 +193392,6 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Determine if the drawable is touching a client based x/y.  Helper method for sensing
      * touching mouse-pointer.  Ignores visibility.
-     *
      * @param {int} drawableID The ID of the drawable to check.
      * @param {int} centerX The client x coordinate of the picking location.
      * @param {int} centerY The client y coordinate of the picking location.
@@ -193402,7 +193421,6 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Determine if the drawable is touching a rectangle.
-     *
      * @param {int} drawableID The ID of the drawable to check.
      * @param {int} left - The left X coordinate of the rectangle.
      * @param {int} top - The top Y coordinate of the rectangle.
@@ -193433,7 +193451,6 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Determine if the drawable is touching a point in the Scratch coordinate system
-     *
      * @param {int} drawableID The ID of the drawable to check.
      * @param {int} x The x coordinate of the point.
      * @param {int} y The y coordinate of the point.
@@ -193455,7 +193472,6 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * This function will pick all drawables that are visible, unless specific
      * candidate drawable IDs are provided.  Used for determining what is clicked
      * or dragged.  Will not select hidden / ghosted sprites.
-     *
      * @param {int} centerX The client x coordinate of the picking location.
      * @param {int} centerY The client y coordinate of the picking location.
      * @param {int} [touchWidth] The client width of the touch event (optional).
@@ -193530,7 +193546,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Return a drawable's pixel data and bounds in screen space.
      * @param {int} drawableID The ID of the drawable to get pixel data for
-     * @return {DrawableExtraction} Data about the picked drawable
+     * @returns {DrawableExtraction} Data about the picked drawable
      */
   }, {
     key: "extractDrawableScreenSpace",
@@ -193622,7 +193638,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * @param {int} x The client x coordinate of the picking location.
      * @param {int} y The client y coordinate of the picking location.
      * @param {int} radius The client radius to extract pixels with.
-     * @return {?ColorExtraction} Data about the picked color
+     * @returns {?ColorExtraction} Data about the picked color
      */
   }, {
     key: "extractColor",
@@ -193674,7 +193690,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
     /**
      * Get the candidate bounding box for a touching query.
      * @param {int} drawableID ID for drawable of query.
-     * @return {?Rectangle} Rectangle bounds for touching query, or null.
+     * @returns {?Rectangle} Rectangle bounds for touching query, or null.
      */
   }, {
     key: "_touchingBounds",
@@ -193703,7 +193719,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * could possibly intersect the given bounds.
      * @param {int} drawableID - ID for drawable of query.
      * @param {Array<int>} candidateIDs - Candidates for touching query.
-     * @return {?Array< {id, drawable, intersection} >} Filtered candidates with useful data.
+     * @returns {?Array< {id, drawable, intersection} >} Filtered candidates with useful data.
      */
   }, {
     key: "_candidatesTouching",
@@ -193747,7 +193763,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * Helper to get the union bounds from a set of candidates returned from the above method
      * @private
      * @param {Array<object>} candidates info from _candidatesTouching
-     * @return {Rectangle} the outer bounding box union
+     * @returns {Rectangle} the outer bounding box union
      */
   }, {
     key: "_candidatesBounds",
@@ -193890,7 +193906,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * Update the position object's x & y members to keep the drawable fenced in view.
      * @param {int} drawableID - The ID of the Drawable to update.
      * @param {Array.<number, number>} position to be fenced - An array of type [x, y]
-     * @return {Array.<number, number>} The fenced position as an array [x, y]
+     * @returns {Array.<number, number>} The fenced position as an array [x, y]
      */
   }, {
     key: "getFencedPositionOfDrawable",
@@ -194061,7 +194077,6 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * region. Since one region may be entered from within another a exit
      * handle can also be registered that is called when a new region is about
      * to be entered to restore a common inbetween state.
-     *
      * @param {any} regionId - id of the region to enter
      * @param {function} enter - handle to call when first entering a region
      * @param {function} exit - handle to call when leaving a region
@@ -194172,7 +194187,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * Get the convex hull points for a particular Drawable.
      * To do this, calculate it based on the drawable's Silhouette.
      * @param {int} drawableID The Drawable IDs calculate convex hull for.
-     * @return {Array<Array<number>>} points Convex hull points, as [[x, y], ...]
+     * @returns {Array<Array<number>>} points Convex hull points, as [[x, y], ...]
      */
   }, {
     key: "_getConvexHullPointsForDrawable",
@@ -194192,11 +194207,10 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
        *
        * The determinant is useful in this case to know if AC is counter-clockwise from AB.
        * A positive value means that AC is counter-clockwise from AB. A negative value means AC is clockwise from AB.
-       *
        * @param {Float32Array} A A 2d vector in space.
        * @param {Float32Array} B A 2d vector in space.
        * @param {Float32Array} C A 2d vector in space.
-       * @return {number} Greater than 0 if counter clockwise, less than if clockwise, 0 if all points are on a line.
+       * @returns {number} Greater than 0 if counter clockwise, less than if clockwise, 0 if all points are on a line.
        */
       var determinant = function determinant(A, B, C) {
         // AB = B - A
@@ -194308,7 +194322,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
      * @param {Array<Drawables>} drawables A list of drawables with the "top most"
      *              drawable at index 0
      * @param {Uint8ClampedArray} dst The color3b space to store the answer in.
-     * @return {Uint8ClampedArray} The dst vector with everything blended down.
+     * @returns {Uint8ClampedArray} The dst vector with everything blended down.
      */
   }, {
     key: "requestSnapshot",
@@ -194338,6 +194352,7 @@ var RenderWebGL = /*#__PURE__*/function (_EventEmitter) {
         // Create the context the same way that the constructor will: attributes may make the difference.
         return !!RenderWebGL._getContext(optCanvas || document.createElement('canvas'));
       } catch (e) {
+        // eslint-disable-line no-unused-vars
         return false;
       }
     }
@@ -194454,7 +194469,7 @@ var MAX_TEXTURE_DIMENSION = 2048;
  * All scaled renderings of the SVG are stored in an array. The 1.0 scale of
  * the SVG is stored at the 8th index. The smallest possible 1 / 256 scale
  * rendering is stored at the 0th index.
- * @const {number}
+ * @constant {number}
  */
 var INDEX_OFFSET = 8;
 var SVGSkin = /*#__PURE__*/function (_Skin) {
@@ -194462,8 +194477,8 @@ var SVGSkin = /*#__PURE__*/function (_Skin) {
    * Create a new SVG skin.
    * @param {!int} id - The ID for this Skin.
    * @param {!RenderWebGL} renderer - The renderer which will use this skin.
-   * @constructor
-   * @extends Skin
+   * @class
+   * @augments Skin
    */
   function SVGSkin(id, renderer) {
     var _this;
@@ -194495,9 +194510,9 @@ var SVGSkin = /*#__PURE__*/function (_Skin) {
     _this._largestMIPScale = 0;
 
     /**
-    * Ratio of the size of the SVG and the max size of the WebGL texture
-    * @type {Number}
-    */
+     * Ratio of the size of the SVG and the max size of the WebGL texture
+     * @type {number}
+     */
     _this._maxTextureScale = 1;
     return _this;
   }
@@ -194514,7 +194529,7 @@ var SVGSkin = /*#__PURE__*/function (_Skin) {
     }
 
     /**
-     * @return {Array<number>} the natural size, in Scratch units, of this skin.
+     * @returns {Array<number>} the natural size, in Scratch units, of this skin.
      */
   }, {
     key: "size",
@@ -194549,7 +194564,7 @@ var SVGSkin = /*#__PURE__*/function (_Skin) {
     /**
      * Create a MIP for a given scale.
      * @param {number} scale - The relative size of the MIP
-     * @return {SVGMIP} An object that handles creating and updating SVG textures.
+     * @returns {SVGMIP} An object that handles creating and updating SVG textures.
      */
   }, {
     key: "createMIP",
@@ -194598,7 +194613,7 @@ var SVGSkin = /*#__PURE__*/function (_Skin) {
 
     /**
      * @param {Array<number>} scale - The scaling factors to be used, each in the [0,100] range.
-     * @return {WebGLTexture} The GL texture representation of this skin when drawing at the given scale.
+     * @returns {WebGLTexture} The GL texture representation of this skin when drawing at the given scale.
      */
   }, {
     key: "getTexture",
@@ -194705,7 +194720,7 @@ var twgl = __webpack_require__(/*! twgl.js */ "../../node_modules/twgl.js/dist/4
 var ShaderManager = /*#__PURE__*/function () {
   /**
    * @param {WebGLRenderingContext} gl WebGL rendering context to create shaders for
-   * @constructor
+   * @class
    */
   function ShaderManager(gl) {
     _classCallCheck(this, ShaderManager);
@@ -194764,23 +194779,19 @@ var ShaderManager = /*#__PURE__*/function () {
         }
       }
       var definesText = "".concat(defines.join('\n'), "\n");
-
-      /* eslint-disable global-require */
       var vsFullText = definesText + __webpack_require__(/*! raw-loader!./shaders/sprite.vert */ "./node_modules/raw-loader/index.js!./src/shaders/sprite.vert");
       var fsFullText = definesText + __webpack_require__(/*! raw-loader!./shaders/sprite.frag */ "./node_modules/raw-loader/index.js!./src/shaders/sprite.frag");
-      /* eslint-enable global-require */
-
       return twgl.createProgramInfo(this._gl, [vsFullText, fsFullText]);
     }
   }]);
 }();
 /**
  * @typedef {object} ShaderManager.Effect
- * @prop {int} mask - The bit in 'effectBits' representing the effect.
- * @prop {function} converter - A conversion function which takes a Scratch value (generally in the range
+ * @property {int} mask - The bit in 'effectBits' representing the effect.
+ * @property {function} converter - A conversion function which takes a Scratch value (generally in the range
  *   0..100 or -100..100) and maps it to a value useful to the shader. This
  *   mapping may not be reversible.
- * @prop {boolean} shapeChanges - Whether the effect could change the drawn shape.
+ * @property {boolean} shapeChanges - Whether the effect could change the drawn shape.
  */
 /**
  * Mapping of each effect name to info about that effect.
@@ -194908,7 +194919,7 @@ function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r),
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /**
- * @fileoverview
+ * @file
  * A representation of a Skin's silhouette that can test if a point on the skin
  * renders a pixel where it is drawn.
  */
@@ -194935,7 +194946,7 @@ var intMax = function intMax(i, j) {
  * @param {Silhouette} silhouette - has data width and height
  * @param {number} x - x
  * @param {number} y - y
- * @return {number} Alpha value for x/y position
+ * @returns {number} Alpha value for x/y position
  */
 var getPoint = function getPoint(_ref, x, y) {
   var width = _ref._width,
@@ -194960,7 +194971,7 @@ var __cornerWork = [new Uint8ClampedArray(4), new Uint8ClampedArray(4), new Uint
  * @param {number} x X position of texture [0, width).
  * @param {number} y Y position of texture [0, height).
  * @param {Uint8ClampedArray} dst A color 4b space.
- * @return {Uint8ClampedArray} The dst vector.
+ * @returns {Uint8ClampedArray} The dst vector.
  */
 var getColor4b = function getColor4b(_ref2, x, y, dst) {
   var width = _ref2._width,
@@ -194992,7 +195003,7 @@ var getColor4b = function getColor4b(_ref2, x, y, dst) {
  * @param {number} x X position of texture [0, width).
  * @param {number} y Y position of texture [0, height).
  * @param {Uint8ClampedArray} dst A color 4b space.
- * @return {Uint8ClampedArray} The dst vector.
+ * @returns {Uint8ClampedArray} The dst vector.
  */
 var getPremultipliedColor4b = function getPremultipliedColor4b(_ref3, x, y, dst) {
   var width = _ref3._width,
@@ -195125,7 +195136,7 @@ var Silhouette = /*#__PURE__*/function () {
     /**
      * Test if texture coordinate touches the silhouette using nearest neighbor.
      * @param {twgl.v3} vec A texture coordinate.
-     * @return {boolean} If the nearest pixel has an alpha value.
+     * @returns {boolean} If the nearest pixel has an alpha value.
      */
   }, {
     key: "isTouchingNearest",
@@ -195138,7 +195149,7 @@ var Silhouette = /*#__PURE__*/function () {
      * Test to see if any of the 4 pixels used in the linear interpolate touch
      * the silhouette.
      * @param {twgl.v3} vec A texture coordinate.
-     * @return {boolean} Any of the pixels have some alpha.
+     * @returns {boolean} Any of the pixels have some alpha.
      */
   }, {
     key: "isTouchingLinear",
@@ -195152,7 +195163,7 @@ var Silhouette = /*#__PURE__*/function () {
     /**
      * Get the canvas element reused by Silhouettes to update their data with.
      * @private
-     * @return {CanvasElement} A canvas to draw bitmap data to.
+     * @returns {CanvasElement} A canvas to draw bitmap data to.
      */
   }], [{
     key: "_updateCanvas",
@@ -195195,7 +195206,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
   /**
    * Create a Skin, which stores and/or generates textures for use in rendering.
    * @param {int} id - The unique ID for this Skin.
-   * @constructor
+   * @class
    */
   function Skin(id) {
     var _this;
@@ -195250,7 +195261,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
     }
 
     /**
-     * @return {int} the unique ID for this Skin.
+     * @returns {int} the unique ID for this Skin.
      */
   }, {
     key: "id",
@@ -195269,7 +195280,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * @abstract
-     * @return {Array<number>} the "native" size, in texels, of this skin.
+     * @returns {Array<number>} the "native" size, in texels, of this skin.
      */
   }, {
     key: "size",
@@ -195279,10 +195290,10 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Should this skin's texture be filtered with nearest-neighbor or linear interpolation at the given scale?
-     * @param {?Array<Number>} scale The screen-space X and Y scaling factors at which this skin's texture will be
+     * @param {?Array<number>} scale The screen-space X and Y scaling factors at which this skin's texture will be
      * displayed, as percentages (100 means 1 "native size" unit is 1 screen pixel; 200 means 2 screen pixels, etc).
      * @param {Drawable} drawable The drawable that this skin's texture will be applied to.
-     * @return {boolean} True if this skin's texture, as returned by {@link getTexture}, should be filtered with
+     * @returns {boolean} True if this skin's texture, as returned by {@link getTexture}, should be filtered with
      * nearest-neighbor interpolation.
      */
     // eslint-disable-next-line no-unused-vars
@@ -195294,7 +195305,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Get the center of the current bounding box
-     * @return {Array<number>} the center of the current bounding box
+     * @returns {Array<number>} the center of the current bounding box
      */
   }, {
     key: "calculateRotationCenter",
@@ -195305,7 +195316,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
     /**
      * @abstract
      * @param {Array<number>} scale - The scaling factors to be used.
-     * @return {WebGLTexture} The GL texture representation of this skin when drawing at the given size.
+     * @returns {WebGLTexture} The GL texture representation of this skin when drawing at the given size.
      */
     // eslint-disable-next-line no-unused-vars
   }, {
@@ -195318,7 +195329,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
      * Get the bounds of the drawable for determining its fenced position.
      * @param {Array<number>} drawable - The Drawable instance this skin is using.
      * @param {?Rectangle} result - Optional destination for bounds calculation.
-     * @return {!Rectangle} The drawable's bounds. For compatibility with Scratch 2, we always use getAABB.
+     * @returns {!Rectangle} The drawable's bounds. For compatibility with Scratch 2, we always use getAABB.
      */
   }, {
     key: "getFenceBounds",
@@ -195405,7 +195416,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
      * @see updateSilhouette
      * @see Drawable.updateCPURenderAttributes
      * @param {twgl.v3} vec A texture coordinate.
-     * @return {boolean} Did it touch?
+     * @returns {boolean} Did it touch?
      */
   }, {
     key: "isTouchingNearest",
@@ -195420,7 +195431,7 @@ var Skin = /*#__PURE__*/function (_EventEmitter) {
      * @see updateSilhouette
      * @see Drawable.updateCPURenderAttributes
      * @param {twgl.v3} vec A texture coordinate.
-     * @return {boolean} Did it touch?
+     * @returns {boolean} Did it touch?
      */
   }, {
     key: "isTouchingLinear",
@@ -195508,8 +195519,8 @@ var TextBubbleSkin = /*#__PURE__*/function (_Skin) {
    * Create a new text bubble skin.
    * @param {!int} id - The ID for this Skin.
    * @param {!RenderWebGL} renderer - The renderer which will use this skin.
-   * @constructor
-   * @extends Skin
+   * @class
+   * @augments Skin
    */
   function TextBubbleSkin(id, renderer) {
     var _this;
@@ -195570,7 +195581,7 @@ var TextBubbleSkin = /*#__PURE__*/function (_Skin) {
     }
 
     /**
-     * @return {Array<number>} the dimensions, in Scratch units, of this skin.
+     * @returns {Array<number>} the dimensions, in Scratch units, of this skin.
      */
   }, {
     key: "size",
@@ -195736,7 +195747,7 @@ var TextBubbleSkin = /*#__PURE__*/function (_Skin) {
 
     /**
      * @param {Array<number>} scale - The scaling factors to be used, each in the [0,100] range.
-     * @return {WebGLTexture} The GL texture representation of this skin when drawing at the given scale.
+     * @returns {WebGLTexture} The GL texture representation of this skin when drawing at the given scale.
      */
   }, {
     key: "getTexture",
@@ -195860,13 +195871,12 @@ function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
  * adapted from http://lolengine.net/blog/2013/01/13/fast-rgb-to-hsv.
  * Assumes r, g, and b are in the range [0, 255] and
  * returns h, s, and v in the range [0, 1].
- *
  * @param   {Array<number>} rgb   The RGB color value
  * @param   {number}        rgb.r The red color value
  * @param   {number}        rgb.g The green color value
  * @param   {number}        rgb.b The blue color value
  * @param   {Array<number>} dst   The array to store the HSV values in
- * @return  {Array<number>}       The `dst` array passed in
+ * @returns  {Array<number>}       The `dst` array passed in
  */
 var rgbToHsv = function rgbToHsv(_ref, dst) {
   var _ref2 = _slicedToArray(_ref, 3),
@@ -195905,13 +195915,12 @@ var rgbToHsv = function rgbToHsv(_ref, dst) {
  * adapted from https://gist.github.com/mjackson/5311256.
  * Assumes h, s, and v are contained in the set [0, 1] and
  * returns r, g, and b in the set [0, 255].
- *
  * @param   {Array<number>}                hsv The HSV color value
  * @param   {number}                       hsv.h     The hue
  * @param   {number}                       hsv.s     The saturation
  * @param   {number}                       hsv.v     The value
  * @param   {Uint8Array|Uint8ClampedArray} dst The array to store the RGB values in
- * @return  {Uint8Array|Uint8ClampedArray}     The `dst` array passed in
+ * @returns  {Uint8Array|Uint8ClampedArray}     The `dst` array passed in
  */
 var hsvToRgb = function hsvToRgb(_ref3, dst) {
   var _ref4 = _slicedToArray(_ref3, 3),