tailwindcss 3.2.4 → 3.2.5

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

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createProcessor", {
+    enumerable: true,
+    get: ()=>createProcessor
+});
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+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 _deps = require("./deps");
+const _utils = require("./utils");
+const _sharedState = require("../../../lib/sharedState");
+const _resolveConfig = /*#__PURE__*/ _interopRequireDefault(require("../../../../resolveConfig"));
+const _getModuleDependencies = /*#__PURE__*/ _interopRequireDefault(require("../../../lib/getModuleDependencies"));
+const _content = require("../../../lib/content");
+const _watching = require("./watching");
+const _fastGlob = /*#__PURE__*/ _interopRequireDefault(require("fast-glob"));
+const _findAtConfigPath = require("../../../lib/findAtConfigPath");
+const _log = /*#__PURE__*/ _interopRequireDefault(require("../../../util/log"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ *
+ * @param {string} [customPostCssPath ]
+ * @returns
+ */ async function loadPostCssPlugins(customPostCssPath) {
+    let config = customPostCssPath ? await (async ()=>{
+        let file = _path.default.resolve(customPostCssPath);
+        // Implementation, see: https://unpkg.com/browse/postcss-load-config@3.1.0/src/index.js
+        // @ts-ignore
+        let { config ={}  } = await (0, _lilconfig.lilconfig)("postcss").load(file);
+        if (typeof config === "function") {
+            config = config();
+        } else {
+            config = Object.assign({}, config);
+        }
+        if (!config.plugins) {
+            config.plugins = [];
+        }
+        return {
+            file,
+            plugins: (0, _plugins.default)(config, file),
+            options: (0, _options.default)(config, file)
+        };
+    })() : await (0, _postcssLoadConfig.default)();
+    let configPlugins = config.plugins;
+    let configPluginTailwindIdx = configPlugins.findIndex((plugin)=>{
+        if (typeof plugin === "function" && plugin.name === "tailwindcss") {
+            return true;
+        }
+        if (typeof plugin === "object" && plugin !== null && plugin.postcssPlugin === "tailwindcss") {
+            return true;
+        }
+        return false;
+    });
+    let beforePlugins = configPluginTailwindIdx === -1 ? [] : configPlugins.slice(0, configPluginTailwindIdx);
+    let afterPlugins = configPluginTailwindIdx === -1 ? configPlugins : configPlugins.slice(configPluginTailwindIdx + 1);
+    return [
+        beforePlugins,
+        afterPlugins,
+        config.options
+    ];
+}
+function loadBuiltinPostcssPlugins() {
+    let postcss = (0, _deps.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();
+                    }
+                });
+            },
+            (0, _deps.loadPostcssImport)(),
+            (root)=>{
+                root.walkComments((rule)=>{
+                    if (rule.text.startsWith(IMPORT_COMMENT)) {
+                        rule.after(postcss.atRule({
+                            name: "import",
+                            params: rule.text.replace(IMPORT_COMMENT, "")
+                        }));
+                        rule.remove();
+                    }
+                });
+            }
+        ],
+        [],
+        {}
+    ];
+}
+let state = {
+    /** @type {any} */ context: null,
+    /** @type {ReturnType<typeof createWatcher> | null} */ watcher: null,
+    /** @type {{content: string, extension: string}[]} */ changedContent: [],
+    configDependencies: new Set(),
+    contextDependencies: new Set(),
+    /** @type {import('../../lib/content.js').ContentPath[]} */ contentPaths: [],
+    refreshContentPaths () {
+        var _this_context;
+        this.contentPaths = (0, _content.parseCandidateFiles)(this.context, (_this_context = this.context) === null || _this_context === void 0 ? 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)=>contentPath.glob !== undefined).map((contentPath)=>contentPath.pattern)
+        };
+    },
+    loadConfig (configPath, content) {
+        if (this.watcher && configPath) {
+            this.refreshConfigDependencies(configPath);
+        }
+        let config = configPath ? require(configPath) : {};
+        // @ts-ignore
+        config = (0, _resolveConfig.default)(config, {
+            content: {
+                files: []
+            }
+        });
+        // Override content files if `--content` has been passed explicitly
+        if ((content === null || content === void 0 ? void 0 : content.length) > 0) {
+            config.content.files = content;
+        }
+        return config;
+    },
+    refreshConfigDependencies (configPath) {
+        _sharedState.env.DEBUG && console.time("Module dependencies");
+        for (let file of this.configDependencies){
+            delete require.cache[require.resolve(file)];
+        }
+        if (configPath) {
+            let deps = (0, _getModuleDependencies.default)(configPath).map(({ file  })=>file);
+            for (let dependency of deps){
+                this.configDependencies.add(dependency);
+            }
+        }
+        _sharedState.env.DEBUG && console.timeEnd("Module dependencies");
+    },
+    readContentPaths () {
+        let content = [];
+        // Resolve globs from the content config
+        // TODO: When we make the postcss plugin async-capable this can become async
+        let files = _fastGlob.default.sync(this.contentPatterns.all);
+        for (let file of files){
+            if (_sharedState.env.OXIDE) {
+                content.push({
+                    file,
+                    extension: _path.default.extname(file).slice(1)
+                });
+            } else {
+                content.push({
+                    content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
+                    extension: _path.default.extname(file).slice(1)
+                });
+            }
+        }
+        // Resolve raw content in the tailwind config
+        let rawContent = this.config.content.files.filter((file)=>{
+            return file !== null && typeof file === "object";
+        });
+        for (let { raw: htmlContent , extension ="html"  } of rawContent){
+            content.push({
+                content: htmlContent,
+                extension
+            });
+        }
+        return content;
+    },
+    getContext ({ createContext , cliConfigPath , root , result , content  }) {
+        if (this.context) {
+            this.context.changedContent = this.changedContent.splice(0);
+            return this.context;
+        }
+        _sharedState.env.DEBUG && console.time("Searching for config");
+        var _findAtConfigPath1;
+        let configPath = (_findAtConfigPath1 = (0, _findAtConfigPath.findAtConfigPath)(root, result)) !== null && _findAtConfigPath1 !== void 0 ? _findAtConfigPath1 : cliConfigPath;
+        _sharedState.env.DEBUG && console.timeEnd("Searching for config");
+        _sharedState.env.DEBUG && console.time("Loading config");
+        let config = this.loadConfig(configPath, content);
+        _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");
+        if (this.watcher) {
+            _sharedState.env.DEBUG && console.time("Watch new files");
+            this.watcher.refreshWatchedFiles();
+            _sharedState.env.DEBUG && console.timeEnd("Watch new files");
+        }
+        for (let file of this.readContentPaths()){
+            this.context.changedContent.push(file);
+        }
+        return this.context;
+    }
+};
+async function createProcessor(args, cliConfigPath) {
+    var _args_content;
+    let postcss = (0, _deps.loadPostcss)();
+    let input = args["--input"];
+    let output = args["--output"];
+    let includePostCss = args["--postcss"];
+    let customPostCssPath = typeof args["--postcss"] === "string" ? args["--postcss"] : undefined;
+    let [beforePlugins, afterPlugins, postcssOptions] = includePostCss ? await loadPostCssPlugins(customPostCssPath) : loadBuiltinPostcssPlugins();
+    if (args["--purge"]) {
+        _log.default.warn("purge-flag-deprecated", [
+            "The `--purge` flag has been deprecated.",
+            "Please use `--content` instead."
+        ]);
+        if (!args["--content"]) {
+            args["--content"] = args["--purge"];
+        }
+    }
+    var _args_content_split;
+    let content = (_args_content_split = (_args_content = args["--content"]) === null || _args_content === void 0 ? void 0 : _args_content.split(/(?<!{[^}]+),/)) !== null && _args_content_split !== void 0 ? _args_content_split : [];
+    let tailwindPlugin = ()=>{
+        return {
+            postcssPlugin: "tailwindcss",
+            Once (root, { result  }) {
+                _sharedState.env.DEBUG && console.time("Compiling CSS");
+                (0, _processTailwindFeatures.default)(({ createContext  })=>{
+                    console.error();
+                    console.error("Rebuilding...");
+                    return ()=>{
+                        return state.getContext({
+                            createContext,
+                            cliConfigPath,
+                            root,
+                            result,
+                            content
+                        });
+                    };
+                })(root, result);
+                _sharedState.env.DEBUG && console.timeEnd("Compiling CSS");
+            }
+        };
+    };
+    tailwindPlugin.postcss = true;
+    let plugins = [
+        ...beforePlugins,
+        tailwindPlugin,
+        !args["--minify"] && _utils.formatNodes,
+        ...afterPlugins
+    ].filter(Boolean);
+    /** @type {import('postcss').Processor} */ // @ts-ignore
+    let processor = postcss(plugins);
+    async function readInput() {
+        // Piping in data, let's drain the stdin
+        if (input === "-") {
+            return (0, _utils.drainStdin)();
+        }
+        // Input file has been provided
+        if (input) {
+            return _fs.default.promises.readFile(_path.default.resolve(input), "utf8");
+        }
+        // No input file provided, fallback to default atrules
+        return "@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)=>(0, _deps.lightningcss)(!!args["--minify"], result)).then((result)=>{
+            if (!state.watcher) {
+                return result;
+            }
+            _sharedState.env.DEBUG && console.time("Recording PostCSS dependencies");
+            for (let message of result.messages){
+                if (message.type === "dependency") {
+                    state.contextDependencies.add(message.file);
+                }
+            }
+            _sharedState.env.DEBUG && console.timeEnd("Recording PostCSS dependencies");
+            // TODO: This needs to be in a different spot
+            _sharedState.env.DEBUG && console.time("Watch new files");
+            state.watcher.refreshWatchedFiles();
+            _sharedState.env.DEBUG && console.timeEnd("Watch new files");
+            return 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)=>{
+            // TODO: If an initial build fails we can't easily pick up any PostCSS dependencies
+            // that were collected before the error occurred
+            // The result is not stored on the error so we have to store it externally
+            // and pull the messages off of it here somehow
+            // This results in a less than ideal DX because the watcher will not pick up
+            // changes to imported CSS if one of them caused an error during the initial build
+            // If you fix it and then save the main CSS file so there's no error
+            // The watcher will start watching the imported CSS files and will be
+            // resilient to future errors.
+            console.error(err);
+        });
+    }
+    /**
+   * @param {{file: string, content(): Promise<string>, extension: string}[]} changes
+   */ async function parseChanges(changes) {
+        return Promise.all(changes.map(async (change)=>({
+                content: await change.content(),
+                extension: change.extension
+            })));
+    }
+    if (input !== undefined && input !== "-") {
+        state.contextDependencies.add(_path.default.resolve(input));
+    }
+    return {
+        build,
+        watch: async ()=>{
+            state.watcher = (0, _watching.createWatcher)(args, {
+                state,
+                /**
+         * @param {{file: string, content(): Promise<string>, extension: string}[]} changes
+         */ async rebuild (changes) {
+                    let needsNewContext = changes.some((change)=>{
+                        return state.configDependencies.has(change.file) || state.contextDependencies.has(change.file);
+                    });
+                    if (needsNewContext) {
+                        state.context = null;
+                    } else {
+                        for (let change of (await parseChanges(changes))){
+                            state.changedContent.push(change);
+                        }
+                    }
+                    return build();
+                }
+            });
+            await build();
+        }
+    };
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    indentRecursive: ()=>indentRecursive,
+    formatNodes: ()=>formatNodes,
+    readFileWithRetries: ()=>readFileWithRetries,
+    drainStdin: ()=>drainStdin,
+    outputFile: ()=>outputFile
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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)}`;
+        }
+        child.raws.after = `\n${"  ".repeat(indent)}`;
+        indentRecursive(child, indent + 1);
+    });
+}
+function formatNodes(root) {
+    indentRecursive(root);
+    if (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) {
+                if (err.code === "ENOENT" || err.code === "EBUSY") {
+                    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 {
+        let currentContents = await _fs.default.promises.readFile(file, "utf8");
+        if (currentContents === newContents) {
+            return; // Skip writing the file
+        }
+    } catch  {}
+    // Write the file
+    await _fs.default.promises.mkdir(_path.default.dirname(file), {
+        recursive: true
+    });
+    await _fs.default.promises.writeFile(file, newContents, "utf8");
+}

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createWatcher", {
+    enumerable: true,
+    get: ()=>createWatcher
+});
+const _chokidar = /*#__PURE__*/ _interopRequireDefault(require("chokidar"));
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _micromatch = /*#__PURE__*/ _interopRequireDefault(require("micromatch"));
+const _normalizePath = /*#__PURE__*/ _interopRequireDefault(require("normalize-path"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _utils = require("./utils");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function createWatcher(args, { state , rebuild  }) {
+    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 ? pollInterval : undefined,
+        ignoreInitial: true,
+        awaitWriteFinish: shouldCoalesceWriteEvents ? {
+            stabilityThreshold: 50,
+            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);
+        // 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(()=>{}, ()=>{});
+    }
+    /**
+   *
+   * @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: content !== null && content !== void 0 ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
+            extension: _path.default.extname(file).slice(1)
+        });
+        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;
+    }
+    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);
+        }
+    });
+    // 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
+        ], 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 (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.configDependencies));
+            watcher.add(state.contentPatterns.all);
+        }
+    };
+}

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "help", {
+    enumerable: true,
+    get: ()=>help
+});
+const _packageJson = /*#__PURE__*/ _interopRequireDefault(require("../../../../package.json"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function help({ message , usage , commands , options  }) {
+    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)){
+            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();
+}