tailwindcss 0.0.0-oxide-insiders.5b078d9 → 0.0.0-oxide-insiders.019fddb

package/lib/cli/init/index.js

@@ -32,8 +32,8 @@ function init(args, configs) {
         if (_fs.default.existsSync(postcssConfigLocation)) {
             messages.push(`${_path.default.basename(postcssConfigLocation)} already exists.`);
         } else {
-            let stubFile1 = _fs.default.readFileSync(_path.default.resolve(__dirname, "../../../stubs/defaultPostCssConfig.stub.js"), "utf8");
-            _fs.default.writeFileSync(postcssConfigLocation, stubFile1, "utf8");
+            let stubFile = _fs.default.readFileSync(_path.default.resolve(__dirname, "../../../stubs/defaultPostCssConfig.stub.js"), "utf8");
+            _fs.default.writeFileSync(postcssConfigLocation, stubFile, "utf8");
             messages.push(`Created PostCSS config file: ${_path.default.basename(postcssConfigLocation)}`);
         }
     }

package/lib/corePlugins.js

@@ -372,11 +372,11 @@ let variantPlugins = {
         });
         // screens and min-* are sorted together when they can be
         let id = "min-screens";
-        for (let screen1 of screens){
-            addVariant(screen1.name, `@media ${(0, _buildMediaQuery.default)(screen1)}`, {
+        for (let screen of screens){
+            addVariant(screen.name, `@media ${(0, _buildMediaQuery.default)(screen)}`, {
                 id,
                 sort: areSimpleScreens && screensUseConsistentUnits ? minSort : undefined,
-                value: screen1
+                value: screen
             });
         }
         matchVariant("min", buildScreenVariant("min"), {

package/lib/lib/collapseDuplicateDeclarations.js

@@ -51,21 +51,21 @@ function collapseDuplicateDeclarations() {
             // with the same unit but the last one in the list.
             for (let declarations of byProperty.values()){
                 let byUnit = new Map();
-                for (let decl1 of declarations){
-                    let unit = resolveUnit(decl1.value);
+                for (let decl of declarations){
+                    let unit = resolveUnit(decl.value);
                     if (unit === null) {
                         continue;
                     }
                     if (!byUnit.has(unit)) {
                         byUnit.set(unit, new Set());
                     }
-                    byUnit.get(unit).add(decl1);
+                    byUnit.get(unit).add(decl);
                 }
-                for (let declarations1 of byUnit.values()){
+                for (let declarations of byUnit.values()){
                     // Get all but the last one
-                    let removableDeclarations = Array.from(declarations1).slice(0, -1);
-                    for (let decl2 of removableDeclarations){
-                        decl2.remove();
+                    let removableDeclarations = Array.from(declarations).slice(0, -1);
+                    for (let decl of removableDeclarations){
+                        decl.remove();
                     }
                 }
             }

package/lib/lib/evaluateTailwindFunctions.js

@@ -86,22 +86,22 @@ function validatePath(config, path, defaultValue, themeOpts = {}) {
         };
     }
     if (!(typeof value === "string" || typeof value === "number" || typeof value === "function" || value instanceof String || value instanceof Number || Array.isArray(value))) {
-        let error1 = `'${pathString}' was found but does not resolve to a string.`;
+        let error = `'${pathString}' was found but does not resolve to a string.`;
         if (isObject(value)) {
-            let validKeys1 = Object.keys(value).filter((key)=>validatePath(config, [
+            let validKeys = Object.keys(value).filter((key)=>validatePath(config, [
                     ...pathSegments,
                     key
                 ]).isValid);
-            if (validKeys1.length) {
-                error1 += ` Did you mean something like '${pathToString([
+            if (validKeys.length) {
+                error += ` Did you mean something like '${pathToString([
                     ...pathSegments,
-                    validKeys1[0]
+                    validKeys[0]
                 ])}'?`;
             }
         }
         return {
             isValid: false,
-            error: error1
+            error
         };
     }
     const [themeSection] = pathSegments;

package/lib/lib/expandApplyAtRules.js

@@ -309,11 +309,11 @@ function processApply(root, context, localCache) {
             // Sort tag names before class names (but only sort each group (separated by a combinator)
             // separately and not in total)
             // This happens when replacing `.bar` in `.foo.bar` with a tag like `section`
-            for (let sel1 of replaced){
+            for (let sel of replaced){
                 let groups = [
                     []
                 ];
-                for (let node of sel1.nodes){
+                for (let node of sel.nodes){
                     if (node.type === "combinator") {
                         groups.push(node);
                         groups.push([]);
@@ -322,7 +322,7 @@ function processApply(root, context, localCache) {
                         last.push(node);
                     }
                 }
-                sel1.nodes = [];
+                sel.nodes = [];
                 for (let group of groups){
                     if (Array.isArray(group)) {
                         group.sort((a, b)=>{
@@ -338,7 +338,7 @@ function processApply(root, context, localCache) {
                             return 0;
                         });
                     }
-                    sel1.nodes = sel1.nodes.concat(group);
+                    sel.nodes = sel.nodes.concat(group);
                 }
             }
             sel.replaceWith(...replaced);
@@ -356,15 +356,15 @@ function processApply(root, context, localCache) {
             candidates,
             apply.source
         ]);
-        let [applyCandidates1, important] = extractApplyCandidates(apply.params);
+        let [applyCandidates, important] = extractApplyCandidates(apply.params);
         if (apply.parent.type === "atrule") {
             if (apply.parent.name === "screen") {
                 let screenType = apply.parent.params;
-                throw apply.error(`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${applyCandidates1.map((c)=>`${screenType}:${c}`).join(" ")} instead.`);
+                throw apply.error(`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${applyCandidates.map((c)=>`${screenType}:${c}`).join(" ")} instead.`);
             }
             throw apply.error(`@apply is not supported within nested at-rules like @${apply.parent.name}. You can fix this by un-nesting @${apply.parent.name}.`);
         }
-        for (let applyCandidate of applyCandidates1){
+        for (let applyCandidate of applyCandidates){
             if ([
                 prefix(context, "group"),
                 prefix(context, "peer")
@@ -383,16 +383,16 @@ function processApply(root, context, localCache) {
             ]);
         }
     }
-    for (let [parent, [candidates1, atApplySource]] of perParentApplies){
+    for (let [parent, [candidates, atApplySource]] of perParentApplies){
         let siblings = [];
-        for (let [applyCandidate1, important1, rules1] of candidates1){
+        for (let [applyCandidate, important, rules] of candidates){
             let potentialApplyCandidates = [
-                applyCandidate1,
+                applyCandidate,
                 ...extractBaseCandidates([
-                    applyCandidate1
+                    applyCandidate
                 ], context.tailwindConfig.separator)
             ];
-            for (let [meta, node] of rules1){
+            for (let [meta, node] of rules){
                 let parentClasses = extractClasses(parent);
                 let nodeClasses = extractClasses(node);
                 // When we encounter a rule like `.dark .a, .b { … }` we only want to be left with `[.dark, .a]` if the base applyCandidate is `.a` or with `[.b]` if the base applyCandidate is `.b`
@@ -423,20 +423,20 @@ function processApply(root, context, localCache) {
                 nodeClasses = nodeClasses.concat(extractBaseCandidates(nodeClasses, context.tailwindConfig.separator));
                 let intersects = parentClasses.some((selector)=>nodeClasses.includes(selector));
                 if (intersects) {
-                    throw node.error(`You cannot \`@apply\` the \`${applyCandidate1}\` utility here because it creates a circular dependency.`);
+                    throw node.error(`You cannot \`@apply\` the \`${applyCandidate}\` utility here because it creates a circular dependency.`);
                 }
-                let root1 = _postcss.default.root({
+                let root = _postcss.default.root({
                     nodes: [
                         node.clone()
                     ]
                 });
                 // Make sure every node in the entire tree points back at the @apply rule that generated it
-                root1.walk((node)=>{
+                root.walk((node)=>{
                     node.source = atApplySource;
                 });
                 let canRewriteSelector = node.type !== "atrule" || node.type === "atrule" && node.name !== "keyframes";
                 if (canRewriteSelector) {
-                    root1.walkRules((rule)=>{
+                    root.walkRules((rule)=>{
                         // Let's imagine you have the following structure:
                         //
                         // .foo {
@@ -468,7 +468,7 @@ function processApply(root, context, localCache) {
                         // would have replaced this with something that didn't exist and
                         // therefore it removed the selector altogether. In this specific
                         // case it would result in `{}` instead of `.something-unrelated {}`
-                        if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate1)) {
+                        if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate)) {
                             rule.remove();
                             return;
                         }
@@ -478,25 +478,25 @@ function processApply(root, context, localCache) {
                         // We do *not* want to do this for user CSS that happens to be structured the same
                         let isGenerated = parent.raws.tailwind !== undefined;
                         let parentSelector = isGenerated && importantSelector && parent.selector.indexOf(importantSelector) === 0 ? parent.selector.slice(importantSelector.length) : parent.selector;
-                        rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate1);
+                        rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate);
                         // And then re-add it if it was removed
                         if (importantSelector && parentSelector !== parent.selector) {
                             rule.selector = `${importantSelector} ${rule.selector}`;
                         }
                         rule.walkDecls((d)=>{
-                            d.important = meta.important || important1;
+                            d.important = meta.important || important;
                         });
                     });
                 }
                 // It could be that the node we were inserted was removed because the class didn't match
                 // If that was the *only* rule in the parent, then we have nothing add so we skip it
-                if (!root1.nodes[0]) {
+                if (!root.nodes[0]) {
                     continue;
                 }
                 // Insert it
                 siblings.push([
                     meta.sort,
-                    root1.nodes[0]
+                    root.nodes[0]
                 ]);
             }
         }
@@ -505,13 +505,13 @@ function processApply(root, context, localCache) {
         // `parent` refers to the node at `.abc` in: .abc { @apply mt-2 }
         parent.after(nodes);
     }
-    for (let apply1 of applies){
+    for (let apply of applies){
         // If there are left-over declarations, just remove the @apply
-        if (apply1.parent.nodes.length > 1) {
-            apply1.remove();
+        if (apply.parent.nodes.length > 1) {
+            apply.remove();
         } else {
             // The node is empty, drop the full node
-            apply1.parent.remove();
+            apply.parent.remove();
         }
     }
     // Do it again, in case we have other `@apply` rules

package/lib/lib/expandTailwindAtRules.js

@@ -97,8 +97,8 @@ function getClassCandidates(content, extractor, candidates, seen) {
         } else {
             let extractorMatches = extractor(line).filter((s)=>s !== "!*");
             let lineMatchesSet = new Set(extractorMatches);
-            for (let match1 of lineMatchesSet){
-                candidates.add(match1);
+            for (let match of lineMatchesSet){
+                candidates.add(match);
             }
             extractorCache.get(extractor).set(line, lineMatchesSet);
         }

package/lib/lib/generateRules.js

@@ -216,9 +216,9 @@ function applyVariant(variant, matches, context) {
         // But we don't want:
         //   @-[200px]        (`-` is incorrect)
         //   group[:hover]    (`-` is missing)
-        let match1 = /(.)(-?)\[(.*)\]/g.exec(variant);
-        if (match1) {
-            let [, char, seperator, value] = match1;
+        let match = /(.)(-?)\[(.*)\]/g.exec(variant);
+        if (match) {
+            let [, char, seperator, value] = match;
             // @-[200px] case
             if (char === "@" && seperator === "-") return [];
             // group[:hover] case
@@ -310,14 +310,14 @@ function applyVariant(variant, matches, context) {
                 // It can happen that a list of format strings is returned from within the function. In that
                 // case, we have to process them as well. We can use the existing `variantSort`.
                 if (Array.isArray(ruleWithVariant)) {
-                    for (let [idx, variantFunction1] of ruleWithVariant.entries()){
+                    for (let [idx, variantFunction] of ruleWithVariant.entries()){
                         // This is a little bit scary since we are pushing to an array of items that we are
                         // currently looping over. However, you can also think of it like a processing queue
                         // where you keep handling jobs until everything is done and each job can queue more
                         // jobs if needed.
                         variantFunctionTuples.push([
                             context.offsets.applyParallelOffset(variantSort, idx),
-                            variantFunction1,
+                            variantFunction,
                             // If the clone has been modified we have to pass that back
                             // though so each rule can use the modified container
                             clone.clone()
@@ -607,18 +607,18 @@ function* resolveMatches(candidate, context, original = candidate) {
                     }
                 }
             } else if (modifier === "DEFAULT" || modifier === "-DEFAULT") {
-                let ruleSet1 = plugin;
-                let [rules1, options1] = parseRules(ruleSet1, context.postCssNodeCache);
-                for (let rule1 of rules1){
+                let ruleSet = plugin;
+                let [rules, options] = parseRules(ruleSet, context.postCssNodeCache);
+                for (let rule of rules){
                     matchesPerPlugin.push([
                         {
                             ...sort,
                             options: {
                                 ...sort.options,
-                                ...options1
+                                ...options
                             }
                         },
-                        rule1
+                        rule
                     ]);
                 }
             }
@@ -694,11 +694,11 @@ function* resolveMatches(candidate, context, original = candidate) {
                     }
                     let messages = [];
                     for (let [idx, group] of typesPerPlugin.entries()){
-                        for (let type1 of group){
-                            let rules2 = matches[idx].map(([, rule])=>rule).flat().map((rule)=>rule.toString().split("\n").slice(1, -1) // Remove selector and closing '}'
+                        for (let type of group){
+                            let rules = matches[idx].map(([, rule])=>rule).flat().map((rule)=>rule.toString().split("\n").slice(1, -1) // Remove selector and closing '}'
                                 .map((line)=>line.trim()).map((x)=>`      ${x}`) // Re-indent
                                 .join("\n")).join("\n\n");
-                            messages.push(`  Use \`${candidate.replace("[", `[${type1}:`)}\` for \`${rules2.trim()}\``);
+                            messages.push(`  Use \`${candidate.replace("[", `[${type}:`)}\` for \`${rules.trim()}\``);
                             break;
                         }
                     }

package/lib/lib/resolveDefaultsAtRules.js

@@ -119,12 +119,12 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                         universal.remove();
                         continue;
                     }
-                    for (let [, selectors1] of selectorGroups){
+                    for (let [, selectors] of selectorGroups){
                         let universalRule = _postcss.default.rule({
                             source: universal.source
                         });
                         universalRule.selectors = [
-                            ...selectors1
+                            ...selectors
                         ];
                         universalRule.append(universal.nodes.map((node)=>node.clone()));
                         universal.before(universalRule);
@@ -133,29 +133,29 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                 universal.remove();
             }
         } else if (universals.size) {
-            let universalRule1 = _postcss.default.rule({
+            let universalRule = _postcss.default.rule({
                 selectors: [
                     "*",
                     "::before",
                     "::after"
                 ]
             });
-            for (let universal1 of universals){
-                universalRule1.append(universal1.nodes);
-                if (!universalRule1.parent) {
-                    universal1.before(universalRule1);
+            for (let universal of universals){
+                universalRule.append(universal.nodes);
+                if (!universalRule.parent) {
+                    universal.before(universalRule);
                 }
-                if (!universalRule1.source) {
-                    universalRule1.source = universal1.source;
+                if (!universalRule.source) {
+                    universalRule.source = universal.source;
                 }
-                universal1.remove();
+                universal.remove();
             }
-            let backdropRule = universalRule1.clone({
+            let backdropRule = universalRule.clone({
                 selectors: [
                     "::backdrop"
                 ]
             });
-            universalRule1.after(backdropRule);
+            universalRule.after(backdropRule);
         }
     };
 }

package/lib/lib/setupContextUtils.js

@@ -689,9 +689,9 @@ function collectLayerPlugins(root) {
             }
             layerRule.remove();
         } else if (layerRule.params === "components") {
-            for (let node1 of layerRule.nodes){
+            for (let node of layerRule.nodes){
                 layerPlugins.push(function({ addComponents  }) {
-                    addComponents(node1, {
+                    addComponents(node, {
                         respectPrefix: false,
                         preserveSource: true
                     });
@@ -699,9 +699,9 @@ function collectLayerPlugins(root) {
             }
             layerRule.remove();
         } else if (layerRule.params === "utilities") {
-            for (let node2 of layerRule.nodes){
+            for (let node of layerRule.nodes){
                 layerPlugins.push(function({ addUtilities  }) {
-                    addUtilities(node2, {
+                    addUtilities(node, {
                         respectPrefix: false,
                         preserveSource: true
                     });
@@ -850,7 +850,7 @@ function registerPlugins(plugins, context) {
                 })() : [
                     util
                 ];
-                for (let util1 of utils){
+                for (let util of utils){
                     for (let { pattern , variants =[]  } of checks){
                         // RegExp with the /g flag are stateful, so let's reset the last
                         // index pointer to reset the state.
@@ -858,15 +858,15 @@ function registerPlugins(plugins, context) {
                         if (!patternMatchingCount.has(pattern)) {
                             patternMatchingCount.set(pattern, 0);
                         }
-                        if (!pattern.test(util1)) continue;
+                        if (!pattern.test(util)) continue;
                         patternMatchingCount.set(pattern, patternMatchingCount.get(pattern) + 1);
                         context.changedContent.push({
-                            content: util1,
+                            content: util,
                             extension: "html"
                         });
                         for (let variant of variants){
                             context.changedContent.push({
-                                content: variant + context.tailwindConfig.separator + util1,
+                                content: variant + context.tailwindConfig.separator + util,
                                 extension: "html"
                             });
                         }
@@ -1183,9 +1183,9 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
             contextSourcesMap.get(oldContext).delete(sourcePath);
             if (contextSourcesMap.get(oldContext).size === 0) {
                 contextSourcesMap.delete(oldContext);
-                for (let [tailwindConfigHash1, context1] of configContextMap){
-                    if (context1 === oldContext) {
-                        configContextMap.delete(tailwindConfigHash1);
+                for (let [tailwindConfigHash, context] of configContextMap){
+                    if (context === oldContext) {
+                        configContextMap.delete(tailwindConfigHash);
                     }
                 }
                 for (let disposable of oldContext.disposables.splice(0)){
@@ -1195,24 +1195,24 @@ function getContext(root, result, tailwindConfig, userConfigPath, tailwindConfig
         }
     }
     _sharedState.env.DEBUG && console.log("Setting up new context...");
-    let context2 = createContext(tailwindConfig, [], root);
-    Object.assign(context2, {
+    let context = createContext(tailwindConfig, [], root);
+    Object.assign(context, {
         userConfigPath
     });
-    let [, mtimesToCommit1] = trackModified([
+    let [, mtimesToCommit] = trackModified([
         ...contextDependencies
-    ], getFileModifiedMap(context2));
+    ], getFileModifiedMap(context));
     // ---
     // Update all context tracking state
-    configContextMap.set(tailwindConfigHash, context2);
-    contextMap.set(sourcePath, context2);
-    if (!contextSourcesMap.has(context2)) {
-        contextSourcesMap.set(context2, new Set());
+    configContextMap.set(tailwindConfigHash, context);
+    contextMap.set(sourcePath, context);
+    if (!contextSourcesMap.has(context)) {
+        contextSourcesMap.set(context, new Set());
     }
-    contextSourcesMap.get(context2).add(sourcePath);
+    contextSourcesMap.get(context).add(sourcePath);
     return [
-        context2,
+        context,
         true,
-        mtimesToCommit1
+        mtimesToCommit
     ];
 }

package/lib/lib/setupTrackingContext.js

@@ -62,8 +62,8 @@ function getTailwindConfig(configOrPath) {
             ];
         }
         // It has changed (based on timestamps), or first run
-        for (let file1 of newDeps){
-            delete require.cache[file1];
+        for (let file of newDeps){
+            delete require.cache[file];
         }
         let newConfig = (0, _resolveConfig.default)(require(userConfigPath));
         newConfig = (0, _validateConfigJs.validateConfig)(newConfig);
@@ -82,12 +82,12 @@ function getTailwindConfig(configOrPath) {
         ];
     }
     // It's a plain object, not a path
-    let newConfig1 = (0, _resolveConfig.default)(configOrPath.config === undefined ? configOrPath : configOrPath.config);
-    newConfig1 = (0, _validateConfigJs.validateConfig)(newConfig1);
+    let newConfig = (0, _resolveConfig.default)(configOrPath.config === undefined ? configOrPath : configOrPath.config);
+    newConfig = (0, _validateConfigJs.validateConfig)(newConfig);
     return [
-        newConfig1,
+        newConfig,
         null,
-        (0, _hashConfig.default)(newConfig1),
+        (0, _hashConfig.default)(newConfig),
         []
     ];
 }
@@ -154,8 +154,8 @@ function setupTrackingContext(configOrPath) {
             // "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);
+            for (let [path, mtime] of mTimesToCommit.entries()){
+                fileModifiedMap.set(path, mtime);
             }
             return context;
         };

package/lib/plugin.js

@@ -28,9 +28,9 @@ module.exports = function tailwindcss(configOrPath) {
                 let context = (0, _setupTrackingContext.default)(configOrPath);
                 if (root.type === "document") {
                     let roots = root.nodes.filter((node)=>node.type === "root");
-                    for (const root1 of roots){
-                        if (root1.type === "root") {
-                            (0, _processTailwindFeatures.default)(context)(root1, result);
+                    for (const root of roots){
+                        if (root.type === "root") {
+                            (0, _processTailwindFeatures.default)(context)(root, result);
                         }
                     }
                     return;

package/lib/util/defaults.js

@@ -14,10 +14,10 @@ function defaults(target, ...sources) {
                 target[k] = source[k];
             }
         }
-        for (let k1 of Object.getOwnPropertySymbols(source)){
+        for (let k of Object.getOwnPropertySymbols(source)){
             var _target_hasOwnProperty1;
-            if (!(target === null || target === void 0 ? void 0 : (_target_hasOwnProperty1 = target.hasOwnProperty) === null || _target_hasOwnProperty1 === void 0 ? void 0 : _target_hasOwnProperty1.call(target, k1))) {
-                target[k1] = source[k1];
+            if (!(target === null || target === void 0 ? void 0 : (_target_hasOwnProperty1 = target.hasOwnProperty) === null || _target_hasOwnProperty1 === void 0 ? void 0 : _target_hasOwnProperty1.call(target, k))) {
+                target[k] = source[k];
             }
         }
     }

package/lib/util/normalizeConfig.js

@@ -128,8 +128,8 @@ function normalizeConfig(config) {
                 }
                 // `config.content.transform` is optional, and can be a Function or a Record<String, Function>
                 if (typeof config.content.transform === "object") {
-                    for (let value1 of Object.values(config.content.transform)){
-                        if (typeof value1 !== "function") {
+                    for (let value of Object.values(config.content.transform)){
+                        if (typeof value !== "function") {
                             return false;
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss",
-  "version": "0.0.0-oxide-insiders.5b078d9",
+  "version": "0.0.0-oxide-insiders.019fddb",
   "description": "A utility-first CSS framework for rapidly building custom user interfaces.",
   "license": "MIT",
   "main": "lib/index.js",
@@ -48,19 +48,19 @@
   ],
   "devDependencies": {
     "@swc/cli": "0.1.59",
-    "@swc/core": "1.3.24",
+    "@swc/core": "1.3.27",
     "@swc/jest": "0.2.24",
     "@swc/register": "0.1.10",
     "autoprefixer": "^10.4.13",
     "concurrently": "^7.5.0",
     "cssnano": "^5.1.14",
-    "esbuild": "^0.16.10",
+    "esbuild": "^0.17.3",
     "eslint": "^8.31.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^28.1.3",
     "jest-diff": "^28.1.3",
-    "prettier": "^2.8.1",
+    "prettier": "^2.8.3",
     "rimraf": "^3.0.0",
     "source-map-js": "^1.0.2",
     "turbo": "^1.7.0"
@@ -69,7 +69,7 @@
     "postcss": "^8.0.9"
   },
   "dependencies": {
-    "@tailwindcss/oxide": "0.0.0-oxide-insiders.5b078d9",
+    "@tailwindcss/oxide": "0.0.0-oxide-insiders.019fddb",
     "arg": "^5.0.2",
     "browserslist": "^4.21.4",
     "chokidar": "^3.5.3",