tailwindcss 0.0.0-insiders.ea139f2 → 0.0.0-insiders.ea4e1cd

package/lib/util/pluginUtils.js

@@ -2,33 +2,56 @@
 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 _interopRequireDefault(obj) {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    updateAllClasses: function() {
+        return updateAllClasses;
+    },
+    asValue: function() {
+        return asValue;
+    },
+    parseColorFormat: function() {
+        return parseColorFormat;
+    },
+    asColor: function() {
+        return asColor;
+    },
+    asLookupValue: function() {
+        return asLookupValue;
+    },
+    typeMap: function() {
+        return typeMap;
+    },
+    coerceValue: function() {
+        return coerceValue;
+    },
+    getMatchingTypes: function() {
+        return getMatchingTypes;
+    }
+});
+const _escapeCommas = /*#__PURE__*/ _interop_require_default(require("./escapeCommas"));
+const _withAlphaVariable = require("./withAlphaVariable");
+const _dataTypes = require("./dataTypes");
+const _negateValue = /*#__PURE__*/ _interop_require_default(require("./negateValue"));
+const _validateFormalSyntax = require("./validateFormalSyntax");
+const _featureFlags = require("../featureFlags.js");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function updateAllClasses(selectors1, 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);
-            }
-        });
+function updateAllClasses(selectors, updateClass) {
+    selectors.walkClasses((sel)=>{
+        sel.value = updateClass(sel.value);
+        if (sel.raws && sel.raws.value) {
+            sel.raws.value = (0, _escapeCommas.default)(sel.raws.value);
+        }
     });
-    let result = parser.processSync(selectors1);
-    return result;
 }
 function resolveArbitraryValue(modifier, validate) {
     if (!isArbitraryValue(modifier)) {
@@ -38,44 +61,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
-  } = {
-}) {
-    var ref;
-    let value = (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
+function asValue(modifier, options = {}, { validate =()=>true  } = {}) {
+    var _options_values;
+    let value = (_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[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,39 +113,48 @@ function splitAlpha(modifier) {
         modifier.slice(slashIdx + 1)
     ];
 }
-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];
+function parseColorFormat(value) {
+    if (typeof value === "string" && value.includes("<alpha-value>")) {
+        let oldValue = value;
+        return ({ opacityValue =1  })=>oldValue.replace("<alpha-value>", opacityValue);
     }
-    let [color, alpha] = splitAlpha(modifier);
+    return value;
+}
+function unwrapArbitraryModifier(modifier) {
+    return (0, _dataTypes.normalize)(modifier.slice(1, -1));
+}
+function asColor(modifier, options = {}, { tailwindConfig ={}  } = {}) {
+    var _options_values;
+    if (((_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[modifier]) !== undefined) {
+        var _options_values1;
+        return parseColorFormat((_options_values1 = options.values) === null || _options_values1 === void 0 ? void 0 : _options_values1[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;
-        let normalizedColor = (ref5 = (ref2 = options.values) === null || ref2 === void 0 ? void 0 : ref2[color]) !== null && ref5 !== void 0 ? ref5 : isArbitraryValue(color) ? color.slice(1, -1) : undefined;
+        var _options_values2, _tailwindConfig_theme, _tailwindConfig_theme_opacity;
+        var _options_values_color;
+        let normalizedColor = (_options_values_color = (_options_values2 = options.values) === null || _options_values2 === void 0 ? void 0 : _options_values2[color]) !== null && _options_values_color !== void 0 ? _options_values_color : isArbitraryValue(color) ? color.slice(1, -1) : undefined;
         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) {
+        if (((_tailwindConfig_theme = tailwindConfig.theme) === null || _tailwindConfig_theme === void 0 ? void 0 : (_tailwindConfig_theme_opacity = _tailwindConfig_theme.opacity) === null || _tailwindConfig_theme_opacity === void 0 ? void 0 : _tailwindConfig_theme_opacity[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 = {
-}) {
-    var ref;
-    return (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
+function asLookupValue(modifier, options = {}) {
+    var _options_values;
+    return (_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[modifier];
 }
 function guess(validate) {
     return (modifier, options)=>{
@@ -133,13 +172,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 +194,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 +223,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, _featureFlags.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 _options_modifiers;
+            var _options_modifiers_utilityModifier;
+            let configValue = (_options_modifiers_utilityModifier = (_options_modifiers = options.modifiers) === null || _options_modifiers === void 0 ? void 0 : _options_modifiers[utilityModifier]) !== null && _options_modifiers_utilityModifier !== void 0 ? _options_modifiers_utilityModifier : 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) 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,38 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = _default;
-var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-var _tap = require("./tap");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, /**
+ * @template {string | import('postcss-selector-parser').Root} T
+ *
+ * Prefix all classes in the selector with the given prefix
+ *
+ * It can take either a string or a selector AST and will return the same type
+ *
+ * @param {string} prefix
+ * @param {T} selector
+ * @param {boolean} prependNegative
+ * @returns {T}
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _default(prefix, selector) {
-    return (0, _postcssSelectorParser).default((selectors)=>{
-        selectors.walkClasses((classSelector)=>{
-            (0, _tap).tap(classSelector.value, (baseClass)=>{
-                classSelector.value = `${prefix}${baseClass}`;
-            });
-        });
-    }).processSync(selector);
+function _default(prefix, selector, prependNegative = false) {
+    if (prefix === "") {
+        return selector;
+    }
+    let ast = typeof selector === "string" ? (0, _postcssselectorparser.default)().astSync(selector) : selector;
+    ast.walkClasses((classSelector)=>{
+        let baseClass = classSelector.value;
+        let shouldPlaceNegativeBeforePrefix = prependNegative && baseClass.startsWith("-");
+        classSelector.value = shouldPlaceNegativeBeforePrefix ? `-${prefix}${baseClass.slice(1)}` : `${prefix}${baseClass}`;
+    });
+    return typeof selector === "string" ? ast.toString() : ast;
 }

package/lib/util/pseudoElements.js

@@ -0,0 +1,229 @@
+/** @typedef {import('postcss-selector-parser').Root} Root */ /** @typedef {import('postcss-selector-parser').Selector} Selector */ /** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */ /** @typedef {import('postcss-selector-parser').Node} Node */ // There are some pseudo-elements that may or may not be:
+// **Actionable**
+// Zero or more user-action pseudo-classes may be attached to the pseudo-element itself
+// structural-pseudo-classes are NOT allowed but we don't make
+// The spec is not clear on whether this is allowed or not — but in practice it is.
+// **Terminal**
+// It MUST be placed at the end of a selector
+//
+// This is the required in the spec. However, some pseudo elements are not "terminal" because
+// they represent a "boundary piercing" that is compiled out by a build step.
+// **Jumpable**
+// Any terminal element may "jump" over combinators when moving to the end of the selector
+//
+// This is a backwards-compat quirk of :before and :after variants.
+/** @typedef {'terminal' | 'actionable' | 'jumpable'} PseudoProperty */ /** @type {Record<string, PseudoProperty[]>} */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "movePseudos", {
+    enumerable: true,
+    get: function() {
+        return movePseudos;
+    }
+});
+let elementProperties = {
+    "::after": [
+        "terminal",
+        "jumpable"
+    ],
+    "::backdrop": [
+        "terminal",
+        "jumpable"
+    ],
+    "::before": [
+        "terminal",
+        "jumpable"
+    ],
+    "::cue": [
+        "terminal"
+    ],
+    "::cue-region": [
+        "terminal"
+    ],
+    "::first-letter": [
+        "terminal",
+        "jumpable"
+    ],
+    "::first-line": [
+        "terminal",
+        "jumpable"
+    ],
+    "::grammar-error": [
+        "terminal"
+    ],
+    "::marker": [
+        "terminal",
+        "jumpable"
+    ],
+    "::part": [
+        "terminal",
+        "actionable"
+    ],
+    "::placeholder": [
+        "terminal",
+        "jumpable"
+    ],
+    "::selection": [
+        "terminal",
+        "jumpable"
+    ],
+    "::slotted": [
+        "terminal"
+    ],
+    "::spelling-error": [
+        "terminal"
+    ],
+    "::target-text": [
+        "terminal"
+    ],
+    // other
+    "::file-selector-button": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-progress-bar": [
+        "terminal",
+        "actionable"
+    ],
+    // Webkit scroll bar pseudo elements can be combined with user-action pseudo classes
+    "::-webkit-scrollbar": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-scrollbar-button": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-scrollbar-thumb": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-scrollbar-track": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-scrollbar-track-piece": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-scrollbar-corner": [
+        "terminal",
+        "actionable"
+    ],
+    "::-webkit-resizer": [
+        "terminal",
+        "actionable"
+    ],
+    // Note: As a rule, double colons (::) should be used instead of a single colon
+    // (:). This distinguishes pseudo-classes from pseudo-elements. However, since
+    // this distinction was not present in older versions of the W3C spec, most
+    // browsers support both syntaxes for the original pseudo-elements.
+    ":after": [
+        "terminal",
+        "jumpable"
+    ],
+    ":before": [
+        "terminal",
+        "jumpable"
+    ],
+    ":first-letter": [
+        "terminal",
+        "jumpable"
+    ],
+    ":first-line": [
+        "terminal",
+        "jumpable"
+    ],
+    // The default value is used when the pseudo-element is not recognized
+    // Because it's not recognized, we don't know if it's terminal or not
+    // So we assume it can't be moved AND can have user-action pseudo classes attached to it
+    __default__: [
+        "actionable"
+    ]
+};
+function movePseudos(sel) {
+    let [pseudos] = movablePseudos(sel);
+    // Remove all pseudo elements from their respective selectors
+    pseudos.forEach(([sel, pseudo])=>sel.removeChild(pseudo));
+    // Re-add them to the end of the selector in the correct order.
+    // This moves terminal pseudo elements to the end of the
+    // selector otherwise the selector will not be valid.
+    //
+    // Examples:
+    //  - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
+    //  - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
+    //
+    // The selector `::before:hover` does not work but we
+    // can make it work for you by flipping the order.
+    sel.nodes.push(...pseudos.map(([, pseudo])=>pseudo));
+    return sel;
+}
+/** @typedef {[sel: Selector, pseudo: Pseudo, attachedTo: Pseudo | null]} MovablePseudo */ /** @typedef {[pseudos: MovablePseudo[], lastSeenElement: Pseudo | null]} MovablePseudosResult */ /**
+ * @param {Selector} sel
+ * @returns {MovablePseudosResult}
+ */ function movablePseudos(sel) {
+    /** @type {MovablePseudo[]} */ let buffer = [];
+    /** @type {Pseudo | null} */ let lastSeenElement = null;
+    for (let node of sel.nodes){
+        if (node.type === "combinator") {
+            buffer = buffer.filter(([, node])=>propertiesForPseudo(node).includes("jumpable"));
+            lastSeenElement = null;
+        } else if (node.type === "pseudo") {
+            if (isMovablePseudoElement(node)) {
+                lastSeenElement = node;
+                buffer.push([
+                    sel,
+                    node,
+                    null
+                ]);
+            } else if (lastSeenElement && isAttachablePseudoClass(node, lastSeenElement)) {
+                buffer.push([
+                    sel,
+                    node,
+                    lastSeenElement
+                ]);
+            } else {
+                lastSeenElement = null;
+            }
+            var _node_nodes;
+            for (let sub of (_node_nodes = node.nodes) !== null && _node_nodes !== void 0 ? _node_nodes : []){
+                let [movable, lastSeenElementInSub] = movablePseudos(sub);
+                lastSeenElement = lastSeenElementInSub || lastSeenElement;
+                buffer.push(...movable);
+            }
+        }
+    }
+    return [
+        buffer,
+        lastSeenElement
+    ];
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */ function isPseudoElement(node) {
+    return node.value.startsWith("::") || elementProperties[node.value] !== undefined;
+}
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */ function isMovablePseudoElement(node) {
+    return isPseudoElement(node) && propertiesForPseudo(node).includes("terminal");
+}
+/**
+ * @param {Node} node
+ * @param {Pseudo} pseudo
+ * @returns {boolean}
+ */ function isAttachablePseudoClass(node, pseudo) {
+    if (node.type !== "pseudo") return false;
+    if (isPseudoElement(node)) return false;
+    return propertiesForPseudo(pseudo).includes("actionable");
+}
+/**
+ * @param {Pseudo} pseudo
+ * @returns {PseudoProperty[]}
+ */ function propertiesForPseudo(pseudo) {
+    var _elementProperties_pseudo_value;
+    return (_elementProperties_pseudo_value = elementProperties[pseudo.value]) !== null && _elementProperties_pseudo_value !== void 0 ? _elementProperties_pseudo_value : elementProperties.__default__;
+}

package/lib/util/removeAlphaVariables.js

@@ -0,0 +1,31 @@
+/**
+ * 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: function() {
+        return 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})`, "");
+            }
+        }
+    });
+}