tailwindcss 0.0.0-oxide-insiders.dddaded → 0.0.0-oxide-insiders.b2e3cf2

package/lib/featureFlags.js

@@ -1,37 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
+    value: !0
+}), function(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
+        enumerable: !0,
         get: all[name]
     });
-}
-_export(exports, {
+}(exports, {
     flagEnabled: ()=>flagEnabled,
     issueFlagNotices: ()=>issueFlagNotices,
     default: ()=>_default
 });
-const _picocolors = /*#__PURE__*/ _interopRequireDefault(require("picocolors"));
-const _log = /*#__PURE__*/ _interopRequireDefault(require("./util/log"));
-const _sharedState = require("./lib/sharedState");
+const _picocolors = _interopRequireDefault(require("picocolors")), _log = _interopRequireDefault(require("./util/log"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let defaults = {
-    optimizeUniversalDefaults: false,
-    generalizedModifiers: true,
+    optimizeUniversalDefaults: !1,
+    generalizedModifiers: !0,
     get disableColorOpacityUtilitiesByDefault () {
-        return _sharedState.env.OXIDE;
+        return !0;
     },
     get relativeContentPathsByDefault () {
-        return _sharedState.env.OXIDE;
+        return !0;
     }
-};
-let featureFlags = {
+}, featureFlags = {
     future: [
         "hoverOnlyWhenSupported",
         "respectDefaultRingColorOpacity",
@@ -44,30 +39,15 @@ let featureFlags = {
     ]
 };
 function flagEnabled(config, flag) {
-    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;
+    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);
 }
 function experimentalFlagsEnabled(config) {
-    if (config.experimental === "all") {
-        return featureFlags.experimental;
-    }
     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]);
+    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]);
 }
 function issueFlagNotices(config) {
-    if (process.env.JEST_WORKER_ID !== undefined) {
-        return;
-    }
-    if (experimentalFlagsEnabled(config).length > 0) {
+    if (void 0 === process.env.JEST_WORKER_ID && 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/index.js

@@ -1,6 +1,2 @@
 "use strict";
-if (process.env.OXIDE) {
-    module.exports = require("./oxide/postcss-plugin");
-} else {
-    module.exports = require("./plugin");
-}
+module.exports = require("./plugin");

package/lib/lib/cacheInvalidation.js

@@ -1,90 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "hasContentChanged", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "hasContentChanged", {
+    enumerable: !0,
     get: ()=>hasContentChanged
 });
-const _crypto = /*#__PURE__*/ _interopRequireDefault(require("crypto"));
-const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
-function _interopRequireDefault(obj) {
+const _crypto = function(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 (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
+    if ("function" != typeof WeakMap) return null;
+    var cacheBabelInterop = new WeakMap(), 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;
+    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;
 }

package/lib/lib/collapseAdjacentRules.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>collapseAdjacentRules
 });
 let comparisonMap = {
@@ -14,46 +13,26 @@ let comparisonMap = {
     rule: [
         "selector"
     ]
-};
-let types = new Set(Object.keys(comparisonMap));
+}, types = new Set(Object.keys(comparisonMap));
 function collapseAdjacentRules() {
-    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);
-                }
-                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);
+        !function collapseRulesIn(root) {
+            let currentRule = null;
+            root.each((node)=>{
+                var _node_property, _currentRule_property;
+                if (!types.has(node.type)) {
+                    currentRule = null;
+                    return;
+                }
+                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);
     };
 }

package/lib/lib/collapseDuplicateDeclarations.js

@@ -1,83 +1,42 @@
 "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());
+            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);
                     }
-                    byProperty.get(decl.prop).add(seen.get(decl.prop));
-                    byProperty.get(decl.prop).add(decl);
+                    seen.set(decl.prop, 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.
+            }), droppable))decl.remove();
             for (let declarations of byProperty.values()){
                 let byUnit = new Map();
                 for (let decl of declarations){
-                    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();
-                    }
+                    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));
                 }
+                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,61 +1,36 @@
-// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
+    value: !0
+}), function(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
+        enumerable: !0,
         get: all[name]
     });
-}
-_export(exports, {
+}(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");
+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) {
     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)));
-    }
+    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 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;
+    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);
 }
-/**
- *
- * @param {string} filePath
- * @param {boolean} ignore
- * @returns {ContentPath}
- */ function parseFilePath(filePath, ignore) {
+function parseFilePath(filePath, ignore) {
     let contentPath = {
         original: filePath,
         base: filePath,
@@ -63,79 +38,42 @@ function parseCandidateFiles(context, tailwindConfig) {
         pattern: filePath,
         glob: null
     };
-    if ((0, _isGlob.default)(filePath)) {
-        Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath));
-    }
-    return contentPath;
+    return (0, _isGlob.default)(filePath) && Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath)), 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
+function resolveGlobPattern(contentPath) {
     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;
+    return base = _fastGlob.default.escapePath(base), contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base, contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern, 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) {
+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?
-    }
+        resolvedPath !== contentPath.base && paths.push({
+            ...contentPath,
+            base: resolvedPath
+        });
+    } catch  {}
     return paths;
 }
 function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
-    let changedContent = context.tailwindConfig.content.files.filter((item)=>typeof item.raw === "string").map(({ raw , extension ="html"  })=>({
+    let changedContent = context.tailwindConfig.content.files.filter((item)=>"string" == typeof item.raw).map(({ raw , extension ="html"  })=>({
             content: raw,
             extension
-        }));
-    let [changedFiles, mTimesToCommit] = resolveChangedFiles(candidateFiles, fileModifiedMap);
+        })), [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);
     for (let changedFile of changedFiles){
         let extension = _path.default.extname(changedFile).slice(1);
         changedContent.push({
@@ -148,30 +86,3 @@ 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
-    ];
-}