tailwindcss 0.0.0-insiders.4e21639 → 0.0.0-insiders.4e62334

package/lib/cli.js

@@ -1,44 +1,84 @@
 #!/usr/bin/env node
 "use strict";
-var _indexJs = require("../peers/index.js");
-var _chokidar = _interopRequireDefault(require("chokidar"));
-var _path = _interopRequireDefault(require("path"));
-var _arg = _interopRequireDefault(require("arg"));
-var _fs = _interopRequireDefault(require("fs"));
-var _postcssLoadConfig = _interopRequireDefault(require("postcss-load-config"));
-var _cosmiconfig = require("cosmiconfig");
-var _plugins // Little bit scary, looking at private/internal API
- = _interopRequireDefault(require("postcss-load-config/src/plugins"));
-var _processTailwindFeatures = _interopRequireDefault(require("./processTailwindFeatures"));
-var _resolveConfig = _interopRequireDefault(require("../resolveConfig"));
-var _fastGlob = _interopRequireDefault(require("fast-glob"));
-var _getModuleDependencies = _interopRequireDefault(require("./lib/getModuleDependencies"));
-var _log = _interopRequireDefault(require("./util/log"));
-var _packageJson = _interopRequireDefault(require("../package.json"));
-var _normalizePath = _interopRequireDefault(require("normalize-path"));
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _indexJs = require("../peers/index.js");
+const _chokidar = /*#__PURE__*/ _interopRequireDefault(require("chokidar"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _arg = /*#__PURE__*/ _interopRequireDefault(require("arg"));
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _postcssLoadConfig = /*#__PURE__*/ _interopRequireDefault(require("postcss-load-config"));
+const _lilconfig = require("lilconfig");
+const _plugins = /*#__PURE__*/ _interopRequireDefault(require("postcss-load-config/src/plugins" // Little bit scary, looking at private/internal API
+));
+const _options = /*#__PURE__*/ _interopRequireDefault(require("postcss-load-config/src/options" // Little bit scary, looking at private/internal API
+));
+const _processTailwindFeatures = /*#__PURE__*/ _interopRequireDefault(require("./processTailwindFeatures"));
+const _resolveConfig = /*#__PURE__*/ _interopRequireDefault(require("../resolveConfig"));
+const _fastGlob = /*#__PURE__*/ _interopRequireDefault(require("fast-glob"));
+const _getModuleDependencies = /*#__PURE__*/ _interopRequireDefault(require("./lib/getModuleDependencies"));
+const _log = /*#__PURE__*/ _interopRequireDefault(require("./util/log"));
+const _packageJson = /*#__PURE__*/ _interopRequireDefault(require("../package.json"));
+const _normalizePath = /*#__PURE__*/ _interopRequireDefault(require("normalize-path"));
+const _micromatch = /*#__PURE__*/ _interopRequireDefault(require("micromatch"));
+const _validateConfigJs = require("./util/validateConfig.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let env = {
-    DEBUG: process.env.DEBUG !== undefined && process.env.DEBUG !== '0'
+    DEBUG: process.env.DEBUG !== undefined && process.env.DEBUG !== "0"
+};
+function isESM() {
+    const pkgPath = _path.default.resolve("./package.json");
+    try {
+        let pkg = JSON.parse(_fs.default.readFileSync(pkgPath, "utf8"));
+        return pkg.type && pkg.type === "module";
+    } catch (err) {
+        return false;
+    }
+}
+let configs = isESM() ? {
+    tailwind: "tailwind.config.cjs",
+    postcss: "postcss.config.cjs"
+} : {
+    tailwind: "tailwind.config.js",
+    postcss: "postcss.config.js"
 };
 // ---
 function indentRecursive(node, indent = 0) {
     node.each && node.each((child, i)=>{
-        if (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes('\n')) {
-            child.raws.before = `\n${node.type !== 'rule' && i > 0 ? '\n' : ''}${'  '.repeat(indent)}`;
+        if (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) {
+            child.raws.before = `\n${node.type !== "rule" && i > 0 ? "\n" : ""}${"  ".repeat(indent)}`;
         }
-        child.raws.after = `\n${'  '.repeat(indent)}`;
+        child.raws.after = `\n${"  ".repeat(indent)}`;
         indentRecursive(child, indent + 1);
     });
 }
 function formatNodes(root) {
     indentRecursive(root);
     if (root.first) {
-        root.first.raws.before = '';
+        root.first.raws.before = "";
+    }
+}
+async function outputFile(file, contents) {
+    if (_fs.default.existsSync(file) && await _fs.default.promises.readFile(file, "utf8") === contents) {
+        return; // Skip writing the file
     }
+    // Write the file
+    await _fs.default.promises.writeFile(file, contents, "utf8");
+}
+function drainStdin() {
+    return new Promise((resolve, reject)=>{
+        let result = "";
+        process.stdin.on("data", (chunk)=>{
+            result += chunk;
+        });
+        process.stdin.on("end", ()=>resolve(result));
+        process.stdin.on("error", (err)=>reject(err));
+    });
 }
 function help({ message , usage , commands , options  }) {
     let indent = 2;
@@ -48,32 +88,31 @@ function help({ message , usage , commands , options  }) {
     // Render message
     if (message) {
         console.log();
-        for (let msg of message.split('\n')){
+        for (let msg of message.split("\n")){
             console.log(msg);
         }
     }
     // Render usage
     if (usage && usage.length > 0) {
         console.log();
-        console.log('Usage:');
+        console.log("Usage:");
         for (let example of usage){
-            console.log(' '.repeat(indent), example);
+            console.log(" ".repeat(indent), example);
         }
     }
     // Render commands
     if (commands && commands.length > 0) {
         console.log();
-        console.log('Commands:');
+        console.log("Commands:");
         for (let command of commands){
-            console.log(' '.repeat(indent), command);
+            console.log(" ".repeat(indent), command);
         }
     }
     // Render options
     if (options) {
-        let groupedOptions = {
-        };
+        let groupedOptions = {};
         for (let [key, value] of Object.entries(options)){
-            if (typeof value === 'object') {
+            if (typeof value === "object") {
                 groupedOptions[key] = {
                     ...value,
                     flags: [
@@ -85,13 +124,13 @@ function help({ message , usage , commands , options  }) {
             }
         }
         console.log();
-        console.log('Options:');
+        console.log("Options:");
         for (let { flags , description , deprecated  } of Object.values(groupedOptions)){
             if (deprecated) continue;
             if (flags.length === 1) {
-                console.log(' '.repeat(indent + 4 /* 4 = "-i, ".length */ ), flags.slice().reverse().join(', ').padEnd(20, ' '), description);
+                console.log(" ".repeat(indent + 4 /* 4 = "-i, ".length */ ), flags.slice().reverse().join(", ").padEnd(20, " "), description);
             } else {
-                console.log(' '.repeat(indent), flags.slice().reverse().join(', ').padEnd(24, ' '), description);
+                console.log(" ".repeat(indent), flags.slice().reverse().join(", ").padEnd(24, " "), description);
             }
         }
     }
@@ -105,156 +144,161 @@ function oneOf(...options) {
                 return parsed;
             }
         }
-        throw new Error('...');
+        throw new Error("...");
     }, {
         manualParsing: true
     });
 }
-let commands1 = {
+function loadPostcss() {
+    // Try to load a local `postcss` version first
+    try {
+        return require("postcss");
+    } catch  {}
+    return (0, _indexJs.lazyPostcss)();
+}
+let commands = {
     init: {
         run: init,
         args: {
-            '--full': {
+            "--full": {
                 type: Boolean,
-                description: 'Initialize a full `tailwind.config.js` file'
+                description: `Initialize a full \`${configs.tailwind}\` file`
             },
-            '--postcss': {
+            "--postcss": {
                 type: Boolean,
-                description: 'Initialize a `postcss.config.js` file'
+                description: `Initialize a \`${configs.postcss}\` file`
             },
-            '-f': '--full',
-            '-p': '--postcss'
+            "-f": "--full",
+            "-p": "--postcss"
         }
     },
     build: {
         run: build,
         args: {
-            '--input': {
+            "--input": {
                 type: String,
-                description: 'Input file'
+                description: "Input file"
             },
-            '--output': {
+            "--output": {
                 type: String,
-                description: 'Output file'
+                description: "Output file"
+            },
+            "--watch": {
+                type: Boolean,
+                description: "Watch for changes and rebuild as needed"
             },
-            '--watch': {
+            "--poll": {
                 type: Boolean,
-                description: 'Watch for changes and rebuild as needed'
+                description: "Use polling instead of filesystem events when watching"
             },
-            '--content': {
+            "--content": {
                 type: String,
-                description: 'Content paths to use for removing unused classes'
+                description: "Content paths to use for removing unused classes"
             },
-            '--purge': {
+            "--purge": {
                 type: String,
                 deprecated: true
             },
-            '--postcss': {
+            "--postcss": {
                 type: oneOf(String, Boolean),
-                description: 'Load custom PostCSS configuration'
+                description: "Load custom PostCSS configuration"
             },
-            '--minify': {
+            "--minify": {
                 type: Boolean,
-                description: 'Minify the output'
+                description: "Minify the output"
             },
-            '--config': {
+            "--config": {
                 type: String,
-                description: 'Path to a custom config file'
+                description: "Path to a custom config file"
             },
-            '--no-autoprefixer': {
+            "--no-autoprefixer": {
                 type: Boolean,
-                description: 'Disable autoprefixer'
+                description: "Disable autoprefixer"
             },
-            '-c': '--config',
-            '-i': '--input',
-            '-o': '--output',
-            '-m': '--minify',
-            '-w': '--watch'
+            "-c": "--config",
+            "-i": "--input",
+            "-o": "--output",
+            "-m": "--minify",
+            "-w": "--watch",
+            "-p": "--poll"
         }
     }
 };
 let sharedFlags = {
-    '--help': {
+    "--help": {
         type: Boolean,
-        description: 'Display usage information'
+        description: "Display usage information"
     },
-    '-h': '--help'
+    "-h": "--help"
 };
-if (process.stdout.isTTY /* Detect redirecting output to a file */  && (process.argv[2] === undefined || process.argv.slice(2).every((flag)=>sharedFlags[flag] !== undefined
-))) {
+if (process.stdout.isTTY /* Detect redirecting output to a file */  && (process.argv[2] === undefined || process.argv.slice(2).every((flag)=>sharedFlags[flag] !== undefined))) {
     help({
         usage: [
-            'tailwindcss [--input input.css] [--output output.css] [--watch] [options...]',
-            'tailwindcss init [--full] [--postcss] [options...]', 
+            "tailwindcss [--input input.css] [--output output.css] [--watch] [options...]",
+            "tailwindcss init [--full] [--postcss] [options...]", 
         ],
-        commands: Object.keys(commands1).filter((command)=>command !== 'build'
-        ).map((command)=>`${command} [options]`
-        ),
+        commands: Object.keys(commands).filter((command)=>command !== "build").map((command)=>`${command} [options]`),
         options: {
-            ...commands1.build.args,
+            ...commands.build.args,
             ...sharedFlags
         }
     });
     process.exit(0);
 }
-let command1 = ((arg = '')=>arg.startsWith('-') ? undefined : arg
-)(process.argv[2]) || 'build';
-if (commands1[command1] === undefined) {
-    if (_fs.default.existsSync(_path.default.resolve(command1))) {
+let command = ((arg = "")=>arg.startsWith("-") ? undefined : arg)(process.argv[2]) || "build";
+if (commands[command] === undefined) {
+    if (_fs.default.existsSync(_path.default.resolve(command))) {
         // TODO: Deprecate this in future versions
         // Check if non-existing command, might be a file.
-        command1 = 'build';
+        command = "build";
     } else {
         help({
-            message: `Invalid command: ${command1}`,
+            message: `Invalid command: ${command}`,
             usage: [
-                'tailwindcss <command> [options]'
+                "tailwindcss <command> [options]"
             ],
-            commands: Object.keys(commands1).filter((command)=>command !== 'build'
-            ).map((command)=>`${command} [options]`
-            ),
+            commands: Object.keys(commands).filter((command)=>command !== "build").map((command)=>`${command} [options]`),
             options: sharedFlags
         });
         process.exit(1);
     }
 }
 // Execute command
-let { args: flags1 , run  } = commands1[command1];
-let args1 = (()=>{
+let { args: flags , run  } = commands[command];
+let args = (()=>{
     try {
-        let result = (0, _arg).default(Object.fromEntries(Object.entries({
-            ...flags1,
+        let result = (0, _arg.default)(Object.fromEntries(Object.entries({
+            ...flags,
             ...sharedFlags
         }).filter(([_key, value])=>{
             var ref;
             return !(value === null || value === void 0 ? void 0 : (ref = value.type) === null || ref === void 0 ? void 0 : ref.manualParsing);
         }).map(([key, value])=>[
                 key,
-                typeof value === 'object' ? value.type : value
-            ]
-        )), {
+                typeof value === "object" ? value.type : value
+            ])), {
             permissive: true
         });
         // Manual parsing of flags to allow for special flags like oneOf(Boolean, String)
-        for(let i = result['_'].length - 1; i >= 0; --i){
-            let flag = result['_'][i];
-            if (!flag.startsWith('-')) continue;
+        for(let i = result["_"].length - 1; i >= 0; --i){
+            let flag = result["_"][i];
+            if (!flag.startsWith("-")) continue;
             let flagName = flag;
-            let handler = flags1[flag];
+            let handler = flags[flag];
             // Resolve flagName & handler
-            while(typeof handler === 'string'){
+            while(typeof handler === "string"){
                 flagName = handler;
-                handler = flags1[handler];
+                handler = flags[handler];
             }
             if (!handler) continue;
             let args = [];
             let offset = i + 1;
             // Parse args for current flag
-            while(result['_'][offset] && !result['_'][offset].startsWith('-')){
-                args.push(result['_'][offset++]);
+            while(result["_"][offset] && !result["_"][offset].startsWith("-")){
+                args.push(result["_"][offset++]);
             }
             // Cleanup manually parsed flags + args
-            result['_'].splice(i, 1 + args.length);
+            result["_"].splice(i, 1 + args.length);
             // Set the resolved value in the `result` object
             result[flagName] = handler.type(args.length === 0 ? undefined : args.length === 1 ? args[0] : args, flagName);
         }
@@ -264,16 +308,16 @@ let args1 = (()=>{
         //
         // E.g.: tailwindcss input.css -> _: ['build', 'input.css']
         // E.g.: tailwindcss build input.css -> _: ['build', 'input.css']
-        if (result['_'][0] !== command1) {
-            result['_'].unshift(command1);
+        if (result["_"][0] !== command) {
+            result["_"].unshift(command);
         }
         return result;
     } catch (err) {
-        if (err.code === 'ARG_UNKNOWN_OPTION') {
+        if (err.code === "ARG_UNKNOWN_OPTION") {
             help({
                 message: err.message,
                 usage: [
-                    'tailwindcss <command> [options]'
+                    "tailwindcss <command> [options]"
                 ],
                 options: sharedFlags
             });
@@ -282,14 +326,14 @@ let args1 = (()=>{
         throw err;
     }
 })();
-if (args1['--help']) {
+if (args["--help"]) {
     help({
         options: {
-            ...flags1,
+            ...flags,
             ...sharedFlags
         },
         usage: [
-            `tailwindcss ${command1} [options]`
+            `tailwindcss ${command} [options]`
         ]
     });
     process.exit(0);
@@ -299,23 +343,23 @@ run();
 function init() {
     let messages = [];
     var ref;
-    let tailwindConfigLocation = _path.default.resolve((ref = args1['_'][1]) !== null && ref !== void 0 ? ref : './tailwind.config.js');
+    let tailwindConfigLocation = _path.default.resolve((ref = args["_"][1]) !== null && ref !== void 0 ? ref : `./${configs.tailwind}`);
     if (_fs.default.existsSync(tailwindConfigLocation)) {
         messages.push(`${_path.default.basename(tailwindConfigLocation)} already exists.`);
     } else {
-        let stubFile = _fs.default.readFileSync(args1['--full'] ? _path.default.resolve(__dirname, '../stubs/defaultConfig.stub.js') : _path.default.resolve(__dirname, '../stubs/simpleConfig.stub.js'), 'utf8');
+        let stubFile = _fs.default.readFileSync(args["--full"] ? _path.default.resolve(__dirname, "../stubs/defaultConfig.stub.js") : _path.default.resolve(__dirname, "../stubs/simpleConfig.stub.js"), "utf8");
         // Change colors import
-        stubFile = stubFile.replace('../colors', 'tailwindcss/colors');
-        _fs.default.writeFileSync(tailwindConfigLocation, stubFile, 'utf8');
+        stubFile = stubFile.replace("../colors", "tailwindcss/colors");
+        _fs.default.writeFileSync(tailwindConfigLocation, stubFile, "utf8");
         messages.push(`Created Tailwind CSS config file: ${_path.default.basename(tailwindConfigLocation)}`);
     }
-    if (args1['--postcss']) {
-        let postcssConfigLocation = _path.default.resolve('./postcss.config.js');
+    if (args["--postcss"]) {
+        let postcssConfigLocation = _path.default.resolve(`./${configs.postcss}`);
         if (_fs.default.existsSync(postcssConfigLocation)) {
             messages.push(`${_path.default.basename(postcssConfigLocation)} already exists.`);
         } else {
-            let stubFile = _fs.default.readFileSync(_path.default.resolve(__dirname, '../stubs/defaultPostCssConfig.stub.js'), 'utf8');
-            _fs.default.writeFileSync(postcssConfigLocation, stubFile, 'utf8');
+            let stubFile1 = _fs.default.readFileSync(_path.default.resolve(__dirname, "../stubs/defaultPostCssConfig.stub.js"), "utf8");
+            _fs.default.writeFileSync(postcssConfigLocation, stubFile1, "utf8");
             messages.push(`Created PostCSS config file: ${_path.default.basename(postcssConfigLocation)}`);
         }
     }
@@ -327,50 +371,55 @@ function init() {
     }
 }
 async function build() {
-    let input = args1['--input'];
-    let output = args1['--output'];
-    let shouldWatch = args1['--watch'];
-    let includePostCss = args1['--postcss'];
+    let input = args["--input"];
+    let output = args["--output"];
+    let shouldWatch = args["--watch"];
+    let shouldPoll = args["--poll"];
+    let shouldCoalesceWriteEvents = shouldPoll || process.platform === "win32";
+    let includePostCss = args["--postcss"];
+    // Polling interval in milliseconds
+    // Used only when polling or coalescing add/change events on Windows
+    let pollInterval = 10;
     // TODO: Deprecate this in future versions
-    if (!input && args1['_'][1]) {
-        console.error('[deprecation] Running tailwindcss without -i, please provide an input file.');
-        input = args1['--input'] = args1['_'][1];
+    if (!input && args["_"][1]) {
+        console.error("[deprecation] Running tailwindcss without -i, please provide an input file.");
+        input = args["--input"] = args["_"][1];
     }
-    if (input && !_fs.default.existsSync(input = _path.default.resolve(input))) {
-        console.error(`Specified input file ${args1['--input']} does not exist.`);
+    if (input && input !== "-" && !_fs.default.existsSync(input = _path.default.resolve(input))) {
+        console.error(`Specified input file ${args["--input"]} does not exist.`);
         process.exit(9);
     }
-    if (args1['--config'] && !_fs.default.existsSync(args1['--config'] = _path.default.resolve(args1['--config']))) {
-        console.error(`Specified config file ${args1['--config']} does not exist.`);
+    if (args["--config"] && !_fs.default.existsSync(args["--config"] = _path.default.resolve(args["--config"]))) {
+        console.error(`Specified config file ${args["--config"]} does not exist.`);
         process.exit(9);
     }
-    let configPath = args1['--config'] ? args1['--config'] : ((defaultPath)=>_fs.default.existsSync(defaultPath) ? defaultPath : null
-    )(_path.default.resolve('./tailwind.config.js'));
+    let configPath = args["--config"] ? args["--config"] : ((defaultPath)=>_fs.default.existsSync(defaultPath) ? defaultPath : null)(_path.default.resolve(`./${configs.tailwind}`));
     async function loadPostCssPlugins() {
-        let customPostCssPath = typeof args1['--postcss'] === 'string' ? args1['--postcss'] : undefined;
-        let { plugins: configPlugins  } = customPostCssPath ? await (async ()=>{
+        let customPostCssPath = typeof args["--postcss"] === "string" ? args["--postcss"] : undefined;
+        let config = customPostCssPath ? await (async ()=>{
             let file = _path.default.resolve(customPostCssPath);
-            // Implementation, see: https://unpkg.com/browse/postcss-load-config@3.0.1/src/index.js
-            let { config ={
-            }  } = await (0, _cosmiconfig).cosmiconfig('postcss').load(file);
-            if (typeof config === 'function') {
+            // Implementation, see: https://unpkg.com/browse/postcss-load-config@3.1.0/src/index.js
+            let { config ={}  } = await (0, _lilconfig.lilconfig)("postcss").load(file);
+            if (typeof config === "function") {
                 config = config();
             } else {
-                config = Object.assign({
-                }, config);
+                config = Object.assign({}, config);
             }
             if (!config.plugins) {
                 config.plugins = [];
             }
             return {
-                plugins: (0, _plugins).default(config, file)
+                file,
+                plugins: (0, _plugins.default)(config, file),
+                options: (0, _options.default)(config, file)
             };
-        })() : await (0, _postcssLoadConfig).default();
+        })() : await (0, _postcssLoadConfig.default)();
+        let configPlugins = config.plugins;
         let configPluginTailwindIdx = configPlugins.findIndex((plugin)=>{
-            if (typeof plugin === 'function' && plugin.name === 'tailwindcss') {
+            if (typeof plugin === "function" && plugin.name === "tailwindcss") {
                 return true;
             }
-            if (typeof plugin === 'object' && plugin !== null && plugin.postcssPlugin === 'tailwindcss') {
+            if (typeof plugin === "object" && plugin !== null && plugin.postcssPlugin === "tailwindcss") {
                 return true;
             }
             return false;
@@ -379,39 +428,84 @@ async function build() {
         let afterPlugins = configPluginTailwindIdx === -1 ? configPlugins : configPlugins.slice(configPluginTailwindIdx + 1);
         return [
             beforePlugins,
-            afterPlugins
+            afterPlugins,
+            config.options
+        ];
+    }
+    function loadBuiltinPostcssPlugins() {
+        let postcss = loadPostcss();
+        let IMPORT_COMMENT = "__TAILWIND_RESTORE_IMPORT__: ";
+        return [
+            [
+                (root)=>{
+                    root.walkAtRules("import", (rule)=>{
+                        if (rule.params.slice(1).startsWith("tailwindcss/")) {
+                            rule.after(postcss.comment({
+                                text: IMPORT_COMMENT + rule.params
+                            }));
+                            rule.remove();
+                        }
+                    });
+                },
+                (()=>{
+                    try {
+                        return require("postcss-import");
+                    } catch  {}
+                    return (0, _indexJs.lazyPostcssImport)();
+                })(),
+                (root)=>{
+                    root.walkComments((rule)=>{
+                        if (rule.text.startsWith(IMPORT_COMMENT)) {
+                            rule.after(postcss.atRule({
+                                name: "import",
+                                params: rule.text.replace(IMPORT_COMMENT, "")
+                            }));
+                            rule.remove();
+                        }
+                    });
+                }, 
+            ],
+            [],
+            {}, 
         ];
     }
     function resolveConfig() {
-        let config = configPath ? require(configPath) : {
-        };
-        let resolvedConfig = (0, _resolveConfig).default(config);
-        if (args1['--purge']) {
-            _log.default.warn('purge-flag-deprecated', [
-                'The `--purge` flag has been deprecated.',
-                'Please use `--content` instead.', 
+        let config = configPath ? require(configPath) : {};
+        if (args["--purge"]) {
+            _log.default.warn("purge-flag-deprecated", [
+                "The `--purge` flag has been deprecated.",
+                "Please use `--content` instead.", 
             ]);
-            if (!args1['--content']) {
-                args1['--content'] = args1['--purge'];
+            if (!args["--content"]) {
+                args["--content"] = args["--purge"];
             }
         }
-        if (args1['--content']) {
-            resolvedConfig.content.files = args1['--content'].split(/(?<!{[^}]+),/);
+        if (args["--content"]) {
+            let files = args["--content"].split(/(?<!{[^}]+),/);
+            let resolvedConfig = (0, _resolveConfig.default)(config, {
+                content: {
+                    files
+                }
+            });
+            resolvedConfig.content.files = files;
+            resolvedConfig = (0, _validateConfigJs.validateConfig)(resolvedConfig);
+            return resolvedConfig;
         }
-        return resolvedConfig;
+        let resolvedConfig1 = (0, _resolveConfig.default)(config);
+        resolvedConfig1 = (0, _validateConfigJs.validateConfig)(resolvedConfig1);
+        return resolvedConfig1;
     }
     function extractFileGlobs(config) {
         return config.content.files.filter((file)=>{
             // Strings in this case are files / globs. If it is something else,
             // like an object it's probably a raw content object. But this object
             // is not watchable, so let's remove it.
-            return typeof file === 'string';
-        }).map((glob)=>(0, _normalizePath).default(glob)
-        );
+            return typeof file === "string";
+        }).map((glob)=>(0, _normalizePath.default)(glob));
     }
     function extractRawContent(config) {
         return config.content.files.filter((file)=>{
-            return typeof file === 'object' && file !== null;
+            return typeof file === "object" && file !== null;
         });
     }
     function getChangedContent(config) {
@@ -421,12 +515,12 @@ async function build() {
         let files = _fastGlob.default.sync(globs);
         for (let file of files){
             changedContent.push({
-                content: _fs.default.readFileSync(_path.default.resolve(file), 'utf8'),
+                content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
                 extension: _path.default.extname(file).slice(1)
             });
         }
         // Resolve raw content in the tailwind config
-        for (let { raw: content , extension ='html'  } of extractRawContent(config)){
+        for (let { raw: content , extension ="html"  } of extractRawContent(config)){
             changedContent.push({
                 content,
                 extension
@@ -439,9 +533,9 @@ async function build() {
         let changedContent = getChangedContent(config);
         let tailwindPlugin = ()=>{
             return {
-                postcssPlugin: 'tailwindcss',
+                postcssPlugin: "tailwindcss",
                 Once (root, { result  }) {
-                    (0, _processTailwindFeatures).default(({ createContext  })=>{
+                    (0, _processTailwindFeatures.default)(({ createContext  })=>{
                         return ()=>{
                             return createContext(config, changedContent);
                         };
@@ -450,27 +544,23 @@ async function build() {
             };
         };
         tailwindPlugin.postcss = true;
-        let [beforePlugins, afterPlugins] = includePostCss ? await loadPostCssPlugins() : [
-            [],
-            []
-        ];
+        let [beforePlugins, afterPlugins, postcssOptions] = includePostCss ? await loadPostCssPlugins() : loadBuiltinPostcssPlugins();
         let plugins = [
             ...beforePlugins,
             tailwindPlugin,
-            !args1['--minify'] && formatNodes,
+            !args["--minify"] && formatNodes,
             ...afterPlugins,
-            !args1['--no-autoprefixer'] && (()=>{
+            !args["--no-autoprefixer"] && (()=>{
                 // Try to load a local `autoprefixer` version first
                 try {
-                    return require('autoprefixer');
-                } catch  {
-                }
-                return (0, _indexJs).lazyAutoprefixer();
+                    return require("autoprefixer");
+                } catch  {}
+                return (0, _indexJs.lazyAutoprefixer)();
             })(),
-            args1['--minify'] && (()=>{
+            args["--minify"] && (()=>{
                 let options = {
                     preset: [
-                        'default',
+                        "default",
                         {
                             cssDeclarationSorter: false
                         }
@@ -478,40 +568,48 @@ async function build() {
                 };
                 // Try to load a local `cssnano` version first
                 try {
-                    return require('cssnano');
-                } catch  {
-                }
-                return (0, _indexJs).lazyCssnano()(options);
+                    return require("cssnano");
+                } catch  {}
+                return (0, _indexJs.lazyCssnano)()(options);
             })(), 
         ].filter(Boolean);
-        let processor = (0, _indexJs).postcss(plugins);
+        let postcss = loadPostcss();
+        let processor = postcss(plugins);
         function processCSS(css) {
             let start = process.hrtime.bigint();
             return Promise.resolve().then(()=>output ? _fs.default.promises.mkdir(_path.default.dirname(output), {
                     recursive: true
-                }) : null
-            ).then(()=>processor.process(css, {
+                }) : null).then(()=>processor.process(css, {
+                    ...postcssOptions,
                     from: input,
                     to: output
-                })
-            ).then((result)=>{
+                })).then((result)=>{
                 if (!output) {
                     return process.stdout.write(result.css);
                 }
                 return Promise.all([
-                    _fs.default.promises.writeFile(output, result.css, ()=>true
-                    ),
-                    result.map && _fs.default.writeFile(output + '.map', result.map.toString(), ()=>true
-                    ), 
+                    outputFile(output, result.css),
+                    result.map && outputFile(output + ".map", result.map.toString()), 
                 ].filter(Boolean));
             }).then(()=>{
                 let end = process.hrtime.bigint();
                 console.error();
-                console.error('Done in', (end - start) / BigInt(1000000) + 'ms.');
+                console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
             });
         }
-        let css1 = input ? _fs.default.readFileSync(_path.default.resolve(input), 'utf8') : '@tailwind base; @tailwind components; @tailwind utilities';
-        return processCSS(css1);
+        let css = await (()=>{
+            // Piping in data, let's drain the stdin
+            if (input === "-") {
+                return drainStdin();
+            }
+            // Input file has been provided
+            if (input) {
+                return _fs.default.readFileSync(_path.default.resolve(input), "utf8");
+            }
+            // No input file provided, fallback to default atrules
+            return "@tailwind base; @tailwind components; @tailwind utilities";
+        })();
+        return processCSS(css);
     }
     let context = null;
     async function startWatcher() {
@@ -520,41 +618,36 @@ async function build() {
         let contextDependencies = new Set();
         let watcher = null;
         function refreshConfig() {
-            env.DEBUG && console.time('Module dependencies');
-            for (let file1 of configDependencies){
-                delete require.cache[require.resolve(file1)];
+            env.DEBUG && console.time("Module dependencies");
+            for (let file of configDependencies){
+                delete require.cache[require.resolve(file)];
             }
             if (configPath) {
-                configDependencies = (0, _getModuleDependencies).default(configPath).map(({ file  })=>file
-                );
+                configDependencies = (0, _getModuleDependencies.default)(configPath).map(({ file  })=>file);
                 for (let dependency of configDependencies){
                     contextDependencies.add(dependency);
                 }
             }
-            env.DEBUG && console.timeEnd('Module dependencies');
+            env.DEBUG && console.timeEnd("Module dependencies");
             return resolveConfig();
         }
-        let [beforePlugins, afterPlugins] = includePostCss ? await loadPostCssPlugins() : [
-            [],
-            []
-        ];
+        let [beforePlugins, afterPlugins] = includePostCss ? await loadPostCssPlugins() : loadBuiltinPostcssPlugins();
         let plugins = [
             ...beforePlugins,
-            '__TAILWIND_PLUGIN_POSITION__',
-            !args1['--minify'] && formatNodes,
+            "__TAILWIND_PLUGIN_POSITION__",
+            !args["--minify"] && formatNodes,
             ...afterPlugins,
-            !args1['--no-autoprefixer'] && (()=>{
+            !args["--no-autoprefixer"] && (()=>{
                 // Try to load a local `autoprefixer` version first
                 try {
-                    return require('autoprefixer');
-                } catch  {
-                }
-                return (0, _indexJs).lazyAutoprefixer();
+                    return require("autoprefixer");
+                } catch  {}
+                return (0, _indexJs.lazyAutoprefixer)();
             })(),
-            args1['--minify'] && (()=>{
+            args["--minify"] && (()=>{
                 let options = {
                     preset: [
-                        'default',
+                        "default",
                         {
                             cssDeclarationSorter: false
                         }
@@ -562,54 +655,52 @@ async function build() {
                 };
                 // Try to load a local `cssnano` version first
                 try {
-                    return require('cssnano');
-                } catch  {
-                }
-                return (0, _indexJs).lazyCssnano()(options);
+                    return require("cssnano");
+                } catch  {}
+                return (0, _indexJs.lazyCssnano)()(options);
             })(), 
         ].filter(Boolean);
         async function rebuild(config) {
-            env.DEBUG && console.time('Finished in');
+            env.DEBUG && console.time("Finished in");
             let tailwindPlugin = ()=>{
                 return {
-                    postcssPlugin: 'tailwindcss',
+                    postcssPlugin: "tailwindcss",
                     Once (root, { result  }) {
-                        env.DEBUG && console.time('Compiling CSS');
-                        (0, _processTailwindFeatures).default(({ createContext  })=>{
+                        env.DEBUG && console.time("Compiling CSS");
+                        (0, _processTailwindFeatures.default)(({ createContext  })=>{
                             console.error();
-                            console.error('Rebuilding...');
+                            console.error("Rebuilding...");
                             return ()=>{
                                 if (context !== null) {
                                     context.changedContent = changedContent.splice(0);
                                     return context;
                                 }
-                                env.DEBUG && console.time('Creating context');
+                                env.DEBUG && console.time("Creating context");
                                 context = createContext(config, changedContent.splice(0));
-                                env.DEBUG && console.timeEnd('Creating context');
+                                env.DEBUG && console.timeEnd("Creating context");
                                 return context;
                             };
                         })(root, result);
-                        env.DEBUG && console.timeEnd('Compiling CSS');
+                        env.DEBUG && console.timeEnd("Compiling CSS");
                     }
                 };
             };
             tailwindPlugin.postcss = true;
-            let tailwindPluginIdx = plugins.indexOf('__TAILWIND_PLUGIN_POSITION__');
+            let tailwindPluginIdx = plugins.indexOf("__TAILWIND_PLUGIN_POSITION__");
             let copy = plugins.slice();
             copy.splice(tailwindPluginIdx, 1, tailwindPlugin);
-            let processor = (0, _indexJs).postcss(copy);
+            let postcss = loadPostcss();
+            let processor = postcss(copy);
             function processCSS(css) {
                 let start = process.hrtime.bigint();
                 return Promise.resolve().then(()=>output ? _fs.default.promises.mkdir(_path.default.dirname(output), {
                         recursive: true
-                    }) : null
-                ).then(()=>processor.process(css, {
+                    }) : null).then(()=>processor.process(css, {
                         from: input,
                         to: output
-                    })
-                ).then(async (result)=>{
+                    })).then(async (result)=>{
                     for (let message of result.messages){
-                        if (message.type === 'dependency') {
+                        if (message.type === "dependency") {
                             contextDependencies.add(message.file);
                         }
                     }
@@ -619,85 +710,195 @@ async function build() {
                     if (!output) {
                         return process.stdout.write(result.css);
                     }
-                    await Promise.all([
-                        _fs.default.promises.writeFile(output, result.css, ()=>true
-                        ),
-                        result.map && _fs.default.writeFile(output + '.map', result.map.toString(), ()=>true
-                        ), 
+                    return Promise.all([
+                        outputFile(output, result.css),
+                        result.map && outputFile(output + ".map", result.map.toString()), 
                     ].filter(Boolean));
                 }).then(()=>{
                     let end = process.hrtime.bigint();
-                    console.error('Done in', (end - start) / BigInt(1000000) + 'ms.');
+                    console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
                 }).catch((err)=>{
-                    if (err.name === 'CssSyntaxError') {
+                    if (err.name === "CssSyntaxError") {
                         console.error(err.toString());
                     } else {
                         console.error(err);
                     }
                 });
             }
-            let css2 = input ? _fs.default.readFileSync(_path.default.resolve(input), 'utf8') : '@tailwind base; @tailwind components; @tailwind utilities';
-            let result1 = await processCSS(css2);
-            env.DEBUG && console.timeEnd('Finished in');
-            return result1;
+            let css = await (()=>{
+                // Piping in data, let's drain the stdin
+                if (input === "-") {
+                    return drainStdin();
+                }
+                // Input file has been provided
+                if (input) {
+                    return _fs.default.readFileSync(_path.default.resolve(input), "utf8");
+                }
+                // No input file provided, fallback to default atrules
+                return "@tailwind base; @tailwind components; @tailwind utilities";
+            })();
+            let result = await processCSS(css);
+            env.DEBUG && console.timeEnd("Finished in");
+            return result;
+        }
+        let config = refreshConfig(configPath);
+        let contentPatterns = refreshContentPatterns(config);
+        /**
+     * @param {import('../types/config.js').RequiredConfig} config
+     * @return {{all: string[], dynamic: string[], static: string[]}}
+     **/ function refreshContentPatterns(config) {
+            let globs = extractFileGlobs(config);
+            let tasks = _fastGlob.default.generateTasks(globs, {
+                absolute: true
+            });
+            let dynamicPatterns = tasks.filter((task)=>task.dynamic).flatMap((task)=>task.patterns);
+            let staticPatterns = tasks.filter((task)=>!task.dynamic).flatMap((task)=>task.patterns);
+            return {
+                all: [
+                    ...staticPatterns,
+                    ...dynamicPatterns
+                ],
+                dynamic: dynamicPatterns
+            };
         }
-        let config1 = refreshConfig(configPath);
         if (input) {
             contextDependencies.add(_path.default.resolve(input));
         }
         watcher = _chokidar.default.watch([
             ...contextDependencies,
-            ...extractFileGlobs(config1)
+            ...extractFileGlobs(config)
         ], {
+            // Force checking for atomic writes in all situations
+            // This causes chokidar to wait up to 100ms for a file to re-added after it's been unlinked
+            // This only works when watching directories though
+            atomic: true,
+            usePolling: shouldPoll,
+            interval: shouldPoll ? pollInterval : undefined,
             ignoreInitial: true,
-            awaitWriteFinish: process.platform === 'win32' ? {
+            awaitWriteFinish: shouldCoalesceWriteEvents ? {
                 stabilityThreshold: 50,
-                pollInterval: 10
+                pollInterval: pollInterval
             } : false
         });
         let chain = Promise.resolve();
-        watcher.on('change', async (file)=>{
+        let pendingRebuilds = new Set();
+        watcher.on("change", async (file)=>{
             if (contextDependencies.has(file)) {
-                env.DEBUG && console.time('Resolve config');
+                env.DEBUG && console.time("Resolve config");
                 context = null;
-                config1 = refreshConfig(configPath);
-                env.DEBUG && console.timeEnd('Resolve config');
-                env.DEBUG && console.time('Watch new files');
-                let globs = extractFileGlobs(config1);
+                config = refreshConfig(configPath);
+                contentPatterns = refreshContentPatterns(config);
+                env.DEBUG && console.timeEnd("Resolve config");
+                env.DEBUG && console.time("Watch new files");
+                let globs = extractFileGlobs(config);
                 watcher.add(configDependencies);
                 watcher.add(globs);
-                env.DEBUG && console.timeEnd('Watch new files');
+                env.DEBUG && console.timeEnd("Watch new files");
                 chain = chain.then(async ()=>{
-                    changedContent.push(...getChangedContent(config1));
-                    await rebuild(config1);
+                    changedContent.push(...getChangedContent(config));
+                    await rebuild(config);
                 });
             } else {
                 chain = chain.then(async ()=>{
                     changedContent.push({
-                        content: _fs.default.readFileSync(_path.default.resolve(file), 'utf8'),
+                        content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
                         extension: _path.default.extname(file).slice(1)
                     });
-                    await rebuild(config1);
+                    await rebuild(config);
                 });
             }
         });
-        watcher.on('add', async (file)=>{
+        /**
+     * When rapidly saving files atomically a couple of situations can happen:
+     * - The file is missing since the external program has deleted it by the time we've gotten around to reading it from the earlier save.
+     * - The file is being written to by the external program by the time we're going to read it and is thus treated as busy because a lock is held.
+     *
+     * To work around this we retry reading the file a handful of times with a delay between each attempt
+     *
+     * @param {string} path
+     * @param {number} tries
+     * @returns {string}
+     * @throws {Error} If the file is still missing or busy after the specified number of tries
+     */ async function readFileWithRetries(path, tries = 5) {
+            for(let n = 0; n <= tries; n++){
+                try {
+                    return await _fs.default.promises.readFile(path, "utf8");
+                } catch (err) {
+                    if (n !== tries) {
+                        if (err.code === "ENOENT" || err.code === "EBUSY") {
+                            await new Promise((resolve)=>setTimeout(resolve, 10));
+                            continue;
+                        }
+                    }
+                    throw err;
+                }
+            }
+        }
+        // Restore watching any files that are "removed"
+        // This can happen when a file is pseudo-atomically replaced (a copy is created, overwritten, the old one is unlinked, and the new one is renamed)
+        // TODO: An an optimization we should allow removal when the config changes
+        watcher.on("unlink", (file)=>{
+            file = (0, _normalizePath.default)(file);
+            // Only re-add the file if it's not covered by a dynamic pattern
+            if (!_micromatch.default.some([
+                file
+            ], contentPatterns.dynamic)) {
+                watcher.add(file);
+            }
+        });
+        // Some applications such as Visual Studio (but not VS Code)
+        // will only fire a rename event for atomic writes and not a change event
+        // This is very likely a chokidar bug but it's one we need to work around
+        // We treat this as a change event and rebuild the CSS
+        watcher.on("raw", (evt, filePath, meta)=>{
+            if (evt !== "rename") {
+                return;
+            }
+            let watchedPath = meta.watchedPath;
+            // Watched path might be the file itself
+            // Or the directory it is in
+            filePath = watchedPath.endsWith(filePath) ? watchedPath : _path.default.join(watchedPath, filePath);
+            // Skip this event since the files it is for does not match any of the registered content globs
+            if (!_micromatch.default.some([
+                filePath
+            ], contentPatterns.all)) {
+                return;
+            }
+            // Skip since we've already queued a rebuild for this file that hasn't happened yet
+            if (pendingRebuilds.has(filePath)) {
+                return;
+            }
+            pendingRebuilds.add(filePath);
+            chain = chain.then(async ()=>{
+                let content;
+                try {
+                    content = await readFileWithRetries(_path.default.resolve(filePath));
+                } finally{
+                    pendingRebuilds.delete(filePath);
+                }
+                changedContent.push({
+                    content,
+                    extension: _path.default.extname(filePath).slice(1)
+                });
+                await rebuild(config);
+            });
+        });
+        watcher.on("add", async (file)=>{
             chain = chain.then(async ()=>{
                 changedContent.push({
-                    content: _fs.default.readFileSync(_path.default.resolve(file), 'utf8'),
+                    content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
                     extension: _path.default.extname(file).slice(1)
                 });
-                await rebuild(config1);
+                await rebuild(config);
             });
         });
         chain = chain.then(()=>{
-            changedContent.push(...getChangedContent(config1));
-            return rebuild(config1);
+            changedContent.push(...getChangedContent(config));
+            return rebuild(config);
         });
     }
     if (shouldWatch) {
-        /* Abort the watcher if stdin is closed to avoid zombie processes */ process.stdin.on('end', ()=>process.exit(0)
-        );
+        /* Abort the watcher if stdin is closed to avoid zombie processes */ process.stdin.on("end", ()=>process.exit(0));
         process.stdin.resume();
         startWatcher();
     } else {