tailwindcss 0.0.0-insiders.b2dd6ff → 0.0.0-insiders.b2e3cf2

package/README.md

@@ -1,16 +1,20 @@
-<p>
-  <a href="https://tailwindcss.com/#gh-light-mode-only" target="_blank">
-    <img src="./.github/logo-light.svg" alt="Tailwind CSS" width="350" height="70">
-  </a>
-  <a href="https://tailwindcss.com/#gh-dark-mode-only" target="_blank">
-    <img src="./.github/logo-dark.svg" alt="Tailwind CSS" width="350" height="70">
+<p align="center">
+  <a href="https://tailwindcss.com" target="_blank">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/tailwindlabs/tailwindcss/HEAD/.github/logo-dark.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/tailwindlabs/tailwindcss/HEAD/.github/logo-light.svg">
+      <img alt="Tailwind CSS" src="https://raw.githubusercontent.com/tailwindlabs/tailwindcss/HEAD/.github/logo-light.svg" width="350" height="70" style="max-width: 100%;">
+    </picture>
   </a>
 </p>
 
-A utility-first CSS framework for rapidly building custom user interfaces.
+<p align="center">
+  A utility-first CSS framework for rapidly building custom user interfaces.
+</p>
+
 
-<p>
-    <a href="https://github.com/tailwindlabs/tailwindcss/actions"><img src="https://img.shields.io/github/workflow/status/tailwindlabs/tailwindcss/Node.js%20CI" alt="Build Status"></a>
+<p align="center">
+    <a href="https://github.com/tailwindlabs/tailwindcss/actions"><img src="https://img.shields.io/github/actions/workflow/status/tailwindlabs/tailwindcss/ci-stable.yml?branch=master" alt="Build Status"></a>
     <a href="https://www.npmjs.com/package/tailwindcss"><img src="https://img.shields.io/npm/dt/tailwindcss.svg" alt="Total Downloads"></a>
     <a href="https://github.com/tailwindcss/tailwindcss/releases"><img src="https://img.shields.io/npm/v/tailwindcss.svg" alt="Latest Release"></a>
     <a href="https://github.com/tailwindcss/tailwindcss/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/tailwindcss.svg" alt="License"></a>

package/defaultTheme.d.ts

@@ -1,3 +1,4 @@
 import type { Config } from './types/config'
-declare const theme: Config['theme']
+import { DefaultTheme } from './types/generated/default-theme'
+declare const theme: Config['theme'] & DefaultTheme
 export = theme

package/lib/cli/build/deps.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), function(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: !0,
+        get: all[name]
+    });
+}(exports, {
+    loadPostcss: ()=>loadPostcss,
+    loadPostcssImport: ()=>loadPostcssImport,
+    loadCssNano: ()=>loadCssNano,
+    loadAutoprefixer: ()=>loadAutoprefixer
+});
+const _indexJs = require("../../../peers/index.js");
+function loadPostcss() {
+    try {
+        return require("postcss");
+    } catch  {}
+    return (0, _indexJs.lazyPostcss)();
+}
+function loadPostcssImport() {
+    try {
+        return require("postcss-import");
+    } catch  {}
+    return (0, _indexJs.lazyPostcssImport)();
+}
+function loadCssNano() {
+    try {
+        return require("cssnano");
+    } catch  {}
+    return (0, _indexJs.lazyCssnano)()({
+        preset: [
+            "default",
+            {
+                cssDeclarationSorter: !1
+            }
+        ]
+    });
+}
+function loadAutoprefixer() {
+    try {
+        return require("autoprefixer");
+    } catch  {}
+    return (0, _indexJs.lazyAutoprefixer)();
+}

package/lib/cli/build/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), Object.defineProperty(exports, "build", {
+    enumerable: !0,
+    get: ()=>build
+});
+const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path")), _resolveConfigPathJs = require("../../util/resolveConfigPath.js"), _pluginJs = require("./plugin.js");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function build(args) {
+    let input = args["--input"], shouldWatch = args["--watch"];
+    !input && args._[1] && (console.error("[deprecation] Running tailwindcss without -i, please provide an input file."), input = args["--input"] = args._[1]), input && "-" !== input && !_fs.default.existsSync(input = _path.default.resolve(input)) && (console.error(`Specified input file ${args["--input"]} does not exist.`), process.exit(9)), 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 processor = await (0, _pluginJs.createProcessor)(args, args["--config"] ? args["--config"] : (0, _resolveConfigPathJs.resolveDefaultConfigPath)());
+    shouldWatch ? ("always" !== args["--watch"] && process.stdin.on("end", ()=>process.exit(0)), process.stdin.resume(), await processor.watch()) : await processor.build().catch((e)=>{
+        console.error(e), process.exit(1);
+    });
+}

package/lib/cli/build/plugin.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), Object.defineProperty(exports, "createProcessor", {
+    enumerable: !0,
+    get: ()=>createProcessor
+});
+const _path = _interopRequireDefault(require("path")), _fs = _interopRequireDefault(require("fs")), _postcssLoadConfig = _interopRequireDefault(require("postcss-load-config")), _lilconfig = require("lilconfig"), _plugins = _interopRequireDefault(require("postcss-load-config/src/plugins")), _options = _interopRequireDefault(require("postcss-load-config/src/options")), _processTailwindFeatures = _interopRequireDefault(require("../../processTailwindFeatures")), _deps = require("./deps"), _utils = require("./utils"), _sharedState = require("../../lib/sharedState"), _resolveConfigJs = _interopRequireDefault(require("../../../resolveConfig.js")), _contentJs = require("../../lib/content.js"), _watchingJs = require("./watching.js"), _fastGlob = _interopRequireDefault(require("fast-glob")), _findAtConfigPathJs = require("../../lib/findAtConfigPath.js"), _log = _interopRequireDefault(require("../../util/log")), _loadConfig = require("../../lib/load-config"), _getModuleDependencies = _interopRequireDefault(require("../../lib/getModuleDependencies"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function loadPostCssPlugins(customPostCssPath) {
+    let config = customPostCssPath ? await (async ()=>{
+        let file = _path.default.resolve(customPostCssPath), { config ={}  } = await (0, _lilconfig.lilconfig)("postcss").load(file);
+        return (config = "function" == typeof config ? config() : Object.assign({}, config)).plugins || (config.plugins = []), {
+            file,
+            plugins: (0, _plugins.default)(config, file),
+            options: (0, _options.default)(config, file)
+        };
+    })() : await (0, _postcssLoadConfig.default)(), configPlugins = config.plugins, configPluginTailwindIdx = configPlugins.findIndex((plugin)=>"function" == typeof plugin && "tailwindcss" === plugin.name || "object" == typeof plugin && null !== plugin && "tailwindcss" === plugin.postcssPlugin);
+    return [
+        -1 === configPluginTailwindIdx ? [] : configPlugins.slice(0, configPluginTailwindIdx),
+        -1 === configPluginTailwindIdx ? configPlugins : configPlugins.slice(configPluginTailwindIdx + 1),
+        config.options
+    ];
+}
+let state = {
+    context: null,
+    watcher: null,
+    changedContent: [],
+    configBag: null,
+    contextDependencies: new Set(),
+    contentPaths: [],
+    refreshContentPaths () {
+        var _this_context;
+        this.contentPaths = (0, _contentJs.parseCandidateFiles)(this.context, null === (_this_context = this.context) || void 0 === _this_context ? void 0 : _this_context.tailwindConfig);
+    },
+    get config () {
+        return this.context.tailwindConfig;
+    },
+    get contentPatterns () {
+        return {
+            all: this.contentPaths.map((contentPath)=>contentPath.pattern),
+            dynamic: this.contentPaths.filter((contentPath)=>void 0 !== contentPath.glob).map((contentPath)=>contentPath.pattern)
+        };
+    },
+    loadConfig (configPath, content) {
+        this.watcher && configPath && this.refreshConfigDependencies();
+        let config = (0, _loadConfig.loadConfig)(configPath), dependencies = (0, _getModuleDependencies.default)(configPath);
+        return this.configBag = {
+            config,
+            dependencies,
+            dispose () {
+                for (let file of dependencies)delete require.cache[require.resolve(file)];
+            }
+        }, this.configBag.config = (0, _resolveConfigJs.default)(this.configBag.config, {
+            content: {
+                files: []
+            }
+        }), (null == content ? void 0 : content.length) > 0 && (this.configBag.config.content.files = content), this.configBag.config;
+    },
+    refreshConfigDependencies () {
+        var _this_configBag;
+        _sharedState.env.DEBUG && console.time("Module dependencies"), null === (_this_configBag = this.configBag) || void 0 === _this_configBag || _this_configBag.dispose(), _sharedState.env.DEBUG && console.timeEnd("Module dependencies");
+    },
+    readContentPaths () {
+        let content = [];
+        for (let file of _fastGlob.default.sync(this.contentPatterns.all))content.push({
+            content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
+            extension: _path.default.extname(file).slice(1)
+        });
+        for (let { raw: htmlContent , extension ="html"  } of this.config.content.files.filter((file)=>null !== file && "object" == typeof file))content.push({
+            content: htmlContent,
+            extension
+        });
+        return content;
+    },
+    getContext ({ createContext , cliConfigPath , root , result , content  }) {
+        var _findAtConfigPath;
+        if (this.context) return this.context.changedContent = this.changedContent.splice(0), this.context;
+        _sharedState.env.DEBUG && console.time("Searching for config");
+        let configPath = null !== (_findAtConfigPath = (0, _findAtConfigPathJs.findAtConfigPath)(root, result)) && void 0 !== _findAtConfigPath ? _findAtConfigPath : cliConfigPath;
+        _sharedState.env.DEBUG && console.timeEnd("Searching for config"), _sharedState.env.DEBUG && console.time("Loading config");
+        let config = this.loadConfig(configPath, content);
+        for (let file of (_sharedState.env.DEBUG && console.timeEnd("Loading config"), _sharedState.env.DEBUG && console.time("Creating context"), this.context = createContext(config, []), Object.assign(this.context, {
+            userConfigPath: configPath
+        }), _sharedState.env.DEBUG && console.timeEnd("Creating context"), _sharedState.env.DEBUG && console.time("Resolving content paths"), this.refreshContentPaths(), _sharedState.env.DEBUG && console.timeEnd("Resolving content paths"), this.watcher && (_sharedState.env.DEBUG && console.time("Watch new files"), this.watcher.refreshWatchedFiles(), _sharedState.env.DEBUG && console.timeEnd("Watch new files")), this.readContentPaths()))this.context.changedContent.push(file);
+        return this.context;
+    }
+};
+async function createProcessor(args, cliConfigPath) {
+    var _args_content, _args_content_split;
+    let postcss, IMPORT_COMMENT;
+    let postcss1 = (0, _deps.loadPostcss)(), input = args["--input"], output = args["--output"], includePostCss = args["--postcss"], customPostCssPath = "string" == typeof args["--postcss"] ? args["--postcss"] : void 0, [beforePlugins, afterPlugins, postcssOptions] = includePostCss ? await loadPostCssPlugins(customPostCssPath) : (postcss = (0, _deps.loadPostcss)(), IMPORT_COMMENT = "__TAILWIND_RESTORE_IMPORT__: ", [
+        [
+            (root)=>{
+                root.walkAtRules("import", (rule)=>{
+                    rule.params.slice(1).startsWith("tailwindcss/") && (rule.after(postcss.comment({
+                        text: IMPORT_COMMENT + rule.params
+                    })), rule.remove());
+                });
+            },
+            (0, _deps.loadPostcssImport)(),
+            (root)=>{
+                root.walkComments((rule)=>{
+                    rule.text.startsWith(IMPORT_COMMENT) && (rule.after(postcss.atRule({
+                        name: "import",
+                        params: rule.text.replace(IMPORT_COMMENT, "")
+                    })), rule.remove());
+                });
+            }
+        ],
+        [],
+        {}
+    ]);
+    args["--purge"] && (_log.default.warn("purge-flag-deprecated", [
+        "The `--purge` flag has been deprecated.",
+        "Please use `--content` instead."
+    ]), args["--content"] || (args["--content"] = args["--purge"]));
+    let content = null !== (_args_content_split = null === (_args_content = args["--content"]) || void 0 === _args_content ? void 0 : _args_content.split(/(?<!{[^}]+),/)) && void 0 !== _args_content_split ? _args_content_split : [], tailwindPlugin = ()=>({
+            postcssPlugin: "tailwindcss",
+            Once (root, { result  }) {
+                _sharedState.env.DEBUG && console.time("Compiling CSS"), (0, _processTailwindFeatures.default)(({ createContext  })=>(console.error(), console.error("Rebuilding..."), ()=>state.getContext({
+                            createContext,
+                            cliConfigPath,
+                            root,
+                            result,
+                            content
+                        })))(root, result), _sharedState.env.DEBUG && console.timeEnd("Compiling CSS");
+            }
+        });
+    tailwindPlugin.postcss = !0;
+    let processor = postcss1([
+        ...beforePlugins,
+        tailwindPlugin,
+        !args["--minify"] && _utils.formatNodes,
+        ...afterPlugins,
+        !args["--no-autoprefixer"] && (0, _deps.loadAutoprefixer)(),
+        args["--minify"] && (0, _deps.loadCssNano)()
+    ].filter(Boolean));
+    async function readInput() {
+        return "-" === input ? (0, _utils.drainStdin)() : input ? _fs.default.promises.readFile(_path.default.resolve(input), "utf8") : "@tailwind base; @tailwind components; @tailwind utilities";
+    }
+    async function build() {
+        let start = process.hrtime.bigint();
+        return readInput().then((css)=>processor.process(css, {
+                ...postcssOptions,
+                from: input,
+                to: output
+            })).then((result)=>{
+            if (!state.watcher) return result;
+            for (let message of (_sharedState.env.DEBUG && console.time("Recording PostCSS dependencies"), result.messages))"dependency" === message.type && state.contextDependencies.add(message.file);
+            return _sharedState.env.DEBUG && console.timeEnd("Recording PostCSS dependencies"), _sharedState.env.DEBUG && console.time("Watch new files"), state.watcher.refreshWatchedFiles(), _sharedState.env.DEBUG && console.timeEnd("Watch new files"), result;
+        }).then((result)=>{
+            if (!output) {
+                process.stdout.write(result.css);
+                return;
+            }
+            return Promise.all([
+                (0, _utils.outputFile)(result.opts.to, result.css),
+                result.map && (0, _utils.outputFile)(result.opts.to + ".map", result.map.toString())
+            ]);
+        }).then(()=>{
+            let end = process.hrtime.bigint();
+            console.error(), console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
+        }).then(()=>{}, (err)=>{
+            if (!state.watcher) return Promise.reject(err);
+            console.error(err);
+        });
+    }
+    async function parseChanges(changes) {
+        return Promise.all(changes.map(async (change)=>({
+                content: await change.content(),
+                extension: change.extension
+            })));
+    }
+    return void 0 !== input && "-" !== input && state.contextDependencies.add(_path.default.resolve(input)), {
+        build,
+        watch: async ()=>{
+            state.watcher = (0, _watchingJs.createWatcher)(args, {
+                state,
+                async rebuild (changes) {
+                    if (changes.some((change)=>{
+                        var _state_configBag;
+                        return (null === (_state_configBag = state.configBag) || void 0 === _state_configBag ? void 0 : _state_configBag.dependencies.has(change.file)) || state.contextDependencies.has(change.file);
+                    })) state.context = null;
+                    else for (let change of (await parseChanges(changes)))state.changedContent.push(change);
+                    return build();
+                }
+            }), await build();
+        }
+    };
+}

package/lib/cli/build/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), function(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: !0,
+        get: all[name]
+    });
+}(exports, {
+    indentRecursive: ()=>indentRecursive,
+    formatNodes: ()=>formatNodes,
+    readFileWithRetries: ()=>readFileWithRetries,
+    drainStdin: ()=>drainStdin,
+    outputFile: ()=>outputFile
+});
+const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function indentRecursive(node, indent = 0) {
+    node.each && node.each((child, i)=>{
+        (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) && (child.raws.before = `\n${"rule" !== node.type && i > 0 ? "\n" : ""}${"  ".repeat(indent)}`), child.raws.after = `\n${"  ".repeat(indent)}`, indentRecursive(child, indent + 1);
+    });
+}
+function formatNodes(root) {
+    indentRecursive(root), root.first && (root.first.raws.before = "");
+}
+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 && ("ENOENT" === err.code || "EBUSY" === err.code)) {
+            await new Promise((resolve)=>setTimeout(resolve, 10));
+            continue;
+        }
+        throw err;
+    }
+}
+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));
+    });
+}
+async function outputFile(file, newContents) {
+    try {
+        if (await _fs.default.promises.readFile(file, "utf8") === newContents) return;
+    } catch  {}
+    await _fs.default.promises.mkdir(_path.default.dirname(file), {
+        recursive: !0
+    }), await _fs.default.promises.writeFile(file, newContents, "utf8");
+}

package/lib/cli/build/watching.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), Object.defineProperty(exports, "createWatcher", {
+    enumerable: !0,
+    get: ()=>createWatcher
+});
+const _chokidar = _interopRequireDefault(require("chokidar")), _fs = _interopRequireDefault(require("fs")), _micromatch = _interopRequireDefault(require("micromatch")), _normalizePath = _interopRequireDefault(require("normalize-path")), _path = _interopRequireDefault(require("path")), _utilsJs = require("./utils.js");
+function _interopRequireDefault(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,
+        usePolling: shouldPoll,
+        interval: shouldPoll ? 10 : void 0,
+        ignoreInitial: !0,
+        awaitWriteFinish: !!shouldCoalesceWriteEvents && {
+            stabilityThreshold: 50,
+            pollInterval: 10
+        }
+    }), chain = Promise.resolve(), changedContent = [], pendingRebuilds = new Set();
+    async function rebuildAndContinue() {
+        let changes = changedContent.splice(0);
+        return 0 === changes.length ? Promise.resolve() : (changes.forEach((change)=>pendingRebuilds.delete(change.file)), rebuild(changes).then(()=>{}, (e)=>{
+            console.error(e.toString());
+        }));
+    }
+    function recordChangedFile(file, content = null, skipPendingCheck = !1) {
+        return (file = _path.default.resolve(file), pendingRebuilds.has(file) && !skipPendingCheck) ? Promise.resolve() : (pendingRebuilds.add(file), changedContent.push({
+            file,
+            content: null != content ? 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));
+    }
+    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([
+            file
+        ], state.contentPatterns.dynamic) || watcher.add(file);
+    }), watcher.on("raw", (evt, filePath, meta)=>{
+        if ("rename" !== evt) return;
+        let watchedPath = meta.watchedPath;
+        async function enqueue() {
+            try {
+                let content = await (0, _utilsJs.readFileWithRetries)(_path.default.resolve(filePath));
+                if (void 0 === content) return;
+                await recordChangedFile(filePath, ()=>content, !0);
+            } catch  {}
+        }
+        filePath = watchedPath.endsWith(filePath) ? watchedPath : _path.default.join(watchedPath, filePath), _micromatch.default.some([
+            filePath
+        ], state.contentPatterns.all) && (pendingRebuilds.has(filePath) || (pendingRebuilds.add(filePath), enqueue().then(()=>{
+            pendingRebuilds.delete(filePath);
+        })));
+    }), {
+        fswatcher: watcher,
+        refreshWatchedFiles () {
+            watcher.add(Array.from(state.contextDependencies)), watcher.add(Array.from(state.configBag.dependencies)), watcher.add(state.contentPatterns.all);
+        }
+    };
+}

package/lib/cli/help/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), Object.defineProperty(exports, "help", {
+    enumerable: !0,
+    get: ()=>help
+});
+const _packageJson = function(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);
+    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));
+    }
+    console.log();
+}

package/lib/cli/index.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+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) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function oneOf(...options) {
+    return Object.assign((value = !0)=>{
+        for (let option of options){
+            let parsed = option(value);
+            if (parsed === value) return parsed;
+        }
+        throw Error("...");
+    }, {
+        manualParsing: !0
+    });
+}
+let commands = {
+    init: {
+        run: _init.init,
+        args: {
+            "--esm": {
+                type: Boolean,
+                description: "Initialize configuration file as ESM"
+            },
+            "--ts": {
+                type: Boolean,
+                description: "Initialize configuration file as TypeScript"
+            },
+            "--postcss": {
+                type: Boolean,
+                description: "Initialize a `postcss.config.js` file"
+            },
+            "--full": {
+                type: Boolean,
+                description: "Include the default values for all options in the generated configuration file"
+            },
+            "-f": "--full",
+            "-p": "--postcss"
+        }
+    },
+    build: {
+        run: _build.build,
+        args: {
+            "--input": {
+                type: String,
+                description: "Input file"
+            },
+            "--output": {
+                type: String,
+                description: "Output file"
+            },
+            "--watch": {
+                type: oneOf(String, Boolean),
+                description: "Watch for changes and rebuild as needed"
+            },
+            "--poll": {
+                type: Boolean,
+                description: "Use polling instead of filesystem events when watching"
+            },
+            "--content": {
+                type: String,
+                description: "Content paths to use for removing unused classes"
+            },
+            "--purge": {
+                type: String,
+                deprecated: !0
+            },
+            "--postcss": {
+                type: oneOf(String, Boolean),
+                description: "Load custom PostCSS configuration"
+            },
+            "--minify": {
+                type: Boolean,
+                description: "Minify the output"
+            },
+            "--config": {
+                type: String,
+                description: "Path to a custom config file"
+            },
+            "--no-autoprefixer": {
+                type: Boolean,
+                description: "Disable autoprefixer"
+            },
+            "-c": "--config",
+            "-i": "--input",
+            "-o": "--output",
+            "-m": "--minify",
+            "-w": "--watch",
+            "-p": "--poll"
+        }
+    }
+}, 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] [--postcss] [options...]"
+    ],
+    commands: Object.keys(commands).filter((command)=>"build" !== command).map((command)=>`${command} [options]`),
+    options: {
+        ...commands.build.args,
+        ...sharedFlags
+    }
+}), 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 = (()=>{
+    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);
+        }).map(([key, value])=>[
+                key,
+                "object" == typeof value ? value.type : value
+            ])), {
+            permissive: !0
+        });
+        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];
+            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);
+            result[flagName] = handler.type(flagValue, flagName);
+        }
+        return result._[0] !== command && result._.unshift(command), 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;
+    }
+})();
+args["--help"] && ((0, _help.help)({
+    options: {
+        ...flags,
+        ...sharedFlags
+    },
+    usage: [
+        `tailwindcss ${command} [options]`
+    ]
+}), process.exit(0)), run(args);