tailwindcss 0.0.0-insiders.fe08e91 → 0.0.0-oxide.c7d416b

package/lib/util/parseBoxShadowValue.js

@@ -2,22 +2,29 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.parseBoxShadowValue = parseBoxShadowValue;
-exports.formatBoxShadowValue = formatBoxShadowValue;
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    parseBoxShadowValue: ()=>parseBoxShadowValue,
+    formatBoxShadowValue: ()=>formatBoxShadowValue
+});
+const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
 let KEYWORDS = new Set([
-    'inset',
-    'inherit',
-    'initial',
-    'revert',
-    'unset'
+    "inset",
+    "inherit",
+    "initial",
+    "revert",
+    "unset"
 ]);
-let COMMA = /\,(?![^(]*\))/g // Comma separator that is not located between brackets. E.g.: `cubiz-bezier(a, b, c)` these don't count.
-;
 let SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
 ;
-let LENGTH = /^-?(\d+)(.*?)$/g;
+let LENGTH = /^-?(\d+|\.\d+)(.*?)$/g;
 function parseBoxShadowValue(input) {
-    let shadows = input.split(COMMA);
+    let shadows = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(input, ",");
     return shadows.map((shadow)=>{
         let value = shadow.trim();
         let result = {
@@ -29,22 +36,22 @@ function parseBoxShadowValue(input) {
             // Reset index, since the regex is stateful.
             LENGTH.lastIndex = 0;
             // Keyword
-            if (!seen.has('KEYWORD') && KEYWORDS.has(part)) {
+            if (!seen.has("KEYWORD") && KEYWORDS.has(part)) {
                 result.keyword = part;
-                seen.add('KEYWORD');
+                seen.add("KEYWORD");
             } else if (LENGTH.test(part)) {
-                if (!seen.has('X')) {
+                if (!seen.has("X")) {
                     result.x = part;
-                    seen.add('X');
-                } else if (!seen.has('Y')) {
+                    seen.add("X");
+                } else if (!seen.has("Y")) {
                     result.y = part;
-                    seen.add('Y');
-                } else if (!seen.has('BLUR')) {
+                    seen.add("Y");
+                } else if (!seen.has("BLUR")) {
                     result.blur = part;
-                    seen.add('BLUR');
-                } else if (!seen.has('SPREAD')) {
+                    seen.add("BLUR");
+                } else if (!seen.has("SPREAD")) {
                     result.spread = part;
-                    seen.add('SPREAD');
+                    seen.add("SPREAD");
                 }
             } else {
                 if (!result.color) {
@@ -72,6 +79,6 @@ function formatBoxShadowValue(shadows) {
             shadow.blur,
             shadow.spread,
             shadow.color
-        ].filter(Boolean).join(' ');
-    }).join(', ');
+        ].filter(Boolean).join(" ");
+    }).join(", ");
 }

package/lib/util/parseDependency.js

@@ -1,63 +1,45 @@
-"use strict";
+// @ts-check
+/**
+ * @typedef {{type: 'dependency', file: string} | {type: 'dir-dependency', dir: string, glob: string}} Dependency
+ */ /**
+ *
+ * @param {import('../lib/content.js').ContentPath} contentPath
+ * @returns {Dependency[]}
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = parseDependency;
-var _isGlob = _interopRequireDefault(require("is-glob"));
-var _globParent = _interopRequireDefault(require("glob-parent"));
-var _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// Based on `glob-base`
-// https://github.com/micromatch/glob-base/blob/master/index.js
-function parseGlob(pattern) {
-    let glob = pattern;
-    let base = (0, _globParent).default(pattern);
-    if (base !== '.') {
-        glob = pattern.substr(base.length);
-        if (glob.charAt(0) === '/') {
-            glob = glob.substr(1);
-        }
-    }
-    if (glob.substr(0, 2) === './') {
-        glob = glob.substr(2);
-    }
-    if (glob.charAt(0) === '/') {
-        glob = glob.substr(1);
-    }
-    return {
-        base,
-        glob
-    };
-}
-function parseDependency(normalizedFileOrGlob) {
-    if (normalizedFileOrGlob.startsWith('!')) {
-        return null;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>parseDependency
+});
+function parseDependency(contentPath) {
+    if (contentPath.ignore) {
+        return [];
     }
-    let message;
-    if ((0, _isGlob).default(normalizedFileOrGlob)) {
-        let { base , glob  } = parseGlob(normalizedFileOrGlob);
-        message = {
-            type: 'dir-dependency',
-            dir: _path.default.resolve(base),
-            glob
-        };
-    } else {
-        message = {
-            type: 'dependency',
-            file: _path.default.resolve(normalizedFileOrGlob)
-        };
+    if (!contentPath.glob) {
+        return [
+            {
+                type: "dependency",
+                file: contentPath.base
+            }
+        ];
     }
-    // rollup-plugin-postcss does not support dir-dependency messages
-    // but directories can be watched in the same way as files
-    if (message.type === 'dir-dependency' && process.env.ROLLUP_WATCH === 'true') {
-        message = {
-            type: 'dependency',
-            file: message.dir
-        };
+    if (process.env.ROLLUP_WATCH === "true") {
+        // rollup-plugin-postcss does not support dir-dependency messages
+        // but directories can be watched in the same way as files
+        return [
+            {
+                type: "dependency",
+                file: contentPath.base
+            }
+        ];
     }
-    return message;
+    return [
+        {
+            type: "dir-dependency",
+            dir: contentPath.base,
+            glob: contentPath.glob
+        }
+    ];
 }

package/lib/util/parseGlob.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseGlob", {
+    enumerable: true,
+    get: ()=>parseGlob
+});
+const _globParent = /*#__PURE__*/ _interopRequireDefault(require("glob-parent"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function parseGlob(pattern) {
+    let glob = pattern;
+    let base = (0, _globParent.default)(pattern);
+    if (base !== ".") {
+        glob = pattern.substr(base.length);
+        if (glob.charAt(0) === "/") {
+            glob = glob.substr(1);
+        }
+    }
+    if (glob.substr(0, 2) === "./") {
+        glob = glob.substr(2);
+    }
+    if (glob.charAt(0) === "/") {
+        glob = glob.substr(1);
+    }
+    return {
+        base,
+        glob
+    };
+}

package/lib/util/parseObjectStyles.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = parseObjectStyles;
-var _postcss = _interopRequireDefault(require("postcss"));
-var _postcssNested = _interopRequireDefault(require("postcss-nested"));
-var _postcssJs = _interopRequireDefault(require("postcss-js"));
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>parseObjectStyles
+});
+const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
+const _postcssNested = /*#__PURE__*/ _interopRequireDefault(require("postcss-nested"));
+const _postcssJs = /*#__PURE__*/ _interopRequireDefault(require("postcss-js"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -18,12 +21,12 @@ function parseObjectStyles(styles) {
         ]);
     }
     return styles.flatMap((style)=>{
-        return (0, _postcss).default([
-            (0, _postcssNested).default({
+        return (0, _postcss.default)([
+            (0, _postcssNested.default)({
                 bubble: [
-                    'screen'
+                    "screen"
                 ]
-            }), 
+            })
         ]).process(style, {
             parser: _postcssJs.default
         }).root.nodes;

package/lib/util/pluginUtils.js

@@ -2,32 +2,58 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.updateAllClasses = updateAllClasses;
-exports.asValue = asValue;
-exports.asColor = asColor;
-exports.asLookupValue = asLookupValue;
-exports.coerceValue = coerceValue;
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-var _escapeCommas = _interopRequireDefault(require("./escapeCommas"));
-var _withAlphaVariable = require("./withAlphaVariable");
-var _dataTypes = require("./dataTypes");
-var _negateValue = _interopRequireDefault(require("./negateValue"));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    updateAllClasses: ()=>updateAllClasses,
+    filterSelectorsForClass: ()=>filterSelectorsForClass,
+    asValue: ()=>asValue,
+    parseColorFormat: ()=>parseColorFormat,
+    asColor: ()=>asColor,
+    asLookupValue: ()=>asLookupValue,
+    typeMap: ()=>typeMap,
+    coerceValue: ()=>coerceValue,
+    getMatchingTypes: ()=>getMatchingTypes
+});
+const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
+const _escapeCommas = /*#__PURE__*/ _interopRequireDefault(require("./escapeCommas"));
+const _withAlphaVariable = require("./withAlphaVariable");
+const _dataTypes = require("./dataTypes");
+const _negateValue = /*#__PURE__*/ _interopRequireDefault(require("./negateValue"));
+const _validateFormalSyntax = require("./validateFormalSyntax");
+const _featureFlagsJs = require("../featureFlags.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function updateAllClasses(selectors1, updateClass) {
-    let parser = (0, _postcssSelectorParser).default((selectors)=>{
+function updateAllClasses(selectors, updateClass) {
+    let parser = (0, _postcssSelectorParser.default)((selectors)=>{
         selectors.walkClasses((sel)=>{
             let updatedClass = updateClass(sel.value);
             sel.value = updatedClass;
             if (sel.raws && sel.raws.value) {
-                sel.raws.value = (0, _escapeCommas).default(sel.raws.value);
+                sel.raws.value = (0, _escapeCommas.default)(sel.raws.value);
+            }
+        });
+    });
+    let result = parser.processSync(selectors);
+    return result;
+}
+function filterSelectorsForClass(selectors, classCandidate) {
+    let parser = (0, _postcssSelectorParser.default)((selectors)=>{
+        selectors.each((sel)=>{
+            const containsClass = sel.nodes.some((node)=>node.type === "class" && node.value === classCandidate);
+            if (!containsClass) {
+                sel.remove();
             }
         });
     });
-    let result = parser.processSync(selectors1);
+    let result = parser.processSync(selectors);
     return result;
 }
 function resolveArbitraryValue(modifier, validate) {
@@ -38,44 +64,51 @@ function resolveArbitraryValue(modifier, validate) {
     if (!validate(value)) {
         return undefined;
     }
-    return (0, _dataTypes).normalize(value);
+    return (0, _dataTypes.normalize)(value);
 }
-function asNegativeValue(modifier, lookup = {
-}, validate) {
+function asNegativeValue(modifier, lookup = {}, validate) {
     let positiveValue = lookup[modifier];
     if (positiveValue !== undefined) {
-        return (0, _negateValue).default(positiveValue);
+        return (0, _negateValue.default)(positiveValue);
     }
     if (isArbitraryValue(modifier)) {
         let resolved = resolveArbitraryValue(modifier, validate);
         if (resolved === undefined) {
             return undefined;
         }
-        return (0, _negateValue).default(resolved);
+        return (0, _negateValue.default)(resolved);
     }
 }
-function asValue(modifier, options = {
-}, { validate =()=>true
-  } = {
-}) {
+function asValue(modifier, options = {}, { validate =()=>true  } = {}) {
     var ref;
     let value = (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
     if (value !== undefined) {
         return value;
     }
-    if (options.supportsNegativeValues && modifier.startsWith('-')) {
+    if (options.supportsNegativeValues && modifier.startsWith("-")) {
         return asNegativeValue(modifier.slice(1), options.values, validate);
     }
     return resolveArbitraryValue(modifier, validate);
 }
 function isArbitraryValue(input) {
-    return input.startsWith('[') && input.endsWith(']');
+    return input.startsWith("[") && input.endsWith("]");
 }
-function splitAlpha(modifier) {
-    let slashIdx = modifier.lastIndexOf('/');
+function splitUtilityModifier(modifier) {
+    let slashIdx = modifier.lastIndexOf("/");
     if (slashIdx === -1 || slashIdx === modifier.length - 1) {
         return [
-            modifier
+            modifier,
+            undefined
+        ];
+    }
+    let arbitrary = isArbitraryValue(modifier);
+    // The modifier could be of the form `[foo]/[bar]`
+    // We want to handle this case properly
+    // without affecting `[foo/bar]`
+    if (arbitrary && !modifier.includes("]/[")) {
+        return [
+            modifier,
+            undefined
         ];
     }
     return [
@@ -83,16 +116,29 @@ function splitAlpha(modifier) {
         modifier.slice(slashIdx + 1)
     ];
 }
-function asColor(modifier, options = {
-}, { tailwindConfig ={
-}  } = {
-}) {
+function parseColorFormat(value) {
+    if (typeof value === "string" && value.includes("<alpha-value>")) {
+        let oldValue = value;
+        return ({ opacityValue =1  })=>oldValue.replace("<alpha-value>", opacityValue);
+    }
+    return value;
+}
+function unwrapArbitraryModifier(modifier) {
+    modifier = modifier.slice(1, -1);
+    if (modifier.startsWith("--")) {
+        modifier = `var(${modifier})`;
+    }
+    return modifier;
+}
+function asColor(modifier, options = {}, { tailwindConfig ={}  } = {}) {
     var ref;
     if (((ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier]) !== undefined) {
         var ref1;
-        return (ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[modifier];
+        return parseColorFormat((ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[modifier]);
     }
-    let [color, alpha] = splitAlpha(modifier);
+    // TODO: Hoist this up to getMatchingTypes or something
+    // We do this here because we need the alpha value (if any)
+    let [color, alpha] = splitUtilityModifier(modifier);
     if (alpha !== undefined) {
         var ref2, ref3, ref4;
         var ref5;
@@ -100,20 +146,20 @@ function asColor(modifier, options = {
         if (normalizedColor === undefined) {
             return undefined;
         }
+        normalizedColor = parseColorFormat(normalizedColor);
         if (isArbitraryValue(alpha)) {
-            return (0, _withAlphaVariable).withAlphaValue(normalizedColor, alpha.slice(1, -1));
+            return (0, _withAlphaVariable.withAlphaValue)(normalizedColor, unwrapArbitraryModifier(alpha));
         }
         if (((ref3 = tailwindConfig.theme) === null || ref3 === void 0 ? void 0 : (ref4 = ref3.opacity) === null || ref4 === void 0 ? void 0 : ref4[alpha]) === undefined) {
             return undefined;
         }
-        return (0, _withAlphaVariable).withAlphaValue(normalizedColor, tailwindConfig.theme.opacity[alpha]);
+        return (0, _withAlphaVariable.withAlphaValue)(normalizedColor, tailwindConfig.theme.opacity[alpha]);
     }
     return asValue(modifier, options, {
         validate: _dataTypes.color
     });
 }
-function asLookupValue(modifier, options = {
-}) {
+function asLookupValue(modifier, options = {}) {
     var ref;
     return (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
 }
@@ -133,13 +179,14 @@ let typeMap = {
     percentage: guess(_dataTypes.percentage),
     position: guess(_dataTypes.position),
     lookup: asLookupValue,
-    'generic-name': guess(_dataTypes.genericName),
-    'family-name': guess(_dataTypes.familyName),
+    "generic-name": guess(_dataTypes.genericName),
+    "family-name": guess(_dataTypes.familyName),
     number: guess(_dataTypes.number),
-    'line-width': guess(_dataTypes.lineWidth),
-    'absolute-size': guess(_dataTypes.absoluteSize),
-    'relative-size': guess(_dataTypes.relativeSize),
-    shadow: guess(_dataTypes.shadow)
+    "line-width": guess(_dataTypes.lineWidth),
+    "absolute-size": guess(_dataTypes.absoluteSize),
+    "relative-size": guess(_dataTypes.relativeSize),
+    shadow: guess(_dataTypes.shadow),
+    size: guess(_validateFormalSyntax.backgroundSize)
 };
 let supportedTypes = Object.keys(typeMap);
 function splitAtFirst(input, delim) {
@@ -154,9 +201,24 @@ function splitAtFirst(input, delim) {
     ];
 }
 function coerceValue(types, modifier, options, tailwindConfig) {
+    if (options.values && modifier in options.values) {
+        for (let { type  } of types !== null && types !== void 0 ? types : []){
+            let result = typeMap[type](modifier, options, {
+                tailwindConfig
+            });
+            if (result === undefined) {
+                continue;
+            }
+            return [
+                result,
+                type,
+                null
+            ];
+        }
+    }
     if (isArbitraryValue(modifier)) {
         let arbitraryValue = modifier.slice(1, -1);
-        let [explicitType, value] = splitAtFirst(arbitraryValue, ':');
+        let [explicitType, value] = splitAtFirst(arbitraryValue, ":");
         // It could be that this resolves to `url(https` which is not a valid
         // identifier. We currently only support "simple" words with dashes or
         // underscores. E.g.: family-name
@@ -168,19 +230,54 @@ function coerceValue(types, modifier, options, tailwindConfig) {
         if (value.length > 0 && supportedTypes.includes(explicitType)) {
             return [
                 asValue(`[${value}]`, options),
-                explicitType
+                explicitType,
+                null
             ];
         }
     }
+    let matches = getMatchingTypes(types, modifier, options, tailwindConfig);
     // Find first matching type
-    for (let type of [].concat(types)){
+    for (let match of matches){
+        return match;
+    }
+    return [];
+}
+function* getMatchingTypes(types, rawModifier, options, tailwindConfig) {
+    let modifiersEnabled = (0, _featureFlagsJs.flagEnabled)(tailwindConfig, "generalizedModifiers");
+    let [modifier, utilityModifier] = splitUtilityModifier(rawModifier);
+    let canUseUtilityModifier = modifiersEnabled && options.modifiers != null && (options.modifiers === "any" || typeof options.modifiers === "object" && (utilityModifier && isArbitraryValue(utilityModifier) || utilityModifier in options.modifiers));
+    if (!canUseUtilityModifier) {
+        modifier = rawModifier;
+        utilityModifier = undefined;
+    }
+    if (utilityModifier !== undefined && modifier === "") {
+        modifier = "DEFAULT";
+    }
+    // Check the full value first
+    // TODO: Move to asValue… somehow
+    if (utilityModifier !== undefined) {
+        if (typeof options.modifiers === "object") {
+            var ref;
+            var ref1;
+            let configValue = (ref1 = (ref = options.modifiers) === null || ref === void 0 ? void 0 : ref[utilityModifier]) !== null && ref1 !== void 0 ? ref1 : null;
+            if (configValue !== null) {
+                utilityModifier = configValue;
+            } else if (isArbitraryValue(utilityModifier)) {
+                utilityModifier = unwrapArbitraryModifier(utilityModifier);
+            }
+        }
+    }
+    for (let { type  } of types !== null && types !== void 0 ? types : []){
         let result = typeMap[type](modifier, options, {
             tailwindConfig
         });
-        if (result !== undefined) return [
+        if (result === undefined) {
+            continue;
+        }
+        yield [
             result,
-            type
+            type,
+            utilityModifier !== null && utilityModifier !== void 0 ? utilityModifier : null
         ];
     }
-    return [];
 }

package/lib/util/prefixSelector.js

@@ -2,20 +2,22 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = _default;
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-var _tap = require("./tap");
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _default(prefix, selector) {
-    return (0, _postcssSelectorParser).default((selectors)=>{
+function _default(prefix, selector, prependNegative = false) {
+    return (0, _postcssSelectorParser.default)((selectors)=>{
         selectors.walkClasses((classSelector)=>{
-            (0, _tap).tap(classSelector.value, (baseClass)=>{
-                classSelector.value = `${prefix}${baseClass}`;
-            });
+            let baseClass = classSelector.value;
+            let shouldPlaceNegativeBeforePrefix = prependNegative && baseClass.startsWith("-");
+            classSelector.value = shouldPlaceNegativeBeforePrefix ? `-${prefix}${baseClass.slice(1)}` : `${prefix}${baseClass}`;
         });
     }).processSync(selector);
 }

package/lib/util/removeAlphaVariables.js

@@ -0,0 +1,29 @@
+/**
+ * This function removes any uses of CSS variables used as an alpha channel
+ *
+ * This is required for selectors like `:visited` which do not allow
+ * changes in opacity or external control using CSS variables.
+ *
+ * @param {import('postcss').Container} container
+ * @param {string[]} toRemove
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeAlphaVariables", {
+    enumerable: true,
+    get: ()=>removeAlphaVariables
+});
+function removeAlphaVariables(container, toRemove) {
+    container.walkDecls((decl)=>{
+        if (toRemove.includes(decl.prop)) {
+            decl.remove();
+            return;
+        }
+        for (let varName of toRemove){
+            if (decl.value.includes(`/ var(${varName})`)) {
+                decl.value = decl.value.replace(`/ var(${varName})`, "");
+            }
+        }
+    });
+}