tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.7f555c4

package/lib/featureFlags.js

@@ -1,32 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    flagEnabled: ()=>flagEnabled,
-    issueFlagNotices: ()=>issueFlagNotices,
-    default: ()=>_default
+}
+_export(exports, {
+    flagEnabled: function() {
+        return flagEnabled;
+    },
+    issueFlagNotices: function() {
+        return issueFlagNotices;
+    },
+    default: function() {
+        return _default;
+    }
 });
-const _picocolors = _interopRequireDefault(require("picocolors")), _log = _interopRequireDefault(require("./util/log"));
-function _interopRequireDefault(obj) {
+const _picocolors = /*#__PURE__*/ _interop_require_default(require("picocolors"));
+const _log = /*#__PURE__*/ _interop_require_default(require("./util/log"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let defaults = {
-    optimizeUniversalDefaults: !1,
-    generalizedModifiers: !0,
+    optimizeUniversalDefaults: false,
+    generalizedModifiers: true,
     get disableColorOpacityUtilitiesByDefault () {
-        return !0;
+        return true;
     },
     get relativeContentPathsByDefault () {
-        return !0;
+        return true;
     }
-}, featureFlags = {
+};
+let featureFlags = {
     future: [
         "hoverOnlyWhenSupported",
         "respectDefaultRingColorOpacity",
@@ -39,15 +49,30 @@ let defaults = {
     ]
 };
 function flagEnabled(config, flag) {
-    var _config_future, _config_future_flag, _ref, _config_experimental, _config_experimental_flag, _ref1;
-    return featureFlags.future.includes(flag) ? "all" === config.future || null !== (_ref = null !== (_config_future_flag = null == config ? void 0 : null === (_config_future = config.future) || void 0 === _config_future ? void 0 : _config_future[flag]) && void 0 !== _config_future_flag ? _config_future_flag : defaults[flag]) && void 0 !== _ref && _ref : !!featureFlags.experimental.includes(flag) && ("all" === config.experimental || null !== (_ref1 = null !== (_config_experimental_flag = null == config ? void 0 : null === (_config_experimental = config.experimental) || void 0 === _config_experimental ? void 0 : _config_experimental[flag]) && void 0 !== _config_experimental_flag ? _config_experimental_flag : defaults[flag]) && void 0 !== _ref1 && _ref1);
+    if (featureFlags.future.includes(flag)) {
+        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 _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;
 }
 function experimentalFlagsEnabled(config) {
+    if (config.experimental === "all") {
+        return featureFlags.experimental;
+    }
     var _config_experimental;
-    return "all" === config.experimental ? featureFlags.experimental : Object.keys(null !== (_config_experimental = null == config ? void 0 : config.experimental) && void 0 !== _config_experimental ? _config_experimental : {}).filter((flag)=>featureFlags.experimental.includes(flag) && config.experimental[flag]);
+    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 (void 0 === process.env.JEST_WORKER_ID && experimentalFlagsEnabled(config).length > 0) {
+    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}`,

package/lib/lib/cacheInvalidation.js

@@ -1,44 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "hasContentChanged", {
-    enumerable: !0,
-    get: ()=>hasContentChanged
+    value: true
 });
-const _crypto = function(obj) {
+Object.defineProperty(exports, "hasContentChanged", {
+    enumerable: true,
+    get: function() {
+        return hasContentChanged;
+    }
+});
+const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
+const _sharedState = /*#__PURE__*/ _interop_require_wildcard(require("./sharedState"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("crypto")), _sharedState = function(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) return obj;
-    if (null === obj || "object" != typeof obj && "function" != typeof obj) return {
-        default: obj
-    };
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) return cache.get(obj);
-    var newObj = {}, hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj)if ("default" !== key && Object.prototype.hasOwnProperty.call(obj, key)) {
-        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-        desc && (desc.get || desc.set) ? Object.defineProperty(newObj, key, desc) : newObj[key] = obj[key];
-    }
-    return newObj.default = obj, cache && cache.set(obj, newObj), newObj;
-}(require("./sharedState"));
+}
 function _getRequireWildcardCache(nodeInterop) {
-    if ("function" != typeof WeakMap) return null;
-    var cacheBabelInterop = new WeakMap(), cacheNodeInterop = new WeakMap();
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
     return (_getRequireWildcardCache = function(nodeInterop) {
         return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
     })(nodeInterop);
 }
+function _interop_require_wildcard(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();
-    if (!css.includes("@tailwind")) return !1;
-    let existingHash = _sharedState.sourceHashMap.get(sourcePath), rootHash = function(str) {
-        try {
-            return _crypto.default.createHash("md5").update(str, "utf-8").digest("binary");
-        } catch (err) {
-            return "";
-        }
-    }(css);
-    return _sharedState.sourceHashMap.set(sourcePath, rootHash), existingHash !== rootHash;
+    // 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,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>collapseAdjacentRules
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return collapseAdjacentRules;
+    }
 });
 let comparisonMap = {
     atrule: [
@@ -13,26 +16,46 @@ let comparisonMap = {
     rule: [
         "selector"
     ]
-}, types = new Set(Object.keys(comparisonMap));
+};
+let types = new Set(Object.keys(comparisonMap));
 function collapseAdjacentRules() {
-    return (root)=>{
-        !function collapseRulesIn(root) {
-            let currentRule = null;
-            root.each((node)=>{
-                var _node_property, _currentRule_property;
-                if (!types.has(node.type)) {
-                    currentRule = null;
-                    return;
+    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 _node_property, _currentRule_property;
+            if (node.type === "atrule" && node.name === "font-face") {
+                currentRule = node;
+            } 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);
                 }
-                if (null === currentRule) {
-                    currentRule = node;
-                    return;
-                }
-                let properties = comparisonMap[node.type];
-                "atrule" === node.type && "font-face" === node.name ? currentRule = node : properties.every((property)=>(null !== (_node_property = node[property]) && void 0 !== _node_property ? _node_property : "").replace(/\s+/g, " ") === (null !== (_currentRule_property = currentRule[property]) && void 0 !== _currentRule_property ? _currentRule_property : "").replace(/\s+/g, " ")) ? (node.nodes && currentRule.append(node.nodes), node.remove()) : currentRule = node;
-            }), root.each((node)=>{
-                "atrule" === node.type && collapseRulesIn(node);
-            });
-        }(root);
+                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

@@ -1,42 +1,85 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return collapseDuplicateDeclarations;
+    }
+});
 function collapseDuplicateDeclarations() {
     return (root)=>{
         root.walkRules((node)=>{
-            let seen = new Map(), droppable = new Set([]), byProperty = new Map();
-            for (let decl of (node.walkDecls((decl)=>{
-                if (decl.parent === node) {
-                    if (seen.has(decl.prop)) {
-                        if (seen.get(decl.prop).value === decl.value) {
-                            droppable.add(seen.get(decl.prop)), seen.set(decl.prop, decl);
-                            return;
-                        }
-                        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);
+            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;
                     }
-                    seen.set(decl.prop, decl);
+                    // 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);
                 }
-            }), droppable))decl.remove();
+                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 decl of declarations){
-                    let unit = function(input) {
-                        let result = /^-?\d*.?\d+([\w%]+)?$/g.exec(input);
-                        if (result) {
-                            var _result_;
-                            return null !== (_result_ = result[1]) && void 0 !== _result_ ? _result_ : UNITLESS_NUMBER;
-                        }
-                        return null;
-                    }(decl.value);
-                    null !== unit && (byUnit.has(unit) || byUnit.set(unit, new Set()), byUnit.get(unit).add(decl));
+                    let unit = resolveUnit(decl.value);
+                    if (unit === null) {
+                        continue;
+                    }
+                    if (!byUnit.has(unit)) {
+                        byUnit.set(unit, new Set());
+                    }
+                    byUnit.get(unit).add(decl);
+                }
+                for (let declarations of byUnit.values()){
+                    // Get all but the last one
+                    let removableDeclarations = Array.from(declarations).slice(0, -1);
+                    for (let decl of removableDeclarations){
+                        decl.remove();
+                    }
                 }
-                for (let declarations of byUnit.values())for (let decl of Array.from(declarations).slice(0, -1))decl.remove();
             }
         });
     };
 }
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>collapseDuplicateDeclarations
-});
 let UNITLESS_NUMBER = Symbol("unitless-number");
+function resolveUnit(input) {
+    let result = /^-?\d*.?\d+([\w%]+)?$/g.exec(input);
+    if (result) {
+        var _result_;
+        return (_result_ = result[1]) !== null && _result_ !== void 0 ? _result_ : UNITLESS_NUMBER;
+    }
+    return null;
+}

package/lib/lib/content.js

@@ -1,36 +1,65 @@
+// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    parseCandidateFiles: ()=>parseCandidateFiles,
-    resolvedChangedContent: ()=>resolvedChangedContent
+}
+_export(exports, {
+    parseCandidateFiles: function() {
+        return parseCandidateFiles;
+    },
+    resolvedChangedContent: function() {
+        return resolvedChangedContent;
+    }
 });
-const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path")), _isGlob = _interopRequireDefault(require("is-glob")), _fastGlob = _interopRequireDefault(require("fast-glob")), _normalizePath = _interopRequireDefault(require("normalize-path")), _parseGlob = require("../util/parseGlob"), _sharedState = require("./sharedState");
-function _interopRequireDefault(obj) {
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _isglob = /*#__PURE__*/ _interop_require_default(require("is-glob"));
+const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
+const _normalizepath = /*#__PURE__*/ _interop_require_default(require("normalize-path"));
+const _parseGlob = require("../util/parseGlob");
+const _sharedState = require("./sharedState");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function parseCandidateFiles(context, tailwindConfig) {
-    var contentPaths;
-    let resolveFrom, files = tailwindConfig.content.files;
-    files = (files = files.filter((filePath)=>"string" == typeof filePath)).map(_normalizePath.default);
-    let tasks = _fastGlob.default.generateTasks(files), included = [], excluded = [];
-    for (let task of tasks)included.push(...task.positive.map((filePath)=>parseFilePath(filePath, !1))), excluded.push(...task.negative.map((filePath)=>parseFilePath(filePath, !0)));
+    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
     ];
-    return (paths = (contentPaths = paths, resolveFrom = [], context.userConfigPath && context.tailwindConfig.content.relative && (resolveFrom = [
-        _path.default.dirname(context.userConfigPath)
-    ]), paths = contentPaths.map((contentPath)=>(contentPath.base = _path.default.resolve(...resolveFrom, contentPath.base), contentPath))).flatMap(resolvePathSymlinks)).map(resolveGlobPattern);
+    // 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;
 }
-function parseFilePath(filePath, ignore) {
+/**
+ *
+ * @param {string} filePath
+ * @param {boolean} ignore
+ * @returns {ContentPath}
+ */ function parseFilePath(filePath, ignore) {
     let contentPath = {
         original: filePath,
         base: filePath,
@@ -38,42 +67,79 @@ function parseFilePath(filePath, ignore) {
         pattern: filePath,
         glob: null
     };
-    return (0, _isGlob.default)(filePath) && Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath)), contentPath;
+    if ((0, _isglob.default)(filePath)) {
+        Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath));
+    }
+    return contentPath;
 }
-function resolveGlobPattern(contentPath) {
-    let base = (0, _normalizePath.default)(contentPath.base);
-    return base = _fastGlob.default.escapePath(base), contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base, contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern, 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;
 }
-function resolvePathSymlinks(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);
-        resolvedPath !== contentPath.base && paths.push({
-            ...contentPath,
-            base: resolvedPath
-        });
-    } catch  {}
+        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)=>"string" == typeof item.raw).map(({ raw , extension ="html"  })=>({
+    let changedContent = context.tailwindConfig.content.files.filter((item)=>typeof item.raw === "string").map(({ raw , extension ="html"  })=>({
             content: raw,
             extension
-        })), [changedFiles, mTimesToCommit] = function(candidateFiles, fileModifiedMap) {
-        let paths = candidateFiles.map((contentPath)=>contentPath.pattern), mTimesToCommit = new Map(), changedFiles = new Set();
-        for (let file of (_sharedState.env.DEBUG && console.time("Finding changed files"), _fastGlob.default.sync(paths, {
-            absolute: !0
-        }))){
-            let prevModified = fileModifiedMap.get(file) || -1 / 0, modified = _fs.default.statSync(file).mtimeMs;
-            modified > prevModified && (changedFiles.add(file), mTimesToCommit.set(file, modified));
-        }
-        return _sharedState.env.DEBUG && console.timeEnd("Finding changed files"), [
-            changedFiles,
-            mTimesToCommit
-        ];
-    }(candidateFiles, fileModifiedMap);
+        }));
+    let [changedFiles, mTimesToCommit] = resolveChangedFiles(candidateFiles, fileModifiedMap);
     for (let changedFile of changedFiles){
         let extension = _path.default.extname(changedFile).slice(1);
         changedContent.push({
@@ -86,3 +152,30 @@ function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
         mTimesToCommit
     ];
 }
+/**
+ *
+ * @param {ContentPath[]} candidateFiles
+ * @param {Map<string, number>} fileModifiedMap
+ * @returns {[Set<string>, Map<string, number>]}
+ */ function resolveChangedFiles(candidateFiles, fileModifiedMap) {
+    let paths = candidateFiles.map((contentPath)=>contentPath.pattern);
+    let mTimesToCommit = new Map();
+    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.get(file) || -Infinity;
+        let modified = _fs.default.statSync(file).mtimeMs;
+        if (modified > prevModified) {
+            changedFiles.add(file);
+            mTimesToCommit.set(file, modified);
+        }
+    }
+    _sharedState.env.DEBUG && console.timeEnd("Finding changed files");
+    return [
+        changedFiles,
+        mTimesToCommit
+    ];
+}