tailwindcss 0.0.0-insiders.ddec022 → 0.0.0-insiders.de00a62

package/lib/lib/expandApplyAtRules.js

@@ -482,6 +482,12 @@ function processApply(root, context, localCache) {
                         // We do *not* want to do this for user CSS that happens to be structured the same
                         let isGenerated = parent.raws.tailwind !== undefined;
                         let parentSelector = isGenerated && importantSelector && parent.selector.indexOf(importantSelector) === 0 ? parent.selector.slice(importantSelector.length) : parent.selector;
+                        // If the selector becomes empty after replacing the important selector
+                        // This means that it's the same as the parent selector and we don't want to replace it
+                        // Otherwise we'll crash
+                        if (parentSelector === "") {
+                            parentSelector = parent.selector;
+                        }
                         rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate);
                         // And then re-add it if it was removed
                         if (importantSelector && parentSelector !== parent.selector) {

package/lib/lib/expandTailwindAtRules.js

@@ -124,7 +124,7 @@ function getClassCandidates(content, extractor, candidates, seen) {
     return returnValue;
 }
 function expandTailwindAtRules(context) {
-    return (root)=>{
+    return async (root)=>{
         let layerNodes = {
             base: null,
             components: null,
@@ -165,11 +165,25 @@ function expandTailwindAtRules(context) {
         //   getClassCandidatesOxide(file, transformer(content), extractor, candidates, seen)
         // }
         } else {
-            for (let { file , content , extension  } of context.changedContent){
-                let transformer = getTransformer(context.tailwindConfig, extension);
-                let extractor = getExtractor(context, extension);
-                content = file ? _fs.default.readFileSync(file, "utf8") : content;
-                getClassCandidates(transformer(content), extractor, candidates, seen);
+            /** @type {[item: {file?: string, content?: string}, meta: {transformer: any, extractor: any}][]} */ let regexParserContent = [];
+            for (let item of context.changedContent){
+                let transformer = getTransformer(context.tailwindConfig, item.extension);
+                let extractor = getExtractor(context, item.extension);
+                regexParserContent.push([
+                    item,
+                    {
+                        transformer,
+                        extractor
+                    }
+                ]);
+            }
+            const BATCH_SIZE = 500;
+            for(let i = 0; i < regexParserContent.length; i += BATCH_SIZE){
+                let batch = regexParserContent.slice(i, i + BATCH_SIZE);
+                await Promise.all(batch.map(async ([{ file , content  }, { transformer , extractor  }])=>{
+                    content = file ? await _fs.default.promises.readFile(file, "utf8") : content;
+                    getClassCandidates(transformer(content), extractor, candidates, seen);
+                }));
             }
         }
         env.DEBUG && console.timeEnd("Reading changed files");
@@ -246,6 +260,9 @@ function expandTailwindAtRules(context) {
                 layer: "variants"
             }));
         }
+        var _root_source_end;
+        // TODO: Why is the root node having no source location for `end` possible?
+        root.source.end = (_root_source_end = root.source.end) !== null && _root_source_end !== void 0 ? _root_source_end : root.source.start;
         // If we've got a utility layer and no utilities are generated there's likely something wrong
         const hasUtilityVariants = variantNodes.some((node)=>{
             var _node_raws_tailwind;

package/lib/lib/generateRules.js

@@ -162,6 +162,9 @@ function applyImportant(matches, classCandidate) {
         return matches;
     }
     let result = [];
+    function isInKeyframes(rule) {
+        return rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes";
+    }
     for (let [meta, rule] of matches){
         let container = _postcss.default.root({
             nodes: [
@@ -169,6 +172,11 @@ function applyImportant(matches, classCandidate) {
             ]
         });
         container.walkRules((r)=>{
+            // Declarations inside keyframes cannot be marked as important
+            // They will be ignored by the browser
+            if (isInKeyframes(r)) {
+                return;
+            }
             let ast = (0, _postcssselectorparser.default)().astSync(r.selector);
             // Remove extraneous selectors that do not include the base candidate
             ast.each((sel)=>(0, _formatVariantSelector.eliminateIrrelevantSelectors)(sel, classCandidate));
@@ -231,12 +239,12 @@ function applyVariant(variant, matches, context) {
         //   group[:hover]    (`-` is missing)
         let match = /(.)(-?)\[(.*)\]/g.exec(variant);
         if (match) {
-            let [, char, seperator, value] = match;
+            let [, char, separator, value] = match;
             // @-[200px] case
-            if (char === "@" && seperator === "-") return [];
+            if (char === "@" && separator === "-") return [];
             // group[:hover] case
-            if (char !== "@" && seperator === "") return [];
-            variant = variant.replace(`${seperator}[${value}]`, "");
+            if (char !== "@" && separator === "") return [];
+            variant = variant.replace(`${separator}[${value}]`, "");
             args.value = value;
         }
     }
@@ -259,9 +267,17 @@ function applyVariant(variant, matches, context) {
         context.variantMap.set(variant, records);
     }
     if (context.variantMap.has(variant)) {
+        var _context_variantOptions_get;
         let isArbitraryVariant = isArbitraryValue(variant);
+        var _context_variantOptions_get_INTERNAL_FEATURES;
+        let internalFeatures = (_context_variantOptions_get_INTERNAL_FEATURES = (_context_variantOptions_get = context.variantOptions.get(variant)) === null || _context_variantOptions_get === void 0 ? void 0 : _context_variantOptions_get[_setupContextUtils.INTERNAL_FEATURES]) !== null && _context_variantOptions_get_INTERNAL_FEATURES !== void 0 ? _context_variantOptions_get_INTERNAL_FEATURES : {};
         let variantFunctionTuples = context.variantMap.get(variant).slice();
         let result = [];
+        let respectPrefix = (()=>{
+            if (isArbitraryVariant) return false;
+            if (internalFeatures.respectPrefix === false) return false;
+            return true;
+        })();
         for (let [meta, rule] of matches){
             // Don't generate variants for user css
             if (meta.layer === "user") {
@@ -318,7 +334,7 @@ function applyVariant(variant, matches, context) {
                     format (selectorFormat) {
                         collectedFormats.push({
                             format: selectorFormat,
-                            isArbitraryVariant
+                            respectPrefix
                         });
                     },
                     args
@@ -344,7 +360,7 @@ function applyVariant(variant, matches, context) {
                 if (typeof ruleWithVariant === "string") {
                     collectedFormats.push({
                         format: ruleWithVariant,
-                        isArbitraryVariant
+                        respectPrefix
                     });
                 }
                 if (ruleWithVariant === null) {
@@ -383,7 +399,7 @@ function applyVariant(variant, matches, context) {
                         //                    format: .foo &
                         collectedFormats.push({
                             format: modified.replace(rebuiltBase, "&"),
-                            isArbitraryVariant
+                            respectPrefix
                         });
                         rule.selector = before;
                     });
@@ -492,11 +508,13 @@ function extractArbitraryProperty(classCandidate, context) {
     if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) {
         return null;
     }
-    let normalized = (0, _dataTypes.normalize)(value);
+    let normalized = (0, _dataTypes.normalize)(value, {
+        property
+    });
     if (!isParsableCssValue(property, normalized)) {
         return null;
     }
-    let sort = context.offsets.arbitraryProperty();
+    let sort = context.offsets.arbitraryProperty(classCandidate);
     return [
         [
             {
@@ -570,7 +588,7 @@ function* recordCandidates(matches, classCandidate) {
         yield match;
     }
 }
-function* resolveMatches(candidate, context, original = candidate) {
+function* resolveMatches(candidate, context) {
     let separator = context.tailwindConfig.separator;
     let [classCandidate, ...variants] = splitWithSeparator(candidate, separator).reverse();
     let important = false;
@@ -578,14 +596,6 @@ function* resolveMatches(candidate, context, original = candidate) {
         important = true;
         classCandidate = classCandidate.slice(1);
     }
-    if ((0, _featureFlags.flagEnabled)(context.tailwindConfig, "variantGrouping")) {
-        if (classCandidate.startsWith("(") && classCandidate.endsWith(")")) {
-            let base = variants.slice().reverse().join(separator);
-            for (let part of (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(classCandidate.slice(1, -1), ",")){
-                yield* resolveMatches(base + separator + part, context, original);
-            }
-        }
-    }
     // TODO: Reintroduce this in ways that doesn't break on false positives
     // function sortAgainst(toSort, against) {
     //   return toSort.slice().sort((a, z) => {
@@ -745,8 +755,7 @@ function* resolveMatches(candidate, context, original = candidate) {
             // Apply final format selector
             match = applyFinalFormat(match, {
                 context,
-                candidate,
-                original
+                candidate
             });
             // Skip rules with invalid selectors
             // This will cause the candidate to be added to the "not class"
@@ -758,7 +767,7 @@ function* resolveMatches(candidate, context, original = candidate) {
         }
     }
 }
-function applyFinalFormat(match, { context , candidate , original  }) {
+function applyFinalFormat(match, { context , candidate  }) {
     if (!match[0].collectedFormats) {
         return match;
     }
@@ -791,10 +800,17 @@ function applyFinalFormat(match, { context , candidate , original  }) {
             return;
         }
         try {
-            rule.selector = (0, _formatVariantSelector.finalizeSelector)(rule.selector, finalFormat, {
-                candidate: original,
+            let selector = (0, _formatVariantSelector.finalizeSelector)(rule.selector, finalFormat, {
+                candidate,
                 context
             });
+            // Finalize Selector determined that this candidate is irrelevant
+            // TODO: This elimination should happen earlier so this never happens
+            if (selector === null) {
+                rule.remove();
+                return;
+            }
+            rule.selector = selector;
         } catch  {
             // If this selector is invalid we also want to skip it
             // But it's likely that being invalid here means there's a bug in a plugin rather than too loosely matching content
@@ -805,6 +821,10 @@ function applyFinalFormat(match, { context , candidate , original  }) {
     if (!isValid) {
         return null;
     }
+    // If all rules have been eliminated we can skip this candidate entirely
+    if (container.nodes.length === 0) {
+        return null;
+    }
     match[1] = container.nodes[0];
     return match;
 }
@@ -835,7 +855,7 @@ function getImportantStrategy(important) {
         };
     }
 }
-function generateRules(candidates, context) {
+function generateRules(candidates, context, isSorting = false) {
     let allRules = [];
     let strategy = getImportantStrategy(context.tailwindConfig.important);
     for (let candidate of candidates){
@@ -866,9 +886,11 @@ function generateRules(candidates, context) {
                 container.walkRules(strategy);
                 rule = container.nodes[0];
             }
+            // Note: We have to clone rules during sorting
+            // so we eliminate some shared mutable state
             let newEntry = [
                 sort,
-                rule
+                isSorting ? rule.clone() : rule
             ];
             rules.add(newEntry);
             context.ruleCache.add(newEntry);

package/lib/lib/load-config.js

@@ -2,9 +2,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "loadConfig", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useCustomJiti: function() {
+        return useCustomJiti;
+    },
+    loadConfig: function() {
         return loadConfig;
     }
 });
@@ -16,6 +24,9 @@ function _interop_require_default(obj) {
     };
 }
 let jiti = null;
+function useCustomJiti(_jiti) {
+    jiti = _jiti();
+}
 function lazyJiti() {
     return jiti !== null && jiti !== void 0 ? jiti : jiti = (0, _jiti.default)(__filename, {
         interopDefault: true,

package/lib/lib/offsets.js

@@ -66,15 +66,19 @@ class Offsets {
             variants: 0n,
             parallelIndex: 0n,
             index: this.offsets[layer]++,
+            propertyOffset: 0n,
+            property: "",
             options: []
         };
     }
     /**
+   * @param {string} name
    * @returns {RuleOffset}
-   */ arbitraryProperty() {
+   */ arbitraryProperty(name) {
         return {
             ...this.create("utilities"),
-            arbitrary: 1n
+            arbitrary: 1n,
+            property: name
         };
     }
     /**
@@ -214,6 +218,10 @@ class Offsets {
         if (a.arbitrary !== b.arbitrary) {
             return a.arbitrary - b.arbitrary;
         }
+        // Always sort arbitrary properties alphabetically
+        if (a.propertyOffset !== b.propertyOffset) {
+            return a.propertyOffset - b.propertyOffset;
+        }
         // Sort utilities, components, etc… in the order they were registered
         return a.index - b.index;
     }
@@ -267,8 +275,49 @@ class Offsets {
    * @template T
    * @param {[RuleOffset, T][]} list
    * @returns {[RuleOffset, T][]}
+   */ sortArbitraryProperties(list) {
+        // Collect all known arbitrary properties
+        let known = new Set();
+        for (let [offset] of list){
+            if (offset.arbitrary === 1n) {
+                known.add(offset.property);
+            }
+        }
+        // No arbitrary properties? Nothing to do.
+        if (known.size === 0) {
+            return list;
+        }
+        // Sort the properties alphabetically
+        let properties = Array.from(known).sort();
+        // Create a map from the property name to its offset
+        let offsets = new Map();
+        let offset = 1n;
+        for (let property of properties){
+            offsets.set(property, offset++);
+        }
+        // Apply the sorted offsets to the list
+        return list.map((item)=>{
+            let [offset, rule] = item;
+            var _offsets_get;
+            offset = {
+                ...offset,
+                propertyOffset: (_offsets_get = offsets.get(offset.property)) !== null && _offsets_get !== void 0 ? _offsets_get : 0n
+            };
+            return [
+                offset,
+                rule
+            ];
+        });
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
    */ sort(list) {
+        // Sort arbitrary variants so they're in alphabetical order
         list = this.remapArbitraryVariantOffsets(list);
+        // Sort arbitrary properties so they're in alphabetical order
+        list = this.sortArbitraryProperties(list);
         return list.sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
     }
 }

package/lib/lib/resolveDefaultsAtRules.js

@@ -111,7 +111,9 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                         // we consider them separately because merging the declarations into
                         // a single rule will cause browsers that do not understand the
                         // vendor prefix to throw out the whole rule
-                        let selectorGroupName = selector.includes(":-") || selector.includes("::-") ? selector : "__DEFAULT__";
+                        // Additionally if a selector contains `:has` we also consider
+                        // it separately because FF only recently gained support for it
+                        let selectorGroupName = selector.includes(":-") || selector.includes("::-") || selector.includes(":has") ? selector : "__DEFAULT__";
                         var _selectorGroups_get;
                         let selectors = (_selectorGroups_get = selectorGroups.get(selectorGroupName)) !== null && _selectorGroups_get !== void 0 ? _selectorGroups_get : new Set();
                         selectorGroups.set(selectorGroupName, selectors);

package/lib/lib/setupContextUtils.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    INTERNAL_FEATURES: function() {
+        return INTERNAL_FEATURES;
+    },
     isValidVariantFormatString: function() {
         return isValidVariantFormatString;
     },
@@ -92,6 +95,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const INTERNAL_FEATURES = Symbol();
 const VARIANT_TYPES = {
     AddVariant: Symbol.for("ADD_VARIANT"),
     MatchVariant: Symbol.for("MATCH_VARIANT")
@@ -197,39 +201,41 @@ function getClasses(selector, mutate) {
     });
     return parser.transformSync(selector);
 }
+/**
+ * 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.
+ *
+ * @param {selectorParser.Root} selectors
+ */ function ignoreNot(selectors) {
+    selectors.walkPseudos((pseudo)=>{
+        if (pseudo.value === ":not") {
+            pseudo.remove();
+        }
+    });
+}
 function extractCandidates(node, state = {
     containsNonOnDemandable: false
 }, depth = 0) {
     let classes = [];
-    // Handle normal rules
+    let selectors = [];
     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();
-                }
-            });
+        // Handle normal rules
+        selectors.push(...node.selectors);
+    } else if (node.type === "atrule") {
+        // Handle at-rules (which contains nested rules)
+        node.walkRules((rule)=>selectors.push(...rule.selectors));
+    }
+    for (let selector of 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 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);
-            }
+        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 [
@@ -270,11 +276,14 @@ function parseVariant(variant) {
         if (!str.startsWith("@")) {
             return ({ format  })=>format(str);
         }
-        let [, name, params] = /@(.*?)( .+|[({].*)/g.exec(str);
-        return ({ wrap  })=>wrap(_postcss.default.atRule({
+        let [, name, params] = /@(\S*)( .+|[({].*)?/g.exec(str);
+        var _params_trim;
+        return ({ wrap  })=>{
+            return wrap(_postcss.default.atRule({
                 name,
-                params: params.trim()
+                params: (_params_trim = params === null || params === void 0 ? void 0 : params.trim()) !== null && _params_trim !== void 0 ? _params_trim : ""
             }));
+        };
     }).reverse();
     return (api)=>{
         for (let fn of fns){
@@ -742,21 +751,40 @@ function resolvePlugins(context, root) {
     // TODO: This is a workaround for backwards compatibility, since custom variants
     // were historically sorted before screen/stackable variants.
     let beforeVariants = [
+        _corePlugins.variantPlugins["childVariant"],
         _corePlugins.variantPlugins["pseudoElementVariants"],
         _corePlugins.variantPlugins["pseudoClassVariants"],
+        _corePlugins.variantPlugins["hasVariants"],
         _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"]
+        _corePlugins.variantPlugins["orientationVariants"],
+        _corePlugins.variantPlugins["directionVariants"],
+        _corePlugins.variantPlugins["darkVariants"],
+        _corePlugins.variantPlugins["forcedColorsVariants"],
+        _corePlugins.variantPlugins["printVariant"]
     ];
+    // This is a compatibility fix for the pre 3.4 dark mode behavior
+    // `class` retains the old behavior, but `selector` keeps the new behavior
+    let isLegacyDarkMode = context.tailwindConfig.darkMode === "class" || Array.isArray(context.tailwindConfig.darkMode) && context.tailwindConfig.darkMode[0] === "class";
+    if (isLegacyDarkMode) {
+        afterVariants = [
+            _corePlugins.variantPlugins["supportsVariants"],
+            _corePlugins.variantPlugins["reducedMotionVariants"],
+            _corePlugins.variantPlugins["prefersContrastVariants"],
+            _corePlugins.variantPlugins["darkVariants"],
+            _corePlugins.variantPlugins["screenVariants"],
+            _corePlugins.variantPlugins["orientationVariants"],
+            _corePlugins.variantPlugins["directionVariants"],
+            _corePlugins.variantPlugins["forcedColorsVariants"],
+            _corePlugins.variantPlugins["printVariant"]
+        ];
+    }
     return [
         ...corePluginList,
         ...beforeVariants,
@@ -920,11 +948,15 @@ function registerPlugins(plugins, context) {
             ]));
         // 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);
+        let rules = (0, _generateRules.generateRules)(new Set(sorted), context, true);
         rules = context.offsets.sort(rules);
         let idx = BigInt(parasiteUtilities.length);
         for (const [, rule] of rules){
-            sortedClassNames.set(rule.raws.tailwind.candidate, idx++);
+            let candidate = rule.raws.tailwind.candidate;
+            var _sortedClassNames_get;
+            // When multiple rules match a candidate
+            // always take the position of the first one
+            sortedClassNames.set(candidate, (_sortedClassNames_get = sortedClassNames.get(candidate)) !== null && _sortedClassNames_get !== void 0 ? _sortedClassNames_get : idx++);
         }
         return classes.map((className)=>{
             var _sortedClassNames_get;
@@ -1095,13 +1127,20 @@ function registerPlugins(plugins, context) {
                     }
                     var _options_values1;
                     let isArbitraryVariant = !(value in ((_options_values1 = options.values) !== null && _options_values1 !== void 0 ? _options_values1 : {}));
+                    var _options_INTERNAL_FEATURES;
+                    let internalFeatures = (_options_INTERNAL_FEATURES = options[INTERNAL_FEATURES]) !== null && _options_INTERNAL_FEATURES !== void 0 ? _options_INTERNAL_FEATURES : {};
+                    let respectPrefix = (()=>{
+                        if (isArbitraryVariant) return false;
+                        if (internalFeatures.respectPrefix === false) return false;
+                        return true;
+                    })();
                     formatStrings = formatStrings.map((format)=>format.map((str)=>({
                                 format: str,
-                                isArbitraryVariant
+                                respectPrefix
                             })));
                     manualFormatStrings = manualFormatStrings.map((format)=>({
                             format,
-                            isArbitraryVariant
+                            respectPrefix
                         }));
                     let opts = {
                         candidate,

package/lib/lib/setupTrackingContext.js

@@ -83,8 +83,9 @@ function getTailwindConfig(configOrPath) {
             newDeps
         ];
     }
+    var _configOrPath_config, _ref;
     // It's a plain object, not a path
-    let newConfig = (0, _resolveconfig.default)(configOrPath.config === undefined ? configOrPath : configOrPath.config);
+    let newConfig = (0, _resolveconfig.default)((_ref = (_configOrPath_config = configOrPath === null || configOrPath === void 0 ? void 0 : configOrPath.config) !== null && _configOrPath_config !== void 0 ? _configOrPath_config : configOrPath) !== null && _ref !== void 0 ? _ref : {});
     newConfig = (0, _validateConfig.validateConfig)(newConfig);
     return [
         newConfig,

package/lib/oxide/cli/build/plugin.js

@@ -191,14 +191,14 @@ let state = {
         return content;
     },
     getContext ({ createContext , cliConfigPath , root , result , content  }) {
-        if (this.context) {
-            this.context.changedContent = this.changedContent.splice(0);
-            return this.context;
-        }
         _sharedState.env.DEBUG && console.time("Searching for config");
         var _findAtConfigPath1;
         let configPath = (_findAtConfigPath1 = (0, _findAtConfigPath.findAtConfigPath)(root, result)) !== null && _findAtConfigPath1 !== void 0 ? _findAtConfigPath1 : cliConfigPath;
         _sharedState.env.DEBUG && console.timeEnd("Searching for config");
+        if (this.context) {
+            this.context.changedContent = this.changedContent.splice(0);
+            return this.context;
+        }
         _sharedState.env.DEBUG && console.time("Loading config");
         let config = this.loadConfig(configPath, content);
         _sharedState.env.DEBUG && console.timeEnd("Loading config");
@@ -244,9 +244,9 @@ async function createProcessor(args, cliConfigPath) {
     let tailwindPlugin = ()=>{
         return {
             postcssPlugin: "tailwindcss",
-            Once (root, { result  }) {
+            async Once (root, { result  }) {
                 _sharedState.env.DEBUG && console.time("Compiling CSS");
-                (0, _processTailwindFeatures.default)(({ createContext  })=>{
+                await (0, _processTailwindFeatures.default)(({ createContext  })=>{
                     console.error();
                     console.error("Rebuilding...");
                     return ()=>{

package/lib/plugin.js

@@ -20,7 +20,7 @@ module.exports = function tailwindcss(configOrPath) {
                 console.time("JIT TOTAL");
                 return root;
             },
-            function(root, result) {
+            async function(root, result) {
                 var _findAtConfigPath1;
                 // Use the path for the `@config` directive if it exists, otherwise use the
                 // path for the file being processed
@@ -30,12 +30,12 @@ module.exports = function tailwindcss(configOrPath) {
                     let roots = root.nodes.filter((node)=>node.type === "root");
                     for (const root of roots){
                         if (root.type === "root") {
-                            (0, _processTailwindFeatures.default)(context)(root, result);
+                            await (0, _processTailwindFeatures.default)(context)(root, result);
                         }
                     }
                     return;
                 }
-                (0, _processTailwindFeatures.default)(context)(root, result);
+                await (0, _processTailwindFeatures.default)(context)(root, result);
             },
             false && function lightningCssPlugin(_root, result) {
                 let postcss = require("postcss");

package/lib/processTailwindFeatures.js

@@ -26,7 +26,7 @@ function _interop_require_default(obj) {
     };
 }
 function processTailwindFeatures(setupContext) {
-    return function(root, result) {
+    return async function(root, result) {
         let { tailwindDirectives , applyDirectives  } = (0, _normalizeTailwindDirectives.default)(root);
         (0, _detectNesting.default)()(root, result);
         // Partition apply rules that are found in the css
@@ -50,7 +50,7 @@ function processTailwindFeatures(setupContext) {
             throw new Error("The '-' character cannot be used as a custom separator in JIT mode due to parsing ambiguity. Please use another character like '_' instead.");
         }
         (0, _featureFlags.issueFlagNotices)(context.tailwindConfig);
-        (0, _expandTailwindAtRules.default)(context)(root, result);
+        await (0, _expandTailwindAtRules.default)(context)(root, result);
         // Partition apply rules that are generated by
         // addComponents, addUtilities and so on.
         (0, _partitionApplyAtRules.default)()(root, result);