tailwindcss 0.0.0-insiders.ea10bb9 → 0.0.0-insiders.ea4e1cd

package/lib/util/createPlugin.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>_default
+    get: function() {
+        return _default;
+    }
 });
 function createPlugin(plugin, config) {
     return {

package/lib/util/createUtilityPlugin.js

@@ -4,10 +4,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>createUtilityPlugin
+    get: function() {
+        return createUtilityPlugin;
+    }
 });
-const _transformThemeValue = /*#__PURE__*/ _interopRequireDefault(require("./transformThemeValue"));
-function _interopRequireDefault(obj) {
+const _transformThemeValue = /*#__PURE__*/ _interop_require_default(require("./transformThemeValue"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -26,7 +28,7 @@ function createUtilityPlugin(themeKey, utilityVariations = [
             let group = Array.isArray(utilityVariation[0]) ? utilityVariation : [
                 utilityVariation
             ];
-            var ref;
+            var _theme;
             matchUtilities(group.reduce((obj, [classPrefix, properties])=>{
                 return Object.assign(obj, {
                     [classPrefix]: (value)=>{
@@ -44,7 +46,7 @@ function createUtilityPlugin(themeKey, utilityVariations = [
                 });
             }, {}), {
                 ...options,
-                values: filterDefault ? Object.fromEntries(Object.entries((ref = theme(themeKey)) !== null && ref !== void 0 ? ref : {}).filter(([modifier])=>modifier !== "DEFAULT")) : theme(themeKey)
+                values: filterDefault ? Object.fromEntries(Object.entries((_theme = theme(themeKey)) !== null && _theme !== void 0 ? _theme : {}).filter(([modifier])=>modifier !== "DEFAULT")) : theme(themeKey)
             });
         }
     };

package/lib/util/dataTypes.js

@@ -9,21 +9,51 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    normalize: ()=>normalize,
-    url: ()=>url,
-    number: ()=>number,
-    percentage: ()=>percentage,
-    length: ()=>length,
-    lineWidth: ()=>lineWidth,
-    shadow: ()=>shadow,
-    color: ()=>color,
-    image: ()=>image,
-    gradient: ()=>gradient,
-    position: ()=>position,
-    familyName: ()=>familyName,
-    genericName: ()=>genericName,
-    absoluteSize: ()=>absoluteSize,
-    relativeSize: ()=>relativeSize
+    normalize: function() {
+        return normalize;
+    },
+    url: function() {
+        return url;
+    },
+    number: function() {
+        return number;
+    },
+    percentage: function() {
+        return percentage;
+    },
+    length: function() {
+        return length;
+    },
+    lineWidth: function() {
+        return lineWidth;
+    },
+    shadow: function() {
+        return shadow;
+    },
+    color: function() {
+        return color;
+    },
+    image: function() {
+        return image;
+    },
+    gradient: function() {
+        return gradient;
+    },
+    position: function() {
+        return position;
+    },
+    familyName: function() {
+        return familyName;
+    },
+    genericName: function() {
+        return genericName;
+    },
+    absoluteSize: function() {
+        return absoluteSize;
+    },
+    relativeSize: function() {
+        return relativeSize;
+    }
 });
 const _color = require("./color");
 const _parseBoxShadowValue = require("./parseBoxShadowValue");
@@ -38,7 +68,12 @@ let cssFunctions = [
 function isCSSFunction(value) {
     return cssFunctions.some((fn)=>new RegExp(`^${fn}\\(.*\\)`).test(value));
 }
+const placeholder = "--tw-placeholder";
+const placeholderRe = new RegExp(placeholder, "g");
 function normalize(value, isRoot = true) {
+    if (value.startsWith("--")) {
+        return `var(${value})`;
+    }
     // Keep raw strings if it starts with `url(`
     if (value.includes("url(")) {
         return value.split(/(url\(.*?\))/g).filter(Boolean).map((part)=>{
@@ -57,7 +92,11 @@ function normalize(value, isRoot = true) {
     // Add spaces around operators inside math functions like calc() that do not follow an operator
     // or '('.
     value = value.replace(/(calc|min|max|clamp)\(.+\)/g, (match)=>{
-        return match.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
+        let vars = [];
+        return match.replace(/var\((--.+?)[,)]/g, (match, g1)=>{
+            vars.push(g1);
+            return match.replace(g1, placeholder);
+        }).replace(/(-?\d*\.?\d(?!\b-\d.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ").replace(placeholderRe, ()=>vars.shift());
     });
     return value;
 }
@@ -70,6 +109,9 @@ function number(value) {
 function percentage(value) {
     return value.endsWith("%") && number(value.slice(0, -1)) || isCSSFunction(value);
 }
+// Please refer to MDN when updating this list:
+// https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Values_and_units
+// https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Container_Queries#container_query_length_units
 let lengthUnits = [
     "cm",
     "mm",
@@ -83,10 +125,25 @@ let lengthUnits = [
     "ch",
     "rem",
     "lh",
+    "rlh",
     "vw",
     "vh",
     "vmin",
-    "vmax"
+    "vmax",
+    "vb",
+    "vi",
+    "svw",
+    "svh",
+    "lvw",
+    "lvh",
+    "dvw",
+    "dvh",
+    "cqw",
+    "cqh",
+    "cqi",
+    "cqb",
+    "cqmin",
+    "cqmax"
 ];
 let lengthUnitsPattern = `(?:${lengthUnits.join("|")})`;
 function length(value) {

package/lib/util/defaults.js

@@ -4,20 +4,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "defaults", {
     enumerable: true,
-    get: ()=>defaults
+    get: function() {
+        return defaults;
+    }
 });
 function defaults(target, ...sources) {
     for (let source of sources){
         for(let k in source){
-            var ref;
-            if (!(target === null || target === void 0 ? void 0 : (ref = target.hasOwnProperty) === null || ref === void 0 ? void 0 : ref.call(target, k))) {
+            var _target_hasOwnProperty;
+            if (!(target === null || target === void 0 ? void 0 : (_target_hasOwnProperty = target.hasOwnProperty) === null || _target_hasOwnProperty === void 0 ? void 0 : _target_hasOwnProperty.call(target, k))) {
                 target[k] = source[k];
             }
         }
-        for (let k1 of Object.getOwnPropertySymbols(source)){
-            var ref1;
-            if (!(target === null || target === void 0 ? void 0 : (ref1 = target.hasOwnProperty) === null || ref1 === void 0 ? void 0 : ref1.call(target, k1))) {
-                target[k1] = source[k1];
+        for (let k of Object.getOwnPropertySymbols(source)){
+            var _target_hasOwnProperty1;
+            if (!(target === null || target === void 0 ? void 0 : (_target_hasOwnProperty1 = target.hasOwnProperty) === null || _target_hasOwnProperty1 === void 0 ? void 0 : _target_hasOwnProperty1.call(target, k))) {
+                target[k] = source[k];
             }
         }
     }

package/lib/util/escapeClassName.js

@@ -4,19 +4,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>escapeClassName
+    get: function() {
+        return escapeClassName;
+    }
 });
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
-function _interopRequireDefault(obj) {
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+const _escapeCommas = /*#__PURE__*/ _interop_require_default(require("./escapeCommas"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function escapeClassName(className) {
-    var ref;
-    let node = _postcssSelectorParser.default.className();
+    var _node_raws;
+    let node = _postcssselectorparser.default.className();
     node.value = className;
-    var ref1;
-    return (0, _escapeCommas.default)((ref1 = node === null || node === void 0 ? void 0 : (ref = node.raws) === null || ref === void 0 ? void 0 : ref.value) !== null && ref1 !== void 0 ? ref1 : node.value);
+    var _node_raws_value;
+    return (0, _escapeCommas.default)((_node_raws_value = node === null || node === void 0 ? void 0 : (_node_raws = node.raws) === null || _node_raws === void 0 ? void 0 : _node_raws.value) !== null && _node_raws_value !== void 0 ? _node_raws_value : node.value);
 }

package/lib/util/escapeCommas.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>escapeCommas
+    get: function() {
+        return escapeCommas;
+    }
 });
 function escapeCommas(className) {
     return className.replace(/\\,/g, "\\2c ");

package/lib/util/flattenColorPalette.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>_default
+    get: function() {
+        return _default;
+    }
 });
 const flattenColorPalette = (colors)=>Object.assign({}, ...Object.entries(colors !== null && colors !== void 0 ? colors : {}).flatMap(([color, values])=>typeof values == "object" ? Object.entries(flattenColorPalette(values)).map(([number, hex])=>({
                 [color + (number === "DEFAULT" ? "" : `-${number}`)]: hex

package/lib/util/formatVariantSelector.js

@@ -9,41 +9,62 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    selectorFunctions: ()=>selectorFunctions,
-    formatVariantSelector: ()=>formatVariantSelector,
-    finalizeSelector: ()=>finalizeSelector
+    formatVariantSelector: function() {
+        return formatVariantSelector;
+    },
+    eliminateIrrelevantSelectors: function() {
+        return eliminateIrrelevantSelectors;
+    },
+    finalizeSelector: function() {
+        return finalizeSelector;
+    },
+    handleMergePseudo: function() {
+        return handleMergePseudo;
+    }
 });
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-const _unesc = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser/dist/util/unesc"));
-const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
-const _prefixSelector = /*#__PURE__*/ _interopRequireDefault(require("../util/prefixSelector"));
-function _interopRequireDefault(obj) {
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+const _unesc = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser/dist/util/unesc"));
+const _escapeClassName = /*#__PURE__*/ _interop_require_default(require("../util/escapeClassName"));
+const _prefixSelector = /*#__PURE__*/ _interop_require_default(require("../util/prefixSelector"));
+const _pseudoElements = require("./pseudoElements");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-var ref;
-let MERGE = ":merge";
-let PARENT = "&";
-let selectorFunctions = new Set([
-    MERGE
-]);
-function formatVariantSelector(current, ...others) {
-    for (let other of others){
-        let incomingValue = resolveFunctionArgument(other, MERGE);
-        if (incomingValue !== null) {
-            let existingValue = resolveFunctionArgument(current, MERGE, incomingValue);
-            if (existingValue !== null) {
-                let existingTarget = `${MERGE}(${incomingValue})`;
-                let splitIdx = other.indexOf(existingTarget);
-                let addition = other.slice(splitIdx + existingTarget.length).split(" ")[0];
-                current = current.replace(existingTarget, existingTarget + addition);
-                continue;
-            }
-        }
-        current = other.replace(PARENT, current);
+/** @typedef {import('postcss-selector-parser').Root} Root */ /** @typedef {import('postcss-selector-parser').Selector} Selector */ /** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */ /** @typedef {import('postcss-selector-parser').Node} Node */ /** @typedef {{format: string, isArbitraryVariant: boolean}[]} RawFormats */ /** @typedef {import('postcss-selector-parser').Root} ParsedFormats */ /** @typedef {RawFormats | ParsedFormats} AcceptedFormats */ let MERGE = ":merge";
+function formatVariantSelector(formats, { context , candidate  }) {
+    var _context_tailwindConfig_prefix;
+    let prefix = (_context_tailwindConfig_prefix = context === null || context === void 0 ? void 0 : context.tailwindConfig.prefix) !== null && _context_tailwindConfig_prefix !== void 0 ? _context_tailwindConfig_prefix : "";
+    // Parse the format selector into an AST
+    let parsedFormats = formats.map((format)=>{
+        let ast = (0, _postcssselectorparser.default)().astSync(format.format);
+        return {
+            ...format,
+            ast: format.isArbitraryVariant ? ast : (0, _prefixSelector.default)(prefix, ast)
+        };
+    });
+    // We start with the candidate selector
+    let formatAst = _postcssselectorparser.default.root({
+        nodes: [
+            _postcssselectorparser.default.selector({
+                nodes: [
+                    _postcssselectorparser.default.className({
+                        value: (0, _escapeClassName.default)(candidate)
+                    })
+                ]
+            })
+        ]
+    });
+    // And iteratively merge each format selector into the candidate selector
+    for (let { ast  } of parsedFormats){
+        [formatAst, ast] = handleMergePseudo(formatAst, ast);
+        // 2. Merge the format selector into the current selector AST
+        ast.walkNesting((nesting)=>nesting.replaceWith(...formatAst.nodes[0].nodes));
+        // 3. Keep going!
+        formatAst = ast;
     }
-    return current;
+    return formatAst;
 }
 /**
  * Given any node in a selector this gets the "simple" selector it's a part of
@@ -51,10 +72,10 @@ function formatVariantSelector(current, ...others) {
  * Technically :is(), :not(), :has(), etc… can have combinators but those are nested
  * inside the relevant node and won't be picked up so they're fine to ignore
  *
- * @param {import('postcss-selector-parser').Node} node
- * @returns {import('postcss-selector-parser').Node[]}
+ * @param {Node} node
+ * @returns {Node[]}
  **/ function simpleSelectorForNode(node) {
-    /** @type {import('postcss-selector-parser').Node[]} */ let nodes = [];
+    /** @type {Node[]} */ let nodes = [];
     // Walk backwards until we hit a combinator node (or the start)
     while(node.prev() && node.prev().type !== "combinator"){
         node = node.prev();
@@ -70,8 +91,8 @@ function formatVariantSelector(current, ...others) {
  * Resorts the nodes in a selector to ensure they're in the correct order
  * Tags go before classes, and pseudo classes go after classes
  *
- * @param {import('postcss-selector-parser').Selector} sel
- * @returns {import('postcss-selector-parser').Selector}
+ * @param {Selector} sel
+ * @returns {Selector}
  **/ function resortSelector(sel) {
     sel.sort((a, b)=>{
         if (a.type === "tag" && b.type === "class") {
@@ -106,27 +127,20 @@ function eliminateIrrelevantSelectors(sel, base) {
 // meaning of the selector.
 // TODO: Can we do this for :matches, :is, and :where?
 }
-var ref1;
-function finalizeSelector(format, { selector , candidate , context , isArbitraryVariant , // Split by the separator, but ignore the separator inside square brackets:
-//
-// E.g.: dark:lg:hover:[paint-order:markers]
-//           ┬  ┬     ┬            ┬
-//           │  │     │            ╰── We will not split here
-//           ╰──┴─────┴─────────────── We will split here
-//
-base =candidate.split(new RegExp(`\\${(ref1 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref1 !== void 0 ? ref1 : ":"}(?![^[]*\\])`)).pop()  }) {
-    var ref2;
-    let ast = (0, _postcssSelectorParser.default)().astSync(selector);
-    // We explicitly DO NOT prefix classes in arbitrary variants
-    if ((context === null || context === void 0 ? void 0 : (ref2 = context.tailwindConfig) === null || ref2 === void 0 ? void 0 : ref2.prefix) && !isArbitraryVariant) {
-        format = (0, _prefixSelector.default)(context.tailwindConfig.prefix, format);
-    }
-    format = format.replace(PARENT, `.${(0, _escapeClassName.default)(candidate)}`);
-    let formatAst = (0, _postcssSelectorParser.default)().astSync(format);
-    // Remove extraneous selectors that do not include the base class/candidate being matched against
-    // For example if we have a utility defined `.a, .b { color: red}`
-    // And the formatted variant is sm:b then we want the final selector to be `.sm\:b` and not `.a, .sm\:b`
-    ast.each((sel)=>eliminateIrrelevantSelectors(sel, base));
+function finalizeSelector(current, formats, { context , candidate , base  }) {
+    var _context_tailwindConfig;
+    var _context_tailwindConfig_separator;
+    let separator = (_context_tailwindConfig_separator = context === null || context === void 0 ? void 0 : (_context_tailwindConfig = context.tailwindConfig) === null || _context_tailwindConfig === void 0 ? void 0 : _context_tailwindConfig.separator) !== null && _context_tailwindConfig_separator !== void 0 ? _context_tailwindConfig_separator : ":";
+    // Split by the separator, but ignore the separator inside square brackets:
+    //
+    // E.g.: dark:lg:hover:[paint-order:markers]
+    //           ┬  ┬     ┬            ┬
+    //           │  │     │            ╰── We will not split here
+    //           ╰──┴─────┴─────────────── We will split here
+    //
+    base = base !== null && base !== void 0 ? base : candidate.split(new RegExp(`\\${separator}(?![^[]*\\])`)).pop();
+    // Parse the selector into an AST
+    let selector = (0, _postcssselectorparser.default)().astSync(current);
     // Normalize escaped classes, e.g.:
     //
     // The idea would be to replace the escaped `base` in the selector with the
@@ -138,20 +152,31 @@ base =candidate.split(new RegExp(`\\${(ref1 = context === null || context === vo
     //   base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
     //       escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
     //
-    ast.walkClasses((node)=>{
+    selector.walkClasses((node)=>{
         if (node.raws && node.value.includes(base)) {
             node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value));
         }
     });
-    let simpleStart = _postcssSelectorParser.default.comment({
+    // Remove extraneous selectors that do not include the base candidate
+    selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
+    // If there are no formats that means there were no variants added to the candidate
+    // so we can just return the selector as-is
+    let formatAst = Array.isArray(formats) ? formatVariantSelector(formats, {
+        context,
+        candidate
+    }) : formats;
+    if (formatAst === null) {
+        return selector.toString();
+    }
+    let simpleStart = _postcssselectorparser.default.comment({
         value: "/*__simple__*/"
     });
-    let simpleEnd = _postcssSelectorParser.default.comment({
+    let simpleEnd = _postcssselectorparser.default.comment({
         value: "/*__simple__*/"
     });
     // We can safely replace the escaped base now, since the `base` section is
     // now in a normalized escaped value.
-    ast.walkClasses((node)=>{
+    selector.walkClasses((node)=>{
         if (node.value !== base) {
             return;
         }
@@ -166,120 +191,73 @@ base =candidate.split(new RegExp(`\\${(ref1 = context === null || context === vo
         parent.insertBefore(simpleSelector[0], simpleStart);
         parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd);
         for (let child of formatNodes){
-            parent.insertBefore(simpleSelector[0], child);
+            parent.insertBefore(simpleSelector[0], child.clone());
         }
         node.remove();
         // Re-sort the simple selector to ensure it's in the correct order
         simpleSelector = simpleSelectorForNode(simpleStart);
         let firstNode = parent.index(simpleStart);
-        parent.nodes.splice(firstNode, simpleSelector.length, ...resortSelector(_postcssSelectorParser.default.selector({
+        parent.nodes.splice(firstNode, simpleSelector.length, ...resortSelector(_postcssselectorparser.default.selector({
             nodes: simpleSelector
         })).nodes);
         simpleStart.remove();
         simpleEnd.remove();
     });
-    // This will make sure to move pseudo's to the correct spot (the end for
-    // pseudo elements) because otherwise the selector will never work
-    // anyway.
-    //
-    // E.g.:
-    //  - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
-    //  - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
-    //
-    // `::before:hover` doesn't work, which means that we can make it work for you by flipping the order.
-    function collectPseudoElements(selector) {
-        let nodes = [];
-        for (let node of selector.nodes){
-            if (isPseudoElement(node)) {
-                nodes.push(node);
-                selector.removeChild(node);
-            }
-            if (node === null || node === void 0 ? void 0 : node.nodes) {
-                nodes.push(...collectPseudoElements(node));
-            }
-        }
-        return nodes;
-    }
     // Remove unnecessary pseudo selectors that we used as placeholders
-    ast.each((selector)=>{
-        selector.walkPseudos((p)=>{
-            if (selectorFunctions.has(p.value)) {
-                p.replaceWith(p.nodes);
-            }
-        });
-        let pseudoElements = collectPseudoElements(selector);
-        if (pseudoElements.length > 0) {
-            selector.nodes.push(pseudoElements.sort(sortSelector));
+    selector.walkPseudos((p)=>{
+        if (p.value === MERGE) {
+            p.replaceWith(p.nodes);
         }
     });
-    return ast.toString();
-}
-// Note: As a rule, double colons (::) should be used instead of a single colon
-// (:). This distinguishes pseudo-classes from pseudo-elements. However, since
-// this distinction was not present in older versions of the W3C spec, most
-// browsers support both syntaxes for the original pseudo-elements.
-let pseudoElementsBC = [
-    ":before",
-    ":after",
-    ":first-line",
-    ":first-letter"
-];
-// These pseudo-elements _can_ be combined with other pseudo selectors AND the order does matter.
-let pseudoElementExceptions = [
-    "::file-selector-button"
-];
-// This will make sure to move pseudo's to the correct spot (the end for
-// pseudo elements) because otherwise the selector will never work
-// anyway.
-//
-// E.g.:
-//  - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
-//  - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
-//
-// `::before:hover` doesn't work, which means that we can make it work
-// for you by flipping the order.
-function sortSelector(a, z) {
-    // Both nodes are non-pseudo's so we can safely ignore them and keep
-    // them in the same order.
-    if (a.type !== "pseudo" && z.type !== "pseudo") {
-        return 0;
-    }
-    // If one of them is a combinator, we need to keep it in the same order
-    // because that means it will start a new "section" in the selector.
-    if (a.type === "combinator" ^ z.type === "combinator") {
-        return 0;
-    }
-    // One of the items is a pseudo and the other one isn't. Let's move
-    // the pseudo to the right.
-    if (a.type === "pseudo" ^ z.type === "pseudo") {
-        return (a.type === "pseudo") - (z.type === "pseudo");
-    }
-    // Both are pseudo's, move the pseudo elements (except for
-    // ::file-selector-button) to the right.
-    return isPseudoElement(a) - isPseudoElement(z);
-}
-function isPseudoElement(node) {
-    if (node.type !== "pseudo") return false;
-    if (pseudoElementExceptions.includes(node.value)) return false;
-    return node.value.startsWith("::") || pseudoElementsBC.includes(node.value);
+    // Move pseudo elements to the end of the selector (if necessary)
+    selector.each((sel)=>(0, _pseudoElements.movePseudos)(sel));
+    return selector.toString();
 }
-function resolveFunctionArgument(haystack, needle, arg) {
-    let startIdx = haystack.indexOf(arg ? `${needle}(${arg})` : needle);
-    if (startIdx === -1) return null;
-    // Start inside the `(`
-    startIdx += needle.length + 1;
-    let target = "";
-    let count = 0;
-    for (let char of haystack.slice(startIdx)){
-        if (char !== "(" && char !== ")") {
-            target += char;
-        } else if (char === "(") {
-            target += char;
-            count++;
-        } else if (char === ")") {
-            if (--count < 0) break; // unbalanced
-            target += char;
+function handleMergePseudo(selector, format) {
+    /** @type {{pseudo: Pseudo, value: string}[]} */ let merges = [];
+    // Find all :merge() pseudo-classes in `selector`
+    selector.walkPseudos((pseudo)=>{
+        if (pseudo.value === MERGE) {
+            merges.push({
+                pseudo,
+                value: pseudo.nodes[0].toString()
+            });
         }
-    }
-    return target;
+    });
+    // Find all :merge() "attachments" in `format` and attach them to the matching selector in `selector`
+    format.walkPseudos((pseudo)=>{
+        if (pseudo.value !== MERGE) {
+            return;
+        }
+        let value = pseudo.nodes[0].toString();
+        // Does `selector` contain a :merge() pseudo-class with the same value?
+        let existing = merges.find((merge)=>merge.value === value);
+        // Nope so there's nothing to do
+        if (!existing) {
+            return;
+        }
+        // Everything after `:merge()` up to the next combinator is what is attached to the merged selector
+        let attachments = [];
+        let next = pseudo.next();
+        while(next && next.type !== "combinator"){
+            attachments.push(next);
+            next = next.next();
+        }
+        let combinator = next;
+        existing.pseudo.parent.insertAfter(existing.pseudo, _postcssselectorparser.default.selector({
+            nodes: attachments.map((node)=>node.clone())
+        }));
+        pseudo.remove();
+        attachments.forEach((node)=>node.remove());
+        // What about this case:
+        // :merge(.group):focus > &
+        // :merge(.group):hover &
+        if (combinator && combinator.type === "combinator") {
+            combinator.remove();
+        }
+    });
+    return [
+        selector,
+        format
+    ];
 }