tailwindcss 3.2.4 → 3.2.5

package/lib/lib/expandTailwindAtRules.js

@@ -6,12 +6,14 @@ Object.defineProperty(exports, "default", {
     enumerable: true,
     get: ()=>expandTailwindAtRules
 });
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
 const _quickLru = /*#__PURE__*/ _interopRequireDefault(require("quick-lru"));
 const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
 const _generateRules = require("./generateRules");
 const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
 const _cloneNodes = /*#__PURE__*/ _interopRequireDefault(require("../util/cloneNodes"));
 const _defaultExtractor = require("./defaultExtractor");
+const _oxide = /*#__PURE__*/ _interopRequireDefault(require("@tailwindcss/oxide"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -142,24 +144,48 @@ function expandTailwindAtRules(context) {
         if (Object.values(layerNodes).every((n)=>n === null)) {
             return root;
         }
+        var _context_candidates;
         // ---
         // Find potential rules in changed files
         let candidates = new Set([
+            ...(_context_candidates = context.candidates) !== null && _context_candidates !== void 0 ? _context_candidates : [],
             _sharedState.NOT_ON_DEMAND
         ]);
         let seen = new Set();
         env.DEBUG && console.time("Reading changed files");
-        for (let { content , extension  } of context.changedContent){
-            let transformer = getTransformer(context.tailwindConfig, extension);
-            let extractor = getExtractor(context, extension);
-            getClassCandidates(transformer(content), extractor, candidates, seen);
+        if (env.OXIDE) {
+            // TODO: Pass through or implement `extractor`
+            for (let candidate of _oxide.default.parseCandidateStringsFromFiles(context.changedContent)){
+                candidates.add(candidate);
+            }
+        // for (let { file, content, extension } of context.changedContent) {
+        //   let transformer = getTransformer(context.tailwindConfig, extension)
+        //   let extractor = getExtractor(context, extension)
+        //   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);
+            }
         }
         env.DEBUG && console.timeEnd("Reading changed files");
         // ---
         // Generate the actual CSS
         let classCacheCount = context.classCache.size;
         env.DEBUG && console.time("Generate rules");
-        (0, _generateRules.generateRules)(candidates, context);
+        env.DEBUG && console.time("Sorting candidates");
+        let sortedCandidates = env.OXIDE ? candidates : new Set([
+            ...candidates
+        ].sort((a, z)=>{
+            if (a === z) return 0;
+            if (a < z) return -1;
+            return 1;
+        }));
+        env.DEBUG && console.timeEnd("Sorting candidates");
+        (0, _generateRules.generateRules)(sortedCandidates, context);
         env.DEBUG && console.timeEnd("Generate rules");
         // We only ever add to the classCache, so if it didn't grow, there is nothing new.
         env.DEBUG && console.time("Build stylesheet");
@@ -199,8 +225,8 @@ function expandTailwindAtRules(context) {
         }
         // We do post-filtering to not alter the emitted order of the variants
         const variantNodes = Array.from(screenNodes).filter((node)=>{
-            var ref;
-            const parentLayer = (ref = node.raws.tailwind) === null || ref === void 0 ? void 0 : ref.parentLayer;
+            var _node_raws_tailwind;
+            const parentLayer = (_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.parentLayer;
             if (parentLayer === "components") {
                 return layerNodes.components !== null;
             }
@@ -221,8 +247,8 @@ function expandTailwindAtRules(context) {
         }
         // If we've got a utility layer and no utilities are generated there's likely something wrong
         const hasUtilityVariants = variantNodes.some((node)=>{
-            var ref;
-            return ((ref = node.raws.tailwind) === null || ref === void 0 ? void 0 : ref.parentLayer) === "utilities";
+            var _node_raws_tailwind;
+            return ((_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.parentLayer) === "utilities";
         });
         if (layerNodes.utilities && utilityNodes.size === 0 && !hasUtilityVariants) {
             _log.default.warn("content-problems", [

package/lib/lib/findAtConfigPath.js

@@ -17,9 +17,9 @@ function findAtConfigPath(root, result) {
     let configPath = null;
     let relativeTo = null;
     root.walkAtRules("config", (rule)=>{
-        var ref;
-        var _file, ref1;
-        relativeTo = (ref1 = (_file = (ref = rule.source) === null || ref === void 0 ? void 0 : ref.input.file) !== null && _file !== void 0 ? _file : result.opts.from) !== null && ref1 !== void 0 ? ref1 : null;
+        var _rule_source;
+        var _rule_source_input_file, _ref;
+        relativeTo = (_ref = (_rule_source_input_file = (_rule_source = rule.source) === null || _rule_source === void 0 ? void 0 : _rule_source.input.file) !== null && _rule_source_input_file !== void 0 ? _rule_source_input_file : result.opts.from) !== null && _ref !== void 0 ? _ref : null;
         if (relativeTo === null) {
             throw rule.error("The `@config` directive cannot be used without setting `from` in your PostCSS config.");
         }

package/lib/lib/generateRules.js

@@ -25,7 +25,7 @@ const _formatVariantSelector = require("../util/formatVariantSelector");
 const _nameClass = require("../util/nameClass");
 const _dataTypes = require("../util/dataTypes");
 const _setupContextUtils = require("./setupContextUtils");
-const _isValidArbitraryValue = /*#__PURE__*/ _interopRequireDefault(require("../util/isValidArbitraryValue"));
+const _isSyntacticallyValidPropertyValue = /*#__PURE__*/ _interopRequireDefault(require("../util/isSyntacticallyValidPropertyValue"));
 const _splitAtTopLevelOnlyJs = require("../util/splitAtTopLevelOnly.js");
 const _featureFlags = require("../featureFlags");
 function _interopRequireDefault(obj) {
@@ -198,10 +198,16 @@ function applyVariant(variant, matches, context) {
     };
     // Retrieve "modifier"
     {
-        let match = /(.*)\/(.*)$/g.exec(variant);
-        if (match) {
-            variant = match[1];
-            args.modifier = match[2];
+        let [baseVariant, ...modifiers] = (0, _splitAtTopLevelOnlyJs.splitAtTopLevelOnly)(variant, "/");
+        // This is a hack to support variants with `/` in them, like `ar-1/10/20:text-red-500`
+        // In this case 1/10 is a value but /20 is a modifier
+        if (modifiers.length > 1) {
+            baseVariant = baseVariant + "/" + modifiers.slice(0, -1).join("/");
+            modifiers = modifiers.slice(-1);
+        }
+        if (modifiers.length && !context.variantMap.has(variant)) {
+            variant = baseVariant;
+            args.modifier = modifiers[0];
             if (!(0, _featureFlags.flagEnabled)(context.tailwindConfig, "generalizedModifiers")) {
                 return [];
             }
@@ -216,9 +222,9 @@ function applyVariant(variant, matches, context) {
         // But we don't want:
         //   @-[200px]        (`-` is incorrect)
         //   group[:hover]    (`-` is missing)
-        let match1 = /(.)(-?)\[(.*)\]/g.exec(variant);
-        if (match1) {
-            let [, char, seperator, value] = match1;
+        let match = /(.)(-?)\[(.*)\]/g.exec(variant);
+        if (match) {
+            let [, char, seperator, value] = match;
             // @-[200px] case
             if (char === "@" && seperator === "-") return [];
             // group[:hover] case
@@ -243,6 +249,7 @@ function applyVariant(variant, matches, context) {
         ]);
     }
     if (context.variantMap.has(variant)) {
+        let isArbitraryVariant = isArbitraryValue(variant);
         let variantFunctionTuples = context.variantMap.get(variant).slice();
         let result = [];
         for (let [meta, rule] of matches){
@@ -299,7 +306,10 @@ function applyVariant(variant, matches, context) {
                         clone.append(wrapper);
                     },
                     format (selectorFormat) {
-                        collectedFormats.push(selectorFormat);
+                        collectedFormats.push({
+                            format: selectorFormat,
+                            isArbitraryVariant
+                        });
                     },
                     args
                 });
@@ -322,7 +332,10 @@ function applyVariant(variant, matches, context) {
                     continue;
                 }
                 if (typeof ruleWithVariant === "string") {
-                    collectedFormats.push(ruleWithVariant);
+                    collectedFormats.push({
+                        format: ruleWithVariant,
+                        isArbitraryVariant
+                    });
                 }
                 if (ruleWithVariant === null) {
                     continue;
@@ -358,7 +371,10 @@ function applyVariant(variant, matches, context) {
                         //      modified (by plugin): .foo .foo\\:markdown > p
                         //    rebuiltBase (internal): .foo\\:markdown > p
                         //                    format: .foo &
-                        collectedFormats.push(modified.replace(rebuiltBase, "&"));
+                        collectedFormats.push({
+                            format: modified.replace(rebuiltBase, "&"),
+                            isArbitraryVariant
+                        });
                         rule.selector = before;
                     });
                 }
@@ -370,13 +386,12 @@ function applyVariant(variant, matches, context) {
                     ...clone.nodes[0].raws.tailwind,
                     parentLayer: meta.layer
                 };
-                var _collectedFormats;
+                var _meta_collectedFormats;
                 let withOffset = [
                     {
                         ...meta,
                         sort: context.offsets.applyVariantOffset(meta.sort, variantSort, Object.assign(args, context.variantOptions.get(variant))),
-                        collectedFormats: ((_collectedFormats = meta.collectedFormats) !== null && _collectedFormats !== void 0 ? _collectedFormats : []).concat(collectedFormats),
-                        isArbitraryVariant: isArbitraryValue(variant)
+                        collectedFormats: ((_meta_collectedFormats = meta.collectedFormats) !== null && _meta_collectedFormats !== void 0 ? _meta_collectedFormats : []).concat(collectedFormats)
                     },
                     clone.nodes[0]
                 ];
@@ -434,7 +449,7 @@ function isValidPropName(name) {
 function isParsableNode(node) {
     let isParsable = true;
     node.walkDecls((decl)=>{
-        if (!isParsableCssValue(decl.name, decl.value)) {
+        if (!isParsableCssValue(decl.prop, decl.value)) {
             isParsable = false;
             return false;
         }
@@ -456,15 +471,15 @@ function isParsableCssValue(property, value) {
     }
 }
 function extractArbitraryProperty(classCandidate, context) {
-    var ref;
-    let [, property, value] = (ref = classCandidate.match(/^\[([a-zA-Z0-9-_]+):(\S+)\]$/)) !== null && ref !== void 0 ? ref : [];
+    var _classCandidate_match;
+    let [, property, value] = (_classCandidate_match = classCandidate.match(/^\[([a-zA-Z0-9-_]+):(\S+)\]$/)) !== null && _classCandidate_match !== void 0 ? _classCandidate_match : [];
     if (value === undefined) {
         return null;
     }
     if (!isValidPropName(property)) {
         return null;
     }
-    if (!(0, _isValidArbitraryValue.default)(value)) {
+    if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) {
         return null;
     }
     let normalized = (0, _dataTypes.normalize)(value);
@@ -535,12 +550,12 @@ function splitWithSeparator(input, separator) {
 }
 function* recordCandidates(matches, classCandidate) {
     for (const match of matches){
-        var ref;
-        var ref1;
+        var _match__options;
+        var _match__options_preserveSource;
         match[1].raws.tailwind = {
             ...match[1].raws.tailwind,
             classCandidate,
-            preserveSource: (ref1 = (ref = match[0].options) === null || ref === void 0 ? void 0 : ref.preserveSource) !== null && ref1 !== void 0 ? ref1 : false
+            preserveSource: (_match__options_preserveSource = (_match__options = match[0].options) === null || _match__options === void 0 ? void 0 : _match__options.preserveSource) !== null && _match__options_preserveSource !== void 0 ? _match__options_preserveSource : false
         };
         yield match;
     }
@@ -614,9 +629,9 @@ function* resolveMatches(candidate, context, original = candidate) {
                 }
             }
             if (matchesPerPlugin.length > 0) {
-                var ref;
-                var ref1, _options;
-                let matchingTypes = Array.from((0, _pluginUtils.getMatchingTypes)((ref1 = (ref = sort.options) === null || ref === void 0 ? void 0 : ref.types) !== null && ref1 !== void 0 ? ref1 : [], modifier, (_options = sort.options) !== null && _options !== void 0 ? _options : {}, context.tailwindConfig)).map(([_, type])=>type);
+                var _sort_options;
+                var _sort_options_types, _sort_options1;
+                let matchingTypes = Array.from((0, _pluginUtils.getMatchingTypes)((_sort_options_types = (_sort_options = sort.options) === null || _sort_options === void 0 ? void 0 : _sort_options.types) !== null && _sort_options_types !== void 0 ? _sort_options_types : [], modifier, (_sort_options1 = sort.options) !== null && _sort_options1 !== void 0 ? _sort_options1 : {}, context.tailwindConfig)).map(([_, type])=>type);
                 if (matchingTypes.length > 0) {
                     typesByMatches.set(matchesPerPlugin, matchingTypes);
                 }
@@ -656,18 +671,18 @@ function* resolveMatches(candidate, context, original = candidate) {
                         });
                     });
                 }
-                var ref2;
+                var _findFallback;
                 // Try to find a fallback plugin, because we already know that multiple plugins matched for
                 // the given arbitrary value.
-                let fallback = (ref2 = findFallback(withoutAny)) !== null && ref2 !== void 0 ? ref2 : findFallback(withAny);
+                let fallback = (_findFallback = findFallback(withoutAny)) !== null && _findFallback !== void 0 ? _findFallback : findFallback(withAny);
                 if (fallback) {
                     matches = [
                         fallback
                     ];
                 } else {
-                    var ref3;
+                    var _typesByMatches_get;
                     let typesPerPlugin = matches.map((match)=>new Set([
-                            ...(ref3 = typesByMatches.get(match)) !== null && ref3 !== void 0 ? ref3 : []
+                            ...(_typesByMatches_get = typesByMatches.get(match)) !== null && _typesByMatches_get !== void 0 ? _typesByMatches_get : []
                         ]));
                     // Remove duplicates, so that we can detect proper unique types for each plugin.
                     for (let pluginTypes of typesPerPlugin){
@@ -718,31 +733,71 @@ function* resolveMatches(candidate, context, original = candidate) {
                 candidate
             };
             // Apply final format selector
-            if (match[0].collectedFormats) {
-                let finalFormat = (0, _formatVariantSelector.formatVariantSelector)("&", ...match[0].collectedFormats);
-                let container = _postcss.default.root({
-                    nodes: [
-                        match[1].clone()
-                    ]
-                });
-                container.walkRules((rule)=>{
-                    var ref;
-                    if (inKeyframes(rule)) return;
-                    var ref1;
-                    rule.selector = (0, _formatVariantSelector.finalizeSelector)(finalFormat, {
-                        selector: rule.selector,
-                        candidate: original,
-                        base: candidate.split(new RegExp(`\\${(ref1 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref1 !== void 0 ? ref1 : ":"}(?![^[]*\\])`)).pop(),
-                        isArbitraryVariant: match[0].isArbitraryVariant,
-                        context
-                    });
-                });
-                match[1] = container.nodes[0];
+            match = applyFinalFormat(match, {
+                context,
+                candidate,
+                original
+            });
+            // Skip rules with invalid selectors
+            // This will cause the candidate to be added to the "not class"
+            // cache skipping it entirely for future builds
+            if (match === null) {
+                continue;
             }
             yield match;
         }
     }
 }
+function applyFinalFormat(match, { context , candidate , original  }) {
+    if (!match[0].collectedFormats) {
+        return match;
+    }
+    let isValid = true;
+    let finalFormat;
+    try {
+        finalFormat = (0, _formatVariantSelector.formatVariantSelector)(match[0].collectedFormats, {
+            context,
+            candidate
+        });
+    } catch  {
+        // The format selector we produced is invalid
+        // This could be because:
+        // - A bug exists
+        // - A plugin introduced an invalid variant selector (ex: `addVariant('foo', '&;foo')`)
+        // - The user used an invalid arbitrary variant (ex: `[&;foo]:underline`)
+        // Either way the build will fail because of this
+        // We would rather that the build pass "silently" given that this could
+        // happen because of picking up invalid things when scanning content
+        // So we'll throw out the candidate instead
+        return null;
+    }
+    let container = _postcss.default.root({
+        nodes: [
+            match[1].clone()
+        ]
+    });
+    container.walkRules((rule)=>{
+        if (inKeyframes(rule)) {
+            return;
+        }
+        try {
+            rule.selector = (0, _formatVariantSelector.finalizeSelector)(rule.selector, finalFormat, {
+                candidate: original,
+                context
+            });
+        } 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
+            isValid = false;
+            return false;
+        }
+    });
+    if (!isValid) {
+        return null;
+    }
+    match[1] = container.nodes[0];
+    return match;
+}
 function inKeyframes(rule) {
     return rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes";
 }
@@ -787,8 +842,8 @@ function generateRules(candidates, context) {
             continue;
         }
         context.classCache.set(candidate, matches);
-        var ref;
-        let rules = (ref = context.candidateRuleCache.get(candidate)) !== null && ref !== void 0 ? ref : new Set();
+        var _context_candidateRuleCache_get;
+        let rules = (_context_candidateRuleCache_get = context.candidateRuleCache.get(candidate)) !== null && _context_candidateRuleCache_get !== void 0 ? _context_candidateRuleCache_get : new Set();
         context.candidateRuleCache.set(candidate, rules);
         for (const match of matches){
             let [{ sort , options  }, rule] = match;

package/lib/lib/offsets.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "Offsets", {
     get: ()=>Offsets
 });
 const _bigSign = /*#__PURE__*/ _interopRequireDefault(require("../util/bigSign"));
+const _remapBitfieldJs = require("./remap-bitfield.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -96,6 +97,7 @@ class Offsets {
    * @param {VariantOption} options
    * @returns {RuleOffset}
    */ applyVariantOffset(rule, variant, options) {
+        options.variant = variant.variants;
         return {
             ...rule,
             layer: "variants",
@@ -153,7 +155,7 @@ class Offsets {
         this.reservedVariantBits += BigInt(fnCount);
         return {
             ...this.create("variants"),
-            variants: 1n << this.reservedVariantBits
+            variants: this.variantOffsets.get(variant)
         };
     }
     /**
@@ -165,11 +167,29 @@ class Offsets {
         if (a.layer !== b.layer) {
             return this.layerPositions[a.layer] - this.layerPositions[b.layer];
         }
+        // When sorting the `variants` layer, we need to sort based on the parent layer as well within
+        // this variants layer.
+        if (a.parentLayer !== b.parentLayer) {
+            return this.layerPositions[a.parentLayer] - this.layerPositions[b.parentLayer];
+        }
         // Sort based on the sorting function
         for (let aOptions of a.options){
             for (let bOptions of b.options){
                 if (aOptions.id !== bOptions.id) continue;
                 if (!aOptions.sort || !bOptions.sort) continue;
+                var _max;
+                let maxFnVariant = (_max = max([
+                    aOptions.variant,
+                    bOptions.variant
+                ])) !== null && _max !== void 0 ? _max : 0n;
+                // Create a mask of 0s from bits 1..N where N represents the mask of the Nth bit
+                let mask = ~(maxFnVariant | maxFnVariant - 1n);
+                let aVariantsAfterFn = a.variants & mask;
+                let bVariantsAfterFn = b.variants & mask;
+                // If the variants the same, we _can_ sort them
+                if (aVariantsAfterFn !== bVariantsAfterFn) {
+                    continue;
+                }
                 let result = aOptions.sort({
                     value: aOptions.value,
                     modifier: aOptions.modifier
@@ -196,10 +216,57 @@ class Offsets {
         return a.index - b.index;
     }
     /**
+   * Arbitrary variants are recorded in the order they're encountered.
+   * This means that the order is not stable between environments and sets of content files.
+   *
+   * In order to make the order stable, we need to remap the arbitrary variant offsets to
+   * be in alphabetical order starting from the offset of the first arbitrary variant.
+   */ recalculateVariantOffsets() {
+        // Sort the variants by their name
+        let variants = Array.from(this.variantOffsets.entries()).filter(([v])=>v.startsWith("[")).sort(([a], [z])=>fastCompare(a, z));
+        // Sort the list of offsets
+        // This is not necessarily a discrete range of numbers which is why
+        // we're using sort instead of creating a range from min/max
+        let newOffsets = variants.map(([, offset])=>offset).sort((a, z)=>(0, _bigSign.default)(a - z));
+        // Create a map from the old offsets to the new offsets in the new sort order
+        /** @type {[bigint, bigint][]} */ let mapping = variants.map(([, oldOffset], i)=>[
+                oldOffset,
+                newOffsets[i]
+            ]);
+        // Remove any variants that will not move letting us skip
+        // remapping if everything happens to be in order
+        return mapping.filter(([a, z])=>a !== z);
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ remapArbitraryVariantOffsets(list) {
+        let mapping = this.recalculateVariantOffsets();
+        // No arbitrary variants? Nothing to do.
+        // Everyhing already in order? Nothing to do.
+        if (mapping.length === 0) {
+            return list;
+        }
+        // Remap every variant offset in the list
+        return list.map((item)=>{
+            let [offset, rule] = item;
+            offset = {
+                ...offset,
+                variants: (0, _remapBitfieldJs.remapBitfield)(offset.variants, mapping)
+            };
+            return [
+                offset,
+                rule
+            ];
+        });
+    }
+    /**
    * @template T
    * @param {[RuleOffset, T][]} list
    * @returns {[RuleOffset, T][]}
    */ sort(list) {
+        list = this.remapArbitraryVariantOffsets(list);
         return list.sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
     }
 }
@@ -215,3 +282,23 @@ class Offsets {
     }
     return max;
 }
+/**
+ * A fast ASCII order string comparison function.
+ *
+ * Using `.sort()` without a custom compare function is faster
+ * But you can only use that if you're sorting an array of
+ * only strings. If you're sorting strings inside objects
+ * or arrays, you need must use a custom compare function.
+ *
+ * @param {string} a
+ * @param {string} b
+ */ function fastCompare(a, b) {
+    let aLen = a.length;
+    let bLen = b.length;
+    let minLen = aLen < bLen ? aLen : bLen;
+    for(let i = 0; i < minLen; i++){
+        let cmp = a.charCodeAt(i) - b.charCodeAt(i);
+        if (cmp !== 0) return cmp;
+    }
+    return aLen - bLen;
+}

package/lib/lib/remap-bitfield.js

@@ -0,0 +1,87 @@
+// @ts-check
+/**
+ * We must remap all the old bits to new bits for each set variant
+ * Only arbitrary variants are considered as those are the only
+ * ones that need to be re-sorted at this time
+ *
+ * An iterated process that removes and sets individual bits simultaneously
+ * will not work because we may have a new bit that is also a later old bit
+ * This means that we would be removing a previously set bit which we don't
+ * want to do
+ *
+ * For example (assume `bN` = `1<<N`)
+ * Given the "total" mapping `[[b1, b3], [b2, b4], [b3, b1], [b4, b2]]`
+ * The mapping is "total" because:
+ * 1. Every input and output is accounted for
+ * 2. All combinations are unique
+ * 3. No one input maps to multiple outputs and vice versa
+ * And, given an offset with all bits set:
+ * V = b1 | b2 | b3 | b4
+ *
+ * Let's explore the issue with removing and setting bits simultaneously:
+ * V & ~b1 | b3 = b2 | b3 | b4
+ * V & ~b2 | b4 = b3 | b4
+ * V & ~b3 | b1 = b1 | b4
+ * V & ~b4 | b2 = b1 | b2
+ *
+ * As you can see, we end up with the wrong result.
+ * This is because we're removing a bit that was previously set.
+ * And, thus the final result is missing b3 and b4.
+ *
+ * Now, let's explore the issue with removing the bits first:
+ * V & ~b1 = b2 | b3 | b4
+ * V & ~b2 = b3 | b4
+ * V & ~b3 = b4
+ * V & ~b4 = 0
+ *
+ * And then setting the bits:
+ * V | b3 = b3
+ * V | b4 = b3 | b4
+ * V | b1 = b1 | b3 | b4
+ * V | b2 = b1 | b2 | b3 | b4
+ *
+ * We get the correct result because we're not removing any bits that were
+ * previously set thus properly remapping the bits to the new order
+ *
+ * To collect this into a single operation that can be done simultaneously
+ * we must first create a mask for the old bits that are set and a mask for
+ * the new bits that are set. Then we can remove the old bits and set the new
+ * bits simultaneously in a "single" operation like so:
+ * OldMask = b1 | b2 | b3 | b4
+ * NewMask = b3 | b4 | b1 | b2
+ *
+ * So this:
+ * V & ~oldMask | newMask
+ *
+ * Expands to this:
+ * V & ~b1 & ~b2 & ~b3 & ~b4 | b3 | b4 | b1 | b2
+ *
+ * Which becomes this:
+ * b1 | b2 | b3 | b4
+ *
+ * Which is the correct result!
+ *
+ * @param {bigint} num
+ * @param {[bigint, bigint][]} mapping
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "remapBitfield", {
+    enumerable: true,
+    get: ()=>remapBitfield
+});
+function remapBitfield(num, mapping) {
+    // Create masks for the old and new bits that are set
+    let oldMask = 0n;
+    let newMask = 0n;
+    for (let [oldBit, newBit] of mapping){
+        if (num & oldBit) {
+            oldMask = oldMask | oldBit;
+            newMask = newMask | newBit;
+        }
+    }
+    // Remove all old bits
+    // Set all new bits
+    return num & ~oldMask | newMask;
+}

package/lib/lib/resolveDefaultsAtRules.js

@@ -99,8 +99,8 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
         if ((0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) {
             for (let universal of universals){
                 /** @type {Map<string, Set<string>>} */ let selectorGroups = new Map();
-                var ref;
-                let rules = (ref = variableNodeMap.get(universal.params)) !== null && ref !== void 0 ? ref : [];
+                var _variableNodeMap_get;
+                let rules = (_variableNodeMap_get = variableNodeMap.get(universal.params)) !== null && _variableNodeMap_get !== void 0 ? _variableNodeMap_get : [];
                 for (let rule of rules){
                     for (let selector of extractElementSelector(rule.selector)){
                         // If selector contains a vendor prefix after a pseudo element or class,
@@ -108,8 +108,8 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                         // 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__";
-                        var ref1;
-                        let selectors = (ref1 = selectorGroups.get(selectorGroupName)) !== null && ref1 !== void 0 ? ref1 : new Set();
+                        var _selectorGroups_get;
+                        let selectors = (_selectorGroups_get = selectorGroups.get(selectorGroupName)) !== null && _selectorGroups_get !== void 0 ? _selectorGroups_get : new Set();
                         selectorGroups.set(selectorGroupName, selectors);
                         selectors.add(selector);
                     }