@yahoo/uds 3.144.0 → 3.145.0-beta.2

package/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/collapseDuplicateDeclarations.js

@@ -0,0 +1,85 @@
+"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/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/content.js

@@ -0,0 +1,247 @@
+// @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;
+    },
+    createBroadPatternCheck: function() {
+        return createBroadPatternCheck;
+    }
+});
+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");
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+const _micromatch = /*#__PURE__*/ _interop_require_default(require("micromatch"));
+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
+    ];
+}
+const LARGE_DIRECTORIES = [
+    "node_modules"
+];
+// Ensures that `node_modules` has to match as-is, otherwise `mynode_modules`
+// would match as well, but that is not a known large directory.
+const LARGE_DIRECTORIES_REGEX = new RegExp(`(${LARGE_DIRECTORIES.map((dir)=>String.raw`\b${dir}\b`).join("|")})`);
+function createBroadPatternCheck(paths) {
+    // Detect whether a glob pattern might be too broad. This means that it:
+    // - Includes `**`
+    // - Does not include any of the known large directories (e.g.: node_modules)
+    let maybeBroadPattern = paths.some((path)=>path.includes("**") && !LARGE_DIRECTORIES_REGEX.test(path));
+    // Didn't detect any potentially broad patterns, so we can skip further
+    // checks.
+    if (!maybeBroadPattern) {
+        return ()=>{};
+    }
+    // All glob matchers
+    let matchers = [];
+    // All glob matchers that explicitly contain any of the known large
+    // directories (e.g.: node_modules).
+    let explicitMatchers = [];
+    // Create matchers for all paths
+    for (let path of paths){
+        let matcher = _micromatch.default.matcher(path);
+        if (LARGE_DIRECTORIES_REGEX.test(path)) {
+            explicitMatchers.push(matcher);
+        }
+        matchers.push(matcher);
+    }
+    // Keep track of whether we already warned about the broad pattern issue or
+    // not. The `log.warn` function already does something similar where we only
+    // output the log once. However, with this we can also skip the other checks
+    // when we already warned about the broad pattern.
+    let warned = false;
+    /**
+   * @param {string} file
+   */ return (file)=>{
+        if (warned) return; // Already warned about the broad pattern
+        if (explicitMatchers.some((matcher)=>matcher(file))) return; // Explicitly included, so we can skip further checks
+        // When a broad pattern is used, we have to double check that the file was
+        // not explicitly included in the globs.
+        let matchingGlobIndex = matchers.findIndex((matcher)=>matcher(file));
+        if (matchingGlobIndex === -1) return; // This should never happen
+        let matchingGlob = paths[matchingGlobIndex];
+        // Create relative paths to make the output a bit more readable.
+        let relativeMatchingGlob = _path.default.relative(process.cwd(), matchingGlob);
+        if (relativeMatchingGlob[0] !== ".") relativeMatchingGlob = `./${relativeMatchingGlob}`;
+        let largeDirectory = LARGE_DIRECTORIES.find((directory)=>file.includes(directory));
+        if (largeDirectory) {
+            warned = true;
+            _log.default.warn("broad-content-glob-pattern", [
+                `Your \`content\` configuration includes a pattern which looks like it's accidentally matching all of \`${largeDirectory}\` and can cause serious performance issues.`,
+                `Pattern: \`${relativeMatchingGlob}\``,
+                `See our documentation for recommendations:`,
+                "https://tailwindcss.com/docs/content-configuration#pattern-recommendations"
+            ]);
+        }
+    };
+}
+/**
+ *
+ * @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 checkBroadPattern = createBroadPatternCheck(paths);
+    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){
+        checkBroadPattern(file);
+        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/dist/tailwind-internal/dist/vendor/tailwindcss/lib/lib/defaultExtractor.js

@@ -0,0 +1,273 @@
+"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"));
+const _splitAtTopLevelOnly = require("../util/splitAtTopLevelOnly");
+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));
+            }
+        }
+        // Extract any subclasses from languages like Slim and Pug, eg:
+        // div.flex.px-5.underline
+        for (let result of results.slice()){
+            let segments = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(result, ".");
+            for(let idx = 0; idx < segments.length; idx++){
+                let segment = segments[idx];
+                if (idx >= segments.length - 1) {
+                    results.push(segment);
+                    continue;
+                }
+                // If the next segment is a number, discard both, for example seeing
+                // `px-1` and `5` means the real candidate was `px-1.5` which is already
+                // captured.
+                let next = Number(segments[idx + 1]);
+                if (isNaN(next)) {
+                    results.push(segment);
+                } else {
+                    idx++;
+                }
+            }
+        }
+        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(){}[\]#=%$]*[^<>"'`\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}]