tailwindcss 3.0.8 → 3.0.12

package/lib/lib/collapseDuplicateDeclarations.js

@@ -8,6 +8,7 @@ function collapseDuplicateDeclarations() {
         root.walkRules((node)=>{
             let seen = new Map();
             let droppable = new Set([]);
+            let byProperty = new Map();
             node.walkDecls((decl)=>{
                 // This could happen if we have nested selectors. In that case the
                 // parent will loop over all its declarations but also the declarations
@@ -17,13 +18,63 @@ function collapseDuplicateDeclarations() {
                     return;
                 }
                 if (seen.has(decl.prop)) {
-                    droppable.add(seen.get(decl.prop));
+                    // Exact same value as what we have seen so far
+                    if (seen.get(decl.prop).value === decl.value) {
+                        // Keep the last one, drop the one we've seen so far
+                        droppable.add(seen.get(decl.prop));
+                        // Override the existing one with the new value. This is necessary
+                        // so that if we happen to have more than one declaration with the
+                        // same value, that we keep removing the previous one. Otherwise we
+                        // will only remove the *first* one.
+                        seen.set(decl.prop, decl);
+                        return;
+                    }
+                    // Not the same value, so we need to check if we can merge it so
+                    // let's collect it first.
+                    if (!byProperty.has(decl.prop)) {
+                        byProperty.set(decl.prop, new Set());
+                    }
+                    byProperty.get(decl.prop).add(seen.get(decl.prop));
+                    byProperty.get(decl.prop).add(decl);
                 }
                 seen.set(decl.prop, decl);
             });
+            // Drop all the duplicate declarations with the exact same value we've
+            // already seen so far.
             for (let decl1 of droppable){
                 decl1.remove();
             }
+            // Analyze the declarations based on its unit, drop all the declarations
+            // with the same unit but the last one in the list.
+            for (let declarations of byProperty.values()){
+                let byUnit = new Map();
+                for (let decl of declarations){
+                    let unit = resolveUnit(decl.value);
+                    if (unit === null) {
+                        continue;
+                    }
+                    if (!byUnit.has(unit)) {
+                        byUnit.set(unit, new Set());
+                    }
+                    byUnit.get(unit).add(decl);
+                }
+                for (let declarations1 of byUnit.values()){
+                    // Get all but the last one
+                    let removableDeclarations = Array.from(declarations1).slice(0, -1);
+                    for (let decl of removableDeclarations){
+                        decl.remove();
+                    }
+                }
+            }
         });
     };
 }
+let UNITLESS_NUMBER = Symbol('unitless-number');
+function resolveUnit(input) {
+    let result = /^-?\d*.?\d+([\w%]+)?$/g.exec(input);
+    if (result) {
+        var ref;
+        return (ref = result[1]) !== null && ref !== void 0 ? ref : UNITLESS_NUMBER;
+    }
+    return null;
+}

package/lib/lib/defaultExtractor.js

@@ -15,9 +15,11 @@ const PATTERNS = [
     /([^<>"'`\s]*\[\w*\("[^'`\s]*"\)\])/.source,
     /([^<>"'`\s]*\['[^"'`\s]*'\])/.source,
     /([^<>"'`\s]*\["[^"'`\s]*"\])/.source,
+    /([^<>"'`\s]*\[[^<>"'`\s]*:[^\]\s]*\])/.source,
     /([^<>"'`\s]*\[[^<>"'`\s]*:'[^"'`\s]*'\])/.source,
     /([^<>"'`\s]*\[[^<>"'`\s]*:"[^"'`\s]*"\])/.source,
     /([^<>"'`\s]*\[[^"'`\s]+\][^<>"'`\s]*)/.source,
+    /([^"'`\s]*[^<>"'`\s:\\])/.source,
     /([^<>"'`\s]*[^"'`\s:\\])/.source, 
 ].join('|');
 const BROAD_MATCH_GLOBAL_REGEXP = new RegExp(PATTERNS, 'g');

package/lib/lib/expandApplyAtRules.js

@@ -75,45 +75,6 @@ function extractApplyCandidates(params) {
         false
     ];
 }
-function partitionApplyParents(root) {
-    let applyParents = new Set();
-    root.walkAtRules('apply', (rule)=>{
-        applyParents.add(rule.parent);
-    });
-    for (let rule1 of applyParents){
-        let nodeGroups = [];
-        let lastGroup = [];
-        for (let node of rule1.nodes){
-            if (node.type === 'atrule' && node.name === 'apply') {
-                if (lastGroup.length > 0) {
-                    nodeGroups.push(lastGroup);
-                    lastGroup = [];
-                }
-                nodeGroups.push([
-                    node
-                ]);
-            } else {
-                lastGroup.push(node);
-            }
-        }
-        if (lastGroup.length > 0) {
-            nodeGroups.push(lastGroup);
-        }
-        if (nodeGroups.length === 1) {
-            continue;
-        }
-        for (let group of [
-            ...nodeGroups
-        ].reverse()){
-            let newParent = rule1.clone({
-                nodes: []
-            });
-            newParent.append(group);
-            rule1.after(newParent);
-        }
-        rule1.remove();
-    }
-}
 function processApply(root, context) {
     let applyCandidates = new Set();
     // Collect all @apply rules and candidates
@@ -311,7 +272,6 @@ function processApply(root, context) {
 }
 function expandApplyAtRules(context) {
     return (root)=>{
-        partitionApplyParents(root);
         processApply(root, context);
     };
 }

package/lib/lib/expandTailwindAtRules.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 exports.default = expandTailwindAtRules;
-exports.DEFAULTS_LAYER = void 0;
 var _quickLru = _interopRequireDefault(require("quick-lru"));
 var sharedState = _interopRequireWildcard(require("./sharedState"));
 var _generateRules = require("./generateRules");
@@ -133,8 +132,6 @@ function buildStylesheet(rules, context) {
     }
     return returnValue;
 }
-const DEFAULTS_LAYER = Symbol('defaults-layer');
-exports.DEFAULTS_LAYER = DEFAULTS_LAYER;
 function expandTailwindAtRules(context) {
     return (root)=>{
         let layerNodes = {
@@ -143,13 +140,15 @@ function expandTailwindAtRules(context) {
             utilities: null,
             variants: null
         };
-        // Make sure this file contains Tailwind directives. If not, we can save
-        // a lot of work and bail early. Also we don't have to register our touch
-        // file as a dependency since the output of this CSS does not depend on
-        // the source of any templates. Think Vue <style> blocks for example.
-        root.walkAtRules('tailwind', (rule)=>{
-            if (Object.keys(layerNodes).includes(rule.params)) {
-                layerNodes[rule.params] = rule;
+        root.walkAtRules((rule)=>{
+            // Make sure this file contains Tailwind directives. If not, we can save
+            // a lot of work and bail early. Also we don't have to register our touch
+            // file as a dependency since the output of this CSS does not depend on
+            // the source of any templates. Think Vue <style> blocks for example.
+            if (rule.name === 'tailwind') {
+                if (Object.keys(layerNodes).includes(rule.params)) {
+                    layerNodes[rule.params] = rule;
+                }
             }
         });
         if (Object.values(layerNodes).every((n)=>n === null
@@ -168,6 +167,7 @@ function expandTailwindAtRules(context) {
             let extractor = getExtractor(context.tailwindConfig, extension);
             getClassCandidates(transformer(content), extractor, candidates, seen);
         }
+        env.DEBUG && console.timeEnd('Reading changed files');
         // ---
         // Generate the actual CSS
         let classCacheCount = context.classCache.size;
@@ -190,23 +190,10 @@ function expandTailwindAtRules(context) {
         // Replace any Tailwind directives with generated CSS
         if (layerNodes.base) {
             layerNodes.base.before((0, _cloneNodes).default([
-                ...baseNodes
+                ...baseNodes,
+                ...defaultNodes
             ], layerNodes.base.source));
         }
-        // @defaults rules are unconditionally added first to ensure that
-        // using any utility that relies on defaults will work even when
-        // compiled in an isolated environment like CSS modules
-        if (context.tailwindConfig[DEFAULTS_LAYER] !== false) {
-            if (layerNodes.base) {
-                layerNodes.base.after((0, _cloneNodes).default([
-                    ...defaultNodes
-                ], root.source));
-            } else {
-                root.prepend((0, _cloneNodes).default([
-                    ...defaultNodes
-                ], root.source));
-            }
-        }
         if (layerNodes.base) {
             layerNodes.base.remove();
         }

package/lib/lib/normalizeTailwindDirectives.js

@@ -12,7 +12,11 @@ function _interopRequireDefault(obj) {
 function normalizeTailwindDirectives(root) {
     let tailwindDirectives = new Set();
     let layerDirectives = new Set();
+    let applyDirectives = new Set();
     root.walkAtRules((atRule)=>{
+        if (atRule.name === 'apply') {
+            applyDirectives.add(atRule);
+        }
         if (atRule.name === 'import') {
             if (atRule.params === '"tailwindcss/base"' || atRule.params === "'tailwindcss/base'") {
                 atRule.name = 'tailwind';
@@ -72,5 +76,8 @@ function normalizeTailwindDirectives(root) {
             }
         }
     }
-    return tailwindDirectives;
+    return {
+        tailwindDirectives,
+        applyDirectives
+    };
 }

package/lib/lib/resolveDefaultsAtRules.js

@@ -109,11 +109,11 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                     selectors.add(selector);
                 }
             }
-            if (selectorGroups.size === 0) {
-                universal.remove();
-                continue;
-            }
             if ((0, _featureFlags).flagEnabled(tailwindConfig, 'optimizeUniversalDefaults')) {
+                if (selectorGroups.size === 0) {
+                    universal.remove();
+                    continue;
+                }
                 for (let [, selectors] of selectorGroups){
                     let universalRule = _postcss.default.rule();
                     universalRule.selectors = [

package/lib/lib/setupContextUtils.js

@@ -52,6 +52,55 @@ function _interopRequireWildcard(obj) {
         return newObj;
     }
 }
+function partitionRules(root) {
+    if (!root.walkAtRules) return [
+        root
+    ];
+    let applyParents = new Set();
+    let rules = [];
+    root.walkAtRules('apply', (rule)=>{
+        applyParents.add(rule.parent);
+    });
+    if (applyParents.size === 0) {
+        rules.push(root);
+    }
+    for (let rule1 of applyParents){
+        let nodeGroups = [];
+        let lastGroup = [];
+        for (let node of rule1.nodes){
+            if (node.type === 'atrule' && node.name === 'apply') {
+                if (lastGroup.length > 0) {
+                    nodeGroups.push(lastGroup);
+                    lastGroup = [];
+                }
+                nodeGroups.push([
+                    node
+                ]);
+            } else {
+                lastGroup.push(node);
+            }
+        }
+        if (lastGroup.length > 0) {
+            nodeGroups.push(lastGroup);
+        }
+        if (nodeGroups.length === 1) {
+            rules.push(rule1);
+            continue;
+        }
+        for (let group of [
+            ...nodeGroups
+        ].reverse()){
+            let clone = rule1.clone({
+                nodes: []
+            });
+            clone.append(group);
+            rules.unshift(clone);
+            rule1.after(clone);
+        }
+        rule1.remove();
+    }
+    return rules;
+}
 function parseVariantFormatString(input) {
     if (input.includes('{')) {
         if (!isBalanced(input)) throw new Error(`Your { and } are unbalanced.`);
@@ -112,44 +161,49 @@ function getClasses(selector) {
     });
     return parser.transformSync(selector);
 }
-function extractCandidates(node) {
+function extractCandidates(node, state = {
+    containsNonOnDemandable: false
+}, depth = 0) {
     let classes = [];
+    // Handle normal rules
     if (node.type === 'rule') {
         for (let selector of node.selectors){
             let classCandidates = getClasses(selector);
             // At least one of the selectors contains non-"on-demandable" candidates.
-            if (classCandidates.length === 0) return [];
-            classes = [
-                ...classes,
-                ...classCandidates
-            ];
+            if (classCandidates.length === 0) {
+                state.containsNonOnDemandable = true;
+            }
+            for (let classCandidate of classCandidates){
+                classes.push(classCandidate);
+            }
         }
-        return classes;
-    }
-    if (node.type === 'atrule') {
+    } else if (node.type === 'atrule') {
         node.walkRules((rule)=>{
-            classes = [
-                ...classes,
-                ...rule.selectors.flatMap((selector)=>getClasses(selector)
-                )
-            ];
+            for (let classCandidate of rule.selectors.flatMap((selector)=>getClasses(selector, state, depth + 1)
+            )){
+                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 candidates = extractCandidates(node);
-        // If this isn't "on-demandable", assign it a universal candidate.
-        if (candidates.length === 0) {
-            return [
-                [
-                    '*',
-                    node
-                ]
-            ];
+        let [containsNonOnDemandableSelectors, candidates] = extractCandidates(node);
+        // If this isn't "on-demandable", assign it a universal candidate to always include it.
+        if (containsNonOnDemandableSelectors) {
+            candidates.unshift('*');
         }
+        // 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);
@@ -240,35 +294,37 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
             return [];
         },
         addUserCss (userCss) {
-            for (let [identifier, rule] of withIdentifiers(userCss)){
+            for (let [identifier, rule2] of withIdentifiers(userCss)){
                 let offset = offsets.user++;
                 if (!context.candidateRuleMap.has(identifier)) {
                     context.candidateRuleMap.set(identifier, []);
                 }
-                context.candidateRuleMap.get(identifier).push([
-                    {
-                        sort: offset,
-                        layer: 'user'
-                    },
-                    rule
-                ]);
+                context.candidateRuleMap.get(identifier).push(...partitionRules(rule2).map((rule)=>[
+                        {
+                            sort: offset,
+                            layer: 'user'
+                        },
+                        rule
+                    ]
+                ));
             }
         },
         addBase (base) {
-            for (let [identifier, rule] of withIdentifiers(base)){
+            for (let [identifier, rule3] of withIdentifiers(base)){
                 let prefixedIdentifier = prefixIdentifier(identifier, {
                 });
                 let offset = offsets.base++;
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offset,
-                        layer: 'base'
-                    },
-                    rule
-                ]);
+                context.candidateRuleMap.get(prefixedIdentifier).push(...partitionRules(rule3).map((rule)=>[
+                        {
+                            sort: offset,
+                            layer: 'base'
+                        },
+                        rule
+                    ]
+                ));
             }
         },
         /**
@@ -278,20 +334,20 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
             const groups = {
                 [`@defaults ${group}`]: declarations
             };
-            for (let [identifier, rule] of withIdentifiers(groups)){
+            for (let [identifier, rule4] of withIdentifiers(groups)){
                 let prefixedIdentifier = prefixIdentifier(identifier, {
                 });
-                let offset = offsets.base++;
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offset,
-                        layer: 'defaults'
-                    },
-                    rule
-                ]);
+                context.candidateRuleMap.get(prefixedIdentifier).push(...partitionRules(rule4).map((rule)=>[
+                        {
+                            sort: offsets.base++,
+                            layer: 'defaults'
+                        },
+                        rule, 
+                    ]
+                ));
             }
         },
         addComponents (components, options) {
@@ -302,21 +358,21 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
             options = Object.assign({
             }, defaultOptions, Array.isArray(options) ? {
             } : options);
-            for (let [identifier, rule] of withIdentifiers(components)){
+            for (let [identifier, rule5] of withIdentifiers(components)){
                 let prefixedIdentifier = prefixIdentifier(identifier, options);
-                let offset = offsets.components++;
                 classList.add(prefixedIdentifier);
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offset,
-                        layer: 'components',
-                        options
-                    },
-                    rule
-                ]);
+                context.candidateRuleMap.get(prefixedIdentifier).push(...partitionRules(rule5).map((rule)=>[
+                        {
+                            sort: offsets.components++,
+                            layer: 'components',
+                            options
+                        },
+                        rule, 
+                    ]
+                ));
             }
         },
         addUtilities (utilities, options) {
@@ -327,21 +383,21 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
             options = Object.assign({
             }, defaultOptions, Array.isArray(options) ? {
             } : options);
-            for (let [identifier, rule] of withIdentifiers(utilities)){
+            for (let [identifier, rule6] of withIdentifiers(utilities)){
                 let prefixedIdentifier = prefixIdentifier(identifier, options);
-                let offset = offsets.utilities++;
                 classList.add(prefixedIdentifier);
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
-                context.candidateRuleMap.get(prefixedIdentifier).push([
-                    {
-                        sort: offset,
-                        layer: 'utilities',
-                        options
-                    },
-                    rule
-                ]);
+                context.candidateRuleMap.get(prefixedIdentifier).push(...partitionRules(rule6).map((rule)=>[
+                        {
+                            sort: offsets.utilities++,
+                            layer: 'utilities',
+                            options
+                        },
+                        rule, 
+                    ]
+                ));
             }
         },
         matchUtilities: function(utilities, options) {
@@ -463,11 +519,17 @@ function getFileModifiedMap(context) {
 function trackModified(files, fileModifiedMap) {
     let changed = false;
     for (let file of files){
+        var ref;
         if (!file) continue;
         let parsed = _url.default.parse(file);
         let pathname = parsed.hash ? parsed.href.replace(parsed.hash, '') : parsed.href;
         pathname = parsed.search ? pathname.replace(parsed.search, '') : pathname;
-        let newModified = _fs.default.statSync(decodeURIComponent(pathname)).mtimeMs;
+        let newModified = (ref = _fs.default.statSync(decodeURIComponent(pathname), {
+            throwIfNoEntry: false
+        })) === null || ref === void 0 ? void 0 : ref.mtimeMs;
+        if (!newModified) {
+            continue;
+        }
         if (!fileModifiedMap.has(file) || newModified > fileModifiedMap.get(file)) {
             changed = true;
         }

package/lib/lib/setupTrackingContext.js

@@ -119,16 +119,17 @@ function resolveChangedFiles(candidateFiles, fileModifiedMap) {
     return changedFiles;
 }
 function setupTrackingContext(configOrPath) {
-    return ({ tailwindDirectives , registerDependency  })=>{
+    return ({ tailwindDirectives , registerDependency , applyDirectives  })=>{
         return (root, result)=>{
             let [tailwindConfig, userConfigPath, tailwindConfigHash, configDependencies] = getTailwindConfig(configOrPath);
             let contextDependencies = new Set(configDependencies);
-            // If there are no @tailwind 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) {
+            // If there are no @tailwind or @apply rules, we don't consider this CSS
+            // file or its 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) {
                 // Add current css file as a context dependencies.
                 contextDependencies.add(result.opts.from);
                 // Add all css @import dependencies as context dependencies.
@@ -140,12 +141,12 @@ function setupTrackingContext(configOrPath) {
             }
             let [context] = (0, _setupContextUtils).getContext(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
             let candidateFiles = getCandidateFiles(context, tailwindConfig);
-            // If there are no @tailwind 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.
+            // 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) {
+            if (tailwindDirectives.size > 0 || applyDirectives.size > 0) {
                 let fileModifiedMap = (0, _setupContextUtils).getFileModifiedMap(context);
                 // Add template paths as postcss dependencies.
                 for (let fileOrGlob of candidateFiles){

package/lib/lib/sharedState.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+exports.resolveDebug = resolveDebug;
 exports.contextSourcesMap = exports.configContextMap = exports.contextMap = exports.env = void 0;
 const env = {
-    TAILWIND_MODE: process.env.TAILWIND_MODE,
     NODE_ENV: process.env.NODE_ENV,
-    DEBUG: process.env.DEBUG !== undefined && process.env.DEBUG !== '0',
-    TAILWIND_DISABLE_TOUCH: process.env.TAILWIND_DISABLE_TOUCH !== undefined,
-    TAILWIND_TOUCH_DIR: process.env.TAILWIND_TOUCH_DIR
+    DEBUG: resolveDebug(process.env.DEBUG)
 };
 exports.env = env;
 const contextMap = new Map();
@@ -17,3 +15,34 @@ const configContextMap = new Map();
 exports.configContextMap = configContextMap;
 const contextSourcesMap = new Map();
 exports.contextSourcesMap = contextSourcesMap;
+function resolveDebug(debug) {
+    if (debug === undefined) {
+        return false;
+    }
+    // Environment variables are strings, so convert to boolean
+    if (debug === 'true' || debug === '1') {
+        return true;
+    }
+    if (debug === 'false' || debug === '0') {
+        return false;
+    }
+    // Keep the debug convention into account:
+    // DEBUG=* -> This enables all debug modes
+    // 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 === '*') {
+        return true;
+    }
+    let debuggers = debug.split(',').map((d)=>d.split(':')[0]
+    );
+    // Ignoring tailwindcss
+    if (debuggers.includes('-tailwindcss')) {
+        return false;
+    }
+    // Including tailwindcss
+    if (debuggers.includes('tailwindcss')) {
+        return true;
+    }
+    return false;
+}

package/lib/processTailwindFeatures.js

@@ -21,9 +21,11 @@ function _interopRequireDefault(obj) {
 }
 function processTailwindFeatures(setupContext) {
     return function(root, result) {
-        let tailwindDirectives = (0, _normalizeTailwindDirectives).default(root);
+        let { tailwindDirectives , applyDirectives  } = (0, _normalizeTailwindDirectives).default(root);
+        (0, _detectNesting).default()(root, result);
         let context = setupContext({
             tailwindDirectives,
+            applyDirectives,
             registerDependency (dependency) {
                 result.messages.push({
                     plugin: 'tailwindcss',
@@ -39,7 +41,6 @@ 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, _detectNesting).default(context)(root, result);
         (0, _expandTailwindAtRules).default(context)(root, result);
         (0, _expandApplyAtRules).default(context)(root, result);
         (0, _evaluateTailwindFunctions).default(context)(root, result);