tailwindcss 0.0.0-insiders.ea10bb9 → 0.0.0-insiders.ea4e1cd

package/lib/lib/generateRules.js

@@ -9,26 +9,33 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getClassNameFromSelector: ()=>getClassNameFromSelector,
-    resolveMatches: ()=>resolveMatches,
-    generateRules: ()=>generateRules
+    getClassNameFromSelector: function() {
+        return getClassNameFromSelector;
+    },
+    resolveMatches: function() {
+        return resolveMatches;
+    },
+    generateRules: function() {
+        return generateRules;
+    }
 });
-const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
-const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
-const _parseObjectStyles = /*#__PURE__*/ _interopRequireDefault(require("../util/parseObjectStyles"));
-const _isPlainObject = /*#__PURE__*/ _interopRequireDefault(require("../util/isPlainObject"));
-const _prefixSelector = /*#__PURE__*/ _interopRequireDefault(require("../util/prefixSelector"));
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
+const _parseObjectStyles = /*#__PURE__*/ _interop_require_default(require("../util/parseObjectStyles"));
+const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("../util/isPlainObject"));
+const _prefixSelector = /*#__PURE__*/ _interop_require_default(require("../util/prefixSelector"));
 const _pluginUtils = require("../util/pluginUtils");
-const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
-const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+const _sharedState = /*#__PURE__*/ _interop_require_wildcard(require("./sharedState"));
 const _formatVariantSelector = require("../util/formatVariantSelector");
 const _nameClass = require("../util/nameClass");
 const _dataTypes = require("../util/dataTypes");
 const _setupContextUtils = require("./setupContextUtils");
-const _isSyntacticallyValidPropertyValue = /*#__PURE__*/ _interopRequireDefault(require("../util/isSyntacticallyValidPropertyValue"));
-const _splitAtTopLevelOnlyJs = require("../util/splitAtTopLevelOnly.js");
+const _isSyntacticallyValidPropertyValue = /*#__PURE__*/ _interop_require_default(require("../util/isSyntacticallyValidPropertyValue"));
+const _splitAtTopLevelOnly = require("../util/splitAtTopLevelOnly.js");
 const _featureFlags = require("../featureFlags");
-function _interopRequireDefault(obj) {
+const _applyImportantSelector = require("../util/applyImportantSelector");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -41,7 +48,7 @@ function _getRequireWildcardCache(nodeInterop) {
         return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
     })(nodeInterop);
 }
-function _interopRequireWildcard(obj, nodeInterop) {
+function _interop_require_wildcard(obj, nodeInterop) {
     if (!nodeInterop && obj && obj.__esModule) {
         return obj;
     }
@@ -72,7 +79,7 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let classNameParser = (0, _postcssSelectorParser.default)((selectors)=>{
+let classNameParser = (0, _postcssselectorparser.default)((selectors)=>{
     return selectors.first.filter(({ type  })=>type === "class").pop().value;
 });
 function getClassNameFromSelector(selector) {
@@ -162,12 +169,12 @@ function applyImportant(matches, classCandidate) {
             ]
         });
         container.walkRules((r)=>{
-            r.selector = (0, _pluginUtils.updateAllClasses)((0, _pluginUtils.filterSelectorsForClass)(r.selector, classCandidate), (className)=>{
-                if (className === classCandidate) {
-                    return `!${className}`;
-                }
-                return className;
-            });
+            let ast = (0, _postcssselectorparser.default)().astSync(r.selector);
+            // Remove extraneous selectors that do not include the base candidate
+            ast.each((sel)=>(0, _formatVariantSelector.eliminateIrrelevantSelectors)(sel, classCandidate));
+            // Update all instances of the base candidate to include the important marker
+            (0, _pluginUtils.updateAllClasses)(ast, (className)=>className === classCandidate ? `!${className}` : className);
+            r.selector = ast.toString();
             r.walkDecls((d)=>d.important = true);
         });
         result.push([
@@ -198,10 +205,16 @@ function applyVariant(variant, matches, context) {
     };
     // Retrieve "modifier"
     {
-        let match = /(.*)\/(.*)$/g.exec(variant);
-        if (match) {
-            variant = match[1];
-            args.modifier = match[2];
+        let [baseVariant, ...modifiers] = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(variant, "/");
+        // This is a hack to support variants with `/` in them, like `ar-1/10/20:text-red-500`
+        // In this case 1/10 is a value but /20 is a modifier
+        if (modifiers.length > 1) {
+            baseVariant = baseVariant + "/" + modifiers.slice(0, -1).join("/");
+            modifiers = modifiers.slice(-1);
+        }
+        if (modifiers.length && !context.variantMap.has(variant)) {
+            variant = baseVariant;
+            args.modifier = modifiers[0];
             if (!(0, _featureFlags.flagEnabled)(context.tailwindConfig, "generalizedModifiers")) {
                 return [];
             }
@@ -216,9 +229,9 @@ function applyVariant(variant, matches, context) {
         // But we don't want:
         //   @-[200px]        (`-` is incorrect)
         //   group[:hover]    (`-` is missing)
-        let match1 = /(.)(-?)\[(.*)\]/g.exec(variant);
-        if (match1) {
-            let [, char, seperator, value] = match1;
+        let match = /(.)(-?)\[(.*)\]/g.exec(variant);
+        if (match) {
+            let [, char, seperator, value] = match;
             // @-[200px] case
             if (char === "@" && seperator === "-") return [];
             // group[:hover] case
@@ -229,20 +242,24 @@ function applyVariant(variant, matches, context) {
     }
     // Register arbitrary variants
     if (isArbitraryValue(variant) && !context.variantMap.has(variant)) {
+        let sort = context.offsets.recordVariant(variant);
         let selector = (0, _dataTypes.normalize)(variant.slice(1, -1));
-        if (!(0, _setupContextUtils.isValidVariantFormatString)(selector)) {
+        let selectors = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(selector, ",");
+        // We do not support multiple selectors for arbitrary variants
+        if (selectors.length > 1) {
             return [];
         }
-        let fn = (0, _setupContextUtils.parseVariant)(selector);
-        let sort = context.offsets.recordVariant(variant);
-        context.variantMap.set(variant, [
-            [
-                sort,
-                fn
-            ]
-        ]);
+        if (!selectors.every(_setupContextUtils.isValidVariantFormatString)) {
+            return [];
+        }
+        let records = selectors.map((sel, idx)=>[
+                context.offsets.applyParallelOffset(sort, idx),
+                (0, _setupContextUtils.parseVariant)(sel.trim())
+            ]);
+        context.variantMap.set(variant, records);
     }
     if (context.variantMap.has(variant)) {
+        let isArbitraryVariant = isArbitraryValue(variant);
         let variantFunctionTuples = context.variantMap.get(variant).slice();
         let result = [];
         for (let [meta, rule] of matches){
@@ -299,21 +316,24 @@ function applyVariant(variant, matches, context) {
                         clone.append(wrapper);
                     },
                     format (selectorFormat) {
-                        collectedFormats.push(selectorFormat);
+                        collectedFormats.push({
+                            format: selectorFormat,
+                            isArbitraryVariant
+                        });
                     },
                     args
                 });
                 // It can happen that a list of format strings is returned from within the function. In that
                 // case, we have to process them as well. We can use the existing `variantSort`.
                 if (Array.isArray(ruleWithVariant)) {
-                    for (let [idx, variantFunction1] of ruleWithVariant.entries()){
+                    for (let [idx, variantFunction] of ruleWithVariant.entries()){
                         // This is a little bit scary since we are pushing to an array of items that we are
                         // currently looping over. However, you can also think of it like a processing queue
                         // where you keep handling jobs until everything is done and each job can queue more
                         // jobs if needed.
                         variantFunctionTuples.push([
                             context.offsets.applyParallelOffset(variantSort, idx),
-                            variantFunction1,
+                            variantFunction,
                             // If the clone has been modified we have to pass that back
                             // though so each rule can use the modified container
                             clone.clone()
@@ -322,7 +342,10 @@ function applyVariant(variant, matches, context) {
                     continue;
                 }
                 if (typeof ruleWithVariant === "string") {
-                    collectedFormats.push(ruleWithVariant);
+                    collectedFormats.push({
+                        format: ruleWithVariant,
+                        isArbitraryVariant
+                    });
                 }
                 if (ruleWithVariant === null) {
                     continue;
@@ -342,7 +365,7 @@ function applyVariant(variant, matches, context) {
                         // as well. E.g.: `${variant}${separator}${className}`.
                         // However, plugin authors probably also prepend or append certain
                         // classes, pseudos, ids, ...
-                        let rebuiltBase = (0, _postcssSelectorParser.default)((selectors)=>{
+                        let rebuiltBase = (0, _postcssselectorparser.default)((selectors)=>{
                             selectors.walkClasses((classNode)=>{
                                 classNode.value = `${variant}${context.tailwindConfig.separator}${classNode.value}`;
                             });
@@ -358,7 +381,10 @@ function applyVariant(variant, matches, context) {
                         //      modified (by plugin): .foo .foo\\:markdown > p
                         //    rebuiltBase (internal): .foo\\:markdown > p
                         //                    format: .foo &
-                        collectedFormats.push(modified.replace(rebuiltBase, "&"));
+                        collectedFormats.push({
+                            format: modified.replace(rebuiltBase, "&"),
+                            isArbitraryVariant
+                        });
                         rule.selector = before;
                     });
                 }
@@ -370,13 +396,12 @@ function applyVariant(variant, matches, context) {
                     ...clone.nodes[0].raws.tailwind,
                     parentLayer: meta.layer
                 };
-                var _collectedFormats;
+                var _meta_collectedFormats;
                 let withOffset = [
                     {
                         ...meta,
                         sort: context.offsets.applyVariantOffset(meta.sort, variantSort, Object.assign(args, context.variantOptions.get(variant))),
-                        collectedFormats: ((_collectedFormats = meta.collectedFormats) !== null && _collectedFormats !== void 0 ? _collectedFormats : []).concat(collectedFormats),
-                        isArbitraryVariant: isArbitraryValue(variant)
+                        collectedFormats: ((_meta_collectedFormats = meta.collectedFormats) !== null && _meta_collectedFormats !== void 0 ? _meta_collectedFormats : []).concat(collectedFormats)
                     },
                     clone.nodes[0]
                 ];
@@ -434,7 +459,7 @@ function isValidPropName(name) {
 function isParsableNode(node) {
     let isParsable = true;
     node.walkDecls((decl)=>{
-        if (!isParsableCssValue(decl.name, decl.value)) {
+        if (!isParsableCssValue(decl.prop, decl.value)) {
             isParsable = false;
             return false;
         }
@@ -456,8 +481,8 @@ function isParsableCssValue(property, value) {
     }
 }
 function extractArbitraryProperty(classCandidate, context) {
-    var ref;
-    let [, property, value] = (ref = classCandidate.match(/^\[([a-zA-Z0-9-_]+):(\S+)\]$/)) !== null && ref !== void 0 ? ref : [];
+    var _classCandidate_match;
+    let [, property, value] = (_classCandidate_match = classCandidate.match(/^\[([a-zA-Z0-9-_]+):(\S+)\]$/)) !== null && _classCandidate_match !== void 0 ? _classCandidate_match : [];
     if (value === undefined) {
         return null;
     }
@@ -531,16 +556,16 @@ function splitWithSeparator(input, separator) {
             _sharedState.NOT_ON_DEMAND
         ];
     }
-    return (0, _splitAtTopLevelOnlyJs.splitAtTopLevelOnly)(input, separator);
+    return (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(input, separator);
 }
 function* recordCandidates(matches, classCandidate) {
     for (const match of matches){
-        var ref;
-        var ref1;
+        var _match__options;
+        var _match__options_preserveSource;
         match[1].raws.tailwind = {
             ...match[1].raws.tailwind,
             classCandidate,
-            preserveSource: (ref1 = (ref = match[0].options) === null || ref === void 0 ? void 0 : ref.preserveSource) !== null && ref1 !== void 0 ? ref1 : false
+            preserveSource: (_match__options_preserveSource = (_match__options = match[0].options) === null || _match__options === void 0 ? void 0 : _match__options.preserveSource) !== null && _match__options_preserveSource !== void 0 ? _match__options_preserveSource : false
         };
         yield match;
     }
@@ -556,7 +581,7 @@ function* resolveMatches(candidate, context, original = candidate) {
     if ((0, _featureFlags.flagEnabled)(context.tailwindConfig, "variantGrouping")) {
         if (classCandidate.startsWith("(") && classCandidate.endsWith(")")) {
             let base = variants.slice().reverse().join(separator);
-            for (let part of (0, _splitAtTopLevelOnlyJs.splitAtTopLevelOnly)(classCandidate.slice(1, -1), ",")){
+            for (let part of (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(classCandidate.slice(1, -1), ",")){
                 yield* resolveMatches(base + separator + part, context, original);
             }
         }
@@ -598,25 +623,25 @@ function* resolveMatches(candidate, context, original = candidate) {
                     }
                 }
             } else if (modifier === "DEFAULT" || modifier === "-DEFAULT") {
-                let ruleSet1 = plugin;
-                let [rules1, options1] = parseRules(ruleSet1, context.postCssNodeCache);
-                for (let rule1 of rules1){
+                let ruleSet = plugin;
+                let [rules, options] = parseRules(ruleSet, context.postCssNodeCache);
+                for (let rule of rules){
                     matchesPerPlugin.push([
                         {
                             ...sort,
                             options: {
                                 ...sort.options,
-                                ...options1
+                                ...options
                             }
                         },
-                        rule1
+                        rule
                     ]);
                 }
             }
             if (matchesPerPlugin.length > 0) {
-                var ref;
-                var ref1, _options;
-                let matchingTypes = Array.from((0, _pluginUtils.getMatchingTypes)((ref1 = (ref = sort.options) === null || ref === void 0 ? void 0 : ref.types) !== null && ref1 !== void 0 ? ref1 : [], modifier, (_options = sort.options) !== null && _options !== void 0 ? _options : {}, context.tailwindConfig)).map(([_, type])=>type);
+                var _sort_options;
+                var _sort_options_types, _sort_options1;
+                let matchingTypes = Array.from((0, _pluginUtils.getMatchingTypes)((_sort_options_types = (_sort_options = sort.options) === null || _sort_options === void 0 ? void 0 : _sort_options.types) !== null && _sort_options_types !== void 0 ? _sort_options_types : [], modifier, (_sort_options1 = sort.options) !== null && _sort_options1 !== void 0 ? _sort_options1 : {}, context.tailwindConfig)).map(([_, type])=>type);
                 if (matchingTypes.length > 0) {
                     typesByMatches.set(matchesPerPlugin, matchingTypes);
                 }
@@ -656,18 +681,18 @@ function* resolveMatches(candidate, context, original = candidate) {
                         });
                     });
                 }
-                var ref2;
+                var _findFallback;
                 // Try to find a fallback plugin, because we already know that multiple plugins matched for
                 // the given arbitrary value.
-                let fallback = (ref2 = findFallback(withoutAny)) !== null && ref2 !== void 0 ? ref2 : findFallback(withAny);
+                let fallback = (_findFallback = findFallback(withoutAny)) !== null && _findFallback !== void 0 ? _findFallback : findFallback(withAny);
                 if (fallback) {
                     matches = [
                         fallback
                     ];
                 } else {
-                    var ref3;
+                    var _typesByMatches_get;
                     let typesPerPlugin = matches.map((match)=>new Set([
-                            ...(ref3 = typesByMatches.get(match)) !== null && ref3 !== void 0 ? ref3 : []
+                            ...(_typesByMatches_get = typesByMatches.get(match)) !== null && _typesByMatches_get !== void 0 ? _typesByMatches_get : []
                         ]));
                     // Remove duplicates, so that we can detect proper unique types for each plugin.
                     for (let pluginTypes of typesPerPlugin){
@@ -685,11 +710,11 @@ function* resolveMatches(candidate, context, original = candidate) {
                     }
                     let messages = [];
                     for (let [idx, group] of typesPerPlugin.entries()){
-                        for (let type1 of group){
-                            let rules2 = matches[idx].map(([, rule])=>rule).flat().map((rule)=>rule.toString().split("\n").slice(1, -1) // Remove selector and closing '}'
+                        for (let type of group){
+                            let rules = matches[idx].map(([, rule])=>rule).flat().map((rule)=>rule.toString().split("\n").slice(1, -1) // Remove selector and closing '}'
                                 .map((line)=>line.trim()).map((x)=>`      ${x}`) // Re-indent
                                 .join("\n")).join("\n\n");
-                            messages.push(`  Use \`${candidate.replace("[", `[${type1}:`)}\` for \`${rules2.trim()}\``);
+                            messages.push(`  Use \`${candidate.replace("[", `[${type}:`)}\` for \`${rules.trim()}\``);
                             break;
                         }
                     }
@@ -718,31 +743,71 @@ function* resolveMatches(candidate, context, original = candidate) {
                 candidate
             };
             // Apply final format selector
-            if (match[0].collectedFormats) {
-                let finalFormat = (0, _formatVariantSelector.formatVariantSelector)("&", ...match[0].collectedFormats);
-                let container = _postcss.default.root({
-                    nodes: [
-                        match[1].clone()
-                    ]
-                });
-                container.walkRules((rule)=>{
-                    var ref;
-                    if (inKeyframes(rule)) return;
-                    var ref1;
-                    rule.selector = (0, _formatVariantSelector.finalizeSelector)(finalFormat, {
-                        selector: rule.selector,
-                        candidate: original,
-                        base: candidate.split(new RegExp(`\\${(ref1 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref1 !== void 0 ? ref1 : ":"}(?![^[]*\\])`)).pop(),
-                        isArbitraryVariant: match[0].isArbitraryVariant,
-                        context
-                    });
-                });
-                match[1] = container.nodes[0];
+            match = applyFinalFormat(match, {
+                context,
+                candidate,
+                original
+            });
+            // Skip rules with invalid selectors
+            // This will cause the candidate to be added to the "not class"
+            // cache skipping it entirely for future builds
+            if (match === null) {
+                continue;
             }
             yield match;
         }
     }
 }
+function applyFinalFormat(match, { context , candidate , original  }) {
+    if (!match[0].collectedFormats) {
+        return match;
+    }
+    let isValid = true;
+    let finalFormat;
+    try {
+        finalFormat = (0, _formatVariantSelector.formatVariantSelector)(match[0].collectedFormats, {
+            context,
+            candidate
+        });
+    } catch  {
+        // The format selector we produced is invalid
+        // This could be because:
+        // - A bug exists
+        // - A plugin introduced an invalid variant selector (ex: `addVariant('foo', '&;foo')`)
+        // - The user used an invalid arbitrary variant (ex: `[&;foo]:underline`)
+        // Either way the build will fail because of this
+        // We would rather that the build pass "silently" given that this could
+        // happen because of picking up invalid things when scanning content
+        // So we'll throw out the candidate instead
+        return null;
+    }
+    let container = _postcss.default.root({
+        nodes: [
+            match[1].clone()
+        ]
+    });
+    container.walkRules((rule)=>{
+        if (inKeyframes(rule)) {
+            return;
+        }
+        try {
+            rule.selector = (0, _formatVariantSelector.finalizeSelector)(rule.selector, finalFormat, {
+                candidate: original,
+                context
+            });
+        } catch  {
+            // If this selector is invalid we also want to skip it
+            // But it's likely that being invalid here means there's a bug in a plugin rather than too loosely matching content
+            isValid = false;
+            return false;
+        }
+    });
+    if (!isValid) {
+        return null;
+    }
+    match[1] = container.nodes[0];
+    return match;
+}
 function inKeyframes(rule) {
     return rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes";
 }
@@ -765,7 +830,7 @@ function getImportantStrategy(important) {
                 return;
             }
             rule.selectors = rule.selectors.map((selector)=>{
-                return `${important} ${selector}`;
+                return (0, _applyImportantSelector.applyImportantSelector)(selector, important);
             });
         };
     }
@@ -787,8 +852,8 @@ function generateRules(candidates, context) {
             continue;
         }
         context.classCache.set(candidate, matches);
-        var ref;
-        let rules = (ref = context.candidateRuleCache.get(candidate)) !== null && ref !== void 0 ? ref : new Set();
+        var _context_candidateRuleCache_get;
+        let rules = (_context_candidateRuleCache_get = context.candidateRuleCache.get(candidate)) !== null && _context_candidateRuleCache_get !== void 0 ? _context_candidateRuleCache_get : new Set();
         context.candidateRuleCache.set(candidate, rules);
         for (const match of matches){
             let [{ sort , options  }, rule] = match;

package/lib/lib/getModuleDependencies.js

@@ -4,48 +4,96 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>getModuleDependencies
+    get: function() {
+        return getModuleDependencies;
+    }
 });
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _resolve = /*#__PURE__*/ _interopRequireDefault(require("resolve"));
-const _detective = /*#__PURE__*/ _interopRequireDefault(require("detective"));
-function _interopRequireDefault(obj) {
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function createModule(file) {
-    const source = _fs.default.readFileSync(file, "utf-8");
-    const requires = (0, _detective.default)(source);
-    return {
-        file,
-        requires
-    };
+let jsExtensions = [
+    ".js",
+    ".cjs",
+    ".mjs"
+];
+// Given the current file `a.ts`, we want to make sure that when importing `b` that we resolve
+// `b.ts` before `b.js`
+//
+// E.g.:
+//
+// a.ts
+//   b // .ts
+//   c // .ts
+// a.js
+//   b // .js or .ts
+let jsResolutionOrder = [
+    "",
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".ts",
+    ".cts",
+    ".mts",
+    ".jsx",
+    ".tsx"
+];
+let tsResolutionOrder = [
+    "",
+    ".ts",
+    ".cts",
+    ".mts",
+    ".tsx",
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".jsx"
+];
+function resolveWithExtension(file, extensions) {
+    // Try to find `./a.ts`, `./a.ts`, ... from `./a`
+    for (let ext of extensions){
+        let full = `${file}${ext}`;
+        if (_fs.default.existsSync(full) && _fs.default.statSync(full).isFile()) {
+            return full;
+        }
+    }
+    // Try to find `./a/index.js` from `./a`
+    for (let ext of extensions){
+        let full = `${file}/index${ext}`;
+        if (_fs.default.existsSync(full)) {
+            return full;
+        }
+    }
+    return null;
 }
-function getModuleDependencies(entryFile) {
-    const rootModule = createModule(entryFile);
-    const modules = [
-        rootModule
-    ];
-    // Iterate over the modules, even when new
-    // ones are being added
-    for (const mdl of modules){
-        mdl.requires.filter((dep)=>{
-            // Only track local modules, not node_modules
-            return dep.startsWith("./") || dep.startsWith("../");
-        }).forEach((dep)=>{
-            try {
-                const basedir = _path.default.dirname(mdl.file);
-                const depPath = _resolve.default.sync(dep, {
-                    basedir
-                });
-                const depModule = createModule(depPath);
-                modules.push(depModule);
-            } catch (_err) {
-            // eslint-disable-next-line no-empty
-            }
-        });
+function* _getModuleDependencies(filename, base, seen, ext = _path.default.extname(filename)) {
+    // Try to find the file
+    let absoluteFile = resolveWithExtension(_path.default.resolve(base, filename), jsExtensions.includes(ext) ? jsResolutionOrder : tsResolutionOrder);
+    if (absoluteFile === null) return; // File doesn't exist
+    // Prevent infinite loops when there are circular dependencies
+    if (seen.has(absoluteFile)) return; // Already seen
+    seen.add(absoluteFile);
+    // Mark the file as a dependency
+    yield absoluteFile;
+    // Resolve new base for new imports/requires
+    base = _path.default.dirname(absoluteFile);
+    ext = _path.default.extname(absoluteFile);
+    let contents = _fs.default.readFileSync(absoluteFile, "utf-8");
+    // Find imports/requires
+    for (let match of [
+        ...contents.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
+        ...contents.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
+        ...contents.matchAll(/require\(['"`](.+)['"`]\)/gi)
+    ]){
+        // Bail out if it's not a relative file
+        if (!match[1].startsWith(".")) continue;
+        yield* _getModuleDependencies(match[1], base, seen, ext);
     }
-    return modules;
+}
+function getModuleDependencies(absoluteFilePath) {
+    if (absoluteFilePath === null) return new Set();
+    return new Set(_getModuleDependencies(absoluteFilePath, _path.default.dirname(absoluteFilePath), new Set()));
 }

package/lib/lib/load-config.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadConfig", {
+    enumerable: true,
+    get: function() {
+        return loadConfig;
+    }
+});
+const _jiti = /*#__PURE__*/ _interop_require_default(require("jiti"));
+const _sucrase = require("sucrase");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let jiti = null;
+function lazyJiti() {
+    return jiti !== null && jiti !== void 0 ? jiti : jiti = (0, _jiti.default)(__filename, {
+        interopDefault: true,
+        transform: (opts)=>{
+            return (0, _sucrase.transform)(opts.source, {
+                transforms: [
+                    "typescript",
+                    "imports"
+                ]
+            });
+        }
+    });
+}
+function loadConfig(path) {
+    let config = function() {
+        try {
+            return path ? require(path) : {};
+        } catch  {
+            return lazyJiti()(path);
+        }
+    }();
+    var _config_default;
+    return (_config_default = config.default) !== null && _config_default !== void 0 ? _config_default : config;
+}

package/lib/lib/normalizeTailwindDirectives.js

@@ -4,10 +4,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "default", {
     enumerable: true,
-    get: ()=>normalizeTailwindDirectives
+    get: function() {
+        return normalizeTailwindDirectives;
+    }
 });
-const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
-function _interopRequireDefault(obj) {
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };