tailwindcss 3.4.1 → 4.0.0-alpha.2

package/lib/util/parseGlob.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "parseGlob", {
-    enumerable: true,
-    get: function() {
-        return parseGlob;
-    }
-});
-const _globparent = /*#__PURE__*/ _interop_require_default(require("glob-parent"));
-function _interop_require_default(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

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return parseObjectStyles;
-    }
-});
-const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
-const _postcssnested = /*#__PURE__*/ _interop_require_default(require("postcss-nested"));
-const _postcssjs = /*#__PURE__*/ _interop_require_default(require("postcss-js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function parseObjectStyles(styles) {
-    if (!Array.isArray(styles)) {
-        return parseObjectStyles([
-            styles
-        ]);
-    }
-    return styles.flatMap((style)=>{
-        return (0, _postcss.default)([
-            (0, _postcssnested.default)({
-                bubble: [
-                    "screen"
-                ]
-            })
-        ]).process(style, {
-            parser: _postcssjs.default
-        }).root.nodes;
-    });
-}

package/lib/util/pluginUtils.js

@@ -1,289 +0,0 @@
-"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, {
-    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(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);
-        }
-    });
-}
-function resolveArbitraryValue(modifier, validate) {
-    if (!isArbitraryValue(modifier)) {
-        return undefined;
-    }
-    let value = modifier.slice(1, -1);
-    if (!validate(value)) {
-        return undefined;
-    }
-    return (0, _dataTypes.normalize)(value);
-}
-function asNegativeValue(modifier, lookup = {}, validate) {
-    let positiveValue = lookup[modifier];
-    if (positiveValue !== undefined) {
-        return (0, _negateValue.default)(positiveValue);
-    }
-    if (isArbitraryValue(modifier)) {
-        let resolved = resolveArbitraryValue(modifier, validate);
-        if (resolved === undefined) {
-            return undefined;
-        }
-        return (0, _negateValue.default)(resolved);
-    }
-}
-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("-")) {
-        return asNegativeValue(modifier.slice(1), options.values, validate);
-    }
-    return resolveArbitraryValue(modifier, validate);
-}
-function isArbitraryValue(input) {
-    return input.startsWith("[") && input.endsWith("]");
-}
-function splitUtilityModifier(modifier) {
-    let slashIdx = modifier.lastIndexOf("/");
-    // If the `/` is inside an arbitrary, we want to find the previous one if any
-    // This logic probably isn't perfect but it should work for most cases
-    let arbitraryStartIdx = modifier.lastIndexOf("[", slashIdx);
-    let arbitraryEndIdx = modifier.indexOf("]", slashIdx);
-    let isNextToArbitrary = modifier[slashIdx - 1] === "]" || modifier[slashIdx + 1] === "[";
-    // Backtrack to the previous `/` if the one we found was inside an arbitrary
-    if (!isNextToArbitrary) {
-        if (arbitraryStartIdx !== -1 && arbitraryEndIdx !== -1) {
-            if (arbitraryStartIdx < slashIdx && slashIdx < arbitraryEndIdx) {
-                slashIdx = modifier.lastIndexOf("/", arbitraryStartIdx);
-            }
-        }
-    }
-    if (slashIdx === -1 || slashIdx === modifier.length - 1) {
-        return [
-            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 [
-        modifier.slice(0, slashIdx),
-        modifier.slice(slashIdx + 1)
-    ];
-}
-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) {
-    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 _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, unwrapArbitraryModifier(alpha));
-        }
-        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 asValue(modifier, options, {
-        validate: _dataTypes.color
-    });
-}
-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)=>{
-        return asValue(modifier, options, {
-            validate
-        });
-    };
-}
-let typeMap = {
-    any: asValue,
-    color: asColor,
-    url: guess(_dataTypes.url),
-    image: guess(_dataTypes.image),
-    length: guess(_dataTypes.length),
-    percentage: guess(_dataTypes.percentage),
-    position: guess(_dataTypes.position),
-    lookup: asLookupValue,
-    "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),
-    size: guess(_validateFormalSyntax.backgroundSize)
-};
-let supportedTypes = Object.keys(typeMap);
-function splitAtFirst(input, delim) {
-    let idx = input.indexOf(delim);
-    if (idx === -1) return [
-        undefined,
-        input
-    ];
-    return [
-        input.slice(0, idx),
-        input.slice(idx + 1)
-    ];
-}
-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, ":");
-        // 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
-        if (!/^[\w-_]+$/g.test(explicitType)) {
-            value = arbitraryValue;
-        } else if (explicitType !== undefined && !supportedTypes.includes(explicitType)) {
-            return [];
-        }
-        if (value.length > 0 && supportedTypes.includes(explicitType)) {
-            return [
-                asValue(`[${value}]`, options),
-                explicitType,
-                null
-            ];
-        }
-    }
-    let matches = getMatchingTypes(types, modifier, options, tailwindConfig);
-    // Find first matching type
-    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 === undefined) {
-            continue;
-        }
-        yield [
-            result,
-            type,
-            utilityModifier !== null && utilityModifier !== void 0 ? utilityModifier : null
-        ];
-    }
-}

package/lib/util/prefixSelector.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-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, prependNegative = false) {
-    if (prefix === "") {
-        return selector;
-    }
-    /** @type {import('postcss-selector-parser').Root} */ 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

@@ -1,212 +0,0 @@
-/** @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 pseudo element variants from earlier versions of Tailwind CSS.
-/** @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 = {
-    // Pseudo elements from the spec
-    "::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"
-    ],
-    // Pseudo elements from the spec with special rules
-    "::file-selector-button": [
-        "terminal",
-        "actionable"
-    ],
-    // Library-specific pseudo elements used by component libraries
-    // These are Shadow DOM-like
-    "::deep": [
-        "actionable"
-    ],
-    "::v-deep": [
-        "actionable"
-    ],
-    "::ng-deep": [
-        "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"
-    ],
-    ":where": [],
-    ":is": [],
-    ":has": [],
-    // 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 be moved AND can have user-action pseudo classes attached to it
-    __default__: [
-        "terminal",
-        "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

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