tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.7f555c4

package/lib/lib/partitionApplyAtRules.js

@@ -1,34 +1,58 @@
 "use strict";
-function expandApplyAtRules() {
-    return (root)=>{
-        !function(root) {
-            if (!root.walkAtRules) return;
-            let applyParents = new Set();
-            if (root.walkAtRules("apply", (rule)=>{
-                applyParents.add(rule.parent);
-            }), 0 !== applyParents.size) for (let rule of applyParents){
-                let nodeGroups = [], lastGroup = [];
-                for (let node of rule.nodes)"atrule" === node.type && "apply" === node.name ? (lastGroup.length > 0 && (nodeGroups.push(lastGroup), lastGroup = []), nodeGroups.push([
-                    node
-                ])) : lastGroup.push(node);
-                if (lastGroup.length > 0 && nodeGroups.push(lastGroup), 1 !== nodeGroups.length) {
-                    for (let group of [
-                        ...nodeGroups
-                    ].reverse()){
-                        let clone = rule.clone({
-                            nodes: []
-                        });
-                        clone.append(group), rule.after(clone);
-                    }
-                    rule.remove();
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return expandApplyAtRules;
+    }
+});
+function partitionRules(root) {
+    if (!root.walkAtRules) return;
+    let applyParents = new Set();
+    root.walkAtRules("apply", (rule)=>{
+        applyParents.add(rule.parent);
+    });
+    if (applyParents.size === 0) {
+        return;
+    }
+    for (let rule of applyParents){
+        let nodeGroups = [];
+        let lastGroup = [];
+        for (let node of rule.nodes){
+            if (node.type === "atrule" && node.name === "apply") {
+                if (lastGroup.length > 0) {
+                    nodeGroups.push(lastGroup);
+                    lastGroup = [];
                 }
+                nodeGroups.push([
+                    node
+                ]);
+            } else {
+                lastGroup.push(node);
             }
-        }(root);
+        }
+        if (lastGroup.length > 0) {
+            nodeGroups.push(lastGroup);
+        }
+        if (nodeGroups.length === 1) {
+            continue;
+        }
+        for (let group of [
+            ...nodeGroups
+        ].reverse()){
+            let clone = rule.clone({
+                nodes: []
+            });
+            clone.append(group);
+            rule.after(clone);
+        }
+        rule.remove();
+    }
+}
+function expandApplyAtRules() {
+    return (root)=>{
+        partitionRules(root);
     };
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>expandApplyAtRules
-});

package/lib/lib/regex.js

@@ -1,42 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    pattern: ()=>pattern,
-    withoutCapturing: ()=>withoutCapturing,
-    any: ()=>any,
-    optional: ()=>optional,
-    zeroOrMore: ()=>zeroOrMore,
-    nestedBrackets: ()=>function nestedBrackets(open, close, depth = 1) {
-            return withoutCapturing([
-                escape(open),
-                /[^\s]*/,
-                1 === depth ? `[^${escape(open)}${escape(close)}\s]*` : any([
-                    `[^${escape(open)}${escape(close)}\s]*`,
-                    nestedBrackets(open, close, depth - 1)
-                ]),
-                /[^\s]*/,
-                escape(close)
-            ]);
-        },
-    escape: ()=>escape
+}
+_export(exports, {
+    pattern: function() {
+        return pattern;
+    },
+    withoutCapturing: function() {
+        return withoutCapturing;
+    },
+    any: function() {
+        return any;
+    },
+    optional: function() {
+        return optional;
+    },
+    zeroOrMore: function() {
+        return zeroOrMore;
+    },
+    nestedBrackets: function() {
+        return nestedBrackets;
+    },
+    escape: function() {
+        return escape;
+    }
 });
-const REGEX_SPECIAL = /[\\^$.*+?()[\]{}|]/g, REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source);
-function toSource(source) {
-    return (source = (source = Array.isArray(source) ? source : [
+const REGEX_SPECIAL = /[\\^$.*+?()[\]{}|]/g;
+const REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source);
+/**
+ * @param {string|RegExp|Array<string|RegExp>} source
+ */ function toSource(source) {
+    source = Array.isArray(source) ? source : [
         source
-    ]).map((item)=>item instanceof RegExp ? item.source : item)).join("");
+    ];
+    source = source.map((item)=>item instanceof RegExp ? item.source : item);
+    return source.join("");
 }
 function pattern(source) {
-    return RegExp(toSource(source), "g");
+    return new RegExp(toSource(source), "g");
 }
 function withoutCapturing(source) {
-    return RegExp(`(?:${toSource(source)})`, "g");
+    return new RegExp(`(?:${toSource(source)})`, "g");
 }
 function any(sources) {
     return `(?:${sources.map(toSource).join("|")})`;
@@ -47,6 +57,18 @@ function optional(source) {
 function zeroOrMore(source) {
     return `(?:${toSource(source)})*`;
 }
+function nestedBrackets(open, close, depth = 1) {
+    return withoutCapturing([
+        escape(open),
+        /[^\s]*/,
+        depth === 1 ? `[^${escape(open)}${escape(close)}\s]*` : any([
+            `[^${escape(open)}${escape(close)}\s]*`,
+            nestedBrackets(open, close, depth - 1)
+        ]),
+        /[^\s]*/,
+        escape(close)
+    ]);
+}
 function escape(string) {
     return string && REGEX_HAS_SPECIAL.test(string) ? string.replace(REGEX_SPECIAL, "\\$&") : string || "";
 }

package/lib/lib/remap-bitfield.js

@@ -1,12 +1,89 @@
-"use strict";
+// @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: function() {
+        return remapBitfield;
+    }
+});
 function remapBitfield(num, mapping) {
-    let oldMask = 0n, newMask = 0n;
-    for (let [oldBit, newBit] of mapping)num & oldBit && (oldMask |= oldBit, newMask |= newBit);
+    // 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;
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "remapBitfield", {
-    enumerable: !0,
-    get: ()=>remapBitfield
-});

package/lib/lib/resolveDefaultsAtRules.js

@@ -1,81 +1,142 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    elementSelectorParser: ()=>elementSelectorParser,
-    default: ()=>resolveDefaultsAtRules
+}
+_export(exports, {
+    elementSelectorParser: function() {
+        return elementSelectorParser;
+    },
+    default: function() {
+        return resolveDefaultsAtRules;
+    }
 });
-const _postcss = _interopRequireDefault(require("postcss")), _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser")), _featureFlags = require("../featureFlags");
-function _interopRequireDefault(obj) {
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+const _featureFlags = require("../featureFlags");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let getNode = {
-    id: (node)=>_postcssSelectorParser.default.attribute({
+    id (node) {
+        return _postcssselectorparser.default.attribute({
             attribute: "id",
             operator: "=",
             value: node.value,
             quoteMark: '"'
-        })
-}, elementSelectorParser = (0, _postcssSelectorParser.default)((selectors)=>selectors.map((s)=>(function(nodes) {
-            let rest = nodes.filter((node)=>"pseudo" !== node.type || node.nodes.length > 0 || node.value.startsWith("::") || [
-                    ":before",
-                    ":after",
-                    ":first-line",
-                    ":first-letter"
-                ].includes(node.value)).reverse(), searchFor = new Set([
-                "tag",
-                "class",
-                "id",
-                "attribute"
-            ]), splitPointIdx = rest.findIndex((n)=>searchFor.has(n.type));
-            if (-1 === splitPointIdx) return rest.reverse().join("").trim();
-            let node = rest[splitPointIdx], bestNode = getNode[node.type] ? getNode[node.type](node) : node, combinatorIdx = (rest = rest.slice(0, splitPointIdx)).findIndex((n)=>"combinator" === n.type && ">" === n.value);
-            return -1 !== combinatorIdx && (rest.splice(0, combinatorIdx), rest.unshift(_postcssSelectorParser.default.universal())), [
-                bestNode,
-                ...rest.reverse()
-            ].join("").trim();
-        })(s.split((n)=>"combinator" === n.type && " " === n.value).pop()))), cache = new Map();
+        });
+    }
+};
+function minimumImpactSelector(nodes) {
+    let rest = nodes.filter((node)=>{
+        // Keep non-pseudo nodes
+        if (node.type !== "pseudo") return true;
+        // Keep pseudo nodes that have subnodes
+        // E.g.: `:not()` contains subnodes inside the parentheses
+        if (node.nodes.length > 0) return true;
+        // Keep pseudo `elements`
+        // This implicitly means that we ignore pseudo `classes`
+        return node.value.startsWith("::") || [
+            ":before",
+            ":after",
+            ":first-line",
+            ":first-letter"
+        ].includes(node.value);
+    }).reverse();
+    let searchFor = new Set([
+        "tag",
+        "class",
+        "id",
+        "attribute"
+    ]);
+    let splitPointIdx = rest.findIndex((n)=>searchFor.has(n.type));
+    if (splitPointIdx === -1) return rest.reverse().join("").trim();
+    let node = rest[splitPointIdx];
+    let bestNode = getNode[node.type] ? getNode[node.type](node) : node;
+    rest = rest.slice(0, splitPointIdx);
+    let combinatorIdx = rest.findIndex((n)=>n.type === "combinator" && n.value === ">");
+    if (combinatorIdx !== -1) {
+        rest.splice(0, combinatorIdx);
+        rest.unshift(_postcssselectorparser.default.universal());
+    }
+    return [
+        bestNode,
+        ...rest.reverse()
+    ].join("").trim();
+}
+let elementSelectorParser = (0, _postcssselectorparser.default)((selectors)=>{
+    return selectors.map((s)=>{
+        let nodes = s.split((n)=>n.type === "combinator" && n.value === " ").pop();
+        return minimumImpactSelector(nodes);
+    });
+});
+let cache = new Map();
+function extractElementSelector(selector) {
+    if (!cache.has(selector)) {
+        cache.set(selector, elementSelectorParser.transformSync(selector));
+    }
+    return cache.get(selector);
+}
 function resolveDefaultsAtRules({ tailwindConfig  }) {
     return (root)=>{
-        let variableNodeMap = new Map(), universals = new Set();
-        if (root.walkAtRules("defaults", (rule)=>{
+        let variableNodeMap = new Map();
+        /** @type {Set<import('postcss').AtRule>} */ let universals = new Set();
+        root.walkAtRules("defaults", (rule)=>{
             if (rule.nodes && rule.nodes.length > 0) {
                 universals.add(rule);
                 return;
             }
             let variable = rule.params;
-            variableNodeMap.has(variable) || variableNodeMap.set(variable, new Set()), variableNodeMap.get(variable).add(rule.parent), rule.remove();
-        }), (0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) for (let universal of universals){
-            var _variableNodeMap_get, _selectorGroups_get, selector;
-            let selectorGroups = new Map();
-            for (let rule of null !== (_variableNodeMap_get = variableNodeMap.get(universal.params)) && void 0 !== _variableNodeMap_get ? _variableNodeMap_get : [])for (let selector1 of (selector = rule.selector, cache.has(selector) || cache.set(selector, elementSelectorParser.transformSync(selector)), cache.get(selector))){
-                let selectorGroupName = selector1.includes(":-") || selector1.includes("::-") ? selector1 : "__DEFAULT__", selectors = null !== (_selectorGroups_get = selectorGroups.get(selectorGroupName)) && void 0 !== _selectorGroups_get ? _selectorGroups_get : new Set();
-                selectorGroups.set(selectorGroupName, selectors), selectors.add(selector1);
+            if (!variableNodeMap.has(variable)) {
+                variableNodeMap.set(variable, new Set());
             }
-            if ((0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) {
-                if (0 === selectorGroups.size) {
-                    universal.remove();
-                    continue;
+            variableNodeMap.get(variable).add(rule.parent);
+            rule.remove();
+        });
+        if ((0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) {
+            for (let universal of universals){
+                /** @type {Map<string, Set<string>>} */ let selectorGroups = new Map();
+                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,
+                        // we consider them separately because merging the declarations into
+                        // a single rule will cause browsers that do not understand the
+                        // vendor prefix to throw out the whole rule
+                        let selectorGroupName = selector.includes(":-") || selector.includes("::-") ? selector : "__DEFAULT__";
+                        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);
+                    }
                 }
-                for (let [, selectors] of selectorGroups){
-                    let universalRule = _postcss.default.rule({
-                        source: universal.source
-                    });
-                    universalRule.selectors = [
-                        ...selectors
-                    ], universalRule.append(universal.nodes.map((node)=>node.clone())), universal.before(universalRule);
+                if ((0, _featureFlags.flagEnabled)(tailwindConfig, "optimizeUniversalDefaults")) {
+                    if (selectorGroups.size === 0) {
+                        universal.remove();
+                        continue;
+                    }
+                    for (let [, selectors] of selectorGroups){
+                        let universalRule = _postcss.default.rule({
+                            source: universal.source
+                        });
+                        universalRule.selectors = [
+                            ...selectors
+                        ];
+                        universalRule.append(universal.nodes.map((node)=>node.clone()));
+                        universal.before(universalRule);
+                    }
                 }
+                universal.remove();
             }
-            universal.remove();
-        }
-        else if (universals.size) {
+        } else if (universals.size) {
             let universalRule = _postcss.default.rule({
                 selectors: [
                     "*",
@@ -83,7 +144,16 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                     "::after"
                 ]
             });
-            for (let universal of universals)universalRule.append(universal.nodes), universalRule.parent || universal.before(universalRule), universalRule.source || (universalRule.source = universal.source), universal.remove();
+            for (let universal of universals){
+                universalRule.append(universal.nodes);
+                if (!universalRule.parent) {
+                    universal.before(universalRule);
+                }
+                if (!universalRule.source) {
+                    universalRule.source = universal.source;
+                }
+                universal.remove();
+            }
             let backdropRule = universalRule.clone({
                 selectors: [
                     "::backdrop"