tailwindcss 0.0.0-insiders.fda68f7 → 0.0.0-oxide.6bf5e56

package/lib/css/preflight.css

@@ -9,7 +9,12 @@
   box-sizing: border-box; /* 1 */
   border-width: 0; /* 2 */
   border-style: solid; /* 2 */
-  border-color: currentColor; /* 2 */
+  border-color: theme('borderColor.DEFAULT', currentColor); /* 2 */
+}
+
+::before,
+::after {
+  --tw-content: '';
 }
 
 /*
@@ -17,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 {
@@ -25,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 */
 }
 
 /*
@@ -53,7 +60,7 @@ hr {
 Add the correct text decoration in Chrome, Edge, and Safari.
 */
 
-abbr[title] {
+abbr:where([title]) {
   text-decoration: underline dotted;
 }
 
@@ -139,7 +146,7 @@ sup {
 table {
   text-indent: 0; /* 1 */
   border-color: inherit; /* 2 */
-  border-collapse: collapse;  /* 3 */
+  border-collapse: collapse; /* 3 */
 }
 
 /*
@@ -155,6 +162,7 @@ select,
 textarea {
   font-family: inherit; /* 1 */
   font-size: 100%; /* 1 */
+  font-weight: inherit; /* 1 */
   line-height: inherit; /* 1 */
   color: inherit; /* 1 */
   margin: 0; /* 2 */
@@ -283,7 +291,8 @@ legend {
 }
 
 ol,
-ul {
+ul,
+menu {
   list-style: none;
   margin: 0;
   padding: 0;
@@ -304,7 +313,7 @@ textarea {
 
 input::placeholder,
 textarea::placeholder {
-  opacity: 1;  /* 1 */
+  opacity: 1; /* 1 */
   color: theme('colors.gray.400', #9ca3af); /* 2 */
 }
 
@@ -317,6 +326,13 @@ button,
   cursor: pointer;
 }
 
+/*
+Make sure disabled buttons don't get the pointer cursor.
+*/
+:disabled {
+  cursor: default;
+}
+
 /*
 1. Make replaced elements `display: block` by default. (https://github.com/mozdevs/cssremedy/issues/14)
 2. Add `vertical-align: middle` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210)
@@ -345,10 +361,7 @@ video {
   height: auto;
 }
 
-/*
-Ensure the default browser behavior of the `hidden` attribute.
-*/
-
+/* Make elements with the HTML hidden attribute stay hidden by default */
 [hidden] {
   display: none;
 }

package/lib/featureFlags.js

@@ -1,60 +1,71 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.flagEnabled = flagEnabled;
-exports.issueFlagNotices = issueFlagNotices;
-exports.default = void 0;
-
-var _chalk = _interopRequireDefault(require("chalk"));
-
-var _log = _interopRequireDefault(require("./util/log"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const featureFlags = {
-  future: [],
-  experimental: ['optimizeUniversalDefaults']
+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,
+    generalizedModifiers: true
+};
+let featureFlags = {
+    future: [
+        "hoverOnlyWhenSupported",
+        "respectDefaultRingColorOpacity",
+        "disableColorOpacityUtilitiesByDefault",
+        "relativeContentPathsByDefault"
+    ],
+    experimental: [
+        "optimizeUniversalDefaults",
+        "generalizedModifiers"
+    ]
 };
-
 function flagEnabled(config, flag) {
-  if (featureFlags.future.includes(flag)) {
-    var _config$future$flag, _config$future;
-
-    return config.future === 'all' || ((_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 : false);
-  }
-
-  if (featureFlags.experimental.includes(flag)) {
-    var _config$experimental$, _config$experimental;
-
-    return config.experimental === 'all' || ((_config$experimental$ = config === null || config === void 0 ? void 0 : (_config$experimental = config.experimental) === null || _config$experimental === void 0 ? void 0 : _config$experimental[flag]) !== null && _config$experimental$ !== void 0 ? _config$experimental$ : false);
-  }
-
-  return false;
+    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);
+    }
+    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);
+    }
+    return false;
 }
-
 function experimentalFlagsEnabled(config) {
-  var _config$experimental2;
-
-  if (config.experimental === 'all') {
-    return featureFlags.experimental;
-  }
-
-  return Object.keys((_config$experimental2 = config === null || config === void 0 ? void 0 : config.experimental) !== null && _config$experimental2 !== void 0 ? _config$experimental2 : {}).filter(flag => featureFlags.experimental.includes(flag) && config.experimental[flag]);
+    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]);
 }
-
 function issueFlagNotices(config) {
-  if (process.env.JEST_WORKER_ID !== undefined) {
-    return;
-  }
-
-  if (experimentalFlagsEnabled(config).length > 0) {
-    const changes = experimentalFlagsEnabled(config).map(s => _chalk.default.yellow(s)).join(', ');
-
-    _log.default.warn([`You have enabled experimental features: ${changes}`, 'Experimental features are not covered by semver, may introduce breaking changes, and can change at any time.']);
-  }
+    if (process.env.JEST_WORKER_ID !== undefined) {
+        return;
+    }
+    if (experimentalFlagsEnabled(config).length > 0) {
+        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."
+        ]);
+    }
 }
-
-var _default = featureFlags;
-exports.default = _default;
+const _default = featureFlags;

package/lib/index.js

@@ -1,31 +1,48 @@
 "use strict";
-
-var _setupTrackingContext = _interopRequireDefault(require("./lib/setupTrackingContext"));
-
-var _setupWatchingContext = _interopRequireDefault(require("./lib/setupWatchingContext"));
-
-var _processTailwindFeatures = _interopRequireDefault(require("./processTailwindFeatures"));
-
-var _sharedState = require("./lib/sharedState");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+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
+    };
+}
 module.exports = function tailwindcss(configOrPath) {
-  return {
-    postcssPlugin: 'tailwindcss',
-    plugins: [_sharedState.env.DEBUG && function (root) {
-      console.log('\n');
-      console.time('JIT TOTAL');
-      return root;
-    }, function (root, result) {
-      let setupContext = _sharedState.env.TAILWIND_MODE === 'watch' ? (0, _setupWatchingContext.default)(configOrPath) : (0, _setupTrackingContext.default)(configOrPath);
-      (0, _processTailwindFeatures.default)(setupContext)(root, result);
-    }, _sharedState.env.DEBUG && function (root) {
-      console.timeEnd('JIT TOTAL');
-      console.log('\n');
-      return root;
-    }].filter(Boolean)
-  };
+    return {
+        postcssPlugin: "tailwindcss",
+        plugins: [
+            _sharedState.env.DEBUG && function(root) {
+                console.log("\n");
+                console.time("JIT TOTAL");
+                return root;
+            },
+            function(root, result) {
+                var ref;
+                // Use the path for the `@config` directive if it exists, otherwise use the
+                // path for the file being processed
+                configOrPath = (ref = (0, _findAtConfigPath.findAtConfigPath)(root, result)) !== null && ref !== void 0 ? ref : configOrPath;
+                let context = (0, _setupTrackingContext.default)(configOrPath);
+                if (root.type === "document") {
+                    let roots = root.nodes.filter((node)=>node.type === "root");
+                    for (const root1 of roots){
+                        if (root1.type === "root") {
+                            (0, _processTailwindFeatures.default)(context)(root1, result);
+                        }
+                    }
+                    return;
+                }
+                (0, _processTailwindFeatures.default)(context)(root, result);
+            },
+            _sharedState.env.DEBUG && function(root) {
+                console.timeEnd("JIT TOTAL");
+                console.log("\n");
+                return root;
+            }
+        ].filter(Boolean)
+    };
 };
-
-module.exports.postcss = true;
+module.exports.postcss = true;

package/lib/lib/cacheInvalidation.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+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 _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;
+    }
+    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;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/**
+ * Calculate the hash of a string.
+ *
+ * This doesn't need to be cryptographically secure or
+ * anything like that since it's used only to detect
+ * when the CSS changes to invalidate the context.
+ *
+ * This is wrapped in a try/catch because it's really dependent
+ * on how Node itself is build and the environment and OpenSSL
+ * version / build that is installed on the user's machine.
+ *
+ * Based on the environment this can just outright fail.
+ *
+ * See https://github.com/nodejs/node/issues/40455
+ *
+ * @param {string} str
+ */ function getHash(str) {
+    try {
+        return _crypto.default.createHash("md5").update(str, "utf-8").digest("binary");
+    } catch (err) {
+        return "";
+    }
+}
+function hasContentChanged(sourcePath, root) {
+    let css = root.toString();
+    // We only care about files with @tailwind directives
+    // Other files use an existing context
+    if (!css.includes("@tailwind")) {
+        return false;
+    }
+    let existingHash = _sharedState.sourceHashMap.get(sourcePath);
+    let rootHash = getHash(css);
+    let didChange = existingHash !== rootHash;
+    _sharedState.sourceHashMap.set(sourcePath, rootHash);
+    return didChange;
+}

package/lib/lib/collapseAdjacentRules.js

@@ -1,43 +1,59 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>collapseAdjacentRules
 });
-exports.default = collapseAdjacentRules;
 let comparisonMap = {
-  atrule: ['name', 'params'],
-  rule: ['selector']
+    atrule: [
+        "name",
+        "params"
+    ],
+    rule: [
+        "selector"
+    ]
 };
 let types = new Set(Object.keys(comparisonMap));
-
 function collapseAdjacentRules() {
-  return root => {
-    let currentRule = null;
-    root.each(node => {
-      if (!types.has(node.type)) {
-        currentRule = null;
-        return;
-      }
-
-      if (currentRule === null) {
-        currentRule = node;
-        return;
-      }
-
-      let properties = comparisonMap[node.type];
-
-      if (node.type === 'atrule' && node.name === 'font-face') {
-        currentRule = node;
-      } else if (properties.every(property => {
-        var _node$property, _currentRule$property;
-
-        return ((_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, ' ');
-      })) {
-        currentRule.append(node.nodes);
-        node.remove();
-      } else {
-        currentRule = node;
-      }
-    });
-  };
-}
+    function collapseRulesIn(root) {
+        let currentRule = null;
+        root.each((node)=>{
+            if (!types.has(node.type)) {
+                currentRule = null;
+                return;
+            }
+            if (currentRule === null) {
+                currentRule = node;
+                return;
+            }
+            let properties = comparisonMap[node.type];
+            var _property, _property1;
+            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, " "))) {
+                // An AtRule may not have children (for example if we encounter duplicate @import url(…) rules)
+                if (node.nodes) {
+                    currentRule.append(node.nodes);
+                }
+                node.remove();
+            } else {
+                currentRule = node;
+            }
+        });
+        // After we've collapsed adjacent rules & at-rules, we need to collapse
+        // adjacent rules & at-rules that are children of at-rules.
+        // We do not care about nesting rules because Tailwind CSS
+        // explicitly does not handle rule nesting on its own as
+        // the user is expected to use a nesting plugin
+        root.each((node)=>{
+            if (node.type === "atrule") {
+                collapseRulesIn(node);
+            }
+        });
+    }
+    return (root)=>{
+        collapseRulesIn(root);
+    };
+}

package/lib/lib/collapseDuplicateDeclarations.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>collapseDuplicateDeclarations
+});
+function collapseDuplicateDeclarations() {
+    return (root)=>{
+        root.walkRules((node)=>{
+            let seen = new Map();
+            let droppable = new Set([]);
+            let byProperty = new Map();
+            node.walkDecls((decl)=>{
+                // This could happen if we have nested selectors. In that case the
+                // parent will loop over all its declarations but also the declarations
+                // of nested rules. With this we ensure that we are shallowly checking
+                // declarations.
+                if (decl.parent !== node) {
+                    return;
+                }
+                if (seen.has(decl.prop)) {
+                    // Exact same value as what we have seen so far
+                    if (seen.get(decl.prop).value === decl.value) {
+                        // Keep the last one, drop the one we've seen so far
+                        droppable.add(seen.get(decl.prop));
+                        // Override the existing one with the new value. This is necessary
+                        // so that if we happen to have more than one declaration with the
+                        // same value, that we keep removing the previous one. Otherwise we
+                        // will only remove the *first* one.
+                        seen.set(decl.prop, decl);
+                        return;
+                    }
+                    // Not the same value, so we need to check if we can merge it so
+                    // let's collect it first.
+                    if (!byProperty.has(decl.prop)) {
+                        byProperty.set(decl.prop, new Set());
+                    }
+                    byProperty.get(decl.prop).add(seen.get(decl.prop));
+                    byProperty.get(decl.prop).add(decl);
+                }
+                seen.set(decl.prop, decl);
+            });
+            // Drop all the duplicate declarations with the exact same value we've
+            // already seen so far.
+            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 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(decl1);
+                }
+                for (let declarations1 of byUnit.values()){
+                    // Get all but the last one
+                    let removableDeclarations = Array.from(declarations1).slice(0, -1);
+                    for (let decl2 of removableDeclarations){
+                        decl2.remove();
+                    }
+                }
+            }
+        });
+    };
+}
+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;
+    }
+    return null;
+}