tailwindcss 3.3.3 → 3.3.5

package/CHANGELOG.md

@@ -7,7 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-- Nothing yet!
+## [3.3.5] - 2023-10-25
+
+### Fixed
+
+- Fix incorrect spaces around `-` in `calc()` expression ([#12283](https://github.com/tailwindlabs/tailwindcss/pull/12283))
+
+## [3.3.4] - 2023-10-24
+
+### Fixed
+
+- Improve normalisation of `calc()`-like functions ([#11686](https://github.com/tailwindlabs/tailwindcss/pull/11686))
+- Skip `calc()` normalisation in nested `theme()` calls ([#11705](https://github.com/tailwindlabs/tailwindcss/pull/11705))
+- Fix incorrectly generated CSS when using square brackets inside arbitrary properties ([#11709](https://github.com/tailwindlabs/tailwindcss/pull/11709))
+- Make `content` optional for presets in TypeScript types ([#11730](https://github.com/tailwindlabs/tailwindcss/pull/11730))
+- Handle variable colors that have variable fallback values ([#12049](https://github.com/tailwindlabs/tailwindcss/pull/12049))
+- Batch reading content files to prevent `too many open files` error ([#12079](https://github.com/tailwindlabs/tailwindcss/pull/12079))
+- Skip over classes inside `:not(…)` when nested in an at-rule ([#12105](https://github.com/tailwindlabs/tailwindcss/pull/12105))
+- Update types to work with `Node16` module resolution ([#12097](https://github.com/tailwindlabs/tailwindcss/pull/12097))
+- Don’t crash when important and parent selectors are equal in `@apply` ([#12112](https://github.com/tailwindlabs/tailwindcss/pull/12112))
+- Eliminate irrelevant rules when applying variants ([#12113](https://github.com/tailwindlabs/tailwindcss/pull/12113))
+- Improve RegEx parser, reduce possibilities as the key for arbitrary properties ([#12121](https://github.com/tailwindlabs/tailwindcss/pull/12121))
+- Fix sorting of utilities that share multiple candidates ([#12173](https://github.com/tailwindlabs/tailwindcss/pull/12173))
+- Ensure variants with arbitrary values and a modifier are correctly matched in the RegEx based parser ([#12179](https://github.com/tailwindlabs/tailwindcss/pull/12179))
+- Fix crash when watching renamed files on FreeBSD ([#12193](https://github.com/tailwindlabs/tailwindcss/pull/12193))
+- Allow plugins from a parent document to be used in an iframe ([#12208](https://github.com/tailwindlabs/tailwindcss/pull/12208))
+- Add types for `tailwindcss/nesting` ([#12269](https://github.com/tailwindlabs/tailwindcss/pull/12269))
+- Bump `jiti`, `fast-glob`, and `browserlist` dependencies ([#11550](https://github.com/tailwindlabs/tailwindcss/pull/11550))
+- Improve automatic `var` injection for properties that accept a `<dashed-ident>` ([#12236](https://github.com/tailwindlabs/tailwindcss/pull/12236))
 
 ## [3.3.3] - 2023-07-13
 
@@ -2260,7 +2287,9 @@ No release notes
 
 - Everything!
 
-[unreleased]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.3...HEAD
+[unreleased]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.5...HEAD
+[3.3.5]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.4...v3.3.5
+[3.3.4]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.3...v3.3.4
 [3.3.3]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.2...v3.3.3
 [3.3.2]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.1...v3.3.2
 [3.3.1]: https://github.com/tailwindlabs/tailwindcss/compare/v3.3.0...v3.3.1

package/lib/cli/build/watching.js

@@ -126,7 +126,7 @@ function createWatcher(args, { state , rebuild  }) {
     // This is very likely a chokidar bug but it's one we need to work around
     // We treat this as a change event and rebuild the CSS
     watcher.on("raw", (evt, filePath, meta)=>{
-        if (evt !== "rename") {
+        if (evt !== "rename" || filePath === null) {
             return;
         }
         let watchedPath = meta.watchedPath;

package/lib/lib/defaultExtractor.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "defaultExtractor", {
         return defaultExtractor;
     }
 });
-const _featureFlags = require("../featureFlags");
 const _regex = /*#__PURE__*/ _interop_require_wildcard(require("./regex"));
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -57,17 +56,15 @@ function defaultExtractor(context) {
         /** @type {(string|string)[]} */ let results = [];
         for (let pattern of patterns){
             var _content_match;
-            results = [
-                ...results,
-                ...(_content_match = content.match(pattern)) !== null && _content_match !== void 0 ? _content_match : []
-            ];
+            for (let result of (_content_match = content.match(pattern)) !== null && _content_match !== void 0 ? _content_match : []){
+                results.push(clipAtBalancedParens(result));
+            }
         }
-        return results.filter((v)=>v !== undefined).map(clipAtBalancedParens);
+        return results;
     };
 }
 function* buildRegExps(context) {
     let separator = context.tailwindConfig.separator;
-    let variantGroupingEnabled = (0, _featureFlags.flagEnabled)(context.tailwindConfig, "variantGrouping");
     let prefix = context.tailwindConfig.prefix !== "" ? _regex.optional(_regex.pattern([
         /-?/,
         _regex.escape(context.tailwindConfig.prefix)
@@ -79,7 +76,7 @@ function* buildRegExps(context) {
         // This is a targeted fix to continue to allow theme()
         // with square brackets to work in arbitrary properties
         // while fixing a problem with the regex matching too much
-        /\[[^\s:'"`]+:[^\s]+?\[[^\s]+\][^\s]+?\]/,
+        /\[[^\s:'"`\]]+:[^\s]+?\[[^\s]+\][^\s]+?\]/,
         // Utilities
         _regex.pattern([
             // Utility Name / Group Name
@@ -115,6 +112,11 @@ function* buildRegExps(context) {
                 /@\[[^\s"'`]+\](\/[^\s"'`]+)?/,
                 separator
             ]),
+            // With variant modifier (e.g.: group-[..]/modifier)
+            _regex.pattern([
+                /([^\s"'`\[\\]+-)?\[[^\s"'`]+\]\/\w+/,
+                separator
+            ]),
             _regex.pattern([
                 /([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/,
                 separator
@@ -126,6 +128,11 @@ function* buildRegExps(context) {
         ]),
         // With quotes allowed
         _regex.any([
+            // With variant modifier (e.g.: group-[..]/modifier)
+            _regex.pattern([
+                /([^\s"'`\[\\]+-)?\[[^\s`]+\]\/\w+/,
+                separator
+            ]),
             _regex.pattern([
                 /([^\s"'`\[\\]+-)?\[[^\s`]+\]/,
                 separator
@@ -145,20 +152,7 @@ function* buildRegExps(context) {
             // Important (optional)
             /!?/,
             prefix,
-            variantGroupingEnabled ? _regex.any([
-                // Or any of those things but grouped separated by commas
-                _regex.pattern([
-                    /\(/,
-                    utility,
-                    _regex.zeroOrMore([
-                        /,/,
-                        utility
-                    ]),
-                    /\)/
-                ]),
-                // Arbitrary properties, constrained utilities, arbitrary values, etc…
-                utility
-            ]) : utility
+            utility
         ]);
     }
     // 5. Inner matches

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

@@ -165,12 +165,26 @@ function expandTailwindAtRules(context) {
         //   getClassCandidatesOxide(file, transformer(content), extractor, candidates, seen)
         // }
         } else {
-            await Promise.all(context.changedContent.map(async ({ file , content , extension  })=>{
-                let transformer = getTransformer(context.tailwindConfig, extension);
-                let extractor = getExtractor(context, extension);
-                content = file ? await _fs.default.promises.readFile(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");
         // ---

package/lib/lib/generateRules.js

@@ -500,7 +500,9 @@ 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;
     }
@@ -578,7 +580,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;
@@ -586,14 +588,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) => {
@@ -753,8 +747,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"
@@ -766,7 +759,7 @@ function* resolveMatches(candidate, context, original = candidate) {
         }
     }
 }
-function applyFinalFormat(match, { context , candidate , original  }) {
+function applyFinalFormat(match, { context , candidate  }) {
     if (!match[0].collectedFormats) {
         return match;
     }
@@ -799,10 +792,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
@@ -843,7 +843,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){
@@ -874,9 +874,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/setupContextUtils.js

@@ -201,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 [
@@ -927,7 +929,7 @@ 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){

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

@@ -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/util/color.js

@@ -27,7 +27,7 @@ let SHORT_HEX = /^#([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i;
 let VALUE = /(?:\d+|\d*\.\d+)%?/;
 let SEP = /(?:\s*,\s*|\s+)/;
 let ALPHA_SEP = /\s*[,/]\s*/;
-let CUSTOM_PROPERTY = /var\(--(?:[^ )]*?)\)/;
+let CUSTOM_PROPERTY = /var\(--(?:[^ )]*?)(?:,(?:[^ )]*?|var\(--[^ )]*?\)))?\)/;
 let RGB = new RegExp(`^(rgba?)\\(\\s*(${VALUE.source}|${CUSTOM_PROPERTY.source})(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${ALPHA_SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?\\s*\\)$`);
 let HSL = new RegExp(`^(hsla?)\\(\\s*((?:${VALUE.source})(?:deg|rad|grad|turn)?|${CUSTOM_PROPERTY.source})(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${ALPHA_SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?\\s*\\)$`);
 function parseColor(value, { loose =false  } = {}) {

package/lib/util/dataTypes.js

@@ -68,10 +68,30 @@ let cssFunctions = [
 function isCSSFunction(value) {
     return cssFunctions.some((fn)=>new RegExp(`^${fn}\\(.*\\)`).test(value));
 }
-const placeholder = "--tw-placeholder";
-const placeholderRe = new RegExp(placeholder, "g");
-function normalize(value, isRoot = true) {
-    if (value.startsWith("--")) {
+// These properties accept a `<dashed-ident>` as one of the values. This means that you can use them
+// as: `timeline-scope: --tl;`
+//
+// Without the `var(--tl)`, in these cases we don't want to normalize the value, and you should add
+// the `var()` yourself.
+//
+// More info:
+// - https://drafts.csswg.org/scroll-animations/#propdef-timeline-scope
+// - https://developer.mozilla.org/en-US/docs/Web/CSS/timeline-scope#dashed-ident
+//
+const AUTO_VAR_INJECTION_EXCEPTIONS = new Set([
+    // Concrete properties
+    "scroll-timeline-name",
+    "timeline-scope",
+    "view-timeline-name",
+    "font-palette",
+    // Shorthand properties
+    "scroll-timeline",
+    "animation-timeline",
+    "view-timeline"
+]);
+function normalize(value, context = null, isRoot = true) {
+    let isVarException = context && AUTO_VAR_INJECTION_EXCEPTIONS.has(context.property);
+    if (value.startsWith("--") && !isVarException) {
         return `var(${value})`;
     }
     // Keep raw strings if it starts with `url(`
@@ -80,7 +100,7 @@ function normalize(value, isRoot = true) {
             if (/^url\(.*?\)$/.test(part)) {
                 return part;
             }
-            return normalize(part, false);
+            return normalize(part, context, false);
         }).join("");
     }
     // Convert `_` to ` `, except for escaped underscores `\_`
@@ -99,12 +119,92 @@ function normalize(value, isRoot = true) {
  * @param {string} value
  * @returns {string}
  */ function normalizeMathOperatorSpacing(value) {
+    let preventFormattingInFunctions = [
+        "theme"
+    ];
+    let preventFormattingKeywords = [
+        "min-content",
+        "max-content",
+        "fit-content",
+        // Env
+        "safe-area-inset-top",
+        "safe-area-inset-right",
+        "safe-area-inset-bottom",
+        "safe-area-inset-left",
+        "titlebar-area-x",
+        "titlebar-area-y",
+        "titlebar-area-width",
+        "titlebar-area-height",
+        "keyboard-inset-top",
+        "keyboard-inset-right",
+        "keyboard-inset-bottom",
+        "keyboard-inset-left",
+        "keyboard-inset-width",
+        "keyboard-inset-height"
+    ];
     return value.replace(/(calc|min|max|clamp)\(.+\)/g, (match)=>{
-        let vars = [];
-        return match.replace(/var\((--.+?)[,)]/g, (match, g1)=>{
-            vars.push(g1);
-            return match.replace(g1, placeholder);
-        }).replace(/(-?\d*\.?\d(?!\b-\d.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ").replace(placeholderRe, ()=>vars.shift());
+        let result = "";
+        function lastChar() {
+            let char = result.trimEnd();
+            return char[char.length - 1];
+        }
+        for(let i = 0; i < match.length; i++){
+            function peek(word) {
+                return word.split("").every((char, j)=>match[i + j] === char);
+            }
+            function consumeUntil(chars) {
+                let minIndex = Infinity;
+                for (let char of chars){
+                    let index = match.indexOf(char, i);
+                    if (index !== -1 && index < minIndex) {
+                        minIndex = index;
+                    }
+                }
+                let result = match.slice(i, minIndex);
+                i += result.length - 1;
+                return result;
+            }
+            let char = match[i];
+            // Handle `var(--variable)`
+            if (peek("var")) {
+                // When we consume until `)`, then we are dealing with this scenario:
+                //   `var(--example)`
+                //
+                // When we consume until `,`, then we are dealing with this scenario:
+                //   `var(--example, 1rem)`
+                //
+                //   In this case we do want to "format", the default value as well
+                result += consumeUntil([
+                    ")",
+                    ","
+                ]);
+            } else if (preventFormattingKeywords.some((keyword)=>peek(keyword))) {
+                let keyword = preventFormattingKeywords.find((keyword)=>peek(keyword));
+                result += keyword;
+                i += keyword.length - 1;
+            } else if (preventFormattingInFunctions.some((fn)=>peek(fn))) {
+                result += consumeUntil([
+                    ")"
+                ]);
+            } else if ([
+                "+",
+                "-",
+                "*",
+                "/"
+            ].includes(char) && ![
+                "(",
+                "+",
+                "-",
+                "*",
+                "/"
+            ].includes(lastChar())) {
+                result += ` ${char} `;
+            } else {
+                result += char;
+            }
+        }
+        // Simplify multiple spaces
+        return result.replace(/\s+/g, " ");
     });
 }
 function url(value) {

package/lib/util/formatVariantSelector.js

@@ -27,6 +27,7 @@ const _unesc = /*#__PURE__*/ _interop_require_default(require("postcss-selector-
 const _escapeClassName = /*#__PURE__*/ _interop_require_default(require("../util/escapeClassName"));
 const _prefixSelector = /*#__PURE__*/ _interop_require_default(require("../util/prefixSelector"));
 const _pseudoElements = require("./pseudoElements");
+const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -138,7 +139,7 @@ function finalizeSelector(current, formats, { context , candidate , base  }) {
     //           │  │     │            ╰── We will not split here
     //           ╰──┴─────┴─────────────── We will split here
     //
-    base = base !== null && base !== void 0 ? base : candidate.split(new RegExp(`\\${separator}(?![^[]*\\])`)).pop();
+    base = base !== null && base !== void 0 ? base : (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(candidate, separator).pop();
     // Parse the selector into an AST
     let selector = (0, _postcssselectorparser.default)().astSync(current);
     // Normalize escaped classes, e.g.:
@@ -159,6 +160,12 @@ function finalizeSelector(current, formats, { context , candidate , base  }) {
     });
     // Remove extraneous selectors that do not include the base candidate
     selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
+    // If ffter eliminating irrelevant selectors, we end up with nothing
+    // Then the whole "rule" this is associated with does not need to exist
+    // We use `null` as a marker value for that case
+    if (selector.length === 0) {
+        return null;
+    }
     // If there are no formats that means there were no variants added to the candidate
     // so we can just return the selector as-is
     let formatAst = Array.isArray(formats) ? formatVariantSelector(formats, {

package/lib/util/isPlainObject.js

@@ -13,5 +13,5 @@ function isPlainObject(value) {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);
-    return prototype === null || prototype === Object.prototype;
+    return prototype === null || Object.getPrototypeOf(prototype) === null;
 }

package/nesting/index.d.ts

@@ -0,0 +1,4 @@
+import type { AcceptedPlugin, PluginCreator } from 'postcss'
+
+declare const plugin: PluginCreator<AcceptedPlugin | string | void>
+export = plugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss",
-  "version": "3.3.3",
+  "version": "3.3.5",
   "description": "A utility-first CSS framework for rapidly building custom user interfaces.",
   "license": "MIT",
   "main": "lib/index.js",
@@ -58,8 +58,8 @@
     "eslint": "^8.39.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "jest": "^29.5.0",
-    "jest-diff": "^29.5.0",
+    "jest": "^29.6.0",
+    "jest-diff": "^29.6.0",
     "lightningcss": "1.18.0",
     "prettier": "^2.8.8",
     "rimraf": "^5.0.0",
@@ -72,10 +72,10 @@
     "chokidar": "^3.5.3",
     "didyoumean": "^1.2.2",
     "dlv": "^1.1.3",
-    "fast-glob": "^3.2.12",
+    "fast-glob": "^3.3.0",
     "glob-parent": "^6.0.2",
     "is-glob": "^4.0.3",
-    "jiti": "^1.18.2",
+    "jiti": "^1.19.1",
     "lilconfig": "^2.1.0",
     "micromatch": "^4.0.5",
     "normalize-path": "^3.0.0",