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

package/lib/oxide/cli/build/watching.js

@@ -1,62 +1,179 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "createWatcher", {
-    enumerable: !0,
-    get: ()=>createWatcher
+    value: true
 });
-const _chokidar = _interopRequireDefault(require("chokidar")), _fs = _interopRequireDefault(require("fs")), _micromatch = _interopRequireDefault(require("micromatch")), _normalizePath = _interopRequireDefault(require("normalize-path")), _path = _interopRequireDefault(require("path")), _utils = require("./utils");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "createWatcher", {
+    enumerable: true,
+    get: function() {
+        return createWatcher;
+    }
+});
+const _chokidar = /*#__PURE__*/ _interop_require_default(require("chokidar"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _micromatch = /*#__PURE__*/ _interop_require_default(require("micromatch"));
+const _normalizepath = /*#__PURE__*/ _interop_require_default(require("normalize-path"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _utils = require("./utils");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function createWatcher(args, { state , rebuild  }) {
-    let _timer, _reject, shouldPoll = args["--poll"], shouldCoalesceWriteEvents = shouldPoll || "win32" === process.platform, watcher = _chokidar.default.watch([], {
-        atomic: !0,
+    let shouldPoll = args["--poll"];
+    let shouldCoalesceWriteEvents = shouldPoll || process.platform === "win32";
+    // Polling interval in milliseconds
+    // Used only when polling or coalescing add/change events on Windows
+    let pollInterval = 10;
+    let watcher = _chokidar.default.watch([], {
+        // 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 ? 10 : void 0,
-        ignoreInitial: !0,
-        awaitWriteFinish: !!shouldCoalesceWriteEvents && {
+        interval: shouldPoll ? pollInterval : undefined,
+        ignoreInitial: true,
+        awaitWriteFinish: shouldCoalesceWriteEvents ? {
             stabilityThreshold: 50,
-            pollInterval: 10
-        }
-    }), chain = Promise.resolve(), changedContent = [], pendingRebuilds = new Set();
-    async function rebuildAndContinue() {
+            pollInterval: pollInterval
+        } : false
+    });
+    // A queue of rebuilds, file reads, etc… to run
+    let chain = Promise.resolve();
+    /**
+   * A list of files that have been changed since the last rebuild
+   *
+   * @type {{file: string, content: () => Promise<string>, extension: string}[]}
+   */ let changedContent = [];
+    /**
+   * A list of files for which a rebuild has already been queued.
+   * This is used to prevent duplicate rebuilds when multiple events are fired for the same file.
+   * The rebuilt file is cleared from this list when it's associated rebuild has _started_
+   * This is because if the file is changed during a rebuild it won't trigger a new rebuild which it should
+   **/ let pendingRebuilds = new Set();
+    let _timer;
+    let _reject;
+    /**
+   * Rebuilds the changed files and resolves when the rebuild is
+   * complete regardless of whether it was successful or not
+   */ async function rebuildAndContinue() {
         let changes = changedContent.splice(0);
-        return 0 === changes.length ? Promise.resolve() : (changes.forEach((change)=>pendingRebuilds.delete(change.file)), rebuild(changes).then(()=>{}, ()=>{}));
+        // There are no changes to rebuild so we can just do nothing
+        if (changes.length === 0) {
+            return Promise.resolve();
+        }
+        // Clear all pending rebuilds for the about-to-be-built files
+        changes.forEach((change)=>pendingRebuilds.delete(change.file));
+        // Resolve the promise even when the rebuild fails
+        return rebuild(changes).then(()=>{}, ()=>{});
     }
-    function recordChangedFile(file, content = null, skipPendingCheck = !1) {
-        return (file = _path.default.resolve(file), pendingRebuilds.has(file) && !skipPendingCheck) ? Promise.resolve() : (pendingRebuilds.add(file), changedContent.push({
+    /**
+   *
+   * @param {*} file
+   * @param {(() => Promise<string>) | null} content
+   * @param {boolean} skipPendingCheck
+   * @returns {Promise<void>}
+   */ function recordChangedFile(file, content = null, skipPendingCheck = false) {
+        file = _path.default.resolve(file);
+        // Applications like Vim/Neovim fire both rename and change events in succession for atomic writes
+        // In that case rebuild has already been queued by rename, so can be skipped in change
+        if (pendingRebuilds.has(file) && !skipPendingCheck) {
+            return Promise.resolve();
+        }
+        // Mark that a rebuild of this file is going to happen
+        // It MUST happen synchronously before the rebuild is queued for this to be effective
+        pendingRebuilds.add(file);
+        changedContent.push({
             file,
-            content: null != content ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
+            content: content !== null && content !== void 0 ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
             extension: _path.default.extname(file).slice(1)
-        }), _timer && (clearTimeout(_timer), _reject()), chain = (chain = chain.then(()=>new Promise((resolve, reject)=>{
-                _timer = setTimeout(resolve, 10), _reject = reject;
-            }))).then(rebuildAndContinue, rebuildAndContinue));
+        });
+        if (_timer) {
+            clearTimeout(_timer);
+            _reject();
+        }
+        // If a rebuild is already in progress we don't want to start another one until the 10ms timer has expired
+        chain = chain.then(()=>new Promise((resolve, reject)=>{
+                _timer = setTimeout(resolve, 10);
+                _reject = reject;
+            }));
+        // Resolves once this file has been rebuilt (or the rebuild for this file has failed)
+        // This queues as many rebuilds as there are changed files
+        // But those rebuilds happen after some delay
+        // And will immediately resolve if there are no changes
+        chain = chain.then(rebuildAndContinue, rebuildAndContinue);
+        return chain;
     }
-    return watcher.on("change", (file)=>recordChangedFile(file)), watcher.on("add", (file)=>recordChangedFile(file)), watcher.on("unlink", (file)=>{
-        file = (0, _normalizePath.default)(file), _micromatch.default.some([
+    watcher.on("change", (file)=>recordChangedFile(file));
+    watcher.on("add", (file)=>recordChangedFile(file));
+    // 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
-        ], state.contentPatterns.dynamic) || watcher.add(file);
-    }), watcher.on("raw", (evt, filePath, meta)=>{
-        if ("rename" !== evt) return;
+        ], state.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;
-        filePath = watchedPath.endsWith(filePath) ? watchedPath : _path.default.join(watchedPath, filePath), !_micromatch.default.some([
+        // 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
-        ], state.contentPatterns.all) || pendingRebuilds.has(filePath) || (pendingRebuilds.add(filePath), (async function() {
+        ], state.contentPatterns.all)) {
+            return;
+        }
+        // Skip since we've already queued a rebuild for this file that hasn't happened yet
+        if (pendingRebuilds.has(filePath)) {
+            return;
+        }
+        // We'll go ahead and add the file to the pending rebuilds list here
+        // It'll be removed when the rebuild starts unless the read fails
+        // which will be taken care of as well
+        pendingRebuilds.add(filePath);
+        async function enqueue() {
             try {
+                // We need to read the file as early as possible outside of the chain
+                // because it may be gone by the time we get to it. doing the read
+                // immediately increases the chance that the file is still there
                 let content = await (0, _utils.readFileWithRetries)(_path.default.resolve(filePath));
-                if (void 0 === content) return;
-                await recordChangedFile(filePath, ()=>content, !0);
-            } catch  {}
-        })().then(()=>{
+                if (content === undefined) {
+                    return;
+                }
+                // This will push the rebuild onto the chain
+                // We MUST skip the rebuild check here otherwise the rebuild will never happen on Linux
+                // This is because the order of events and timing is different on Linux
+                // @ts-ignore: TypeScript isn't picking up that content is a string here
+                await recordChangedFile(filePath, ()=>content, true);
+            } catch  {
+            // If reading the file fails, it's was probably a deleted temporary file
+            // So we can ignore it and no rebuild is needed
+            }
+        }
+        enqueue().then(()=>{
+            // If the file read fails we still need to make sure the file isn't stuck in the pending rebuilds list
             pendingRebuilds.delete(filePath);
-        }));
-    }), {
+        });
+    });
+    return {
         fswatcher: watcher,
         refreshWatchedFiles () {
-            watcher.add(Array.from(state.contextDependencies)), watcher.add(Array.from(state.configBag.dependencies)), watcher.add(state.contentPatterns.all);
+            watcher.add(Array.from(state.contextDependencies));
+            watcher.add(Array.from(state.configBag.dependencies));
+            watcher.add(state.contentPatterns.all);
         }
     };
 }

package/lib/oxide/cli/help/index.js

@@ -1,28 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "help", {
-    enumerable: !0,
-    get: ()=>help
+    value: true
 });
-const _packageJson = function(obj) {
+Object.defineProperty(exports, "help", {
+    enumerable: true,
+    get: function() {
+        return help;
+    }
+});
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../../../package.json"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../../../../package.json"));
+}
 function help({ message , usage , commands , options  }) {
-    if (console.log(), console.log(`${_packageJson.default.name} v${_packageJson.default.version}`), message) for (let msg of (console.log(), message.split("\n")))console.log(msg);
-    if (usage && usage.length > 0) for (let example of (console.log(), console.log("Usage:"), usage))console.log(" ".repeat(2), example);
-    if (commands && commands.length > 0) for (let command of (console.log(), console.log("Commands:"), commands))console.log(" ".repeat(2), command);
+    let indent = 2;
+    // Render header
+    console.log();
+    console.log(`${_packagejson.default.name} v${_packagejson.default.version}`);
+    // Render message
+    if (message) {
+        console.log();
+        for (let msg of message.split("\n")){
+            console.log(msg);
+        }
+    }
+    // Render usage
+    if (usage && usage.length > 0) {
+        console.log();
+        console.log("Usage:");
+        for (let example of usage){
+            console.log(" ".repeat(indent), example);
+        }
+    }
+    // Render commands
+    if (commands && commands.length > 0) {
+        console.log();
+        console.log("Commands:");
+        for (let command of commands){
+            console.log(" ".repeat(indent), command);
+        }
+    }
+    // Render options
     if (options) {
         let groupedOptions = {};
-        for (let [key, value] of Object.entries(options))"object" == typeof value ? groupedOptions[key] = {
-            ...value,
-            flags: [
-                key
-            ]
-        } : groupedOptions[value].flags.push(key);
-        for (let { flags , description , deprecated  } of (console.log(), console.log("Options:"), Object.values(groupedOptions)))deprecated || (1 === flags.length ? console.log(" ".repeat(6), flags.slice().reverse().join(", ").padEnd(20, " "), description) : console.log(" ".repeat(2), flags.slice().reverse().join(", ").padEnd(24, " "), description));
+        for (let [key, value] of Object.entries(options)){
+            if (typeof value === "object") {
+                groupedOptions[key] = {
+                    ...value,
+                    flags: [
+                        key
+                    ]
+                };
+            } else {
+                groupedOptions[value].flags.push(key);
+            }
+        }
+        console.log();
+        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);
+            } else {
+                console.log(" ".repeat(indent), flags.slice().reverse().join(", ").padEnd(24, " "), description);
+            }
+        }
     }
     console.log();
 }

package/lib/oxide/cli/index.js

@@ -1,29 +1,48 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
+    value: true
 });
-const _path = _interopRequireDefault(require("path")), _arg = _interopRequireDefault(require("arg")), _fs = _interopRequireDefault(require("fs")), _build = require("./build"), _help = require("./help"), _init = require("./init");
-function _interopRequireDefault(obj) {
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _arg = /*#__PURE__*/ _interop_require_default(require("arg"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _build = require("./build");
+const _help = require("./help");
+const _init = require("./init");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+// ---
+function oneOf(...options) {
+    return Object.assign((value = true)=>{
+        for (let option of options){
+            let parsed = option(value);
+            if (parsed === value) {
+                return parsed;
+            }
+        }
+        throw new Error("...");
+    }, {
+        manualParsing: true
+    });
+}
 let commands = {
     init: {
         run: _init.init,
         args: {
             "--esm": {
                 type: Boolean,
-                description: "Initialize configuration file as ESM"
+                description: `Initialize configuration file as ESM`
             },
             "--ts": {
                 type: Boolean,
-                description: "Initialize configuration file as TypeScript"
+                description: `Initialize configuration file as TypeScript`
             },
             "--full": {
                 type: Boolean,
-                description: "Include the default values for all options in the generated configuration file"
+                description: `Include the default values for all options in the generated configuration file`
             },
             "-f": "--full"
         }
@@ -40,17 +59,7 @@ let commands = {
                 description: "Output file"
             },
             "--watch": {
-                type: function(...options) {
-                    return Object.assign((value = !0)=>{
-                        for (let option of options){
-                            let parsed = option(value);
-                            if (parsed === value) return parsed;
-                        }
-                        throw Error("...");
-                    }, {
-                        manualParsing: !0
-                    });
-                }(String, Boolean),
+                type: oneOf(String, Boolean),
                 description: "Watch for changes and rebuild as needed"
             },
             "--poll": {
@@ -77,77 +86,129 @@ let commands = {
             "-p": "--poll"
         }
     }
-}, sharedFlags = {
+};
+let sharedFlags = {
     "--help": {
         type: Boolean,
         description: "Display usage information"
     },
     "-h": "--help"
 };
-process.stdout.isTTY && (void 0 === process.argv[2] || process.argv.slice(2).every((flag)=>void 0 !== sharedFlags[flag])) && ((0, _help.help)({
-    usage: [
-        "tailwindcss [--input input.css] [--output output.css] [--watch] [options...]",
-        "tailwindcss init [--full] [options...]"
-    ],
-    commands: Object.keys(commands).filter((command)=>"build" !== command).map((command)=>`${command} [options]`),
-    options: {
-        ...commands.build.args,
-        ...sharedFlags
+if (process.stdout.isTTY /* Detect redirecting output to a file */  && (process.argv[2] === undefined || process.argv.slice(2).every((flag)=>sharedFlags[flag] !== undefined))) {
+    (0, _help.help)({
+        usage: [
+            "tailwindcss [--input input.css] [--output output.css] [--watch] [options...]",
+            "tailwindcss init [--full] [options...]"
+        ],
+        commands: Object.keys(commands).filter((command)=>command !== "build").map((command)=>`${command} [options]`),
+        options: {
+            ...commands.build.args,
+            ...sharedFlags
+        }
+    });
+    process.exit(0);
+}
+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.
+        command = "build";
+    } else {
+        (0, _help.help)({
+            message: `Invalid command: ${command}`,
+            usage: [
+                "tailwindcss <command> [options]"
+            ],
+            commands: Object.keys(commands).filter((command)=>command !== "build").map((command)=>`${command} [options]`),
+            options: sharedFlags
+        });
+        process.exit(1);
     }
-}), process.exit(0));
-let command = ((arg = "")=>arg.startsWith("-") ? void 0 : arg)(process.argv[2]) || "build";
-void 0 === commands[command] && (_fs.default.existsSync(_path.default.resolve(command)) ? command = "build" : ((0, _help.help)({
-    message: `Invalid command: ${command}`,
-    usage: [
-        "tailwindcss <command> [options]"
-    ],
-    commands: Object.keys(commands).filter((command)=>"build" !== command).map((command)=>`${command} [options]`),
-    options: sharedFlags
-}), process.exit(1)));
-let { args: flags , run  } = commands[command], args = (()=>{
+}
+// Execute command
+let { args: flags , run  } = commands[command];
+let args = (()=>{
     try {
         let result = (0, _arg.default)(Object.fromEntries(Object.entries({
             ...flags,
             ...sharedFlags
         }).filter(([_key, value])=>{
             var _value_type;
-            return !(null == value ? void 0 : null === (_value_type = value.type) || void 0 === _value_type ? void 0 : _value_type.manualParsing);
+            return !(value === null || value === void 0 ? void 0 : (_value_type = value.type) === null || _value_type === void 0 ? void 0 : _value_type.manualParsing);
         }).map(([key, value])=>[
                 key,
-                "object" == typeof value ? value.type : value
+                typeof value === "object" ? value.type : value
             ])), {
-            permissive: !0
+            permissive: true
         });
-        for(let i = result._.length - 1; i >= 0; --i){
-            let flag = result._[i];
+        // 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;
-            let [flagName, flagValue] = flag.split("="), handler = flags[flagName];
-            for(; "string" == typeof handler;)flagName = handler, handler = flags[handler];
+            let [flagName, flagValue] = flag.split("=");
+            let handler = flags[flagName];
+            // Resolve flagName & handler
+            while(typeof handler === "string"){
+                flagName = handler;
+                handler = flags[handler];
+            }
             if (!handler) continue;
-            let args = [], offset = i + 1;
-            if (void 0 === flagValue) {
-                for(; result._[offset] && !result._[offset].startsWith("-");)args.push(result._[offset++]);
-                result._.splice(i, 1 + args.length), flagValue = 0 === args.length ? void 0 : 1 === args.length ? args[0] : args;
-            } else result._.splice(i, 1);
+            let args = [];
+            let offset = i + 1;
+            // --flag value syntax was used so we need to pull `value` from `args`
+            if (flagValue === undefined) {
+                // Parse args for current flag
+                while(result["_"][offset] && !result["_"][offset].startsWith("-")){
+                    args.push(result["_"][offset++]);
+                }
+                // Cleanup manually parsed flags + args
+                result["_"].splice(i, 1 + args.length);
+                // No args were provided, use default value defined in handler
+                // One arg was provided, use that directly
+                // Multiple args were provided so pass them all in an array
+                flagValue = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
+            } else {
+                // Remove the whole flag from the args array
+                result["_"].splice(i, 1);
+            }
+            // Set the resolved value in the `result` object
             result[flagName] = handler.type(flagValue, flagName);
         }
-        return result._[0] !== command && result._.unshift(command), result;
+        // Ensure that the `command` is always the first argument in the `args`.
+        // This is important so that we don't have to check if a default command
+        // (build) was used or not from within each plugin.
+        //
+        // E.g.: tailwindcss input.css -> _: ['build', 'input.css']
+        // E.g.: tailwindcss build input.css -> _: ['build', 'input.css']
+        if (result["_"][0] !== command) {
+            result["_"].unshift(command);
+        }
+        return result;
     } catch (err) {
-        throw "ARG_UNKNOWN_OPTION" === err.code && ((0, _help.help)({
-            message: err.message,
-            usage: [
-                "tailwindcss <command> [options]"
-            ],
-            options: sharedFlags
-        }), process.exit(1)), err;
+        if (err.code === "ARG_UNKNOWN_OPTION") {
+            (0, _help.help)({
+                message: err.message,
+                usage: [
+                    "tailwindcss <command> [options]"
+                ],
+                options: sharedFlags
+            });
+            process.exit(1);
+        }
+        throw err;
     }
 })();
-args["--help"] && ((0, _help.help)({
-    options: {
-        ...flags,
-        ...sharedFlags
-    },
-    usage: [
-        `tailwindcss ${command} [options]`
-    ]
-}), process.exit(0)), run(args);
+if (args["--help"]) {
+    (0, _help.help)({
+        options: {
+            ...flags,
+            ...sharedFlags
+        },
+        usage: [
+            `tailwindcss ${command} [options]`
+        ]
+    });
+    process.exit(0);
+}
+run(args);

package/lib/oxide/cli/init/index.js

@@ -1,31 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "init", {
-    enumerable: !0,
-    get: ()=>init
+    value: true
 });
-const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "init", {
+    enumerable: true,
+    get: function() {
+        return init;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+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;
+    }
+}
 function init(args) {
+    let messages = [];
+    let isProjectESM = args["--ts"] || args["--esm"] || isESM();
+    let syntax = args["--ts"] ? "ts" : isProjectESM ? "js" : "cjs";
+    let extension = args["--ts"] ? "ts" : "js";
     var _args___;
-    let messages = [], isProjectESM = args["--ts"] || args["--esm"] || function() {
-        let pkgPath = _path.default.resolve("./package.json");
-        try {
-            let pkg = JSON.parse(_fs.default.readFileSync(pkgPath, "utf8"));
-            return pkg.type && "module" === pkg.type;
-        } catch (err) {
-            return !1;
+    let tailwindConfigLocation = _path.default.resolve((_args___ = args["_"][1]) !== null && _args___ !== void 0 ? _args___ : `./tailwind.config.${extension}`);
+    if (_fs.default.existsSync(tailwindConfigLocation)) {
+        messages.push(`${_path.default.basename(tailwindConfigLocation)} already exists.`);
+    } else {
+        let stubContentsFile = _fs.default.readFileSync(args["--full"] ? _path.default.resolve(__dirname, "../../../../stubs/config.full.js") : _path.default.resolve(__dirname, "../../../../stubs/config.simple.js"), "utf8");
+        let stubFile = _fs.default.readFileSync(_path.default.resolve(__dirname, `../../../../stubs/tailwind.config.${syntax}`), "utf8");
+        // Change colors import
+        stubContentsFile = stubContentsFile.replace("../colors", "tailwindcss/colors");
+        // Replace contents of {ts,js,cjs} file with the stub {simple,full}.
+        stubFile = stubFile.replace("__CONFIG__", stubContentsFile.replace("module.exports =", "").trim()).trim() + "\n\n";
+        _fs.default.writeFileSync(tailwindConfigLocation, stubFile, "utf8");
+        messages.push(`Created Tailwind CSS config file: ${_path.default.basename(tailwindConfigLocation)}`);
+    }
+    if (messages.length > 0) {
+        console.log();
+        for (let message of messages){
+            console.log(message);
         }
-    }(), syntax = args["--ts"] ? "ts" : isProjectESM ? "js" : "cjs", extension = args["--ts"] ? "ts" : "js", tailwindConfigLocation = _path.default.resolve(null !== (_args___ = args._[1]) && void 0 !== _args___ ? _args___ : `./tailwind.config.${extension}`);
-    if (_fs.default.existsSync(tailwindConfigLocation)) messages.push(`${_path.default.basename(tailwindConfigLocation)} already exists.`);
-    else {
-        let stubContentsFile = _fs.default.readFileSync(args["--full"] ? _path.default.resolve(__dirname, "../../../../stubs/config.full.js") : _path.default.resolve(__dirname, "../../../../stubs/config.simple.js"), "utf8"), stubFile = _fs.default.readFileSync(_path.default.resolve(__dirname, `../../../../stubs/tailwind.config.${syntax}`), "utf8");
-        stubContentsFile = stubContentsFile.replace("../colors", "tailwindcss/colors"), stubFile = stubFile.replace("__CONFIG__", stubContentsFile.replace("module.exports =", "").trim()).trim() + "\n\n", _fs.default.writeFileSync(tailwindConfigLocation, stubFile, "utf8"), messages.push(`Created Tailwind CSS config file: ${_path.default.basename(tailwindConfigLocation)}`);
     }
-    if (messages.length > 0) for (let message of (console.log(), messages))console.log(message);
 }

package/lib/oxide/cli.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), require("./cli/index");
+    value: true
+});
+require("./cli/index");