tailwindcss 0.0.0-insiders.e63c111 → 0.0.0-insiders.e66110e

package/CHANGELOG.md

@@ -9,7 +9,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Cleanup unused `variantOrder` ([#9829](https://github.com/tailwindlabs/tailwindcss/pull/9829))
+- Fix `foo-[abc]/[def]` not being handled correctly ([#9866](https://github.com/tailwindlabs/tailwindcss/pull/9866))
+
+### Added
+
+- Add container queries plugin to standalone CLI ([#9865](https://github.com/tailwindlabs/tailwindcss/pull/9865))
+
+## [3.2.4] - 2022-11-11
+
+### Added
+
+- Add `blocklist` option to prevent generating unwanted CSS ([#9812](https://github.com/tailwindlabs/tailwindcss/pull/9812))
+
+### Fixed
+
+- Fix watching of files on Linux when renames are involved ([#9796](https://github.com/tailwindlabs/tailwindcss/pull/9796))
+- Make sure errors are always displayed when watching for changes ([#9810](https://github.com/tailwindlabs/tailwindcss/pull/9810))
+
+## [3.2.3] - 2022-11-09
+
+### Fixed
+
+- Fixed use of `raw` content in the CLI ([#9773](https://github.com/tailwindlabs/tailwindcss/pull/9773))
+- Pick up changes from files that are both context and content deps ([#9787](https://github.com/tailwindlabs/tailwindcss/pull/9787))
+- Sort pseudo-elements ONLY after classes when using variants and `@apply` ([#9765](https://github.com/tailwindlabs/tailwindcss/pull/9765))
+- Support important utilities in the safelist (pattern must include a `!`) ([#9791](https://github.com/tailwindlabs/tailwindcss/pull/9791))
+
+## [3.2.2] - 2022-11-04
+
+### Fixed
+
 - Escape special characters in resolved content base paths ([#9650](https://github.com/tailwindlabs/tailwindcss/pull/9650))
+- Don't reuse container for array returning variant functions ([#9644](https://github.com/tailwindlabs/tailwindcss/pull/9644))
+- Exclude non-relevant selectors when generating rules with the important modifier ([#9677](https://github.com/tailwindlabs/tailwindcss/issues/9677))
+- Fix merging of arrays during config resolution ([#9706](https://github.com/tailwindlabs/tailwindcss/issues/9706))
+- Ensure configured `font-feature-settings` are included in Preflight ([#9707](https://github.com/tailwindlabs/tailwindcss/pull/9707))
+- Fix fractional values not being parsed properly inside arbitrary properties ([#9705](https://github.com/tailwindlabs/tailwindcss/pull/9705))
+- Fix incorrect selectors when using `@apply` in selectors with combinators and pseudos ([#9722](https://github.com/tailwindlabs/tailwindcss/pull/9722))
+- Fix cannot read properties of undefined (reading 'modifier') ([#9656](https://github.com/tailwindlabs/tailwindcss/pull/9656), [aa979d6](https://github.com/tailwindlabs/tailwindcss/commit/aa979d645f8bf4108c5fc938d7c0ba085b654c31))
 
 ## [3.2.1] - 2022-10-21
 
@@ -2090,7 +2128,10 @@ No release notes
 
 - Everything!
 
-[unreleased]: https://github.com/tailwindlabs/tailwindcss/compare/v3.2.1...HEAD
+[unreleased]: https://github.com/tailwindlabs/tailwindcss/compare/v3.2.4...HEAD
+[3.2.4]: https://github.com/tailwindlabs/tailwindcss/compare/v3.2.3...v3.2.4
+[3.2.3]: https://github.com/tailwindlabs/tailwindcss/compare/v3.2.2...v3.2.3
+[3.2.2]: https://github.com/tailwindlabs/tailwindcss/compare/v3.2.1...v3.2.2
 [3.2.1]: https://github.com/tailwindlabs/tailwindcss/compare/v3.2.0...v3.2.1
 [3.2.0]: https://github.com/tailwindlabs/tailwindcss/compare/v3.1.8...v3.2.0
 [3.1.8]: https://github.com/tailwindlabs/tailwindcss/compare/v3.1.7...v3.1.8

package/lib/cli/build/plugin.js

@@ -170,9 +170,9 @@ let state = {
         let rawContent = this.config.content.files.filter((file)=>{
             return file !== null && typeof file === "object";
         });
-        for (let { raw: content1 , extension ="html"  } of rawContent){
-            content1.push({
-                content: content1,
+        for (let { raw: htmlContent , extension ="html"  } of rawContent){
+            content.push({
+                content: htmlContent,
                 extension
             });
         }
@@ -311,6 +311,17 @@ async function createProcessor(args, cliConfigPath) {
             let end = process.hrtime.bigint();
             console.error();
             console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
+        }).then(()=>{}, (err)=>{
+            // TODO: If an initial build fails we can't easily pick up any PostCSS dependencies
+            // that were collected before the error occurred
+            // The result is not stored on the error so we have to store it externally
+            // and pull the messages off of it here somehow
+            // This results in a less than ideal DX because the watcher will not pick up
+            // changes to imported CSS if one of them caused an error during the initial build
+            // If you fix it and then save the main CSS file so there's no error
+            // The watcher will start watching the imported CSS files and will be
+            // resilient to future errors.
+            console.error(err);
         });
     }
     /**

package/lib/cli/build/watching.js

@@ -37,22 +37,70 @@ function createWatcher(args, { state , rebuild  }) {
             pollInterval: pollInterval
         } : false
     });
+    // A queue of rebuilds, file reads, etc… to run
     let chain = Promise.resolve();
-    let pendingRebuilds = new Set();
-    let changedContent = [];
+    /**
+   * A list of files that have been changed since the last rebuild
+   *
+   * @type {{file: string, content: () => Promise<string>, extension: string}[]}
+   */ let changedContent = [];
+    /**
+   * A list of files for which a rebuild has already been queued.
+   * This is used to prevent duplicate rebuilds when multiple events are fired for the same file.
+   * The rebuilt file is cleared from this list when it's associated rebuild has _started_
+   * This is because if the file is changed during a rebuild it won't trigger a new rebuild which it should
+   **/ let pendingRebuilds = new Set();
+    let _timer;
+    let _reject;
+    /**
+   * Rebuilds the changed files and resolves when the rebuild is
+   * complete regardless of whether it was successful or not
+   */ async function rebuildAndContinue() {
+        let changes = changedContent.splice(0);
+        // There are no changes to rebuild so we can just do nothing
+        if (changes.length === 0) {
+            return Promise.resolve();
+        }
+        // Clear all pending rebuilds for the about-to-be-built files
+        changes.forEach((change)=>pendingRebuilds.delete(change.file));
+        // Resolve the promise even when the rebuild fails
+        return rebuild(changes).then(()=>{}, ()=>{});
+    }
     /**
    *
    * @param {*} file
    * @param {(() => Promise<string>) | null} content
-   */ function recordChangedFile(file, content = null) {
+   * @param {boolean} skipPendingCheck
+   * @returns {Promise<void>}
+   */ function recordChangedFile(file, content = null, skipPendingCheck = false) {
         file = _path.default.resolve(file);
-        content = content !== null && content !== void 0 ? content : async ()=>await _fs.default.promises.readFile(file, "utf8");
+        // Applications like Vim/Neovim fire both rename and change events in succession for atomic writes
+        // In that case rebuild has already been queued by rename, so can be skipped in change
+        if (pendingRebuilds.has(file) && !skipPendingCheck) {
+            return Promise.resolve();
+        }
+        // Mark that a rebuild of this file is going to happen
+        // It MUST happen synchronously before the rebuild is queued for this to be effective
+        pendingRebuilds.add(file);
         changedContent.push({
             file,
-            content,
+            content: content !== null && content !== void 0 ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
             extension: _path.default.extname(file).slice(1)
         });
-        chain = chain.then(()=>rebuild(changedContent.splice(0)));
+        if (_timer) {
+            clearTimeout(_timer);
+            _reject();
+        }
+        // If a rebuild is already in progress we don't want to start another one until the 10ms timer has expired
+        chain = chain.then(()=>new Promise((resolve, reject)=>{
+                _timer = setTimeout(resolve, 10);
+                _reject = reject;
+            }));
+        // Resolves once this file has been rebuilt (or the rebuild for this file has failed)
+        // This queues as many rebuilds as there are changed files
+        // But those rebuilds happen after some delay
+        // And will immediately resolve if there are no changes
+        chain = chain.then(rebuildAndContinue, rebuildAndContinue);
         return chain;
     }
     watcher.on("change", (file)=>recordChangedFile(file));
@@ -91,15 +139,32 @@ function createWatcher(args, { state , rebuild  }) {
         if (pendingRebuilds.has(filePath)) {
             return;
         }
+        // We'll go ahead and add the file to the pending rebuilds list here
+        // It'll be removed when the rebuild starts unless the read fails
+        // which will be taken care of as well
         pendingRebuilds.add(filePath);
-        chain = chain.then(async ()=>{
-            let content;
+        async function enqueue() {
             try {
-                content = await (0, _utilsJs.readFileWithRetries)(_path.default.resolve(filePath));
-            } finally{
-                pendingRebuilds.delete(filePath);
+                // We need to read the file as early as possible outside of the chain
+                // because it may be gone by the time we get to it. doing the read
+                // immediately increases the chance that the file is still there
+                let content = await (0, _utilsJs.readFileWithRetries)(_path.default.resolve(filePath));
+                if (content === undefined) {
+                    return;
+                }
+                // This will push the rebuild onto the chain
+                // We MUST skip the rebuild check here otherwise the rebuild will never happen on Linux
+                // This is because the order of events and timing is different on Linux
+                // @ts-ignore: TypeScript isn't picking up that content is a string here
+                await recordChangedFile(filePath, ()=>content, true);
+            } catch  {
+            // If reading the file fails, it's was probably a deleted temporary file
+            // So we can ignore it and no rebuild is needed
             }
-            return recordChangedFile(filePath, ()=>content);
+        }
+        enqueue().then(()=>{
+            // If the file read fails we still need to make sure the file isn't stuck in the pending rebuilds list
+            pendingRebuilds.delete(filePath);
         });
     });
     return {

package/lib/css/preflight.css

@@ -22,6 +22,7 @@
 2. Prevent adjustments of font size after orientation changes in iOS.
 3. Use a more readable tab size.
 4. Use the user's configured `sans` font-family by default.
+5. Use the user's configured `sans` font-feature-settings by default.
 */
 
 html {
@@ -30,6 +31,7 @@ html {
   -moz-tab-size: 4; /* 3 */
   tab-size: 4; /* 3 */
   font-family: theme('fontFamily.sans', ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"); /* 4 */
+  font-feature-settings: theme('fontFamily.sans[1].fontFeatureSettings', normal); /* 5 */
 }
 
 /*

package/lib/lib/content.js

@@ -160,7 +160,14 @@ function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
     for (let file of files){
         let prevModified = fileModifiedMap.has(file) ? fileModifiedMap.get(file) : -Infinity;
         let modified = _fs.default.statSync(file).mtimeMs;
-        if (modified > prevModified) {
+        // This check is intentionally >= because we track the last modified time of context dependencies
+        // earier in the process and we want to make sure we don't miss any changes that happen
+        // when a context dependency is also a content dependency
+        // Ideally, we'd do all this tracking at one time but that is a larger refactor
+        // than we want to commit to right now, so this is a decent compromise.
+        // This should be sufficient because file modification times will be off by at least
+        // 1ms (the precision of fstat in Node) in most cases if they exist and were changed.
+        if (modified >= prevModified) {
             changedFiles.add(file);
             fileModifiedMap.set(file, modified);
         }

package/lib/lib/defaultExtractor.js

@@ -72,7 +72,7 @@ function* buildRegExps(context) {
     ])) : "";
     let utility = _regex.any([
         // Arbitrary properties
-        /\[[^\s:'"`]+:[^\s\]]+\]/,
+        /\[[^\s:'"`]+:[^\s]+\]/,
         // Utilities
         _regex.pattern([
             // Utility Name / Group Name

package/lib/lib/expandApplyAtRules.js

@@ -306,21 +306,40 @@ function processApply(root, context, localCache) {
                     hasReplaced = true;
                 });
             });
-            // Sort tag names before class names
+            // 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 (const sel1 of replaced){
-                sel1.sort((a, b)=>{
-                    if (a.type === "tag" && b.type === "class") {
-                        return -1;
-                    } else if (a.type === "class" && b.type === "tag") {
-                        return 1;
-                    } else if (a.type === "class" && b.type === "pseudo") {
-                        return -1;
-                    } else if (a.type === "pseudo" && b.type === "class") {
-                        return 1;
+            for (let sel1 of replaced){
+                let groups = [
+                    []
+                ];
+                for (let node of sel1.nodes){
+                    if (node.type === "combinator") {
+                        groups.push(node);
+                        groups.push([]);
+                    } else {
+                        let last = groups[groups.length - 1];
+                        last.push(node);
                     }
-                    return sel1.index(a) - sel1.index(b);
-                });
+                }
+                sel1.nodes = [];
+                for (let group of groups){
+                    if (Array.isArray(group)) {
+                        group.sort((a, b)=>{
+                            if (a.type === "tag" && b.type === "class") {
+                                return -1;
+                            } else if (a.type === "class" && b.type === "tag") {
+                                return 1;
+                            } else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
+                                return -1;
+                            } else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
+                                return 1;
+                            }
+                            return 0;
+                        });
+                    }
+                    sel1.nodes = sel1.nodes.concat(group);
+                }
             }
             sel.replaceWith(...replaced);
         });
@@ -340,7 +359,7 @@ function processApply(root, context, localCache) {
         let [applyCandidates1, important] = extractApplyCandidates(apply.params);
         if (apply.parent.type === "atrule") {
             if (apply.parent.name === "screen") {
-                const screenType = apply.parent.params;
+                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 @${apply.parent.name}. You can fix this by un-nesting @${apply.parent.name}.`);
@@ -364,7 +383,7 @@ function processApply(root, context, localCache) {
             ]);
         }
     }
-    for (const [parent, [candidates1, atApplySource]] of perParentApplies){
+    for (let [parent, [candidates1, atApplySource]] of perParentApplies){
         let siblings = [];
         for (let [applyCandidate1, important1, rules1] of candidates1){
             let potentialApplyCandidates = [

package/lib/lib/expandTailwindAtRules.js

@@ -169,7 +169,7 @@ function expandTailwindAtRules(context) {
             ], context);
         }
         env.DEBUG && console.timeEnd("Build stylesheet");
-        let { defaults: defaultNodes , base: baseNodes , components: componentNodes , utilities: utilityNodes , variants: screenNodes ,  } = context.stylesheetCache;
+        let { defaults: defaultNodes , base: baseNodes , components: componentNodes , utilities: utilityNodes , variants: screenNodes  } = context.stylesheetCache;
         // ---
         // Replace any Tailwind directives with generated CSS
         if (layerNodes.base) {

package/lib/lib/generateRules.js

@@ -162,7 +162,7 @@ function applyImportant(matches, classCandidate) {
             ]
         });
         container.walkRules((r)=>{
-            r.selector = (0, _pluginUtils.updateAllClasses)(r.selector, (className)=>{
+            r.selector = (0, _pluginUtils.updateAllClasses)((0, _pluginUtils.filterSelectorsForClass)(r.selector, classCandidate), (className)=>{
                 if (className === classCandidate) {
                     return `!${className}`;
                 }
@@ -256,7 +256,7 @@ function applyVariant(variant, matches, context) {
                 ]
             });
             for (let [variantSort, variantFunction, containerFromArray] of variantFunctionTuples){
-                let clone = containerFromArray !== null && containerFromArray !== void 0 ? containerFromArray : container.clone();
+                let clone = (containerFromArray !== null && containerFromArray !== void 0 ? containerFromArray : container).clone();
                 let collectedFormats = [];
                 function prepareBackup() {
                     // Already prepared, chicken out

package/lib/lib/setupContextUtils.js

@@ -533,7 +533,7 @@ function parseVariant(variant) {
             variantFunctions = [].concat(variantFunctions).map((variantFunction)=>{
                 if (typeof variantFunction !== "string") {
                     // Safelist public API functions
-                    return (api)=>{
+                    return (api = {})=>{
                         let { args , modifySelectors , container , separator , wrap , format  } = api;
                         let result = variantFunction(Object.assign({
                             modifySelectors,
@@ -574,12 +574,14 @@ function parseVariant(variant) {
             var ref1;
             for (let [key, value] of Object.entries((ref1 = options === null || options === void 0 ? void 0 : options.values) !== null && ref1 !== void 0 ? ref1 : {})){
                 if (key === "DEFAULT") continue;
-                api.addVariant(isSpecial ? `${variant}${key}` : `${variant}-${key}`, ({ args , container  })=>variantFn(value, modifiersEnabled ? {
-                        modifier: args.modifier,
+                api.addVariant(isSpecial ? `${variant}${key}` : `${variant}-${key}`, ({ args , container  })=>{
+                    return variantFn(value, modifiersEnabled ? {
+                        modifier: args === null || args === void 0 ? void 0 : args.modifier,
                         container
                     } : {
                         container
-                    }), {
+                    });
+                }, {
                     ...options,
                     value,
                     id,
@@ -590,11 +592,13 @@ function parseVariant(variant) {
             var ref2;
             let hasDefault = "DEFAULT" in ((ref2 = options === null || options === void 0 ? void 0 : options.values) !== null && ref2 !== void 0 ? ref2 : {});
             api.addVariant(variant, ({ args , container  })=>{
-                if (args.value === _sharedState.NONE && !hasDefault) {
+                if ((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE && !hasDefault) {
                     return null;
                 }
-                return variantFn(args.value === _sharedState.NONE ? options.values.DEFAULT : args.value, modifiersEnabled ? {
-                    modifier: args.modifier,
+                var // (JetBrains) plugins.
+                ref;
+                return variantFn((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE ? options.values.DEFAULT : (ref = args === null || args === void 0 ? void 0 : args.value) !== null && ref !== void 0 ? ref : typeof args === "string" ? args : "", modifiersEnabled ? {
+                    modifier: args === null || args === void 0 ? void 0 : args.modifier,
                     container
                 } : {
                     container
@@ -795,6 +799,7 @@ function registerPlugins(plugins, context) {
         if (checks.length > 0) {
             let patternMatchingCount = new Map();
             let prefixLength = context.tailwindConfig.prefix.length;
+            let checkImportantUtils = checks.some((check)=>check.pattern.source.includes("!"));
             for (let util of classList){
                 let utils = Array.isArray(util) ? (()=>{
                     let [utilName, options] = util;
@@ -823,6 +828,12 @@ function registerPlugins(plugins, context) {
                             ...classes.flatMap((cls)=>Object.keys(context.tailwindConfig.theme.opacity).map((opacity)=>`${cls}/${opacity}`))
                         ];
                     }
+                    if (checkImportantUtils && (options === null || options === void 0 ? void 0 : options.respectImportant)) {
+                        classes = [
+                            ...classes,
+                            ...classes.map((cls)=>"!" + cls)
+                        ];
+                    }
                     return classes;
                 })() : [
                     util
@@ -1087,13 +1098,15 @@ function registerPlugins(plugins, context) {
     markInvalidUtilityCandidate(context, candidate);
 }
 function createContext(tailwindConfig, changedContent = [], root = _postcss.default.root()) {
+    var _blocklist;
     let context = {
         disposables: [],
         ruleCache: new Set(),
         candidateRuleCache: new Map(),
         classCache: new Map(),
         applyClassCache: new Map(),
-        notClassCache: new Set(),
+        // Seed the not class cache with the blocklist (which is only strings)
+        notClassCache: new Set((_blocklist = tailwindConfig.blocklist) !== null && _blocklist !== void 0 ? _blocklist : []),
         postCssNodeCache: new Map(),
         candidateRuleMap: new Map(),
         tailwindConfig,

package/lib/util/formatVariantSelector.js

@@ -78,9 +78,9 @@ function formatVariantSelector(current, ...others) {
             return -1;
         } else if (a.type === "class" && b.type === "tag") {
             return 1;
-        } else if (a.type === "class" && b.type === "pseudo" && b.value !== ":merge") {
+        } else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
             return -1;
-        } else if (a.type === "pseudo" && a.value !== ":merge" && b.type === "class") {
+        } else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
             return 1;
         }
         return sel.index(a) - sel.index(b);
@@ -114,7 +114,7 @@ function finalizeSelector(format, { selector , candidate , context , isArbitrary
 //           │  │     │            ╰── We will not split here
 //           ╰──┴─────┴─────────────── We will split here
 //
-base =candidate.split(new RegExp(`\\${(ref1 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref1 !== void 0 ? ref1 : ":"}(?![^[]*\\])`)).pop() ,  }) {
+base =candidate.split(new RegExp(`\\${(ref1 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref1 !== void 0 ? ref1 : ":"}(?![^[]*\\])`)).pop()  }) {
     var ref2;
     let ast = (0, _postcssSelectorParser.default)().astSync(selector);
     // We explicitly DO NOT prefix classes in arbitrary variants

package/lib/util/normalizeConfig.js

@@ -162,6 +162,20 @@ function normalizeConfig(config) {
         if (Array.isArray(purge === null || purge === void 0 ? void 0 : (ref = purge.options) === null || ref === void 0 ? void 0 : ref.safelist)) return purge.options.safelist;
         return [];
     })();
+    // Normalize the `blocklist`
+    config.blocklist = (()=>{
+        let { blocklist  } = config;
+        if (Array.isArray(blocklist)) {
+            if (blocklist.every((item)=>typeof item === "string")) {
+                return blocklist;
+            }
+            _log.default.warn("blocklist-invalid", [
+                "The `blocklist` option must be an array of strings.",
+                "https://tailwindcss.com/docs/content-configuration#discarding-classes"
+            ]);
+        }
+        return [];
+    })();
     // Normalize prefix option
     if (typeof config.prefix === "function") {
         _log.default.warn("prefix-function", [

package/lib/util/pluginUtils.js

@@ -10,6 +10,7 @@ function _export(target, all) {
 }
 _export(exports, {
     updateAllClasses: ()=>updateAllClasses,
+    filterSelectorsForClass: ()=>filterSelectorsForClass,
     asValue: ()=>asValue,
     parseColorFormat: ()=>parseColorFormat,
     asColor: ()=>asColor,
@@ -43,6 +44,18 @@ function updateAllClasses(selectors, updateClass) {
     let result = parser.processSync(selectors);
     return result;
 }
+function filterSelectorsForClass(selectors, classCandidate) {
+    let parser = (0, _postcssSelectorParser.default)((selectors)=>{
+        selectors.each((sel)=>{
+            const containsClass = sel.nodes.some((node)=>node.type === "class" && node.value === classCandidate);
+            if (!containsClass) {
+                sel.remove();
+            }
+        });
+    });
+    let result = parser.processSync(selectors);
+    return result;
+}
 function resolveArbitraryValue(modifier, validate) {
     if (!isArbitraryValue(modifier)) {
         return undefined;
@@ -110,15 +123,15 @@ function parseColorFormat(value) {
     }
     return value;
 }
-function asColor(_, options = {}, { tailwindConfig ={} , utilityModifier , rawModifier  } = {}) {
+function asColor(modifier, options = {}, { tailwindConfig ={}  } = {}) {
     var ref;
-    if (((ref = options.values) === null || ref === void 0 ? void 0 : ref[rawModifier]) !== undefined) {
+    if (((ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier]) !== undefined) {
         var ref1;
-        return parseColorFormat((ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[rawModifier]);
+        return parseColorFormat((ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[modifier]);
     }
     // TODO: Hoist this up to getMatchingTypes or something
     // We do this here because we need the alpha value (if any)
-    let [color, alpha] = splitUtilityModifier(rawModifier);
+    let [color, alpha] = splitUtilityModifier(modifier);
     if (alpha !== undefined) {
         var ref2, ref3, ref4;
         var ref5;
@@ -135,9 +148,7 @@ function asColor(_, options = {}, { tailwindConfig ={} , utilityModifier , rawMo
         }
         return (0, _withAlphaVariable.withAlphaValue)(normalizedColor, tailwindConfig.theme.opacity[alpha]);
     }
-    return asValue(rawModifier, options, {
-        rawModifier,
-        utilityModifier,
+    return asValue(modifier, options, {
         validate: _dataTypes.color
     });
 }
@@ -146,9 +157,8 @@ function asLookupValue(modifier, options = {}) {
     return (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
 }
 function guess(validate) {
-    return (modifier, options, extras)=>{
+    return (modifier, options)=>{
         return asValue(modifier, options, {
-            ...extras,
             validate
         });
     };
@@ -184,6 +194,21 @@ function splitAtFirst(input, delim) {
     ];
 }
 function coerceValue(types, modifier, options, tailwindConfig) {
+    if (options.values && modifier in options.values) {
+        for (let { type  } of types !== null && types !== void 0 ? types : []){
+            let result = typeMap[type](modifier, options, {
+                tailwindConfig
+            });
+            if (result === undefined) {
+                continue;
+            }
+            return [
+                result,
+                type,
+                null
+            ];
+        }
+    }
     if (isArbitraryValue(modifier)) {
         let arbitraryValue = modifier.slice(1, -1);
         let [explicitType, value] = splitAtFirst(arbitraryValue, ":");
@@ -234,30 +259,16 @@ function* getMatchingTypes(types, rawModifier, options, tailwindConfig) {
                 utilityModifier = utilityModifier.slice(1, -1);
             }
         }
-        let result = asValue(rawModifier, options, {
-            rawModifier,
-            utilityModifier,
-            tailwindConfig
-        });
-        if (result !== undefined) {
-            yield [
-                result,
-                "any",
-                null
-            ];
-        }
     }
-    for (const { type  } of types !== null && types !== void 0 ? types : []){
-        let result1 = typeMap[type](modifier, options, {
-            rawModifier,
-            utilityModifier,
+    for (let { type  } of types !== null && types !== void 0 ? types : []){
+        let result = typeMap[type](modifier, options, {
             tailwindConfig
         });
-        if (result1 === undefined) {
+        if (result === undefined) {
             continue;
         }
         yield [
-            result1,
+            result,
             type,
             utilityModifier !== null && utilityModifier !== void 0 ? utilityModifier : null
         ];

package/lib/util/resolveConfig.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "default", {
 const _negateValue = /*#__PURE__*/ _interopRequireDefault(require("./negateValue"));
 const _corePluginList = /*#__PURE__*/ _interopRequireDefault(require("../corePluginList"));
 const _configurePlugins = /*#__PURE__*/ _interopRequireDefault(require("./configurePlugins"));
-const _defaultConfigStub = /*#__PURE__*/ _interopRequireDefault(require("../../stubs/defaultConfig.stub"));
 const _colors = /*#__PURE__*/ _interopRequireDefault(require("../public/colors"));
 const _defaults = require("./defaults");
 const _toPath = require("./toPath");
@@ -27,16 +26,13 @@ function _interopRequireDefault(obj) {
 function isFunction(input) {
     return typeof input === "function";
 }
-function isObject(input) {
-    return typeof input === "object" && input !== null;
-}
 function mergeWith(target, ...sources) {
     let customizer = sources.pop();
     for (let source of sources){
         for(let k in source){
             let merged = customizer(target[k], source[k]);
             if (merged === undefined) {
-                if (isObject(target[k]) && isObject(source[k])) {
+                if ((0, _isPlainObject.default)(target[k]) && (0, _isPlainObject.default)(source[k])) {
                     target[k] = mergeWith({}, target[k], source[k], customizer);
                 } else {
                     target[k] = source[k];
@@ -101,11 +97,11 @@ function mergeThemes(themes) {
 }
 function mergeExtensionCustomizer(merged, value) {
     // When we have an array of objects, we do want to merge it
-    if (Array.isArray(merged) && isObject(merged[0])) {
+    if (Array.isArray(merged) && (0, _isPlainObject.default)(merged[0])) {
         return merged.concat(value);
     }
     // When the incoming value is an array, and the existing config is an object, prepend the existing object
-    if (Array.isArray(value) && isObject(value[0]) && isObject(merged)) {
+    if (Array.isArray(value) && (0, _isPlainObject.default)(value[0]) && (0, _isPlainObject.default)(merged)) {
         return [
             merged,
             ...value
@@ -242,8 +238,7 @@ function resolveConfig(configs) {
         {
             prefix: "",
             important: false,
-            separator: ":",
-            variantOrder: _defaultConfigStub.default.variantOrder
+            separator: ":"
         }
     ];
     var ref, ref1;