tailwindcss 3.2.3 → 3.2.5

package/lib/lib/setupContextUtils.js

@@ -32,7 +32,7 @@ const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedStat
 const _toPath = require("../util/toPath");
 const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
 const _negateValue = /*#__PURE__*/ _interopRequireDefault(require("../util/negateValue"));
-const _isValidArbitraryValue = /*#__PURE__*/ _interopRequireDefault(require("../util/isValidArbitraryValue"));
+const _isSyntacticallyValidPropertyValue = /*#__PURE__*/ _interopRequireDefault(require("../util/isSyntacticallyValidPropertyValue"));
 const _generateRules = require("./generateRules");
 const _cacheInvalidationJs = require("./cacheInvalidation.js");
 const _offsetsJs = require("./offsets.js");
@@ -113,27 +113,41 @@ function normalizeOptionTypes({ type ="any" , ...options }) {
     };
 }
 function parseVariantFormatString(input) {
-    if (input.includes("{")) {
-        if (!isBalanced(input)) throw new Error(`Your { and } are unbalanced.`);
-        return input.split(/{(.*)}/gim).flatMap((line)=>parseVariantFormatString(line)).filter(Boolean);
-    }
-    return [
-        input.trim()
-    ];
-}
-function isBalanced(input) {
-    let count = 0;
-    for (let char of input){
-        if (char === "{") {
-            count++;
+    /** @type {string[]} */ let parts = [];
+    // When parsing whitespace around special characters are insignificant
+    // However, _inside_ of a variant they could be
+    // Because the selector could look like this
+    // @media { &[data-name="foo bar"] }
+    // This is why we do not skip whitespace
+    let current = "";
+    let depth = 0;
+    for(let idx = 0; idx < input.length; idx++){
+        let char = input[idx];
+        if (char === "\\") {
+            // Escaped characters are not special
+            current += "\\" + input[++idx];
+        } else if (char === "{") {
+            // Nested rule: start
+            ++depth;
+            parts.push(current.trim());
+            current = "";
         } else if (char === "}") {
-            if (--count < 0) {
-                return false // unbalanced
-                ;
+            // Nested rule: end
+            if (--depth < 0) {
+                throw new Error(`Your { and } are unbalanced.`);
             }
+            parts.push(current.trim());
+            current = "";
+        } else {
+            // Normal character
+            current += char;
         }
     }
-    return count === 0;
+    if (current.length > 0) {
+        parts.push(current.trim());
+    }
+    parts = parts.filter((part)=>part !== "");
+    return parts;
 }
 function insertInto(list, value, { before =[]  } = {}) {
     before = [].concat(before);
@@ -281,26 +295,20 @@ function parseVariant(variant) {
         return context.tailwindConfig.prefix + identifier;
     }
     function resolveThemeValue(path, defaultValue, opts = {}) {
-        const [pathRoot, ...subPaths] = (0, _toPath.toPath)(path);
-        const value = getConfigValue([
+        let parts = (0, _toPath.toPath)(path);
+        let value = getConfigValue([
             "theme",
-            pathRoot,
-            ...subPaths
+            ...parts
         ], defaultValue);
-        return (0, _transformThemeValue.default)(pathRoot)(value, opts);
+        return (0, _transformThemeValue.default)(parts[0])(value, opts);
     }
-    const theme = Object.assign((path, defaultValue = undefined)=>resolveThemeValue(path, defaultValue), {
-        withAlpha: (path, opacityValue)=>resolveThemeValue(path, undefined, {
-                opacityValue
-            })
-    });
     let variantIdentifier = 0;
     let api = {
         postcss: _postcss.default,
         prefix: applyConfiguredPrefix,
         e: _escapeClassName.default,
         config: getConfigValue,
-        theme,
+        theme: resolveThemeValue,
         corePlugins: (path)=>{
             if (Array.isArray(tailwindConfig.corePlugins)) {
                 return tailwindConfig.corePlugins.includes(path);
@@ -430,7 +438,7 @@ function parseVariant(variant) {
                             return [];
                         }
                     }
-                    if (!(0, _isValidArbitraryValue.default)(value)) {
+                    if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) {
                         return [];
                     }
                     let extras = {
@@ -496,7 +504,7 @@ function parseVariant(variant) {
                             return [];
                         }
                     }
-                    if (!(0, _isValidArbitraryValue.default)(value)) {
+                    if (!(0, _isSyntacticallyValidPropertyValue.default)(value)) {
                         return [];
                     }
                     let extras = {
@@ -565,14 +573,14 @@ function parseVariant(variant) {
             context.variantOptions.set(variantName, options);
         },
         matchVariant (variant, variantFn, options) {
-            var ref;
+            var _options_id;
             // A unique identifier that "groups" these variants together.
             // This is for internal use only which is why it is not present in the types
-            let id = (ref = options === null || options === void 0 ? void 0 : options.id) !== null && ref !== void 0 ? ref : ++variantIdentifier;
+            let id = (_options_id = options === null || options === void 0 ? void 0 : options.id) !== null && _options_id !== void 0 ? _options_id : ++variantIdentifier;
             let isSpecial = variant === "@";
             let modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
-            var ref1;
-            for (let [key, value] of Object.entries((ref1 = options === null || options === void 0 ? void 0 : options.values) !== null && ref1 !== void 0 ? ref1 : {})){
+            var _options_values;
+            for (let [key, value] of Object.entries((_options_values = options === null || options === void 0 ? void 0 : options.values) !== null && _options_values !== void 0 ? _options_values : {})){
                 if (key === "DEFAULT") continue;
                 api.addVariant(isSpecial ? `${variant}${key}` : `${variant}-${key}`, ({ args , container  })=>{
                     return variantFn(value, modifiersEnabled ? {
@@ -589,15 +597,15 @@ function parseVariant(variant) {
                     variantInfo: VARIANT_INFO.Base
                 });
             }
-            var ref2;
-            let hasDefault = "DEFAULT" in ((ref2 = options === null || options === void 0 ? void 0 : options.values) !== null && ref2 !== void 0 ? ref2 : {});
+            var _options_values1;
+            let hasDefault = "DEFAULT" in ((_options_values1 = options === null || options === void 0 ? void 0 : options.values) !== null && _options_values1 !== void 0 ? _options_values1 : {});
             api.addVariant(variant, ({ args , container  })=>{
                 if ((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE && !hasDefault) {
                     return null;
                 }
                 var // (JetBrains) plugins.
-                ref;
-                return variantFn((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE ? options.values.DEFAULT : (ref = args === null || args === void 0 ? void 0 : args.value) !== null && ref !== void 0 ? ref : typeof args === "string" ? args : "", modifiersEnabled ? {
+                _args_value;
+                return variantFn((args === null || args === void 0 ? void 0 : args.value) === _sharedState.NONE ? options.values.DEFAULT : (_args_value = args === null || args === void 0 ? void 0 : args.value) !== null && _args_value !== void 0 ? _args_value : typeof args === "string" ? args : "", modifiersEnabled ? {
                     modifier: args === null || args === void 0 ? void 0 : args.modifier,
                     container
                 } : {
@@ -622,24 +630,28 @@ function getFileModifiedMap(context) {
 }
 function trackModified(files, fileModifiedMap) {
     let changed = false;
+    let mtimesToCommit = new Map();
     for (let file of files){
-        var ref;
+        var _fs_statSync;
         if (!file) continue;
         let parsed = _url.default.parse(file);
         let pathname = parsed.hash ? parsed.href.replace(parsed.hash, "") : parsed.href;
         pathname = parsed.search ? pathname.replace(parsed.search, "") : pathname;
-        let newModified = (ref = _fs.default.statSync(decodeURIComponent(pathname), {
+        let newModified = (_fs_statSync = _fs.default.statSync(decodeURIComponent(pathname), {
             throwIfNoEntry: false
-        })) === null || ref === void 0 ? void 0 : ref.mtimeMs;
+        })) === null || _fs_statSync === void 0 ? void 0 : _fs_statSync.mtimeMs;
         if (!newModified) {
             continue;
         }
         if (!fileModifiedMap.has(file) || newModified > fileModifiedMap.get(file)) {
             changed = true;
         }
-        fileModifiedMap.set(file, newModified);
+        mtimesToCommit.set(file, newModified);
     }
-    return changed;
+    return [
+        changed,
+        mtimesToCommit
+    ];
 }
 function extractVariantAtRules(node) {
     node.walkAtRules((atRule)=>{
@@ -774,8 +786,8 @@ function registerPlugins(plugins, context) {
                 variantFunction
             ]));
     }
-    var _safelist;
-    let safelist = ((_safelist = context.tailwindConfig.safelist) !== null && _safelist !== void 0 ? _safelist : []).filter(Boolean);
+    var _context_tailwindConfig_safelist;
+    let safelist = ((_context_tailwindConfig_safelist = context.tailwindConfig.safelist) !== null && _context_tailwindConfig_safelist !== void 0 ? _context_tailwindConfig_safelist : []).filter(Boolean);
     if (safelist.length > 0) {
         let checks = [];
         for (let value of safelist){
@@ -803,8 +815,8 @@ function registerPlugins(plugins, context) {
             for (let util of classList){
                 let utils = Array.isArray(util) ? (()=>{
                     let [utilName, options] = util;
-                    var ref;
-                    let values = Object.keys((ref = options === null || options === void 0 ? void 0 : options.values) !== null && ref !== void 0 ? ref : {});
+                    var _options_values;
+                    let values = Object.keys((_options_values = options === null || options === void 0 ? void 0 : options.values) !== null && _options_values !== void 0 ? _options_values : {});
                     let classes = values.map((value)=>(0, _nameClass.formatClass)(utilName, value));
                     if (options === null || options === void 0 ? void 0 : options.supportsNegativeValues) {
                         // This is the normal negated version
@@ -871,8 +883,8 @@ function registerPlugins(plugins, context) {
             }
         }
     }
-    var _darkMode, ref;
-    let darkClassName = (ref = [].concat((_darkMode = context.tailwindConfig.darkMode) !== null && _darkMode !== void 0 ? _darkMode : "media")[1]) !== null && ref !== void 0 ? ref : "dark";
+    var _context_tailwindConfig_darkMode, _concat_;
+    let darkClassName = (_concat_ = [].concat((_context_tailwindConfig_darkMode = context.tailwindConfig.darkMode) !== null && _context_tailwindConfig_darkMode !== void 0 ? _context_tailwindConfig_darkMode : "media")[1]) !== null && _concat_ !== void 0 ? _concat_ : "dark";
     // A list of utilities that are used by certain Tailwind CSS utilities but
     // that don't exist on their own. This will result in them "not existing" and
     // sorting could be weird since you still require them in order to make the
@@ -897,8 +909,8 @@ function registerPlugins(plugins, context) {
             sortedClassNames.set(rule.raws.tailwind.candidate, idx++);
         }
         return classes.map((className)=>{
-            var ref;
-            let order = (ref = sortedClassNames.get(className)) !== null && ref !== void 0 ? ref : null;
+            var _sortedClassNames_get;
+            let order = (_sortedClassNames_get = sortedClassNames.get(className)) !== null && _sortedClassNames_get !== void 0 ? _sortedClassNames_get : null;
             let parasiteIndex = parasiteUtilities.indexOf(className);
             if (order === null && parasiteIndex !== -1) {
                 // This will make sure that it is at the very beginning of the
@@ -914,21 +926,40 @@ function registerPlugins(plugins, context) {
     };
     // Generate a list of strings for autocompletion purposes, e.g.
     // ['uppercase', 'lowercase', ...]
-    context.getClassList = function getClassList() {
+    context.getClassList = function getClassList(options = {}) {
         let output = [];
         for (let util of classList){
             if (Array.isArray(util)) {
-                let [utilName, options] = util;
+                var _utilOptions_types;
+                let [utilName, utilOptions] = util;
                 let negativeClasses = [];
-                var ref;
-                for (let [key, value] of Object.entries((ref = options === null || options === void 0 ? void 0 : options.values) !== null && ref !== void 0 ? ref : {})){
+                var _utilOptions_modifiers;
+                let modifiers = Object.keys((_utilOptions_modifiers = utilOptions === null || utilOptions === void 0 ? void 0 : utilOptions.modifiers) !== null && _utilOptions_modifiers !== void 0 ? _utilOptions_modifiers : {});
+                if (utilOptions === null || utilOptions === void 0 ? void 0 : (_utilOptions_types = utilOptions.types) === null || _utilOptions_types === void 0 ? void 0 : _utilOptions_types.some(({ type  })=>type === "color")) {
+                    var _context_tailwindConfig_theme_opacity;
+                    modifiers.push(...Object.keys((_context_tailwindConfig_theme_opacity = context.tailwindConfig.theme.opacity) !== null && _context_tailwindConfig_theme_opacity !== void 0 ? _context_tailwindConfig_theme_opacity : {}));
+                }
+                let metadata = {
+                    modifiers
+                };
+                let includeMetadata = options.includeMetadata && modifiers.length > 0;
+                var _utilOptions_values;
+                for (let [key, value] of Object.entries((_utilOptions_values = utilOptions === null || utilOptions === void 0 ? void 0 : utilOptions.values) !== null && _utilOptions_values !== void 0 ? _utilOptions_values : {})){
                     // Ignore undefined and null values
                     if (value == null) {
                         continue;
                     }
-                    output.push((0, _nameClass.formatClass)(utilName, key));
-                    if ((options === null || options === void 0 ? void 0 : options.supportsNegativeValues) && (0, _negateValue.default)(value)) {
-                        negativeClasses.push((0, _nameClass.formatClass)(utilName, `-${key}`));
+                    let cls = (0, _nameClass.formatClass)(utilName, key);
+                    output.push(includeMetadata ? [
+                        cls,
+                        metadata
+                    ] : cls);
+                    if ((utilOptions === null || utilOptions === void 0 ? void 0 : utilOptions.supportsNegativeValues) && (0, _negateValue.default)(value)) {
+                        let cls1 = (0, _nameClass.formatClass)(utilName, `-${key}`);
+                        negativeClasses.push(includeMetadata ? [
+                            cls1,
+                            metadata
+                        ] : cls1);
                     }
                 }
                 output.push(...negativeClasses);
@@ -943,11 +974,11 @@ function registerPlugins(plugins, context) {
         let result = [];
         for (let [name, options] of context.variantOptions.entries()){
             if (options.variantInfo === VARIANT_INFO.Base) continue;
-            var _values;
+            var _options_values;
             result.push({
                 name,
                 isArbitrary: options.type === Symbol.for("MATCH_VARIANT"),
-                values: Object.keys((_values = options.values) !== null && _values !== void 0 ? _values : {}),
+                values: Object.keys((_options_values = options.values) !== null && _options_values !== void 0 ? _options_values : {}),
                 hasDash: name !== "@",
                 selectors ({ modifier , value  } = {}) {
                     let candidate = "__TAILWIND_PLACEHOLDER__";
@@ -960,17 +991,17 @@ function registerPlugins(plugins, context) {
                         ]
                     });
                     let before = container.toString();
-                    var ref;
-                    let fns = ((ref = context.variantMap.get(name)) !== null && ref !== void 0 ? ref : []).flatMap(([_, fn])=>fn);
+                    var _context_variantMap_get;
+                    let fns = ((_context_variantMap_get = context.variantMap.get(name)) !== null && _context_variantMap_get !== void 0 ? _context_variantMap_get : []).flatMap(([_, fn])=>fn);
                     let formatStrings = [];
                     for (let fn of fns){
-                        var ref1;
+                        var _options_values;
                         let localFormatStrings = [];
-                        var ref2;
+                        var _options_values_value;
                         let api = {
                             args: {
                                 modifier,
-                                value: (ref2 = (ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[value]) !== null && ref2 !== void 0 ? ref2 : value
+                                value: (_options_values_value = (_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[value]) !== null && _options_values_value !== void 0 ? _options_values_value : value
                             },
                             separator: context.tailwindConfig.separator,
                             modifySelectors (modifierFunction) {
@@ -1044,15 +1075,23 @@ function registerPlugins(plugins, context) {
                             manualFormatStrings.push(`@${atrule.name} (${atrule.params}) { & }`);
                         });
                     }
-                    var _values;
-                    let result = formatStrings.map((formatString)=>(0, _formatVariantSelector.finalizeSelector)((0, _formatVariantSelector.formatVariantSelector)("&", ...formatString), {
-                            selector: `.${candidate}`,
-                            candidate,
-                            context,
-                            isArbitraryVariant: !(value in ((_values = options.values) !== null && _values !== void 0 ? _values : {}))
-                        }).replace(`.${candidate}`, "&").replace("{ & }", "").trim());
+                    var _options_values1;
+                    let isArbitraryVariant = !(value in ((_options_values1 = options.values) !== null && _options_values1 !== void 0 ? _options_values1 : {}));
+                    formatStrings = formatStrings.map((format)=>format.map((str)=>({
+                                format: str,
+                                isArbitraryVariant
+                            })));
+                    manualFormatStrings = manualFormatStrings.map((format)=>({
+                            format,
+                            isArbitraryVariant
+                        }));
+                    let opts = {
+                        candidate,
+                        context
+                    };
+                    let result = formatStrings.map((formats)=>(0, _formatVariantSelector.finalizeSelector)(`.${candidate}`, (0, _formatVariantSelector.formatVariantSelector)(formats, opts), opts).replace(`.${candidate}`, "&").replace("{ & }", "").trim());
                     if (manualFormatStrings.length > 0) {
-                        result.push((0, _formatVariantSelector.formatVariantSelector)("&", ...manualFormatStrings));
+                        result.push((0, _formatVariantSelector.formatVariantSelector)(manualFormatStrings, opts).toString().replace(`.${candidate}`, "&"));
                     }
                     return result;
                 }
@@ -1098,13 +1137,15 @@ function registerPlugins(plugins, context) {
     markInvalidUtilityCandidate(context, candidate);
 }
 function createContext(tailwindConfig, changedContent = [], root = _postcss.default.root()) {
+    var _tailwindConfig_blocklist;
     let context = {
         disposables: [],
         ruleCache: new Set(),
         candidateRuleCache: new Map(),
         classCache: new Map(),
         applyClassCache: new Map(),
-        notClassCache: new Set(),
+        // Seed the not class cache with the blocklist (which is only strings)
+        notClassCache: new Set((_tailwindConfig_blocklist = tailwindConfig.blocklist) !== null && _tailwindConfig_blocklist !== void 0 ? _tailwindConfig_blocklist : []),
         postCssNodeCache: new Map(),
         candidateRuleMap: new Map(),
         tailwindConfig,
@@ -1139,13 +1180,14 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
     // If there's already a context in the cache and we don't need to
     // reset the context, return the cached context.
     if (existingContext) {
-        let contextDependenciesChanged = trackModified([
+        let [contextDependenciesChanged, mtimesToCommit] = trackModified([
             ...contextDependencies
         ], getFileModifiedMap(existingContext));
         if (!contextDependenciesChanged && !cssDidChange) {
             return [
                 existingContext,
-                false
+                false,
+                mtimesToCommit
             ];
         }
     }
@@ -1176,7 +1218,7 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
     Object.assign(context2, {
         userConfigPath
     });
-    trackModified([
+    let [, mtimesToCommit1] = trackModified([
         ...contextDependencies
     ], getFileModifiedMap(context2));
     // ---
@@ -1189,6 +1231,7 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
     contextSourcesMap.get(context2).add(sourcePath);
     return [
         context2,
-        true
+        true,
+        mtimesToCommit1
     ];
 }

package/lib/lib/setupTrackingContext.js

@@ -1,3 +1,4 @@
+// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -111,7 +112,8 @@ function setupTrackingContext(configOrPath) {
                     }
                 }
             }
-            let [context] = (0, _setupContextUtils.getContext)(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
+            let [context, , mTimesToCommit] = (0, _setupContextUtils.getContext)(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
+            let fileModifiedMap = (0, _setupContextUtils.getFileModifiedMap)(context);
             let candidateFiles = getCandidateFiles(context, tailwindConfig);
             // If there are no @tailwind or @apply rules, we don't consider this CSS file or it's
             // dependencies to be dependencies of the context. Can reuse the context even if they change.
@@ -119,15 +121,28 @@ function setupTrackingContext(configOrPath) {
             // because it's impossible for a layer in one file to end up in the actual @tailwind rule
             // in another file since independent sources are effectively isolated.
             if (tailwindDirectives.size > 0) {
-                let fileModifiedMap = (0, _setupContextUtils.getFileModifiedMap)(context);
                 // Add template paths as postcss dependencies.
                 for (let contentPath of candidateFiles){
                     for (let dependency of (0, _parseDependency.default)(contentPath)){
                         registerDependency(dependency);
                     }
                 }
-                for (let changedContent of (0, _contentJs.resolvedChangedContent)(context, candidateFiles, fileModifiedMap)){
-                    context.changedContent.push(changedContent);
+                let [changedContent, contentMTimesToCommit] = (0, _contentJs.resolvedChangedContent)(context, candidateFiles, fileModifiedMap);
+                for (let content of changedContent){
+                    context.changedContent.push(content);
+                }
+                // Add the mtimes of the content files to the commit list
+                // We can overwrite the existing values because unconditionally
+                // This is because:
+                // 1. Most of the files here won't be in the map yet
+                // 2. If they are that means it's a context dependency
+                // and we're reading this after the context. This means
+                // that the mtime we just read is strictly >= the context
+                // mtime. Unless the user / os is doing something weird
+                // in which the mtime would be going backwards. If that
+                // happens there's already going to be problems.
+                for (let [path, mtime] of contentMTimesToCommit.entries()){
+                    mTimesToCommit.set(path, mtime);
                 }
             }
             for (let file of configDependencies){
@@ -136,6 +151,12 @@ function setupTrackingContext(configOrPath) {
                     file
                 });
             }
+            // "commit" the new modified time for all context deps
+            // We do this here because we want content tracking to
+            // read the "old" mtime even when it's a context dependency.
+            for (let [path1, mtime1] of mTimesToCommit.entries()){
+                fileModifiedMap.set(path1, mtime1);
+            }
             return context;
         };
     };

package/lib/lib/sharedState.js

@@ -18,9 +18,18 @@ _export(exports, {
     NONE: ()=>NONE,
     resolveDebug: ()=>resolveDebug
 });
+const _packageJson = /*#__PURE__*/ _interopRequireDefault(require("../../package.json"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let OXIDE_DEFAULT_ENABLED = _packageJson.default.tailwindcss.engine === "oxide";
 const env = {
     NODE_ENV: process.env.NODE_ENV,
-    DEBUG: resolveDebug(process.env.DEBUG)
+    DEBUG: resolveDebug(process.env.DEBUG),
+    ENGINE: _packageJson.default.tailwindcss.engine,
+    OXIDE: resolveBoolean(process.env.OXIDE, OXIDE_DEFAULT_ENABLED)
 };
 const contextMap = new Map();
 const configContextMap = new Map();
@@ -28,6 +37,15 @@ const contextSourcesMap = new Map();
 const sourceHashMap = new Map();
 const NOT_ON_DEMAND = new String("*");
 const NONE = Symbol("__NONE__");
+function resolveBoolean(value, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (value === "0" || value === "false") {
+        return false;
+    }
+    return true;
+}
 function resolveDebug(debug) {
     if (debug === undefined) {
         return false;

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

@@ -0,0 +1,81 @@
+"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, {
+    lazyLightningCss: ()=>lazyLightningCss,
+    lightningcss: ()=>lightningcss,
+    loadPostcss: ()=>loadPostcss,
+    loadPostcssImport: ()=>loadPostcssImport
+});
+const _packageJson = /*#__PURE__*/ _interopRequireDefault(require("../../../../package.json"));
+const _browserslist = /*#__PURE__*/ _interopRequireDefault(require("browserslist"));
+const _index = require("../../../../peers/index");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function lazyLightningCss() {
+    // TODO: Make this lazy/bundled
+    return require("lightningcss");
+}
+let lightningCss;
+function loadLightningCss() {
+    if (lightningCss) {
+        return lightningCss;
+    }
+    // Try to load a local version first
+    try {
+        return lightningCss = require("lightningcss");
+    } catch  {}
+    return lightningCss = lazyLightningCss();
+}
+async function lightningcss(shouldMinify, result) {
+    let css = loadLightningCss();
+    try {
+        let transformed = css.transform({
+            filename: result.opts.from || "input.css",
+            code: Buffer.from(result.css, "utf-8"),
+            minify: shouldMinify,
+            sourceMap: !!result.map,
+            inputSourceMap: result.map ? result.map.toString() : undefined,
+            targets: css.browserslistToTargets((0, _browserslist.default)(_packageJson.default.browserslist)),
+            drafts: {
+                nesting: true
+            }
+        });
+        return Object.assign(result, {
+            css: transformed.code.toString("utf8"),
+            map: result.map ? Object.assign(result.map, {
+                toString () {
+                    return transformed.map.toString();
+                }
+            }) : result.map
+        });
+    } catch (err) {
+        console.error("Unable to use Lightning CSS. Using raw version instead.");
+        console.error(err);
+        return result;
+    }
+}
+function loadPostcss() {
+    // Try to load a local `postcss` version first
+    try {
+        return require("postcss");
+    } catch  {}
+    return (0, _index.lazyPostcss)();
+}
+function loadPostcssImport() {
+    // Try to load a local `postcss-import` version first
+    try {
+        return require("postcss-import");
+    } catch  {}
+    return (0, _index.lazyPostcssImport)();
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "build", {
+    enumerable: true,
+    get: ()=>build
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _plugin = require("./plugin");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function build(args, configs) {
+    let input = args["--input"];
+    let shouldWatch = args["--watch"];
+    // TODO: Deprecate this in future versions
+    if (!input && args["_"][1]) {
+        console.error("[deprecation] Running tailwindcss without -i, please provide an input file.");
+        input = args["--input"] = args["_"][1];
+    }
+    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 (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);
+    }
+    // TODO: Reference the @config path here if exists
+    let configPath = args["--config"] ? args["--config"] : ((defaultPath)=>_fs.default.existsSync(defaultPath) ? defaultPath : null)(_path.default.resolve(`./${configs.tailwind}`));
+    let processor = await (0, _plugin.createProcessor)(args, configPath);
+    if (shouldWatch) {
+        // Abort the watcher if stdin is closed to avoid zombie processes
+        // You can disable this behavior with --watch=always
+        if (args["--watch"] !== "always") {
+            process.stdin.on("end", ()=>process.exit(0));
+        }
+        process.stdin.resume();
+        await processor.watch();
+    } else {
+        await processor.build();
+    }
+}