@m2c2kit/build-helpers 0.3.27 → 0.3.29

package/dist/index.js

@@ -3103,7 +3103,7 @@ function findOneChild(test, nodes) {
  * @param recurse Also consider child nodes.
  * @returns The first node that passes `test`.
  */
-function findOne(test, nodes, recurse = true) {
+function findOne$1(test, nodes, recurse = true) {
     const searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
     for (let i = 0; i < searchedNodes.length; i++) {
         const node = searchedNodes[i];
@@ -3111,7 +3111,9 @@ function findOne(test, nodes, recurse = true) {
             return node;
         }
         if (recurse && hasChildren(node) && node.children.length > 0) {
-            return findOne(test, node.children, true);
+            const found = findOne$1(test, node.children, true);
+            if (found)
+                return found;
         }
     }
     return null;
@@ -3138,7 +3140,7 @@ function existsOne(test, nodes) {
  * @param nodes Array of nodes to search.
  * @returns All nodes passing `test`.
  */
-function findAll(test, nodes) {
+function findAll$1(test, nodes) {
     const result = [];
     const nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
     const indexStack = [0];
@@ -3271,7 +3273,7 @@ function getElements(options, nodes, recurse, limit = Infinity) {
 function getElementById(id, nodes, recurse = true) {
     if (!Array.isArray(nodes))
         nodes = [nodes];
-    return findOne(getAttribCheck("id", id), nodes, recurse);
+    return findOne$1(getAttribCheck("id", id), nodes, recurse);
 }
 /**
  * Returns all nodes with the supplied `tagName`.
@@ -3638,8 +3640,8 @@ var DomUtils = /*#__PURE__*/Object.freeze({
     existsOne: existsOne,
     filter: filter,
     find: find,
-    findAll: findAll,
-    findOne: findOne,
+    findAll: findAll$1,
+    findOne: findOne$1,
     findOneChild: findOneChild,
     getAttributeValue: getAttributeValue,
     getChildren: getChildren,
@@ -3741,15 +3743,49 @@ var AttributeAction;
     AttributeAction["Start"] = "start";
 })(AttributeAction || (AttributeAction = {}));
 
-const reName = /^[^\\#]?(?:\\(?:[\da-f]{1,6}\s?|.)|[\w\-\u00b0-\uFFFF])+/;
+const reName = /^[^#\\]?(?:\\(?:[\da-f]{1,6}\s?|.)|[\w\u00B0-\uFFFF-])+/;
 const reEscape = /\\([\da-f]{1,6}\s?|(\s)|.)/gi;
+var CharCode;
+(function (CharCode) {
+    CharCode[CharCode["LeftParenthesis"] = 40] = "LeftParenthesis";
+    CharCode[CharCode["RightParenthesis"] = 41] = "RightParenthesis";
+    CharCode[CharCode["LeftSquareBracket"] = 91] = "LeftSquareBracket";
+    CharCode[CharCode["RightSquareBracket"] = 93] = "RightSquareBracket";
+    CharCode[CharCode["Comma"] = 44] = "Comma";
+    CharCode[CharCode["Period"] = 46] = "Period";
+    CharCode[CharCode["Colon"] = 58] = "Colon";
+    CharCode[CharCode["SingleQuote"] = 39] = "SingleQuote";
+    CharCode[CharCode["DoubleQuote"] = 34] = "DoubleQuote";
+    CharCode[CharCode["Plus"] = 43] = "Plus";
+    CharCode[CharCode["Tilde"] = 126] = "Tilde";
+    CharCode[CharCode["QuestionMark"] = 63] = "QuestionMark";
+    CharCode[CharCode["ExclamationMark"] = 33] = "ExclamationMark";
+    CharCode[CharCode["Slash"] = 47] = "Slash";
+    CharCode[CharCode["Equal"] = 61] = "Equal";
+    CharCode[CharCode["Dollar"] = 36] = "Dollar";
+    CharCode[CharCode["Pipe"] = 124] = "Pipe";
+    CharCode[CharCode["Circumflex"] = 94] = "Circumflex";
+    CharCode[CharCode["Asterisk"] = 42] = "Asterisk";
+    CharCode[CharCode["GreaterThan"] = 62] = "GreaterThan";
+    CharCode[CharCode["LessThan"] = 60] = "LessThan";
+    CharCode[CharCode["Hash"] = 35] = "Hash";
+    CharCode[CharCode["LowerI"] = 105] = "LowerI";
+    CharCode[CharCode["LowerS"] = 115] = "LowerS";
+    CharCode[CharCode["BackSlash"] = 92] = "BackSlash";
+    // Whitespace
+    CharCode[CharCode["Space"] = 32] = "Space";
+    CharCode[CharCode["Tab"] = 9] = "Tab";
+    CharCode[CharCode["NewLine"] = 10] = "NewLine";
+    CharCode[CharCode["FormFeed"] = 12] = "FormFeed";
+    CharCode[CharCode["CarriageReturn"] = 13] = "CarriageReturn";
+})(CharCode || (CharCode = {}));
 const actionTypes = new Map([
-    [126 /* Tilde */, AttributeAction.Element],
-    [94 /* Circumflex */, AttributeAction.Start],
-    [36 /* Dollar */, AttributeAction.End],
-    [42 /* Asterisk */, AttributeAction.Any],
-    [33 /* ExclamationMark */, AttributeAction.Not],
-    [124 /* Pipe */, AttributeAction.Hyphen],
+    [CharCode.Tilde, AttributeAction.Element],
+    [CharCode.Circumflex, AttributeAction.Start],
+    [CharCode.Dollar, AttributeAction.End],
+    [CharCode.Asterisk, AttributeAction.Any],
+    [CharCode.ExclamationMark, AttributeAction.Not],
+    [CharCode.Pipe, AttributeAction.Hyphen],
 ]);
 // Pseudos, whose data property is parsed as well.
 const unpackPseudos = new Set([
@@ -3761,6 +3797,18 @@ const unpackPseudos = new Set([
     "host",
     "host-context",
 ]);
+/**
+ * Pseudo elements defined in CSS Level 1 and CSS Level 2 can be written with
+ * a single colon; eg. :before will turn into ::before.
+ *
+ * @see {@link https://www.w3.org/TR/2018/WD-selectors-4-20181121/#pseudo-element-syntax}
+ */
+const pseudosToPseudoElements = new Set([
+    "before",
+    "after",
+    "first-line",
+    "first-letter",
+]);
 /**
  * Checks whether a specific selector is a traversal.
  * This is useful eg. in swapping the order of elements that
@@ -3775,43 +3823,44 @@ function isTraversal$1(selector) {
         case SelectorType.Descendant:
         case SelectorType.Parent:
         case SelectorType.Sibling:
-        case SelectorType.ColumnCombinator:
+        case SelectorType.ColumnCombinator: {
             return true;
-        default:
+        }
+        default: {
             return false;
+        }
     }
 }
 const stripQuotesFromPseudos = new Set(["contains", "icontains"]);
 // Unescape function taken from https://github.com/jquery/sizzle/blob/master/src/sizzle.js#L152
 function funescape(_, escaped, escapedWhitespace) {
-    const high = parseInt(escaped, 16) - 0x10000;
+    const high = Number.parseInt(escaped, 16) - 65536;
     // NaN means non-codepoint
     return high !== high || escapedWhitespace
         ? escaped
         : high < 0
             ? // BMP codepoint
-                String.fromCharCode(high + 0x10000)
+                String.fromCharCode(high + 65536)
             : // Supplemental Plane codepoint (surrogate pair)
-                String.fromCharCode((high >> 10) | 0xd800, (high & 0x3ff) | 0xdc00);
+                String.fromCharCode((high >> 10) | 55296, (high & 1023) | 56320);
 }
-function unescapeCSS(str) {
-    return str.replace(reEscape, funescape);
+function unescapeCSS(cssString) {
+    return cssString.replace(reEscape, funescape);
 }
 function isQuote(c) {
-    return c === 39 /* SingleQuote */ || c === 34 /* DoubleQuote */;
+    return c === CharCode.SingleQuote || c === CharCode.DoubleQuote;
 }
 function isWhitespace(c) {
-    return (c === 32 /* Space */ ||
-        c === 9 /* Tab */ ||
-        c === 10 /* NewLine */ ||
-        c === 12 /* FormFeed */ ||
-        c === 13 /* CarriageReturn */);
+    return (c === CharCode.Space ||
+        c === CharCode.Tab ||
+        c === CharCode.NewLine ||
+        c === CharCode.FormFeed ||
+        c === CharCode.CarriageReturn);
 }
 /**
- * Parses `selector`, optionally with the passed `options`.
+ * Parses `selector`.
  *
  * @param selector Selector to parse.
- * @param options Options for parsing.
  * @returns Returns a two-dimensional array.
  * The first dimension represents selectors separated by commas (eg. `sub1, sub2`),
  * the second contains the relevant tokens for that selector.
@@ -3845,29 +3894,27 @@ function parseSelector(subselects, selector, selectorIndex) {
     function readValueWithParenthesis() {
         selectorIndex += 1;
         const start = selectorIndex;
-        let counter = 1;
-        for (; counter > 0 && selectorIndex < selector.length; selectorIndex++) {
-            if (selector.charCodeAt(selectorIndex) ===
-                40 /* LeftParenthesis */ &&
-                !isEscaped(selectorIndex)) {
-                counter++;
-            }
-            else if (selector.charCodeAt(selectorIndex) ===
-                41 /* RightParenthesis */ &&
-                !isEscaped(selectorIndex)) {
-                counter--;
+        for (let counter = 1; selectorIndex < selector.length; selectorIndex++) {
+            switch (selector.charCodeAt(selectorIndex)) {
+                case CharCode.BackSlash: {
+                    // Skip next character
+                    selectorIndex += 1;
+                    break;
+                }
+                case CharCode.LeftParenthesis: {
+                    counter += 1;
+                    break;
+                }
+                case CharCode.RightParenthesis: {
+                    counter -= 1;
+                    if (counter === 0) {
+                        return unescapeCSS(selector.slice(start, selectorIndex++));
+                    }
+                    break;
+                }
             }
         }
-        if (counter) {
-            throw new Error("Parenthesis not matched");
-        }
-        return unescapeCSS(selector.slice(start, selectorIndex - 1));
-    }
-    function isEscaped(pos) {
-        let slashCount = 0;
-        while (selector.charCodeAt(--pos) === 92 /* BackSlash */)
-            slashCount++;
-        return (slashCount & 1) === 1;
+        throw new Error("Parenthesis not matched");
     }
     function ensureNotTraversal() {
         if (tokens.length > 0 && isTraversal$1(tokens[tokens.length - 1])) {
@@ -3901,7 +3948,7 @@ function parseSelector(subselects, selector, selectorIndex) {
      * picked up from here.
      */
     function finalizeSubselector() {
-        if (tokens.length &&
+        if (tokens.length > 0 &&
             tokens[tokens.length - 1].type === SelectorType.Descendant) {
             tokens.pop();
         }
@@ -3918,11 +3965,11 @@ function parseSelector(subselects, selector, selectorIndex) {
         const firstChar = selector.charCodeAt(selectorIndex);
         switch (firstChar) {
             // Whitespace
-            case 32 /* Space */:
-            case 9 /* Tab */:
-            case 10 /* NewLine */:
-            case 12 /* FormFeed */:
-            case 13 /* CarriageReturn */: {
+            case CharCode.Space:
+            case CharCode.Tab:
+            case CharCode.NewLine:
+            case CharCode.FormFeed:
+            case CharCode.CarriageReturn: {
                 if (tokens.length === 0 ||
                     tokens[0].type !== SelectorType.Descendant) {
                     ensureNotTraversal();
@@ -3932,41 +3979,41 @@ function parseSelector(subselects, selector, selectorIndex) {
                 break;
             }
             // Traversals
-            case 62 /* GreaterThan */: {
+            case CharCode.GreaterThan: {
                 addTraversal(SelectorType.Child);
                 stripWhitespace(1);
                 break;
             }
-            case 60 /* LessThan */: {
+            case CharCode.LessThan: {
                 addTraversal(SelectorType.Parent);
                 stripWhitespace(1);
                 break;
             }
-            case 126 /* Tilde */: {
+            case CharCode.Tilde: {
                 addTraversal(SelectorType.Sibling);
                 stripWhitespace(1);
                 break;
             }
-            case 43 /* Plus */: {
+            case CharCode.Plus: {
                 addTraversal(SelectorType.Adjacent);
                 stripWhitespace(1);
                 break;
             }
             // Special attribute selectors: .class, #id
-            case 46 /* Period */: {
+            case CharCode.Period: {
                 addSpecialAttribute("class", AttributeAction.Element);
                 break;
             }
-            case 35 /* Hash */: {
+            case CharCode.Hash: {
                 addSpecialAttribute("id", AttributeAction.Equals);
                 break;
             }
-            case 91 /* LeftSquareBracket */: {
+            case CharCode.LeftSquareBracket: {
                 stripWhitespace(1);
                 // Determine attribute name and namespace
                 let name;
                 let namespace = null;
-                if (selector.charCodeAt(selectorIndex) === 124 /* Pipe */) {
+                if (selector.charCodeAt(selectorIndex) === CharCode.Pipe) {
                     // Equivalent to no namespace
                     name = getName(1);
                 }
@@ -3976,9 +4023,9 @@ function parseSelector(subselects, selector, selectorIndex) {
                 }
                 else {
                     name = getName(0);
-                    if (selector.charCodeAt(selectorIndex) === 124 /* Pipe */ &&
+                    if (selector.charCodeAt(selectorIndex) === CharCode.Pipe &&
                         selector.charCodeAt(selectorIndex + 1) !==
-                            61 /* Equal */) {
+                            CharCode.Equal) {
                         namespace = name;
                         name = getName(1);
                     }
@@ -3990,12 +4037,12 @@ function parseSelector(subselects, selector, selectorIndex) {
                 if (possibleAction) {
                     action = possibleAction;
                     if (selector.charCodeAt(selectorIndex + 1) !==
-                        61 /* Equal */) {
+                        CharCode.Equal) {
                         throw new Error("Expected `=`");
                     }
                     stripWhitespace(2);
                 }
-                else if (selector.charCodeAt(selectorIndex) === 61 /* Equal */) {
+                else if (selector.charCodeAt(selectorIndex) === CharCode.Equal) {
                     action = AttributeAction.Equals;
                     stripWhitespace(1);
                 }
@@ -4005,44 +4052,56 @@ function parseSelector(subselects, selector, selectorIndex) {
                 if (action !== "exists") {
                     if (isQuote(selector.charCodeAt(selectorIndex))) {
                         const quote = selector.charCodeAt(selectorIndex);
-                        let sectionEnd = selectorIndex + 1;
-                        while (sectionEnd < selector.length &&
-                            (selector.charCodeAt(sectionEnd) !== quote ||
-                                isEscaped(sectionEnd))) {
-                            sectionEnd += 1;
+                        selectorIndex += 1;
+                        const sectionStart = selectorIndex;
+                        while (selectorIndex < selector.length &&
+                            selector.charCodeAt(selectorIndex) !== quote) {
+                            selectorIndex +=
+                                // Skip next character if it is escaped
+                                selector.charCodeAt(selectorIndex) ===
+                                    CharCode.BackSlash
+                                    ? 2
+                                    : 1;
                         }
-                        if (selector.charCodeAt(sectionEnd) !== quote) {
+                        if (selector.charCodeAt(selectorIndex) !== quote) {
                             throw new Error("Attribute value didn't end");
                         }
-                        value = unescapeCSS(selector.slice(selectorIndex + 1, sectionEnd));
-                        selectorIndex = sectionEnd + 1;
+                        value = unescapeCSS(selector.slice(sectionStart, selectorIndex));
+                        selectorIndex += 1;
                     }
                     else {
                         const valueStart = selectorIndex;
                         while (selectorIndex < selector.length &&
-                            ((!isWhitespace(selector.charCodeAt(selectorIndex)) &&
-                                selector.charCodeAt(selectorIndex) !==
-                                    93 /* RightSquareBracket */) ||
-                                isEscaped(selectorIndex))) {
-                            selectorIndex += 1;
+                            !isWhitespace(selector.charCodeAt(selectorIndex)) &&
+                            selector.charCodeAt(selectorIndex) !==
+                                CharCode.RightSquareBracket) {
+                            selectorIndex +=
+                                // Skip next character if it is escaped
+                                selector.charCodeAt(selectorIndex) ===
+                                    CharCode.BackSlash
+                                    ? 2
+                                    : 1;
                         }
                         value = unescapeCSS(selector.slice(valueStart, selectorIndex));
                     }
                     stripWhitespace(0);
                     // See if we have a force ignore flag
-                    const forceIgnore = selector.charCodeAt(selectorIndex) | 0x20;
-                    // If the forceIgnore flag is set (either `i` or `s`), use that value
-                    if (forceIgnore === 115 /* LowerS */) {
-                        ignoreCase = false;
-                        stripWhitespace(1);
-                    }
-                    else if (forceIgnore === 105 /* LowerI */) {
-                        ignoreCase = true;
-                        stripWhitespace(1);
+                    switch (selector.charCodeAt(selectorIndex) | 0x20) {
+                        // If the forceIgnore flag is set (either `i` or `s`), use that value
+                        case CharCode.LowerI: {
+                            ignoreCase = true;
+                            stripWhitespace(1);
+                            break;
+                        }
+                        case CharCode.LowerS: {
+                            ignoreCase = false;
+                            stripWhitespace(1);
+                            break;
+                        }
                     }
                 }
                 if (selector.charCodeAt(selectorIndex) !==
-                    93 /* RightSquareBracket */) {
+                    CharCode.RightSquareBracket) {
                     throw new Error("Attribute selector didn't terminate");
                 }
                 selectorIndex += 1;
@@ -4057,22 +4116,30 @@ function parseSelector(subselects, selector, selectorIndex) {
                 tokens.push(attributeSelector);
                 break;
             }
-            case 58 /* Colon */: {
-                if (selector.charCodeAt(selectorIndex + 1) === 58 /* Colon */) {
+            case CharCode.Colon: {
+                if (selector.charCodeAt(selectorIndex + 1) === CharCode.Colon) {
                     tokens.push({
                         type: SelectorType.PseudoElement,
                         name: getName(2).toLowerCase(),
                         data: selector.charCodeAt(selectorIndex) ===
-                            40 /* LeftParenthesis */
+                            CharCode.LeftParenthesis
                             ? readValueWithParenthesis()
                             : null,
                     });
-                    continue;
+                    break;
                 }
                 const name = getName(1).toLowerCase();
+                if (pseudosToPseudoElements.has(name)) {
+                    tokens.push({
+                        type: SelectorType.PseudoElement,
+                        name,
+                        data: null,
+                    });
+                    break;
+                }
                 let data = null;
                 if (selector.charCodeAt(selectorIndex) ===
-                    40 /* LeftParenthesis */) {
+                    CharCode.LeftParenthesis) {
                     if (unpackPseudos.has(name)) {
                         if (isQuote(selector.charCodeAt(selectorIndex + 1))) {
                             throw new Error(`Pseudo-selector ${name} cannot be quoted`);
@@ -4080,7 +4147,7 @@ function parseSelector(subselects, selector, selectorIndex) {
                         data = [];
                         selectorIndex = parseSelector(data, selector, selectorIndex + 1);
                         if (selector.charCodeAt(selectorIndex) !==
-                            41 /* RightParenthesis */) {
+                            CharCode.RightParenthesis) {
                             throw new Error(`Missing closing parenthesis in :${name} (${selector})`);
                         }
                         selectorIndex += 1;
@@ -4100,7 +4167,7 @@ function parseSelector(subselects, selector, selectorIndex) {
                 tokens.push({ type: SelectorType.Pseudo, name, data });
                 break;
             }
-            case 44 /* Comma */: {
+            case CharCode.Comma: {
                 finalizeSubselector();
                 tokens = [];
                 stripWhitespace(1);
@@ -4121,13 +4188,13 @@ function parseSelector(subselects, selector, selectorIndex) {
                 }
                 let namespace = null;
                 let name;
-                if (firstChar === 42 /* Asterisk */) {
+                if (firstChar === CharCode.Asterisk) {
                     selectorIndex += 1;
                     name = "*";
                 }
-                else if (firstChar === 124 /* Pipe */) {
+                else if (firstChar === CharCode.Pipe) {
                     name = "";
-                    if (selector.charCodeAt(selectorIndex + 1) === 124 /* Pipe */) {
+                    if (selector.charCodeAt(selectorIndex + 1) === CharCode.Pipe) {
                         addTraversal(SelectorType.ColumnCombinator);
                         stripWhitespace(2);
                         break;
@@ -4139,11 +4206,11 @@ function parseSelector(subselects, selector, selectorIndex) {
                 else {
                     break loop;
                 }
-                if (selector.charCodeAt(selectorIndex) === 124 /* Pipe */ &&
-                    selector.charCodeAt(selectorIndex + 1) !== 124 /* Pipe */) {
+                if (selector.charCodeAt(selectorIndex) === CharCode.Pipe &&
+                    selector.charCodeAt(selectorIndex + 1) !== CharCode.Pipe) {
                     namespace = name;
                     if (selector.charCodeAt(selectorIndex + 1) ===
-                        42 /* Asterisk */) {
+                        CharCode.Asterisk) {
                         name = "*";
                         selectorIndex += 2;
                     }
@@ -4161,84 +4228,6 @@ function parseSelector(subselects, selector, selectorIndex) {
     return selectorIndex;
 }
 
-const procedure = new Map([
-    [SelectorType.Universal, 50],
-    [SelectorType.Tag, 30],
-    [SelectorType.Attribute, 1],
-    [SelectorType.Pseudo, 0],
-]);
-function isTraversal(token) {
-    return !procedure.has(token.type);
-}
-const attributes = new Map([
-    [AttributeAction.Exists, 10],
-    [AttributeAction.Equals, 8],
-    [AttributeAction.Not, 7],
-    [AttributeAction.Start, 6],
-    [AttributeAction.End, 6],
-    [AttributeAction.Any, 5],
-]);
-/**
- * Sort the parts of the passed selector,
- * as there is potential for optimization
- * (some types of selectors are faster than others)
- *
- * @param arr Selector to sort
- */
-function sortByProcedure(arr) {
-    const procs = arr.map(getProcedure);
-    for (let i = 1; i < arr.length; i++) {
-        const procNew = procs[i];
-        if (procNew < 0)
-            continue;
-        for (let j = i - 1; j >= 0 && procNew < procs[j]; j--) {
-            const token = arr[j + 1];
-            arr[j + 1] = arr[j];
-            arr[j] = token;
-            procs[j + 1] = procs[j];
-            procs[j] = procNew;
-        }
-    }
-}
-function getProcedure(token) {
-    var _a, _b;
-    let proc = (_a = procedure.get(token.type)) !== null && _a !== void 0 ? _a : -1;
-    if (token.type === SelectorType.Attribute) {
-        proc = (_b = attributes.get(token.action)) !== null && _b !== void 0 ? _b : 4;
-        if (token.action === AttributeAction.Equals && token.name === "id") {
-            // Prefer ID selectors (eg. #ID)
-            proc = 9;
-        }
-        if (token.ignoreCase) {
-            /*
-             * IgnoreCase adds some overhead, prefer "normal" token
-             * this is a binary operation, to ensure it's still an int
-             */
-            proc >>= 1;
-        }
-    }
-    else if (token.type === SelectorType.Pseudo) {
-        if (!token.data) {
-            proc = 3;
-        }
-        else if (token.name === "has" || token.name === "contains") {
-            proc = 0; // Expensive in any case
-        }
-        else if (Array.isArray(token.data)) {
-            // Eg. :matches, :not
-            proc = Math.min(...token.data.map((d) => Math.min(...d.map(getProcedure))));
-            // If we have traversals, try to avoid executing this selector
-            if (proc < 0) {
-                proc = 0;
-            }
-        }
-        else {
-            proc = 2;
-        }
-    }
-    return proc;
-}
-
 /**
  * All reserved characters in a regex, used for escaping.
  *
@@ -4357,7 +4346,7 @@ const attributeRules = {
         const { adapter } = options;
         const { name, value } = data;
         if (/\s/.test(value)) {
-            return boolbase.falseFunc;
+            return boolbaseExports.falseFunc;
         }
         const regex = new RegExp(`(?:^|\\s)${escapeRegex(value)}(?:$|\\s)`, shouldIgnoreCase(data, options) ? "i" : "");
         return function element(elem) {
@@ -4377,7 +4366,7 @@ const attributeRules = {
         let { value } = data;
         const len = value.length;
         if (len === 0) {
-            return boolbase.falseFunc;
+            return boolbaseExports.falseFunc;
         }
         if (shouldIgnoreCase(data, options)) {
             value = value.toLowerCase();
@@ -4389,11 +4378,8 @@ const attributeRules = {
                     next(elem));
             };
         }
-        return (elem) => {
-            var _a;
-            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.startsWith(value)) &&
-                next(elem);
-        };
+        return (elem) => !!adapter.getAttributeValue(elem, name)?.startsWith(value) &&
+            next(elem);
     },
     end(next, data, options) {
         const { adapter } = options;
@@ -4401,27 +4387,23 @@ const attributeRules = {
         let { value } = data;
         const len = -value.length;
         if (len === 0) {
-            return boolbase.falseFunc;
+            return boolbaseExports.falseFunc;
         }
         if (shouldIgnoreCase(data, options)) {
             value = value.toLowerCase();
-            return (elem) => {
-                var _a;
-                return ((_a = adapter
-                    .getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.substr(len).toLowerCase()) === value && next(elem);
-            };
+            return (elem) => adapter
+                .getAttributeValue(elem, name)
+                ?.substr(len)
+                .toLowerCase() === value && next(elem);
         }
-        return (elem) => {
-            var _a;
-            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.endsWith(value)) &&
-                next(elem);
-        };
+        return (elem) => !!adapter.getAttributeValue(elem, name)?.endsWith(value) &&
+            next(elem);
     },
     any(next, data, options) {
         const { adapter } = options;
         const { name, value } = data;
         if (value === "") {
-            return boolbase.falseFunc;
+            return boolbaseExports.falseFunc;
         }
         if (shouldIgnoreCase(data, options)) {
             const regex = new RegExp(escapeRegex(value), "i");
@@ -4433,11 +4415,8 @@ const attributeRules = {
                     next(elem));
             };
         }
-        return (elem) => {
-            var _a;
-            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.includes(value)) &&
-                next(elem);
-        };
+        return (elem) => !!adapter.getAttributeValue(elem, name)?.includes(value) &&
+            next(elem);
     },
     not(next, data, options) {
         const { adapter } = options;
@@ -4446,7 +4425,7 @@ const attributeRules = {
         if (value === "") {
             return (elem) => !!adapter.getAttributeValue(elem, name) && next(elem);
         }
-        else if (shouldIgnoreCase(data, options)) {
+        if (shouldIgnoreCase(data, options)) {
             value = value.toLowerCase();
             return (elem) => {
                 const attr = adapter.getAttributeValue(elem, name);
@@ -4460,6 +4439,169 @@ const attributeRules = {
     },
 };
 
+/**
+ * Find all elements matching the query. If not in XML mode, the query will ignore
+ * the contents of `<template>` elements.
+ *
+ * @param query - Function that returns true if the element matches the query.
+ * @param elems - Nodes to query. If a node is an element, its children will be queried.
+ * @param options - Options for querying the document.
+ * @returns All matching elements.
+ */
+function findAll(query, elems, options) {
+    const { adapter, xmlMode = false } = options;
+    const result = [];
+    /** Stack of the arrays we are looking at. */
+    const nodeStack = [elems];
+    /** Stack of the indices within the arrays. */
+    const indexStack = [0];
+    for (;;) {
+        // First, check if the current array has any more elements to look at.
+        if (indexStack[0] >= nodeStack[0].length) {
+            // If we have no more arrays to look at, we are done.
+            if (nodeStack.length === 1) {
+                return result;
+            }
+            nodeStack.shift();
+            indexStack.shift();
+            // Loop back to the start to continue with the next array.
+            continue;
+        }
+        const elem = nodeStack[0][indexStack[0]++];
+        if (!adapter.isTag(elem)) {
+            continue;
+        }
+        if (query(elem)) {
+            result.push(elem);
+        }
+        if (xmlMode || adapter.getName(elem) !== "template") {
+            /*
+             * Add the children to the stack. We are depth-first, so this is
+             * the next array we look at.
+             */
+            const children = adapter.getChildren(elem);
+            if (children.length > 0) {
+                nodeStack.unshift(children);
+                indexStack.unshift(0);
+            }
+        }
+    }
+}
+/**
+ * Find the first element matching the query. If not in XML mode, the query will ignore
+ * the contents of `<template>` elements.
+ *
+ * @param query - Function that returns true if the element matches the query.
+ * @param elems - Nodes to query. If a node is an element, its children will be queried.
+ * @param options - Options for querying the document.
+ * @returns The first matching element, or null if there was no match.
+ */
+function findOne(query, elems, options) {
+    const { adapter, xmlMode = false } = options;
+    /** Stack of the arrays we are looking at. */
+    const nodeStack = [elems];
+    /** Stack of the indices within the arrays. */
+    const indexStack = [0];
+    for (;;) {
+        // First, check if the current array has any more elements to look at.
+        if (indexStack[0] >= nodeStack[0].length) {
+            // If we have no more arrays to look at, we are done.
+            if (nodeStack.length === 1) {
+                return null;
+            }
+            nodeStack.shift();
+            indexStack.shift();
+            // Loop back to the start to continue with the next array.
+            continue;
+        }
+        const elem = nodeStack[0][indexStack[0]++];
+        if (!adapter.isTag(elem)) {
+            continue;
+        }
+        if (query(elem)) {
+            return elem;
+        }
+        if (xmlMode || adapter.getName(elem) !== "template") {
+            /*
+             * Add the children to the stack. We are depth-first, so this is
+             * the next array we look at.
+             */
+            const children = adapter.getChildren(elem);
+            if (children.length > 0) {
+                nodeStack.unshift(children);
+                indexStack.unshift(0);
+            }
+        }
+    }
+}
+function getNextSiblings(elem, adapter) {
+    const siblings = adapter.getSiblings(elem);
+    if (siblings.length <= 1) {
+        return [];
+    }
+    const elemIndex = siblings.indexOf(elem);
+    if (elemIndex < 0 || elemIndex === siblings.length - 1) {
+        return [];
+    }
+    return siblings.slice(elemIndex + 1).filter(adapter.isTag);
+}
+function getElementParent(node, adapter) {
+    const parent = adapter.getParent(node);
+    return parent != null && adapter.isTag(parent) ? parent : null;
+}
+
+/**
+ * Only text controls can be made read-only, since for other controls (such
+ * as checkboxes and buttons) there is no useful distinction between being
+ * read-only and being disabled.
+ *
+ * @see {@link https://html.spec.whatwg.org/multipage/input.html#attr-input-readonly}
+ */
+const textControl = "input:is([type=text i],[type=search i],[type=url i],[type=tel i],[type=email i],[type=password i],[type=date i],[type=month i],[type=week i],[type=time i],[type=datetime-local i],[type=number i])";
+/**
+ * Aliases are pseudos that are expressed as selectors.
+ */
+const aliases = {
+    // Links
+    "any-link": ":is(a, area, link)[href]",
+    link: ":any-link:not(:visited)",
+    // Forms
+    // https://html.spec.whatwg.org/multipage/scripting.html#disabled-elements
+    disabled: `:is(
+        :is(button, input, select, textarea, optgroup, option)[disabled],
+        optgroup[disabled] > option,
+        fieldset[disabled]:not(fieldset[disabled] legend:first-of-type *)
+    )`,
+    enabled: ":not(:disabled)",
+    checked: ":is(:is(input[type=radio], input[type=checkbox])[checked], :selected)",
+    required: ":is(input, select, textarea)[required]",
+    optional: ":is(input, select, textarea):not([required])",
+    "read-only": `[readonly]:is(textarea, ${textControl})`,
+    "read-write": `:not([readonly]):is(textarea, ${textControl})`,
+    // JQuery extensions
+    /**
+     * `:selected` matches option elements that have the `selected` attribute,
+     * or are the first option element in a select element that does not have
+     * the `multiple` attribute and does not have any option elements with the
+     * `selected` attribute.
+     *
+     * @see https://html.spec.whatwg.org/multipage/form-elements.html#concept-option-selectedness
+     */
+    selected: "option:is([selected], select:not([multiple]):not(:has(> option[selected])) > :first-of-type)",
+    checkbox: "[type=checkbox]",
+    file: "[type=file]",
+    password: "[type=password]",
+    radio: "[type=radio]",
+    reset: "[type=reset]",
+    image: "[type=image]",
+    submit: "[type=submit]",
+    parent: ":not(:empty)",
+    header: ":is(h1, h2, h3, h4, h5, h6)",
+    button: ":is(button, input[type=button])",
+    input: ":is(input, textarea, select, button)",
+    text: "input:is(:not([type!='']), [type=text])",
+};
+
 // Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
 // Whitespace as per https://www.w3.org/TR/selectors-3/#lex is " \t\r\n\f"
 const whitespace = new Set([9, 10, 12, 13, 32]);
@@ -4614,38 +4756,73 @@ function nthCheck(formula) {
     return compile(parse(formula));
 }
 
-function getChildFunc(next, adapter) {
-    return (elem) => {
-        const parent = adapter.getParent(elem);
-        return parent != null && adapter.isTag(parent) && next(elem);
+/**
+ * Some selectors such as `:contains` and (non-relative) `:has` will only be
+ * able to match elements if their parents match the selector (as they contain
+ * a subset of the elements that the parent contains).
+ *
+ * This function wraps the given `matches` function in a function that caches
+ * the results of the parent elements, so that the `matches` function only
+ * needs to be called once for each subtree.
+ */
+function cacheParentResults(next, { adapter, cacheResults }, matches) {
+    if (cacheResults === false || typeof WeakMap === "undefined") {
+        return (elem) => next(elem) && matches(elem);
+    }
+    // Use a cache to avoid re-checking children of an element.
+    // @ts-expect-error `Node` is not extending object
+    const resultCache = new WeakMap();
+    function addResultToCache(elem) {
+        const result = matches(elem);
+        resultCache.set(elem, result);
+        return result;
+    }
+    return function cachedMatcher(elem) {
+        if (!next(elem)) {
+            return false;
+        }
+        if (resultCache.has(elem)) {
+            return resultCache.get(elem);
+        }
+        // Check all of the element's parents.
+        let node = elem;
+        do {
+            const parent = getElementParent(node, adapter);
+            if (parent === null) {
+                return addResultToCache(elem);
+            }
+            node = parent;
+        } while (!resultCache.has(node));
+        return resultCache.get(node) && addResultToCache(elem);
     };
 }
+
 const filters = {
-    contains(next, text, { adapter }) {
-        return function contains(elem) {
-            return next(elem) && adapter.getText(elem).includes(text);
-        };
+    contains(next, text, options) {
+        const { getText } = options.adapter;
+        return cacheParentResults(next, options, (elem) => getText(elem).includes(text));
     },
-    icontains(next, text, { adapter }) {
+    icontains(next, text, options) {
         const itext = text.toLowerCase();
-        return function icontains(elem) {
-            return (next(elem) &&
-                adapter.getText(elem).toLowerCase().includes(itext));
-        };
+        const { getText } = options.adapter;
+        return cacheParentResults(next, options, (elem) => getText(elem).toLowerCase().includes(itext));
     },
     // Location specific methods
     "nth-child"(next, rule, { adapter, equals }) {
         const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
+        if (func === boolbaseExports.falseFunc) {
+            return boolbaseExports.falseFunc;
+        }
+        if (func === boolbaseExports.trueFunc) {
+            return (elem) => getElementParent(elem, adapter) !== null && next(elem);
+        }
         return function nthChild(elem) {
             const siblings = adapter.getSiblings(elem);
             let pos = 0;
             for (let i = 0; i < siblings.length; i++) {
-                if (equals(elem, siblings[i]))
+                if (equals(elem, siblings[i])) {
                     break;
+                }
                 if (adapter.isTag(siblings[i])) {
                     pos++;
                 }
@@ -4655,16 +4832,19 @@ const filters = {
     },
     "nth-last-child"(next, rule, { adapter, equals }) {
         const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
+        if (func === boolbaseExports.falseFunc) {
+            return boolbaseExports.falseFunc;
+        }
+        if (func === boolbaseExports.trueFunc) {
+            return (elem) => getElementParent(elem, adapter) !== null && next(elem);
+        }
         return function nthLastChild(elem) {
             const siblings = adapter.getSiblings(elem);
             let pos = 0;
             for (let i = siblings.length - 1; i >= 0; i--) {
-                if (equals(elem, siblings[i]))
+                if (equals(elem, siblings[i])) {
                     break;
+                }
                 if (adapter.isTag(siblings[i])) {
                     pos++;
                 }
@@ -4674,17 +4854,20 @@ const filters = {
     },
     "nth-of-type"(next, rule, { adapter, equals }) {
         const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
+        if (func === boolbaseExports.falseFunc) {
+            return boolbaseExports.falseFunc;
+        }
+        if (func === boolbaseExports.trueFunc) {
+            return (elem) => getElementParent(elem, adapter) !== null && next(elem);
+        }
         return function nthOfType(elem) {
             const siblings = adapter.getSiblings(elem);
             let pos = 0;
             for (let i = 0; i < siblings.length; i++) {
                 const currentSibling = siblings[i];
-                if (equals(elem, currentSibling))
+                if (equals(elem, currentSibling)) {
                     break;
+                }
                 if (adapter.isTag(currentSibling) &&
                     adapter.getName(currentSibling) === adapter.getName(elem)) {
                     pos++;
@@ -4695,17 +4878,20 @@ const filters = {
     },
     "nth-last-of-type"(next, rule, { adapter, equals }) {
         const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
+        if (func === boolbaseExports.falseFunc) {
+            return boolbaseExports.falseFunc;
+        }
+        if (func === boolbaseExports.trueFunc) {
+            return (elem) => getElementParent(elem, adapter) !== null && next(elem);
+        }
         return function nthLastOfType(elem) {
             const siblings = adapter.getSiblings(elem);
             let pos = 0;
             for (let i = siblings.length - 1; i >= 0; i--) {
                 const currentSibling = siblings[i];
-                if (equals(elem, currentSibling))
+                if (equals(elem, currentSibling)) {
                     break;
+                }
                 if (adapter.isTag(currentSibling) &&
                     adapter.getName(currentSibling) === adapter.getName(elem)) {
                     pos++;
@@ -4716,10 +4902,7 @@ const filters = {
     },
     // TODO determine the actual root element
     root(next, _rule, { adapter }) {
-        return (elem) => {
-            const parent = adapter.getParent(elem);
-            return (parent == null || !adapter.isTag(parent)) && next(elem);
-        };
+        return (elem) => getElementParent(elem, adapter) === null && next(elem);
     },
     scope(next, rule, options, context) {
         const { equals } = options;
@@ -4747,7 +4930,7 @@ function dynamicStatePseudo(name) {
     return function dynamicPseudo(next, _rule, { adapter }) {
         const func = adapter[name];
         if (typeof func !== "function") {
-            return boolbase.falseFunc;
+            return boolbaseExports.falseFunc;
         }
         return function active(elem) {
             return func(elem) && next(elem);
@@ -4755,12 +4938,25 @@ function dynamicStatePseudo(name) {
     };
 }
 
+/**
+ * CSS limits the characters considered as whitespace to space, tab & line
+ * feed. We add carriage returns as htmlparser2 doesn't normalize them to
+ * line feeds.
+ *
+ * @see {@link https://www.w3.org/TR/css-text-3/#white-space}
+ */
+const isDocumentWhiteSpace = /^[ \t\r\n]*$/;
 // While filters are precompiled, pseudos get called when they are needed
 const pseudos = {
     empty(elem, { adapter }) {
-        return !adapter.getChildren(elem).some((elem) => 
-        // FIXME: `getText` call is potentially expensive.
-        adapter.isTag(elem) || adapter.getText(elem) !== "");
+        const children = adapter.getChildren(elem);
+        return (
+        // First, make sure the tag does not have any element children.
+        children.every((elem) => !adapter.isTag(elem)) &&
+            // Then, check that the text content is only whitespace.
+            children.every((elem) => 
+            // FIXME: `getText` call is potentially expensive.
+            isDocumentWhiteSpace.test(adapter.getText(elem))));
     },
     "first-child"(elem, { adapter, equals }) {
         if (adapter.prevElementSibling) {
@@ -4774,10 +4970,12 @@ const pseudos = {
     "last-child"(elem, { adapter, equals }) {
         const siblings = adapter.getSiblings(elem);
         for (let i = siblings.length - 1; i >= 0; i--) {
-            if (equals(elem, siblings[i]))
+            if (equals(elem, siblings[i])) {
                 return true;
-            if (adapter.isTag(siblings[i]))
+            }
+            if (adapter.isTag(siblings[i])) {
                 break;
+            }
         }
         return false;
     },
@@ -4786,8 +4984,9 @@ const pseudos = {
         const elemName = adapter.getName(elem);
         for (let i = 0; i < siblings.length; i++) {
             const currentSibling = siblings[i];
-            if (equals(elem, currentSibling))
+            if (equals(elem, currentSibling)) {
                 return true;
+            }
             if (adapter.isTag(currentSibling) &&
                 adapter.getName(currentSibling) === elemName) {
                 break;
@@ -4800,8 +4999,9 @@ const pseudos = {
         const elemName = adapter.getName(elem);
         for (let i = siblings.length - 1; i >= 0; i--) {
             const currentSibling = siblings[i];
-            if (equals(elem, currentSibling))
+            if (equals(elem, currentSibling)) {
                 return true;
+            }
             if (adapter.isTag(currentSibling) &&
                 adapter.getName(currentSibling) === elemName) {
                 break;
@@ -4834,56 +5034,123 @@ function verifyPseudoArgs(func, name, subselect, argIndex) {
     }
 }
 
+function isTraversal(token) {
+    return token.type === "_flexibleDescendant" || isTraversal$1(token);
+}
 /**
- * Aliases are pseudos that are expressed as selectors.
+ * Sort the parts of the passed selector, as there is potential for
+ * optimization (some types of selectors are faster than others).
+ *
+ * @param arr Selector to sort
  */
-const aliases = {
-    // Links
-    "any-link": ":is(a, area, link)[href]",
-    link: ":any-link:not(:visited)",
-    // Forms
-    // https://html.spec.whatwg.org/multipage/scripting.html#disabled-elements
-    disabled: `:is(
-        :is(button, input, select, textarea, optgroup, option)[disabled],
-        optgroup[disabled] > option,
-        fieldset[disabled]:not(fieldset[disabled] legend:first-of-type *)
-    )`,
-    enabled: ":not(:disabled)",
-    checked: ":is(:is(input[type=radio], input[type=checkbox])[checked], option:selected)",
-    required: ":is(input, select, textarea)[required]",
-    optional: ":is(input, select, textarea):not([required])",
-    // JQuery extensions
-    // https://html.spec.whatwg.org/multipage/form-elements.html#concept-option-selectedness
-    selected: "option:is([selected], select:not([multiple]):not(:has(> option[selected])) > :first-of-type)",
-    checkbox: "[type=checkbox]",
-    file: "[type=file]",
-    password: "[type=password]",
-    radio: "[type=radio]",
-    reset: "[type=reset]",
-    image: "[type=image]",
-    submit: "[type=submit]",
-    parent: ":not(:empty)",
-    header: ":is(h1, h2, h3, h4, h5, h6)",
-    button: ":is(button, input[type=button])",
-    input: ":is(input, textarea, select, button)",
-    text: "input:is(:not([type!='']), [type=text])",
-};
-
-/** Used as a placeholder for :has. Will be replaced with the actual element. */
-const PLACEHOLDER_ELEMENT = {};
-function ensureIsTag(next, adapter) {
-    if (next === boolbase.falseFunc)
-        return boolbase.falseFunc;
-    return (elem) => adapter.isTag(elem) && next(elem);
-}
-function getNextSiblings(elem, adapter) {
-    const siblings = adapter.getSiblings(elem);
-    if (siblings.length <= 1)
-        return [];
-    const elemIndex = siblings.indexOf(elem);
-    if (elemIndex < 0 || elemIndex === siblings.length - 1)
-        return [];
-    return siblings.slice(elemIndex + 1).filter(adapter.isTag);
+function sortRules(arr) {
+    const ratings = arr.map(getQuality);
+    for (let i = 1; i < arr.length; i++) {
+        const procNew = ratings[i];
+        if (procNew < 0) {
+            continue;
+        }
+        // Use insertion sort to move the token to the correct position.
+        for (let j = i; j > 0 && procNew < ratings[j - 1]; j--) {
+            const token = arr[j];
+            arr[j] = arr[j - 1];
+            arr[j - 1] = token;
+            ratings[j] = ratings[j - 1];
+            ratings[j - 1] = procNew;
+        }
+    }
+}
+function getAttributeQuality(token) {
+    switch (token.action) {
+        case AttributeAction.Exists: {
+            return 10;
+        }
+        case AttributeAction.Equals: {
+            // Prefer ID selectors (eg. #ID)
+            return token.name === "id" ? 9 : 8;
+        }
+        case AttributeAction.Not: {
+            return 7;
+        }
+        case AttributeAction.Start: {
+            return 6;
+        }
+        case AttributeAction.End: {
+            return 6;
+        }
+        case AttributeAction.Any: {
+            return 5;
+        }
+        case AttributeAction.Hyphen: {
+            return 4;
+        }
+        case AttributeAction.Element: {
+            return 3;
+        }
+    }
+}
+/**
+ * Determine the quality of the passed token. The higher the number, the
+ * faster the token is to execute.
+ *
+ * @param token Token to get the quality of.
+ * @returns The token's quality.
+ */
+function getQuality(token) {
+    switch (token.type) {
+        case SelectorType.Universal: {
+            return 50;
+        }
+        case SelectorType.Tag: {
+            return 30;
+        }
+        case SelectorType.Attribute: {
+            return Math.floor(getAttributeQuality(token) /
+                // `ignoreCase` adds some overhead, half the result if applicable.
+                (token.ignoreCase ? 2 : 1));
+        }
+        case SelectorType.Pseudo: {
+            return !token.data
+                ? 3
+                : token.name === "has" ||
+                    token.name === "contains" ||
+                    token.name === "icontains"
+                    ? // Expensive in any case — run as late as possible.
+                        0
+                    : Array.isArray(token.data)
+                        ? // Eg. `:is`, `:not`
+                            Math.max(
+                            // If we have traversals, try to avoid executing this selector
+                            0, Math.min(...token.data.map((d) => Math.min(...d.map(getQuality)))))
+                        : 2;
+        }
+        default: {
+            return -1;
+        }
+    }
+}
+function includesScopePseudo(t) {
+    return (t.type === SelectorType.Pseudo &&
+        (t.name === "scope" ||
+            (Array.isArray(t.data) &&
+                t.data.some((data) => data.some(includesScopePseudo)))));
+}
+
+/** Used as a placeholder for :has. Will be replaced with the actual element. */
+const PLACEHOLDER_ELEMENT = {};
+/**
+ * Check if the selector has any properties that rely on the current element.
+ * If not, we can cache the result of the selector.
+ *
+ * We can't cache selectors that start with a traversal (e.g. `>`, `+`, `~`),
+ * or include a `:scope`.
+ *
+ * @param selector - The selector to check.
+ * @returns Whether the selector has any properties that rely on the current element.
+ */
+function hasDependsOnCurrentElement(selector) {
+    return selector.some((sel) => sel.length > 0 &&
+        (isTraversal(sel[0]) || sel.some(includesScopePseudo)));
 }
 function copyOptions(options) {
     // Not copied: context, rootFunc
@@ -4900,10 +5167,10 @@ function copyOptions(options) {
 }
 const is = (next, token, options, context, compileToken) => {
     const func = compileToken(token, copyOptions(options), context);
-    return func === boolbase.trueFunc
+    return func === boolbaseExports.trueFunc
         ? next
-        : func === boolbase.falseFunc
-            ? boolbase.falseFunc
+        : func === boolbaseExports.falseFunc
+            ? boolbaseExports.falseFunc
             : (elem) => func(elem) && next(elem);
 };
 /*
@@ -4920,10 +5187,10 @@ const subselects = {
     where: is,
     not(next, token, options, context, compileToken) {
         const func = compileToken(token, copyOptions(options), context);
-        return func === boolbase.falseFunc
+        return func === boolbaseExports.falseFunc
             ? next
-            : func === boolbase.trueFunc
-                ? boolbase.falseFunc
+            : func === boolbaseExports.trueFunc
+                ? boolbaseExports.falseFunc
                 : (elem) => !func(elem) && next(elem);
     },
     has(next, subselect, options, _context, compileToken) {
@@ -4934,35 +5201,54 @@ const subselects = {
             ? // Used as a placeholder. Will be replaced with the actual element.
                 [PLACEHOLDER_ELEMENT]
             : undefined;
+        const skipCache = hasDependsOnCurrentElement(subselect);
         const compiled = compileToken(subselect, opts, context);
-        if (compiled === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        const hasElement = ensureIsTag(compiled, adapter);
+        if (compiled === boolbaseExports.falseFunc) {
+            return boolbaseExports.falseFunc;
+        }
         // If `compiled` is `trueFunc`, we can skip this.
-        if (context && compiled !== boolbase.trueFunc) {
-            /*
-             * `shouldTestNextSiblings` will only be true if the query starts with
-             * a traversal (sibling or adjacent). That means we will always have a context.
-             */
-            const { shouldTestNextSiblings = false } = compiled;
-            return (elem) => {
-                if (!next(elem))
-                    return false;
-                context[0] = elem;
-                const childs = adapter.getChildren(elem);
-                const nextElements = shouldTestNextSiblings
-                    ? [...childs, ...getNextSiblings(elem, adapter)]
-                    : childs;
-                return adapter.existsOne(hasElement, nextElements);
-            };
+        if (context && compiled !== boolbaseExports.trueFunc) {
+            return skipCache
+                ? (elem) => {
+                    if (!next(elem)) {
+                        return false;
+                    }
+                    context[0] = elem;
+                    const childs = adapter.getChildren(elem);
+                    return (findOne(compiled, compiled.shouldTestNextSiblings
+                        ? [
+                            ...childs,
+                            ...getNextSiblings(elem, adapter),
+                        ]
+                        : childs, options) !== null);
+                }
+                : cacheParentResults(next, options, (elem) => {
+                    context[0] = elem;
+                    return (findOne(compiled, adapter.getChildren(elem), options) !== null);
+                });
         }
-        return (elem) => next(elem) &&
-            adapter.existsOne(hasElement, adapter.getChildren(elem));
+        const hasOne = (elem) => findOne(compiled, adapter.getChildren(elem), options) !== null;
+        return skipCache
+            ? (elem) => next(elem) && hasOne(elem)
+            : cacheParentResults(next, options, hasOne);
     },
 };
 
+/*
+ * Pseudo selectors
+ *
+ * Pseudo selectors are available in three forms:
+ *
+ * 1. Filters are called when the selector is compiled and return a function
+ *  that has to return either false, or the results of `next()`.
+ * 2. Pseudos are called on execution. They have to return a boolean.
+ * 3. Subselects work like filters, but have an embedded selector that will be run separately.
+ *
+ * Filters are great if you want to do some pre-processing, or change the call order
+ * of `next()` and your code.
+ * Pseudos should be used to implement simple checks.
+ */
 function compilePseudoSelector(next, selector, options, context, compileToken) {
-    var _a;
     const { name, data } = selector;
     if (Array.isArray(data)) {
         if (!(name in subselects)) {
@@ -4970,7 +5256,7 @@ function compilePseudoSelector(next, selector, options, context, compileToken) {
         }
         return subselects[name](next, data, options, context, compileToken);
     }
-    const userPseudo = (_a = options.pseudos) === null || _a === void 0 ? void 0 : _a[name];
+    const userPseudo = options.pseudos?.[name];
     const stringPseudo = typeof userPseudo === "string" ? userPseudo : aliases[name];
     if (typeof stringPseudo === "string") {
         if (data != null) {
@@ -4995,18 +5281,11 @@ function compilePseudoSelector(next, selector, options, context, compileToken) {
     throw new Error(`Unknown pseudo-class :${name}`);
 }
 
-function getElementParent(node, adapter) {
-    const parent = adapter.getParent(node);
-    if (parent && adapter.isTag(parent)) {
-        return parent;
-    }
-    return null;
-}
 /*
  * All available rules
  */
-function compileGeneralSelector(next, selector, options, context, compileToken) {
-    const { adapter, equals } = options;
+function compileGeneralSelector(next, selector, options, context, compileToken, hasExpensiveSubselector) {
+    const { adapter, equals, cacheResults } = options;
     switch (selector.type) {
         case SelectorType.PseudoElement: {
             throw new Error("Pseudo-elements are not supported by css-select");
@@ -5041,10 +5320,12 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
         }
         // Traversal
         case SelectorType.Descendant: {
-            if (options.cacheResults === false ||
-                typeof WeakSet === "undefined") {
+            if (!hasExpensiveSubselector ||
+                cacheResults === false ||
+                typeof WeakMap === "undefined") {
                 return function descendant(elem) {
                     let current = elem;
+                    // biome-ignore lint/suspicious/noAssignInExpressions: TODO
                     while ((current = getElementParent(current, adapter))) {
                         if (next(current)) {
                             return true;
@@ -5053,16 +5334,26 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
                     return false;
                 };
             }
-            // @ts-expect-error `ElementNode` is not extending object
-            const isFalseCache = new WeakSet();
+            const resultCache = new WeakMap();
             return function cachedDescendant(elem) {
                 let current = elem;
+                let result;
+                // biome-ignore lint/suspicious/noAssignInExpressions: TODO
                 while ((current = getElementParent(current, adapter))) {
-                    if (!isFalseCache.has(current)) {
-                        if (adapter.isTag(current) && next(current)) {
+                    const cached = resultCache.get(current);
+                    if (cached === undefined) {
+                        result ?? (result = { matches: false });
+                        result.matches = next(current);
+                        resultCache.set(current, result);
+                        if (result.matches) {
                             return true;
                         }
-                        isFalseCache.add(current);
+                    }
+                    else {
+                        if (result) {
+                            result.matches = cached.matches;
+                        }
+                        return cached.matches;
                     }
                 }
                 return false;
@@ -5073,9 +5364,11 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
             return function flexibleDescendant(elem) {
                 let current = elem;
                 do {
-                    if (next(current))
+                    if (next(current)) {
                         return true;
-                } while ((current = getElementParent(current, adapter)));
+                    }
+                    current = getElementParent(current, adapter);
+                } while (current);
                 return false;
             };
         }
@@ -5088,8 +5381,8 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
         }
         case SelectorType.Child: {
             return function child(elem) {
-                const parent = adapter.getParent(elem);
-                return parent != null && adapter.isTag(parent) && next(parent);
+                const parent = getElementParent(elem, adapter);
+                return parent !== null && next(parent);
             };
         }
         case SelectorType.Sibling: {
@@ -5097,8 +5390,9 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
                 const siblings = adapter.getSiblings(elem);
                 for (let i = 0; i < siblings.length; i++) {
                     const currentSibling = siblings[i];
-                    if (equals(elem, currentSibling))
+                    if (equals(elem, currentSibling)) {
                         break;
+                    }
                     if (adapter.isTag(currentSibling) && next(currentSibling)) {
                         return true;
                     }
@@ -5118,8 +5412,9 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
                 let lastElement;
                 for (let i = 0; i < siblings.length; i++) {
                     const currentSibling = siblings[i];
-                    if (equals(elem, currentSibling))
+                    if (equals(elem, currentSibling)) {
                         break;
+                    }
                     if (adapter.isTag(currentSibling)) {
                         lastElement = currentSibling;
                     }
@@ -5136,16 +5431,6 @@ function compileGeneralSelector(next, selector, options, context, compileToken)
     }
 }
 
-function compileUnsafe(selector, options, context) {
-    const token = typeof selector === "string" ? parse$1(selector) : selector;
-    return compileToken(token, options, context);
-}
-function includesScopePseudo(t) {
-    return (t.type === SelectorType.Pseudo &&
-        (t.name === "scope" ||
-            (Array.isArray(t.data) &&
-                t.data.some((data) => data.some(includesScopePseudo)))));
-}
 const DESCENDANT_TOKEN = { type: SelectorType.Descendant };
 const FLEXIBLE_DESCENDANT_TOKEN = {
     type: "_flexibleDescendant",
@@ -5161,10 +5446,8 @@ const SCOPE_TOKEN = {
  */
 function absolutize(token, { adapter }, context) {
     // TODO Use better check if the context is a document
-    const hasContext = !!(context === null || context === void 0 ? void 0 : context.every((e) => {
-        const parent = adapter.isTag(e) && adapter.getParent(e);
-        return e === PLACEHOLDER_ELEMENT || (parent && adapter.isTag(parent));
-    }));
+    const hasContext = !!context?.every((e) => e === PLACEHOLDER_ELEMENT ||
+        (adapter.isTag(e) && getElementParent(e, adapter) !== null));
     for (const t of token) {
         if (t.length > 0 &&
             isTraversal(t[0]) &&
@@ -5178,10 +5461,9 @@ function absolutize(token, { adapter }, context) {
         t.unshift(SCOPE_TOKEN);
     }
 }
-function compileToken(token, options, context) {
-    var _a;
-    token.forEach(sortByProcedure);
-    context = (_a = options.context) !== null && _a !== void 0 ? _a : context;
+function compileToken(token, options, ctx) {
+    token.forEach(sortRules);
+    const { context = ctx, rootFunc = boolbaseExports.trueFunc } = options;
     const isArrayContext = Array.isArray(context);
     const finalContext = context && (Array.isArray(context) ? context : [context]);
     // Check if the selector is relative
@@ -5192,12 +5474,11 @@ function compileToken(token, options, context) {
         throw new Error("Relative selectors are not allowed when the `relativeSelector` option is disabled");
     }
     let shouldTestNextSiblings = false;
-    const query = token
-        .map((rules) => {
+    let query = boolbaseExports.falseFunc;
+    combineLoop: for (const rules of token) {
         if (rules.length >= 2) {
             const [first, second] = rules;
-            if (first.type !== SelectorType.Pseudo ||
-                first.name !== "scope") ;
+            if (first.type !== SelectorType.Pseudo || first.name !== "scope") ;
             else if (isArrayContext &&
                 second.type === SelectorType.Descendant) {
                 rules[1] = FLEXIBLE_DESCENDANT_TOKEN;
@@ -5207,28 +5488,30 @@ function compileToken(token, options, context) {
                 shouldTestNextSiblings = true;
             }
         }
-        return compileRules(rules, options, finalContext);
-    })
-        .reduce(reduceRules, boolbase.falseFunc);
+        let next = rootFunc;
+        let hasExpensiveSubselector = false;
+        for (const rule of rules) {
+            next = compileGeneralSelector(next, rule, options, finalContext, compileToken, hasExpensiveSubselector);
+            const quality = getQuality(rule);
+            if (quality === 0) {
+                hasExpensiveSubselector = true;
+            }
+            // If the sub-selector won't match any elements, skip it.
+            if (next === boolbaseExports.falseFunc) {
+                continue combineLoop;
+            }
+        }
+        // If we have a function that always returns true, we can stop here.
+        if (next === rootFunc) {
+            return rootFunc;
+        }
+        query = query === boolbaseExports.falseFunc ? next : or(query, next);
+    }
     query.shouldTestNextSiblings = shouldTestNextSiblings;
     return query;
 }
-function compileRules(rules, options, context) {
-    var _a;
-    return rules.reduce((previous, rule) => previous === boolbase.falseFunc
-        ? boolbase.falseFunc
-        : compileGeneralSelector(previous, rule, options, context, compileToken), (_a = options.rootFunc) !== null && _a !== void 0 ? _a : boolbase.trueFunc);
-}
-function reduceRules(a, b) {
-    if (b === boolbase.falseFunc || a === boolbase.trueFunc) {
-        return a;
-    }
-    if (a === boolbase.falseFunc || b === boolbase.trueFunc) {
-        return b;
-    }
-    return function combine(elem) {
-        return a(elem) || b(elem);
-    };
+function or(a, b) {
+    return (elem) => a(elem) || b(elem);
 }
 
 const defaultEquals = (a, b) => a === b;
@@ -5237,23 +5520,34 @@ const defaultOptions$1 = {
     equals: defaultEquals,
 };
 function convertOptionFormats(options) {
-    var _a, _b, _c, _d;
     /*
      * We force one format of options to the other one.
      */
     // @ts-expect-error Default options may have incompatible `Node` / `ElementNode`.
-    const opts = options !== null && options !== void 0 ? options : defaultOptions$1;
+    const opts = options ?? defaultOptions$1;
     // @ts-expect-error Same as above.
-    (_a = opts.adapter) !== null && _a !== void 0 ? _a : (opts.adapter = DomUtils);
+    opts.adapter ?? (opts.adapter = DomUtils);
     // @ts-expect-error `equals` does not exist on `Options`
-    (_b = opts.equals) !== null && _b !== void 0 ? _b : (opts.equals = (_d = (_c = opts.adapter) === null || _c === void 0 ? void 0 : _c.equals) !== null && _d !== void 0 ? _d : defaultEquals);
+    opts.equals ?? (opts.equals = opts.adapter?.equals ?? defaultEquals);
     return opts;
 }
+/**
+ * Like `compile`, but does not add a check if elements are tags.
+ */
+function _compileUnsafe(selector, options, context) {
+    return _compileToken(typeof selector === "string" ? parse$1(selector) : selector, options, context);
+}
+/**
+ * @deprecated Use `_compileUnsafe` instead.
+ */
+function _compileToken(selector, options, context) {
+    return compileToken(selector, convertOptionFormats(options), context);
+}
 function getSelectorFunc(searchFunc) {
     return function select(query, elements, options) {
         const opts = convertOptionFormats(options);
         if (typeof query !== "function") {
-            query = compileUnsafe(query, opts, elements);
+            query = _compileUnsafe(query, opts, elements);
         }
         const filteredElements = prepareContext(elements, opts.adapter, query.shouldTestNextSiblings);
         return searchFunc(query, filteredElements, opts);
@@ -5284,111 +5578,102 @@ function appendNextSiblings(elem, adapter) {
 /**
  * @template Node The generic Node type for the DOM adapter being used.
  * @template ElementNode The Node type for elements for the DOM adapter being used.
- * @param elems Elements to query. If it is an element, its children will be queried..
+ * @param elems Elements to query. If it is an element, its children will be queried.
  * @param query can be either a CSS selector string or a compiled query function.
  * @param [options] options for querying the document.
  * @see compile for supported selector queries.
  * @returns All matching elements.
  *
  */
-const selectAll = getSelectorFunc((query, elems, options) => query === boolbase.falseFunc || !elems || elems.length === 0
+const selectAll = getSelectorFunc((query, elems, options) => query === boolbaseExports.falseFunc || !elems || elems.length === 0
     ? []
-    : options.adapter.findAll(query, elems));
-
-const comma = ','.charCodeAt(0);
-const semicolon = ';'.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
+    : findAll(query, elems, options));
+
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
 for (let i = 0; i < chars.length; i++) {
-    const c = chars.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
 }
 function encodeInteger(builder, num, relative) {
-    let delta = num - relative;
-    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
-    do {
-        let clamped = delta & 0b011111;
-        delta >>>= 5;
-        if (delta > 0)
-            clamped |= 0b100000;
-        builder.write(intToChar[clamped]);
-    } while (delta > 0);
-    return num;
-}
-
-const bufLength = 1024 * 16;
-// Provide a fallback for older environments.
-const td = typeof TextDecoder !== 'undefined'
-    ? /* #__PURE__ */ new TextDecoder()
-    : typeof Buffer !== 'undefined'
-        ? {
-            decode(buf) {
-                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
-                return out.toString();
-            },
-        }
-        : {
-            decode(buf) {
-                let out = '';
-                for (let i = 0; i < buf.length; i++) {
-                    out += String.fromCharCode(buf[i]);
-                }
-                return out;
-            },
-        };
-class StringWriter {
-    constructor() {
-        this.pos = 0;
-        this.out = '';
-        this.buffer = new Uint8Array(bufLength);
-    }
-    write(v) {
-        const { buffer } = this;
-        buffer[this.pos++] = v;
-        if (this.pos === bufLength) {
-            this.out += td.decode(buffer);
-            this.pos = 0;
-        }
+  let delta = num - relative;
+  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+  do {
+    let clamped = delta & 31;
+    delta >>>= 5;
+    if (delta > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (delta > 0);
+  return num;
+}
+
+// src/strings.ts
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
     }
-    flush() {
-        const { buffer, out, pos } = this;
-        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
     }
-}
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
 function encode(decoded) {
-    const writer = new StringWriter();
-    let sourcesIndex = 0;
-    let sourceLine = 0;
-    let sourceColumn = 0;
-    let namesIndex = 0;
-    for (let i = 0; i < decoded.length; i++) {
-        const line = decoded[i];
-        if (i > 0)
-            writer.write(semicolon);
-        if (line.length === 0)
-            continue;
-        let genColumn = 0;
-        for (let j = 0; j < line.length; j++) {
-            const segment = line[j];
-            if (j > 0)
-                writer.write(comma);
-            genColumn = encodeInteger(writer, segment[0], genColumn);
-            if (segment.length === 1)
-                continue;
-            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-            sourceLine = encodeInteger(writer, segment[2], sourceLine);
-            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
-            if (segment.length === 4)
-                continue;
-            namesIndex = encodeInteger(writer, segment[4], namesIndex);
-        }
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0) writer.write(comma);
+      genColumn = encodeInteger(writer, segment[0], genColumn);
+      if (segment.length === 1) continue;
+      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+      sourceLine = encodeInteger(writer, segment[2], sourceLine);
+      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      if (segment.length === 4) continue;
+      namesIndex = encodeInteger(writer, segment[4], namesIndex);
     }
-    return writer.flush();
+  }
+  return writer.flush();
 }
 
-class BitSet {
+let BitSet$1 = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
 	}
@@ -5400,9 +5685,9 @@ class BitSet {
 	has(n) {
 		return !!(this.bits[n >> 5] & (1 << (n & 31)));
 	}
-}
+};
 
-class Chunk {
+let Chunk$1 = class Chunk {
 	constructor(start, end, content) {
 		this.start = start;
 		this.end = end;
@@ -5579,9 +5864,9 @@ class Chunk {
 			if (this.outro.length) return true;
 		}
 	}
-}
+};
 
-function getBtoa() {
+function getBtoa$1() {
 	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
 		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
 	} else if (typeof Buffer === 'function') {
@@ -5593,9 +5878,9 @@ function getBtoa() {
 	}
 }
 
-const btoa = /*#__PURE__*/ getBtoa();
+const btoa$1 = /*#__PURE__*/ getBtoa$1();
 
-class SourceMap {
+let SourceMap$1 = class SourceMap {
 	constructor(properties) {
 		this.version = 3;
 		this.file = properties.file;
@@ -5616,11 +5901,11 @@ class SourceMap {
 	}
 
 	toUrl() {
-		return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+		return 'data:application/json;charset=utf-8;base64,' + btoa$1(this.toString());
 	}
-}
+};
 
-function guessIndent(code) {
+function guessIndent$1(code) {
 	const lines = code.split('\n');
 
 	const tabbed = lines.filter((line) => /^\t+/.test(line));
@@ -5646,7 +5931,7 @@ function guessIndent(code) {
 	return new Array(min + 1).join(' ');
 }
 
-function getRelativePath(from, to) {
+function getRelativePath$1(from, to) {
 	const fromParts = from.split(/[/\\]/);
 	const toParts = to.split(/[/\\]/);
 
@@ -5665,13 +5950,13 @@ function getRelativePath(from, to) {
 	return fromParts.concat(toParts).join('/');
 }
 
-const toString = Object.prototype.toString;
+const toString$1 = Object.prototype.toString;
 
-function isObject(thing) {
-	return toString.call(thing) === '[object Object]';
+function isObject$1(thing) {
+	return toString$1.call(thing) === '[object Object]';
 }
 
-function getLocator(source) {
+function getLocator$1(source) {
 	const originalLines = source.split('\n');
 	const lineOffsets = [];
 
@@ -5697,9 +5982,9 @@ function getLocator(source) {
 	};
 }
 
-const wordRegex = /\w/;
+const wordRegex$1 = /\w/;
 
-class Mappings {
+let Mappings$1 = class Mappings {
 	constructor(hires) {
 		this.hires = hires;
 		this.generatedCodeLine = 0;
@@ -5767,7 +6052,7 @@ class Mappings {
 
 					if (this.hires === 'boundary') {
 						// in hires "boundary", group segments per word boundary than per char
-						if (wordRegex.test(original[originalCharIndex])) {
+						if (wordRegex$1.test(original[originalCharIndex])) {
 							// for first char in the boundary found, start the boundary by pushing a segment
 							if (!charInHiresBoundary) {
 								this.rawSegments.push(segment);
@@ -5809,19 +6094,19 @@ class Mappings {
 
 		this.generatedCodeColumn += lines[lines.length - 1].length;
 	}
-}
+};
 
-const n = '\n';
+const n$1 = '\n';
 
-const warned = {
+const warned$1 = {
 	insertLeft: false,
 	insertRight: false,
 	storeName: false,
 };
 
-class MagicString {
+let MagicString$1 = class MagicString {
 	constructor(string, options = {}) {
-		const chunk = new Chunk(0, string.length, string);
+		const chunk = new Chunk$1(0, string.length, string);
 
 		Object.defineProperties(this, {
 			original: { writable: true, value: string },
@@ -5834,7 +6119,7 @@ class MagicString {
 			byEnd: { writable: true, value: {} },
 			filename: { writable: true, value: options.filename },
 			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
-			sourcemapLocations: { writable: true, value: new BitSet() },
+			sourcemapLocations: { writable: true, value: new BitSet$1() },
 			storedNames: { writable: true, value: {} },
 			indentStr: { writable: true, value: undefined },
 			ignoreList: { writable: true, value: options.ignoreList },
@@ -5919,7 +6204,7 @@ class MagicString {
 			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
 		}
 
-		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+		cloned.sourcemapLocations = new BitSet$1(this.sourcemapLocations);
 
 		cloned.intro = this.intro;
 		cloned.outro = this.outro;
@@ -5932,9 +6217,9 @@ class MagicString {
 
 		const sourceIndex = 0;
 		const names = Object.keys(this.storedNames);
-		const mappings = new Mappings(options.hires);
+		const mappings = new Mappings$1(options.hires);
 
-		const locate = getLocator(this.original);
+		const locate = getLocator$1(this.original);
 
 		if (this.intro) {
 			mappings.advance(this.intro);
@@ -5959,10 +6244,14 @@ class MagicString {
 			if (chunk.outro.length) mappings.advance(chunk.outro);
 		});
 
+		if (this.outro) {
+			mappings.advance(this.outro);
+		}
+
 		return {
 			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
 			sources: [
-				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+				options.source ? getRelativePath$1(options.file || '', options.source) : options.file || '',
 			],
 			sourcesContent: options.includeContent ? [this.original] : undefined,
 			names,
@@ -5972,12 +6261,12 @@ class MagicString {
 	}
 
 	generateMap(options) {
-		return new SourceMap(this.generateDecodedMap(options));
+		return new SourceMap$1(this.generateDecodedMap(options));
 	}
 
 	_ensureindentStr() {
 		if (this.indentStr === undefined) {
-			this.indentStr = guessIndent(this.original);
+			this.indentStr = guessIndent$1(this.original);
 		}
 	}
 
@@ -5994,7 +6283,7 @@ class MagicString {
 	indent(indentStr, options) {
 		const pattern = /^[^\r\n]/gm;
 
-		if (isObject(indentStr)) {
+		if (isObject$1(indentStr)) {
 			options = indentStr;
 			indentStr = undefined;
 		}
@@ -6086,22 +6375,22 @@ class MagicString {
 	}
 
 	insertLeft(index, content) {
-		if (!warned.insertLeft) {
+		if (!warned$1.insertLeft) {
 			console.warn(
 				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
 			);
-			warned.insertLeft = true;
+			warned$1.insertLeft = true;
 		}
 
 		return this.appendLeft(index, content);
 	}
 
 	insertRight(index, content) {
-		if (!warned.insertRight) {
+		if (!warned$1.insertRight) {
 			console.warn(
 				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
 			);
-			warned.insertRight = true;
+			warned$1.insertRight = true;
 		}
 
 		return this.prependRight(index, content);
@@ -6174,11 +6463,11 @@ class MagicString {
 		this._split(end);
 
 		if (options === true) {
-			if (!warned.storeName) {
+			if (!warned$1.storeName) {
 				console.warn(
 					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
 				);
-				warned.storeName = true;
+				warned$1.storeName = true;
 			}
 
 			options = { storeName: true };
@@ -6211,7 +6500,7 @@ class MagicString {
 			first.edit(content, storeName, !overwrite);
 		} else {
 			// must be inserting at the end
-			const newChunk = new Chunk(start, end, '').edit(content, storeName);
+			const newChunk = new Chunk$1(start, end, '').edit(content, storeName);
 
 			// TODO last chunk in the array may not be the last chunk, if it's moved...
 			last.next = newChunk;
@@ -6330,30 +6619,30 @@ class MagicString {
 	}
 
 	lastLine() {
-		let lineIndex = this.outro.lastIndexOf(n);
+		let lineIndex = this.outro.lastIndexOf(n$1);
 		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
 		let lineStr = this.outro;
 		let chunk = this.lastChunk;
 		do {
 			if (chunk.outro.length > 0) {
-				lineIndex = chunk.outro.lastIndexOf(n);
+				lineIndex = chunk.outro.lastIndexOf(n$1);
 				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.outro + lineStr;
 			}
 
 			if (chunk.content.length > 0) {
-				lineIndex = chunk.content.lastIndexOf(n);
+				lineIndex = chunk.content.lastIndexOf(n$1);
 				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.content + lineStr;
 			}
 
 			if (chunk.intro.length > 0) {
-				lineIndex = chunk.intro.lastIndexOf(n);
+				lineIndex = chunk.intro.lastIndexOf(n$1);
 				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
 				lineStr = chunk.intro + lineStr;
 			}
 		} while ((chunk = chunk.previous));
-		lineIndex = this.intro.lastIndexOf(n);
+		lineIndex = this.intro.lastIndexOf(n$1);
 		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
 		return this.intro + lineStr;
 	}
@@ -6425,19 +6714,25 @@ class MagicString {
 		if (this.byStart[index] || this.byEnd[index]) return;
 
 		let chunk = this.lastSearchedChunk;
+		let previousChunk = chunk;
 		const searchForward = index > chunk.end;
 
 		while (chunk) {
 			if (chunk.contains(index)) return this._splitChunk(chunk, index);
 
 			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+
+			// Prevent infinite loop (e.g. via empty chunks, where start === end)
+			if (chunk === previousChunk) return;
+
+			previousChunk = chunk;
 		}
 	}
 
 	_splitChunk(chunk, index) {
 		if (chunk.edited && chunk.content.length) {
 			// zero-length edited chunks are a special case (overlapping replacements)
-			const loc = getLocator(this.original)(index);
+			const loc = getLocator$1(this.original)(index);
 			throw new Error(
 				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
 			);
@@ -6618,7 +6913,12 @@ class MagicString {
 		const index = original.indexOf(string);
 
 		if (index !== -1) {
-			this.overwrite(index, index + string.length, replacement);
+			if (typeof replacement === 'function') {
+				replacement = replacement(string, index, original);
+			}
+			if (string !== replacement) {
+				this.overwrite(index, index + string.length, replacement);
+			}
 		}
 
 		return this;
@@ -6641,7 +6941,11 @@ class MagicString {
 			index = original.indexOf(string, index + stringLength)
 		) {
 			const previous = original.slice(index, index + stringLength);
-			if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+			let _replacement = replacement;
+			if (typeof replacement === 'function') {
+				_replacement = replacement(previous, index, original);
+			}
+			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
 		}
 
 		return this;
@@ -6660,7 +6964,7 @@ class MagicString {
 
 		return this._replaceRegexp(searchValue, replacement);
 	}
-}
+};
 
 const HASH_CHARACTER_LENGTH = 16;
 function hashM2c2kitAssets(rootDir, cwd = "") {
@@ -6669,7 +6973,7 @@ function hashM2c2kitAssets(rootDir, cwd = "") {
     name: "hash-m2c2kit-assets",
     renderChunk: {
       handler(code) {
-        const magicString = new MagicString(code);
+        const magicString = new MagicString$1(code);
         magicString.replace(
           new RegExp("__NO_M2C2KIT_MANIFEST_JSON_URL__", "g"),
           "manifest.json"
@@ -6874,7 +7178,7 @@ function restoreImportMeta(pattern = "import_meta = {};", replacement = "import_
     name: "restore-import-meta",
     renderChunk: {
       handler(code) {
-        const magicString = new MagicString(code);
+        const magicString = new MagicString$1(code);
         magicString.replace(new RegExp(pattern, "g"), replacement);
         return {
           code: magicString.toString(),
@@ -22749,7 +23053,7 @@ function addModuleMetadata() {
     transform: {
       async handler(code) {
         const pkg = JSON.parse(await readFile("./package.json", "utf8"));
-        const magicString = new MagicString(code);
+        const magicString = new MagicString$1(code);
         magicString.replace(
           new RegExp(
             "moduleMetadata:\\s*Constants.MODULE_METADATA_PLACEHOLDER",
@@ -22766,6 +23070,1280 @@ function addModuleMetadata() {
   };
 }
 
+class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+
+	has(n) {
+		return !!(this.bits[n >> 5] & (1 << (n & 31)));
+	}
+}
+
+class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+
+		this.intro = '';
+		this.outro = '';
+
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+
+		{
+			this.previous = null;
+			this.next = null;
+		}
+	}
+
+	appendLeft(content) {
+		this.outro += content;
+	}
+
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+
+		return chunk;
+	}
+
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = '';
+			this.outro = '';
+		}
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	}
+
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+
+	reset() {
+		this.intro = '';
+		this.outro = '';
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+
+	split(index) {
+		const sliceIndex = index - this.start;
+
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+
+		this.original = originalBefore;
+
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = '';
+
+		this.end = index;
+
+		if (this.edited) {
+			// after split we should save the edit content record into the correct chunk
+			// to make sure sourcemap correct
+			// For example:
+			// '  test'.trim()
+			//     split   -> '  ' + 'test'
+			//   ✔️ edit    -> '' + 'test'
+			//   ✖️ edit    -> 'test' + ''
+			// TODO is this block necessary?...
+			newChunk.edit('', false);
+			this.content = '';
+		} else {
+			this.content = originalBefore;
+		}
+
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+
+		return newChunk;
+	}
+
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit('', undefined, true);
+				if (this.edited) {
+					// save the change, if it has been edited
+					this.edit(trimmed, this.storeName, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.intro = this.intro.replace(rx, '');
+			if (this.intro.length) return true;
+		}
+	}
+
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) {
+					// save the change, if it has been edited
+					newChunk.edit(trimmed, this.storeName, true);
+				}
+				this.edit('', undefined, true);
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.outro = this.outro.replace(rx, '');
+			if (this.outro.length) return true;
+		}
+	}
+}
+
+function getBtoa() {
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	} else if (typeof Buffer === 'function') {
+		return (str) => Buffer.from(str, 'utf-8').toString('base64');
+	} else {
+		return () => {
+			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+		};
+	}
+}
+
+const btoa = /*#__PURE__*/ getBtoa();
+
+class SourceMap {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
+		if (typeof properties.debugId !== 'undefined') {
+			this.debugId = properties.debugId;
+		}
+	}
+
+	toString() {
+		return JSON.stringify(this);
+	}
+
+	toUrl() {
+		return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+	}
+}
+
+function guessIndent(code) {
+	const lines = code.split('\n');
+
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+
+	if (tabbed.length === 0 && spaced.length === 0) {
+		return null;
+	}
+
+	// More lines tabbed than spaced? Assume tabs, and
+	// default to tabs in the case of a tie (or nothing
+	// to go on)
+	if (tabbed.length >= spaced.length) {
+		return '\t';
+	}
+
+	// Otherwise, we need to guess the multiple
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+
+	return new Array(min + 1).join(' ');
+}
+
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+
+	fromParts.pop(); // get dirname
+
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = '..';
+	}
+
+	return fromParts.concat(toParts).join('/');
+}
+
+const toString = Object.prototype.toString;
+
+function isObject(thing) {
+	return toString.call(thing) === '[object Object]';
+}
+
+function getLocator(source) {
+	const originalLines = source.split('\n');
+	const lineOffsets = [];
+
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = (i + j) >> 1;
+			if (index < lineOffsets[m]) {
+				j = m;
+			} else {
+				i = m + 1;
+			}
+		}
+		const line = i - 1;
+		const column = index - lineOffsets[line];
+		return { line, column };
+	};
+}
+
+const wordRegex = /\w/;
+
+class Mappings {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf('\n', 0);
+			let previousContentLineEnd = -1;
+			// Loop through each line in the content and add a segment, but stop if the last line is empty,
+			// else code afterwards would fill one line too many
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+				if (nameIndex >= 0) {
+					segment.push(nameIndex);
+				}
+				this.rawSegments.push(segment);
+
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+			}
+
+			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+			if (nameIndex >= 0) {
+				segment.push(nameIndex);
+			}
+			this.rawSegments.push(segment);
+
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+
+		this.pending = null;
+	}
+
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		// when iterating each char, check if it's in a word boundary
+		let charInHiresBoundary = false;
+
+		while (originalCharIndex < chunk.end) {
+			if (original[originalCharIndex] === '\n') {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+				charInHiresBoundary = false;
+			} else {
+				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+					const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+					if (this.hires === 'boundary') {
+						// in hires "boundary", group segments per word boundary than per char
+						if (wordRegex.test(original[originalCharIndex])) {
+							// for first char in the boundary found, start the boundary by pushing a segment
+							if (!charInHiresBoundary) {
+								this.rawSegments.push(segment);
+								charInHiresBoundary = true;
+							}
+						} else {
+							// for non-word char, end the boundary by pushing a segment
+							this.rawSegments.push(segment);
+							charInHiresBoundary = false;
+						}
+					} else {
+						this.rawSegments.push(segment);
+					}
+				}
+
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+
+			originalCharIndex += 1;
+		}
+
+		this.pending = null;
+	}
+
+	advance(str) {
+		if (!str) return;
+
+		const lines = str.split('\n');
+
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+}
+
+const n = '\n';
+
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false,
+};
+
+class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+
+		Object.defineProperties(this, {
+			original: { writable: true, value: string },
+			outro: { writable: true, value: '' },
+			intro: { writable: true, value: '' },
+			firstChunk: { writable: true, value: chunk },
+			lastChunk: { writable: true, value: chunk },
+			lastSearchedChunk: { writable: true, value: chunk },
+			byStart: { writable: true, value: {} },
+			byEnd: { writable: true, value: {} },
+			filename: { writable: true, value: options.filename },
+			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+			sourcemapLocations: { writable: true, value: new BitSet() },
+			storedNames: { writable: true, value: {} },
+			indentStr: { writable: true, value: undefined },
+			ignoreList: { writable: true, value: options.ignoreList },
+			offset: { writable: true, value: options.offset || 0 },
+		});
+
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+
+	append(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.outro += content;
+		return this;
+	}
+
+	appendLeft(index, content) {
+		index = index + this.offset;
+
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.appendLeft(content);
+		} else {
+			this.intro += content;
+		}
+		return this;
+	}
+
+	appendRight(index, content) {
+		index = index + this.offset;
+
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.appendRight(content);
+		} else {
+			this.outro += content;
+		}
+		return this;
+	}
+
+	clone() {
+		const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });
+
+		let originalChunk = this.firstChunk;
+		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
+
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+
+				clonedChunk = nextClonedChunk;
+			}
+
+			originalChunk = nextOriginalChunk;
+		}
+
+		cloned.lastChunk = clonedChunk;
+
+		if (this.indentExclusionRanges) {
+			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		}
+
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+
+		return cloned;
+	}
+
+	generateDecodedMap(options) {
+		options = options || {};
+
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+
+		const locate = getLocator(this.original);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+
+			if (chunk.edited) {
+				mappings.addEdit(
+					sourceIndex,
+					chunk.content,
+					loc,
+					chunk.storeName ? names.indexOf(chunk.original) : -1,
+				);
+			} else {
+				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			}
+
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: [
+				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+			],
+			sourcesContent: options.includeContent ? [this.original] : undefined,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+
+	_ensureindentStr() {
+		if (this.indentStr === undefined) {
+			this.indentStr = guessIndent(this.original);
+		}
+	}
+
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? '\t' : this.indentStr;
+	}
+
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = undefined;
+		}
+
+		if (indentStr === undefined) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || '\t';
+		}
+
+		if (indentStr === '') return this; // noop
+
+		options = options || {};
+
+		// Process exclusion ranges
+		const isExcluded = {};
+
+		if (options.exclude) {
+			const exclusions =
+				typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+			exclusions.forEach((exclusion) => {
+				for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+					isExcluded[i] = true;
+				}
+			});
+		}
+
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+
+		this.intro = this.intro.replace(pattern, replacer);
+
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+
+		while (chunk) {
+			const end = chunk.end;
+
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+
+					if (chunk.content.length) {
+						shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+					}
+				}
+			} else {
+				charIndex = chunk.start;
+
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+
+						if (char === '\n') {
+							shouldIndentNextCharacter = true;
+						} else if (char !== '\r' && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+
+							if (charIndex === chunk.start) {
+								chunk.prependRight(indentStr);
+							} else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+
+					charIndex += 1;
+				}
+			}
+
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+
+		this.outro = this.outro.replace(pattern, replacer);
+
+		return this;
+	}
+
+	insert() {
+		throw new Error(
+			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
+		);
+	}
+
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn(
+				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
+			);
+			warned.insertLeft = true;
+		}
+
+		return this.appendLeft(index, content);
+	}
+
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn(
+				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
+			);
+			warned.insertRight = true;
+		}
+
+		return this.prependRight(index, content);
+	}
+
+	move(start, end, index) {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+
+		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+
+		this._split(start);
+		this._split(end);
+		this._split(index);
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+
+		first.previous = newLeft;
+		last.next = newRight || null;
+
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+	}
+
+	update(start, end, content, options) {
+		start = start + this.offset;
+		end = end + this.offset;
+
+		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (end > this.original.length) throw new Error('end is out of bounds');
+		if (start === end)
+			throw new Error(
+				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
+			);
+
+		this._split(start);
+		this._split(end);
+
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn(
+					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
+				);
+				warned.storeName = true;
+			}
+
+			options = { storeName: true };
+		}
+		const storeName = options !== undefined ? options.storeName : false;
+		const overwrite = options !== undefined ? options.overwrite : false;
+
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true,
+			});
+		}
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) {
+					throw new Error('Cannot overwrite across a split point');
+				}
+				chunk = chunk.next;
+				chunk.edit('', false);
+			}
+
+			first.edit(content, storeName, !overwrite);
+		} else {
+			// must be inserting at the end
+			const newChunk = new Chunk(start, end, '').edit(content, storeName);
+
+			// TODO last chunk in the array may not be the last chunk, if it's moved...
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+
+	prepend(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.intro = content + this.intro;
+		return this;
+	}
+
+	prependLeft(index, content) {
+		index = index + this.offset;
+
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.prependLeft(content);
+		} else {
+			this.intro = content + this.intro;
+		}
+		return this;
+	}
+
+	prependRight(index, content) {
+		index = index + this.offset;
+
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.prependRight(content);
+		} else {
+			this.outro = content + this.outro;
+		}
+		return this;
+	}
+
+	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.intro = '';
+			chunk.outro = '';
+			chunk.edit('');
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.reset();
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while ((chunk = chunk.previous));
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return '';
+	}
+
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while ((chunk = chunk.previous));
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		let result = '';
+
+		// find start chunk
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			// found end chunk before start
+			if (chunk.start < end && chunk.end >= end) {
+				return result;
+			}
+
+			chunk = chunk.next;
+		}
+
+		if (chunk && chunk.edited && chunk.start !== start)
+			throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+				result += chunk.intro;
+			}
+
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end)
+				throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+
+			result += chunk.content.slice(sliceStart, sliceEnd);
+
+			if (chunk.outro && (!containsEnd || chunk.end === end)) {
+				result += chunk.outro;
+			}
+
+			if (containsEnd) {
+				break;
+			}
+
+			chunk = chunk.next;
+		}
+
+		return result;
+	}
+
+	// TODO deprecate this? not really very useful
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+
+		return clone;
+	}
+
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+
+		let chunk = this.lastSearchedChunk;
+		const searchForward = index > chunk.end;
+
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+		}
+	}
+
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			// zero-length edited chunks are a special case (overlapping replacements)
+			const loc = getLocator(this.original)(index);
+			throw new Error(
+				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
+			);
+		}
+
+		const newChunk = chunk.split(index);
+
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+
+	toString() {
+		let str = this.intro;
+
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+
+		return str + this.outro;
+	}
+
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do {
+			if (
+				(chunk.intro.length && chunk.intro.trim()) ||
+				(chunk.content.length && chunk.content.trim()) ||
+				(chunk.outro.length && chunk.outro.trim())
+			)
+				return false;
+		} while ((chunk = chunk.next));
+		return true;
+	}
+
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		} while ((chunk = chunk.next));
+		return length;
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		let chunk = this.lastChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+
+			// if chunk was trimmed, we have a new lastChunk
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) {
+					this.lastChunk = chunk.next;
+				}
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		let chunk = this.firstChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+
+			if (chunk.end !== end) {
+				// special case...
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === 'string') {
+				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+					// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+					if (i === '$') return '$';
+					if (i === '&') return match[0];
+					const num = +i;
+					if (num < match.length) return match[+i];
+					return `$${i}`;
+				});
+			} else {
+				return replacement(...match, match.index, str, match.groups);
+			}
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while ((match = re.exec(str))) {
+				matches.push(match);
+			}
+			return matches;
+		}
+		if (searchValue.global) {
+			const matches = matchAll(searchValue, this.original);
+			matches.forEach((match) => {
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(match.index, match.index + match[0].length, replacement);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
+					this.overwrite(match.index, match.index + match[0].length, replacement);
+				}
+			}
+		}
+		return this;
+	}
+
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+
+		if (index !== -1) {
+			this.overwrite(index, index + string.length, replacement);
+		}
+
+		return this;
+	}
+
+	replace(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceString(searchValue, replacement);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (
+			let index = original.indexOf(string);
+			index !== -1;
+			index = original.indexOf(string, index + stringLength)
+		) {
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+		}
+
+		return this;
+	}
+
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceAllString(searchValue, replacement);
+		}
+
+		if (!searchValue.global) {
+			throw new TypeError(
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
+			);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+}
+
 var utils = {};
 
 var constants;