tailwindcss 3.1.6 → 3.1.7

package/lib/lib/expandApplyAtRules.js

@@ -2,19 +2,15 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = expandApplyAtRules;
-var _postcss = _interopRequireDefault(require("postcss"));
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-var _generateRules = require("./generateRules");
-var _bigSign = _interopRequireDefault(require("../util/bigSign"));
-var _escapeClassName = _interopRequireDefault(require("../util/escapeClassName"));
-function expandApplyAtRules(context) {
-    return (root)=>{
-        // Build a cache of the user's CSS so we can use it to resolve classes used by @apply
-        let localCache = lazyCache(()=>buildLocalApplyCache(root, context));
-        processApply(root, context, localCache);
-    };
-}
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>expandApplyAtRules
+});
+const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
+const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
+const _generateRules = require("./generateRules");
+const _bigSign = /*#__PURE__*/ _interopRequireDefault(require("../util/bigSign"));
+const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -28,7 +24,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);
@@ -40,12 +36,12 @@ function _interopRequireDefault(obj) {
         }).processSync(rule.selector);
     });
     let normalizedGroups = Array.from(groups.values(), (classes)=>Array.from(classes));
-    let classes1 = normalizedGroups.flat();
-    return Object.assign(classes1, {
+    let classes = normalizedGroups.flat();
+    return Object.assign(classes, {
         groups: normalizedGroups
     });
 }
-let selectorExtractor = (0, _postcssSelectorParser).default((root)=>root.nodes.map((node)=>node.toString()));
+let selectorExtractor = (0, _postcssSelectorParser.default)((root)=>root.nodes.map((node)=>node.toString()));
 /**
  * @param {string} ruleSelectors
  */ function extractSelectors(ruleSelectors) {
@@ -59,8 +55,8 @@ function extractBaseCandidates(candidates, separator) {
     return Array.from(baseClasses);
 }
 function prefix(context, selector) {
-    let prefix1 = context.tailwindConfig.prefix;
-    return typeof prefix1 === "function" ? prefix1(selector) : prefix1 + selector;
+    let prefix = context.tailwindConfig.prefix;
+    return typeof prefix === "function" ? prefix(selector) : prefix + selector;
 }
 function* pathToRoot(node) {
     yield node;
@@ -181,7 +177,7 @@ function* pathToRoot(node) {
                 ]));
             continue;
         }
-        let matches = Array.from((0, _generateRules).resolveMatches(candidate, context));
+        let matches = Array.from((0, _generateRules.resolveMatches)(candidate, context));
         if (matches.length === 0) {
             context.notClassCache.add(candidate);
             continue;
@@ -274,11 +270,11 @@ function processApply(root, context, localCache) {
    * Which means that we can replace `.hover\:font-bold` with `.abc` in `.hover\:font-bold:hover` resulting in `.abc:hover`
    */ // TODO: Should we use postcss-selector-parser for this instead?
     function replaceSelector(selector, utilitySelectors, candidate) {
-        let needle1 = `.${(0, _escapeClassName).default(candidate)}`;
+        let needle = `.${(0, _escapeClassName.default)(candidate)}`;
         let needles = [
             ...new Set([
-                needle1,
-                needle1.replace(/\\2c /g, "\\,")
+                needle,
+                needle.replace(/\\2c /g, "\\,")
             ])
         ];
         let utilitySelectorsList = extractSelectors(utilitySelectors);
@@ -308,15 +304,15 @@ function processApply(root, context, localCache) {
             candidates,
             apply.source
         ]);
-        let [applyCandidates, important] = extractApplyCandidates(apply.params);
+        let [applyCandidates1, important] = extractApplyCandidates(apply.params);
         if (apply.parent.type === "atrule") {
             if (apply.parent.name === "screen") {
                 const screenType = apply.parent.params;
-                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 @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 @${apply.parent.name}. You can fix this by un-nesting @${apply.parent.name}.`);
         }
-        for (let applyCandidate of applyCandidates){
+        for (let applyCandidate of applyCandidates1){
             if ([
                 prefix(context, "group"),
                 prefix(context, "peer")
@@ -337,16 +333,16 @@ function processApply(root, context, localCache) {
     }
     for (const [parent, [candidates1, atApplySource]] of perParentApplies){
         let siblings = [];
-        for (let [applyCandidate, important, rules] of candidates1){
+        for (let [applyCandidate1, important1, rules1] of candidates1){
             let potentialApplyCandidates = [
-                applyCandidate,
+                applyCandidate1,
                 ...extractBaseCandidates([
-                    applyCandidate
+                    applyCandidate1
                 ], context.tailwindConfig.separator), 
             ];
-            for (let [meta, node1] of rules){
+            for (let [meta, node] of rules1){
                 let parentClasses = extractClasses(parent);
-                let nodeClasses = extractClasses(node1);
+                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`
                 // So we've split them into groups
                 nodeClasses = nodeClasses.groups.filter((classList)=>classList.some((className)=>potentialApplyCandidates.includes(className))).flat();
@@ -375,20 +371,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 node1.error(`You cannot \`@apply\` the \`${applyCandidate}\` utility here because it creates a circular dependency.`);
+                    throw node.error(`You cannot \`@apply\` the \`${applyCandidate1}\` utility here because it creates a circular dependency.`);
                 }
-                let root = _postcss.default.root({
+                let root1 = _postcss.default.root({
                     nodes: [
-                        node1.clone()
+                        node.clone()
                     ]
                 });
                 // Make sure every node in the entire tree points back at the @apply rule that generated it
-                root.walk((node)=>{
+                root1.walk((node)=>{
                     node.source = atApplySource;
                 });
-                let canRewriteSelector = node1.type !== "atrule" || node1.type === "atrule" && node1.name !== "keyframes";
+                let canRewriteSelector = node.type !== "atrule" || node.type === "atrule" && node.name !== "keyframes";
                 if (canRewriteSelector) {
-                    root.walkRules((rule)=>{
+                    root1.walkRules((rule)=>{
                         // Let's imagine you have the following structure:
                         //
                         // .foo {
@@ -420,7 +416,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 === applyCandidate)) {
+                        if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate1)) {
                             rule.remove();
                             return;
                         }
@@ -430,13 +426,13 @@ 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, applyCandidate);
+                        rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate1);
                         // And then re-add it if it was removed
                         if (importantSelector && parentSelector !== parent.selector) {
                             rule.selector = `${importantSelector} ${rule.selector}`;
                         }
                         rule.walkDecls((d)=>{
-                            d.important = meta.important || important;
+                            d.important = meta.important || important1;
                         });
                     });
                 }
@@ -447,12 +443,12 @@ function processApply(root, context, localCache) {
                         ...meta,
                         sort: meta.sort | context.layerOrder[meta.layer]
                     },
-                    root.nodes[0], 
+                    root1.nodes[0], 
                 ]);
             }
         }
         // Inject the rules, sorted, correctly
-        let nodes = siblings.sort(([a], [z])=>(0, _bigSign).default(a.sort - z.sort)).map((s)=>s[1]);
+        let nodes = siblings.sort(([a], [z])=>(0, _bigSign.default)(a.sort - z.sort)).map((s)=>s[1]);
         // `parent` refers to the node at `.abc` in: .abc { @apply mt-2 }
         parent.after(nodes);
     }
@@ -468,3 +464,10 @@ function processApply(root, context, localCache) {
     // Do it again, in case we have other `@apply` rules
     processApply(root, context, localCache);
 }
+function expandApplyAtRules(context) {
+    return (root)=>{
+        // Build a cache of the user's CSS so we can use it to resolve classes used by @apply
+        let localCache = lazyCache(()=>buildLocalApplyCache(root, context));
+        processApply(root, context, localCache);
+    };
+}

package/lib/lib/expandTailwindAtRules.js

@@ -2,157 +2,32 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = expandTailwindAtRules;
-var _quickLru = _interopRequireDefault(require("quick-lru"));
-var sharedState = _interopRequireWildcard(require("./sharedState"));
-var _generateRules = require("./generateRules");
-var _bigSign = _interopRequireDefault(require("../util/bigSign"));
-var _log = _interopRequireDefault(require("../util/log"));
-var _cloneNodes = _interopRequireDefault(require("../util/cloneNodes"));
-var _defaultExtractor = require("./defaultExtractor");
-function expandTailwindAtRules(context) {
-    return (root)=>{
-        let layerNodes = {
-            base: null,
-            components: null,
-            utilities: null,
-            variants: null
-        };
-        root.walkAtRules((rule)=>{
-            // Make sure this file contains Tailwind directives. If not, we can save
-            // a lot of work and bail early. Also we don't have to register our touch
-            // file as a dependency since the output of this CSS does not depend on
-            // the source of any templates. Think Vue <style> blocks for example.
-            if (rule.name === "tailwind") {
-                if (Object.keys(layerNodes).includes(rule.params)) {
-                    layerNodes[rule.params] = rule;
-                }
-            }
-        });
-        if (Object.values(layerNodes).every((n)=>n === null)) {
-            return root;
-        }
-        // ---
-        // Find potential rules in changed files
-        let candidates = new Set([
-            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);
-        }
-        env.DEBUG && console.timeEnd("Reading changed files");
-        // ---
-        // Generate the actual CSS
-        let classCacheCount = context.classCache.size;
-        env.DEBUG && console.time("Generate rules");
-        let rules = (0, _generateRules).generateRules(candidates, 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");
-        if (context.stylesheetCache === null || context.classCache.size !== classCacheCount) {
-            for (let rule of rules){
-                context.ruleCache.add(rule);
-            }
-            context.stylesheetCache = buildStylesheet([
-                ...context.ruleCache
-            ], context);
-        }
-        env.DEBUG && console.timeEnd("Build stylesheet");
-        let { defaults: defaultNodes , base: baseNodes , components: componentNodes , utilities: utilityNodes , variants: screenNodes ,  } = context.stylesheetCache;
-        // ---
-        // Replace any Tailwind directives with generated CSS
-        if (layerNodes.base) {
-            layerNodes.base.before((0, _cloneNodes).default([
-                ...baseNodes,
-                ...defaultNodes
-            ], layerNodes.base.source, {
-                layer: "base"
-            }));
-            layerNodes.base.remove();
-        }
-        if (layerNodes.components) {
-            layerNodes.components.before((0, _cloneNodes).default([
-                ...componentNodes
-            ], layerNodes.components.source, {
-                layer: "components"
-            }));
-            layerNodes.components.remove();
-        }
-        if (layerNodes.utilities) {
-            layerNodes.utilities.before((0, _cloneNodes).default([
-                ...utilityNodes
-            ], layerNodes.utilities.source, {
-                layer: "utilities"
-            }));
-            layerNodes.utilities.remove();
-        }
-        // 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;
-            if (parentLayer === "components") {
-                return layerNodes.components !== null;
-            }
-            if (parentLayer === "utilities") {
-                return layerNodes.utilities !== null;
-            }
-            return true;
-        });
-        if (layerNodes.variants) {
-            layerNodes.variants.before((0, _cloneNodes).default(variantNodes, layerNodes.variants.source, {
-                layer: "variants"
-            }));
-            layerNodes.variants.remove();
-        } else if (variantNodes.length > 0) {
-            root.append((0, _cloneNodes).default(variantNodes, root.source, {
-                layer: "variants"
-            }));
-        }
-        // 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";
-        });
-        if (layerNodes.utilities && utilityNodes.size === 0 && !hasUtilityVariants) {
-            _log.default.warn("content-problems", [
-                "No utility classes were detected in your source files. If this is unexpected, double-check the `content` option in your Tailwind CSS configuration.",
-                "https://tailwindcss.com/docs/content-configuration", 
-            ]);
-        }
-        // ---
-        if (env.DEBUG) {
-            console.log("Potential classes: ", candidates.size);
-            console.log("Active contexts: ", sharedState.contextSourcesMap.size);
-        }
-        // Clear the cache for the changed files
-        context.changedContent = [];
-        // Cleanup any leftover @layer atrules
-        root.walkAtRules("layer", (rule)=>{
-            if (Object.keys(layerNodes).includes(rule.params)) {
-                rule.remove();
-            }
-        });
-    };
-}
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>expandTailwindAtRules
+});
+const _quickLru = /*#__PURE__*/ _interopRequireDefault(require("quick-lru"));
+const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
+const _generateRules = require("./generateRules");
+const _bigSign = /*#__PURE__*/ _interopRequireDefault(require("../util/bigSign"));
+const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
+const _cloneNodes = /*#__PURE__*/ _interopRequireDefault(require("../util/cloneNodes"));
+const _defaultExtractor = require("./defaultExtractor");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _getRequireWildcardCache() {
+function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
-    var cache = new WeakMap();
-    _getRequireWildcardCache = function() {
-        return cache;
-    };
-    return cache;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
 }
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
         return obj;
     }
     if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
@@ -160,14 +35,14 @@ function _interopRequireWildcard(obj) {
             default: obj
         };
     }
-    var cache = _getRequireWildcardCache();
+    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 (Object.prototype.hasOwnProperty.call(obj, key)) {
+        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);
@@ -182,7 +57,7 @@ function _interopRequireWildcard(obj) {
     }
     return newObj;
 }
-let env = sharedState.env;
+let env = _sharedState.env;
 const builtInExtractors = {
     DEFAULT: _defaultExtractor.defaultExtractor
 };
@@ -221,15 +96,15 @@ function getClassCandidates(content, extractor, candidates, seen) {
         } else {
             let extractorMatches = extractor(line).filter((s)=>s !== "!*");
             let lineMatchesSet = new Set(extractorMatches);
-            for (let match of lineMatchesSet){
-                candidates.add(match);
+            for (let match1 of lineMatchesSet){
+                candidates.add(match1);
             }
             extractorCache.get(extractor).set(line, lineMatchesSet);
         }
     }
 }
 function buildStylesheet(rules, context) {
-    let sortedRules = rules.sort(([a], [z])=>(0, _bigSign).default(a - z));
+    let sortedRules = rules.sort(([a], [z])=>(0, _bigSign.default)(a - z));
     let returnValue = {
         base: new Set(),
         defaults: new Set(),
@@ -274,3 +149,131 @@ function buildStylesheet(rules, context) {
     }
     return returnValue;
 }
+function expandTailwindAtRules(context) {
+    return (root)=>{
+        let layerNodes = {
+            base: null,
+            components: null,
+            utilities: null,
+            variants: null
+        };
+        root.walkAtRules((rule)=>{
+            // Make sure this file contains Tailwind directives. If not, we can save
+            // a lot of work and bail early. Also we don't have to register our touch
+            // file as a dependency since the output of this CSS does not depend on
+            // the source of any templates. Think Vue <style> blocks for example.
+            if (rule.name === "tailwind") {
+                if (Object.keys(layerNodes).includes(rule.params)) {
+                    layerNodes[rule.params] = rule;
+                }
+            }
+        });
+        if (Object.values(layerNodes).every((n)=>n === null)) {
+            return root;
+        }
+        // ---
+        // Find potential rules in changed files
+        let candidates = new Set([
+            _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);
+        }
+        env.DEBUG && console.timeEnd("Reading changed files");
+        // ---
+        // Generate the actual CSS
+        let classCacheCount = context.classCache.size;
+        env.DEBUG && console.time("Generate rules");
+        let rules = (0, _generateRules.generateRules)(candidates, 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");
+        if (context.stylesheetCache === null || context.classCache.size !== classCacheCount) {
+            for (let rule of rules){
+                context.ruleCache.add(rule);
+            }
+            context.stylesheetCache = buildStylesheet([
+                ...context.ruleCache
+            ], context);
+        }
+        env.DEBUG && console.timeEnd("Build stylesheet");
+        let { defaults: defaultNodes , base: baseNodes , components: componentNodes , utilities: utilityNodes , variants: screenNodes ,  } = context.stylesheetCache;
+        // ---
+        // Replace any Tailwind directives with generated CSS
+        if (layerNodes.base) {
+            layerNodes.base.before((0, _cloneNodes.default)([
+                ...baseNodes,
+                ...defaultNodes
+            ], layerNodes.base.source, {
+                layer: "base"
+            }));
+            layerNodes.base.remove();
+        }
+        if (layerNodes.components) {
+            layerNodes.components.before((0, _cloneNodes.default)([
+                ...componentNodes
+            ], layerNodes.components.source, {
+                layer: "components"
+            }));
+            layerNodes.components.remove();
+        }
+        if (layerNodes.utilities) {
+            layerNodes.utilities.before((0, _cloneNodes.default)([
+                ...utilityNodes
+            ], layerNodes.utilities.source, {
+                layer: "utilities"
+            }));
+            layerNodes.utilities.remove();
+        }
+        // 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;
+            if (parentLayer === "components") {
+                return layerNodes.components !== null;
+            }
+            if (parentLayer === "utilities") {
+                return layerNodes.utilities !== null;
+            }
+            return true;
+        });
+        if (layerNodes.variants) {
+            layerNodes.variants.before((0, _cloneNodes.default)(variantNodes, layerNodes.variants.source, {
+                layer: "variants"
+            }));
+            layerNodes.variants.remove();
+        } else if (variantNodes.length > 0) {
+            root.append((0, _cloneNodes.default)(variantNodes, root.source, {
+                layer: "variants"
+            }));
+        }
+        // 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";
+        });
+        if (layerNodes.utilities && utilityNodes.size === 0 && !hasUtilityVariants) {
+            _log.default.warn("content-problems", [
+                "No utility classes were detected in your source files. If this is unexpected, double-check the `content` option in your Tailwind CSS configuration.",
+                "https://tailwindcss.com/docs/content-configuration", 
+            ]);
+        }
+        // ---
+        if (env.DEBUG) {
+            console.log("Potential classes: ", candidates.size);
+            console.log("Active contexts: ", _sharedState.contextSourcesMap.size);
+        }
+        // Clear the cache for the changed files
+        context.changedContent = [];
+        // Cleanup any leftover @layer atrules
+        root.walkAtRules("layer", (rule)=>{
+            if (Object.keys(layerNodes).includes(rule.params)) {
+                rule.remove();
+            }
+        });
+    };
+}