tailwindcss 0.0.0-insiders.fe08e91 → 0.0.0-oxide.dd87d75

package/lib/lib/setupTrackingContext.js

@@ -2,19 +2,24 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = setupTrackingContext;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-var _fastGlob = _interopRequireDefault(require("fast-glob"));
-var _quickLru = _interopRequireDefault(require("quick-lru"));
-var _normalizePath = _interopRequireDefault(require("normalize-path"));
-var _hashConfig = _interopRequireDefault(require("../util/hashConfig"));
-var _getModuleDependencies = _interopRequireDefault(require("../lib/getModuleDependencies"));
-var _resolveConfig = _interopRequireDefault(require("../public/resolve-config"));
-var _resolveConfigPath = _interopRequireDefault(require("../util/resolveConfigPath"));
-var _sharedState = require("./sharedState");
-var _setupContextUtils = require("./setupContextUtils");
-var _parseDependency = _interopRequireDefault(require("../util/parseDependency"));
+Object.defineProperty(exports, // DISABLE_TOUCH = TRUE
+// Retrieve an existing context from cache if possible (since contexts are unique per
+// source path), or set up a new one (including setting up watchers and registering
+// plugins) then return it
+"default", {
+    enumerable: true,
+    get: ()=>setupTrackingContext
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _quickLru = /*#__PURE__*/ _interopRequireDefault(require("quick-lru"));
+const _hashConfig = /*#__PURE__*/ _interopRequireDefault(require("../util/hashConfig"));
+const _getModuleDependencies = /*#__PURE__*/ _interopRequireDefault(require("../lib/getModuleDependencies"));
+const _resolveConfig = /*#__PURE__*/ _interopRequireDefault(require("../public/resolve-config"));
+const _resolveConfigPath = /*#__PURE__*/ _interopRequireDefault(require("../util/resolveConfigPath"));
+const _setupContextUtils = require("./setupContextUtils");
+const _parseDependency = /*#__PURE__*/ _interopRequireDefault(require("../util/parseDependency"));
+const _validateConfigJs = require("../util/validateConfig.js");
+const _contentJs = require("./content.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -28,18 +33,15 @@ function getCandidateFiles(context, tailwindConfig) {
     if (candidateFilesCache.has(context)) {
         return candidateFilesCache.get(context);
     }
-    let candidateFiles = tailwindConfig.content.files.filter((item)=>typeof item === 'string'
-    ).map((contentPath)=>(0, _normalizePath).default(contentPath)
-    );
+    let candidateFiles = (0, _contentJs.parseCandidateFiles)(context, tailwindConfig);
     return candidateFilesCache.set(context, candidateFiles).get(context);
 }
 // Get the config object based on a path
 function getTailwindConfig(configOrPath) {
-    let userConfigPath = (0, _resolveConfigPath).default(configOrPath);
+    let userConfigPath = (0, _resolveConfigPath.default)(configOrPath);
     if (userConfigPath !== null) {
         let [prevConfig, prevConfigHash, prevDeps, prevModified] = configPathCache.get(userConfigPath) || [];
-        let newDeps = (0, _getModuleDependencies).default(userConfigPath).map((dep)=>dep.file
-        );
+        let newDeps = (0, _getModuleDependencies.default)(userConfigPath).map((dep)=>dep.file);
         let modified = false;
         let newModified = new Map();
         for (let file of newDeps){
@@ -62,8 +64,9 @@ function getTailwindConfig(configOrPath) {
         for (let file1 of newDeps){
             delete require.cache[file1];
         }
-        let newConfig = (0, _resolveConfig).default(require(userConfigPath));
-        let newHash = (0, _hashConfig).default(newConfig);
+        let newConfig = (0, _resolveConfig.default)(require(userConfigPath));
+        newConfig = (0, _validateConfigJs.validateConfig)(newConfig);
+        let newHash = (0, _hashConfig.default)(newConfig);
         configPathCache.set(userConfigPath, [
             newConfig,
             newHash,
@@ -78,48 +81,17 @@ function getTailwindConfig(configOrPath) {
         ];
     }
     // It's a plain object, not a path
-    let newConfig = (0, _resolveConfig).default(configOrPath.config === undefined ? configOrPath : configOrPath.config);
+    let newConfig1 = (0, _resolveConfig.default)(configOrPath.config === undefined ? configOrPath : configOrPath.config);
+    newConfig1 = (0, _validateConfigJs.validateConfig)(newConfig1);
     return [
-        newConfig,
+        newConfig1,
         null,
-        (0, _hashConfig).default(newConfig),
+        (0, _hashConfig.default)(newConfig1),
         []
     ];
 }
-function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
-    let changedContent = context.tailwindConfig.content.files.filter((item)=>typeof item.raw === 'string'
-    ).map(({ raw , extension ='html'  })=>({
-            content: raw,
-            extension
-        })
-    );
-    for (let changedFile of resolveChangedFiles(candidateFiles, fileModifiedMap)){
-        let content = _fs.default.readFileSync(changedFile, 'utf8');
-        let extension = _path.default.extname(changedFile).slice(1);
-        changedContent.push({
-            content,
-            extension
-        });
-    }
-    return changedContent;
-}
-function resolveChangedFiles(candidateFiles, fileModifiedMap) {
-    let changedFiles = new Set();
-    _sharedState.env.DEBUG && console.time('Finding changed files');
-    let files = _fastGlob.default.sync(candidateFiles);
-    for (let file of files){
-        let prevModified = fileModifiedMap.has(file) ? fileModifiedMap.get(file) : -Infinity;
-        let modified = _fs.default.statSync(file).mtimeMs;
-        if (modified > prevModified) {
-            changedFiles.add(file);
-            fileModifiedMap.set(file, modified);
-        }
-    }
-    _sharedState.env.DEBUG && console.timeEnd('Finding changed files');
-    return changedFiles;
-}
 function setupTrackingContext(configOrPath) {
-    return ({ tailwindDirectives , registerDependency , applyDirectives  })=>{
+    return ({ tailwindDirectives , registerDependency  })=>{
         return (root, result)=>{
             let [tailwindConfig, userConfigPath, tailwindConfigHash, configDependencies] = getTailwindConfig(configOrPath);
             let contextDependencies = new Set(configDependencies);
@@ -129,39 +101,38 @@ function setupTrackingContext(configOrPath) {
             // being part of this trigger too, but it's tough because it's impossible
             // for a layer in one file to end up in the actual @tailwind rule in
             // another file since independent sources are effectively isolated.
-            if (tailwindDirectives.size > 0 || applyDirectives.size > 0) {
+            if (tailwindDirectives.size > 0) {
                 // Add current css file as a context dependencies.
                 contextDependencies.add(result.opts.from);
                 // Add all css @import dependencies as context dependencies.
                 for (let message of result.messages){
-                    if (message.type === 'dependency') {
+                    if (message.type === "dependency") {
                         contextDependencies.add(message.file);
                     }
                 }
             }
-            let [context] = (0, _setupContextUtils).getContext(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
+            let [context] = (0, _setupContextUtils.getContext)(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
             let candidateFiles = getCandidateFiles(context, tailwindConfig);
             // If there are no @tailwind or @apply rules, we don't consider this CSS file or it's
             // dependencies to be dependencies of the context. Can reuse the context even if they change.
             // We may want to think about `@layer` being part of this trigger too, but it's tough
             // because it's impossible for a layer in one file to end up in the actual @tailwind rule
             // in another file since independent sources are effectively isolated.
-            if (tailwindDirectives.size > 0 || applyDirectives.size > 0) {
-                let fileModifiedMap = (0, _setupContextUtils).getFileModifiedMap(context);
+            if (tailwindDirectives.size > 0) {
+                let fileModifiedMap = (0, _setupContextUtils.getFileModifiedMap)(context);
                 // Add template paths as postcss dependencies.
-                for (let fileOrGlob of candidateFiles){
-                    let dependency = (0, _parseDependency).default(fileOrGlob);
-                    if (dependency) {
+                for (let contentPath of candidateFiles){
+                    for (let dependency of (0, _parseDependency.default)(contentPath)){
                         registerDependency(dependency);
                     }
                 }
-                for (let changedContent of resolvedChangedContent(context, candidateFiles, fileModifiedMap)){
+                for (let changedContent of (0, _contentJs.resolvedChangedContent)(context, candidateFiles, fileModifiedMap)){
                     context.changedContent.push(changedContent);
                 }
             }
             for (let file of configDependencies){
                 registerDependency({
-                    type: 'dependency',
+                    type: "dependency",
                     file
                 });
             }

package/lib/lib/sharedState.js

@@ -2,28 +2,42 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.resolveDebug = resolveDebug;
-exports.contextSourcesMap = exports.configContextMap = exports.contextMap = exports.env = void 0;
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    env: ()=>env,
+    contextMap: ()=>contextMap,
+    configContextMap: ()=>configContextMap,
+    contextSourcesMap: ()=>contextSourcesMap,
+    sourceHashMap: ()=>sourceHashMap,
+    NOT_ON_DEMAND: ()=>NOT_ON_DEMAND,
+    NONE: ()=>NONE,
+    resolveDebug: ()=>resolveDebug
+});
 const env = {
     NODE_ENV: process.env.NODE_ENV,
-    DEBUG: resolveDebug(process.env.DEBUG)
+    DEBUG: resolveDebug(process.env.DEBUG),
+    OXIDE: process.env.OXIDE
 };
-exports.env = env;
 const contextMap = new Map();
-exports.contextMap = contextMap;
 const configContextMap = new Map();
-exports.configContextMap = configContextMap;
 const contextSourcesMap = new Map();
-exports.contextSourcesMap = contextSourcesMap;
+const sourceHashMap = new Map();
+const NOT_ON_DEMAND = new String("*");
+const NONE = Symbol("__NONE__");
 function resolveDebug(debug) {
     if (debug === undefined) {
         return false;
     }
     // Environment variables are strings, so convert to boolean
-    if (debug === 'true' || debug === '1') {
+    if (debug === "true" || debug === "1") {
         return true;
     }
-    if (debug === 'false' || debug === '0') {
+    if (debug === "false" || debug === "0") {
         return false;
     }
     // Keep the debug convention into account:
@@ -31,17 +45,16 @@ function resolveDebug(debug) {
     // DEBUG=projectA,projectB,projectC -> This enables debug for projectA, projectB and projectC
     // DEBUG=projectA:* -> This enables all debug modes for projectA (if you have sub-types)
     // DEBUG=projectA,-projectB -> This enables debug for projectA and explicitly disables it for projectB
-    if (debug === '*') {
+    if (debug === "*") {
         return true;
     }
-    let debuggers = debug.split(',').map((d)=>d.split(':')[0]
-    );
+    let debuggers = debug.split(",").map((d)=>d.split(":")[0]);
     // Ignoring tailwindcss
-    if (debuggers.includes('-tailwindcss')) {
+    if (debuggers.includes("-tailwindcss")) {
         return false;
     }
     // Including tailwindcss
-    if (debuggers.includes('tailwindcss')) {
+    if (debuggers.includes("tailwindcss")) {
         return true;
     }
     return false;

package/lib/lib/substituteScreenAtRules.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = _default;
-var _normalizeScreens = require("../util/normalizeScreens");
-var _buildMediaQuery = _interopRequireDefault(require("../util/buildMediaQuery"));
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _normalizeScreens = require("../util/normalizeScreens");
+const _buildMediaQuery = /*#__PURE__*/ _interopRequireDefault(require("../util/buildMediaQuery"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -12,16 +15,15 @@ function _interopRequireDefault(obj) {
 }
 function _default({ tailwindConfig: { theme  }  }) {
     return function(css) {
-        css.walkAtRules('screen', (atRule)=>{
+        css.walkAtRules("screen", (atRule)=>{
             let screen = atRule.params;
-            let screens = (0, _normalizeScreens).normalizeScreens(theme.screens);
-            let screenDefinition = screens.find(({ name  })=>name === screen
-            );
+            let screens = (0, _normalizeScreens.normalizeScreens)(theme.screens);
+            let screenDefinition = screens.find(({ name  })=>name === screen);
             if (!screenDefinition) {
                 throw atRule.error(`No \`${screen}\` screen found.`);
             }
-            atRule.name = 'media';
-            atRule.params = (0, _buildMediaQuery).default(screenDefinition);
+            atRule.name = "media";
+            atRule.params = (0, _buildMediaQuery.default)(screenDefinition);
         });
     };
 }

package/lib/plugin.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _setupTrackingContext = /*#__PURE__*/ _interopRequireDefault(require("./lib/setupTrackingContext"));
+const _processTailwindFeatures = /*#__PURE__*/ _interopRequireDefault(require("./processTailwindFeatures"));
+const _sharedState = require("./lib/sharedState");
+const _findAtConfigPath = require("./lib/findAtConfigPath");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+module.exports = function tailwindcss(configOrPath) {
+    return {
+        postcssPlugin: "tailwindcss",
+        plugins: [
+            _sharedState.env.DEBUG && function(root) {
+                console.log("\n");
+                console.time("JIT TOTAL");
+                return root;
+            },
+            function(root, result) {
+                var ref;
+                // Use the path for the `@config` directive if it exists, otherwise use the
+                // path for the file being processed
+                configOrPath = (ref = (0, _findAtConfigPath.findAtConfigPath)(root, result)) !== null && ref !== void 0 ? ref : configOrPath;
+                let context = (0, _setupTrackingContext.default)(configOrPath);
+                if (root.type === "document") {
+                    let roots = root.nodes.filter((node)=>node.type === "root");
+                    for (const root1 of roots){
+                        if (root1.type === "root") {
+                            (0, _processTailwindFeatures.default)(context)(root1, result);
+                        }
+                    }
+                    return;
+                }
+                (0, _processTailwindFeatures.default)(context)(root, result);
+            },
+            _sharedState.env.DEBUG && function(root) {
+                console.timeEnd("JIT TOTAL");
+                console.log("\n");
+                return root;
+            }
+        ].filter(Boolean)
+    };
+};
+module.exports.postcss = true;

package/{nesting → lib/postcss-plugins/nesting}/README.md

@@ -1,6 +1,6 @@
 # tailwindcss/nesting
 
-This is a PostCSS plugin that wraps [postcss-nested](https://github.com/postcss/postcss-nested) or [postcss-nesting](https://github.com/jonathantneal/postcss-nesting) and acts as a compatibility layer to make sure your nesting plugin of choice properly understands Tailwind's custom syntax like `@apply` and `@screen`.
+This is a PostCSS plugin that wraps [postcss-nested](https://github.com/postcss/postcss-nested) or [postcss-nesting](https://github.com/csstools/postcss-plugins/tree/main/plugins/postcss-nesting) and acts as a compatibility layer to make sure your nesting plugin of choice properly understands Tailwind's custom syntax like `@apply` and `@screen`.
 
 Add it to your PostCSS configuration, somewhere before Tailwind itself:
 
@@ -18,7 +18,7 @@ module.exports = {
 
 By default, it uses the [postcss-nested](https://github.com/postcss/postcss-nested) plugin under the hood, which uses a Sass-like syntax and is the plugin that powers nesting support in the [Tailwind CSS plugin API](https://tailwindcss.com/docs/plugins#css-in-js-syntax).
 
-If you'd rather use [postcss-nesting](https://github.com/jonathantneal/postcss-nesting) (which is based on the work-in-progress [CSS Nesting](https://drafts.csswg.org/css-nesting-1/) specification), first install the plugin alongside:
+If you'd rather use [postcss-nesting](https://github.com/csstools/postcss-plugins/tree/main/plugins/postcss-nesting) (which is based on the work-in-progress [CSS Nesting](https://drafts.csswg.org/css-nesting-1/) specification), first install the plugin alongside:
 
 ```shell
 npm install postcss-nesting

package/lib/postcss-plugins/nesting/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _plugin = require("./plugin");
+const _default = Object.assign(function(opts) {
+    return {
+        postcssPlugin: "tailwindcss/nesting",
+        Once (root, { result  }) {
+            return (0, _plugin.nesting)(opts)(root, result);
+        }
+    };
+}, {
+    postcss: true
+});

package/lib/postcss-plugins/nesting/plugin.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nesting", {
+    enumerable: true,
+    get: ()=>nesting
+});
+const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
+const _postcssNested = /*#__PURE__*/ _interopRequireDefault(require("postcss-nested"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function nesting(opts = _postcssNested.default) {
+    return (root, result)=>{
+        root.walkAtRules("screen", (rule)=>{
+            rule.name = "media";
+            rule.params = `screen(${rule.params})`;
+        });
+        root.walkAtRules("apply", (rule)=>{
+            rule.before(_postcss.default.decl({
+                prop: "__apply",
+                value: rule.params,
+                source: rule.source
+            }));
+            rule.remove();
+        });
+        let plugin = (()=>{
+            var ref;
+            if (typeof opts === "function" || typeof opts === "object" && (opts === null || opts === void 0 ? void 0 : (ref = opts.hasOwnProperty) === null || ref === void 0 ? void 0 : ref.call(opts, "postcssPlugin"))) {
+                return opts;
+            }
+            if (typeof opts === "string") {
+                return require(opts);
+            }
+            if (Object.keys(opts).length <= 0) {
+                return _postcssNested.default;
+            }
+            throw new Error("tailwindcss/nesting should be loaded with a nesting plugin.");
+        })();
+        (0, _postcss.default)([
+            plugin
+        ]).process(root, result.opts).sync();
+        root.walkDecls("__apply", (decl)=>{
+            decl.before(_postcss.default.atRule({
+                name: "apply",
+                params: decl.value,
+                source: decl.source
+            }));
+            decl.remove();
+        });
+        /**
+     * Use a private PostCSS API to remove the "clean" flag from the entire AST.
+     * This is done because running process() on the AST will set the "clean"
+     * flag on all nodes, which we don't want.
+     *
+     * This causes downstream plugins using the visitor API to be skipped.
+     *
+     * This is guarded because the PostCSS API is not public
+     * and may change in future versions of PostCSS.
+     *
+     * See https://github.com/postcss/postcss/issues/1712 for more details
+     *
+     * @param {import('postcss').Node} node
+     */ function markDirty(node) {
+            if (!("markDirty" in node)) {
+                return;
+            }
+            // Traverse the tree down to the leaf nodes
+            if (node.nodes) {
+                node.nodes.forEach((n)=>markDirty(n));
+            }
+            // If it's a leaf node mark it as dirty
+            // We do this here because marking a node as dirty
+            // will walk up the tree and mark all parents as dirty
+            // resulting in a lot of unnecessary work if we did this
+            // for every single node
+            if (!node.nodes) {
+                node.markDirty();
+            }
+        }
+        markDirty(root);
+        return root;
+    };
+}

package/lib/processTailwindFeatures.js

@@ -2,18 +2,22 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = processTailwindFeatures;
-var _normalizeTailwindDirectives = _interopRequireDefault(require("./lib/normalizeTailwindDirectives"));
-var _expandTailwindAtRules = _interopRequireDefault(require("./lib/expandTailwindAtRules"));
-var _expandApplyAtRules = _interopRequireDefault(require("./lib/expandApplyAtRules"));
-var _evaluateTailwindFunctions = _interopRequireDefault(require("./lib/evaluateTailwindFunctions"));
-var _substituteScreenAtRules = _interopRequireDefault(require("./lib/substituteScreenAtRules"));
-var _resolveDefaultsAtRules = _interopRequireDefault(require("./lib/resolveDefaultsAtRules"));
-var _collapseAdjacentRules = _interopRequireDefault(require("./lib/collapseAdjacentRules"));
-var _collapseDuplicateDeclarations = _interopRequireDefault(require("./lib/collapseDuplicateDeclarations"));
-var _detectNesting = _interopRequireDefault(require("./lib/detectNesting"));
-var _setupContextUtils = require("./lib/setupContextUtils");
-var _featureFlags = require("./featureFlags");
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>processTailwindFeatures
+});
+const _normalizeTailwindDirectives = /*#__PURE__*/ _interopRequireDefault(require("./lib/normalizeTailwindDirectives"));
+const _expandTailwindAtRules = /*#__PURE__*/ _interopRequireDefault(require("./lib/expandTailwindAtRules"));
+const _expandApplyAtRules = /*#__PURE__*/ _interopRequireDefault(require("./lib/expandApplyAtRules"));
+const _evaluateTailwindFunctions = /*#__PURE__*/ _interopRequireDefault(require("./lib/evaluateTailwindFunctions"));
+const _substituteScreenAtRules = /*#__PURE__*/ _interopRequireDefault(require("./lib/substituteScreenAtRules"));
+const _resolveDefaultsAtRules = /*#__PURE__*/ _interopRequireDefault(require("./lib/resolveDefaultsAtRules"));
+const _collapseAdjacentRules = /*#__PURE__*/ _interopRequireDefault(require("./lib/collapseAdjacentRules"));
+const _collapseDuplicateDeclarations = /*#__PURE__*/ _interopRequireDefault(require("./lib/collapseDuplicateDeclarations"));
+const _partitionApplyAtRules = /*#__PURE__*/ _interopRequireDefault(require("./lib/partitionApplyAtRules"));
+const _detectNesting = /*#__PURE__*/ _interopRequireDefault(require("./lib/detectNesting"));
+const _setupContextUtils = require("./lib/setupContextUtils");
+const _featureFlags = require("./featureFlags");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -21,32 +25,38 @@ function _interopRequireDefault(obj) {
 }
 function processTailwindFeatures(setupContext) {
     return function(root, result) {
-        let { tailwindDirectives , applyDirectives  } = (0, _normalizeTailwindDirectives).default(root);
-        (0, _detectNesting).default()(root, result);
+        let { tailwindDirectives , applyDirectives  } = (0, _normalizeTailwindDirectives.default)(root);
+        (0, _detectNesting.default)()(root, result);
+        // Partition apply rules that are found in the css
+        // itself.
+        (0, _partitionApplyAtRules.default)()(root, result);
         let context = setupContext({
             tailwindDirectives,
             applyDirectives,
             registerDependency (dependency) {
                 result.messages.push({
-                    plugin: 'tailwindcss',
+                    plugin: "tailwindcss",
                     parent: result.opts.from,
                     ...dependency
                 });
             },
             createContext (tailwindConfig, changedContent) {
-                return (0, _setupContextUtils).createContext(tailwindConfig, changedContent, root);
+                return (0, _setupContextUtils.createContext)(tailwindConfig, changedContent, root);
             }
         })(root, result);
-        if (context.tailwindConfig.separator === '-') {
+        if (context.tailwindConfig.separator === "-") {
             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);
-        (0, _expandApplyAtRules).default(context)(root, result);
-        (0, _evaluateTailwindFunctions).default(context)(root, result);
-        (0, _substituteScreenAtRules).default(context)(root, result);
-        (0, _resolveDefaultsAtRules).default(context)(root, result);
-        (0, _collapseAdjacentRules).default(context)(root, result);
-        (0, _collapseDuplicateDeclarations).default(context)(root, result);
+        (0, _featureFlags.issueFlagNotices)(context.tailwindConfig);
+        (0, _expandTailwindAtRules.default)(context)(root, result);
+        // Partition apply rules that are generated by
+        // addComponents, addUtilities and so on.
+        (0, _partitionApplyAtRules.default)()(root, result);
+        (0, _expandApplyAtRules.default)(context)(root, result);
+        (0, _evaluateTailwindFunctions.default)(context)(root, result);
+        (0, _substituteScreenAtRules.default)(context)(root, result);
+        (0, _resolveDefaultsAtRules.default)(context)(root, result);
+        (0, _collapseAdjacentRules.default)(context)(root, result);
+        (0, _collapseDuplicateDeclarations.default)(context)(root, result);
     };
 }