tailwindcss 0.0.0-oxide-insiders.dddaded → 0.0.0-oxide-insiders.b2e3cf2

package/lib/lib/setupContextUtils.js

@@ -1,265 +1,129 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
+    value: !0
+}), function(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
+        enumerable: !0,
         get: all[name]
     });
-}
-_export(exports, {
+}(exports, {
     isValidVariantFormatString: ()=>isValidVariantFormatString,
     parseVariant: ()=>parseVariant,
     getFileModifiedMap: ()=>getFileModifiedMap,
     createContext: ()=>createContext,
     getContext: ()=>getContext
 });
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _url = /*#__PURE__*/ _interopRequireDefault(require("url"));
-const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
-const _dlv = /*#__PURE__*/ _interopRequireDefault(require("dlv"));
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-const _transformThemeValue = /*#__PURE__*/ _interopRequireDefault(require("../util/transformThemeValue"));
-const _parseObjectStyles = /*#__PURE__*/ _interopRequireDefault(require("../util/parseObjectStyles"));
-const _prefixSelector = /*#__PURE__*/ _interopRequireDefault(require("../util/prefixSelector"));
-const _isPlainObject = /*#__PURE__*/ _interopRequireDefault(require("../util/isPlainObject"));
-const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
-const _nameClass = /*#__PURE__*/ _interopRequireWildcard(require("../util/nameClass"));
-const _pluginUtils = require("../util/pluginUtils");
-const _corePlugins = require("../corePlugins");
-const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
-const _toPath = require("../util/toPath");
-const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
-const _negateValue = /*#__PURE__*/ _interopRequireDefault(require("../util/negateValue"));
-const _isSyntacticallyValidPropertyValue = /*#__PURE__*/ _interopRequireDefault(require("../util/isSyntacticallyValidPropertyValue"));
-const _generateRules = require("./generateRules");
-const _cacheInvalidationJs = require("./cacheInvalidation.js");
-const _offsetsJs = require("./offsets.js");
-const _featureFlagsJs = require("../featureFlags.js");
-const _formatVariantSelector = require("../util/formatVariantSelector");
+const _fs = _interopRequireDefault(require("fs")), _url = _interopRequireDefault(require("url")), _postcss = _interopRequireDefault(require("postcss")), _dlv = _interopRequireDefault(require("dlv")), _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser")), _transformThemeValue = _interopRequireDefault(require("../util/transformThemeValue")), _parseObjectStyles = _interopRequireDefault(require("../util/parseObjectStyles")), _prefixSelector = _interopRequireDefault(require("../util/prefixSelector")), _isPlainObject = _interopRequireDefault(require("../util/isPlainObject")), _escapeClassName = _interopRequireDefault(require("../util/escapeClassName")), _nameClass = _interopRequireWildcard(require("../util/nameClass")), _pluginUtils = require("../util/pluginUtils"), _corePlugins = require("../corePlugins"), _sharedState = _interopRequireWildcard(require("./sharedState")), _toPath = require("../util/toPath"), _log = _interopRequireDefault(require("../util/log")), _negateValue = _interopRequireDefault(require("../util/negateValue")), _isSyntacticallyValidPropertyValue = _interopRequireDefault(require("../util/isSyntacticallyValidPropertyValue")), _generateRules = require("./generateRules"), _cacheInvalidationJs = require("./cacheInvalidation.js"), _offsetsJs = require("./offsets.js"), _featureFlagsJs = require("../featureFlags.js"), _formatVariantSelector = require("../util/formatVariantSelector");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
+    if ("function" != typeof WeakMap) return null;
+    var cacheBabelInterop = new WeakMap(), cacheNodeInterop = new WeakMap();
     return (_getRequireWildcardCache = function(nodeInterop) {
         return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
     })(nodeInterop);
 }
 function _interopRequireWildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
+    if (!nodeInterop && obj && obj.__esModule) return obj;
+    if (null === obj || "object" != typeof obj && "function" != typeof obj) return {
+        default: obj
+    };
     var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {};
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
+    if (cache && cache.has(obj)) return cache.get(obj);
+    var newObj = {}, hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj)if ("default" !== key && Object.prototype.hasOwnProperty.call(obj, key)) {
+        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+        desc && (desc.get || desc.set) ? Object.defineProperty(newObj, key, desc) : newObj[key] = obj[key];
     }
-    return newObj;
+    return newObj.default = obj, cache && cache.set(obj, newObj), newObj;
 }
 const VARIANT_TYPES = {
     AddVariant: Symbol.for("ADD_VARIANT"),
     MatchVariant: Symbol.for("MATCH_VARIANT")
-};
-const VARIANT_INFO = {
-    Base: 1 << 0,
-    Dynamic: 1 << 1
+}, VARIANT_INFO = {
+    Base: 1,
+    Dynamic: 2
 };
 function prefix(context, selector) {
     let prefix = context.tailwindConfig.prefix;
-    return typeof prefix === "function" ? prefix(selector) : prefix + selector;
+    return "function" == typeof prefix ? prefix(selector) : prefix + selector;
 }
 function normalizeOptionTypes({ type ="any" , ...options }) {
     let types = [].concat(type);
     return {
         ...options,
-        types: types.map((type)=>{
-            if (Array.isArray(type)) {
-                return {
-                    type: type[0],
-                    ...type[1]
-                };
-            }
-            return {
+        types: types.map((type)=>Array.isArray(type) ? {
+                type: type[0],
+                ...type[1]
+            } : {
                 type,
-                preferOnConflict: false
-            };
-        })
+                preferOnConflict: !1
+            })
     };
 }
-function parseVariantFormatString(input) {
-    /** @type {string[]} */ let parts = [];
-    // When parsing whitespace around special characters are insignificant
-    // However, _inside_ of a variant they could be
-    // Because the selector could look like this
-    // @media { &[data-name="foo bar"] }
-    // This is why we do not skip whitespace
-    let current = "";
-    let depth = 0;
-    for(let idx = 0; idx < input.length; idx++){
-        let char = input[idx];
-        if (char === "\\") {
-            // Escaped characters are not special
-            current += "\\" + input[++idx];
-        } else if (char === "{") {
-            // Nested rule: start
-            ++depth;
-            parts.push(current.trim());
-            current = "";
-        } else if (char === "}") {
-            // Nested rule: end
-            if (--depth < 0) {
-                throw new Error(`Your { and } are unbalanced.`);
-            }
-            parts.push(current.trim());
-            current = "";
-        } else {
-            // Normal character
-            current += char;
-        }
-    }
-    if (current.length > 0) {
-        parts.push(current.trim());
-    }
-    parts = parts.filter((part)=>part !== "");
-    return parts;
-}
-function insertInto(list, value, { before =[]  } = {}) {
-    before = [].concat(before);
-    if (before.length <= 0) {
-        list.push(value);
-        return;
-    }
-    let idx = list.length - 1;
-    for (let other of before){
-        let iidx = list.indexOf(other);
-        if (iidx === -1) continue;
-        idx = Math.min(idx, iidx);
-    }
-    list.splice(idx, 0, value);
-}
-function parseStyles(styles) {
-    if (!Array.isArray(styles)) {
-        return parseStyles([
-            styles
-        ]);
-    }
-    return styles.flatMap((style)=>{
-        let isNode = !Array.isArray(style) && !(0, _isPlainObject.default)(style);
-        return isNode ? style : (0, _parseObjectStyles.default)(style);
-    });
-}
 function getClasses(selector, mutate) {
-    let parser = (0, _postcssSelectorParser.default)((selectors)=>{
+    return (0, _postcssSelectorParser.default)((selectors)=>{
         let allClasses = [];
-        if (mutate) {
-            mutate(selectors);
-        }
-        selectors.walkClasses((classNode)=>{
+        return mutate && mutate(selectors), selectors.walkClasses((classNode)=>{
             allClasses.push(classNode.value);
-        });
-        return allClasses;
-    });
-    return parser.transformSync(selector);
+        }), allClasses;
+    }).transformSync(selector);
 }
-function extractCandidates(node, state = {
-    containsNonOnDemandable: false
-}, depth = 0) {
-    let classes = [];
-    // Handle normal rules
-    if (node.type === "rule") {
-        // Ignore everything inside a :not(...). This allows you to write code like
-        // `div:not(.foo)`. If `.foo` is never found in your code, then we used to
-        // not generated it. But now we will ignore everything inside a `:not`, so
-        // that it still gets generated.
-        function ignoreNot(selectors) {
-            selectors.walkPseudos((pseudo)=>{
-                if (pseudo.value === ":not") {
-                    pseudo.remove();
+function withIdentifiers(styles) {
+    return (function parseStyles(styles) {
+        return Array.isArray(styles) ? styles.flatMap((style)=>Array.isArray(style) || (0, _isPlainObject.default)(style) ? (0, _parseObjectStyles.default)(style) : style) : parseStyles([
+            styles
+        ]);
+    })(styles).flatMap((node)=>{
+        let nodeMap = new Map(), [containsNonOnDemandableSelectors, candidates] = function(node, state = {
+            containsNonOnDemandable: !1
+        }, depth = 0) {
+            let classes = [];
+            if ("rule" === node.type) {
+                function ignoreNot(selectors) {
+                    selectors.walkPseudos((pseudo)=>{
+                        ":not" === pseudo.value && pseudo.remove();
+                    });
                 }
+                for (let selector of node.selectors){
+                    let classCandidates = getClasses(selector, ignoreNot);
+                    for (let classCandidate of (0 === classCandidates.length && (state.containsNonOnDemandable = !0), classCandidates))classes.push(classCandidate);
+                }
+            } else "atrule" === node.type && node.walkRules((rule)=>{
+                for (let classCandidate of rule.selectors.flatMap((selector)=>getClasses(selector)))classes.push(classCandidate);
             });
-        }
-        for (let selector of node.selectors){
-            let classCandidates = getClasses(selector, ignoreNot);
-            // At least one of the selectors contains non-"on-demandable" candidates.
-            if (classCandidates.length === 0) {
-                state.containsNonOnDemandable = true;
-            }
-            for (let classCandidate of classCandidates){
-                classes.push(classCandidate);
-            }
-        }
-    } else if (node.type === "atrule") {
-        node.walkRules((rule)=>{
-            for (let classCandidate of rule.selectors.flatMap((selector)=>getClasses(selector))){
-                classes.push(classCandidate);
-            }
-        });
-    }
-    if (depth === 0) {
-        return [
-            state.containsNonOnDemandable || classes.length === 0,
-            classes
-        ];
-    }
-    return classes;
-}
-function withIdentifiers(styles) {
-    return parseStyles(styles).flatMap((node)=>{
-        let nodeMap = new Map();
-        let [containsNonOnDemandableSelectors, candidates] = extractCandidates(node);
-        // If this isn't "on-demandable", assign it a universal candidate to always include it.
-        if (containsNonOnDemandableSelectors) {
-            candidates.unshift(_sharedState.NOT_ON_DEMAND);
-        }
-        // However, it could be that it also contains "on-demandable" candidates.
-        // E.g.: `span, .foo {}`, in that case it should still be possible to use
-        // `@apply foo` for example.
-        return candidates.map((c)=>{
-            if (!nodeMap.has(node)) {
-                nodeMap.set(node, node);
-            }
-            return [
+            return 0 === depth ? [
+                state.containsNonOnDemandable || 0 === classes.length,
+                classes
+            ] : classes;
+        }(node);
+        return containsNonOnDemandableSelectors && candidates.unshift(_sharedState.NOT_ON_DEMAND), candidates.map((c)=>(nodeMap.has(node) || nodeMap.set(node, node), [
                 c,
                 nodeMap.get(node)
-            ];
-        });
+            ]));
     });
 }
 function isValidVariantFormatString(format) {
     return format.startsWith("@") || format.includes("&");
 }
 function parseVariant(variant) {
-    variant = variant.replace(/\n+/g, "").replace(/\s{1,}/g, " ").trim();
-    let fns = parseVariantFormatString(variant).map((str)=>{
-        if (!str.startsWith("@")) {
-            return ({ format  })=>format(str);
+    let fns = (function(input) {
+        let parts = [], current = "", depth = 0;
+        for(let idx = 0; idx < input.length; idx++){
+            let char = input[idx];
+            if ("\\" === char) current += "\\" + input[++idx];
+            else if ("{" === char) ++depth, parts.push(current.trim()), current = "";
+            else if ("}" === char) {
+                if (--depth < 0) throw Error("Your { and } are unbalanced.");
+                parts.push(current.trim()), current = "";
+            } else current += char;
         }
+        return current.length > 0 && parts.push(current.trim()), parts = parts.filter((part)=>"" !== part);
+    })(variant = variant.replace(/\n+/g, "").replace(/\s{1,}/g, " ").trim()).map((str)=>{
+        if (!str.startsWith("@")) return ({ format  })=>format(str);
         let [, name, params] = /@(.*?)( .+|[({].*)/g.exec(str);
         return ({ wrap  })=>wrap(_postcss.default.atRule({
                 name,
@@ -267,702 +131,415 @@ function parseVariant(variant) {
             }));
     }).reverse();
     return (api)=>{
-        for (let fn of fns){
-            fn(api);
-        }
-    };
-}
-/**
- *
- * @param {any} tailwindConfig
- * @param {any} context
- * @param {object} param2
- * @param {Offsets} param2.offsets
- */ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , offsets , classList  }) {
-    function getConfigValue(path, defaultValue) {
-        return path ? (0, _dlv.default)(tailwindConfig, path, defaultValue) : tailwindConfig;
-    }
-    function applyConfiguredPrefix(selector) {
-        return (0, _prefixSelector.default)(tailwindConfig.prefix, selector);
-    }
-    function prefixIdentifier(identifier, options) {
-        if (identifier === _sharedState.NOT_ON_DEMAND) {
-            return _sharedState.NOT_ON_DEMAND;
-        }
-        if (!options.respectPrefix) {
-            return identifier;
-        }
-        return context.tailwindConfig.prefix + identifier;
-    }
-    function resolveThemeValue(path, defaultValue, opts = {}) {
-        let parts = (0, _toPath.toPath)(path);
-        let value = getConfigValue([
-            "theme",
-            ...parts
-        ], defaultValue);
-        return (0, _transformThemeValue.default)(parts[0])(value, opts);
-    }
-    let variantIdentifier = 0;
-    let api = {
-        postcss: _postcss.default,
-        prefix: applyConfiguredPrefix,
-        e: _escapeClassName.default,
-        config: getConfigValue,
-        theme: resolveThemeValue,
-        corePlugins: (path)=>{
-            if (Array.isArray(tailwindConfig.corePlugins)) {
-                return tailwindConfig.corePlugins.includes(path);
-            }
-            return getConfigValue([
-                "corePlugins",
-                path
-            ], true);
-        },
-        variants: ()=>{
-            // Preserved for backwards compatibility but not used in v3.0+
-            return [];
-        },
-        addBase (base) {
-            for (let [identifier, rule] of withIdentifiers(base)){
-                let prefixedIdentifier = prefixIdentifier(identifier, {});
-                let offset = offsets.create("base");
-                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
-                    context.candidateRuleMap.set(prefixedIdentifier, []);
-                }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offset,
-                        layer: "base"
-                    },
-                    rule
-                ]);
-            }
-        },
-        /**
-     * @param {string} group
-     * @param {Record<string, string | string[]>} declarations
-     */ addDefaults (group, declarations) {
-            const groups = {
-                [`@defaults ${group}`]: declarations
-            };
-            for (let [identifier, rule] of withIdentifiers(groups)){
-                let prefixedIdentifier = prefixIdentifier(identifier, {});
-                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
-                    context.candidateRuleMap.set(prefixedIdentifier, []);
-                }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offsets.create("defaults"),
-                        layer: "defaults"
-                    },
-                    rule
-                ]);
-            }
-        },
-        addComponents (components, options) {
-            let defaultOptions = {
-                preserveSource: false,
-                respectPrefix: true,
-                respectImportant: false
-            };
-            options = Object.assign({}, defaultOptions, Array.isArray(options) ? {} : options);
-            for (let [identifier, rule] of withIdentifiers(components)){
-                let prefixedIdentifier = prefixIdentifier(identifier, options);
-                classList.add(prefixedIdentifier);
-                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
-                    context.candidateRuleMap.set(prefixedIdentifier, []);
-                }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offsets.create("components"),
-                        layer: "components",
-                        options
-                    },
-                    rule
-                ]);
-            }
-        },
-        addUtilities (utilities, options) {
-            let defaultOptions = {
-                preserveSource: false,
-                respectPrefix: true,
-                respectImportant: true
-            };
-            options = Object.assign({}, defaultOptions, Array.isArray(options) ? {} : options);
-            for (let [identifier, rule] of withIdentifiers(utilities)){
-                let prefixedIdentifier = prefixIdentifier(identifier, options);
-                classList.add(prefixedIdentifier);
-                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
-                    context.candidateRuleMap.set(prefixedIdentifier, []);
-                }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offsets.create("utilities"),
-                        layer: "utilities",
-                        options
-                    },
-                    rule
-                ]);
-            }
-        },
-        matchUtilities: function(utilities, options) {
-            let defaultOptions = {
-                respectPrefix: true,
-                respectImportant: true,
-                modifiers: false
-            };
-            options = normalizeOptionTypes({
-                ...defaultOptions,
-                ...options
-            });
-            let offset = offsets.create("utilities");
-            for(let identifier in utilities){
-                let prefixedIdentifier = prefixIdentifier(identifier, options);
-                let rule = utilities[identifier];
-                classList.add([
-                    prefixedIdentifier,
-                    options
-                ]);
-                function wrapped(modifier, { isOnlyPlugin  }) {
-                    let [value, coercedType, utilityModifier] = (0, _pluginUtils.coerceValue)(options.types, modifier, options, tailwindConfig);
-                    if (value === undefined) {
-                        return [];
-                    }
-                    if (!options.types.some(({ type  })=>type === coercedType)) {
-                        if (isOnlyPlugin) {
-                            _log.default.warn([
-                                `Unnecessary typehint \`${coercedType}\` in \`${identifier}-${modifier}\`.`,
-                                `You can safely update it to \`${identifier}-${modifier.replace(coercedType + ":", "")}\`.`
-                            ]);
-                        } else {
-                            return [];
-                        }
-                    }
-                    if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) {
-                        return [];
-                    }
-                    let extras = {
-                        get modifier () {
-                            if (!options.modifiers) {
-                                _log.default.warn(`modifier-used-without-options-for-${identifier}`, [
-                                    "Your plugin must set `modifiers: true` in its options to support modifiers."
-                                ]);
-                            }
-                            return utilityModifier;
-                        }
-                    };
-                    let modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
-                    let ruleSets = [].concat(modifiersEnabled ? rule(value, extras) : rule(value)).filter(Boolean).map((declaration)=>({
-                            [(0, _nameClass.default)(identifier, modifier)]: declaration
-                        }));
-                    return ruleSets;
-                }
-                let withOffsets = [
-                    {
-                        sort: offset,
-                        layer: "utilities",
-                        options
-                    },
-                    wrapped
-                ];
-                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
-                    context.candidateRuleMap.set(prefixedIdentifier, []);
-                }
-                context.candidateRuleMap.get(prefixedIdentifier).push(withOffsets);
-            }
-        },
-        matchComponents: function(components, options) {
-            let defaultOptions = {
-                respectPrefix: true,
-                respectImportant: false,
-                modifiers: false
-            };
-            options = normalizeOptionTypes({
-                ...defaultOptions,
-                ...options
-            });
-            let offset = offsets.create("components");
-            for(let identifier in components){
-                let prefixedIdentifier = prefixIdentifier(identifier, options);
-                let rule = components[identifier];
-                classList.add([
-                    prefixedIdentifier,
-                    options
-                ]);
-                function wrapped(modifier, { isOnlyPlugin  }) {
-                    let [value, coercedType, utilityModifier] = (0, _pluginUtils.coerceValue)(options.types, modifier, options, tailwindConfig);
-                    if (value === undefined) {
-                        return [];
-                    }
-                    if (!options.types.some(({ type  })=>type === coercedType)) {
-                        if (isOnlyPlugin) {
-                            _log.default.warn([
-                                `Unnecessary typehint \`${coercedType}\` in \`${identifier}-${modifier}\`.`,
-                                `You can safely update it to \`${identifier}-${modifier.replace(coercedType + ":", "")}\`.`
-                            ]);
-                        } else {
-                            return [];
-                        }
-                    }
-                    if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) {
-                        return [];
-                    }
-                    let extras = {
-                        get modifier () {
-                            if (!options.modifiers) {
-                                _log.default.warn(`modifier-used-without-options-for-${identifier}`, [
-                                    "Your plugin must set `modifiers: true` in its options to support modifiers."
-                                ]);
-                            }
-                            return utilityModifier;
-                        }
-                    };
-                    let modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
-                    let ruleSets = [].concat(modifiersEnabled ? rule(value, extras) : rule(value)).filter(Boolean).map((declaration)=>({
-                            [(0, _nameClass.default)(identifier, modifier)]: declaration
-                        }));
-                    return ruleSets;
-                }
-                let withOffsets = [
-                    {
-                        sort: offset,
-                        layer: "components",
-                        options
-                    },
-                    wrapped
-                ];
-                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
-                    context.candidateRuleMap.set(prefixedIdentifier, []);
-                }
-                context.candidateRuleMap.get(prefixedIdentifier).push(withOffsets);
-            }
-        },
-        addVariant (variantName, variantFunctions, options = {}) {
-            variantFunctions = [].concat(variantFunctions).map((variantFunction)=>{
-                if (typeof variantFunction !== "string") {
-                    // Safelist public API functions
-                    return (api = {})=>{
-                        let { args , modifySelectors , container , separator , wrap , format  } = api;
-                        let result = variantFunction(Object.assign({
-                            modifySelectors,
-                            container,
-                            separator
-                        }, options.type === VARIANT_TYPES.MatchVariant && {
-                            args,
-                            wrap,
-                            format
-                        }));
-                        if (typeof result === "string" && !isValidVariantFormatString(result)) {
-                            throw new Error(`Your custom variant \`${variantName}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`);
-                        }
-                        if (Array.isArray(result)) {
-                            return result.filter((variant)=>typeof variant === "string").map((variant)=>parseVariant(variant));
-                        }
-                        // result may be undefined with legacy variants that use APIs like `modifySelectors`
-                        // result may also be a postcss node if someone was returning the result from `modifySelectors`
-                        return result && typeof result === "string" && parseVariant(result)(api);
-                    };
-                }
-                if (!isValidVariantFormatString(variantFunction)) {
-                    throw new Error(`Your custom variant \`${variantName}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`);
-                }
-                return parseVariant(variantFunction);
-            });
-            insertInto(variantList, variantName, options);
-            variantMap.set(variantName, variantFunctions);
-            context.variantOptions.set(variantName, options);
-        },
-        matchVariant (variant, variantFn, options) {
-            var _options_id;
-            // A unique identifier that "groups" these variants together.
-            // This is for internal use only which is why it is not present in the types
-            let id = (_options_id = options === null || options === void 0 ? void 0 : options.id) !== null && _options_id !== void 0 ? _options_id : ++variantIdentifier;
-            let isSpecial = variant === "@";
-            let modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
-            var _options_values;
-            for (let [key, value] of Object.entries((_options_values = options === null || options === void 0 ? void 0 : options.values) !== null && _options_values !== void 0 ? _options_values : {})){
-                if (key === "DEFAULT") continue;
-                api.addVariant(isSpecial ? `${variant}${key}` : `${variant}-${key}`, ({ args , container  })=>{
-                    return variantFn(value, modifiersEnabled ? {
-                        modifier: args === null || args === void 0 ? void 0 : args.modifier,
-                        container
-                    } : {
-                        container
-                    });
-                }, {
-                    ...options,
-                    value,
-                    id,
-                    type: VARIANT_TYPES.MatchVariant,
-                    variantInfo: VARIANT_INFO.Base
-                });
-            }
-            var _options_values1;
-            let hasDefault = "DEFAULT" in ((_options_values1 = options === null || options === void 0 ? void 0 : options.values) !== null && _options_values1 !== void 0 ? _options_values1 : {});
-            api.addVariant(variant, ({ args , container  })=>{
-                if ((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE && !hasDefault) {
-                    return null;
-                }
-                var // (JetBrains) plugins.
-                _args_value;
-                return variantFn((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE ? options.values.DEFAULT : (_args_value = args === null || args === void 0 ? void 0 : args.value) !== null && _args_value !== void 0 ? _args_value : typeof args === "string" ? args : "", modifiersEnabled ? {
-                    modifier: args === null || args === void 0 ? void 0 : args.modifier,
-                    container
-                } : {
-                    container
-                });
-            }, {
-                ...options,
-                id,
-                type: VARIANT_TYPES.MatchVariant,
-                variantInfo: VARIANT_INFO.Dynamic
-            });
-        }
+        for (let fn of fns)fn(api);
     };
-    return api;
 }
 let fileModifiedMapCache = new WeakMap();
 function getFileModifiedMap(context) {
-    if (!fileModifiedMapCache.has(context)) {
-        fileModifiedMapCache.set(context, new Map());
-    }
-    return fileModifiedMapCache.get(context);
+    return fileModifiedMapCache.has(context) || fileModifiedMapCache.set(context, new Map()), fileModifiedMapCache.get(context);
 }
 function trackModified(files, fileModifiedMap) {
-    let changed = false;
-    let mtimesToCommit = new Map();
+    let changed = !1, mtimesToCommit = new Map();
     for (let file of files){
         var _fs_statSync;
         if (!file) continue;
-        let parsed = _url.default.parse(file);
-        let pathname = parsed.hash ? parsed.href.replace(parsed.hash, "") : parsed.href;
+        let parsed = _url.default.parse(file), pathname = parsed.hash ? parsed.href.replace(parsed.hash, "") : parsed.href;
         pathname = parsed.search ? pathname.replace(parsed.search, "") : pathname;
-        let newModified = (_fs_statSync = _fs.default.statSync(decodeURIComponent(pathname), {
-            throwIfNoEntry: false
-        })) === null || _fs_statSync === void 0 ? void 0 : _fs_statSync.mtimeMs;
-        if (!newModified) {
-            continue;
-        }
-        if (!fileModifiedMap.has(file) || newModified > fileModifiedMap.get(file)) {
-            changed = true;
-        }
-        mtimesToCommit.set(file, newModified);
+        let newModified = null === (_fs_statSync = _fs.default.statSync(decodeURIComponent(pathname), {
+            throwIfNoEntry: !1
+        })) || void 0 === _fs_statSync ? void 0 : _fs_statSync.mtimeMs;
+        newModified && ((!fileModifiedMap.has(file) || newModified > fileModifiedMap.get(file)) && (changed = !0), mtimesToCommit.set(file, newModified));
     }
     return [
         changed,
         mtimesToCommit
     ];
 }
-function extractVariantAtRules(node) {
-    node.walkAtRules((atRule)=>{
-        if ([
-            "responsive",
-            "variants"
-        ].includes(atRule.name)) {
-            extractVariantAtRules(atRule);
-            atRule.before(atRule.nodes);
-            atRule.remove();
-        }
-    });
+function markInvalidUtilityCandidate(context, candidate) {
+    context.classCache.has(candidate) && (context.notClassCache.add(candidate), context.classCache.delete(candidate), context.applyClassCache.delete(candidate), context.candidateRuleMap.delete(candidate), context.candidateRuleCache.delete(candidate), context.stylesheetCache = null);
 }
-function collectLayerPlugins(root) {
-    let layerPlugins = [];
-    root.each((node)=>{
-        if (node.type === "atrule" && [
-            "responsive",
-            "variants"
-        ].includes(node.name)) {
-            node.name = "layer";
-            node.params = "utilities";
-        }
-    });
-    // Walk @layer rules and treat them like plugins
-    root.walkAtRules("layer", (layerRule)=>{
-        extractVariantAtRules(layerRule);
-        if (layerRule.params === "base") {
-            for (let node of layerRule.nodes){
-                layerPlugins.push(function({ addBase  }) {
-                    addBase(node, {
-                        respectPrefix: false
-                    });
-                });
+function createContext(tailwindConfig, changedContent = [], root = _postcss.default.root()) {
+    var _tailwindConfig_blocklist;
+    let corePluginList, userPlugins, layerPlugins;
+    let context = {
+        disposables: [],
+        ruleCache: new Set(),
+        candidateRuleCache: new Map(),
+        classCache: new Map(),
+        applyClassCache: new Map(),
+        notClassCache: new Set(null !== (_tailwindConfig_blocklist = tailwindConfig.blocklist) && void 0 !== _tailwindConfig_blocklist ? _tailwindConfig_blocklist : []),
+        postCssNodeCache: new Map(),
+        candidateRuleMap: new Map(),
+        tailwindConfig,
+        changedContent: changedContent,
+        variantMap: new Map(),
+        stylesheetCache: null,
+        variantOptions: new Map(),
+        markInvalidUtilityCandidate: (candidate)=>markInvalidUtilityCandidate(context, candidate),
+        markInvalidUtilityNode: (node)=>(function(context, node) {
+                let candidate = node.raws.tailwind.candidate;
+                if (candidate) {
+                    for (let entry of context.ruleCache)entry[1].raws.tailwind.candidate === candidate && context.ruleCache.delete(entry);
+                    markInvalidUtilityCandidate(context, candidate);
+                }
+            })(context, node)
+    };
+    return !function(plugins, context) {
+        var _context_tailwindConfig_safelist, _context_tailwindConfig_darkMode, _concat_;
+        let variantList = [], variantMap = new Map();
+        context.variantMap = variantMap;
+        let offsets = new _offsetsJs.Offsets();
+        context.offsets = offsets;
+        let classList = new Set(), pluginApi = function(tailwindConfig, context, { variantList , variantMap , offsets , classList  }) {
+            function getConfigValue(path, defaultValue) {
+                return path ? (0, _dlv.default)(tailwindConfig, path, defaultValue) : tailwindConfig;
             }
-            layerRule.remove();
-        } else if (layerRule.params === "components") {
-            for (let node of layerRule.nodes){
-                layerPlugins.push(function({ addComponents  }) {
-                    addComponents(node, {
-                        respectPrefix: false,
-                        preserveSource: true
-                    });
-                });
+            function prefixIdentifier(identifier, options) {
+                return identifier === _sharedState.NOT_ON_DEMAND ? _sharedState.NOT_ON_DEMAND : options.respectPrefix ? context.tailwindConfig.prefix + identifier : identifier;
             }
-            layerRule.remove();
-        } else if (layerRule.params === "utilities") {
-            for (let node of layerRule.nodes){
-                layerPlugins.push(function({ addUtilities  }) {
-                    addUtilities(node, {
-                        respectPrefix: false,
-                        preserveSource: true
+            let variantIdentifier = 0, api = {
+                postcss: _postcss.default,
+                prefix: function(selector) {
+                    return (0, _prefixSelector.default)(tailwindConfig.prefix, selector);
+                },
+                e: _escapeClassName.default,
+                config: getConfigValue,
+                theme: function(path, defaultValue, opts = {}) {
+                    let parts = (0, _toPath.toPath)(path), value = getConfigValue([
+                        "theme",
+                        ...parts
+                    ], defaultValue);
+                    return (0, _transformThemeValue.default)(parts[0])(value, opts);
+                },
+                corePlugins: (path)=>Array.isArray(tailwindConfig.corePlugins) ? tailwindConfig.corePlugins.includes(path) : getConfigValue([
+                        "corePlugins",
+                        path
+                    ], !0),
+                variants: ()=>[],
+                addBase (base) {
+                    for (let [identifier, rule] of withIdentifiers(base)){
+                        let prefixedIdentifier = prefixIdentifier(identifier, {}), offset = offsets.create("base");
+                        context.candidateRuleMap.has(prefixedIdentifier) || context.candidateRuleMap.set(prefixedIdentifier, []), context.candidateRuleMap.get(prefixedIdentifier).push([
+                            {
+                                sort: offset,
+                                layer: "base"
+                            },
+                            rule
+                        ]);
+                    }
+                },
+                addDefaults (group, declarations) {
+                    let groups = {
+                        [`@defaults ${group}`]: declarations
+                    };
+                    for (let [identifier, rule] of withIdentifiers(groups)){
+                        let prefixedIdentifier = prefixIdentifier(identifier, {});
+                        context.candidateRuleMap.has(prefixedIdentifier) || context.candidateRuleMap.set(prefixedIdentifier, []), context.candidateRuleMap.get(prefixedIdentifier).push([
+                            {
+                                sort: offsets.create("defaults"),
+                                layer: "defaults"
+                            },
+                            rule
+                        ]);
+                    }
+                },
+                addComponents (components, options) {
+                    for (let [identifier, rule] of (options = Object.assign({}, {
+                        preserveSource: !1,
+                        respectPrefix: !0,
+                        respectImportant: !1
+                    }, Array.isArray(options) ? {} : options), withIdentifiers(components))){
+                        let prefixedIdentifier = prefixIdentifier(identifier, options);
+                        classList.add(prefixedIdentifier), context.candidateRuleMap.has(prefixedIdentifier) || context.candidateRuleMap.set(prefixedIdentifier, []), context.candidateRuleMap.get(prefixedIdentifier).push([
+                            {
+                                sort: offsets.create("components"),
+                                layer: "components",
+                                options
+                            },
+                            rule
+                        ]);
+                    }
+                },
+                addUtilities (utilities, options) {
+                    for (let [identifier, rule] of (options = Object.assign({}, {
+                        preserveSource: !1,
+                        respectPrefix: !0,
+                        respectImportant: !0
+                    }, Array.isArray(options) ? {} : options), withIdentifiers(utilities))){
+                        let prefixedIdentifier = prefixIdentifier(identifier, options);
+                        classList.add(prefixedIdentifier), context.candidateRuleMap.has(prefixedIdentifier) || context.candidateRuleMap.set(prefixedIdentifier, []), context.candidateRuleMap.get(prefixedIdentifier).push([
+                            {
+                                sort: offsets.create("utilities"),
+                                layer: "utilities",
+                                options
+                            },
+                            rule
+                        ]);
+                    }
+                },
+                matchUtilities: function(utilities, options) {
+                    options = normalizeOptionTypes({
+                        respectPrefix: !0,
+                        respectImportant: !0,
+                        modifiers: !1,
+                        ...options
                     });
-                });
-            }
-            layerRule.remove();
-        }
-    });
-    return layerPlugins;
-}
-function resolvePlugins(context, root) {
-    let corePluginList = Object.entries({
-        ..._corePlugins.variantPlugins,
-        ..._corePlugins.corePlugins
-    }).map(([name, plugin])=>{
-        if (!context.tailwindConfig.corePlugins.includes(name)) {
-            return null;
-        }
-        return plugin;
-    }).filter(Boolean);
-    let userPlugins = context.tailwindConfig.plugins.map((plugin)=>{
-        if (plugin.__isOptionsFunction) {
-            plugin = plugin();
-        }
-        return typeof plugin === "function" ? plugin : plugin.handler;
-    });
-    let layerPlugins = collectLayerPlugins(root);
-    // TODO: This is a workaround for backwards compatibility, since custom variants
-    // were historically sorted before screen/stackable variants.
-    let beforeVariants = [
-        _corePlugins.variantPlugins["pseudoElementVariants"],
-        _corePlugins.variantPlugins["pseudoClassVariants"],
-        _corePlugins.variantPlugins["ariaVariants"],
-        _corePlugins.variantPlugins["dataVariants"]
-    ];
-    let afterVariants = [
-        _corePlugins.variantPlugins["supportsVariants"],
-        _corePlugins.variantPlugins["directionVariants"],
-        _corePlugins.variantPlugins["reducedMotionVariants"],
-        _corePlugins.variantPlugins["prefersContrastVariants"],
-        _corePlugins.variantPlugins["darkVariants"],
-        _corePlugins.variantPlugins["printVariant"],
-        _corePlugins.variantPlugins["screenVariants"],
-        _corePlugins.variantPlugins["orientationVariants"]
-    ];
-    return [
-        ...corePluginList,
-        ...beforeVariants,
-        ...userPlugins,
-        ...afterVariants,
-        ...layerPlugins
-    ];
-}
-function registerPlugins(plugins, context) {
-    let variantList = [];
-    let variantMap = new Map();
-    context.variantMap = variantMap;
-    let offsets = new _offsetsJs.Offsets();
-    context.offsets = offsets;
-    let classList = new Set();
-    let pluginApi = buildPluginApi(context.tailwindConfig, context, {
-        variantList,
-        variantMap,
-        offsets,
-        classList
-    });
-    for (let plugin of plugins){
-        if (Array.isArray(plugin)) {
-            for (let pluginItem of plugin){
-                pluginItem(pluginApi);
-            }
-        } else {
-            plugin === null || plugin === void 0 ? void 0 : plugin(pluginApi);
-        }
-    }
-    // Make sure to record bit masks for every variant
-    offsets.recordVariants(variantList, (variant)=>variantMap.get(variant).length);
-    // Build variantMap
-    for (let [variantName, variantFunctions] of variantMap.entries()){
-        context.variantMap.set(variantName, variantFunctions.map((variantFunction, idx)=>[
+                    let offset = offsets.create("utilities");
+                    for(let identifier in utilities){
+                        let prefixedIdentifier = prefixIdentifier(identifier, options), rule = utilities[identifier];
+                        function wrapped(modifier, { isOnlyPlugin  }) {
+                            let [value, coercedType, utilityModifier] = (0, _pluginUtils.coerceValue)(options.types, modifier, options, tailwindConfig);
+                            if (void 0 === value) return [];
+                            if (!options.types.some(({ type  })=>type === coercedType)) {
+                                if (!isOnlyPlugin) return [];
+                                _log.default.warn([
+                                    `Unnecessary typehint \`${coercedType}\` in \`${identifier}-${modifier}\`.`,
+                                    `You can safely update it to \`${identifier}-${modifier.replace(coercedType + ":", "")}\`.`
+                                ]);
+                            }
+                            if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) return [];
+                            let extras = {
+                                get modifier () {
+                                    return options.modifiers || _log.default.warn(`modifier-used-without-options-for-${identifier}`, [
+                                        "Your plugin must set `modifiers: true` in its options to support modifiers."
+                                    ]), utilityModifier;
+                                }
+                            };
+                            return [].concat((0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers") ? rule(value, extras) : rule(value)).filter(Boolean).map((declaration)=>({
+                                    [(0, _nameClass.default)(identifier, modifier)]: declaration
+                                }));
+                        }
+                        classList.add([
+                            prefixedIdentifier,
+                            options
+                        ]);
+                        let withOffsets = [
+                            {
+                                sort: offset,
+                                layer: "utilities",
+                                options
+                            },
+                            wrapped
+                        ];
+                        context.candidateRuleMap.has(prefixedIdentifier) || context.candidateRuleMap.set(prefixedIdentifier, []), context.candidateRuleMap.get(prefixedIdentifier).push(withOffsets);
+                    }
+                },
+                matchComponents: function(components, options) {
+                    options = normalizeOptionTypes({
+                        respectPrefix: !0,
+                        respectImportant: !1,
+                        modifiers: !1,
+                        ...options
+                    });
+                    let offset = offsets.create("components");
+                    for(let identifier in components){
+                        let prefixedIdentifier = prefixIdentifier(identifier, options), rule = components[identifier];
+                        function wrapped(modifier, { isOnlyPlugin  }) {
+                            let [value, coercedType, utilityModifier] = (0, _pluginUtils.coerceValue)(options.types, modifier, options, tailwindConfig);
+                            if (void 0 === value) return [];
+                            if (!options.types.some(({ type  })=>type === coercedType)) {
+                                if (!isOnlyPlugin) return [];
+                                _log.default.warn([
+                                    `Unnecessary typehint \`${coercedType}\` in \`${identifier}-${modifier}\`.`,
+                                    `You can safely update it to \`${identifier}-${modifier.replace(coercedType + ":", "")}\`.`
+                                ]);
+                            }
+                            if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) return [];
+                            let extras = {
+                                get modifier () {
+                                    return options.modifiers || _log.default.warn(`modifier-used-without-options-for-${identifier}`, [
+                                        "Your plugin must set `modifiers: true` in its options to support modifiers."
+                                    ]), utilityModifier;
+                                }
+                            };
+                            return [].concat((0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers") ? rule(value, extras) : rule(value)).filter(Boolean).map((declaration)=>({
+                                    [(0, _nameClass.default)(identifier, modifier)]: declaration
+                                }));
+                        }
+                        classList.add([
+                            prefixedIdentifier,
+                            options
+                        ]);
+                        let withOffsets = [
+                            {
+                                sort: offset,
+                                layer: "components",
+                                options
+                            },
+                            wrapped
+                        ];
+                        context.candidateRuleMap.has(prefixedIdentifier) || context.candidateRuleMap.set(prefixedIdentifier, []), context.candidateRuleMap.get(prefixedIdentifier).push(withOffsets);
+                    }
+                },
+                addVariant (variantName, variantFunctions, options = {}) {
+                    variantFunctions = [].concat(variantFunctions).map((variantFunction)=>{
+                        if ("string" != typeof variantFunction) return (api = {})=>{
+                            let { args , modifySelectors , container , separator , wrap , format  } = api, result = variantFunction(Object.assign({
+                                modifySelectors,
+                                container,
+                                separator
+                            }, options.type === VARIANT_TYPES.MatchVariant && {
+                                args,
+                                wrap,
+                                format
+                            }));
+                            if ("string" == typeof result && !isValidVariantFormatString(result)) throw Error(`Your custom variant \`${variantName}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`);
+                            return Array.isArray(result) ? result.filter((variant)=>"string" == typeof variant).map((variant)=>parseVariant(variant)) : result && "string" == typeof result && parseVariant(result)(api);
+                        };
+                        if (!isValidVariantFormatString(variantFunction)) throw Error(`Your custom variant \`${variantName}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`);
+                        return parseVariant(variantFunction);
+                    }), function(list, value, { before =[]  } = {}) {
+                        if ((before = [].concat(before)).length <= 0) {
+                            list.push(value);
+                            return;
+                        }
+                        let idx = list.length - 1;
+                        for (let other of before){
+                            let iidx = list.indexOf(other);
+                            -1 !== iidx && (idx = Math.min(idx, iidx));
+                        }
+                        list.splice(idx, 0, value);
+                    }(variantList, variantName, options), variantMap.set(variantName, variantFunctions), context.variantOptions.set(variantName, options);
+                },
+                matchVariant (variant, variantFn, options) {
+                    var _options_id, _options_values, _options_values1;
+                    let id = null !== (_options_id = null == options ? void 0 : options.id) && void 0 !== _options_id ? _options_id : ++variantIdentifier, isSpecial = "@" === variant, modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
+                    for (let [key, value] of Object.entries(null !== (_options_values = null == options ? void 0 : options.values) && void 0 !== _options_values ? _options_values : {}))"DEFAULT" !== key && api.addVariant(isSpecial ? `${variant}${key}` : `${variant}-${key}`, ({ args , container  })=>variantFn(value, modifiersEnabled ? {
+                            modifier: null == args ? void 0 : args.modifier,
+                            container
+                        } : {
+                            container
+                        }), {
+                        ...options,
+                        value,
+                        id,
+                        type: VARIANT_TYPES.MatchVariant,
+                        variantInfo: VARIANT_INFO.Base
+                    });
+                    let hasDefault = "DEFAULT" in (null !== (_options_values1 = null == options ? void 0 : options.values) && void 0 !== _options_values1 ? _options_values1 : {});
+                    api.addVariant(variant, ({ args , container  })=>{
+                        var _args_value;
+                        return (null == args ? void 0 : args.value) !== _sharedState.NONE || hasDefault ? variantFn((null == args ? void 0 : args.value) === _sharedState.NONE ? options.values.DEFAULT : null !== (_args_value = null == args ? void 0 : args.value) && void 0 !== _args_value ? _args_value : "string" == typeof args ? args : "", modifiersEnabled ? {
+                            modifier: null == args ? void 0 : args.modifier,
+                            container
+                        } : {
+                            container
+                        }) : null;
+                    }, {
+                        ...options,
+                        id,
+                        type: VARIANT_TYPES.MatchVariant,
+                        variantInfo: VARIANT_INFO.Dynamic
+                    });
+                }
+            };
+            return api;
+        }(context.tailwindConfig, context, {
+            variantList,
+            variantMap,
+            offsets,
+            classList
+        });
+        for (let plugin of plugins)if (Array.isArray(plugin)) for (let pluginItem of plugin)pluginItem(pluginApi);
+        else null == plugin || plugin(pluginApi);
+        for (let [variantName, variantFunctions] of (offsets.recordVariants(variantList, (variant)=>variantMap.get(variant).length), variantMap.entries()))context.variantMap.set(variantName, variantFunctions.map((variantFunction, idx)=>[
                 offsets.forVariant(variantName, idx),
                 variantFunction
             ]));
-    }
-    var _context_tailwindConfig_safelist;
-    let safelist = ((_context_tailwindConfig_safelist = context.tailwindConfig.safelist) !== null && _context_tailwindConfig_safelist !== void 0 ? _context_tailwindConfig_safelist : []).filter(Boolean);
-    if (safelist.length > 0) {
-        let checks = [];
-        for (let value of safelist){
-            if (typeof value === "string") {
-                context.changedContent.push({
-                    content: value,
-                    extension: "html"
-                });
-                continue;
-            }
-            if (value instanceof RegExp) {
-                _log.default.warn("root-regex", [
-                    "Regular expressions in `safelist` work differently in Tailwind CSS v3.0.",
-                    "Update your `safelist` configuration to eliminate this warning.",
-                    "https://tailwindcss.com/docs/content-configuration#safelisting-classes"
-                ]);
-                continue;
+        let safelist = (null !== (_context_tailwindConfig_safelist = context.tailwindConfig.safelist) && void 0 !== _context_tailwindConfig_safelist ? _context_tailwindConfig_safelist : []).filter(Boolean);
+        if (safelist.length > 0) {
+            let checks = [];
+            for (let value of safelist){
+                if ("string" == typeof value) {
+                    context.changedContent.push({
+                        content: value,
+                        extension: "html"
+                    });
+                    continue;
+                }
+                if (value instanceof RegExp) {
+                    _log.default.warn("root-regex", [
+                        "Regular expressions in `safelist` work differently in Tailwind CSS v3.0.",
+                        "Update your `safelist` configuration to eliminate this warning.",
+                        "https://tailwindcss.com/docs/content-configuration#safelisting-classes"
+                    ]);
+                    continue;
+                }
+                checks.push(value);
             }
-            checks.push(value);
-        }
-        if (checks.length > 0) {
-            let patternMatchingCount = new Map();
-            let prefixLength = context.tailwindConfig.prefix.length;
-            let checkImportantUtils = checks.some((check)=>check.pattern.source.includes("!"));
-            for (let util of classList){
-                let utils = Array.isArray(util) ? (()=>{
-                    let [utilName, options] = util;
+            if (checks.length > 0) {
+                let patternMatchingCount = new Map(), prefixLength = context.tailwindConfig.prefix.length, checkImportantUtils = checks.some((check)=>check.pattern.source.includes("!"));
+                for (let util of classList)for (let util1 of Array.isArray(util) ? (()=>{
                     var _options_values;
-                    let values = Object.keys((_options_values = options === null || options === void 0 ? void 0 : options.values) !== null && _options_values !== void 0 ? _options_values : {});
-                    let classes = values.map((value)=>(0, _nameClass.formatClass)(utilName, value));
-                    if (options === null || options === void 0 ? void 0 : options.supportsNegativeValues) {
-                        // This is the normal negated version
-                        // e.g. `-inset-1` or `-tw-inset-1`
-                        classes = [
+                    let [utilName, options] = util, classes = Object.keys(null !== (_options_values = null == options ? void 0 : options.values) && void 0 !== _options_values ? _options_values : {}).map((value)=>(0, _nameClass.formatClass)(utilName, value));
+                    return (null == options ? void 0 : options.supportsNegativeValues) && (classes = [
+                        ...classes = [
                             ...classes,
                             ...classes.map((cls)=>"-" + cls)
-                        ];
-                        // This is the negated version *after* the prefix
-                        // e.g. `tw--inset-1`
-                        // The prefix is already attached to util name
-                        // So we add the negative after the prefix
-                        classes = [
-                            ...classes,
-                            ...classes.map((cls)=>cls.slice(0, prefixLength) + "-" + cls.slice(prefixLength))
-                        ];
-                    }
-                    if (options.types.some(({ type  })=>type === "color")) {
-                        classes = [
-                            ...classes,
-                            ...classes.flatMap((cls)=>Object.keys(context.tailwindConfig.theme.opacity).map((opacity)=>`${cls}/${opacity}`))
-                        ];
-                    }
-                    if (checkImportantUtils && (options === null || options === void 0 ? void 0 : options.respectImportant)) {
-                        classes = [
-                            ...classes,
-                            ...classes.map((cls)=>"!" + cls)
-                        ];
-                    }
-                    return classes;
+                        ],
+                        ...classes.map((cls)=>cls.slice(0, prefixLength) + "-" + cls.slice(prefixLength))
+                    ]), options.types.some(({ type  })=>"color" === type) && (classes = [
+                        ...classes,
+                        ...classes.flatMap((cls)=>Object.keys(context.tailwindConfig.theme.opacity).map((opacity)=>`${cls}/${opacity}`))
+                    ]), checkImportantUtils && (null == options ? void 0 : options.respectImportant) && (classes = [
+                        ...classes,
+                        ...classes.map((cls)=>"!" + cls)
+                    ]), classes;
                 })() : [
                     util
-                ];
-                for (let util of utils){
-                    for (let { pattern , variants =[]  } of checks){
-                        // RegExp with the /g flag are stateful, so let's reset the last
-                        // index pointer to reset the state.
-                        pattern.lastIndex = 0;
-                        if (!patternMatchingCount.has(pattern)) {
-                            patternMatchingCount.set(pattern, 0);
-                        }
-                        if (!pattern.test(util)) continue;
-                        patternMatchingCount.set(pattern, patternMatchingCount.get(pattern) + 1);
-                        context.changedContent.push({
-                            content: util,
-                            extension: "html"
-                        });
-                        for (let variant of variants){
-                            context.changedContent.push({
-                                content: variant + context.tailwindConfig.separator + util,
-                                extension: "html"
-                            });
-                        }
-                    }
-                }
-            }
-            for (let [regex, count] of patternMatchingCount.entries()){
-                if (count !== 0) continue;
-                _log.default.warn([
+                ])for (let { pattern , variants =[]  } of checks)if (pattern.lastIndex = 0, patternMatchingCount.has(pattern) || patternMatchingCount.set(pattern, 0), pattern.test(util1)) for (let variant of (patternMatchingCount.set(pattern, patternMatchingCount.get(pattern) + 1), context.changedContent.push({
+                    content: util1,
+                    extension: "html"
+                }), variants))context.changedContent.push({
+                    content: variant + context.tailwindConfig.separator + util1,
+                    extension: "html"
+                });
+                for (let [regex, count] of patternMatchingCount.entries())0 === count && _log.default.warn([
                     `The safelist pattern \`${regex}\` doesn't match any Tailwind CSS classes.`,
                     "Fix this pattern or remove it from your `safelist` configuration.",
                     "https://tailwindcss.com/docs/content-configuration#safelisting-classes"
                 ]);
             }
         }
-    }
-    var _context_tailwindConfig_darkMode, _concat_;
-    let darkClassName = (_concat_ = [].concat((_context_tailwindConfig_darkMode = context.tailwindConfig.darkMode) !== null && _context_tailwindConfig_darkMode !== void 0 ? _context_tailwindConfig_darkMode : "media")[1]) !== null && _concat_ !== void 0 ? _concat_ : "dark";
-    // A list of utilities that are used by certain Tailwind CSS utilities but
-    // that don't exist on their own. This will result in them "not existing" and
-    // sorting could be weird since you still require them in order to make the
-    // host utilities work properly. (Thanks Biology)
-    let parasiteUtilities = [
-        prefix(context, darkClassName),
-        prefix(context, "group"),
-        prefix(context, "peer")
-    ];
-    context.getClassOrder = function getClassOrder(classes) {
-        // Sort classes so they're ordered in a deterministic manner
-        let sorted = [
-            ...classes
-        ].sort((a, z)=>{
-            if (a === z) return 0;
-            if (a < z) return -1;
-            return 1;
-        });
-        // Non-util classes won't be generated, so we default them to null
-        let sortedClassNames = new Map(sorted.map((className)=>[
-                className,
-                null
-            ]));
-        // Sort all classes in order
-        // Non-tailwind classes won't be generated and will be left as `null`
-        let rules = (0, _generateRules.generateRules)(new Set(sorted), context);
-        rules = context.offsets.sort(rules);
-        let idx = BigInt(parasiteUtilities.length);
-        for (const [, rule] of rules){
-            sortedClassNames.set(rule.raws.tailwind.candidate, idx++);
-        }
-        return classes.map((className)=>{
-            var _sortedClassNames_get;
-            let order = (_sortedClassNames_get = sortedClassNames.get(className)) !== null && _sortedClassNames_get !== void 0 ? _sortedClassNames_get : null;
-            let parasiteIndex = parasiteUtilities.indexOf(className);
-            if (order === null && parasiteIndex !== -1) {
-                // This will make sure that it is at the very beginning of the
-                // `components` layer which technically means 'before any
-                // components'.
-                order = BigInt(parasiteIndex);
-            }
-            return [
-                className,
-                order
-            ];
-        });
-    };
-    // Generate a list of strings for autocompletion purposes, e.g.
-    // ['uppercase', 'lowercase', ...]
-    context.getClassList = function getClassList(options = {}) {
-        let output = [];
-        for (let util of classList){
-            if (Array.isArray(util)) {
-                var _utilOptions_types;
-                let [utilName, utilOptions] = util;
-                let negativeClasses = [];
-                var _utilOptions_modifiers;
-                let modifiers = Object.keys((_utilOptions_modifiers = utilOptions === null || utilOptions === void 0 ? void 0 : utilOptions.modifiers) !== null && _utilOptions_modifiers !== void 0 ? _utilOptions_modifiers : {});
-                if (utilOptions === null || utilOptions === void 0 ? void 0 : (_utilOptions_types = utilOptions.types) === null || _utilOptions_types === void 0 ? void 0 : _utilOptions_types.some(({ type  })=>type === "color")) {
-                    var _context_tailwindConfig_theme_opacity;
-                    modifiers.push(...Object.keys((_context_tailwindConfig_theme_opacity = context.tailwindConfig.theme.opacity) !== null && _context_tailwindConfig_theme_opacity !== void 0 ? _context_tailwindConfig_theme_opacity : {}));
-                }
+        let darkClassName = null !== (_concat_ = [].concat(null !== (_context_tailwindConfig_darkMode = context.tailwindConfig.darkMode) && void 0 !== _context_tailwindConfig_darkMode ? _context_tailwindConfig_darkMode : "media")[1]) && void 0 !== _concat_ ? _concat_ : "dark", parasiteUtilities = [
+            prefix(context, darkClassName),
+            prefix(context, "group"),
+            prefix(context, "peer")
+        ];
+        context.getClassOrder = function(classes) {
+            let sorted = [
+                ...classes
+            ].sort((a, z)=>a === z ? 0 : a < z ? -1 : 1), sortedClassNames = new Map(sorted.map((className)=>[
+                    className,
+                    null
+                ])), rules = (0, _generateRules.generateRules)(new Set(sorted), context);
+            rules = context.offsets.sort(rules);
+            let idx = BigInt(parasiteUtilities.length);
+            for (let [, rule] of rules)sortedClassNames.set(rule.raws.tailwind.candidate, idx++);
+            return classes.map((className)=>{
+                var _sortedClassNames_get;
+                let order = null !== (_sortedClassNames_get = sortedClassNames.get(className)) && void 0 !== _sortedClassNames_get ? _sortedClassNames_get : null, parasiteIndex = parasiteUtilities.indexOf(className);
+                return null === order && -1 !== parasiteIndex && (order = BigInt(parasiteIndex)), [
+                    className,
+                    order
+                ];
+            });
+        }, context.getClassList = function(options = {}) {
+            let output = [];
+            for (let util of classList)if (Array.isArray(util)) {
+                var _utilOptions_types, _utilOptions_modifiers, _context_tailwindConfig_theme_opacity, _utilOptions_values;
+                let [utilName, utilOptions] = util, negativeClasses = [], modifiers = Object.keys(null !== (_utilOptions_modifiers = null == utilOptions ? void 0 : utilOptions.modifiers) && void 0 !== _utilOptions_modifiers ? _utilOptions_modifiers : {});
+                (null == utilOptions ? void 0 : null === (_utilOptions_types = utilOptions.types) || void 0 === _utilOptions_types ? void 0 : _utilOptions_types.some(({ type  })=>"color" === type)) && modifiers.push(...Object.keys(null !== (_context_tailwindConfig_theme_opacity = context.tailwindConfig.theme.opacity) && void 0 !== _context_tailwindConfig_theme_opacity ? _context_tailwindConfig_theme_opacity : {}));
                 let metadata = {
                     modifiers
-                };
-                let includeMetadata = options.includeMetadata && modifiers.length > 0;
-                var _utilOptions_values;
-                for (let [key, value] of Object.entries((_utilOptions_values = utilOptions === null || utilOptions === void 0 ? void 0 : utilOptions.values) !== null && _utilOptions_values !== void 0 ? _utilOptions_values : {})){
-                    // Ignore undefined and null values
-                    if (value == null) {
-                        continue;
-                    }
+                }, includeMetadata = options.includeMetadata && modifiers.length > 0;
+                for (let [key, value] of Object.entries(null !== (_utilOptions_values = null == utilOptions ? void 0 : utilOptions.values) && void 0 !== _utilOptions_values ? _utilOptions_values : {})){
+                    if (null == value) continue;
                     let cls = (0, _nameClass.formatClass)(utilName, key);
-                    output.push(includeMetadata ? [
+                    if (output.push(includeMetadata ? [
                         cls,
                         metadata
-                    ] : cls);
-                    if ((utilOptions === null || utilOptions === void 0 ? void 0 : utilOptions.supportsNegativeValues) && (0, _negateValue.default)(value)) {
+                    ] : cls), (null == utilOptions ? void 0 : utilOptions.supportsNegativeValues) && (0, _negateValue.default)(value)) {
                         let cls = (0, _nameClass.formatClass)(utilName, `-${key}`);
                         negativeClasses.push(includeMetadata ? [
                             cls,
@@ -971,254 +548,162 @@ function registerPlugins(plugins, context) {
                     }
                 }
                 output.push(...negativeClasses);
-            } else {
-                output.push(util);
-            }
-        }
-        return output;
-    };
-    // Generate a list of available variants with meta information of the type of variant.
-    context.getVariants = function getVariants() {
-        let result = [];
-        for (let [name, options] of context.variantOptions.entries()){
-            if (options.variantInfo === VARIANT_INFO.Base) continue;
-            var _options_values;
-            result.push({
-                name,
-                isArbitrary: options.type === Symbol.for("MATCH_VARIANT"),
-                values: Object.keys((_options_values = options.values) !== null && _options_values !== void 0 ? _options_values : {}),
-                hasDash: name !== "@",
-                selectors ({ modifier , value  } = {}) {
-                    let candidate = "__TAILWIND_PLACEHOLDER__";
-                    let rule = _postcss.default.rule({
-                        selector: `.${candidate}`
-                    });
-                    let container = _postcss.default.root({
-                        nodes: [
-                            rule.clone()
-                        ]
-                    });
-                    let before = container.toString();
-                    var _context_variantMap_get;
-                    let fns = ((_context_variantMap_get = context.variantMap.get(name)) !== null && _context_variantMap_get !== void 0 ? _context_variantMap_get : []).flatMap(([_, fn])=>fn);
-                    let formatStrings = [];
-                    for (let fn of fns){
-                        var _options_values;
-                        let localFormatStrings = [];
-                        var _options_values_value;
-                        let api = {
-                            args: {
-                                modifier,
-                                value: (_options_values_value = (_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[value]) !== null && _options_values_value !== void 0 ? _options_values_value : value
-                            },
-                            separator: context.tailwindConfig.separator,
-                            modifySelectors (modifierFunction) {
-                                // Run the modifierFunction over each rule
-                                container.each((rule)=>{
-                                    if (rule.type !== "rule") {
-                                        return;
-                                    }
-                                    rule.selectors = rule.selectors.map((selector)=>{
-                                        return modifierFunction({
-                                            get className () {
-                                                return (0, _generateRules.getClassNameFromSelector)(selector);
-                                            },
-                                            selector
-                                        });
-                                    });
-                                });
-                                return container;
-                            },
-                            format (str) {
-                                localFormatStrings.push(str);
-                            },
-                            wrap (wrapper) {
-                                localFormatStrings.push(`@${wrapper.name} ${wrapper.params} { & }`);
-                            },
-                            container
-                        };
-                        let ruleWithVariant = fn(api);
-                        if (localFormatStrings.length > 0) {
-                            formatStrings.push(localFormatStrings);
-                        }
-                        if (Array.isArray(ruleWithVariant)) {
-                            for (let variantFunction of ruleWithVariant){
-                                localFormatStrings = [];
-                                variantFunction(api);
-                                formatStrings.push(localFormatStrings);
-                            }
+            } else output.push(util);
+            return output;
+        }, context.getVariants = function() {
+            let result = [];
+            for (let [name, options] of context.variantOptions.entries()){
+                var _options_values;
+                options.variantInfo !== VARIANT_INFO.Base && result.push({
+                    name,
+                    isArbitrary: options.type === Symbol.for("MATCH_VARIANT"),
+                    values: Object.keys(null !== (_options_values = options.values) && void 0 !== _options_values ? _options_values : {}),
+                    hasDash: "@" !== name,
+                    selectors ({ modifier , value  } = {}) {
+                        var _context_variantMap_get, _options_values, _options_values_value, _options_values1;
+                        let candidate = "__TAILWIND_PLACEHOLDER__", rule = _postcss.default.rule({
+                            selector: `.${candidate}`
+                        }), container = _postcss.default.root({
+                            nodes: [
+                                rule.clone()
+                            ]
+                        }), before = container.toString(), fns = (null !== (_context_variantMap_get = context.variantMap.get(name)) && void 0 !== _context_variantMap_get ? _context_variantMap_get : []).flatMap(([_, fn])=>fn), formatStrings = [];
+                        for (let fn of fns){
+                            let localFormatStrings = [], api = {
+                                args: {
+                                    modifier,
+                                    value: null !== (_options_values_value = null === (_options_values = options.values) || void 0 === _options_values ? void 0 : _options_values[value]) && void 0 !== _options_values_value ? _options_values_value : value
+                                },
+                                separator: context.tailwindConfig.separator,
+                                modifySelectors: (modifierFunction)=>(container.each((rule)=>{
+                                        "rule" === rule.type && (rule.selectors = rule.selectors.map((selector)=>modifierFunction({
+                                                get className () {
+                                                    return (0, _generateRules.getClassNameFromSelector)(selector);
+                                                },
+                                                selector
+                                            })));
+                                    }), container),
+                                format (str) {
+                                    localFormatStrings.push(str);
+                                },
+                                wrap (wrapper) {
+                                    localFormatStrings.push(`@${wrapper.name} ${wrapper.params} { & }`);
+                                },
+                                container
+                            }, ruleWithVariant = fn(api);
+                            if (localFormatStrings.length > 0 && formatStrings.push(localFormatStrings), Array.isArray(ruleWithVariant)) for (let variantFunction of ruleWithVariant)localFormatStrings = [], variantFunction(api), formatStrings.push(localFormatStrings);
                         }
-                    }
-                    // Reverse engineer the result of the `container`
-                    let manualFormatStrings = [];
-                    let after = container.toString();
-                    if (before !== after) {
-                        // Figure out all selectors
-                        container.walkRules((rule)=>{
-                            let modified = rule.selector;
-                            // Rebuild the base selector, this is what plugin authors would do
-                            // as well. E.g.: `${variant}${separator}${className}`.
-                            // However, plugin authors probably also prepend or append certain
-                            // classes, pseudos, ids, ...
-                            let rebuiltBase = (0, _postcssSelectorParser.default)((selectors)=>{
+                        let manualFormatStrings = [];
+                        before !== container.toString() && (container.walkRules((rule)=>{
+                            let modified = rule.selector, rebuiltBase = (0, _postcssSelectorParser.default)((selectors)=>{
                                 selectors.walkClasses((classNode)=>{
                                     classNode.value = `${name}${context.tailwindConfig.separator}${classNode.value}`;
                                 });
                             }).processSync(modified);
-                            // Now that we know the original selector, the new selector, and
-                            // the rebuild part in between, we can replace the part that plugin
-                            // authors need to rebuild with `&`, and eventually store it in the
-                            // collectedFormats. Similar to what `format('...')` would do.
-                            //
-                            // E.g.:
-                            //                   variant: foo
-                            //                  selector: .markdown > p
-                            //      modified (by plugin): .foo .foo\\:markdown > p
-                            //    rebuiltBase (internal): .foo\\:markdown > p
-                            //                    format: .foo &
                             manualFormatStrings.push(modified.replace(rebuiltBase, "&").replace(candidate, "&"));
-                        });
-                        // Figure out all atrules
-                        container.walkAtRules((atrule)=>{
+                        }), container.walkAtRules((atrule)=>{
                             manualFormatStrings.push(`@${atrule.name} (${atrule.params}) { & }`);
-                        });
-                    }
-                    var _options_values1;
-                    let isArbitraryVariant = !(value in ((_options_values1 = options.values) !== null && _options_values1 !== void 0 ? _options_values1 : {}));
-                    formatStrings = formatStrings.map((format)=>format.map((str)=>({
-                                format: str,
-                                isArbitraryVariant
-                            })));
-                    manualFormatStrings = manualFormatStrings.map((format)=>({
-                            format,
-                            isArbitraryVariant
                         }));
-                    let opts = {
-                        candidate,
-                        context
-                    };
-                    let result = formatStrings.map((formats)=>(0, _formatVariantSelector.finalizeSelector)(`.${candidate}`, (0, _formatVariantSelector.formatVariantSelector)(formats, opts), opts).replace(`.${candidate}`, "&").replace("{ & }", "").trim());
-                    if (manualFormatStrings.length > 0) {
-                        result.push((0, _formatVariantSelector.formatVariantSelector)(manualFormatStrings, opts).toString().replace(`.${candidate}`, "&"));
+                        let isArbitraryVariant = !(value in (null !== (_options_values1 = options.values) && void 0 !== _options_values1 ? _options_values1 : {}));
+                        formatStrings = formatStrings.map((format)=>format.map((str)=>({
+                                    format: str,
+                                    isArbitraryVariant
+                                }))), manualFormatStrings = manualFormatStrings.map((format)=>({
+                                format,
+                                isArbitraryVariant
+                            }));
+                        let opts = {
+                            candidate,
+                            context
+                        }, result = formatStrings.map((formats)=>(0, _formatVariantSelector.finalizeSelector)(`.${candidate}`, (0, _formatVariantSelector.formatVariantSelector)(formats, opts), opts).replace(`.${candidate}`, "&").replace("{ & }", "").trim());
+                        return manualFormatStrings.length > 0 && result.push((0, _formatVariantSelector.formatVariantSelector)(manualFormatStrings, opts).toString().replace(`.${candidate}`, "&")), result;
                     }
-                    return result;
-                }
+                });
+            }
+            return result;
+        };
+    }((corePluginList = Object.entries({
+        ..._corePlugins.variantPlugins,
+        ..._corePlugins.corePlugins
+    }).map(([name, plugin])=>context.tailwindConfig.corePlugins.includes(name) ? plugin : null).filter(Boolean), userPlugins = context.tailwindConfig.plugins.map((plugin)=>(plugin.__isOptionsFunction && (plugin = plugin()), "function" == typeof plugin ? plugin : plugin.handler)), layerPlugins = [], root.each((node)=>{
+        "atrule" === node.type && [
+            "responsive",
+            "variants"
+        ].includes(node.name) && (node.name = "layer", node.params = "utilities");
+    }), root.walkAtRules("layer", (layerRule)=>{
+        if (function extractVariantAtRules(node) {
+            node.walkAtRules((atRule)=>{
+                [
+                    "responsive",
+                    "variants"
+                ].includes(atRule.name) && (extractVariantAtRules(atRule), atRule.before(atRule.nodes), atRule.remove());
             });
+        }(layerRule), "base" === layerRule.params) {
+            for (let node of layerRule.nodes)layerPlugins.push(function({ addBase  }) {
+                addBase(node, {
+                    respectPrefix: !1
+                });
+            });
+            layerRule.remove();
+        } else if ("components" === layerRule.params) {
+            for (let node of layerRule.nodes)layerPlugins.push(function({ addComponents  }) {
+                addComponents(node, {
+                    respectPrefix: !1,
+                    preserveSource: !0
+                });
+            });
+            layerRule.remove();
+        } else if ("utilities" === layerRule.params) {
+            for (let node of layerRule.nodes)layerPlugins.push(function({ addUtilities  }) {
+                addUtilities(node, {
+                    respectPrefix: !1,
+                    preserveSource: !0
+                });
+            });
+            layerRule.remove();
         }
-        return result;
-    };
-}
-/**
- * Mark as class as retroactively invalid
- *
- *
- * @param {string} candidate
- */ function markInvalidUtilityCandidate(context, candidate) {
-    if (!context.classCache.has(candidate)) {
-        return;
-    }
-    // Mark this as not being a real utility
-    context.notClassCache.add(candidate);
-    // Remove it from any candidate-specific caches
-    context.classCache.delete(candidate);
-    context.applyClassCache.delete(candidate);
-    context.candidateRuleMap.delete(candidate);
-    context.candidateRuleCache.delete(candidate);
-    // Ensure the stylesheet gets rebuilt
-    context.stylesheetCache = null;
-}
-/**
- * Mark as class as retroactively invalid
- *
- * @param {import('postcss').Node} node
- */ function markInvalidUtilityNode(context, node) {
-    let candidate = node.raws.tailwind.candidate;
-    if (!candidate) {
-        return;
-    }
-    for (const entry of context.ruleCache){
-        if (entry[1].raws.tailwind.candidate === candidate) {
-            context.ruleCache.delete(entry);
-        // context.postCssNodeCache.delete(node)
-        }
-    }
-    markInvalidUtilityCandidate(context, candidate);
-}
-function createContext(tailwindConfig, changedContent = [], root = _postcss.default.root()) {
-    var _tailwindConfig_blocklist;
-    let context = {
-        disposables: [],
-        ruleCache: new Set(),
-        candidateRuleCache: new Map(),
-        classCache: new Map(),
-        applyClassCache: new Map(),
-        // Seed the not class cache with the blocklist (which is only strings)
-        notClassCache: new Set((_tailwindConfig_blocklist = tailwindConfig.blocklist) !== null && _tailwindConfig_blocklist !== void 0 ? _tailwindConfig_blocklist : []),
-        postCssNodeCache: new Map(),
-        candidateRuleMap: new Map(),
-        tailwindConfig,
-        changedContent: changedContent,
-        variantMap: new Map(),
-        stylesheetCache: null,
-        variantOptions: new Map(),
-        markInvalidUtilityCandidate: (candidate)=>markInvalidUtilityCandidate(context, candidate),
-        markInvalidUtilityNode: (node)=>markInvalidUtilityNode(context, node)
-    };
-    let resolvedPlugins = resolvePlugins(context, root);
-    registerPlugins(resolvedPlugins, context);
-    return context;
+    }), [
+        ...corePluginList,
+        _corePlugins.variantPlugins.pseudoElementVariants,
+        _corePlugins.variantPlugins.pseudoClassVariants,
+        _corePlugins.variantPlugins.ariaVariants,
+        _corePlugins.variantPlugins.dataVariants,
+        ...userPlugins,
+        _corePlugins.variantPlugins.supportsVariants,
+        _corePlugins.variantPlugins.directionVariants,
+        _corePlugins.variantPlugins.reducedMotionVariants,
+        _corePlugins.variantPlugins.prefersContrastVariants,
+        _corePlugins.variantPlugins.darkVariants,
+        _corePlugins.variantPlugins.printVariant,
+        _corePlugins.variantPlugins.screenVariants,
+        _corePlugins.variantPlugins.orientationVariants,
+        ...layerPlugins
+    ]), context), context;
 }
-let contextMap = _sharedState.contextMap;
-let configContextMap = _sharedState.configContextMap;
-let contextSourcesMap = _sharedState.contextSourcesMap;
+let contextMap = _sharedState.contextMap, configContextMap = _sharedState.configContextMap, contextSourcesMap = _sharedState.contextSourcesMap;
 function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies) {
-    let sourcePath = result.opts.from;
-    let isConfigFile = userConfigPath !== null;
-    _sharedState.env.DEBUG && console.log("Source path:", sourcePath);
-    let existingContext;
-    if (isConfigFile && contextMap.has(sourcePath)) {
-        existingContext = contextMap.get(sourcePath);
-    } else if (configContextMap.has(tailwindConfigHash)) {
+    let existingContext, sourcePath = result.opts.from;
+    if (_sharedState.env.DEBUG && console.log("Source path:", sourcePath), null !== userConfigPath && contextMap.has(sourcePath)) existingContext = contextMap.get(sourcePath);
+    else if (configContextMap.has(tailwindConfigHash)) {
         let context = configContextMap.get(tailwindConfigHash);
-        contextSourcesMap.get(context).add(sourcePath);
-        contextMap.set(sourcePath, context);
-        existingContext = context;
+        contextSourcesMap.get(context).add(sourcePath), contextMap.set(sourcePath, context), existingContext = context;
     }
     let cssDidChange = (0, _cacheInvalidationJs.hasContentChanged)(sourcePath, root);
-    // If there's already a context in the cache and we don't need to
-    // reset the context, return the cached context.
     if (existingContext) {
         let [contextDependenciesChanged, mtimesToCommit] = trackModified([
             ...contextDependencies
         ], getFileModifiedMap(existingContext));
-        if (!contextDependenciesChanged && !cssDidChange) {
-            return [
-                existingContext,
-                false,
-                mtimesToCommit
-            ];
-        }
+        if (!contextDependenciesChanged && !cssDidChange) return [
+            existingContext,
+            !1,
+            mtimesToCommit
+        ];
     }
-    // If this source is in the context map, get the old context.
-    // Remove this source from the context sources for the old context,
-    // and clean up that context if no one else is using it. This can be
-    // called by many processes in rapid succession, so we check for presence
-    // first because the first process to run this code will wipe it out first.
     if (contextMap.has(sourcePath)) {
         let oldContext = contextMap.get(sourcePath);
-        if (contextSourcesMap.has(oldContext)) {
-            contextSourcesMap.get(oldContext).delete(sourcePath);
-            if (contextSourcesMap.get(oldContext).size === 0) {
-                contextSourcesMap.delete(oldContext);
-                for (let [tailwindConfigHash, context] of configContextMap){
-                    if (context === oldContext) {
-                        configContextMap.delete(tailwindConfigHash);
-                    }
-                }
-                for (let disposable of oldContext.disposables.splice(0)){
-                    disposable(oldContext);
-                }
-            }
+        if (contextSourcesMap.has(oldContext) && (contextSourcesMap.get(oldContext).delete(sourcePath), 0 === contextSourcesMap.get(oldContext).size)) {
+            for (let [tailwindConfigHash, context] of (contextSourcesMap.delete(oldContext), configContextMap))context === oldContext && configContextMap.delete(tailwindConfigHash);
+            for (let disposable of oldContext.disposables.splice(0))disposable(oldContext);
         }
     }
     _sharedState.env.DEBUG && console.log("Setting up new context...");
@@ -1229,17 +714,9 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
     let [, mtimesToCommit] = trackModified([
         ...contextDependencies
     ], getFileModifiedMap(context));
-    // ---
-    // Update all context tracking state
-    configContextMap.set(tailwindConfigHash, context);
-    contextMap.set(sourcePath, context);
-    if (!contextSourcesMap.has(context)) {
-        contextSourcesMap.set(context, new Set());
-    }
-    contextSourcesMap.get(context).add(sourcePath);
-    return [
+    return configContextMap.set(tailwindConfigHash, context), contextMap.set(sourcePath, context), contextSourcesMap.has(context) || contextSourcesMap.set(context, new Set()), contextSourcesMap.get(context).add(sourcePath), [
         context,
-        true,
+        !0,
         mtimesToCommit
     ];
 }