@popsure/dirty-swan 0.62.3 → 0.63.0

package/dist/esm/index-BCxawEMQ.js

@@ -1,3947 +0,0 @@
-import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers-BFTU3MAI.js';
-import { l as libExports } from './customRender-DzdqZxUd.js';
-
-var minIndent;
-var hasRequiredMinIndent;
-
-function requireMinIndent () {
-	if (hasRequiredMinIndent) return minIndent;
-	hasRequiredMinIndent = 1;
-	minIndent = string => {
-		const match = string.match(/^[ \t]*(?=\S)/gm);
-
-		if (!match) {
-			return 0;
-		}
-
-		return match.reduce((r, a) => Math.min(r, a.length), Infinity);
-	};
-	return minIndent;
-}
-
-var stripIndent;
-var hasRequiredStripIndent;
-
-function requireStripIndent () {
-	if (hasRequiredStripIndent) return stripIndent;
-	hasRequiredStripIndent = 1;
-	const minIndent = requireMinIndent();
-
-	stripIndent = string => {
-		const indent = minIndent(string);
-
-		if (indent === 0) {
-			return string;
-		}
-
-		const regex = new RegExp(`^[ \\t]{${indent}}`, 'gm');
-
-		return string.replace(regex, '');
-	};
-	return stripIndent;
-}
-
-var indentString;
-var hasRequiredIndentString;
-
-function requireIndentString () {
-	if (hasRequiredIndentString) return indentString;
-	hasRequiredIndentString = 1;
-
-	indentString = (string, count = 1, options) => {
-		options = {
-			indent: ' ',
-			includeEmptyLines: false,
-			...options
-		};
-
-		if (typeof string !== 'string') {
-			throw new TypeError(
-				`Expected \`input\` to be a \`string\`, got \`${typeof string}\``
-			);
-		}
-
-		if (typeof count !== 'number') {
-			throw new TypeError(
-				`Expected \`count\` to be a \`number\`, got \`${typeof count}\``
-			);
-		}
-
-		if (typeof options.indent !== 'string') {
-			throw new TypeError(
-				`Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
-			);
-		}
-
-		if (count === 0) {
-			return string;
-		}
-
-		const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-
-		return string.replace(regex, options.indent.repeat(count));
-	};
-	return indentString;
-}
-
-var redent$1;
-var hasRequiredRedent;
-
-function requireRedent () {
-	if (hasRequiredRedent) return redent$1;
-	hasRequiredRedent = 1;
-	const stripIndent = requireStripIndent();
-	const indentString = requireIndentString();
-
-	redent$1 = (string, count = 0, options) => indentString(stripIndent(string), count, options);
-	return redent$1;
-}
-
-var redentExports = requireRedent();
-var redent = /*@__PURE__*/getDefaultExportFromCjs(redentExports);
-
-function $parcel$defineInteropFlag(a) {
-  Object.defineProperty(a, '__esModule', {value: true, configurable: true});
-}
-
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
-}
-var $009ddb00d3ec72b8$exports = {};
-
-$parcel$defineInteropFlag($009ddb00d3ec72b8$exports);
-
-$parcel$export($009ddb00d3ec72b8$exports, "default", () => $009ddb00d3ec72b8$export$2e2bcd8739ae039);
-class $009ddb00d3ec72b8$export$2e2bcd8739ae039 extends Error {
-    constructor(filename, msg, lineno, column, css){
-        super(filename + ":" + lineno + ":" + column + ": " + msg);
-        this.reason = msg;
-        this.filename = filename;
-        this.line = lineno;
-        this.column = column;
-        this.source = css;
-    }
-}
-
-
-var $0865a9fb4cc365fe$exports = {};
-
-$parcel$defineInteropFlag($0865a9fb4cc365fe$exports);
-
-$parcel$export($0865a9fb4cc365fe$exports, "default", () => $0865a9fb4cc365fe$export$2e2bcd8739ae039);
-/**
- * Store position information for a node
- */ class $0865a9fb4cc365fe$export$2e2bcd8739ae039 {
-    constructor(start, end, source){
-        this.start = start;
-        this.end = end;
-        this.source = source;
-    }
-}
-
-
-var $b2e137848b48cf4f$exports = {};
-
-$parcel$export($b2e137848b48cf4f$exports, "CssTypes", () => $b2e137848b48cf4f$export$9be5dd6e61d5d73a);
-var $b2e137848b48cf4f$export$9be5dd6e61d5d73a;
-(function(CssTypes) {
-    CssTypes["stylesheet"] = "stylesheet";
-    CssTypes["rule"] = "rule";
-    CssTypes["declaration"] = "declaration";
-    CssTypes["comment"] = "comment";
-    CssTypes["container"] = "container";
-    CssTypes["charset"] = "charset";
-    CssTypes["document"] = "document";
-    CssTypes["customMedia"] = "custom-media";
-    CssTypes["fontFace"] = "font-face";
-    CssTypes["host"] = "host";
-    CssTypes["import"] = "import";
-    CssTypes["keyframes"] = "keyframes";
-    CssTypes["keyframe"] = "keyframe";
-    CssTypes["layer"] = "layer";
-    CssTypes["media"] = "media";
-    CssTypes["namespace"] = "namespace";
-    CssTypes["page"] = "page";
-    CssTypes["startingStyle"] = "starting-style";
-    CssTypes["supports"] = "supports";
-})($b2e137848b48cf4f$export$9be5dd6e61d5d73a || ($b2e137848b48cf4f$export$9be5dd6e61d5d73a = {}));
-
-
-// http://www.w3.org/TR/CSS21/grammar.html
-// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
-// New rule => https://www.w3.org/TR/CSS22/syndata.html#comments
-// [^] is equivalent to [.\n\r]
-const $d708735ed1303b43$var$commentre = /\/\*[^]*?(?:\*\/|$)/g;
-const $d708735ed1303b43$export$98e6a39c04603d36 = (css, options)=>{
-    options = options || {};
-    /**
-   * Positional.
-   */ let lineno = 1;
-    let column = 1;
-    /**
-   * Update lineno and column based on `str`.
-   */ function updatePosition(str) {
-        const lines = str.match(/\n/g);
-        if (lines) lineno += lines.length;
-        const i = str.lastIndexOf("\n");
-        column = ~i ? str.length - i : column + str.length;
-    }
-    /**
-   * Mark position and patch `node.position`.
-   */ function position() {
-        const start = {
-            line: lineno,
-            column: column
-        };
-        return function(node) {
-            node.position = new ($0865a9fb4cc365fe$export$2e2bcd8739ae039)(start, {
-                line: lineno,
-                column: column
-            }, options?.source || "");
-            whitespace();
-            return node;
-        };
-    }
-    /**
-   * Error `msg`.
-   */ const errorsList = [];
-    function error(msg) {
-        const err = new ($009ddb00d3ec72b8$export$2e2bcd8739ae039)(options?.source || "", msg, lineno, column, css);
-        if (options?.silent) errorsList.push(err);
-        else throw err;
-    }
-    /**
-   * Parse stylesheet.
-   */ function stylesheet() {
-        const rulesList = rules();
-        const result = {
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).stylesheet,
-            stylesheet: {
-                source: options?.source,
-                rules: rulesList,
-                parsingErrors: errorsList
-            }
-        };
-        return result;
-    }
-    /**
-   * Opening brace.
-   */ function open() {
-        return match(/^{\s*/);
-    }
-    /**
-   * Closing brace.
-   */ function close() {
-        return match(/^}/);
-    }
-    /**
-   * Parse ruleset.
-   */ function rules() {
-        let node;
-        const rules = [];
-        whitespace();
-        comments(rules);
-        while(css.length && css.charAt(0) !== "}" && (node = atrule() || rule()))if (node) {
-            rules.push(node);
-            comments(rules);
-        }
-        return rules;
-    }
-    /**
-   * Match `re` and return captures.
-   */ function match(re) {
-        const m = re.exec(css);
-        if (!m) return;
-        const str = m[0];
-        updatePosition(str);
-        css = css.slice(str.length);
-        return m;
-    }
-    /**
-   * Parse whitespace.
-   */ function whitespace() {
-        match(/^\s*/);
-    }
-    /**
-   * Parse comments;
-   */ function comments(rules) {
-        let c;
-        rules = rules || [];
-        while(c = comment())if (c) rules.push(c);
-        return rules;
-    }
-    /**
-   * Parse comment.
-   */ function comment() {
-        const pos = position();
-        if ("/" !== css.charAt(0) || "*" !== css.charAt(1)) return;
-        const m = match(/^\/\*[^]*?\*\//);
-        if (!m) return error("End of comment missing");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).comment,
-            comment: m[0].slice(2, -2)
-        });
-    }
-    function findClosingParenthese(str, start, depth) {
-        let ptr = start + 1;
-        let found = false;
-        let closeParentheses = str.indexOf(")", ptr);
-        while(!found && closeParentheses !== -1){
-            const nextParentheses = str.indexOf("(", ptr);
-            if (nextParentheses !== -1 && nextParentheses < closeParentheses) {
-                const nextSearch = findClosingParenthese(str, nextParentheses + 1);
-                ptr = nextSearch + 1;
-                closeParentheses = str.indexOf(")", ptr);
-            } else found = true;
-        }
-        if (found && closeParentheses !== -1) return closeParentheses;
-        else return -1;
-    }
-    /**
-   * Parse selector.
-   */ function selector() {
-        const m = match(/^([^{]+)/);
-        if (!m) return;
-        // remove comment in selector;
-        let res = $d708735ed1303b43$var$trim(m[0]).replace($d708735ed1303b43$var$commentre, "");
-        // Optimisation: If there is no ',' no need to split or post-process (this is less costly)
-        if (res.indexOf(",") === -1) return [
-            res
-        ];
-        // Replace all the , in the parentheses by \u200C
-        let ptr = 0;
-        let startParentheses = res.indexOf("(", ptr);
-        while(startParentheses !== -1){
-            const closeParentheses = findClosingParenthese(res, startParentheses);
-            if (closeParentheses === -1) break;
-            ptr = closeParentheses + 1;
-            res = res.substring(0, startParentheses) + res.substring(startParentheses, closeParentheses).replace(/,/g, "\u200C") + res.substring(closeParentheses);
-            startParentheses = res.indexOf("(", ptr);
-        }
-        // Replace all the , in ' and " by \u200C
-        res = res/**
-       * replace ',' by \u200C for data selector (div[data-lang="fr,de,us"])
-       *
-       * Examples:
-       * div[data-lang="fr,\"de,us"]
-       * div[data-lang='fr,\'de,us']
-       *
-       * Regex logic:
-       *  ("|')(?:\\\1|.)*?\1 => Handle the " and '
-       *
-       * Optimization 1:
-       * No greedy capture (see docs about the difference between .* and .*?)
-       *
-       * Optimization 2:
-       * ("|')(?:\\\1|.)*?\1 this use reference to capture group, it work faster.
-       */ .replace(/("|')(?:\\\1|.)*?\1/g, (m)=>m.replace(/,/g, "\u200C"));
-        // Split all the left , and replace all the \u200C by ,
-        return res// Split the selector by ','
-        .split(",")// Replace back \u200C by ','
-        .map((s)=>{
-            return $d708735ed1303b43$var$trim(s.replace(/\u200C/g, ","));
-        });
-    }
-    /**
-   * Parse declaration.
-   */ function declaration() {
-        const pos = position();
-        // prop
-        const propMatch = match(/^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
-        if (!propMatch) return;
-        const propValue = $d708735ed1303b43$var$trim(propMatch[0]);
-        // :
-        if (!match(/^:\s*/)) return error("property missing ':'");
-        // val
-        const val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/);
-        const ret = pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).declaration,
-            property: propValue.replace($d708735ed1303b43$var$commentre, ""),
-            value: val ? $d708735ed1303b43$var$trim(val[0]).replace($d708735ed1303b43$var$commentre, "") : ""
-        });
-        // ;
-        match(/^[;\s]*/);
-        return ret;
-    }
-    /**
-   * Parse declarations.
-   */ function declarations() {
-        const decls = [];
-        if (!open()) return error("missing '{'");
-        comments(decls);
-        // declarations
-        let decl;
-        while(decl = declaration())if (decl) {
-            decls.push(decl);
-            comments(decls);
-        }
-        if (!close()) return error("missing '}'");
-        return decls;
-    }
-    /**
-   * Parse keyframe.
-   */ function keyframe() {
-        let m;
-        const vals = [];
-        const pos = position();
-        while(m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/)){
-            vals.push(m[1]);
-            match(/^,\s*/);
-        }
-        if (!vals.length) return;
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).keyframe,
-            values: vals,
-            declarations: declarations() || []
-        });
-    }
-    /**
-   * Parse keyframes.
-   */ function atkeyframes() {
-        const pos = position();
-        const m1 = match(/^@([-\w]+)?keyframes\s*/);
-        if (!m1) return;
-        const vendor = m1[1];
-        // identifier
-        const m2 = match(/^([-\w]+)\s*/);
-        if (!m2) return error("@keyframes missing name");
-        const name = m2[1];
-        if (!open()) return error("@keyframes missing '{'");
-        let frame;
-        let frames = comments();
-        while(frame = keyframe()){
-            frames.push(frame);
-            frames = frames.concat(comments());
-        }
-        if (!close()) return error("@keyframes missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).keyframes,
-            name: name,
-            vendor: vendor,
-            keyframes: frames
-        });
-    }
-    /**
-   * Parse supports.
-   */ function atsupports() {
-        const pos = position();
-        const m = match(/^@supports *([^{]+)/);
-        if (!m) return;
-        const supports = $d708735ed1303b43$var$trim(m[1]);
-        if (!open()) return error("@supports missing '{'");
-        const style = comments().concat(rules());
-        if (!close()) return error("@supports missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).supports,
-            supports: supports,
-            rules: style
-        });
-    }
-    /**
-   * Parse host.
-   */ function athost() {
-        const pos = position();
-        const m = match(/^@host\s*/);
-        if (!m) return;
-        if (!open()) return error("@host missing '{'");
-        const style = comments().concat(rules());
-        if (!close()) return error("@host missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).host,
-            rules: style
-        });
-    }
-    /**
-   * Parse container.
-   */ function atcontainer() {
-        const pos = position();
-        const m = match(/^@container *([^{]+)/);
-        if (!m) return;
-        const container = $d708735ed1303b43$var$trim(m[1]);
-        if (!open()) return error("@container missing '{'");
-        const style = comments().concat(rules());
-        if (!close()) return error("@container missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).container,
-            container: container,
-            rules: style
-        });
-    }
-    /**
-   * Parse container.
-   */ function atlayer() {
-        const pos = position();
-        const m = match(/^@layer *([^{;@]+)/);
-        if (!m) return;
-        const layer = $d708735ed1303b43$var$trim(m[1]);
-        if (!open()) {
-            match(/^[;\s]*/);
-            return pos({
-                type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).layer,
-                layer: layer
-            });
-        }
-        const style = comments().concat(rules());
-        if (!close()) return error("@layer missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).layer,
-            layer: layer,
-            rules: style
-        });
-    }
-    /**
-   * Parse media.
-   */ function atmedia() {
-        const pos = position();
-        const m = match(/^@media *([^{]+)/);
-        if (!m) return;
-        const media = $d708735ed1303b43$var$trim(m[1]);
-        if (!open()) return error("@media missing '{'");
-        const style = comments().concat(rules());
-        if (!close()) return error("@media missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).media,
-            media: media,
-            rules: style
-        });
-    }
-    /**
-   * Parse custom-media.
-   */ function atcustommedia() {
-        const pos = position();
-        const m = match(/^@custom-media\s+(--\S+)\s*([^{;\s][^{;]*);/);
-        if (!m) return;
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).customMedia,
-            name: $d708735ed1303b43$var$trim(m[1]),
-            media: $d708735ed1303b43$var$trim(m[2])
-        });
-    }
-    /**
-   * Parse paged media.
-   */ function atpage() {
-        const pos = position();
-        const m = match(/^@page */);
-        if (!m) return;
-        const sel = selector() || [];
-        if (!open()) return error("@page missing '{'");
-        let decls = comments();
-        // declarations
-        let decl;
-        while(decl = declaration()){
-            decls.push(decl);
-            decls = decls.concat(comments());
-        }
-        if (!close()) return error("@page missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).page,
-            selectors: sel,
-            declarations: decls
-        });
-    }
-    /**
-   * Parse document.
-   */ function atdocument() {
-        const pos = position();
-        const m = match(/^@([-\w]+)?document *([^{]+)/);
-        if (!m) return;
-        const vendor = $d708735ed1303b43$var$trim(m[1]);
-        const doc = $d708735ed1303b43$var$trim(m[2]);
-        if (!open()) return error("@document missing '{'");
-        const style = comments().concat(rules());
-        if (!close()) return error("@document missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).document,
-            document: doc,
-            vendor: vendor,
-            rules: style
-        });
-    }
-    /**
-   * Parse font-face.
-   */ function atfontface() {
-        const pos = position();
-        const m = match(/^@font-face\s*/);
-        if (!m) return;
-        if (!open()) return error("@font-face missing '{'");
-        let decls = comments();
-        // declarations
-        let decl;
-        while(decl = declaration()){
-            decls.push(decl);
-            decls = decls.concat(comments());
-        }
-        if (!close()) return error("@font-face missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).fontFace,
-            declarations: decls
-        });
-    }
-    /**
-   * Parse starting style.
-   */ function atstartingstyle() {
-        const pos = position();
-        const m = match(/^@starting-style\s*/);
-        if (!m) return;
-        if (!open()) return error("@starting-style missing '{'");
-        const style = comments().concat(rules());
-        if (!close()) return error("@starting-style missing '}'");
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).startingStyle,
-            rules: style
-        });
-    }
-    /**
-   * Parse import
-   */ const atimport = _compileAtrule("import");
-    /**
-   * Parse charset
-   */ const atcharset = _compileAtrule("charset");
-    /**
-   * Parse namespace
-   */ const atnamespace = _compileAtrule("namespace");
-    /**
-   * Parse non-block at-rules
-   */ function _compileAtrule(name) {
-        const re = new RegExp("^@" + name + "\\s*((?::?[^;'\"]|\"(?:\\\\\"|[^\"])*?\"|'(?:\\\\'|[^'])*?')+)(?:;|$)");
-        // ^@import\s*([^;"']|("|')(?:\\\2|.)*?\2)+(;|$)
-        return function() {
-            const pos = position();
-            const m = match(re);
-            if (!m) return;
-            const ret = {
-                type: name
-            };
-            ret[name] = m[1].trim();
-            return pos(ret);
-        };
-    }
-    /**
-   * Parse at rule.
-   */ function atrule() {
-        if (css[0] !== "@") return;
-        return atkeyframes() || atmedia() || atcustommedia() || atsupports() || atimport() || atcharset() || atnamespace() || atdocument() || atpage() || athost() || atfontface() || atcontainer() || atstartingstyle() || atlayer();
-    }
-    /**
-   * Parse rule.
-   */ function rule() {
-        const pos = position();
-        const sel = selector();
-        if (!sel) return error("selector missing");
-        comments();
-        return pos({
-            type: ($b2e137848b48cf4f$export$9be5dd6e61d5d73a).rule,
-            selectors: sel,
-            declarations: declarations() || []
-        });
-    }
-    return $d708735ed1303b43$var$addParent(stylesheet());
-};
-/**
- * Trim `str`.
- */ function $d708735ed1303b43$var$trim(str) {
-    return str ? str.trim() : "";
-}
-/**
- * Adds non-enumerable parent node reference to each node.
- */ function $d708735ed1303b43$var$addParent(obj, parent) {
-    const isNode = obj && typeof obj.type === "string";
-    const childParent = isNode ? obj : parent;
-    for(const k in obj){
-        const value = obj[k];
-        if (Array.isArray(value)) value.forEach((v)=>{
-            $d708735ed1303b43$var$addParent(v, childParent);
-        });
-        else if (value && typeof value === "object") $d708735ed1303b43$var$addParent(value, childParent);
-    }
-    if (isNode) Object.defineProperty(obj, "parent", {
-        configurable: true,
-        writable: true,
-        enumerable: false,
-        value: parent || null
-    });
-    return obj;
-}
-var $d708735ed1303b43$export$2e2bcd8739ae039 = $d708735ed1303b43$export$98e6a39c04603d36;
-
-
-
-
-
-const $149c1bd638913645$export$98e6a39c04603d36 = ($d708735ed1303b43$export$2e2bcd8739ae039);
-
-/**
- * @source {https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from#Polyfill}
- * but without thisArg (too hard to type, no need to `this`)
- */
-var toStr = Object.prototype.toString;
-function isCallable(fn) {
-  return typeof fn === "function" || toStr.call(fn) === "[object Function]";
-}
-function toInteger(value) {
-  var number = Number(value);
-  if (isNaN(number)) {
-    return 0;
-  }
-  if (number === 0 || !isFinite(number)) {
-    return number;
-  }
-  return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
-}
-var maxSafeInteger = Math.pow(2, 53) - 1;
-function toLength(value) {
-  var len = toInteger(value);
-  return Math.min(Math.max(len, 0), maxSafeInteger);
-}
-/**
- * Creates an array from an iterable object.
- * @param iterable An iterable object to convert to an array.
- */
-
-/**
- * Creates an array from an iterable object.
- * @param iterable An iterable object to convert to an array.
- * @param mapfn A mapping function to call on every element of the array.
- * @param thisArg Value of 'this' used to invoke the mapfn.
- */
-function arrayFrom(arrayLike, mapFn) {
-  // 1. Let C be the this value.
-  // edit(@eps1lon): we're not calling it as Array.from
-  var C = Array;
-
-  // 2. Let items be ToObject(arrayLike).
-  var items = Object(arrayLike);
-
-  // 3. ReturnIfAbrupt(items).
-  if (arrayLike == null) {
-    throw new TypeError("Array.from requires an array-like object - not null or undefined");
-  }
-
-  // 10. Let lenValue be Get(items, "length").
-  // 11. Let len be ToLength(lenValue).
-  var len = toLength(items.length);
-
-  // 13. If IsConstructor(C) is true, then
-  // 13. a. Let A be the result of calling the [[Construct]] internal method
-  // of C with an argument list containing the single item len.
-  // 14. a. Else, Let A be ArrayCreate(len).
-  var A = isCallable(C) ? Object(new C(len)) : new Array(len);
-
-  // 16. Let k be 0.
-  var k = 0;
-  // 17. Repeat, while k < len… (also steps a - h)
-  var kValue;
-  while (k < len) {
-    kValue = items[k];
-    {
-      A[k] = kValue;
-    }
-    k += 1;
-  }
-  // 18. Let putStatus be Put(A, "length", len, true).
-  A.length = len;
-  // 20. Return A.
-  return A;
-}
-
-function _typeof$1(o) { "@babel/helpers - typeof"; return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$1(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey$1(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty$1(obj, key, value) { key = _toPropertyKey$1(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey$1(arg) { var key = _toPrimitive$1(arg, "string"); return _typeof$1(key) === "symbol" ? key : String(key); }
-function _toPrimitive$1(input, hint) { if (_typeof$1(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint); if (_typeof$1(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-// for environments without Set we fallback to arrays with unique members
-var SetLike = /*#__PURE__*/function () {
-  function SetLike() {
-    var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    _classCallCheck(this, SetLike);
-    _defineProperty$1(this, "items", void 0);
-    this.items = items;
-  }
-  _createClass(SetLike, [{
-    key: "add",
-    value: function add(value) {
-      if (this.has(value) === false) {
-        this.items.push(value);
-      }
-      return this;
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.items = [];
-    }
-  }, {
-    key: "delete",
-    value: function _delete(value) {
-      var previousLength = this.items.length;
-      this.items = this.items.filter(function (item) {
-        return item !== value;
-      });
-      return previousLength !== this.items.length;
-    }
-  }, {
-    key: "forEach",
-    value: function forEach(callbackfn) {
-      var _this = this;
-      this.items.forEach(function (item) {
-        callbackfn(item, item, _this);
-      });
-    }
-  }, {
-    key: "has",
-    value: function has(value) {
-      return this.items.indexOf(value) !== -1;
-    }
-  }, {
-    key: "size",
-    get: function get() {
-      return this.items.length;
-    }
-  }]);
-  return SetLike;
-}();
-var SetLike$1 = typeof Set === "undefined" ? Set : SetLike;
-
-// https://w3c.github.io/html-aria/#document-conformance-requirements-for-use-of-aria-attributes-in-html
-
-
-/**
- * Safe Element.localName for all supported environments
- * @param element
- */
-function getLocalName(element) {
-  var _element$localName;
-  return (// eslint-disable-next-line no-restricted-properties -- actual guard for environments without localName
-    (_element$localName = element.localName) !== null && _element$localName !== void 0 ? _element$localName :
-    // eslint-disable-next-line no-restricted-properties -- required for the fallback
-    element.tagName.toLowerCase()
-  );
-}
-var localNameToRoleMappings = {
-  article: "article",
-  aside: "complementary",
-  button: "button",
-  datalist: "listbox",
-  dd: "definition",
-  details: "group",
-  dialog: "dialog",
-  dt: "term",
-  fieldset: "group",
-  figure: "figure",
-  // WARNING: Only with an accessible name
-  form: "form",
-  footer: "contentinfo",
-  h1: "heading",
-  h2: "heading",
-  h3: "heading",
-  h4: "heading",
-  h5: "heading",
-  h6: "heading",
-  header: "banner",
-  hr: "separator",
-  html: "document",
-  legend: "legend",
-  li: "listitem",
-  math: "math",
-  main: "main",
-  menu: "list",
-  nav: "navigation",
-  ol: "list",
-  optgroup: "group",
-  // WARNING: Only in certain context
-  option: "option",
-  output: "status",
-  progress: "progressbar",
-  // WARNING: Only with an accessible name
-  section: "region",
-  summary: "button",
-  table: "table",
-  tbody: "rowgroup",
-  textarea: "textbox",
-  tfoot: "rowgroup",
-  // WARNING: Only in certain context
-  td: "cell",
-  th: "columnheader",
-  thead: "rowgroup",
-  tr: "row",
-  ul: "list"
-};
-var prohibitedAttributes = {
-  caption: new Set(["aria-label", "aria-labelledby"]),
-  code: new Set(["aria-label", "aria-labelledby"]),
-  deletion: new Set(["aria-label", "aria-labelledby"]),
-  emphasis: new Set(["aria-label", "aria-labelledby"]),
-  generic: new Set(["aria-label", "aria-labelledby", "aria-roledescription"]),
-  insertion: new Set(["aria-label", "aria-labelledby"]),
-  none: new Set(["aria-label", "aria-labelledby"]),
-  paragraph: new Set(["aria-label", "aria-labelledby"]),
-  presentation: new Set(["aria-label", "aria-labelledby"]),
-  strong: new Set(["aria-label", "aria-labelledby"]),
-  subscript: new Set(["aria-label", "aria-labelledby"]),
-  superscript: new Set(["aria-label", "aria-labelledby"])
-};
-
-/**
- *
- * @param element
- * @param role The role used for this element. This is specified to control whether you want to use the implicit or explicit role.
- */
-function hasGlobalAriaAttributes(element, role) {
-  // https://rawgit.com/w3c/aria/stable/#global_states
-  // commented attributes are deprecated
-  return ["aria-atomic", "aria-busy", "aria-controls", "aria-current", "aria-description", "aria-describedby", "aria-details",
-  // "disabled",
-  "aria-dropeffect",
-  // "errormessage",
-  "aria-flowto", "aria-grabbed",
-  // "haspopup",
-  "aria-hidden",
-  // "invalid",
-  "aria-keyshortcuts", "aria-label", "aria-labelledby", "aria-live", "aria-owns", "aria-relevant", "aria-roledescription"].some(function (attributeName) {
-    var _prohibitedAttributes;
-    return element.hasAttribute(attributeName) && !((_prohibitedAttributes = prohibitedAttributes[role]) !== null && _prohibitedAttributes !== void 0 && _prohibitedAttributes.has(attributeName));
-  });
-}
-function ignorePresentationalRole(element, implicitRole) {
-  // https://rawgit.com/w3c/aria/stable/#conflict_resolution_presentation_none
-  return hasGlobalAriaAttributes(element, implicitRole);
-}
-function getRole(element) {
-  var explicitRole = getExplicitRole(element);
-  if (explicitRole === null || presentationRoles.indexOf(explicitRole) !== -1) {
-    var implicitRole = getImplicitRole(element);
-    if (presentationRoles.indexOf(explicitRole || "") === -1 || ignorePresentationalRole(element, implicitRole || "")) {
-      return implicitRole;
-    }
-  }
-  return explicitRole;
-}
-function getImplicitRole(element) {
-  var mappedByTag = localNameToRoleMappings[getLocalName(element)];
-  if (mappedByTag !== undefined) {
-    return mappedByTag;
-  }
-  switch (getLocalName(element)) {
-    case "a":
-    case "area":
-    case "link":
-      if (element.hasAttribute("href")) {
-        return "link";
-      }
-      break;
-    case "img":
-      if (element.getAttribute("alt") === "" && !ignorePresentationalRole(element, "img")) {
-        return "presentation";
-      }
-      return "img";
-    case "input":
-      {
-        var _ref = element,
-          type = _ref.type;
-        switch (type) {
-          case "button":
-          case "image":
-          case "reset":
-          case "submit":
-            return "button";
-          case "checkbox":
-          case "radio":
-            return type;
-          case "range":
-            return "slider";
-          case "email":
-          case "tel":
-          case "text":
-          case "url":
-            if (element.hasAttribute("list")) {
-              return "combobox";
-            }
-            return "textbox";
-          case "search":
-            if (element.hasAttribute("list")) {
-              return "combobox";
-            }
-            return "searchbox";
-          case "number":
-            return "spinbutton";
-          default:
-            return null;
-        }
-      }
-    case "select":
-      if (element.hasAttribute("multiple") || element.size > 1) {
-        return "listbox";
-      }
-      return "combobox";
-  }
-  return null;
-}
-function getExplicitRole(element) {
-  var role = element.getAttribute("role");
-  if (role !== null) {
-    var explicitRole = role.trim().split(" ")[0];
-    // String.prototype.split(sep, limit) will always return an array with at least one member
-    // as long as limit is either undefined or > 0
-    if (explicitRole.length > 0) {
-      return explicitRole;
-    }
-  }
-  return null;
-}
-
-var presentationRoles = ["presentation", "none"];
-function isElement(node) {
-  return node !== null && node.nodeType === node.ELEMENT_NODE;
-}
-function isHTMLTableCaptionElement(node) {
-  return isElement(node) && getLocalName(node) === "caption";
-}
-function isHTMLInputElement(node) {
-  return isElement(node) && getLocalName(node) === "input";
-}
-function isHTMLOptGroupElement(node) {
-  return isElement(node) && getLocalName(node) === "optgroup";
-}
-function isHTMLSelectElement(node) {
-  return isElement(node) && getLocalName(node) === "select";
-}
-function isHTMLTableElement(node) {
-  return isElement(node) && getLocalName(node) === "table";
-}
-function isHTMLTextAreaElement(node) {
-  return isElement(node) && getLocalName(node) === "textarea";
-}
-function safeWindow(node) {
-  var _ref = node.ownerDocument === null ? node : node.ownerDocument,
-    defaultView = _ref.defaultView;
-  if (defaultView === null) {
-    throw new TypeError("no window available");
-  }
-  return defaultView;
-}
-function isHTMLFieldSetElement(node) {
-  return isElement(node) && getLocalName(node) === "fieldset";
-}
-function isHTMLLegendElement(node) {
-  return isElement(node) && getLocalName(node) === "legend";
-}
-function isHTMLSlotElement(node) {
-  return isElement(node) && getLocalName(node) === "slot";
-}
-function isSVGElement(node) {
-  return isElement(node) && node.ownerSVGElement !== undefined;
-}
-function isSVGSVGElement(node) {
-  return isElement(node) && getLocalName(node) === "svg";
-}
-function isSVGTitleElement(node) {
-  return isSVGElement(node) && getLocalName(node) === "title";
-}
-
-/**
- *
- * @param {Node} node -
- * @param {string} attributeName -
- * @returns {Element[]} -
- */
-function queryIdRefs(node, attributeName) {
-  if (isElement(node) && node.hasAttribute(attributeName)) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- safe due to hasAttribute check
-    var ids = node.getAttribute(attributeName).split(" ");
-
-    // Browsers that don't support shadow DOM won't have getRootNode
-    var root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
-    return ids.map(function (id) {
-      return root.getElementById(id);
-    }).filter(function (element) {
-      return element !== null;
-    }
-    // TODO: why does this not narrow?
-    );
-  }
-
-  return [];
-}
-function hasAnyConcreteRoles(node, roles) {
-  if (isElement(node)) {
-    return roles.indexOf(getRole(node)) !== -1;
-  }
-  return false;
-}
-
-/**
- * implements https://w3c.github.io/accname/
- */
-
-/**
- *  A string of characters where all carriage returns, newlines, tabs, and form-feeds are replaced with a single space, and multiple spaces are reduced to a single space. The string contains only character data; it does not contain any markup.
- */
-
-/**
- * interface for an options-bag where `window.getComputedStyle` can be mocked
- */
-
-/**
- *
- * @param {string} string -
- * @returns {FlatString} -
- */
-function asFlatString(s) {
-  return s.trim().replace(/\s\s+/g, " ");
-}
-
-/**
- *
- * @param node -
- * @param options - These are not optional to prevent accidentally calling it without options in `computeAccessibleName`
- * @returns {boolean} -
- */
-function isHidden(node, getComputedStyleImplementation) {
-  if (!isElement(node)) {
-    return false;
-  }
-  if (node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true") {
-    return true;
-  }
-  var style = getComputedStyleImplementation(node);
-  return style.getPropertyValue("display") === "none" || style.getPropertyValue("visibility") === "hidden";
-}
-
-/**
- * @param {Node} node -
- * @returns {boolean} - As defined in step 2E of https://w3c.github.io/accname/#mapping_additional_nd_te
- */
-function isControl(node) {
-  return hasAnyConcreteRoles(node, ["button", "combobox", "listbox", "textbox"]) || hasAbstractRole(node, "range");
-}
-function hasAbstractRole(node, role) {
-  if (!isElement(node)) {
-    return false;
-  }
-  switch (role) {
-    case "range":
-      return hasAnyConcreteRoles(node, ["meter", "progressbar", "scrollbar", "slider", "spinbutton"]);
-    default:
-      throw new TypeError("No knowledge about abstract role '".concat(role, "'. This is likely a bug :("));
-  }
-}
-
-/**
- * element.querySelectorAll but also considers owned tree
- * @param element
- * @param selectors
- */
-function querySelectorAllSubtree(element, selectors) {
-  var elements = arrayFrom(element.querySelectorAll(selectors));
-  queryIdRefs(element, "aria-owns").forEach(function (root) {
-    // babel transpiles this assuming an iterator
-    elements.push.apply(elements, arrayFrom(root.querySelectorAll(selectors)));
-  });
-  return elements;
-}
-function querySelectedOptions(listbox) {
-  if (isHTMLSelectElement(listbox)) {
-    // IE11 polyfill
-    return listbox.selectedOptions || querySelectorAllSubtree(listbox, "[selected]");
-  }
-  return querySelectorAllSubtree(listbox, '[aria-selected="true"]');
-}
-function isMarkedPresentational(node) {
-  return hasAnyConcreteRoles(node, presentationRoles);
-}
-
-/**
- * Elements specifically listed in html-aam
- *
- * We don't need this for `label` or `legend` elements.
- * Their implicit roles already allow "naming from content".
- *
- * sources:
- *
- * - https://w3c.github.io/html-aam/#table-element
- */
-function isNativeHostLanguageTextAlternativeElement(node) {
-  return isHTMLTableCaptionElement(node);
-}
-
-/**
- * https://w3c.github.io/aria/#namefromcontent
- */
-function allowsNameFromContent(node) {
-  return hasAnyConcreteRoles(node, ["button", "cell", "checkbox", "columnheader", "gridcell", "heading", "label", "legend", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "row", "rowheader", "switch", "tab", "tooltip", "treeitem"]);
-}
-
-/**
- * TODO https://github.com/eps1lon/dom-accessibility-api/issues/100
- */
-function isDescendantOfNativeHostLanguageTextAlternativeElement(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- not implemented yet
-node) {
-  return false;
-}
-function getValueOfTextbox(element) {
-  if (isHTMLInputElement(element) || isHTMLTextAreaElement(element)) {
-    return element.value;
-  }
-  // https://github.com/eps1lon/dom-accessibility-api/issues/4
-  return element.textContent || "";
-}
-function getTextualContent(declaration) {
-  var content = declaration.getPropertyValue("content");
-  if (/^["'].*["']$/.test(content)) {
-    return content.slice(1, -1);
-  }
-  return "";
-}
-
-/**
- * https://html.spec.whatwg.org/multipage/forms.html#category-label
- * TODO: form-associated custom elements
- * @param element
- */
-function isLabelableElement(element) {
-  var localName = getLocalName(element);
-  return localName === "button" || localName === "input" && element.getAttribute("type") !== "hidden" || localName === "meter" || localName === "output" || localName === "progress" || localName === "select" || localName === "textarea";
-}
-
-/**
- * > [...], then the first such descendant in tree order is the label element's labeled control.
- * -- https://html.spec.whatwg.org/multipage/forms.html#labeled-control
- * @param element
- */
-function findLabelableElement(element) {
-  if (isLabelableElement(element)) {
-    return element;
-  }
-  var labelableElement = null;
-  element.childNodes.forEach(function (childNode) {
-    if (labelableElement === null && isElement(childNode)) {
-      var descendantLabelableElement = findLabelableElement(childNode);
-      if (descendantLabelableElement !== null) {
-        labelableElement = descendantLabelableElement;
-      }
-    }
-  });
-  return labelableElement;
-}
-
-/**
- * Polyfill of HTMLLabelElement.control
- * https://html.spec.whatwg.org/multipage/forms.html#labeled-control
- * @param label
- */
-function getControlOfLabel(label) {
-  if (label.control !== undefined) {
-    return label.control;
-  }
-  var htmlFor = label.getAttribute("for");
-  if (htmlFor !== null) {
-    return label.ownerDocument.getElementById(htmlFor);
-  }
-  return findLabelableElement(label);
-}
-
-/**
- * Polyfill of HTMLInputElement.labels
- * https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/labels
- * @param element
- */
-function getLabels(element) {
-  var labelsProperty = element.labels;
-  if (labelsProperty === null) {
-    return labelsProperty;
-  }
-  if (labelsProperty !== undefined) {
-    return arrayFrom(labelsProperty);
-  }
-
-  // polyfill
-  if (!isLabelableElement(element)) {
-    return null;
-  }
-  var document = element.ownerDocument;
-  return arrayFrom(document.querySelectorAll("label")).filter(function (label) {
-    return getControlOfLabel(label) === element;
-  });
-}
-
-/**
- * Gets the contents of a slot used for computing the accname
- * @param slot
- */
-function getSlotContents(slot) {
-  // Computing the accessible name for elements containing slots is not
-  // currently defined in the spec. This implementation reflects the
-  // behavior of NVDA 2020.2/Firefox 81 and iOS VoiceOver/Safari 13.6.
-  var assignedNodes = slot.assignedNodes();
-  if (assignedNodes.length === 0) {
-    // if no nodes are assigned to the slot, it displays the default content
-    return arrayFrom(slot.childNodes);
-  }
-  return assignedNodes;
-}
-
-/**
- * implements https://w3c.github.io/accname/#mapping_additional_nd_te
- * @param root
- * @param options
- * @returns
- */
-function computeTextAlternative(root) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var consultedNodes = new SetLike$1();
-  var window = safeWindow(root);
-  var _options$compute = options.compute,
-    compute = _options$compute === void 0 ? "name" : _options$compute,
-    _options$computedStyl = options.computedStyleSupportsPseudoElements,
-    computedStyleSupportsPseudoElements = _options$computedStyl === void 0 ? options.getComputedStyle !== undefined : _options$computedStyl,
-    _options$getComputedS = options.getComputedStyle,
-    getComputedStyle = _options$getComputedS === void 0 ? window.getComputedStyle.bind(window) : _options$getComputedS,
-    _options$hidden = options.hidden,
-    hidden = _options$hidden === void 0 ? false : _options$hidden;
-
-  // 2F.i
-  function computeMiscTextAlternative(node, context) {
-    var accumulatedText = "";
-    if (isElement(node) && computedStyleSupportsPseudoElements) {
-      var pseudoBefore = getComputedStyle(node, "::before");
-      var beforeContent = getTextualContent(pseudoBefore);
-      accumulatedText = "".concat(beforeContent, " ").concat(accumulatedText);
-    }
-
-    // FIXME: Including aria-owns is not defined in the spec
-    // But it is required in the web-platform-test
-    var childNodes = isHTMLSlotElement(node) ? getSlotContents(node) : arrayFrom(node.childNodes).concat(queryIdRefs(node, "aria-owns"));
-    childNodes.forEach(function (child) {
-      var result = computeTextAlternative(child, {
-        isEmbeddedInLabel: context.isEmbeddedInLabel,
-        isReferenced: false,
-        recursion: true
-      });
-      // TODO: Unclear why display affects delimiter
-      // see https://github.com/w3c/accname/issues/3
-      var display = isElement(child) ? getComputedStyle(child).getPropertyValue("display") : "inline";
-      var separator = display !== "inline" ? " " : "";
-      // trailing separator for wpt tests
-      accumulatedText += "".concat(separator).concat(result).concat(separator);
-    });
-    if (isElement(node) && computedStyleSupportsPseudoElements) {
-      var pseudoAfter = getComputedStyle(node, "::after");
-      var afterContent = getTextualContent(pseudoAfter);
-      accumulatedText = "".concat(accumulatedText, " ").concat(afterContent);
-    }
-    return accumulatedText.trim();
-  }
-
-  /**
-   *
-   * @param element
-   * @param attributeName
-   * @returns A string non-empty string or `null`
-   */
-  function useAttribute(element, attributeName) {
-    var attribute = element.getAttributeNode(attributeName);
-    if (attribute !== null && !consultedNodes.has(attribute) && attribute.value.trim() !== "") {
-      consultedNodes.add(attribute);
-      return attribute.value;
-    }
-    return null;
-  }
-  function computeTooltipAttributeValue(node) {
-    if (!isElement(node)) {
-      return null;
-    }
-    return useAttribute(node, "title");
-  }
-  function computeElementTextAlternative(node) {
-    if (!isElement(node)) {
-      return null;
-    }
-
-    // https://w3c.github.io/html-aam/#fieldset-and-legend-elements
-    if (isHTMLFieldSetElement(node)) {
-      consultedNodes.add(node);
-      var children = arrayFrom(node.childNodes);
-      for (var i = 0; i < children.length; i += 1) {
-        var child = children[i];
-        if (isHTMLLegendElement(child)) {
-          return computeTextAlternative(child, {
-            isEmbeddedInLabel: false,
-            isReferenced: false,
-            recursion: false
-          });
-        }
-      }
-    } else if (isHTMLTableElement(node)) {
-      // https://w3c.github.io/html-aam/#table-element
-      consultedNodes.add(node);
-      var _children = arrayFrom(node.childNodes);
-      for (var _i = 0; _i < _children.length; _i += 1) {
-        var _child = _children[_i];
-        if (isHTMLTableCaptionElement(_child)) {
-          return computeTextAlternative(_child, {
-            isEmbeddedInLabel: false,
-            isReferenced: false,
-            recursion: false
-          });
-        }
-      }
-    } else if (isSVGSVGElement(node)) {
-      // https://www.w3.org/TR/svg-aam-1.0/
-      consultedNodes.add(node);
-      var _children2 = arrayFrom(node.childNodes);
-      for (var _i2 = 0; _i2 < _children2.length; _i2 += 1) {
-        var _child2 = _children2[_i2];
-        if (isSVGTitleElement(_child2)) {
-          return _child2.textContent;
-        }
-      }
-      return null;
-    } else if (getLocalName(node) === "img" || getLocalName(node) === "area") {
-      // https://w3c.github.io/html-aam/#area-element
-      // https://w3c.github.io/html-aam/#img-element
-      var nameFromAlt = useAttribute(node, "alt");
-      if (nameFromAlt !== null) {
-        return nameFromAlt;
-      }
-    } else if (isHTMLOptGroupElement(node)) {
-      var nameFromLabel = useAttribute(node, "label");
-      if (nameFromLabel !== null) {
-        return nameFromLabel;
-      }
-    }
-    if (isHTMLInputElement(node) && (node.type === "button" || node.type === "submit" || node.type === "reset")) {
-      // https://w3c.github.io/html-aam/#input-type-text-input-type-password-input-type-search-input-type-tel-input-type-email-input-type-url-and-textarea-element-accessible-description-computation
-      var nameFromValue = useAttribute(node, "value");
-      if (nameFromValue !== null) {
-        return nameFromValue;
-      }
-
-      // TODO: l10n
-      if (node.type === "submit") {
-        return "Submit";
-      }
-      // TODO: l10n
-      if (node.type === "reset") {
-        return "Reset";
-      }
-    }
-    var labels = getLabels(node);
-    if (labels !== null && labels.length !== 0) {
-      consultedNodes.add(node);
-      return arrayFrom(labels).map(function (element) {
-        return computeTextAlternative(element, {
-          isEmbeddedInLabel: true,
-          isReferenced: false,
-          recursion: true
-        });
-      }).filter(function (label) {
-        return label.length > 0;
-      }).join(" ");
-    }
-
-    // https://w3c.github.io/html-aam/#input-type-image-accessible-name-computation
-    // TODO: wpt test consider label elements but html-aam does not mention them
-    // We follow existing implementations over spec
-    if (isHTMLInputElement(node) && node.type === "image") {
-      var _nameFromAlt = useAttribute(node, "alt");
-      if (_nameFromAlt !== null) {
-        return _nameFromAlt;
-      }
-      var nameFromTitle = useAttribute(node, "title");
-      if (nameFromTitle !== null) {
-        return nameFromTitle;
-      }
-
-      // TODO: l10n
-      return "Submit Query";
-    }
-    if (hasAnyConcreteRoles(node, ["button"])) {
-      // https://www.w3.org/TR/html-aam-1.0/#button-element
-      var nameFromSubTree = computeMiscTextAlternative(node, {
-        isEmbeddedInLabel: false});
-      if (nameFromSubTree !== "") {
-        return nameFromSubTree;
-      }
-    }
-    return null;
-  }
-  function computeTextAlternative(current, context) {
-    if (consultedNodes.has(current)) {
-      return "";
-    }
-
-    // 2A
-    if (!hidden && isHidden(current, getComputedStyle) && !context.isReferenced) {
-      consultedNodes.add(current);
-      return "";
-    }
-
-    // 2B
-    var labelAttributeNode = isElement(current) ? current.getAttributeNode("aria-labelledby") : null;
-    // TODO: Do we generally need to block query IdRefs of attributes we have already consulted?
-    var labelElements = labelAttributeNode !== null && !consultedNodes.has(labelAttributeNode) ? queryIdRefs(current, "aria-labelledby") : [];
-    if (compute === "name" && !context.isReferenced && labelElements.length > 0) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Can't be null here otherwise labelElements would be empty
-      consultedNodes.add(labelAttributeNode);
-      return labelElements.map(function (element) {
-        // TODO: Chrome will consider repeated values i.e. use a node multiple times while we'll bail out in computeTextAlternative.
-        return computeTextAlternative(element, {
-          isEmbeddedInLabel: context.isEmbeddedInLabel,
-          isReferenced: true,
-          // this isn't recursion as specified, otherwise we would skip
-          // `aria-label` in
-          // <input id="myself" aria-label="foo" aria-labelledby="myself"
-          recursion: false
-        });
-      }).join(" ");
-    }
-
-    // 2C
-    // Changed from the spec in anticipation of https://github.com/w3c/accname/issues/64
-    // spec says we should only consider skipping if we have a non-empty label
-    var skipToStep2E = context.recursion && isControl(current) && compute === "name";
-    if (!skipToStep2E) {
-      var ariaLabel = (isElement(current) && current.getAttribute("aria-label") || "").trim();
-      if (ariaLabel !== "" && compute === "name") {
-        consultedNodes.add(current);
-        return ariaLabel;
-      }
-
-      // 2D
-      if (!isMarkedPresentational(current)) {
-        var elementTextAlternative = computeElementTextAlternative(current);
-        if (elementTextAlternative !== null) {
-          consultedNodes.add(current);
-          return elementTextAlternative;
-        }
-      }
-    }
-
-    // special casing, cheating to make tests pass
-    // https://github.com/w3c/accname/issues/67
-    if (hasAnyConcreteRoles(current, ["menu"])) {
-      consultedNodes.add(current);
-      return "";
-    }
-
-    // 2E
-    if (skipToStep2E || context.isEmbeddedInLabel || context.isReferenced) {
-      if (hasAnyConcreteRoles(current, ["combobox", "listbox"])) {
-        consultedNodes.add(current);
-        var selectedOptions = querySelectedOptions(current);
-        if (selectedOptions.length === 0) {
-          // defined per test `name_heading_combobox`
-          return isHTMLInputElement(current) ? current.value : "";
-        }
-        return arrayFrom(selectedOptions).map(function (selectedOption) {
-          return computeTextAlternative(selectedOption, {
-            isEmbeddedInLabel: context.isEmbeddedInLabel,
-            isReferenced: false,
-            recursion: true
-          });
-        }).join(" ");
-      }
-      if (hasAbstractRole(current, "range")) {
-        consultedNodes.add(current);
-        if (current.hasAttribute("aria-valuetext")) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- safe due to hasAttribute guard
-          return current.getAttribute("aria-valuetext");
-        }
-        if (current.hasAttribute("aria-valuenow")) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- safe due to hasAttribute guard
-          return current.getAttribute("aria-valuenow");
-        }
-        // Otherwise, use the value as specified by a host language attribute.
-        return current.getAttribute("value") || "";
-      }
-      if (hasAnyConcreteRoles(current, ["textbox"])) {
-        consultedNodes.add(current);
-        return getValueOfTextbox(current);
-      }
-    }
-
-    // 2F: https://w3c.github.io/accname/#step2F
-    if (allowsNameFromContent(current) || isElement(current) && context.isReferenced || isNativeHostLanguageTextAlternativeElement(current) || isDescendantOfNativeHostLanguageTextAlternativeElement()) {
-      var accumulatedText2F = computeMiscTextAlternative(current, {
-        isEmbeddedInLabel: context.isEmbeddedInLabel});
-      if (accumulatedText2F !== "") {
-        consultedNodes.add(current);
-        return accumulatedText2F;
-      }
-    }
-    if (current.nodeType === current.TEXT_NODE) {
-      consultedNodes.add(current);
-      return current.textContent || "";
-    }
-    if (context.recursion) {
-      consultedNodes.add(current);
-      return computeMiscTextAlternative(current, {
-        isEmbeddedInLabel: context.isEmbeddedInLabel});
-    }
-    var tooltipAttributeValue = computeTooltipAttributeValue(current);
-    if (tooltipAttributeValue !== null) {
-      consultedNodes.add(current);
-      return tooltipAttributeValue;
-    }
-
-    // TODO should this be reachable?
-    consultedNodes.add(current);
-    return "";
-  }
-  return asFlatString(computeTextAlternative(root, {
-    isEmbeddedInLabel: false,
-    // by spec computeAccessibleDescription starts with the referenced elements as roots
-    isReferenced: compute === "description",
-    recursion: false
-  }));
-}
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-
-/**
- * @param root
- * @param options
- * @returns
- */
-function computeAccessibleDescription(root) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var description = queryIdRefs(root, "aria-describedby").map(function (element) {
-    return computeTextAlternative(element, _objectSpread(_objectSpread({}, options), {}, {
-      compute: "description"
-    }));
-  }).join(" ");
-
-  // TODO: Technically we need to make sure that node wasn't used for the accessible name
-  //       This causes `description_1.0_combobox-focusable-manual` to fail
-
-  // https://w3c.github.io/aria/#aria-description
-  // mentions that aria-description should only be calculated if aria-describedby didn't provide
-  // a description
-  if (description === "") {
-    var ariaDescription = root.getAttribute("aria-description");
-    description = ariaDescription === null ? "" : ariaDescription;
-  }
-
-  // https://www.w3.org/TR/html-aam-1.0/#accessible-name-and-description-computation
-  // says for so many elements to use the `title` that we assume all elements are considered
-  if (description === "") {
-    var title = root.getAttribute("title");
-    description = title === null ? "" : title;
-  }
-  return description;
-}
-
-/**
- * https://w3c.github.io/aria/#namefromprohibited
- */
-function prohibitsNaming(node) {
-  return hasAnyConcreteRoles(node, ["caption", "code", "deletion", "emphasis", "generic", "insertion", "none", "paragraph", "presentation", "strong", "subscript", "superscript"]);
-}
-
-/**
- * implements https://w3c.github.io/accname/#mapping_additional_nd_name
- * @param root
- * @param options
- * @returns
- */
-function computeAccessibleName(root) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  if (prohibitsNaming(root)) {
-    return "";
-  }
-  return computeTextAlternative(root, options);
-}
-
-var picocolors = {exports: {}};
-
-var hasRequiredPicocolors;
-
-function requirePicocolors () {
-	if (hasRequiredPicocolors) return picocolors.exports;
-	hasRequiredPicocolors = 1;
-	let p = process || {}, argv = p.argv || [], env = p.env || {};
-	let isColorSupported =
-		!(!!env.NO_COLOR || argv.includes("--no-color")) &&
-		(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI);
-
-	let formatter = (open, close, replace = open) =>
-		input => {
-			let string = "" + input, index = string.indexOf(close, open.length);
-			return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
-		};
-
-	let replaceClose = (string, close, replace, index) => {
-		let result = "", cursor = 0;
-		do {
-			result += string.substring(cursor, index) + replace;
-			cursor = index + close.length;
-			index = string.indexOf(close, cursor);
-		} while (~index)
-		return result + string.substring(cursor)
-	};
-
-	let createColors = (enabled = isColorSupported) => {
-		let f = enabled ? formatter : () => String;
-		return {
-			isColorSupported: enabled,
-			reset: f("\x1b[0m", "\x1b[0m"),
-			bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-			dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-			italic: f("\x1b[3m", "\x1b[23m"),
-			underline: f("\x1b[4m", "\x1b[24m"),
-			inverse: f("\x1b[7m", "\x1b[27m"),
-			hidden: f("\x1b[8m", "\x1b[28m"),
-			strikethrough: f("\x1b[9m", "\x1b[29m"),
-
-			black: f("\x1b[30m", "\x1b[39m"),
-			red: f("\x1b[31m", "\x1b[39m"),
-			green: f("\x1b[32m", "\x1b[39m"),
-			yellow: f("\x1b[33m", "\x1b[39m"),
-			blue: f("\x1b[34m", "\x1b[39m"),
-			magenta: f("\x1b[35m", "\x1b[39m"),
-			cyan: f("\x1b[36m", "\x1b[39m"),
-			white: f("\x1b[37m", "\x1b[39m"),
-			gray: f("\x1b[90m", "\x1b[39m"),
-
-			bgBlack: f("\x1b[40m", "\x1b[49m"),
-			bgRed: f("\x1b[41m", "\x1b[49m"),
-			bgGreen: f("\x1b[42m", "\x1b[49m"),
-			bgYellow: f("\x1b[43m", "\x1b[49m"),
-			bgBlue: f("\x1b[44m", "\x1b[49m"),
-			bgMagenta: f("\x1b[45m", "\x1b[49m"),
-			bgCyan: f("\x1b[46m", "\x1b[49m"),
-			bgWhite: f("\x1b[47m", "\x1b[49m"),
-
-			blackBright: f("\x1b[90m", "\x1b[39m"),
-			redBright: f("\x1b[91m", "\x1b[39m"),
-			greenBright: f("\x1b[92m", "\x1b[39m"),
-			yellowBright: f("\x1b[93m", "\x1b[39m"),
-			blueBright: f("\x1b[94m", "\x1b[39m"),
-			magentaBright: f("\x1b[95m", "\x1b[39m"),
-			cyanBright: f("\x1b[96m", "\x1b[39m"),
-			whiteBright: f("\x1b[97m", "\x1b[39m"),
-
-			bgBlackBright: f("\x1b[100m", "\x1b[49m"),
-			bgRedBright: f("\x1b[101m", "\x1b[49m"),
-			bgGreenBright: f("\x1b[102m", "\x1b[49m"),
-			bgYellowBright: f("\x1b[103m", "\x1b[49m"),
-			bgBlueBright: f("\x1b[104m", "\x1b[49m"),
-			bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
-			bgCyanBright: f("\x1b[106m", "\x1b[49m"),
-			bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
-		}
-	};
-
-	picocolors.exports = createColors();
-	picocolors.exports.createColors = createColors;
-	return picocolors.exports;
-}
-
-var picocolorsExports = /*@__PURE__*/ requirePicocolors();
-var pico = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
-
-var css_escape$1 = {exports: {}};
-
-/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
-var css_escape = css_escape$1.exports;
-
-var hasRequiredCss_escape;
-
-function requireCss_escape () {
-	if (hasRequiredCss_escape) return css_escape$1.exports;
-	hasRequiredCss_escape = 1;
-	(function (module, exports$1) {
-(function(root, factory) {
-			// https://github.com/umdjs/umd/blob/master/returnExports.js
-			{
-				// For Node.js.
-				module.exports = factory(root);
-			}
-		}(typeof commonjsGlobal != 'undefined' ? commonjsGlobal : css_escape, function(root) {
-
-			if (root.CSS && root.CSS.escape) {
-				return root.CSS.escape;
-			}
-
-			// https://drafts.csswg.org/cssom/#serialize-an-identifier
-			var cssEscape = function(value) {
-				if (arguments.length == 0) {
-					throw new TypeError('`CSS.escape` requires an argument.');
-				}
-				var string = String(value);
-				var length = string.length;
-				var index = -1;
-				var codeUnit;
-				var result = '';
-				var firstCodeUnit = string.charCodeAt(0);
-				while (++index < length) {
-					codeUnit = string.charCodeAt(index);
-					// Note: there’s no need to special-case astral symbols, surrogate
-					// pairs, or lone surrogates.
-
-					// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
-					// (U+FFFD).
-					if (codeUnit == 0x0000) {
-						result += '\uFFFD';
-						continue;
-					}
-
-					if (
-						// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
-						// U+007F, […]
-						(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
-						// If the character is the first character and is in the range [0-9]
-						// (U+0030 to U+0039), […]
-						(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
-						// If the character is the second character and is in the range [0-9]
-						// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
-						(
-							index == 1 &&
-							codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
-							firstCodeUnit == 0x002D
-						)
-					) {
-						// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
-						result += '\\' + codeUnit.toString(16) + ' ';
-						continue;
-					}
-
-					if (
-						// If the character is the first character and is a `-` (U+002D), and
-						// there is no second character, […]
-						index == 0 &&
-						length == 1 &&
-						codeUnit == 0x002D
-					) {
-						result += '\\' + string.charAt(index);
-						continue;
-					}
-
-					// If the character is not handled by one of the above rules and is
-					// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
-					// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
-					// U+005A), or [a-z] (U+0061 to U+007A), […]
-					if (
-						codeUnit >= 0x0080 ||
-						codeUnit == 0x002D ||
-						codeUnit == 0x005F ||
-						codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
-						codeUnit >= 0x0041 && codeUnit <= 0x005A ||
-						codeUnit >= 0x0061 && codeUnit <= 0x007A
-					) {
-						// the character itself
-						result += string.charAt(index);
-						continue;
-					}
-
-					// Otherwise, the escaped character.
-					// https://drafts.csswg.org/cssom/#escape-a-character
-					result += '\\' + string.charAt(index);
-
-				}
-				return result;
-			};
-
-			if (!root.CSS) {
-				root.CSS = {};
-			}
-
-			root.CSS.escape = cssEscape;
-			return cssEscape;
-
-		})); 
-	} (css_escape$1));
-	return css_escape$1.exports;
-}
-
-var css_escapeExports = requireCss_escape();
-var escape = /*@__PURE__*/getDefaultExportFromCjs(css_escapeExports);
-
-class GenericTypeError extends Error {
-  constructor(expectedString, received, matcherFn, context) {
-    super();
-
-    /* istanbul ignore next */
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, matcherFn);
-    }
-    let withType = '';
-    try {
-      withType = context.utils.printWithType(
-        'Received',
-        received,
-        context.utils.printReceived,
-      );
-    } catch (e) {
-      // Can throw for Document:
-      // https://github.com/jsdom/jsdom/issues/2304
-    }
-    this.message = [
-      context.utils.matcherHint(
-        `${context.isNot ? '.not' : ''}.${matcherFn.name}`,
-        'received',
-        '',
-      ),
-      '',
-      // eslint-disable-next-line new-cap
-      `${context.utils.RECEIVED_COLOR(
-        'received',
-      )} value must ${expectedString}.`,
-      withType,
-    ].join('\n');
-  }
-}
-
-class HtmlElementTypeError extends GenericTypeError {
-  constructor(...args) {
-    super('be an HTMLElement or an SVGElement', ...args);
-  }
-}
-
-class NodeTypeError extends GenericTypeError {
-  constructor(...args) {
-    super('be a Node', ...args);
-  }
-}
-
-function checkHasWindow(htmlElement, ErrorClass, ...args) {
-  if (
-    !htmlElement ||
-    !htmlElement.ownerDocument ||
-    !htmlElement.ownerDocument.defaultView
-  ) {
-    throw new ErrorClass(htmlElement, ...args)
-  }
-}
-
-function checkNode(node, ...args) {
-  checkHasWindow(node, NodeTypeError, ...args);
-  const window = node.ownerDocument.defaultView;
-
-  if (!(node instanceof window.Node)) {
-    throw new NodeTypeError(node, ...args)
-  }
-}
-
-function checkHtmlElement(htmlElement, ...args) {
-  checkHasWindow(htmlElement, HtmlElementTypeError, ...args);
-  const window = htmlElement.ownerDocument.defaultView;
-
-  if (
-    !(htmlElement instanceof window.HTMLElement) &&
-    !(htmlElement instanceof window.SVGElement)
-  ) {
-    throw new HtmlElementTypeError(htmlElement, ...args)
-  }
-}
-
-class InvalidCSSError extends Error {
-  constructor(received, matcherFn, context) {
-    super();
-
-    /* istanbul ignore next */
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, matcherFn);
-    }
-    this.message = [
-      received.message,
-      '',
-      // eslint-disable-next-line new-cap
-      context.utils.RECEIVED_COLOR(`Failing css:`),
-      // eslint-disable-next-line new-cap
-      context.utils.RECEIVED_COLOR(`${received.css}`),
-    ].join('\n');
-  }
-}
-
-function parseCSS(css, ...args) {
-  const ast = $149c1bd638913645$export$98e6a39c04603d36(`selector { ${css} }`, {silent: true}).stylesheet;
-
-  if (ast.parsingErrors && ast.parsingErrors.length > 0) {
-    const {reason, line} = ast.parsingErrors[0];
-
-    throw new InvalidCSSError(
-      {
-        css,
-        message: `Syntax error parsing expected css: ${reason} on line: ${line}`,
-      },
-      ...args,
-    )
-  }
-
-  const parsedRules = ast.rules[0].declarations
-    .filter(d => d.type === 'declaration')
-    .reduce(
-      (obj, {property, value}) => Object.assign(obj, {[property]: value}),
-      {},
-    );
-  return parsedRules
-}
-
-function display(context, value) {
-  return typeof value === 'string' ? value : context.utils.stringify(value)
-}
-
-function getMessage(
-  context,
-  matcher,
-  expectedLabel,
-  expectedValue,
-  receivedLabel,
-  receivedValue,
-) {
-  return [
-    `${matcher}\n`,
-    // eslint-disable-next-line new-cap
-    `${expectedLabel}:\n${context.utils.EXPECTED_COLOR(
-      redent(display(context, expectedValue), 2),
-    )}`,
-    // eslint-disable-next-line new-cap
-    `${receivedLabel}:\n${context.utils.RECEIVED_COLOR(
-      redent(display(context, receivedValue), 2),
-    )}`,
-  ].join('\n')
-}
-
-function matches(textToMatch, matcher) {
-  if (matcher instanceof RegExp) {
-    return matcher.test(textToMatch)
-  } else {
-    return textToMatch.includes(String(matcher))
-  }
-}
-
-function deprecate(name, replacementText) {
-  // Notify user that they are using deprecated functionality.
-  // eslint-disable-next-line no-console
-  console.warn(
-    `Warning: ${name} has been deprecated and will be removed in future updates.`,
-    replacementText,
-  );
-}
-
-function normalize(text) {
-  return text.replace(/\s+/g, ' ').trim()
-}
-
-function getTag(element) {
-  return element.tagName && element.tagName.toLowerCase()
-}
-
-function getSelectValue({multiple, options}) {
-  const selectedOptions = [...options].filter(option => option.selected);
-
-  if (multiple) {
-    return [...selectedOptions].map(opt => opt.value)
-  }
-  /* istanbul ignore if */
-  if (selectedOptions.length === 0) {
-    return undefined // Couldn't make this happen, but just in case
-  }
-  return selectedOptions[0].value
-}
-
-function getInputValue(inputElement) {
-  switch (inputElement.type) {
-    case 'number':
-      return inputElement.value === '' ? null : Number(inputElement.value)
-    case 'checkbox':
-      return inputElement.checked
-    default:
-      return inputElement.value
-  }
-}
-
-const rolesSupportingValues = ['meter', 'progressbar', 'slider', 'spinbutton'];
-function getAccessibleValue(element) {
-  if (!rolesSupportingValues.includes(element.getAttribute('role'))) {
-    return undefined
-  }
-  return Number(element.getAttribute('aria-valuenow'))
-}
-
-function getSingleElementValue(element) {
-  /* istanbul ignore if */
-  if (!element) {
-    return undefined
-  }
-
-  switch (element.tagName.toLowerCase()) {
-    case 'input':
-      return getInputValue(element)
-    case 'select':
-      return getSelectValue(element)
-    default: {
-      return element.value ?? getAccessibleValue(element)
-    }
-  }
-}
-
-function toSentence(
-  array,
-  {wordConnector = ', ', lastWordConnector = ' and '} = {},
-) {
-  return [array.slice(0, -1).join(wordConnector), array[array.length - 1]].join(
-    array.length > 1 ? lastWordConnector : '',
-  )
-}
-
-function compareAsSet(val1, val2) {
-  if (Array.isArray(val1) && Array.isArray(val2)) {
-    return [...new Set(val1)].every(v => new Set(val2).has(v))
-  }
-  return val1 === val2
-}
-
-function toBeInTheDOM(element, container) {
-  deprecate(
-    'toBeInTheDOM',
-    'Please use toBeInTheDocument for searching the entire document and toContainElement for searching a specific container.',
-  );
-
-  if (element) {
-    checkHtmlElement(element, toBeInTheDOM, this);
-  }
-
-  if (container) {
-    checkHtmlElement(container, toBeInTheDOM, this);
-  }
-
-  return {
-    pass: container ? container.contains(element) : !!element,
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeInTheDOM`,
-          'element',
-          '',
-        ),
-        '',
-        'Received:',
-        `  ${this.utils.printReceived(
-          element ? element.cloneNode(false) : element,
-        )}`,
-      ].join('\n')
-    },
-  }
-}
-
-function toBeInTheDocument(element) {
-  if (element !== null || !this.isNot) {
-    checkHtmlElement(element, toBeInTheDocument, this);
-  }
-
-  const pass =
-    element === null
-      ? false
-      : element.ownerDocument === element.getRootNode({composed: true});
-
-  const errorFound = () => {
-    return `expected document not to contain element, found ${this.utils.stringify(
-      element.cloneNode(true),
-    )} instead`
-  };
-  const errorNotFound = () => {
-    return `element could not be found in the document`
-  };
-
-  return {
-    pass,
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeInTheDocument`,
-          'element',
-          '',
-        ),
-        '',
-        // eslint-disable-next-line new-cap
-        this.utils.RECEIVED_COLOR(this.isNot ? errorFound() : errorNotFound()),
-      ].join('\n')
-    },
-  }
-}
-
-function toBeEmpty(element) {
-  deprecate(
-    'toBeEmpty',
-    'Please use instead toBeEmptyDOMElement for finding empty nodes in the DOM.',
-  );
-  checkHtmlElement(element, toBeEmpty, this);
-
-  return {
-    pass: element.innerHTML === '',
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeEmpty`,
-          'element',
-          '',
-        ),
-        '',
-        'Received:',
-        `  ${this.utils.printReceived(element.innerHTML)}`,
-      ].join('\n')
-    },
-  }
-}
-
-function toBeEmptyDOMElement(element) {
-  checkHtmlElement(element, toBeEmptyDOMElement, this);
-
-  return {
-    pass: isEmptyElement(element),
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeEmptyDOMElement`,
-          'element',
-          '',
-        ),
-        '',
-        'Received:',
-        `  ${this.utils.printReceived(element.innerHTML)}`,
-      ].join('\n')
-    },
-  }
-}
-
-/**
- * Identifies if an element doesn't contain child nodes (excluding comments)
- * ℹ Node.COMMENT_NODE can't be used because of the following issue 
- * https://github.com/jsdom/jsdom/issues/2220
- *
- * @param {*} element an HtmlElement or SVGElement
- * @return {*} true if the element only contains comments or none
- */
-function isEmptyElement(element){
-  const nonCommentChildNodes = [...element.childNodes].filter(node => node.nodeType !== 8);
-  return nonCommentChildNodes.length === 0;
-}
-
-function toContainElement(container, element) {
-  checkHtmlElement(container, toContainElement, this);
-
-  if (element !== null) {
-    checkHtmlElement(element, toContainElement, this);
-  }
-
-  return {
-    pass: container.contains(element),
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toContainElement`,
-          'element',
-          'element',
-        ),
-        '',
-        // eslint-disable-next-line new-cap
-        this.utils.RECEIVED_COLOR(`${this.utils.stringify(
-          container.cloneNode(false),
-        )} ${
-          this.isNot ? 'contains:' : 'does not contain:'
-        } ${this.utils.stringify(element ? element.cloneNode(false) : element)}
-        `),
-      ].join('\n')
-    },
-  }
-}
-
-function getNormalizedHtml(container, htmlText) {
-  const div = container.ownerDocument.createElement('div');
-  div.innerHTML = htmlText;
-  return div.innerHTML
-}
-
-function toContainHTML(container, htmlText) {
-  checkHtmlElement(container, toContainHTML, this);
-
-  if (typeof htmlText !== 'string') {
-    throw new Error(`.toContainHTML() expects a string value, got ${htmlText}`)
-  }
-
-  return {
-    pass: container.outerHTML.includes(getNormalizedHtml(container, htmlText)),
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toContainHTML`,
-          'element',
-          '',
-        ),
-        'Expected:',
-        // eslint-disable-next-line new-cap
-        `  ${this.utils.EXPECTED_COLOR(htmlText)}`,
-        'Received:',
-        `  ${this.utils.printReceived(container.cloneNode(true))}`,
-      ].join('\n')
-    },
-  }
-}
-
-function toHaveTextContent(
-  node,
-  checkWith,
-  options = {normalizeWhitespace: true},
-) {
-  checkNode(node, toHaveTextContent, this);
-
-  const textContent = options.normalizeWhitespace
-    ? normalize(node.textContent)
-    : node.textContent.replace(/\u00a0/g, ' '); // Replace &nbsp; with normal spaces
-
-  const checkingWithEmptyString = textContent !== '' && checkWith === '';
-
-  return {
-    pass: !checkingWithEmptyString && matches(textContent, checkWith),
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      return getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toHaveTextContent`,
-          'element',
-          '',
-        ),
-        checkingWithEmptyString
-          ? `Checking with empty string will always match, use .toBeEmptyDOMElement() instead`
-          : `Expected element ${to} have text content`,
-        checkWith,
-        'Received',
-        textContent,
-      )
-    },
-  }
-}
-
-function toHaveAccessibleDescription(
-  htmlElement,
-  expectedAccessibleDescription,
-) {
-  checkHtmlElement(htmlElement, toHaveAccessibleDescription, this);
-  const actualAccessibleDescription = computeAccessibleDescription(htmlElement);
-  const missingExpectedValue = arguments.length === 1;
-
-  let pass = false;
-  if (missingExpectedValue) {
-    // When called without an expected value we only want to validate that the element has an
-    // accessible description, whatever it may be.
-    pass = actualAccessibleDescription !== '';
-  } else {
-    pass =
-      expectedAccessibleDescription instanceof RegExp
-        ? expectedAccessibleDescription.test(actualAccessibleDescription)
-        : this.equals(
-            actualAccessibleDescription,
-            expectedAccessibleDescription,
-          );
-  }
-
-  return {
-    pass,
-
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      return getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.${toHaveAccessibleDescription.name}`,
-          'element',
-          '',
-        ),
-        `Expected element ${to} have accessible description`,
-        expectedAccessibleDescription,
-        'Received',
-        actualAccessibleDescription,
-      )
-    },
-  }
-}
-
-const ariaInvalidName = 'aria-invalid';
-const validStates = ['false'];
-
-// See `aria-errormessage` spec at https://www.w3.org/TR/wai-aria-1.2/#aria-errormessage
-function toHaveAccessibleErrorMessage(
-  htmlElement,
-  expectedAccessibleErrorMessage,
-) {
-  checkHtmlElement(htmlElement, toHaveAccessibleErrorMessage, this);
-  const to = this.isNot ? 'not to' : 'to';
-  const method = this.isNot
-    ? '.not.toHaveAccessibleErrorMessage'
-    : '.toHaveAccessibleErrorMessage';
-
-  // Enforce Valid Id
-  const errormessageId = htmlElement.getAttribute('aria-errormessage');
-  const errormessageIdInvalid = !!errormessageId && /\s+/.test(errormessageId);
-
-  if (errormessageIdInvalid) {
-    return {
-      pass: false,
-      message: () => {
-        return getMessage(
-          this,
-          this.utils.matcherHint(method, 'element'),
-          "Expected element's `aria-errormessage` attribute to be empty or a single, valid ID",
-          '',
-          'Received',
-          `aria-errormessage="${errormessageId}"`,
-        )
-      },
-    }
-  }
-
-  // See `aria-invalid` spec at https://www.w3.org/TR/wai-aria-1.2/#aria-invalid
-  const ariaInvalidVal = htmlElement.getAttribute(ariaInvalidName);
-  const fieldValid =
-    !htmlElement.hasAttribute(ariaInvalidName) ||
-    validStates.includes(ariaInvalidVal);
-
-  // Enforce Valid `aria-invalid` Attribute
-  if (fieldValid) {
-    return {
-      pass: false,
-      message: () => {
-        return getMessage(
-          this,
-          this.utils.matcherHint(method, 'element'),
-          'Expected element to be marked as invalid with attribute',
-          `${ariaInvalidName}="${String(true)}"`,
-          'Received',
-          htmlElement.hasAttribute('aria-invalid')
-            ? `${ariaInvalidName}="${htmlElement.getAttribute(ariaInvalidName)}`
-            : null,
-        )
-      },
-    }
-  }
-
-  const error = normalize(
-    htmlElement.ownerDocument.getElementById(errormessageId)?.textContent ?? '',
-  );
-
-  return {
-    pass:
-      expectedAccessibleErrorMessage === undefined
-        ? Boolean(error)
-        : expectedAccessibleErrorMessage instanceof RegExp
-        ? expectedAccessibleErrorMessage.test(error)
-        : this.equals(error, expectedAccessibleErrorMessage),
-
-    message: () => {
-      return getMessage(
-        this,
-        this.utils.matcherHint(method, 'element'),
-        `Expected element ${to} have accessible error message`,
-        expectedAccessibleErrorMessage ?? '',
-        'Received',
-        error,
-      )
-    },
-  }
-}
-
-const elementRoleList = buildElementRoleList(libExports.elementRoles);
-
-function toHaveRole(htmlElement, expectedRole) {
-  checkHtmlElement(htmlElement, toHaveRole, this);
-
-  const actualRoles = getExplicitOrImplicitRoles(htmlElement);
-  const pass = actualRoles.some(el => el === expectedRole);
-
-  return {
-    pass,
-
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      return getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.${toHaveRole.name}`,
-          'element',
-          '',
-        ),
-        `Expected element ${to} have role`,
-        expectedRole,
-        'Received',
-        actualRoles.join(', '),
-      )
-    },
-  }
-}
-
-function getExplicitOrImplicitRoles(htmlElement) {
-  const hasExplicitRole = htmlElement.hasAttribute('role');
-
-  if (hasExplicitRole) {
-    const roleValue = htmlElement.getAttribute('role');
-
-    // Handle fallback roles, such as role="switch button"
-    // testing-library gates this behind the `queryFallbacks` flag; it is
-    // unclear why, but it makes sense to support this pattern out of the box
-    // https://testing-library.com/docs/queries/byrole/#queryfallbacks
-    return roleValue.split(' ').filter(Boolean)
-  }
-
-  const implicitRoles = getImplicitAriaRoles(htmlElement);
-
-  return implicitRoles
-}
-
-function getImplicitAriaRoles(currentNode) {
-  for (const {match, roles} of elementRoleList) {
-    if (match(currentNode)) {
-      return [...roles]
-    }
-  }
-
-  /* istanbul ignore next */
-  return [] // this does not get reached in practice, since elements have at least a 'generic' role
-}
-
-/**
- * Transform the roles map (with required attributes and constraints) to a list
- * of roles. Each item in the list has functions to match an element against it.
- *
- * Essentially copied over from [dom-testing-library's
- * helpers](https://github.com/testing-library/dom-testing-library/blob/bd04cf95a1ed85a2238f7dfc1a77d5d16b4f59dc/src/role-helpers.js#L80)
- *
- * TODO: If we are truly just copying over stuff, would it make sense to move
- * this to a separate package?
- *
- * TODO: This technique relies on CSS selectors; are those consistently
- * available in all jest-dom environments? Why do other matchers in this package
- * not use them like this?
- */
-function buildElementRoleList(elementRolesMap) {
-  function makeElementSelector({name, attributes}) {
-    return `${name}${attributes
-      .map(({name: attributeName, value, constraints = []}) => {
-        const shouldNotExist = constraints.indexOf('undefined') !== -1;
-        if (shouldNotExist) {
-          return `:not([${attributeName}])`
-        } else if (value) {
-          return `[${attributeName}="${value}"]`
-        } else {
-          return `[${attributeName}]`
-        }
-      })
-      .join('')}`
-  }
-
-  function getSelectorSpecificity({attributes = []}) {
-    return attributes.length
-  }
-
-  function bySelectorSpecificity(
-    {specificity: leftSpecificity},
-    {specificity: rightSpecificity},
-  ) {
-    return rightSpecificity - leftSpecificity
-  }
-
-  function match(element) {
-    let {attributes = []} = element;
-
-    // https://github.com/testing-library/dom-testing-library/issues/814
-    const typeTextIndex = attributes.findIndex(
-      attribute =>
-        attribute.value &&
-        attribute.name === 'type' &&
-        attribute.value === 'text',
-    );
-
-    if (typeTextIndex >= 0) {
-      // not using splice to not mutate the attributes array
-      attributes = [
-        ...attributes.slice(0, typeTextIndex),
-        ...attributes.slice(typeTextIndex + 1),
-      ];
-    }
-
-    const selector = makeElementSelector({...element, attributes});
-
-    return node => {
-      if (typeTextIndex >= 0 && node.type !== 'text') {
-        return false
-      }
-
-      return node.matches(selector)
-    }
-  }
-
-  let result = [];
-
-  for (const [element, roles] of elementRolesMap.entries()) {
-    result = [
-      ...result,
-      {
-        match: match(element),
-        roles: Array.from(roles),
-        specificity: getSelectorSpecificity(element),
-      },
-    ];
-  }
-
-  return result.sort(bySelectorSpecificity)
-}
-
-function toHaveAccessibleName(htmlElement, expectedAccessibleName) {
-  checkHtmlElement(htmlElement, toHaveAccessibleName, this);
-  const actualAccessibleName = computeAccessibleName(htmlElement);
-  const missingExpectedValue = arguments.length === 1;
-
-  let pass = false;
-  if (missingExpectedValue) {
-    // When called without an expected value we only want to validate that the element has an
-    // accessible name, whatever it may be.
-    pass = actualAccessibleName !== '';
-  } else {
-    pass =
-      expectedAccessibleName instanceof RegExp
-        ? expectedAccessibleName.test(actualAccessibleName)
-        : this.equals(actualAccessibleName, expectedAccessibleName);
-  }
-
-  return {
-    pass,
-
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      return getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.${toHaveAccessibleName.name}`,
-          'element',
-          '',
-        ),
-        `Expected element ${to} have accessible name`,
-        expectedAccessibleName,
-        'Received',
-        actualAccessibleName,
-      )
-    },
-  }
-}
-
-function printAttribute(stringify, name, value) {
-  return value === undefined ? name : `${name}=${stringify(value)}`
-}
-
-function getAttributeComment(stringify, name, value) {
-  return value === undefined
-    ? `element.hasAttribute(${stringify(name)})`
-    : `element.getAttribute(${stringify(name)}) === ${stringify(value)}`
-}
-
-function toHaveAttribute(htmlElement, name, expectedValue) {
-  checkHtmlElement(htmlElement, toHaveAttribute, this);
-  const isExpectedValuePresent = expectedValue !== undefined;
-  const hasAttribute = htmlElement.hasAttribute(name);
-  const receivedValue = htmlElement.getAttribute(name);
-  return {
-    pass: isExpectedValuePresent
-      ? hasAttribute && this.equals(receivedValue, expectedValue)
-      : hasAttribute,
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      const receivedAttribute = hasAttribute
-        ? printAttribute(this.utils.stringify, name, receivedValue)
-        : null;
-      const matcher = this.utils.matcherHint(
-        `${this.isNot ? '.not' : ''}.toHaveAttribute`,
-        'element',
-        this.utils.printExpected(name),
-        {
-          secondArgument: isExpectedValuePresent
-            ? this.utils.printExpected(expectedValue)
-            : undefined,
-          comment: getAttributeComment(
-            this.utils.stringify,
-            name,
-            expectedValue,
-          ),
-        },
-      );
-      return getMessage(
-        this,
-        matcher,
-        `Expected the element ${to} have attribute`,
-        printAttribute(this.utils.stringify, name, expectedValue),
-        'Received',
-        receivedAttribute,
-      )
-    },
-  }
-}
-
-function getExpectedClassNamesAndOptions(params) {
-  const lastParam = params.pop();
-  let expectedClassNames, options;
-
-  if (typeof lastParam === 'object' && !(lastParam instanceof RegExp)) {
-    expectedClassNames = params;
-    options = lastParam;
-  } else {
-    expectedClassNames = params.concat(lastParam);
-    options = {exact: false};
-  }
-  return {expectedClassNames, options}
-}
-
-function splitClassNames(str) {
-  if (!str) return []
-  return str.split(/\s+/).filter(s => s.length > 0)
-}
-
-function isSubset$1(subset, superset) {
-  return subset.every(strOrRegexp =>
-    typeof strOrRegexp === 'string'
-      ? superset.includes(strOrRegexp)
-      : superset.some(className => strOrRegexp.test(className)),
-  )
-}
-
-function toHaveClass(htmlElement, ...params) {
-  checkHtmlElement(htmlElement, toHaveClass, this);
-  const {expectedClassNames, options} = getExpectedClassNamesAndOptions(params);
-
-  const received = splitClassNames(htmlElement.getAttribute('class'));
-  const expected = expectedClassNames.reduce(
-    (acc, className) =>
-      acc.concat(
-        typeof className === 'string' || !className
-          ? splitClassNames(className)
-          : className,
-      ),
-    [],
-  );
-
-  const hasRegExp = expected.some(className => className instanceof RegExp);
-  if (options.exact && hasRegExp) {
-    throw new Error('Exact option does not support RegExp expected class names')
-  }
-
-  if (options.exact) {
-    return {
-      pass: isSubset$1(expected, received) && expected.length === received.length,
-      message: () => {
-        const to = this.isNot ? 'not to' : 'to';
-        return getMessage(
-          this,
-          this.utils.matcherHint(
-            `${this.isNot ? '.not' : ''}.toHaveClass`,
-            'element',
-            this.utils.printExpected(expected.join(' ')),
-          ),
-          `Expected the element ${to} have EXACTLY defined classes`,
-          expected.join(' '),
-          'Received',
-          received.join(' '),
-        )
-      },
-    }
-  }
-
-  return expected.length > 0
-    ? {
-        pass: isSubset$1(expected, received),
-        message: () => {
-          const to = this.isNot ? 'not to' : 'to';
-          return getMessage(
-            this,
-            this.utils.matcherHint(
-              `${this.isNot ? '.not' : ''}.toHaveClass`,
-              'element',
-              this.utils.printExpected(expected.join(' ')),
-            ),
-            `Expected the element ${to} have class`,
-            expected.join(' '),
-            'Received',
-            received.join(' '),
-          )
-        },
-      }
-    : {
-        pass: this.isNot ? received.length > 0 : false,
-        message: () =>
-          this.isNot
-            ? getMessage(
-                this,
-                this.utils.matcherHint('.not.toHaveClass', 'element', ''),
-                'Expected the element to have classes',
-                '(none)',
-                'Received',
-                received.join(' '),
-              )
-            : [
-                this.utils.matcherHint(`.toHaveClass`, 'element'),
-                'At least one expected class must be provided.',
-              ].join('\n'),
-      }
-}
-
-function getStyleDeclaration(document, css) {
-  const styles = {};
-
-  // The next block is necessary to normalize colors
-  const copy = document.createElement('div');
-  Object.keys(css).forEach(property => {
-    copy.style[property] = css[property];
-    styles[property] = copy.style[property];
-  });
-
-  return styles
-}
-
-function isSubset(styles, computedStyle) {
-  return (
-    !!Object.keys(styles).length &&
-    Object.entries(styles).every(([prop, value]) => {
-      const isCustomProperty = prop.startsWith('--');
-      const spellingVariants = [prop];
-      if (!isCustomProperty) spellingVariants.push(prop.toLowerCase());
-
-      return spellingVariants.some(
-        name =>
-          computedStyle[name] === value ||
-          computedStyle.getPropertyValue(name) === value,
-      )
-    })
-  )
-}
-
-function printoutStyles(styles) {
-  return Object.keys(styles)
-    .sort()
-    .map(prop => `${prop}: ${styles[prop]};`)
-    .join('\n')
-}
-
-// Highlights only style rules that were expected but were not found in the
-// received computed styles
-function expectedDiff(diffFn, expected, computedStyles) {
-  const received = Array.from(computedStyles)
-    .filter(prop => expected[prop] !== undefined)
-    .reduce(
-      (obj, prop) =>
-        Object.assign(obj, {[prop]: computedStyles.getPropertyValue(prop)}),
-      {},
-    );
-  const diffOutput = diffFn(printoutStyles(expected), printoutStyles(received));
-  // Remove the "+ Received" annotation because this is a one-way diff
-  return diffOutput.replace(`${pico.red('+ Received')}\n`, '')
-}
-
-function toHaveStyle(htmlElement, css) {
-  checkHtmlElement(htmlElement, toHaveStyle, this);
-  const parsedCSS =
-    typeof css === 'object' ? css : parseCSS(css, toHaveStyle, this);
-  const {getComputedStyle} = htmlElement.ownerDocument.defaultView;
-
-  const expected = getStyleDeclaration(htmlElement.ownerDocument, parsedCSS);
-  const received = getComputedStyle(htmlElement);
-
-  return {
-    pass: isSubset(expected, received),
-    message: () => {
-      const matcher = `${this.isNot ? '.not' : ''}.toHaveStyle`;
-      return [
-        this.utils.matcherHint(matcher, 'element', ''),
-        expectedDiff(this.utils.diff, expected, received),
-      ].join('\n\n')
-    },
-  }
-}
-
-function toHaveFocus(element) {
-  checkHtmlElement(element, toHaveFocus, this);
-
-  return {
-    pass: element.ownerDocument.activeElement === element,
-    message: () => {
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toHaveFocus`,
-          'element',
-          '',
-        ),
-        '',
-        ...(this.isNot
-          ? [
-              'Received element is focused:',
-              `  ${this.utils.printReceived(element)}`,
-            ]
-          : [
-              'Expected element with focus:',
-              `  ${this.utils.printExpected(element)}`,
-              'Received element with focus:',
-              `  ${this.utils.printReceived(
-                element.ownerDocument.activeElement,
-              )}`,
-            ]),
-      ].join('\n')
-    },
-  }
-}
-
-// Returns the combined value of several elements that have the same name
-// e.g. radio buttons or groups of checkboxes
-function getMultiElementValue(elements) {
-  const types = [...new Set(elements.map(element => element.type))];
-  if (types.length !== 1) {
-    throw new Error(
-      'Multiple form elements with the same name must be of the same type',
-    )
-  }
-  switch (types[0]) {
-    case 'radio': {
-      const theChosenOne = elements.find(radio => radio.checked);
-      return theChosenOne ? theChosenOne.value : undefined
-    }
-    case 'checkbox':
-      return elements
-        .filter(checkbox => checkbox.checked)
-        .map(checkbox => checkbox.value)
-    default:
-      // NOTE: Not even sure this is a valid use case, but just in case...
-      return elements.map(element => element.value)
-  }
-}
-
-function getFormValue(container, name) {
-  const elements = [...container.querySelectorAll(`[name="${escape(name)}"]`)];
-  /* istanbul ignore if */
-  if (elements.length === 0) {
-    return undefined // shouldn't happen, but just in case
-  }
-  switch (elements.length) {
-    case 1:
-      return getSingleElementValue(elements[0])
-    default:
-      return getMultiElementValue(elements)
-  }
-}
-
-// Strips the `[]` suffix off a form value name
-function getPureName(name) {
-  return /\[\]$/.test(name) ? name.slice(0, -2) : name
-}
-
-function getAllFormValues(container) {
-  const names = Array.from(container.elements).map(element => element.name);
-  return names.reduce(
-    (obj, name) => ({
-      ...obj,
-      [getPureName(name)]: getFormValue(container, name),
-    }),
-    {},
-  )
-}
-
-function toHaveFormValues(formElement, expectedValues) {
-  checkHtmlElement(formElement, toHaveFormValues, this);
-  if (!formElement.elements) {
-    // TODO: Change condition to use instanceof against the appropriate element classes instead
-    throw new Error('toHaveFormValues must be called on a form or a fieldset')
-  }
-  const formValues = getAllFormValues(formElement);
-  return {
-    pass: Object.entries(expectedValues).every(([name, expectedValue]) =>
-      compareAsSet(formValues[name], expectedValue),
-    ),
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      const matcher = `${this.isNot ? '.not' : ''}.toHaveFormValues`;
-      const commonKeyValues = Object.keys(formValues)
-        .filter(key => expectedValues.hasOwnProperty(key))
-        .reduce((obj, key) => ({...obj, [key]: formValues[key]}), {});
-      return [
-        this.utils.matcherHint(matcher, 'element', ''),
-        `Expected the element ${to} have form values`,
-        this.utils.diff(expectedValues, commonKeyValues),
-      ].join('\n\n')
-    },
-  }
-}
-
-function isStyleVisible(element) {
-  const {getComputedStyle} = element.ownerDocument.defaultView;
-
-  const {display, visibility, opacity} = getComputedStyle(element);
-  return (
-    display !== 'none' &&
-    visibility !== 'hidden' &&
-    visibility !== 'collapse' &&
-    opacity !== '0' &&
-    opacity !== 0
-  )
-}
-
-function isAttributeVisible(element, previousElement) {
-  let detailsVisibility;
-
-  if (previousElement) {
-    detailsVisibility =
-      element.nodeName === 'DETAILS' && previousElement.nodeName !== 'SUMMARY'
-        ? element.hasAttribute('open')
-        : true;
-  } else {
-    detailsVisibility =
-      element.nodeName === 'DETAILS' ? element.hasAttribute('open') : true;
-  }
-
-  return !element.hasAttribute('hidden') && detailsVisibility
-}
-
-function isElementVisible(element, previousElement) {
-  return (
-    isStyleVisible(element) &&
-    isAttributeVisible(element, previousElement) &&
-    (!element.parentElement || isElementVisible(element.parentElement, element))
-  )
-}
-
-function toBeVisible(element) {
-  checkHtmlElement(element, toBeVisible, this);
-  const isInDocument =
-    element.ownerDocument === element.getRootNode({composed: true});
-  const isVisible = isInDocument && isElementVisible(element);
-  return {
-    pass: isVisible,
-    message: () => {
-      const is = isVisible ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeVisible`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} visible${
-          isInDocument ? '' : ' (element is not in the document)'
-        }:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-// form elements that support 'disabled'
-const FORM_TAGS$2 = [
-  'fieldset',
-  'input',
-  'select',
-  'optgroup',
-  'option',
-  'button',
-  'textarea',
-];
-
-/*
- * According to specification:
- * If <fieldset> is disabled, the form controls that are its descendants,
- * except descendants of its first optional <legend> element, are disabled
- *
- * https://html.spec.whatwg.org/multipage/form-elements.html#concept-fieldset-disabled
- *
- * This method tests whether element is first legend child of fieldset parent
- */
-function isFirstLegendChildOfFieldset(element, parent) {
-  return (
-    getTag(element) === 'legend' &&
-    getTag(parent) === 'fieldset' &&
-    element.isSameNode(
-      Array.from(parent.children).find(child => getTag(child) === 'legend'),
-    )
-  )
-}
-
-function isElementDisabledByParent(element, parent) {
-  return (
-    isElementDisabled(parent) && !isFirstLegendChildOfFieldset(element, parent)
-  )
-}
-
-function isCustomElement(tag) {
-  return tag.includes('-')
-}
-
-/*
- * Only certain form elements and custom elements can actually be disabled:
- * https://html.spec.whatwg.org/multipage/semantics-other.html#disabled-elements
- */
-function canElementBeDisabled(element) {
-  const tag = getTag(element);
-  return FORM_TAGS$2.includes(tag) || isCustomElement(tag)
-}
-
-function isElementDisabled(element) {
-  return canElementBeDisabled(element) && element.hasAttribute('disabled')
-}
-
-function isAncestorDisabled(element) {
-  const parent = element.parentElement;
-  return (
-    Boolean(parent) &&
-    (isElementDisabledByParent(element, parent) || isAncestorDisabled(parent))
-  )
-}
-
-function isElementOrAncestorDisabled(element) {
-  return (
-    canElementBeDisabled(element) &&
-    (isElementDisabled(element) || isAncestorDisabled(element))
-  )
-}
-
-function toBeDisabled(element) {
-  checkHtmlElement(element, toBeDisabled, this);
-
-  const isDisabled = isElementOrAncestorDisabled(element);
-
-  return {
-    pass: isDisabled,
-    message: () => {
-      const is = isDisabled ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeDisabled`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} disabled:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-function toBeEnabled(element) {
-  checkHtmlElement(element, toBeEnabled, this);
-
-  const isEnabled = !isElementOrAncestorDisabled(element);
-
-  return {
-    pass: isEnabled,
-    message: () => {
-      const is = isEnabled ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeEnabled`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} enabled:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-// form elements that support 'required'
-const FORM_TAGS$1 = ['select', 'textarea'];
-
-const ARIA_FORM_TAGS = ['input', 'select', 'textarea'];
-
-const UNSUPPORTED_INPUT_TYPES = [
-  'color',
-  'hidden',
-  'range',
-  'submit',
-  'image',
-  'reset',
-];
-
-const SUPPORTED_ARIA_ROLES = [
-  'checkbox',
-  'combobox',
-  'gridcell',
-  'listbox',
-  'radiogroup',
-  'spinbutton',
-  'textbox',
-  'tree',
-];
-
-function isRequiredOnFormTagsExceptInput(element) {
-  return FORM_TAGS$1.includes(getTag(element)) && element.hasAttribute('required')
-}
-
-function isRequiredOnSupportedInput(element) {
-  return (
-    getTag(element) === 'input' &&
-    element.hasAttribute('required') &&
-    ((element.hasAttribute('type') &&
-      !UNSUPPORTED_INPUT_TYPES.includes(element.getAttribute('type'))) ||
-      !element.hasAttribute('type'))
-  )
-}
-
-function isElementRequiredByARIA(element) {
-  return (
-    element.hasAttribute('aria-required') &&
-    element.getAttribute('aria-required') === 'true' &&
-    (ARIA_FORM_TAGS.includes(getTag(element)) ||
-      (element.hasAttribute('role') &&
-        SUPPORTED_ARIA_ROLES.includes(element.getAttribute('role'))))
-  )
-}
-
-function toBeRequired(element) {
-  checkHtmlElement(element, toBeRequired, this);
-
-  const isRequired =
-    isRequiredOnFormTagsExceptInput(element) ||
-    isRequiredOnSupportedInput(element) ||
-    isElementRequiredByARIA(element);
-
-  return {
-    pass: isRequired,
-    message: () => {
-      const is = isRequired ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeRequired`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} required:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-const FORM_TAGS = ['form', 'input', 'select', 'textarea'];
-
-function isElementHavingAriaInvalid(element) {
-  return (
-    element.hasAttribute('aria-invalid') &&
-    element.getAttribute('aria-invalid') !== 'false'
-  )
-}
-
-function isSupportsValidityMethod(element) {
-  return FORM_TAGS.includes(getTag(element))
-}
-
-function isElementInvalid(element) {
-  const isHaveAriaInvalid = isElementHavingAriaInvalid(element);
-  if (isSupportsValidityMethod(element)) {
-    return isHaveAriaInvalid || !element.checkValidity()
-  } else {
-    return isHaveAriaInvalid
-  }
-}
-
-function toBeInvalid(element) {
-  checkHtmlElement(element, toBeInvalid, this);
-
-  const isInvalid = isElementInvalid(element);
-
-  return {
-    pass: isInvalid,
-    message: () => {
-      const is = isInvalid ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeInvalid`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} currently invalid:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-function toBeValid(element) {
-  checkHtmlElement(element, toBeValid, this);
-
-  const isValid = !isElementInvalid(element);
-
-  return {
-    pass: isValid,
-    message: () => {
-      const is = isValid ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeValid`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} currently valid:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-function toHaveValue(htmlElement, expectedValue) {
-  checkHtmlElement(htmlElement, toHaveValue, this);
-
-  if (
-    htmlElement.tagName.toLowerCase() === 'input' &&
-    ['checkbox', 'radio'].includes(htmlElement.type)
-  ) {
-    throw new Error(
-      'input with type=checkbox or type=radio cannot be used with .toHaveValue(). Use .toBeChecked() for type=checkbox or .toHaveFormValues() instead',
-    )
-  }
-
-  const receivedValue = getSingleElementValue(htmlElement);
-  const expectsValue = expectedValue !== undefined;
-
-  let expectedTypedValue = expectedValue;
-  let receivedTypedValue = receivedValue;
-  if (expectedValue == receivedValue && expectedValue !== receivedValue) {
-    expectedTypedValue = `${expectedValue} (${typeof expectedValue})`;
-    receivedTypedValue = `${receivedValue} (${typeof receivedValue})`;
-  }
-
-  return {
-    pass: expectsValue
-      ? compareAsSet(receivedValue, expectedValue)
-      : Boolean(receivedValue),
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      const matcher = this.utils.matcherHint(
-        `${this.isNot ? '.not' : ''}.toHaveValue`,
-        'element',
-        expectedValue,
-      );
-      return getMessage(
-        this,
-        matcher,
-        `Expected the element ${to} have value`,
-        expectsValue ? expectedTypedValue : '(any)',
-        'Received',
-        receivedTypedValue,
-      )
-    },
-  }
-}
-
-function toHaveDisplayValue(htmlElement, expectedValue) {
-  checkHtmlElement(htmlElement, toHaveDisplayValue, this);
-  const tagName = htmlElement.tagName.toLowerCase();
-
-  if (!['select', 'input', 'textarea'].includes(tagName)) {
-    throw new Error(
-      '.toHaveDisplayValue() currently supports only input, textarea or select elements, try with another matcher instead.',
-    )
-  }
-
-  if (tagName === 'input' && ['radio', 'checkbox'].includes(htmlElement.type)) {
-    throw new Error(
-      `.toHaveDisplayValue() currently does not support input[type="${htmlElement.type}"], try with another matcher instead.`,
-    )
-  }
-
-  const values = getValues(tagName, htmlElement);
-  const expectedValues = getExpectedValues(expectedValue);
-  const numberOfMatchesWithValues = expectedValues.filter(expected =>
-    values.some(value =>
-      expected instanceof RegExp
-        ? expected.test(value)
-        : this.equals(value, String(expected)),
-    ),
-  ).length;
-
-  const matchedWithAllValues = numberOfMatchesWithValues === values.length;
-  const matchedWithAllExpectedValues =
-    numberOfMatchesWithValues === expectedValues.length;
-
-  return {
-    pass: matchedWithAllValues && matchedWithAllExpectedValues,
-    message: () =>
-      getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toHaveDisplayValue`,
-          'element',
-          '',
-        ),
-        `Expected element ${this.isNot ? 'not ' : ''}to have display value`,
-        expectedValue,
-        'Received',
-        values,
-      ),
-  }
-}
-
-function getValues(tagName, htmlElement) {
-  return tagName === 'select'
-    ? Array.from(htmlElement)
-        .filter(option => option.selected)
-        .map(option => option.textContent)
-    : [htmlElement.value]
-}
-
-function getExpectedValues(expectedValue) {
-  return expectedValue instanceof Array ? expectedValue : [expectedValue]
-}
-
-function toBeChecked(element) {
-  checkHtmlElement(element, toBeChecked, this);
-
-  const isValidInput = () => {
-    return (
-      element.tagName.toLowerCase() === 'input' &&
-      ['checkbox', 'radio'].includes(element.type)
-    )
-  };
-
-  const isValidAriaElement = () => {
-    return (
-      roleSupportsChecked(element.getAttribute('role')) &&
-      ['true', 'false'].includes(element.getAttribute('aria-checked'))
-    )
-  };
-
-  if (!isValidInput() && !isValidAriaElement()) {
-    return {
-      pass: false,
-      message: () =>
-        `only inputs with type="checkbox" or type="radio" or elements with ${supportedRolesSentence()} and a valid aria-checked attribute can be used with .toBeChecked(). Use .toHaveValue() instead`,
-    }
-  }
-
-  const isChecked = () => {
-    if (isValidInput()) return element.checked
-    return element.getAttribute('aria-checked') === 'true'
-  };
-
-  return {
-    pass: isChecked(),
-    message: () => {
-      const is = isChecked() ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBeChecked`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} checked:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-function supportedRolesSentence() {
-  return toSentence(
-    supportedRoles().map(role => `role="${role}"`),
-    {lastWordConnector: ' or '},
-  )
-}
-
-function supportedRoles() {
-  return libExports.roles.keys().filter(roleSupportsChecked)
-}
-
-function roleSupportsChecked(role) {
-  return libExports.roles.get(role)?.props['aria-checked'] !== undefined
-}
-
-function toBePartiallyChecked(element) {
-  checkHtmlElement(element, toBePartiallyChecked, this);
-
-  const isValidInput = () => {
-    return (
-      element.tagName.toLowerCase() === 'input' && element.type === 'checkbox'
-    )
-  };
-
-  const isValidAriaElement = () => {
-    return element.getAttribute('role') === 'checkbox'
-  };
-
-  if (!isValidInput() && !isValidAriaElement()) {
-    return {
-      pass: false,
-      message: () =>
-        'only inputs with type="checkbox" or elements with role="checkbox" and a valid aria-checked attribute can be used with .toBePartiallyChecked(). Use .toHaveValue() instead',
-    }
-  }
-
-  const isPartiallyChecked = () => {
-    const isAriaMixed = element.getAttribute('aria-checked') === 'mixed';
-
-    if (isValidInput()) {
-      return element.indeterminate || isAriaMixed
-    }
-
-    return isAriaMixed
-  };
-
-  return {
-    pass: isPartiallyChecked(),
-    message: () => {
-      const is = isPartiallyChecked() ? 'is' : 'is not';
-      return [
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toBePartiallyChecked`,
-          'element',
-          '',
-        ),
-        '',
-        `Received element ${is} partially checked:`,
-        `  ${this.utils.printReceived(element.cloneNode(false))}`,
-      ].join('\n')
-    },
-  }
-}
-
-// See algoritm: https://www.w3.org/TR/accname-1.1/#mapping_additional_nd_description
-function toHaveDescription(htmlElement, checkWith) {
-  deprecate(
-    'toHaveDescription',
-    'Please use toHaveAccessibleDescription.',
-  );
-
-  checkHtmlElement(htmlElement, toHaveDescription, this);
-
-  const expectsDescription = checkWith !== undefined;
-
-  const descriptionIDRaw = htmlElement.getAttribute('aria-describedby') || '';
-  const descriptionIDs = descriptionIDRaw.split(/\s+/).filter(Boolean);
-  let description = '';
-  if (descriptionIDs.length > 0) {
-    const document = htmlElement.ownerDocument;
-    const descriptionEls = descriptionIDs
-      .map(descriptionID => document.getElementById(descriptionID))
-      .filter(Boolean);
-    description = normalize(descriptionEls.map(el => el.textContent).join(' '));
-  }
-
-  return {
-    pass: expectsDescription
-      ? checkWith instanceof RegExp
-        ? checkWith.test(description)
-        : this.equals(description, checkWith)
-      : Boolean(description),
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      return getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toHaveDescription`,
-          'element',
-          '',
-        ),
-        `Expected the element ${to} have description`,
-        this.utils.printExpected(checkWith),
-        'Received',
-        this.utils.printReceived(description),
-      )
-    },
-  }
-}
-
-// See aria-errormessage spec https://www.w3.org/TR/wai-aria-1.2/#aria-errormessage
-function toHaveErrorMessage(htmlElement, checkWith) {
-  deprecate('toHaveErrorMessage', 'Please use toHaveAccessibleErrorMessage.');
-  checkHtmlElement(htmlElement, toHaveErrorMessage, this);
-
-  if (
-    !htmlElement.hasAttribute('aria-invalid') ||
-    htmlElement.getAttribute('aria-invalid') === 'false'
-  ) {
-    const not = this.isNot ? '.not' : '';
-
-    return {
-      pass: false,
-      message: () => {
-        return getMessage(
-          this,
-          this.utils.matcherHint(`${not}.toHaveErrorMessage`, 'element', ''),
-          `Expected the element to have invalid state indicated by`,
-          'aria-invalid="true"',
-          'Received',
-          htmlElement.hasAttribute('aria-invalid')
-            ? `aria-invalid="${htmlElement.getAttribute('aria-invalid')}"`
-            : this.utils.printReceived(''),
-        )
-      },
-    }
-  }
-
-  const expectsErrorMessage = checkWith !== undefined;
-
-  const errormessageIDRaw = htmlElement.getAttribute('aria-errormessage') || '';
-  const errormessageIDs = errormessageIDRaw.split(/\s+/).filter(Boolean);
-
-  let errormessage = '';
-  if (errormessageIDs.length > 0) {
-    const document = htmlElement.ownerDocument;
-
-    const errormessageEls = errormessageIDs
-      .map(errormessageID => document.getElementById(errormessageID))
-      .filter(Boolean);
-
-    errormessage = normalize(
-      errormessageEls.map(el => el.textContent).join(' '),
-    );
-  }
-
-  return {
-    pass: expectsErrorMessage
-      ? checkWith instanceof RegExp
-        ? checkWith.test(errormessage)
-        : this.equals(errormessage, checkWith)
-      : Boolean(errormessage),
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      return getMessage(
-        this,
-        this.utils.matcherHint(
-          `${this.isNot ? '.not' : ''}.toHaveErrorMessage`,
-          'element',
-          '',
-        ),
-        `Expected the element ${to} have error message`,
-        this.utils.printExpected(checkWith),
-        'Received',
-        this.utils.printReceived(errormessage),
-      )
-    },
-  }
-}
-
-/**
- * Returns the selection from the element.
- *
- * @param element {HTMLElement} The element to get the selection from.
- * @returns {String} The selection.
- */
-function getSelection(element) {
-  const selection = element.ownerDocument.getSelection();
-
-  if (['input', 'textarea'].includes(element.tagName.toLowerCase())) {
-    if (['radio', 'checkbox'].includes(element.type)) return ''
-    return element.value
-      .toString()
-      .substring(element.selectionStart, element.selectionEnd)
-  }
-
-  if (selection.anchorNode === null || selection.focusNode === null) {
-    // No selection
-    return ''
-  }
-
-  const originalRange = selection.getRangeAt(0);
-  const temporaryRange = element.ownerDocument.createRange();
-
-  if (selection.containsNode(element, false)) {
-    // Whole element is inside selection
-    temporaryRange.selectNodeContents(element);
-    selection.removeAllRanges();
-    selection.addRange(temporaryRange);
-  } else if (
-    element.contains(selection.anchorNode) &&
-    element.contains(selection.focusNode)
-  ) ; else {
-    // Element is partially selected
-    const selectionStartsWithinElement =
-      element === originalRange.startContainer ||
-      element.contains(originalRange.startContainer);
-    const selectionEndsWithinElement =
-      element === originalRange.endContainer ||
-      element.contains(originalRange.endContainer);
-    selection.removeAllRanges();
-
-    if (selectionStartsWithinElement || selectionEndsWithinElement) {
-      temporaryRange.selectNodeContents(element);
-
-      if (selectionStartsWithinElement) {
-        temporaryRange.setStart(
-          originalRange.startContainer,
-          originalRange.startOffset,
-        );
-      }
-      if (selectionEndsWithinElement) {
-        temporaryRange.setEnd(
-          originalRange.endContainer,
-          originalRange.endOffset,
-        );
-      }
-
-      selection.addRange(temporaryRange);
-    }
-  }
-
-  const result = selection.toString();
-
-  selection.removeAllRanges();
-  selection.addRange(originalRange);
-
-  return result
-}
-
-/**
- * Checks if the element has the string selected.
- *
- * @param htmlElement {HTMLElement} The html element to check the selection for.
- * @param expectedSelection {String} The selection as a string.
- */
-function toHaveSelection(htmlElement, expectedSelection) {
-  checkHtmlElement(htmlElement, toHaveSelection, this);
-
-  const expectsSelection = expectedSelection !== undefined;
-
-  if (expectsSelection && typeof expectedSelection !== 'string') {
-    throw new Error(`expected selection must be a string or undefined`)
-  }
-
-  const receivedSelection = getSelection(htmlElement);
-
-  return {
-    pass: expectsSelection
-      ? compareAsSet(receivedSelection, expectedSelection)
-      : Boolean(receivedSelection),
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-      const matcher = this.utils.matcherHint(
-        `${this.isNot ? '.not' : ''}.toHaveSelection`,
-        'element',
-        expectedSelection,
-      );
-      return getMessage(
-        this,
-        matcher,
-        `Expected the element ${to} have selection`,
-        expectsSelection ? expectedSelection : '(any)',
-        'Received',
-        receivedSelection,
-      )
-    },
-  }
-}
-
-function toBePressed(element) {
-  checkHtmlElement(element, toBePressed, this);
-
-  const roles = (element.getAttribute('role') || '')
-    .split(' ')
-    .map(role => role.trim());
-
-  const isButton =
-    element.tagName.toLowerCase() === 'button' ||
-    (element.tagName.toLowerCase() === 'input' && element.type === 'button') ||
-    roles.includes('button');
-
-  const pressedAttribute = element.getAttribute('aria-pressed');
-
-  const isValidAriaElement =
-    pressedAttribute === 'true' || pressedAttribute === 'false';
-
-  if (!isButton || !isValidAriaElement) {
-    return {
-      pass: false,
-      message: () =>
-        `Only button or input with type="button" or element with role="button" and a valid aria-pressed attribute can be used with .toBePressed()`,
-    }
-  }
-
-  const isPressed = pressedAttribute === 'true';
-
-  return {
-    pass: isButton && isPressed,
-
-    message: () => {
-      const matcher = this.utils.matcherHint(
-        `${this.isNot ? '.not' : ''}.toBePressed`,
-        'element',
-        '',
-      );
-
-      return getMessage(
-        this,
-        matcher,
-        `Expected element to have`,
-        `aria-pressed="${this.isNot ? 'false' : 'true'}"`,
-        `Received`,
-        `aria-pressed="${pressedAttribute}"`,
-      )
-    },
-  }
-}
-
-function toBePartiallyPressed(element) {
-  checkHtmlElement(element, toBePartiallyPressed, this);
-
-  const roles = (element.getAttribute('role') || '')
-    .split(' ')
-    .map(role => role.trim());
-
-  const isButton =
-    element.tagName.toLowerCase() === 'button' ||
-    (element.tagName.toLowerCase() === 'input' && element.type === 'button') ||
-    roles.includes('button');
-
-  const pressedAttribute = element.getAttribute('aria-pressed');
-
-  const isValidAriaElement =
-    pressedAttribute === 'true' ||
-    pressedAttribute === 'false' ||
-    pressedAttribute === 'mixed';
-
-  if (!isButton || !isValidAriaElement) {
-    return {
-      pass: false,
-      message: () =>
-        `Only button or input with type="button" or element with role="button" and a valid aria-pressed attribute can be used with .toBePartiallyPressed()`,
-    }
-  }
-
-  const isPartiallyPressed = pressedAttribute === 'mixed';
-
-  return {
-    pass: isButton && isPartiallyPressed,
-
-    message: () => {
-      const to = this.isNot ? 'not to' : 'to';
-
-      const matcher = this.utils.matcherHint(
-        `${this.isNot ? '.not' : ''}.toBePartiallyPressed`,
-        'element',
-        '',
-      );
-
-      return getMessage(
-        this,
-        matcher,
-        `Expected element ${to} have`,
-        `aria-pressed="mixed"`,
-        `Received`,
-        `aria-pressed="${pressedAttribute}"`,
-      )
-    },
-  }
-}
-
-// ref: https://dom.spec.whatwg.org/#dom-node-document_position_disconnected
-const DOCUMENT_POSITION_DISCONNECTED = 0x01;
-const DOCUMENT_POSITION_PRECEDING = 0x02;
-const DOCUMENT_POSITION_FOLLOWING = 0x04;
-const DOCUMENT_POSITION_CONTAINS = 0x08;
-const DOCUMENT_POSITION_CONTAINED_BY = 0x10;
-const DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
-
-// ref: https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
-const DOCUMENT_POSITIONS_STRINGS = {
-  [DOCUMENT_POSITION_DISCONNECTED]: 'Node.DOCUMENT_POSITION_DISCONNECTED',
-  [DOCUMENT_POSITION_PRECEDING]: 'Node.DOCUMENT_POSITION_PRECEDING',
-  [DOCUMENT_POSITION_FOLLOWING]: 'Node.DOCUMENT_POSITION_FOLLOWING',
-  [DOCUMENT_POSITION_CONTAINS]: 'Node.DOCUMENT_POSITION_CONTAINS',
-  [DOCUMENT_POSITION_CONTAINED_BY]: 'Node.DOCUMENT_POSITION_CONTAINED_BY',
-  [DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC]:
-    'Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC',
-};
-
-function makeDocumentPositionErrorString(documentPosition) {
-  if (documentPosition in DOCUMENT_POSITIONS_STRINGS) {
-    return `${DOCUMENT_POSITIONS_STRINGS[documentPosition]} (${documentPosition})`
-  }
-
-  return `Unknown document position (${documentPosition})`
-}
-
-function checkToAppear(methodName, targetDocumentPosition) {
-  // eslint-disable-next-line func-names
-  return function (element, secondElement) {
-    checkHtmlElement(element, toAppearBefore, this);
-    checkHtmlElement(secondElement, toAppearBefore, this);
-
-    const documentPosition = element.compareDocumentPosition(secondElement);
-    const pass = documentPosition === targetDocumentPosition;
-
-    return {
-      pass,
-      message: () => {
-        return [
-          this.utils.matcherHint(
-            `${this.isNot ? '.not' : ''}.${methodName}`,
-            'element',
-            'secondElement',
-          ),
-          '',
-          `Received: ${makeDocumentPositionErrorString(documentPosition)}`,
-        ].join('\n')
-      },
-    }
-  }
-}
-
-function toAppearBefore(element, secondElement) {
-  return checkToAppear('toAppearBefore', DOCUMENT_POSITION_FOLLOWING).apply(
-    this,
-    [element, secondElement],
-  )
-}
-
-function toAppearAfter(element, secondElement) {
-  return checkToAppear('toAppearAfter', DOCUMENT_POSITION_PRECEDING).apply(
-    this,
-    [element, secondElement],
-  )
-}
-
-var extensions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toAppearAfter: toAppearAfter,
-  toAppearBefore: toAppearBefore,
-  toBeChecked: toBeChecked,
-  toBeDisabled: toBeDisabled,
-  toBeEmpty: toBeEmpty,
-  toBeEmptyDOMElement: toBeEmptyDOMElement,
-  toBeEnabled: toBeEnabled,
-  toBeInTheDOM: toBeInTheDOM,
-  toBeInTheDocument: toBeInTheDocument,
-  toBeInvalid: toBeInvalid,
-  toBePartiallyChecked: toBePartiallyChecked,
-  toBePartiallyPressed: toBePartiallyPressed,
-  toBePressed: toBePressed,
-  toBeRequired: toBeRequired,
-  toBeValid: toBeValid,
-  toBeVisible: toBeVisible,
-  toContainElement: toContainElement,
-  toContainHTML: toContainHTML,
-  toHaveAccessibleDescription: toHaveAccessibleDescription,
-  toHaveAccessibleErrorMessage: toHaveAccessibleErrorMessage,
-  toHaveAccessibleName: toHaveAccessibleName,
-  toHaveAttribute: toHaveAttribute,
-  toHaveClass: toHaveClass,
-  toHaveDescription: toHaveDescription,
-  toHaveDisplayValue: toHaveDisplayValue,
-  toHaveErrorMessage: toHaveErrorMessage,
-  toHaveFocus: toHaveFocus,
-  toHaveFormValues: toHaveFormValues,
-  toHaveRole: toHaveRole,
-  toHaveSelection: toHaveSelection,
-  toHaveStyle: toHaveStyle,
-  toHaveTextContent: toHaveTextContent,
-  toHaveValue: toHaveValue
-});
-
-expect.extend(extensions);
-//# sourceMappingURL=index-BCxawEMQ.js.map