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

package/lib/lib/content.js

@@ -10,28 +10,62 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    parseCandidateFiles: ()=>parseCandidateFiles,
-    resolvedChangedContent: ()=>resolvedChangedContent
+    parseCandidateFiles: function() {
+        return parseCandidateFiles;
+    },
+    resolvedChangedContent: function() {
+        return resolvedChangedContent;
+    }
 });
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _isGlob = /*#__PURE__*/ _interopRequireDefault(require("is-glob"));
-const _fastGlob = /*#__PURE__*/ _interopRequireDefault(require("fast-glob"));
-const _normalizePath = /*#__PURE__*/ _interopRequireDefault(require("normalize-path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _isglob = /*#__PURE__*/ _interop_require_default(require("is-glob"));
+const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
 const _parseGlob = require("../util/parseGlob");
 const _sharedState = require("./sharedState");
-function _interopRequireDefault(obj) {
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+/*!
+ * Modified version of normalize-path, original license below
+ *
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */ function normalizePath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError("expected path to be a string");
+    }
+    if (path === "\\" || path === "/") return "/";
+    var len = path.length;
+    if (len <= 1) return path;
+    // ensure that win32 namespaces has two leading slashes, so that the path is
+    // handled properly by the win32 version of path.parse() after being normalized
+    // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+    var prefix = "";
+    if (len > 4 && path[3] === "\\") {
+        var ch = path[2];
+        if ((ch === "?" || ch === ".") && path.slice(0, 2) === "\\\\") {
+            path = path.slice(2);
+            prefix = "//";
+        }
+    }
+    // Modified part: instead of purely splitting on `\\` and `/`, we split on
+    // `/` and `\\` that is _not_ followed by any of the following characters: ()[]
+    // This is to ensure that we keep the escaping of brackets and parentheses
+    let segs = path.split(/[/\\]+(?![\(\)\[\]])/);
+    return prefix + segs.join("/");
+}
 function parseCandidateFiles(context, tailwindConfig) {
     let files = tailwindConfig.content.files;
     // Normalize the file globs
     files = files.filter((filePath)=>typeof filePath === "string");
-    files = files.map(_normalizePath.default);
+    files = files.map(normalizePath);
     // Split into included and excluded globs
-    let tasks = _fastGlob.default.generateTasks(files);
+    let tasks = _fastglob.default.generateTasks(files);
     /** @type {ContentPath[]} */ let included = [];
     /** @type {ContentPath[]} */ let excluded = [];
     for (const task of tasks){
@@ -56,6 +90,9 @@ function parseCandidateFiles(context, tailwindConfig) {
  * @param {boolean} ignore
  * @returns {ContentPath}
  */ function parseFilePath(filePath, ignore) {
+    // Escape special characters in the file path such as: ()[]
+    // But only if the special character isn't already escaped
+    filePath = filePath.replace(/(?<!\\)([\[\]\(\)])/g, "\\$1");
     let contentPath = {
         original: filePath,
         base: filePath,
@@ -63,7 +100,7 @@ function parseCandidateFiles(context, tailwindConfig) {
         pattern: filePath,
         glob: null
     };
-    if ((0, _isGlob.default)(filePath)) {
+    if ((0, _isglob.default)(filePath)) {
         Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath));
     }
     return contentPath;
@@ -77,10 +114,10 @@ function parseCandidateFiles(context, tailwindConfig) {
     // Afaik, this technically shouldn't be needed but there's probably
     // some internal, direct path matching with a normalized path in
     // a package which can't handle mixed directory separators
-    let base = (0, _normalizePath.default)(contentPath.base);
+    let base = normalizePath(contentPath.base);
     // If the user's file path contains any special characters (like parens) for instance fast-glob
     // is like "OOOH SHINY" and treats them as such. So we have to escape the base path to fix this
-    base = _fastGlob.default.escapePath(base);
+    base = _fastglob.default.escapePath(base);
     contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base;
     contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern;
     return contentPath;
@@ -158,7 +195,7 @@ function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
     let mTimesToCommit = new Map();
     let changedFiles = new Set();
     _sharedState.env.DEBUG && console.time("Finding changed files");
-    let files = _fastGlob.default.sync(paths, {
+    let files = _fastglob.default.sync(paths, {
         absolute: true
     });
     for (let file of files){

package/lib/lib/defaultExtractor.js

@@ -4,10 +4,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "defaultExtractor", {
     enumerable: true,
-    get: ()=>defaultExtractor
+    get: function() {
+        return defaultExtractor;
+    }
 });
-const _featureFlags = require("../featureFlags");
-const _regex = /*#__PURE__*/ _interopRequireWildcard(require("./regex"));
+const _regex = /*#__PURE__*/ _interop_require_wildcard(require("./regex"));
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -16,7 +17,7 @@ function _getRequireWildcardCache(nodeInterop) {
         return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
     })(nodeInterop);
 }
-function _interopRequireWildcard(obj, nodeInterop) {
+function _interop_require_wildcard(obj, nodeInterop) {
     if (!nodeInterop && obj && obj.__esModule) {
         return obj;
     }
@@ -55,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)
@@ -77,16 +76,25 @@ 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
-            /-?(?:\w+)/,
+            _regex.any([
+                /-?(?:\w+)/,
+                // This is here to make sure @container supports everything that other utilities do
+                /@(?:\w+)/
+            ]),
             // Normal/Arbitrary values
             _regex.optional(_regex.any([
                 _regex.pattern([
                     // Arbitrary values
-                    /-(?:\w+-)*\[[^\s:]+\]/,
+                    _regex.any([
+                        /-(?:\w+-)*\['[^\s]+'\]/,
+                        /-(?:\w+-)*\["[^\s]+"\]/,
+                        /-(?:\w+-)*\[`[^\s]+`\]/,
+                        /-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s:\[\]]+\]/
+                    ]),
                     // Not immediately followed by an `{[(`
                     /(?![{([]])/,
                     // optionally followed by an opacity modifier
@@ -94,7 +102,12 @@ function* buildRegExps(context) {
                 ]),
                 _regex.pattern([
                     // Arbitrary values
-                    /-(?:\w+-)*\[[^\s]+\]/,
+                    _regex.any([
+                        /-(?:\w+-)*\['[^\s]+'\]/,
+                        /-(?:\w+-)*\["[^\s]+"\]/,
+                        /-(?:\w+-)*\[`[^\s]+`\]/,
+                        /-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s\[\]]+\]/
+                    ]),
                     // Not immediately followed by an `{[(`
                     /(?![{([]])/,
                     // optionally followed by an opacity modifier
@@ -113,6 +126,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
@@ -124,6 +142,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
@@ -143,20 +166,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/detectNesting.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>_default
+    get: function() {
+        return _default;
+    }
 });
 function isRoot(node) {
     return node.type === "root";

package/lib/lib/evaluateTailwindFunctions.js

@@ -4,19 +4,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>_default
+    get: function() {
+        return _default;
+    }
 });
-const _dlv = /*#__PURE__*/ _interopRequireDefault(require("dlv"));
-const _didyoumean = /*#__PURE__*/ _interopRequireDefault(require("didyoumean"));
-const _transformThemeValue = /*#__PURE__*/ _interopRequireDefault(require("../util/transformThemeValue"));
-const _postcssValueParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-value-parser"));
+const _dlv = /*#__PURE__*/ _interop_require_default(require("dlv"));
+const _didyoumean = /*#__PURE__*/ _interop_require_default(require("didyoumean"));
+const _transformThemeValue = /*#__PURE__*/ _interop_require_default(require("../util/transformThemeValue"));
+const _index = /*#__PURE__*/ _interop_require_default(require("../value-parser/index"));
 const _normalizeScreens = require("../util/normalizeScreens");
-const _buildMediaQuery = /*#__PURE__*/ _interopRequireDefault(require("../util/buildMediaQuery"));
+const _buildMediaQuery = /*#__PURE__*/ _interop_require_default(require("../util/buildMediaQuery"));
 const _toPath = require("../util/toPath");
 const _withAlphaVariable = require("../util/withAlphaVariable");
 const _pluginUtils = require("../util/pluginUtils");
-const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
-function _interopRequireDefault(obj) {
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -86,22 +88,22 @@ function validatePath(config, path, defaultValue, themeOpts = {}) {
         };
     }
     if (!(typeof value === "string" || typeof value === "number" || typeof value === "function" || value instanceof String || value instanceof Number || Array.isArray(value))) {
-        let error1 = `'${pathString}' was found but does not resolve to a string.`;
+        let error = `'${pathString}' was found but does not resolve to a string.`;
         if (isObject(value)) {
-            let validKeys1 = Object.keys(value).filter((key)=>validatePath(config, [
+            let validKeys = Object.keys(value).filter((key)=>validatePath(config, [
                     ...pathSegments,
                     key
                 ]).isValid);
-            if (validKeys1.length) {
-                error1 += ` Did you mean something like '${pathToString([
+            if (validKeys.length) {
+                error += ` Did you mean something like '${pathToString([
                     ...pathSegments,
-                    validKeys1[0]
+                    validKeys[0]
                 ])}'?`;
             }
         }
         return {
             isValid: false,
-            error: error1
+            error
         };
     }
     const [themeSection] = pathSegments;
@@ -119,7 +121,7 @@ function extractArgs(node, vNodes, functions) {
         if (vNode.type === "div" && vNode.value === ",") {
             args.push("");
         } else {
-            args[args.length - 1] += _postcssValueParser.default.stringify(vNode);
+            args[args.length - 1] += _index.default.stringify(vNode);
         }
     }
     return args;
@@ -133,7 +135,9 @@ function resolveVNode(node, vNode, functions) {
     return vNode;
 }
 function resolveFunctions(node, input, functions) {
-    return (0, _postcssValueParser.default)(input).walk((vNode)=>{
+    let hasAnyFn = Object.keys(functions).some((fn)=>input.includes(`${fn}(`));
+    if (!hasAnyFn) return input;
+    return (0, _index.default)(input).walk((vNode)=>{
         resolveVNode(node, vNode, functions);
     }).toString();
 }

package/lib/lib/expandApplyAtRules.js

@@ -4,15 +4,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>expandApplyAtRules
+    get: function() {
+        return expandApplyAtRules;
+    }
 });
-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 _generateRules = require("./generateRules");
-const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
+const _escapeClassName = /*#__PURE__*/ _interop_require_default(require("../util/escapeClassName"));
 const _applyImportantSelector = require("../util/applyImportantSelector");
 const _pseudoElements = require("../util/pseudoElements");
-function _interopRequireDefault(obj) {
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -25,7 +27,7 @@ function _interopRequireDefault(obj) {
         ]
     });
     container.walkRules((rule)=>{
-        (0, _postcssSelectorParser.default)((selectors)=>{
+        (0, _postcssselectorparser.default)((selectors)=>{
             selectors.walkClasses((classSelector)=>{
                 let parentSelector = classSelector.parent.toString();
                 let classes = groups.get(parentSelector);
@@ -42,7 +44,7 @@ function _interopRequireDefault(obj) {
         groups: normalizedGroups
     });
 }
-let selectorExtractor = (0, _postcssSelectorParser.default)();
+let selectorExtractor = (0, _postcssselectorparser.default)();
 /**
  * @param {string} ruleSelectors
  */ function extractSelectors(ruleSelectors) {
@@ -311,11 +313,11 @@ function processApply(root, context, localCache) {
             // Sort tag names before class names (but only sort each group (separated by a combinator)
             // separately and not in total)
             // This happens when replacing `.bar` in `.foo.bar` with a tag like `section`
-            for (let sel1 of replaced){
+            for (let sel of replaced){
                 let groups = [
                     []
                 ];
-                for (let node of sel1.nodes){
+                for (let node of sel.nodes){
                     if (node.type === "combinator") {
                         groups.push(node);
                         groups.push([]);
@@ -324,7 +326,7 @@ function processApply(root, context, localCache) {
                         last.push(node);
                     }
                 }
-                sel1.nodes = [];
+                sel.nodes = [];
                 for (let group of groups){
                     if (Array.isArray(group)) {
                         group.sort((a, b)=>{
@@ -340,7 +342,7 @@ function processApply(root, context, localCache) {
                             return 0;
                         });
                     }
-                    sel1.nodes = sel1.nodes.concat(group);
+                    sel.nodes = sel.nodes.concat(group);
                 }
             }
             sel.replaceWith(...replaced);
@@ -358,15 +360,15 @@ function processApply(root, context, localCache) {
             candidates,
             apply.source
         ]);
-        let [applyCandidates1, important] = extractApplyCandidates(apply.params);
+        let [applyCandidates, important] = extractApplyCandidates(apply.params);
         if (apply.parent.type === "atrule") {
             if (apply.parent.name === "screen") {
                 let screenType = apply.parent.params;
-                throw apply.error(`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${applyCandidates1.map((c)=>`${screenType}:${c}`).join(" ")} instead.`);
+                throw apply.error(`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${applyCandidates.map((c)=>`${screenType}:${c}`).join(" ")} instead.`);
             }
             throw apply.error(`@apply is not supported within nested at-rules like @${apply.parent.name}. You can fix this by un-nesting @${apply.parent.name}.`);
         }
-        for (let applyCandidate of applyCandidates1){
+        for (let applyCandidate of applyCandidates){
             if ([
                 prefix(context, "group"),
                 prefix(context, "peer")
@@ -385,16 +387,16 @@ function processApply(root, context, localCache) {
             ]);
         }
     }
-    for (let [parent, [candidates1, atApplySource]] of perParentApplies){
+    for (let [parent, [candidates, atApplySource]] of perParentApplies){
         let siblings = [];
-        for (let [applyCandidate1, important1, rules1] of candidates1){
+        for (let [applyCandidate, important, rules] of candidates){
             let potentialApplyCandidates = [
-                applyCandidate1,
+                applyCandidate,
                 ...extractBaseCandidates([
-                    applyCandidate1
+                    applyCandidate
                 ], context.tailwindConfig.separator)
             ];
-            for (let [meta, node] of rules1){
+            for (let [meta, node] of rules){
                 let parentClasses = extractClasses(parent);
                 let nodeClasses = extractClasses(node);
                 // When we encounter a rule like `.dark .a, .b { … }` we only want to be left with `[.dark, .a]` if the base applyCandidate is `.a` or with `[.b]` if the base applyCandidate is `.b`
@@ -425,20 +427,20 @@ function processApply(root, context, localCache) {
                 nodeClasses = nodeClasses.concat(extractBaseCandidates(nodeClasses, context.tailwindConfig.separator));
                 let intersects = parentClasses.some((selector)=>nodeClasses.includes(selector));
                 if (intersects) {
-                    throw node.error(`You cannot \`@apply\` the \`${applyCandidate1}\` utility here because it creates a circular dependency.`);
+                    throw node.error(`You cannot \`@apply\` the \`${applyCandidate}\` utility here because it creates a circular dependency.`);
                 }
-                let root1 = _postcss.default.root({
+                let root = _postcss.default.root({
                     nodes: [
                         node.clone()
                     ]
                 });
                 // Make sure every node in the entire tree points back at the @apply rule that generated it
-                root1.walk((node)=>{
+                root.walk((node)=>{
                     node.source = atApplySource;
                 });
                 let canRewriteSelector = node.type !== "atrule" || node.type === "atrule" && node.name !== "keyframes";
                 if (canRewriteSelector) {
-                    root1.walkRules((rule)=>{
+                    root.walkRules((rule)=>{
                         // Let's imagine you have the following structure:
                         //
                         // .foo {
@@ -470,7 +472,7 @@ function processApply(root, context, localCache) {
                         // would have replaced this with something that didn't exist and
                         // therefore it removed the selector altogether. In this specific
                         // case it would result in `{}` instead of `.something-unrelated {}`
-                        if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate1)) {
+                        if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate)) {
                             rule.remove();
                             return;
                         }
@@ -480,29 +482,35 @@ 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;
-                        rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate1);
+                        // 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) {
                             rule.selector = (0, _applyImportantSelector.applyImportantSelector)(rule.selector, importantSelector);
                         }
                         rule.walkDecls((d)=>{
-                            d.important = meta.important || important1;
+                            d.important = meta.important || important;
                         });
                         // Move pseudo elements to the end of the selector (if necessary)
-                        let selector = (0, _postcssSelectorParser.default)().astSync(rule.selector);
+                        let selector = (0, _postcssselectorparser.default)().astSync(rule.selector);
                         selector.each((sel)=>(0, _pseudoElements.movePseudos)(sel));
                         rule.selector = selector.toString();
                     });
                 }
                 // It could be that the node we were inserted was removed because the class didn't match
                 // If that was the *only* rule in the parent, then we have nothing add so we skip it
-                if (!root1.nodes[0]) {
+                if (!root.nodes[0]) {
                     continue;
                 }
                 // Insert it
                 siblings.push([
                     meta.sort,
-                    root1.nodes[0]
+                    root.nodes[0]
                 ]);
             }
         }
@@ -511,13 +519,13 @@ function processApply(root, context, localCache) {
         // `parent` refers to the node at `.abc` in: .abc { @apply mt-2 }
         parent.after(nodes);
     }
-    for (let apply1 of applies){
+    for (let apply of applies){
         // If there are left-over declarations, just remove the @apply
-        if (apply1.parent.nodes.length > 1) {
-            apply1.remove();
+        if (apply.parent.nodes.length > 1) {
+            apply.remove();
         } else {
             // The node is empty, drop the full node
-            apply1.parent.remove();
+            apply.parent.remove();
         }
     }
     // Do it again, in case we have other `@apply` rules