tailwindcss 0.0.0-insiders.dddaded → 0.0.0-insiders.de00a62

package/lib/lib/offsets.js

@@ -5,11 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "Offsets", {
     enumerable: true,
-    get: ()=>Offsets
+    get: function() {
+        return Offsets;
+    }
 });
-const _bigSign = /*#__PURE__*/ _interopRequireDefault(require("../util/bigSign"));
-const _remapBitfieldJs = require("./remap-bitfield.js");
-function _interopRequireDefault(obj) {
+const _bigSign = /*#__PURE__*/ _interop_require_default(require("../util/bigSign"));
+const _remapbitfield = require("./remap-bitfield.js");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -64,15 +66,19 @@ class Offsets {
             variants: 0n,
             parallelIndex: 0n,
             index: this.offsets[layer]++,
+            propertyOffset: 0n,
+            property: "",
             options: []
         };
     }
     /**
+   * @param {string} name
    * @returns {RuleOffset}
-   */ arbitraryProperty() {
+   */ arbitraryProperty(name) {
         return {
             ...this.create("utilities"),
-            arbitrary: 1n
+            arbitrary: 1n,
+            property: name
         };
     }
     /**
@@ -212,6 +218,10 @@ class Offsets {
         if (a.arbitrary !== b.arbitrary) {
             return a.arbitrary - b.arbitrary;
         }
+        // Always sort arbitrary properties alphabetically
+        if (a.propertyOffset !== b.propertyOffset) {
+            return a.propertyOffset - b.propertyOffset;
+        }
         // Sort utilities, components, etc… in the order they were registered
         return a.index - b.index;
     }
@@ -253,7 +263,45 @@ class Offsets {
             let [offset, rule] = item;
             offset = {
                 ...offset,
-                variants: (0, _remapBitfieldJs.remapBitfield)(offset.variants, mapping)
+                variants: (0, _remapbitfield.remapBitfield)(offset.variants, mapping)
+            };
+            return [
+                offset,
+                rule
+            ];
+        });
+    }
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ sortArbitraryProperties(list) {
+        // Collect all known arbitrary properties
+        let known = new Set();
+        for (let [offset] of list){
+            if (offset.arbitrary === 1n) {
+                known.add(offset.property);
+            }
+        }
+        // No arbitrary properties? Nothing to do.
+        if (known.size === 0) {
+            return list;
+        }
+        // Sort the properties alphabetically
+        let properties = Array.from(known).sort();
+        // Create a map from the property name to its offset
+        let offsets = new Map();
+        let offset = 1n;
+        for (let property of properties){
+            offsets.set(property, offset++);
+        }
+        // Apply the sorted offsets to the list
+        return list.map((item)=>{
+            let [offset, rule] = item;
+            var _offsets_get;
+            offset = {
+                ...offset,
+                propertyOffset: (_offsets_get = offsets.get(offset.property)) !== null && _offsets_get !== void 0 ? _offsets_get : 0n
             };
             return [
                 offset,
@@ -266,7 +314,10 @@ class Offsets {
    * @param {[RuleOffset, T][]} list
    * @returns {[RuleOffset, T][]}
    */ sort(list) {
+        // Sort arbitrary variants so they're in alphabetical order
         list = this.remapArbitraryVariantOffsets(list);
+        // Sort arbitrary properties so they're in alphabetical order
+        list = this.sortArbitraryProperties(list);
         return list.sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
     }
 }

package/lib/lib/partitionApplyAtRules.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>expandApplyAtRules
+    get: function() {
+        return expandApplyAtRules;
+    }
 });
 function partitionRules(root) {
     if (!root.walkAtRules) return;

package/lib/lib/regex.js

@@ -9,13 +9,27 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    pattern: ()=>pattern,
-    withoutCapturing: ()=>withoutCapturing,
-    any: ()=>any,
-    optional: ()=>optional,
-    zeroOrMore: ()=>zeroOrMore,
-    nestedBrackets: ()=>nestedBrackets,
-    escape: ()=>escape
+    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;
 const REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source);

package/lib/lib/remap-bitfield.js

@@ -69,7 +69,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "remapBitfield", {
     enumerable: true,
-    get: ()=>remapBitfield
+    get: function() {
+        return remapBitfield;
+    }
 });
 function remapBitfield(num, mapping) {
     // Create masks for the old and new bits that are set

package/lib/lib/resolveDefaultsAtRules.js

@@ -9,20 +9,24 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    elementSelectorParser: ()=>elementSelectorParser,
-    default: ()=>resolveDefaultsAtRules
+    elementSelectorParser: function() {
+        return elementSelectorParser;
+    },
+    default: function() {
+        return resolveDefaultsAtRules;
+    }
 });
-const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
 const _featureFlags = require("../featureFlags");
-function _interopRequireDefault(obj) {
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let getNode = {
     id (node) {
-        return _postcssSelectorParser.default.attribute({
+        return _postcssselectorparser.default.attribute({
             attribute: "id",
             operator: "=",
             value: node.value,
@@ -60,14 +64,14 @@ function minimumImpactSelector(nodes) {
     let combinatorIdx = rest.findIndex((n)=>n.type === "combinator" && n.value === ">");
     if (combinatorIdx !== -1) {
         rest.splice(0, combinatorIdx);
-        rest.unshift(_postcssSelectorParser.default.universal());
+        rest.unshift(_postcssselectorparser.default.universal());
     }
     return [
         bestNode,
         ...rest.reverse()
     ].join("").trim();
 }
-let elementSelectorParser = (0, _postcssSelectorParser.default)((selectors)=>{
+let elementSelectorParser = (0, _postcssselectorparser.default)((selectors)=>{
     return selectors.map((s)=>{
         let nodes = s.split((n)=>n.type === "combinator" && n.value === " ").pop();
         return minimumImpactSelector(nodes);
@@ -107,7 +111,9 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                         // 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__";
+                        // Additionally if a selector contains `:has` we also consider
+                        // it separately because FF only recently gained support for it
+                        let selectorGroupName = selector.includes(":-") || selector.includes("::-") || selector.includes(":has") ? 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);
@@ -119,12 +125,12 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                         universal.remove();
                         continue;
                     }
-                    for (let [, selectors1] of selectorGroups){
+                    for (let [, selectors] of selectorGroups){
                         let universalRule = _postcss.default.rule({
                             source: universal.source
                         });
                         universalRule.selectors = [
-                            ...selectors1
+                            ...selectors
                         ];
                         universalRule.append(universal.nodes.map((node)=>node.clone()));
                         universal.before(universalRule);
@@ -133,29 +139,29 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                 universal.remove();
             }
         } else if (universals.size) {
-            let universalRule1 = _postcss.default.rule({
+            let universalRule = _postcss.default.rule({
                 selectors: [
                     "*",
                     "::before",
                     "::after"
                 ]
             });
-            for (let universal1 of universals){
-                universalRule1.append(universal1.nodes);
-                if (!universalRule1.parent) {
-                    universal1.before(universalRule1);
+            for (let universal of universals){
+                universalRule.append(universal.nodes);
+                if (!universalRule.parent) {
+                    universal.before(universalRule);
                 }
-                if (!universalRule1.source) {
-                    universalRule1.source = universal1.source;
+                if (!universalRule.source) {
+                    universalRule.source = universal.source;
                 }
-                universal1.remove();
+                universal.remove();
             }
-            let backdropRule = universalRule1.clone({
+            let backdropRule = universalRule.clone({
                 selectors: [
                     "::backdrop"
                 ]
             });
-            universalRule1.after(backdropRule);
+            universalRule.after(backdropRule);
         }
     };
 }