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

package/lib/lib/defaultExtractor.js

@@ -1,88 +1,152 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "defaultExtractor", {
-    enumerable: !0,
-    get: ()=>defaultExtractor
+    value: true
 });
-const _featureFlags = require("../featureFlags"), _regex = function(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) return obj;
-    if (null === obj || "object" != typeof obj && "function" != typeof obj) return {
-        default: obj
-    };
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) return cache.get(obj);
-    var newObj = {}, hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj)if ("default" !== key && Object.prototype.hasOwnProperty.call(obj, key)) {
-        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-        desc && (desc.get || desc.set) ? Object.defineProperty(newObj, key, desc) : newObj[key] = obj[key];
+Object.defineProperty(exports, "defaultExtractor", {
+    enumerable: true,
+    get: function() {
+        return defaultExtractor;
     }
-    return newObj.default = obj, cache && cache.set(obj, newObj), newObj;
-}(require("./regex"));
+});
+const _featureFlags = require("../featureFlags");
+const _regex = /*#__PURE__*/ _interop_require_wildcard(require("./regex"));
 function _getRequireWildcardCache(nodeInterop) {
-    if ("function" != typeof WeakMap) return null;
-    var cacheBabelInterop = new WeakMap(), cacheNodeInterop = new WeakMap();
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
     return (_getRequireWildcardCache = function(nodeInterop) {
         return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
     })(nodeInterop);
 }
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 function defaultExtractor(context) {
-    let patterns = Array.from(function*(context) {
-        let separator = context.tailwindConfig.separator, variantGroupingEnabled = (0, _featureFlags.flagEnabled)(context.tailwindConfig, "variantGrouping"), prefix = "" !== context.tailwindConfig.prefix ? _regex.optional(_regex.pattern([
-            /-?/,
-            _regex.escape(context.tailwindConfig.prefix)
-        ])) : "", utility = _regex.any([
-            /\[[^\s:'"`]+:[^\s\[\]]+\]/,
-            /\[[^\s:'"`]+:[^\s]+?\[[^\s]+\][^\s]+?\]/,
-            _regex.pattern([
-                /-?(?:\w+)/,
-                _regex.optional(_regex.any([
-                    _regex.pattern([
-                        /-(?:\w+-)*\[[^\s:]+\]/,
-                        /(?![{([]])/,
-                        /(?:\/[^\s'"`\\><$]*)?/
-                    ]),
-                    _regex.pattern([
-                        /-(?:\w+-)*\[[^\s]+\]/,
-                        /(?![{([]])/,
-                        /(?:\/[^\s'"`\\$]*)?/
-                    ]),
-                    /[-\/][^\s'"`\\$={><]*/
-                ]))
-            ])
-        ]);
-        for (let variantPattern of [
-            _regex.any([
+    let patterns = Array.from(buildRegExps(context));
+    /**
+   * @param {string} content
+   */ return (content)=>{
+        /** @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 : []
+            ];
+        }
+        return results.filter((v)=>v !== undefined).map(clipAtBalancedParens);
+    };
+}
+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)
+    ])) : "";
+    let utility = _regex.any([
+        // Arbitrary properties (without square brackets)
+        /\[[^\s:'"`]+:[^\s\[\]]+\]/,
+        // Arbitrary properties with balanced square brackets
+        // 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]+?\]/,
+        // Utilities
+        _regex.pattern([
+            // Utility Name / Group Name
+            /-?(?:\w+)/,
+            // Normal/Arbitrary values
+            _regex.optional(_regex.any([
                 _regex.pattern([
-                    /@\[[^\s"'`]+\](\/[^\s"'`]+)?/,
-                    separator
+                    // Arbitrary values
+                    /-(?:\w+-)*\[[^\s:]+\]/,
+                    // Not immediately followed by an `{[(`
+                    /(?![{([]])/,
+                    // optionally followed by an opacity modifier
+                    /(?:\/[^\s'"`\\><$]*)?/
                 ]),
                 _regex.pattern([
-                    /([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/,
-                    separator
+                    // Arbitrary values
+                    /-(?:\w+-)*\[[^\s]+\]/,
+                    // Not immediately followed by an `{[(`
+                    /(?![{([]])/,
+                    // optionally followed by an opacity modifier
+                    /(?:\/[^\s'"`\\$]*)?/
                 ]),
-                _regex.pattern([
-                    /[^\s"'`\[\\]+/,
-                    separator
-                ])
+                // Normal values w/o quotes — may include an opacity modifier
+                /[-\/][^\s'"`\\$={><]*/
+            ]))
+        ])
+    ]);
+    let variantPatterns = [
+        // Without quotes
+        _regex.any([
+            // This is here to provide special support for the `@` variant
+            _regex.pattern([
+                /@\[[^\s"'`]+\](\/[^\s"'`]+)?/,
+                separator
             ]),
-            _regex.any([
-                _regex.pattern([
-                    /([^\s"'`\[\\]+-)?\[[^\s`]+\]/,
-                    separator
-                ]),
-                _regex.pattern([
-                    /[^\s`\[\\]+/,
-                    separator
-                ])
+            _regex.pattern([
+                /([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/,
+                separator
+            ]),
+            _regex.pattern([
+                /[^\s"'`\[\\]+/,
+                separator
             ])
-        ])yield _regex.pattern([
+        ]),
+        // With quotes allowed
+        _regex.any([
+            _regex.pattern([
+                /([^\s"'`\[\\]+-)?\[[^\s`]+\]/,
+                separator
+            ]),
+            _regex.pattern([
+                /[^\s`\[\\]+/,
+                separator
+            ])
+        ])
+    ];
+    for (const variantPattern of variantPatterns){
+        yield _regex.pattern([
+            // Variants
             "((?=((",
             variantPattern,
             ")+))\\2)?",
+            // Important (optional)
             /!?/,
             prefix,
             variantGroupingEnabled ? _regex.any([
+                // Or any of those things but grouped separated by commas
                 _regex.pattern([
                     /\(/,
                     utility,
@@ -92,47 +156,88 @@ function defaultExtractor(context) {
                     ]),
                     /\)/
                 ]),
+                // Arbitrary properties, constrained utilities, arbitrary values, etc…
                 utility
             ]) : utility
         ]);
-        yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g;
-    }(context));
-    return (content)=>{
-        let results = [];
-        for (let pattern of patterns){
-            var _content_match;
-            results = [
-                ...results,
-                ...null !== (_content_match = content.match(pattern)) && void 0 !== _content_match ? _content_match : []
-            ];
-        }
-        return results.filter((v)=>void 0 !== v).map(clipAtBalancedParens);
-    };
+    }
+    // 5. Inner matches
+    yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g;
 }
-let SPECIALS = /([\[\]'"`])([^\[\]'"`])?/g, ALLOWED_CLASS_CHARACTERS = /[^"'`\s<>\]]+/;
-function clipAtBalancedParens(input) {
-    if (!input.includes("-[")) return input;
-    let depth = 0, openStringTypes = [], matches = input.matchAll(SPECIALS);
-    for (let match of matches = Array.from(matches).flatMap((match)=>{
-        let [, ...groups] = match;
+// We want to capture any "special" characters
+// AND the characters immediately following them (if there is one)
+let SPECIALS = /([\[\]'"`])([^\[\]'"`])?/g;
+let ALLOWED_CLASS_CHARACTERS = /[^"'`\s<>\]]+/;
+/**
+ * Clips a string ensuring that parentheses, quotes, etc… are balanced
+ * Used for arbitrary values only
+ *
+ * We will go past the end of the balanced parens until we find a non-class character
+ *
+ * Depth matching behavior:
+ * w-[calc(100%-theme('spacing[some_key][1.5]'))]']
+ *   ┬    ┬          ┬┬       ┬        ┬┬   ┬┬┬┬┬┬┬
+ *   1    2          3        4        34   3 210 END
+ *   ╰────┴──────────┴────────┴────────┴┴───┴─┴┴┴
+ *
+ * @param {string} input
+ */ function clipAtBalancedParens(input) {
+    // We are care about this for arbitrary values
+    if (!input.includes("-[")) {
+        return input;
+    }
+    let depth = 0;
+    let openStringTypes = [];
+    // Find all parens, brackets, quotes, etc
+    // Stop when we end at a balanced pair
+    // This is naive and will treat mismatched parens as balanced
+    // This shouldn't be a problem in practice though
+    let matches = input.matchAll(SPECIALS);
+    // We can't use lookbehind assertions because we have to support Safari
+    // So, instead, we've emulated it using capture groups and we'll re-work the matches to accommodate
+    matches = Array.from(matches).flatMap((match)=>{
+        const [, ...groups] = match;
         return groups.map((group, idx)=>Object.assign([], match, {
                 index: match.index + idx,
                 0: group
             }));
-    })){
-        let char = match[0], inStringType = openStringTypes[openStringTypes.length - 1];
-        if (char === inStringType ? openStringTypes.pop() : ("'" === char || '"' === char || "`" === char) && openStringTypes.push(char), !inStringType) {
-            if ("[" === char) {
-                depth++;
-                continue;
-            }
-            if ("]" === char) {
-                depth--;
-                continue;
-            }
-            if (depth < 0) return input.substring(0, match.index - 1);
-            if (0 === depth && !ALLOWED_CLASS_CHARACTERS.test(char)) return input.substring(0, match.index);
+    });
+    for (let match of matches){
+        let char = match[0];
+        let inStringType = openStringTypes[openStringTypes.length - 1];
+        if (char === inStringType) {
+            openStringTypes.pop();
+        } else if (char === "'" || char === '"' || char === "`") {
+            openStringTypes.push(char);
+        }
+        if (inStringType) {
+            continue;
+        } else if (char === "[") {
+            depth++;
+            continue;
+        } else if (char === "]") {
+            depth--;
+            continue;
+        }
+        // We've gone one character past the point where we should stop
+        // This means that there was an extra closing `]`
+        // We'll clip to just before it
+        if (depth < 0) {
+            return input.substring(0, match.index - 1);
+        }
+        // We've finished balancing the brackets but there still may be characters that can be included
+        // For example in the class `text-[#336699]/[.35]`
+        // The depth goes to `0` at the closing `]` but goes up again at the `[`
+        // If we're at zero and encounter a non-class character then we clip the class there
+        if (depth === 0 && !ALLOWED_CLASS_CHARACTERS.test(char)) {
+            return input.substring(0, match.index);
         }
     }
     return input;
-}
+} // Regular utilities
+ // {{modifier}:}*{namespace}{-{suffix}}*{/{opacityModifier}}?
+ // Arbitrary values
+ // {{modifier}:}*{namespace}-[{arbitraryValue}]{/{opacityModifier}}?
+ // arbitraryValue: no whitespace, balanced quotes unless within quotes, balanced brackets unless within quotes
+ // Arbitrary properties
+ // {{modifier}:}*[{validCssPropertyName}:{arbitraryValue}]

package/lib/lib/detectNesting.js

@@ -1,19 +1,45 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+function isRoot(node) {
+    return node.type === "root";
+}
+function isAtLayer(node) {
+    return node.type === "atrule" && node.name === "layer";
+}
 function _default(_context) {
     return (root, result)=>{
-        let found = !1;
+        let found = false;
         root.walkAtRules("tailwind", (node)=>{
-            var node1;
-            return !found && (node.parent && !("root" === node.parent.type || "atrule" === (node1 = node.parent).type && "layer" === node1.name) ? (found = !0, node.warn(result, "Nested @tailwind rules were detected, but are not supported.\nConsider using a prefix to scope Tailwind's classes: https://tailwindcss.com/docs/configuration#prefix\nAlternatively, use the important selector strategy: https://tailwindcss.com/docs/configuration#selector-strategy"), !1) : void 0);
-        }), root.walkRules((rule)=>{
-            if (found) return !1;
-            rule.walkRules((nestedRule)=>(found = !0, nestedRule.warn(result, "Nested CSS was detected, but CSS nesting has not been configured correctly.\nPlease enable a CSS nesting plugin *before* Tailwind in your configuration.\nSee how here: https://tailwindcss.com/docs/using-with-preprocessors#nesting"), !1));
+            if (found) return false;
+            if (node.parent && !(isRoot(node.parent) || isAtLayer(node.parent))) {
+                found = true;
+                node.warn(result, [
+                    "Nested @tailwind rules were detected, but are not supported.",
+                    "Consider using a prefix to scope Tailwind's classes: https://tailwindcss.com/docs/configuration#prefix",
+                    "Alternatively, use the important selector strategy: https://tailwindcss.com/docs/configuration#selector-strategy"
+                ].join("\n"));
+                return false;
+            }
+        });
+        root.walkRules((rule)=>{
+            if (found) return false;
+            rule.walkRules((nestedRule)=>{
+                found = true;
+                nestedRule.warn(result, [
+                    "Nested CSS was detected, but CSS nesting has not been configured correctly.",
+                    "Please enable a CSS nesting plugin *before* Tailwind in your configuration.",
+                    "See how here: https://tailwindcss.com/docs/using-with-preprocessors#nesting"
+                ].join("\n"));
+                return false;
+            });
         });
     };
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>_default
-});