tailwindcss 0.0.0-insiders.7c337f2 → 0.0.0-insiders.7d8eb21

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 */
 }
 
 /*
@@ -358,3 +360,8 @@ video {
   max-width: 100%;
   height: auto;
 }
+
+/* Make elements with the HTML hidden attribute stay hidden by default */
+[hidden] {
+  display: none;
+}

package/lib/featureFlags.js

@@ -2,35 +2,50 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.flagEnabled = flagEnabled;
-exports.issueFlagNotices = issueFlagNotices;
-exports.default = void 0;
-var _picocolors = _interopRequireDefault(require("picocolors"));
-var _log = _interopRequireDefault(require("./util/log"));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    flagEnabled: ()=>flagEnabled,
+    issueFlagNotices: ()=>issueFlagNotices,
+    default: ()=>_default
+});
+const _picocolors = /*#__PURE__*/ _interopRequireDefault(require("picocolors"));
+const _log = /*#__PURE__*/ _interopRequireDefault(require("./util/log"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let defaults = {
-    optimizeUniversalDefaults: false
+    optimizeUniversalDefaults: false,
+    generalizedModifiers: true
 };
 let featureFlags = {
-    future: [],
+    future: [
+        "hoverOnlyWhenSupported",
+        "respectDefaultRingColorOpacity",
+        "disableColorOpacityUtilitiesByDefault",
+        "relativeContentPathsByDefault"
+    ],
     experimental: [
-        "optimizeUniversalDefaults"
+        "optimizeUniversalDefaults",
+        "generalizedModifiers"
     ]
 };
 function flagEnabled(config, flag) {
     if (featureFlags.future.includes(flag)) {
-        var ref;
-        var ref1, ref2;
-        return config.future === "all" || ((ref2 = (ref1 = config === null || config === void 0 ? void 0 : (ref = config.future) === null || ref === void 0 ? void 0 : ref[flag]) !== null && ref1 !== void 0 ? ref1 : defaults[flag]) !== null && ref2 !== void 0 ? ref2 : false);
+        var _config_future;
+        var _config_future_flag, _ref;
+        return config.future === "all" || ((_ref = (_config_future_flag = config === null || config === void 0 ? void 0 : (_config_future = config.future) === null || _config_future === void 0 ? void 0 : _config_future[flag]) !== null && _config_future_flag !== void 0 ? _config_future_flag : defaults[flag]) !== null && _ref !== void 0 ? _ref : false);
     }
     if (featureFlags.experimental.includes(flag)) {
-        var ref3;
-        var ref4, ref5;
-        return config.experimental === "all" || ((ref5 = (ref4 = config === null || config === void 0 ? void 0 : (ref3 = config.experimental) === null || ref3 === void 0 ? void 0 : ref3[flag]) !== null && ref4 !== void 0 ? ref4 : defaults[flag]) !== null && ref5 !== void 0 ? ref5 : false);
+        var _config_experimental;
+        var _config_experimental_flag, _ref1;
+        return config.experimental === "all" || ((_ref1 = (_config_experimental_flag = config === null || config === void 0 ? void 0 : (_config_experimental = config.experimental) === null || _config_experimental === void 0 ? void 0 : _config_experimental[flag]) !== null && _config_experimental_flag !== void 0 ? _config_experimental_flag : defaults[flag]) !== null && _ref1 !== void 0 ? _ref1 : false);
     }
     return false;
 }
@@ -38,22 +53,19 @@ function experimentalFlagsEnabled(config) {
     if (config.experimental === "all") {
         return featureFlags.experimental;
     }
-    var ref;
-    return Object.keys((ref = config === null || config === void 0 ? void 0 : config.experimental) !== null && ref !== void 0 ? ref : {}).filter((flag)=>featureFlags.experimental.includes(flag) && config.experimental[flag]
-    );
+    var _config_experimental;
+    return Object.keys((_config_experimental = config === null || config === void 0 ? void 0 : config.experimental) !== null && _config_experimental !== void 0 ? _config_experimental : {}).filter((flag)=>featureFlags.experimental.includes(flag) && config.experimental[flag]);
 }
 function issueFlagNotices(config) {
     if (process.env.JEST_WORKER_ID !== undefined) {
         return;
     }
     if (experimentalFlagsEnabled(config).length > 0) {
-        let changes = experimentalFlagsEnabled(config).map((s)=>_picocolors.default.yellow(s)
-        ).join(", ");
+        let changes = experimentalFlagsEnabled(config).map((s)=>_picocolors.default.yellow(s)).join(", ");
         _log.default.warn("experimental-flags-enabled", [
             `You have enabled experimental features: ${changes}`,
-            "Experimental features in Tailwind CSS are not covered by semver, may introduce breaking changes, and can change at any time.", 
+            "Experimental features in Tailwind CSS are not covered by semver, may introduce breaking changes, and can change at any time."
         ]);
     }
 }
-var _default = featureFlags;
-exports.default = _default;
+const _default = featureFlags;

package/lib/index.js

@@ -1,7 +1,11 @@
 "use strict";
-var _setupTrackingContext = _interopRequireDefault(require("./lib/setupTrackingContext"));
-var _processTailwindFeatures = _interopRequireDefault(require("./processTailwindFeatures"));
-var _sharedState = require("./lib/sharedState");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _setupTrackingContext = /*#__PURE__*/ _interopRequireDefault(require("./lib/setupTrackingContext"));
+const _processTailwindFeatures = /*#__PURE__*/ _interopRequireDefault(require("./processTailwindFeatures"));
+const _sharedState = require("./lib/sharedState");
+const _findAtConfigPath = require("./lib/findAtConfigPath");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -17,24 +21,27 @@ module.exports = function tailwindcss(configOrPath) {
                 return root;
             },
             function(root, result) {
-                let context = (0, _setupTrackingContext).default(configOrPath);
+                var _findAtConfigPath1;
+                // Use the path for the `@config` directive if it exists, otherwise use the
+                // path for the file being processed
+                configOrPath = (_findAtConfigPath1 = (0, _findAtConfigPath.findAtConfigPath)(root, result)) !== null && _findAtConfigPath1 !== void 0 ? _findAtConfigPath1 : configOrPath;
+                let context = (0, _setupTrackingContext.default)(configOrPath);
                 if (root.type === "document") {
-                    let roots = root.nodes.filter((node)=>node.type === "root"
-                    );
+                    let roots = root.nodes.filter((node)=>node.type === "root");
                     for (const root1 of roots){
                         if (root1.type === "root") {
-                            (0, _processTailwindFeatures).default(context)(root1, result);
+                            (0, _processTailwindFeatures.default)(context)(root1, result);
                         }
                     }
                     return;
                 }
-                (0, _processTailwindFeatures).default(context)(root, result);
+                (0, _processTailwindFeatures.default)(context)(root, result);
             },
             _sharedState.env.DEBUG && function(root) {
                 console.timeEnd("JIT TOTAL");
                 console.log("\n");
                 return root;
-            }, 
+            }
         ].filter(Boolean)
     };
 };

package/lib/lib/cacheInvalidation.js

@@ -2,34 +2,55 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.hasContentChanged = hasContentChanged;
-var _crypto = _interopRequireDefault(require("crypto"));
-var sharedState = _interopRequireWildcard(require("./sharedState"));
+Object.defineProperty(exports, "hasContentChanged", {
+    enumerable: true,
+    get: ()=>hasContentChanged
+});
+const _crypto = /*#__PURE__*/ _interopRequireDefault(require("crypto"));
+const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
         return obj;
-    } else {
-        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) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
             }
         }
-        newObj.default = obj;
-        return newObj;
     }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
 }
 /**
  * Calculate the hash of a string.
@@ -61,9 +82,9 @@ function hasContentChanged(sourcePath, root) {
     if (!css.includes("@tailwind")) {
         return false;
     }
-    let existingHash = sharedState.sourceHashMap.get(sourcePath);
+    let existingHash = _sharedState.sourceHashMap.get(sourcePath);
     let rootHash = getHash(css);
     let didChange = existingHash !== rootHash;
-    sharedState.sourceHashMap.set(sourcePath, rootHash);
+    _sharedState.sourceHashMap.set(sourcePath, rootHash);
     return didChange;
 }

package/lib/lib/collapseAdjacentRules.js

@@ -2,7 +2,20 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = collapseAdjacentRules;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>collapseAdjacentRules
+});
+let comparisonMap = {
+    atrule: [
+        "name",
+        "params"
+    ],
+    rule: [
+        "selector"
+    ]
+};
+let types = new Set(Object.keys(comparisonMap));
 function collapseAdjacentRules() {
     function collapseRulesIn(root) {
         let currentRule = null;
@@ -16,11 +29,10 @@ function collapseAdjacentRules() {
                 return;
             }
             let properties = comparisonMap[node.type];
-            var _property, _property1;
+            var _node_property, _currentRule_property;
             if (node.type === "atrule" && node.name === "font-face") {
                 currentRule = node;
-            } else if (properties.every((property)=>((_property = node[property]) !== null && _property !== void 0 ? _property : "").replace(/\s+/g, " ") === ((_property1 = currentRule[property]) !== null && _property1 !== void 0 ? _property1 : "").replace(/\s+/g, " ")
-            )) {
+            } else if (properties.every((property)=>((_node_property = node[property]) !== null && _node_property !== void 0 ? _node_property : "").replace(/\s+/g, " ") === ((_currentRule_property = currentRule[property]) !== null && _currentRule_property !== void 0 ? _currentRule_property : "").replace(/\s+/g, " "))) {
                 // An AtRule may not have children (for example if we encounter duplicate @import url(…) rules)
                 if (node.nodes) {
                     currentRule.append(node.nodes);
@@ -45,13 +57,3 @@ function collapseAdjacentRules() {
         collapseRulesIn(root);
     };
 }
-let comparisonMap = {
-    atrule: [
-        "name",
-        "params"
-    ],
-    rule: [
-        "selector"
-    ]
-};
-let types = new Set(Object.keys(comparisonMap));

package/lib/lib/collapseDuplicateDeclarations.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = collapseDuplicateDeclarations;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>collapseDuplicateDeclarations
+});
 function collapseDuplicateDeclarations() {
     return (root)=>{
         root.walkRules((node)=>{
@@ -41,28 +44,28 @@ function collapseDuplicateDeclarations() {
             });
             // Drop all the duplicate declarations with the exact same value we've
             // already seen so far.
-            for (let decl1 of droppable){
-                decl1.remove();
+            for (let decl of droppable){
+                decl.remove();
             }
             // Analyze the declarations based on its unit, drop all the declarations
             // with the same unit but the last one in the list.
             for (let declarations of byProperty.values()){
                 let byUnit = new Map();
-                for (let decl of declarations){
-                    let unit = resolveUnit(decl.value);
+                for (let decl1 of declarations){
+                    let unit = resolveUnit(decl1.value);
                     if (unit === null) {
                         continue;
                     }
                     if (!byUnit.has(unit)) {
                         byUnit.set(unit, new Set());
                     }
-                    byUnit.get(unit).add(decl);
+                    byUnit.get(unit).add(decl1);
                 }
                 for (let declarations1 of byUnit.values()){
                     // Get all but the last one
                     let removableDeclarations = Array.from(declarations1).slice(0, -1);
-                    for (let decl of removableDeclarations){
-                        decl.remove();
+                    for (let decl2 of removableDeclarations){
+                        decl2.remove();
                     }
                 }
             }
@@ -73,8 +76,8 @@ let UNITLESS_NUMBER = Symbol("unitless-number");
 function resolveUnit(input) {
     let result = /^-?\d*.?\d+([\w%]+)?$/g.exec(input);
     if (result) {
-        var ref;
-        return (ref = result[1]) !== null && ref !== void 0 ? ref : UNITLESS_NUMBER;
+        var _result_;
+        return (_result_ = result[1]) !== null && _result_ !== void 0 ? _result_ : UNITLESS_NUMBER;
     }
     return null;
 }

package/lib/lib/content.js

@@ -0,0 +1,177 @@
+// @ts-check
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    parseCandidateFiles: ()=>parseCandidateFiles,
+    resolvedChangedContent: ()=>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 _parseGlob = require("../util/parseGlob");
+const _sharedState = require("./sharedState");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);
+    // Split into included and excluded globs
+    let tasks = _fastGlob.default.generateTasks(files);
+    /** @type {ContentPath[]} */ let included = [];
+    /** @type {ContentPath[]} */ let excluded = [];
+    for (const task of tasks){
+        included.push(...task.positive.map((filePath)=>parseFilePath(filePath, false)));
+        excluded.push(...task.negative.map((filePath)=>parseFilePath(filePath, true)));
+    }
+    let paths = [
+        ...included,
+        ...excluded
+    ];
+    // Resolve paths relative to the config file or cwd
+    paths = resolveRelativePaths(context, paths);
+    // Resolve symlinks if possible
+    paths = paths.flatMap(resolvePathSymlinks);
+    // Update cached patterns
+    paths = paths.map(resolveGlobPattern);
+    return paths;
+}
+/**
+ *
+ * @param {string} filePath
+ * @param {boolean} ignore
+ * @returns {ContentPath}
+ */ function parseFilePath(filePath, ignore) {
+    let contentPath = {
+        original: filePath,
+        base: filePath,
+        ignore,
+        pattern: filePath,
+        glob: null
+    };
+    if ((0, _isGlob.default)(filePath)) {
+        Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath));
+    }
+    return contentPath;
+}
+/**
+ *
+ * @param {ContentPath} contentPath
+ * @returns {ContentPath}
+ */ function resolveGlobPattern(contentPath) {
+    // This is required for Windows support to properly pick up Glob paths.
+    // 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);
+    // 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);
+    contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base;
+    contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern;
+    return contentPath;
+}
+/**
+ * Resolve each path relative to the config file (when possible) if the experimental flag is enabled
+ * Otherwise, resolve relative to the current working directory
+ *
+ * @param {any} context
+ * @param {ContentPath[]} contentPaths
+ * @returns {ContentPath[]}
+ */ function resolveRelativePaths(context, contentPaths) {
+    let resolveFrom = [];
+    // Resolve base paths relative to the config file (when possible) if the experimental flag is enabled
+    if (context.userConfigPath && context.tailwindConfig.content.relative) {
+        resolveFrom = [
+            _path.default.dirname(context.userConfigPath)
+        ];
+    }
+    return contentPaths.map((contentPath)=>{
+        contentPath.base = _path.default.resolve(...resolveFrom, contentPath.base);
+        return contentPath;
+    });
+}
+/**
+ * Resolve the symlink for the base directory / file in each path
+ * These are added as additional dependencies to watch for changes because
+ * some tools (like webpack) will only watch the actual file or directory
+ * but not the symlink itself even in projects that use monorepos.
+ *
+ * @param {ContentPath} contentPath
+ * @returns {ContentPath[]}
+ */ function resolvePathSymlinks(contentPath) {
+    let paths = [
+        contentPath
+    ];
+    try {
+        let resolvedPath = _fs.default.realpathSync(contentPath.base);
+        if (resolvedPath !== contentPath.base) {
+            paths.push({
+                ...contentPath,
+                base: resolvedPath
+            });
+        }
+    } catch  {
+    // TODO: log this?
+    }
+    return paths;
+}
+function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
+    let changedContent = context.tailwindConfig.content.files.filter((item)=>typeof item.raw === "string").map(({ raw , extension ="html"  })=>({
+            content: raw,
+            extension
+        }));
+    for (let changedFile of resolveChangedFiles(candidateFiles, fileModifiedMap)){
+        let content = _fs.default.readFileSync(changedFile, "utf8");
+        let extension = _path.default.extname(changedFile).slice(1);
+        changedContent.push({
+            content,
+            extension
+        });
+    }
+    return changedContent;
+}
+/**
+ *
+ * @param {ContentPath[]} candidateFiles
+ * @param {Map<string, number>} fileModifiedMap
+ * @returns {Set<string>}
+ */ function resolveChangedFiles(candidateFiles, fileModifiedMap) {
+    let paths = candidateFiles.map((contentPath)=>contentPath.pattern);
+    let changedFiles = new Set();
+    _sharedState.env.DEBUG && console.time("Finding changed files");
+    let files = _fastGlob.default.sync(paths, {
+        absolute: true
+    });
+    for (let file of files){
+        let prevModified = fileModifiedMap.has(file) ? fileModifiedMap.get(file) : -Infinity;
+        let modified = _fs.default.statSync(file).mtimeMs;
+        // 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);
+        }
+    }
+    _sharedState.env.DEBUG && console.timeEnd("Finding changed files");
+    return changedFiles;
+}