tailwindcss 0.0.0-insiders.ff2c25f → 0.0.0-internal.b2586d4e

package/lib/util/dataTypes.js

@@ -1,266 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_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
-});
-const _color = require("./color");
-const _parseBoxShadowValue = require("./parseBoxShadowValue");
-const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
-let cssFunctions = [
-    "min",
-    "max",
-    "clamp",
-    "calc"
-];
-// Ref: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Types
-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)=>{
-            if (/^url\(.*?\)$/.test(part)) {
-                return part;
-            }
-            return normalize(part, false);
-        }).join("");
-    }
-    // Convert `_` to ` `, except for escaped underscores `\_`
-    value = value.replace(/([^\\])_+/g, (fullMatch, characterBefore)=>characterBefore + " ".repeat(fullMatch.length - 1)).replace(/^_/g, " ").replace(/\\_/g, "_");
-    // Remove leftover whitespace
-    if (isRoot) {
-        value = value.trim();
-    }
-    // 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)=>{
-        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;
-}
-function url(value) {
-    return value.startsWith("url(");
-}
-function number(value) {
-    return !isNaN(Number(value)) || isCSSFunction(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",
-    "Q",
-    "in",
-    "pc",
-    "pt",
-    "px",
-    "em",
-    "ex",
-    "ch",
-    "rem",
-    "lh",
-    "rlh",
-    "vw",
-    "vh",
-    "vmin",
-    "vmax",
-    "vb",
-    "vi",
-    "svw",
-    "svh",
-    "lvw",
-    "lvh",
-    "dvw",
-    "dvh",
-    "cqw",
-    "cqh",
-    "cqi",
-    "cqb",
-    "cqmin",
-    "cqmax"
-];
-let lengthUnitsPattern = `(?:${lengthUnits.join("|")})`;
-function length(value) {
-    return value === "0" || new RegExp(`^[+-]?[0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`).test(value) || isCSSFunction(value);
-}
-let lineWidths = new Set([
-    "thin",
-    "medium",
-    "thick"
-]);
-function lineWidth(value) {
-    return lineWidths.has(value);
-}
-function shadow(value) {
-    let parsedShadows = (0, _parseBoxShadowValue.parseBoxShadowValue)(normalize(value));
-    for (let parsedShadow of parsedShadows){
-        if (!parsedShadow.valid) {
-            return false;
-        }
-    }
-    return true;
-}
-function color(value) {
-    let colors = 0;
-    let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, "_").every((part)=>{
-        part = normalize(part);
-        if (part.startsWith("var(")) return true;
-        if ((0, _color.parseColor)(part, {
-            loose: true
-        }) !== null) return colors++, true;
-        return false;
-    });
-    if (!result) return false;
-    return colors > 0;
-}
-function image(value) {
-    let images = 0;
-    let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, ",").every((part)=>{
-        part = normalize(part);
-        if (part.startsWith("var(")) return true;
-        if (url(part) || gradient(part) || [
-            "element(",
-            "image(",
-            "cross-fade(",
-            "image-set("
-        ].some((fn)=>part.startsWith(fn))) {
-            images++;
-            return true;
-        }
-        return false;
-    });
-    if (!result) return false;
-    return images > 0;
-}
-let gradientTypes = new Set([
-    "linear-gradient",
-    "radial-gradient",
-    "repeating-linear-gradient",
-    "repeating-radial-gradient",
-    "conic-gradient"
-]);
-function gradient(value) {
-    value = normalize(value);
-    for (let type of gradientTypes){
-        if (value.startsWith(`${type}(`)) {
-            return true;
-        }
-    }
-    return false;
-}
-let validPositions = new Set([
-    "center",
-    "top",
-    "right",
-    "bottom",
-    "left"
-]);
-function position(value) {
-    let positions = 0;
-    let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, "_").every((part)=>{
-        part = normalize(part);
-        if (part.startsWith("var(")) return true;
-        if (validPositions.has(part) || length(part) || percentage(part)) {
-            positions++;
-            return true;
-        }
-        return false;
-    });
-    if (!result) return false;
-    return positions > 0;
-}
-function familyName(value) {
-    let fonts = 0;
-    let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, ",").every((part)=>{
-        part = normalize(part);
-        if (part.startsWith("var(")) return true;
-        // If it contains spaces, then it should be quoted
-        if (part.includes(" ")) {
-            if (!/(['"])([^"']+)\1/g.test(part)) {
-                return false;
-            }
-        }
-        // If it starts with a number, it's invalid
-        if (/^\d/g.test(part)) {
-            return false;
-        }
-        fonts++;
-        return true;
-    });
-    if (!result) return false;
-    return fonts > 0;
-}
-let genericNames = new Set([
-    "serif",
-    "sans-serif",
-    "monospace",
-    "cursive",
-    "fantasy",
-    "system-ui",
-    "ui-serif",
-    "ui-sans-serif",
-    "ui-monospace",
-    "ui-rounded",
-    "math",
-    "emoji",
-    "fangsong"
-]);
-function genericName(value) {
-    return genericNames.has(value);
-}
-let absoluteSizes = new Set([
-    "xx-small",
-    "x-small",
-    "small",
-    "medium",
-    "large",
-    "x-large",
-    "x-large",
-    "xxx-large"
-]);
-function absoluteSize(value) {
-    return absoluteSizes.has(value);
-}
-let relativeSizes = new Set([
-    "larger",
-    "smaller"
-]);
-function relativeSize(value) {
-    return relativeSizes.has(value);
-}

package/lib/util/defaults.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "defaults", {
-    enumerable: true,
-    get: ()=>defaults
-});
-function defaults(target, ...sources) {
-    for (let source of sources){
-        for(let k in source){
-            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 _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, k1))) {
-                target[k1] = source[k1];
-            }
-        }
-    }
-    return target;
-}

package/lib/util/escapeClassName.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: ()=>escapeClassName
-});
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function escapeClassName(className) {
-    var _node_raws;
-    let node = _postcssSelectorParser.default.className();
-    node.value = className;
-    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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: ()=>escapeCommas
-});
-function escapeCommas(className) {
-    return className.replace(/\\,/g, "\\2c ");
-}

package/lib/util/flattenColorPalette.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: ()=>_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
-            })) : [
-            {
-                [`${color}`]: values
-            }
-        ]));
-const _default = flattenColorPalette;

package/lib/util/formatVariantSelector.js

@@ -1,351 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    formatVariantSelector: ()=>formatVariantSelector,
-    finalizeSelector: ()=>finalizeSelector,
-    handleMergePseudo: ()=>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) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/** @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 formatAst;
-}
-/**
- * Given any node in a selector this gets the "simple" selector it's a part of
- * A simple selector is just a list of nodes without any combinators
- * 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 {Node} node
- * @returns {Node[]}
- **/ function simpleSelectorForNode(node) {
-    /** @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();
-    }
-    // Now record all non-combinator nodes until we hit one (or the end)
-    while(node && node.type !== "combinator"){
-        nodes.push(node);
-        node = node.next();
-    }
-    return nodes;
-}
-/**
- * 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 {Selector} sel
- * @returns {Selector}
- **/ function resortSelector(sel) {
-    sel.sort((a, b)=>{
-        if (a.type === "tag" && b.type === "class") {
-            return -1;
-        } else if (a.type === "class" && b.type === "tag") {
-            return 1;
-        } else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
-            return -1;
-        } else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
-            return 1;
-        }
-        return sel.index(a) - sel.index(b);
-    });
-    return sel;
-}
-/**
- * Remove extraneous selectors that do not include the base class/candidate
- *
- * Example:
- * Given the utility `.a, .b { color: red}`
- * Given the candidate `sm:b`
- *
- * The final selector should be `.sm\:b` and not `.a, .sm\:b`
- *
- * @param {Selector} ast
- * @param {string} base
- */ function eliminateIrrelevantSelectors(sel, base) {
-    let hasClassesMatchingCandidate = false;
-    sel.walk((child)=>{
-        if (child.type === "class" && child.value === base) {
-            hasClassesMatchingCandidate = true;
-            return false // Stop walking
-            ;
-        }
-    });
-    if (!hasClassesMatchingCandidate) {
-        sel.remove();
-    }
-// We do NOT recursively eliminate sub selectors that don't have the base class
-// as this is NOT a safe operation. For example, if we have:
-// `.space-x-2 > :not([hidden]) ~ :not([hidden])`
-// We cannot remove the [hidden] from the :not() because it would change the
-// meaning of the selector.
-// TODO: Can we do this for :matches, :is, and :where?
-}
-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
-    // `format`. However, in css you can escape the same selector in a few
-    // different ways. This would result in different strings and therefore we
-    // can't replace it properly.
-    //
-    //               base: bg-[rgb(255,0,0)]
-    //   base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
-    //       escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
-    //
-    selector.walkClasses((node)=>{
-        if (node.raws && node.value.includes(base)) {
-            node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value));
-        }
-    });
-    // 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({
-        value: "/*__simple__*/"
-    });
-    // We can safely replace the escaped base now, since the `base` section is
-    // now in a normalized escaped value.
-    selector.walkClasses((node)=>{
-        if (node.value !== base) {
-            return;
-        }
-        let parent = node.parent;
-        let formatNodes = formatAst.nodes[0].nodes;
-        // Perf optimization: if the parent is a single class we can just replace it and be done
-        if (parent.nodes.length === 1) {
-            node.replaceWith(...formatNodes);
-            return;
-        }
-        let simpleSelector = simpleSelectorForNode(node);
-        parent.insertBefore(simpleSelector[0], simpleStart);
-        parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd);
-        for (let child of formatNodes){
-            parent.insertBefore(simpleSelector[0], child);
-        }
-        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({
-            nodes: simpleSelector
-        })).nodes);
-        simpleStart.remove();
-        simpleEnd.remove();
-    });
-    // Remove unnecessary pseudo selectors that we used as placeholders
-    selector.walkPseudos((p)=>{
-        if (p.value === MERGE) {
-            p.replaceWith(p.nodes);
-        }
-    });
-    // Move pseudo elements to the end of the selector (if necessary)
-    selector.each((sel)=>{
-        let pseudoElements = collectPseudoElements(sel);
-        if (pseudoElements.length > 0) {
-            sel.nodes.push(pseudoElements.sort(sortSelector));
-        }
-    });
-    return selector.toString();
-}
-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()
-            });
-        }
-    });
-    // 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
-    ];
-}
-// 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",
-    // Webkit scroll bar pseudo elements can be combined with user-action pseudo classes
-    "::-webkit-scrollbar",
-    "::-webkit-scrollbar-button",
-    "::-webkit-scrollbar-thumb",
-    "::-webkit-scrollbar-track",
-    "::-webkit-scrollbar-track-piece",
-    "::-webkit-scrollbar-corner",
-    "::-webkit-resizer"
-];
-/**
- * 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.
- *
- * @param {Selector} selector
- **/ function collectPseudoElements(selector) {
-    /** @type {Node[]} */ 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;
-}
-// 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);
-}