tailwindcss 3.4.0 → 4.0.0-alpha.1

package/lib/lib/collapseDuplicateDeclarations.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return collapseDuplicateDeclarations;
-    }
-});
-function collapseDuplicateDeclarations() {
-    return (root)=>{
-        root.walkRules((node)=>{
-            let seen = new Map();
-            let droppable = new Set([]);
-            let byProperty = new Map();
-            node.walkDecls((decl)=>{
-                // This could happen if we have nested selectors. In that case the
-                // parent will loop over all its declarations but also the declarations
-                // of nested rules. With this we ensure that we are shallowly checking
-                // declarations.
-                if (decl.parent !== node) {
-                    return;
-                }
-                if (seen.has(decl.prop)) {
-                    // Exact same value as what we have seen so far
-                    if (seen.get(decl.prop).value === decl.value) {
-                        // Keep the last one, drop the one we've seen so far
-                        droppable.add(seen.get(decl.prop));
-                        // Override the existing one with the new value. This is necessary
-                        // so that if we happen to have more than one declaration with the
-                        // same value, that we keep removing the previous one. Otherwise we
-                        // will only remove the *first* one.
-                        seen.set(decl.prop, decl);
-                        return;
-                    }
-                    // Not the same value, so we need to check if we can merge it so
-                    // let's collect it first.
-                    if (!byProperty.has(decl.prop)) {
-                        byProperty.set(decl.prop, new Set());
-                    }
-                    byProperty.get(decl.prop).add(seen.get(decl.prop));
-                    byProperty.get(decl.prop).add(decl);
-                }
-                seen.set(decl.prop, decl);
-            });
-            // Drop all the duplicate declarations with the exact same value we've
-            // already seen so far.
-            for (let decl of droppable){
-                decl.remove();
-            }
-            // Analyze the declarations based on its unit, drop all the declarations
-            // with the same unit but the last one in the list.
-            for (let declarations of byProperty.values()){
-                let byUnit = new Map();
-                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(decl);
-                }
-                for (let declarations of byUnit.values()){
-                    // Get all but the last one
-                    let removableDeclarations = Array.from(declarations).slice(0, -1);
-                    for (let decl of removableDeclarations){
-                        decl.remove();
-                    }
-                }
-            }
-        });
-    };
-}
-let UNITLESS_NUMBER = Symbol("unitless-number");
-function resolveUnit(input) {
-    let result = /^-?\d*.?\d+([\w%]+)?$/g.exec(input);
-    if (result) {
-        var _result_;
-        return (_result_ = result[1]) !== null && _result_ !== void 0 ? _result_ : UNITLESS_NUMBER;
-    }
-    return null;
-}

package/lib/lib/content.js

@@ -1,181 +0,0 @@
-// @ts-check
-"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, {
-    parseCandidateFiles: function() {
-        return parseCandidateFiles;
-    },
-    resolvedChangedContent: function() {
-        return resolvedChangedContent;
-    }
-});
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _isglob = /*#__PURE__*/ _interop_require_default(require("is-glob"));
-const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
-const _normalizepath = /*#__PURE__*/ _interop_require_default(require("normalize-path"));
-const _parseGlob = require("../util/parseGlob");
-const _sharedState = require("./sharedState");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function parseCandidateFiles(context, tailwindConfig) {
-    let files = tailwindConfig.content.files;
-    // Normalize the file globs
-    files = files.filter((filePath)=>typeof filePath === "string");
-    files = files.map(_normalizepath.default);
-    // Split into included and excluded globs
-    let tasks = _fastglob.default.generateTasks(files);
-    /** @type {ContentPath[]} */ let included = [];
-    /** @type {ContentPath[]} */ let excluded = [];
-    for (const task of tasks){
-        included.push(...task.positive.map((filePath)=>parseFilePath(filePath, false)));
-        excluded.push(...task.negative.map((filePath)=>parseFilePath(filePath, true)));
-    }
-    let paths = [
-        ...included,
-        ...excluded
-    ];
-    // Resolve paths relative to the config file or cwd
-    paths = resolveRelativePaths(context, paths);
-    // Resolve symlinks if possible
-    paths = paths.flatMap(resolvePathSymlinks);
-    // Update cached patterns
-    paths = paths.map(resolveGlobPattern);
-    return paths;
-}
-/**
- *
- * @param {string} filePath
- * @param {boolean} ignore
- * @returns {ContentPath}
- */ function parseFilePath(filePath, ignore) {
-    let contentPath = {
-        original: filePath,
-        base: filePath,
-        ignore,
-        pattern: filePath,
-        glob: null
-    };
-    if ((0, _isglob.default)(filePath)) {
-        Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath));
-    }
-    return contentPath;
-}
-/**
- *
- * @param {ContentPath} contentPath
- * @returns {ContentPath}
- */ function resolveGlobPattern(contentPath) {
-    // This is required for Windows support to properly pick up Glob paths.
-    // Afaik, this technically shouldn't be needed but there's probably
-    // some internal, direct path matching with a normalized path in
-    // a package which can't handle mixed directory separators
-    let base = (0, _normalizepath.default)(contentPath.base);
-    // If the user's file path contains any special characters (like parens) for instance fast-glob
-    // is like "OOOH SHINY" and treats them as such. So we have to escape the base path to fix this
-    base = _fastglob.default.escapePath(base);
-    contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base;
-    contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern;
-    return contentPath;
-}
-/**
- * Resolve each path relative to the config file (when possible) if the experimental flag is enabled
- * Otherwise, resolve relative to the current working directory
- *
- * @param {any} context
- * @param {ContentPath[]} contentPaths
- * @returns {ContentPath[]}
- */ function resolveRelativePaths(context, contentPaths) {
-    let resolveFrom = [];
-    // Resolve base paths relative to the config file (when possible) if the experimental flag is enabled
-    if (context.userConfigPath && context.tailwindConfig.content.relative) {
-        resolveFrom = [
-            _path.default.dirname(context.userConfigPath)
-        ];
-    }
-    return contentPaths.map((contentPath)=>{
-        contentPath.base = _path.default.resolve(...resolveFrom, contentPath.base);
-        return contentPath;
-    });
-}
-/**
- * Resolve the symlink for the base directory / file in each path
- * These are added as additional dependencies to watch for changes because
- * some tools (like webpack) will only watch the actual file or directory
- * but not the symlink itself even in projects that use monorepos.
- *
- * @param {ContentPath} contentPath
- * @returns {ContentPath[]}
- */ function resolvePathSymlinks(contentPath) {
-    let paths = [
-        contentPath
-    ];
-    try {
-        let resolvedPath = _fs.default.realpathSync(contentPath.base);
-        if (resolvedPath !== contentPath.base) {
-            paths.push({
-                ...contentPath,
-                base: resolvedPath
-            });
-        }
-    } catch  {
-    // TODO: log this?
-    }
-    return paths;
-}
-function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
-    let changedContent = context.tailwindConfig.content.files.filter((item)=>typeof item.raw === "string").map(({ raw , extension ="html"  })=>({
-            content: raw,
-            extension
-        }));
-    let [changedFiles, mTimesToCommit] = resolveChangedFiles(candidateFiles, fileModifiedMap);
-    for (let changedFile of changedFiles){
-        let extension = _path.default.extname(changedFile).slice(1);
-        changedContent.push({
-            file: changedFile,
-            extension
-        });
-    }
-    return [
-        changedContent,
-        mTimesToCommit
-    ];
-}
-/**
- *
- * @param {ContentPath[]} candidateFiles
- * @param {Map<string, number>} fileModifiedMap
- * @returns {[Set<string>, Map<string, number>]}
- */ function resolveChangedFiles(candidateFiles, fileModifiedMap) {
-    let paths = candidateFiles.map((contentPath)=>contentPath.pattern);
-    let mTimesToCommit = new Map();
-    let changedFiles = new Set();
-    _sharedState.env.DEBUG && console.time("Finding changed files");
-    let files = _fastglob.default.sync(paths, {
-        absolute: true
-    });
-    for (let file of files){
-        let prevModified = fileModifiedMap.get(file) || -Infinity;
-        let modified = _fs.default.statSync(file).mtimeMs;
-        if (modified > prevModified) {
-            changedFiles.add(file);
-            mTimesToCommit.set(file, modified);
-        }
-    }
-    _sharedState.env.DEBUG && console.timeEnd("Finding changed files");
-    return [
-        changedFiles,
-        mTimesToCommit
-    ];
-}

package/lib/lib/defaultExtractor.js

@@ -1,251 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "defaultExtractor", {
-    enumerable: true,
-    get: function() {
-        return defaultExtractor;
-    }
-});
-const _regex = /*#__PURE__*/ _interop_require_wildcard(require("./regex"));
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {};
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-function defaultExtractor(context) {
-    let patterns = Array.from(buildRegExps(context));
-    /**
-   * @param {string} content
-   */ return (content)=>{
-        /** @type {(string|string)[]} */ let results = [];
-        for (let pattern of patterns){
-            var _content_match;
-            for (let result of (_content_match = content.match(pattern)) !== null && _content_match !== void 0 ? _content_match : []){
-                results.push(clipAtBalancedParens(result));
-            }
-        }
-        return results;
-    };
-}
-function* buildRegExps(context) {
-    let separator = context.tailwindConfig.separator;
-    let prefix = context.tailwindConfig.prefix !== "" ? _regex.optional(_regex.pattern([
-        /-?/,
-        _regex.escape(context.tailwindConfig.prefix)
-    ])) : "";
-    let utility = _regex.any([
-        // Arbitrary properties (without square brackets)
-        /\[[^\s:'"`]+:[^\s\[\]]+\]/,
-        // Arbitrary properties with balanced square brackets
-        // This is a targeted fix to continue to allow theme()
-        // with square brackets to work in arbitrary properties
-        // while fixing a problem with the regex matching too much
-        /\[[^\s:'"`\]]+:[^\s]+?\[[^\s]+\][^\s]+?\]/,
-        // Utilities
-        _regex.pattern([
-            // Utility Name / Group Name
-            _regex.any([
-                /-?(?:\w+)/,
-                // This is here to make sure @container supports everything that other utilities do
-                /@(?:\w+)/
-            ]),
-            // Normal/Arbitrary values
-            _regex.optional(_regex.any([
-                _regex.pattern([
-                    // Arbitrary values
-                    _regex.any([
-                        /-(?:\w+-)*\['[^\s]+'\]/,
-                        /-(?:\w+-)*\["[^\s]+"\]/,
-                        /-(?:\w+-)*\[`[^\s]+`\]/,
-                        /-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s:\[\]]+\]/
-                    ]),
-                    // Not immediately followed by an `{[(`
-                    /(?![{([]])/,
-                    // optionally followed by an opacity modifier
-                    /(?:\/[^\s'"`\\><$]*)?/
-                ]),
-                _regex.pattern([
-                    // Arbitrary values
-                    _regex.any([
-                        /-(?:\w+-)*\['[^\s]+'\]/,
-                        /-(?:\w+-)*\["[^\s]+"\]/,
-                        /-(?:\w+-)*\[`[^\s]+`\]/,
-                        /-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s\[\]]+\]/
-                    ]),
-                    // Not immediately followed by an `{[(`
-                    /(?![{([]])/,
-                    // optionally followed by an opacity modifier
-                    /(?:\/[^\s'"`\\$]*)?/
-                ]),
-                // Normal values w/o quotes — may include an opacity modifier
-                /[-\/][^\s'"`\\$={><]*/
-            ]))
-        ])
-    ]);
-    let variantPatterns = [
-        // Without quotes
-        _regex.any([
-            // This is here to provide special support for the `@` variant
-            _regex.pattern([
-                /@\[[^\s"'`]+\](\/[^\s"'`]+)?/,
-                separator
-            ]),
-            // With variant modifier (e.g.: group-[..]/modifier)
-            _regex.pattern([
-                /([^\s"'`\[\\]+-)?\[[^\s"'`]+\]\/\w+/,
-                separator
-            ]),
-            _regex.pattern([
-                /([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/,
-                separator
-            ]),
-            _regex.pattern([
-                /[^\s"'`\[\\]+/,
-                separator
-            ])
-        ]),
-        // With quotes allowed
-        _regex.any([
-            // With variant modifier (e.g.: group-[..]/modifier)
-            _regex.pattern([
-                /([^\s"'`\[\\]+-)?\[[^\s`]+\]\/\w+/,
-                separator
-            ]),
-            _regex.pattern([
-                /([^\s"'`\[\\]+-)?\[[^\s`]+\]/,
-                separator
-            ]),
-            _regex.pattern([
-                /[^\s`\[\\]+/,
-                separator
-            ])
-        ])
-    ];
-    for (const variantPattern of variantPatterns){
-        yield _regex.pattern([
-            // Variants
-            "((?=((",
-            variantPattern,
-            ")+))\\2)?",
-            // Important (optional)
-            /!?/,
-            prefix,
-            utility
-        ]);
-    }
-    // 5. Inner matches
-    yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g;
-}
-// We want to capture any "special" characters
-// AND the characters immediately following them (if there is one)
-let SPECIALS = /([\[\]'"`])([^\[\]'"`])?/g;
-let ALLOWED_CLASS_CHARACTERS = /[^"'`\s<>\]]+/;
-/**
- * Clips a string ensuring that parentheses, quotes, etc… are balanced
- * Used for arbitrary values only
- *
- * We will go past the end of the balanced parens until we find a non-class character
- *
- * Depth matching behavior:
- * w-[calc(100%-theme('spacing[some_key][1.5]'))]']
- *   ┬    ┬          ┬┬       ┬        ┬┬   ┬┬┬┬┬┬┬
- *   1    2          3        4        34   3 210 END
- *   ╰────┴──────────┴────────┴────────┴┴───┴─┴┴┴
- *
- * @param {string} input
- */ function clipAtBalancedParens(input) {
-    // We are care about this for arbitrary values
-    if (!input.includes("-[")) {
-        return input;
-    }
-    let depth = 0;
-    let openStringTypes = [];
-    // Find all parens, brackets, quotes, etc
-    // Stop when we end at a balanced pair
-    // This is naive and will treat mismatched parens as balanced
-    // This shouldn't be a problem in practice though
-    let matches = input.matchAll(SPECIALS);
-    // We can't use lookbehind assertions because we have to support Safari
-    // So, instead, we've emulated it using capture groups and we'll re-work the matches to accommodate
-    matches = Array.from(matches).flatMap((match)=>{
-        const [, ...groups] = match;
-        return groups.map((group, idx)=>Object.assign([], match, {
-                index: match.index + idx,
-                0: group
-            }));
-    });
-    for (let match of matches){
-        let char = match[0];
-        let inStringType = openStringTypes[openStringTypes.length - 1];
-        if (char === inStringType) {
-            openStringTypes.pop();
-        } else if (char === "'" || char === '"' || char === "`") {
-            openStringTypes.push(char);
-        }
-        if (inStringType) {
-            continue;
-        } else if (char === "[") {
-            depth++;
-            continue;
-        } else if (char === "]") {
-            depth--;
-            continue;
-        }
-        // We've gone one character past the point where we should stop
-        // This means that there was an extra closing `]`
-        // We'll clip to just before it
-        if (depth < 0) {
-            return input.substring(0, match.index - 1);
-        }
-        // We've finished balancing the brackets but there still may be characters that can be included
-        // For example in the class `text-[#336699]/[.35]`
-        // The depth goes to `0` at the closing `]` but goes up again at the `[`
-        // If we're at zero and encounter a non-class character then we clip the class there
-        if (depth === 0 && !ALLOWED_CLASS_CHARACTERS.test(char)) {
-            return input.substring(0, match.index);
-        }
-    }
-    return input;
-} // Regular utilities
- // {{modifier}:}*{namespace}{-{suffix}}*{/{opacityModifier}}?
- // Arbitrary values
- // {{modifier}:}*{namespace}-[{arbitraryValue}]{/{opacityModifier}}?
- // arbitraryValue: no whitespace, balanced quotes unless within quotes, balanced brackets unless within quotes
- // Arbitrary properties
- // {{modifier}:}*[{validCssPropertyName}:{arbitraryValue}]

package/lib/lib/detectNesting.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-function isRoot(node) {
-    return node.type === "root";
-}
-function isAtLayer(node) {
-    return node.type === "atrule" && node.name === "layer";
-}
-function _default(_context) {
-    return (root, result)=>{
-        let found = false;
-        root.walkAtRules("tailwind", (node)=>{
-            if (found) return false;
-            if (node.parent && !(isRoot(node.parent) || isAtLayer(node.parent))) {
-                found = true;
-                node.warn(result, [
-                    "Nested @tailwind rules were detected, but are not supported.",
-                    "Consider using a prefix to scope Tailwind's classes: https://tailwindcss.com/docs/configuration#prefix",
-                    "Alternatively, use the important selector strategy: https://tailwindcss.com/docs/configuration#selector-strategy"
-                ].join("\n"));
-                return false;
-            }
-        });
-        root.walkRules((rule)=>{
-            if (found) return false;
-            rule.walkRules((nestedRule)=>{
-                found = true;
-                nestedRule.warn(result, [
-                    "Nested CSS was detected, but CSS nesting has not been configured correctly.",
-                    "Please enable a CSS nesting plugin *before* Tailwind in your configuration.",
-                    "See how here: https://tailwindcss.com/docs/using-with-preprocessors#nesting"
-                ].join("\n"));
-                return false;
-            });
-        });
-    };
-}