tailwindcss 0.0.0-insiders.ba2fd32 → 0.0.0-insiders.bbafc8e

package/lib/lib/setupContextUtils.js

@@ -23,6 +23,9 @@ var sharedState = _interopRequireWildcard(require("./sharedState"));
 var _toPath = require("../util/toPath");
 var _log = _interopRequireDefault(require("../util/log"));
 var _negateValue = _interopRequireDefault(require("../util/negateValue"));
+var _isValidArbitraryValue = _interopRequireDefault(require("../util/isValidArbitraryValue"));
+var _generateRules = require("./generateRules");
+var _cacheInvalidationJs = require("./cacheInvalidation.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -32,13 +35,11 @@ function _interopRequireWildcard(obj) {
     if (obj && obj.__esModule) {
         return obj;
     } else {
-        var newObj = {
-        };
+        var newObj = {};
         if (obj != null) {
             for(var key in obj){
                 if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {
-                    };
+                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
                     if (desc.get || desc.set) {
                         Object.defineProperty(newObj, key, desc);
                     } else {
@@ -51,6 +52,10 @@ function _interopRequireWildcard(obj) {
         return newObj;
     }
 }
+function prefix(context, selector) {
+    let prefix1 = context.tailwindConfig.prefix;
+    return typeof prefix1 === 'function' ? prefix1(selector) : prefix1 + selector;
+}
 function parseVariantFormatString(input) {
     if (input.includes('{')) {
         if (!isBalanced(input)) throw new Error(`Your { and } are unbalanced.`);
@@ -75,8 +80,7 @@ function isBalanced(input) {
     }
     return count === 0;
 }
-function insertInto(list, value, { before =[]  } = {
-}) {
+function insertInto(list, value, { before =[]  } = {}) {
     before = [].concat(before);
     if (before.length <= 0) {
         list.push(value);
@@ -111,44 +115,49 @@ function getClasses(selector) {
     });
     return parser.transformSync(selector);
 }
-function extractCandidates(node) {
+function extractCandidates(node, state = {
+    containsNonOnDemandable: false
+}, depth = 0) {
     let classes = [];
+    // Handle normal rules
     if (node.type === 'rule') {
         for (let selector of node.selectors){
             let classCandidates = getClasses(selector);
             // At least one of the selectors contains non-"on-demandable" candidates.
-            if (classCandidates.length === 0) return [];
-            classes = [
-                ...classes,
-                ...classCandidates
-            ];
+            if (classCandidates.length === 0) {
+                state.containsNonOnDemandable = true;
+            }
+            for (let classCandidate of classCandidates){
+                classes.push(classCandidate);
+            }
         }
-        return classes;
-    }
-    if (node.type === 'atrule') {
+    } else if (node.type === 'atrule') {
         node.walkRules((rule)=>{
-            classes = [
-                ...classes,
-                ...rule.selectors.flatMap((selector)=>getClasses(selector)
-                )
-            ];
+            for (let classCandidate of rule.selectors.flatMap((selector)=>getClasses(selector, state, depth + 1)
+            )){
+                classes.push(classCandidate);
+            }
         });
     }
+    if (depth === 0) {
+        return [
+            state.containsNonOnDemandable || classes.length === 0,
+            classes
+        ];
+    }
     return classes;
 }
 function withIdentifiers(styles) {
     return parseStyles(styles).flatMap((node)=>{
         let nodeMap = new Map();
-        let candidates = extractCandidates(node);
-        // If this isn't "on-demandable", assign it a universal candidate.
-        if (candidates.length === 0) {
-            return [
-                [
-                    '*',
-                    node
-                ]
-            ];
+        let [containsNonOnDemandableSelectors, candidates] = extractCandidates(node);
+        // If this isn't "on-demandable", assign it a universal candidate to always include it.
+        if (containsNonOnDemandableSelectors) {
+            candidates.unshift(sharedState.NOT_ON_DEMAND);
         }
+        // However, it could be that it also contains "on-demandable" candidates.
+        // E.g.: `span, .foo {}`, in that case it should still be possible to use
+        // `@apply foo` for example.
         return candidates.map((c)=>{
             if (!nodeMap.has(node)) {
                 nodeMap.set(node, node);
@@ -160,68 +169,6 @@ function withIdentifiers(styles) {
         });
     });
 }
-let matchingBrackets = new Map([
-    [
-        '{',
-        '}'
-    ],
-    [
-        '[',
-        ']'
-    ],
-    [
-        '(',
-        ')'
-    ], 
-]);
-let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
-        v,
-        k
-    ]
-));
-let quotes = new Set([
-    '"',
-    "'",
-    '`'
-]);
-// Arbitrary values must contain balanced brackets (), [] and {}. Escaped
-// values don't count, and brackets inside quotes also don't count.
-//
-// E.g.: w-[this-is]w-[weird-and-invalid]
-// E.g.: w-[this-is\\]w-\\[weird-but-valid]
-// E.g.: content-['this-is-also-valid]-weirdly-enough']
-function isValidArbitraryValue(value) {
-    let stack = [];
-    let inQuotes = false;
-    for(let i = 0; i < value.length; i++){
-        let char = value[i];
-        // Non-escaped quotes allow us to "allow" anything in between
-        if (quotes.has(char) && value[i - 1] !== '\\') {
-            inQuotes = !inQuotes;
-        }
-        if (inQuotes) continue;
-        if (value[i - 1] === '\\') continue; // Escaped
-        if (matchingBrackets.has(char)) {
-            stack.push(char);
-        } else if (inverseMatchingBrackets.has(char)) {
-            let inverse = inverseMatchingBrackets.get(char);
-            // Nothing to pop from, therefore it is unbalanced
-            if (stack.length <= 0) {
-                return false;
-            }
-            // Popped value must match the inverse value, otherwise it is unbalanced
-            if (stack.pop() !== inverse) {
-                return false;
-            }
-        }
-    }
-    // If there is still something on the stack, it is also unbalanced
-    if (stack.length > 0) {
-        return false;
-    }
-    // All good, totally balanced!
-    return true;
-}
 function buildPluginApi(tailwindConfig, context, { variantList , variantMap , offsets , classList  }) {
     function getConfigValue(path, defaultValue) {
         return path ? (0, _dlv).default(tailwindConfig, path, defaultValue) : tailwindConfig;
@@ -230,8 +177,8 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
         return (0, _prefixSelector).default(tailwindConfig.prefix, selector);
     }
     function prefixIdentifier(identifier, options) {
-        if (identifier === '*') {
-            return '*';
+        if (identifier === sharedState.NOT_ON_DEMAND) {
+            return sharedState.NOT_ON_DEMAND;
         }
         if (!options.respectPrefix) {
             return identifier;
@@ -239,8 +186,7 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
         return context.tailwindConfig.prefix + identifier;
     }
     return {
-        addVariant (variantName, variantFunctions, options = {
-        }) {
+        addVariant (variantName, variantFunctions, options = {}) {
             variantFunctions = [].concat(variantFunctions).map((variantFunction)=>{
                 if (typeof variantFunction !== 'string') {
                     // Safelist public API functions
@@ -300,33 +246,38 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
             // Preserved for backwards compatibility but not used in v3.0+
             return [];
         },
-        addUserCss (userCss) {
-            for (let [identifier, rule] of withIdentifiers(userCss)){
-                let offset = offsets.user++;
-                if (!context.candidateRuleMap.has(identifier)) {
-                    context.candidateRuleMap.set(identifier, []);
+        addBase (base) {
+            for (let [identifier, rule] of withIdentifiers(base)){
+                let prefixedIdentifier = prefixIdentifier(identifier, {});
+                let offset = offsets.base++;
+                if (!context.candidateRuleMap.has(prefixedIdentifier)) {
+                    context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
-                context.candidateRuleMap.get(identifier).push([
+                context.candidateRuleMap.get(prefixedIdentifier).push([
                     {
                         sort: offset,
-                        layer: 'user'
+                        layer: 'base'
                     },
                     rule
                 ]);
             }
         },
-        addBase (base) {
-            for (let [identifier, rule] of withIdentifiers(base)){
-                let prefixedIdentifier = prefixIdentifier(identifier, {
-                });
-                let offset = offsets.base++;
+        /**
+     * @param {string} group
+     * @param {Record<string, string | string[]>} declarations
+     */ addDefaults (group, declarations) {
+            const groups = {
+                [`@defaults ${group}`]: declarations
+            };
+            for (let [identifier, rule] of withIdentifiers(groups)){
+                let prefixedIdentifier = prefixIdentifier(identifier, {});
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
                 context.candidateRuleMap.get(prefixedIdentifier).push([
                     {
-                        sort: offset,
-                        layer: 'base'
+                        sort: offsets.base++,
+                        layer: 'defaults'
                     },
                     rule
                 ]);
@@ -337,19 +288,16 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
                 respectPrefix: true,
                 respectImportant: false
             };
-            options = Object.assign({
-            }, defaultOptions, Array.isArray(options) ? {
-            } : options);
+            options = Object.assign({}, defaultOptions, Array.isArray(options) ? {} : options);
             for (let [identifier, rule] of withIdentifiers(components)){
                 let prefixedIdentifier = prefixIdentifier(identifier, options);
-                let offset = offsets.components++;
                 classList.add(prefixedIdentifier);
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
                 context.candidateRuleMap.get(prefixedIdentifier).push([
                     {
-                        sort: offset,
+                        sort: offsets.components++,
                         layer: 'components',
                         options
                     },
@@ -362,19 +310,16 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
                 respectPrefix: true,
                 respectImportant: true
             };
-            options = Object.assign({
-            }, defaultOptions, Array.isArray(options) ? {
-            } : options);
+            options = Object.assign({}, defaultOptions, Array.isArray(options) ? {} : options);
             for (let [identifier, rule] of withIdentifiers(utilities)){
                 let prefixedIdentifier = prefixIdentifier(identifier, options);
-                let offset = offsets.utilities++;
                 classList.add(prefixedIdentifier);
                 if (!context.candidateRuleMap.has(prefixedIdentifier)) {
                     context.candidateRuleMap.set(prefixedIdentifier, []);
                 }
                 context.candidateRuleMap.get(prefixedIdentifier).push([
                     {
-                        sort: offset,
+                        sort: offsets.utilities++,
                         layer: 'utilities',
                         options
                     },
@@ -409,7 +354,7 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
                     if (!type.includes(coercedType) && !isOnlyPlugin) {
                         return [];
                     }
-                    if (!isValidArbitraryValue(value)) {
+                    if (!(0, _isValidArbitraryValue).default(value)) {
                         return [];
                     }
                     let ruleSets = [].concat(rule(value)).filter(Boolean).map((declaration)=>({
@@ -466,7 +411,7 @@ function buildPluginApi(tailwindConfig, context, { variantList , variantMap , of
                             return [];
                         }
                     }
-                    if (!isValidArbitraryValue(value)) {
+                    if (!(0, _isValidArbitraryValue).default(value)) {
                         return [];
                     }
                     let ruleSets = [].concat(rule(value)).filter(Boolean).map((declaration)=>({
@@ -501,11 +446,17 @@ function getFileModifiedMap(context) {
 function trackModified(files, fileModifiedMap) {
     let changed = false;
     for (let file of files){
+        var ref;
         if (!file) continue;
         let parsed = _url.default.parse(file);
         let pathname = parsed.hash ? parsed.href.replace(parsed.hash, '') : parsed.href;
         pathname = parsed.search ? pathname.replace(parsed.search, '') : pathname;
-        let newModified = _fs.default.statSync(decodeURIComponent(pathname)).mtimeMs;
+        let newModified = (ref = _fs.default.statSync(decodeURIComponent(pathname), {
+            throwIfNoEntry: false
+        })) === null || ref === void 0 ? void 0 : ref.mtimeMs;
+        if (!newModified) {
+            continue;
+        }
         if (!fileModifiedMap.has(file) || newModified > fileModifiedMap.get(file)) {
             changed = true;
         }
@@ -568,16 +519,6 @@ function collectLayerPlugins(root) {
             layerRule.remove();
         }
     });
-    root.walkRules((rule)=>{
-        // At this point it is safe to include all the left-over css from the
-        // user's css file. This is because the `@tailwind` and `@layer` directives
-        // will already be handled and will be removed from the css tree.
-        layerPlugins.push(function({ addUserCss  }) {
-            addUserCss(rule, {
-                respectPrefix: false
-            });
-        });
-    });
     return layerPlugins;
 }
 function resolvePlugins(context, root) {
@@ -608,7 +549,8 @@ function resolvePlugins(context, root) {
         _corePlugins.variantPlugins['reducedMotionVariants'],
         _corePlugins.variantPlugins['darkVariants'],
         _corePlugins.variantPlugins['printVariant'],
-        _corePlugins.variantPlugins['screenVariants'], 
+        _corePlugins.variantPlugins['screenVariants'],
+        _corePlugins.variantPlugins['orientationVariants'], 
     ];
     return [
         ...corePluginList,
@@ -622,6 +564,7 @@ function registerPlugins(plugins, context) {
     let variantList = [];
     let variantMap = new Map();
     let offsets = {
+        defaults: 0n,
         base: 0n,
         components: 0n,
         utilities: 0n,
@@ -647,18 +590,23 @@ function registerPlugins(plugins, context) {
         )
     )([
         offsets.base,
+        offsets.defaults,
         offsets.components,
         offsets.utilities,
         offsets.user, 
     ]);
     let reservedBits = BigInt(highestOffset.toString(2).length);
+    // A number one less than the top range of the highest offset area
+    // so arbitrary properties are always sorted at the end.
+    context.arbitraryPropertiesSort = (1n << reservedBits << 0n) - 1n;
     context.layerOrder = {
-        base: 1n << reservedBits << 0n,
-        components: 1n << reservedBits << 1n,
-        utilities: 1n << reservedBits << 2n,
-        user: 1n << reservedBits << 3n
+        defaults: 1n << reservedBits << 0n,
+        base: 1n << reservedBits << 1n,
+        components: 1n << reservedBits << 2n,
+        utilities: 1n << reservedBits << 3n,
+        user: 1n << reservedBits << 4n
     };
-    reservedBits += 4n;
+    reservedBits += 5n;
     let offset = 0;
     context.variantOrder = new Map(variantList.map((variant, i)=>{
         let variantFunctions = variantMap.get(variant).length;
@@ -674,9 +622,9 @@ function registerPlugins(plugins, context) {
         ...context.variantOrder.values()
     ].shift();
     // Build variantMap
-    for (let [variantName, variantFunctions] of variantMap.entries()){
+    for (let [variantName, variantFunctions1] of variantMap.entries()){
         let sort = context.variantOrder.get(variantName);
-        context.variantMap.set(variantName, variantFunctions.map((variantFunction, idx)=>[
+        context.variantMap.set(variantName, variantFunctions1.map((variantFunction, idx)=>[
                 sort << BigInt(idx),
                 variantFunction
             ]
@@ -686,32 +634,53 @@ function registerPlugins(plugins, context) {
     let safelist = ((_safelist = context.tailwindConfig.safelist) !== null && _safelist !== void 0 ? _safelist : []).filter(Boolean);
     if (safelist.length > 0) {
         let checks = [];
-        for (let value of safelist){
-            if (typeof value === 'string') {
+        for (let value1 of safelist){
+            if (typeof value1 === 'string') {
                 context.changedContent.push({
-                    content: value,
+                    content: value1,
                     extension: 'html'
                 });
                 continue;
             }
-            if (value instanceof RegExp) {
+            if (value1 instanceof RegExp) {
                 _log.default.warn('root-regex', [
                     'Regular expressions in `safelist` work differently in Tailwind CSS v3.0.',
-                    'Update your `safelist` configuration to eliminate this warning.'
+                    'Update your `safelist` configuration to eliminate this warning.',
+                    'https://tailwindcss.com/docs/content-configuration#safelisting-classes', 
                 ]);
                 continue;
             }
-            checks.push(value);
+            checks.push(value1);
         }
         if (checks.length > 0) {
             let patternMatchingCount = new Map();
+            let prefixLength = context.tailwindConfig.prefix.length;
             for (let util of classList){
                 let utils = Array.isArray(util) ? (()=>{
                     let [utilName, options] = util;
                     var ref;
-                    return Object.keys((ref = options === null || options === void 0 ? void 0 : options.values) !== null && ref !== void 0 ? ref : {
-                    }).map((value)=>(0, _nameClass).formatClass(utilName, value)
+                    let values = Object.keys((ref = options === null || options === void 0 ? void 0 : options.values) !== null && ref !== void 0 ? ref : {});
+                    let classes = values.map((value)=>(0, _nameClass).formatClass(utilName, value)
                     );
+                    if (options === null || options === void 0 ? void 0 : options.supportsNegativeValues) {
+                        // This is the normal negated version
+                        // e.g. `-inset-1` or `-tw-inset-1`
+                        classes = [
+                            ...classes,
+                            ...classes.map((cls)=>'-' + cls
+                            )
+                        ];
+                        // This is the negated version *after* the prefix
+                        // e.g. `tw--inset-1`
+                        // The prefix is already attached to util name
+                        // So we add the negative after the prefix
+                        classes = [
+                            ...classes,
+                            ...classes.map((cls)=>cls.slice(0, prefixLength) + '-' + cls.slice(prefixLength)
+                            ), 
+                        ];
+                    }
+                    return classes;
                 })() : [
                     util
                 ];
@@ -742,22 +711,51 @@ function registerPlugins(plugins, context) {
                 if (count !== 0) continue;
                 _log.default.warn([
                     `The safelist pattern \`${regex}\` doesn't match any Tailwind CSS classes.`,
-                    'Fix this pattern or remove it from your `safelist` configuration.', 
+                    'Fix this pattern or remove it from your `safelist` configuration.',
+                    'https://tailwindcss.com/docs/content-configuration#safelisting-classes', 
                 ]);
             }
         }
     }
+    // A list of utilities that are used by certain Tailwind CSS utilities but
+    // that don't exist on their own. This will result in them "not existing" and
+    // sorting could be weird since you still require them in order to make the
+    // host utitlies work properly. (Thanks Biology)
+    let parasiteUtilities = new Set([
+        prefix(context, 'group'),
+        prefix(context, 'peer')
+    ]);
+    context.getClassOrder = function getClassOrder(classes) {
+        let sortedClassNames = new Map();
+        for (let [sort, rule] of (0, _generateRules).generateRules(new Set(classes), context)){
+            if (sortedClassNames.has(rule.raws.tailwind.candidate)) continue;
+            sortedClassNames.set(rule.raws.tailwind.candidate, sort);
+        }
+        return classes.map((className)=>{
+            var ref;
+            let order = (ref = sortedClassNames.get(className)) !== null && ref !== void 0 ? ref : null;
+            if (order === null && parasiteUtilities.has(className)) {
+                // This will make sure that it is at the very beginning of the
+                // `components` layer which technically means 'before any
+                // components'.
+                order = context.layerOrder.components;
+            }
+            return [
+                className,
+                order
+            ];
+        });
+    };
     // Generate a list of strings for autocompletion purposes, e.g.
     // ['uppercase', 'lowercase', ...]
-    context.getClassList = function() {
+    context.getClassList = function getClassList() {
         let output = [];
         for (let util of classList){
             if (Array.isArray(util)) {
                 let [utilName, options] = util;
                 let negativeClasses = [];
                 var ref;
-                for (let [key, value] of Object.entries((ref = options === null || options === void 0 ? void 0 : options.values) !== null && ref !== void 0 ? ref : {
-                })){
+                for (let [key, value] of Object.entries((ref = options === null || options === void 0 ? void 0 : options.values) !== null && ref !== void 0 ? ref : {})){
                     output.push((0, _nameClass).formatClass(utilName, key));
                     if ((options === null || options === void 0 ? void 0 : options.supportsNegativeValues) && (0, _negateValue).default(value)) {
                         negativeClasses.push((0, _nameClass).formatClass(utilName, `-${key}`));
@@ -805,13 +803,14 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
         contextMap.set(sourcePath, context);
         existingContext = context;
     }
+    let cssDidChange = (0, _cacheInvalidationJs).hasContentChanged(sourcePath, root);
     // If there's already a context in the cache and we don't need to
     // reset the context, return the cached context.
     if (existingContext) {
         let contextDependenciesChanged = trackModified([
             ...contextDependencies
         ], getFileModifiedMap(existingContext));
-        if (!contextDependenciesChanged) {
+        if (!contextDependenciesChanged && !cssDidChange) {
             return [
                 existingContext,
                 false

package/lib/lib/setupTrackingContext.js

@@ -123,11 +123,12 @@ function setupTrackingContext(configOrPath) {
         return (root, result)=>{
             let [tailwindConfig, userConfigPath, tailwindConfigHash, configDependencies] = getTailwindConfig(configOrPath);
             let contextDependencies = new Set(configDependencies);
-            // If there are no @tailwind rules, we don't consider this CSS file or it's dependencies
-            // to be dependencies of the context. Can reuse the context even if they change.
-            // We may want to think about `@layer` being part of this trigger too, but it's tough
-            // because it's impossible for a layer in one file to end up in the actual @tailwind rule
-            // in another file since independent sources are effectively isolated.
+            // If there are no @tailwind or @apply rules, we don't consider this CSS
+            // file or its dependencies to be dependencies of the context. Can reuse
+            // the context even if they change. We may want to think about `@layer`
+            // being part of this trigger too, but it's tough because it's impossible
+            // for a layer in one file to end up in the actual @tailwind rule in
+            // another file since independent sources are effectively isolated.
             if (tailwindDirectives.size > 0) {
                 // Add current css file as a context dependencies.
                 contextDependencies.add(result.opts.from);
@@ -140,8 +141,8 @@ function setupTrackingContext(configOrPath) {
             }
             let [context] = (0, _setupContextUtils).getContext(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
             let candidateFiles = getCandidateFiles(context, tailwindConfig);
-            // If there are no @tailwind rules, we don't consider this CSS file or it's dependencies
-            // to be dependencies of the context. Can reuse the context even if they change.
+            // If there are no @tailwind or @apply rules, we don't consider this CSS file or it's
+            // dependencies to be dependencies of the context. Can reuse the context even if they change.
             // We may want to think about `@layer` being part of this trigger too, but it's tough
             // because it's impossible for a layer in one file to end up in the actual @tailwind rule
             // in another file since independent sources are effectively isolated.

package/lib/lib/sharedState.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.contextSourcesMap = exports.configContextMap = exports.env = exports.contextMap = void 0;
+exports.resolveDebug = resolveDebug;
+exports.NOT_ON_DEMAND = exports.sourceHashMap = exports.contextSourcesMap = exports.configContextMap = exports.contextMap = exports.env = void 0;
 const env = {
-    TAILWIND_MODE: process.env.TAILWIND_MODE,
     NODE_ENV: process.env.NODE_ENV,
-    DEBUG: process.env.DEBUG !== undefined && process.env.DEBUG !== '0',
-    TAILWIND_DISABLE_TOUCH: process.env.TAILWIND_DISABLE_TOUCH !== undefined,
-    TAILWIND_TOUCH_DIR: process.env.TAILWIND_TOUCH_DIR
+    DEBUG: resolveDebug(process.env.DEBUG)
 };
 exports.env = env;
 const contextMap = new Map();
@@ -17,3 +15,38 @@ const configContextMap = new Map();
 exports.configContextMap = configContextMap;
 const contextSourcesMap = new Map();
 exports.contextSourcesMap = contextSourcesMap;
+const sourceHashMap = new Map();
+exports.sourceHashMap = sourceHashMap;
+const NOT_ON_DEMAND = new String('*');
+exports.NOT_ON_DEMAND = NOT_ON_DEMAND;
+function resolveDebug(debug) {
+    if (debug === undefined) {
+        return false;
+    }
+    // Environment variables are strings, so convert to boolean
+    if (debug === 'true' || debug === '1') {
+        return true;
+    }
+    if (debug === 'false' || debug === '0') {
+        return false;
+    }
+    // Keep the debug convention into account:
+    // DEBUG=* -> This enables all debug modes
+    // DEBUG=projectA,projectB,projectC -> This enables debug for projectA, projectB and projectC
+    // DEBUG=projectA:* -> This enables all debug modes for projectA (if you have sub-types)
+    // DEBUG=projectA,-projectB -> This enables debug for projectA and explicitly disables it for projectB
+    if (debug === '*') {
+        return true;
+    }
+    let debuggers = debug.split(',').map((d)=>d.split(':')[0]
+    );
+    // Ignoring tailwindcss
+    if (debuggers.includes('-tailwindcss')) {
+        return false;
+    }
+    // Including tailwindcss
+    if (debuggers.includes('tailwindcss')) {
+        return true;
+    }
+    return false;
+}

package/lib/lib/substituteScreenAtRules.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 exports.default = _default;
+var _normalizeScreens = require("../util/normalizeScreens");
 var _buildMediaQuery = _interopRequireDefault(require("../util/buildMediaQuery"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
@@ -12,13 +13,15 @@ function _interopRequireDefault(obj) {
 function _default({ tailwindConfig: { theme  }  }) {
     return function(css) {
         css.walkAtRules('screen', (atRule)=>{
-            var ref, ref1;
-            const screen = atRule.params;
-            if (!((ref = theme.screens) === null || ref === void 0 ? void 0 : (ref1 = ref.hasOwnProperty) === null || ref1 === void 0 ? void 0 : ref1.call(ref, screen))) {
+            let screen = atRule.params;
+            let screens = (0, _normalizeScreens).normalizeScreens(theme.screens);
+            let screenDefinition = screens.find(({ name  })=>name === screen
+            );
+            if (!screenDefinition) {
                 throw atRule.error(`No \`${screen}\` screen found.`);
             }
             atRule.name = 'media';
-            atRule.params = (0, _buildMediaQuery).default(theme.screens[screen]);
+            atRule.params = (0, _buildMediaQuery).default(screenDefinition);
         });
     };
 }