@knighted/css 1.0.0-rc.8 → 1.0.0-rc.9

package/dist/cjs/css.cjs

@@ -9,9 +9,9 @@ exports.cssWithMeta = cssWithMeta;
 exports.compileVanillaModule = compileVanillaModule;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = require("node:fs");
-const dependency_tree_1 = __importDefault(require("dependency-tree"));
 const lightningcss_1 = require("lightningcss");
 const helpers_js_1 = require("./helpers.cjs");
+const moduleGraph_js_1 = require("./moduleGraph.cjs");
 const sassInternals_js_1 = require("./sassInternals.cjs");
 exports.DEFAULT_EXTENSIONS = ['.css', '.scss', '.sass', '.less', '.css.ts'];
 async function css(entry, options = {}) {
@@ -22,11 +22,12 @@ async function cssWithMeta(entry, options = {}) {
     const cwd = options.cwd ? node_path_1.default.resolve(options.cwd) : process.cwd();
     const entryPath = await resolveEntry(entry, cwd, options.resolver);
     const extensions = (options.extensions ?? exports.DEFAULT_EXTENSIONS).map(ext => ext.toLowerCase());
-    const files = collectStyleDependencies(entryPath, {
+    const files = await collectStyleDependencies(entryPath, {
         cwd,
         extensions,
         filter: options.filter,
-        dependencyTreeOptions: options.dependencyTree,
+        graphOptions: options.moduleGraph,
+        resolver: options.resolver,
     });
     if (files.length === 0) {
         return { css: '', files: [] };
@@ -76,30 +77,33 @@ async function resolveEntry(entry, cwd, resolver) {
     }
     return node_path_1.default.resolve(cwd, entry);
 }
-function collectStyleDependencies(entryPath, { cwd, extensions, filter, dependencyTreeOptions, }) {
+async function collectStyleDependencies(entryPath, { cwd, extensions, filter, graphOptions, resolver, }) {
     const seen = new Set();
     const order = [];
     const shouldInclude = typeof filter === 'function'
         ? filter
         : (filePath) => !filePath.includes('node_modules');
     const entryIsStyle = Boolean(matchExtension(entryPath, extensions));
-    let treeList = [];
+    let discoveredStyles = [];
     if (!entryIsStyle) {
-        const dependencyConfig = {
-            ...dependencyTreeOptions,
-            filename: entryPath,
-            directory: cwd,
+        discoveredStyles = await (0, moduleGraph_js_1.collectStyleImports)(entryPath, {
+            cwd,
+            styleExtensions: extensions,
             filter: shouldInclude,
-        };
-        treeList = dependency_tree_1.default.toList(dependencyConfig);
+            resolver,
+            graphOptions,
+        });
     }
-    const candidates = entryIsStyle ? [entryPath] : [entryPath, ...treeList];
+    const candidates = entryIsStyle ? [entryPath] : [entryPath, ...discoveredStyles];
     for (const candidate of candidates) {
         const match = matchExtension(candidate, extensions);
-        if (!match || seen.has(candidate))
+        if (!match)
+            continue;
+        const resolvedCandidate = node_path_1.default.resolve(candidate);
+        if (seen.has(resolvedCandidate))
             continue;
-        seen.add(candidate);
-        order.push({ path: node_path_1.default.resolve(candidate), ext: match });
+        seen.add(resolvedCandidate);
+        order.push({ path: resolvedCandidate, ext: match });
     }
     return order;
 }

package/dist/cjs/css.d.cts

@@ -1,8 +1,9 @@
-import type { Options as DependencyTreeOpts } from 'dependency-tree';
 import { type TransformOptions as LightningTransformOptions } from 'lightningcss';
 import { type SpecificitySelector, type SpecificityStrategy } from './helpers.cjs';
-import type { CssResolver } from './sassInternals.cjs';
-export type { CssResolver } from './sassInternals.cjs';
+import type { ModuleGraphOptions } from './moduleGraph.cjs';
+import type { CssResolver } from './types.cjs';
+export type { CssResolver } from './types.cjs';
+export type { ModuleGraphOptions } from './moduleGraph.cjs';
 export declare const DEFAULT_EXTENSIONS: string[];
 type LightningCssConfig = boolean | Partial<Omit<LightningTransformOptions<never>, 'code'>>;
 type PeerLoader = (name: string) => Promise<unknown>;
@@ -16,7 +17,7 @@ export interface CssOptions {
         strategy?: SpecificityStrategy;
         match?: SpecificitySelector[];
     };
-    dependencyTree?: Partial<Omit<DependencyTreeOpts, 'filename' | 'directory'>>;
+    moduleGraph?: ModuleGraphOptions;
     resolver?: CssResolver;
     peerResolver?: PeerLoader;
 }

package/dist/cjs/moduleGraph.cjs

@@ -0,0 +1,431 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectStyleImports = collectStyleImports;
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
+const node_fs_1 = require("node:fs");
+const node_url_1 = require("node:url");
+const oxc_parser_1 = require("oxc-parser");
+const oxc_resolver_1 = require("oxc-resolver");
+const tsconfig_paths_1 = require("tsconfig-paths");
+const get_tsconfig_1 = require("get-tsconfig");
+const SCRIPT_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
+const BUILTIN_SPECIFIERS = new Set([
+    ...node_module_1.builtinModules,
+    ...node_module_1.builtinModules.map(mod => `node:${mod}`),
+]);
+const tsconfigResultCache = new Map();
+const tsconfigFsCache = new Map();
+async function collectStyleImports(entryPath, options) {
+    const { cwd, styleExtensions, filter, resolver, graphOptions } = options;
+    const normalizedStyles = normalizeExtensions(styleExtensions);
+    const scriptExtensions = normalizeExtensions([
+        ...SCRIPT_EXTENSIONS,
+        ...(graphOptions?.extensions ?? []),
+    ]);
+    const resolutionExtensions = dedupeExtensions([
+        ...scriptExtensions,
+        ...normalizedStyles,
+    ]);
+    const tsconfigMatcher = createTsconfigMatcher(graphOptions?.tsConfig, cwd, resolutionExtensions);
+    const seenScripts = new Set();
+    const seenStyles = new Set();
+    const styleOrder = [];
+    const resolutionCache = new Map();
+    const resolverFactory = createResolverFactory(cwd, resolutionExtensions, scriptExtensions, graphOptions);
+    async function walk(filePath) {
+        const absolutePath = node_path_1.default.resolve(filePath);
+        if (seenScripts.has(absolutePath)) {
+            return;
+        }
+        seenScripts.add(absolutePath);
+        const source = await readSourceFile(absolutePath);
+        if (!source) {
+            return;
+        }
+        const specifiers = extractModuleSpecifiers(source, absolutePath);
+        for (const specifier of specifiers) {
+            if (!specifier || isBuiltinSpecifier(specifier)) {
+                continue;
+            }
+            const resolved = await resolveImport(specifier, absolutePath);
+            if (!resolved) {
+                continue;
+            }
+            const normalized = node_path_1.default.resolve(resolved);
+            if (!filter(normalized)) {
+                continue;
+            }
+            if (isStyleExtension(normalized, normalizedStyles)) {
+                if (!seenStyles.has(normalized)) {
+                    seenStyles.add(normalized);
+                    styleOrder.push(normalized);
+                }
+                continue;
+            }
+            if (isScriptExtension(normalized, scriptExtensions)) {
+                await walk(normalized);
+            }
+        }
+    }
+    async function resolveImport(specifier, importer) {
+        const cacheKey = `${importer}::${specifier}`;
+        if (resolutionCache.has(cacheKey)) {
+            return resolutionCache.get(cacheKey);
+        }
+        let resolved;
+        if (resolver) {
+            resolved = normalizeResolverResult(await resolver(specifier, { cwd, from: importer }), cwd);
+        }
+        if (!resolved && tsconfigMatcher) {
+            resolved = tsconfigMatcher(specifier);
+        }
+        if (!resolved) {
+            resolved = resolveWithFactory(resolverFactory, specifier, importer, resolutionExtensions);
+        }
+        resolutionCache.set(cacheKey, resolved);
+        return resolved;
+    }
+    await walk(entryPath);
+    return styleOrder;
+}
+function normalizeExtensions(extensions) {
+    const result = new Set();
+    for (const ext of extensions) {
+        if (!ext)
+            continue;
+        const normalized = ext.startsWith('.') ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+        result.add(normalized);
+    }
+    return Array.from(result);
+}
+function dedupeExtensions(extensions) {
+    const result = new Set();
+    for (const ext of extensions) {
+        result.add(ext);
+    }
+    return Array.from(result);
+}
+function isBuiltinSpecifier(specifier) {
+    if (BUILTIN_SPECIFIERS.has(specifier)) {
+        return true;
+    }
+    if (specifier.startsWith('node:')) {
+        return true;
+    }
+    return false;
+}
+function isStyleExtension(filePath, extensions) {
+    const lower = filePath.toLowerCase();
+    return extensions.some(ext => lower.endsWith(ext));
+}
+function isScriptExtension(filePath, extensions) {
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    return extensions.includes(ext);
+}
+async function readSourceFile(filePath) {
+    try {
+        return await node_fs_1.promises.readFile(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractModuleSpecifiers(sourceText, filePath) {
+    let program;
+    try {
+        ;
+        ({ program } = (0, oxc_parser_1.parseSync)(filePath, sourceText, { sourceType: 'unambiguous' }));
+    }
+    catch {
+        return [];
+    }
+    const specifiers = [];
+    const addSpecifier = (raw) => {
+        if (!raw) {
+            return;
+        }
+        const normalized = normalizeSpecifier(raw);
+        if (normalized) {
+            specifiers.push(normalized);
+        }
+    };
+    const visitor = new oxc_parser_1.Visitor({
+        ImportDeclaration(node) {
+            addSpecifier(node.source?.value);
+        },
+        ExportNamedDeclaration(node) {
+            if (node.source) {
+                addSpecifier(node.source.value);
+            }
+        },
+        ExportAllDeclaration(node) {
+            addSpecifier(node.source?.value);
+        },
+        TSImportEqualsDeclaration(node) {
+            const specifier = extractImportEqualsSpecifier(node);
+            if (specifier) {
+                addSpecifier(specifier);
+            }
+        },
+        ImportExpression(node) {
+            const specifier = getStringFromExpression(node.source);
+            if (specifier) {
+                addSpecifier(specifier);
+            }
+        },
+        CallExpression(node) {
+            if (!isRequireLikeCallee(node.callee)) {
+                return;
+            }
+            const specifier = getStringFromArgument(node.arguments[0]);
+            if (specifier) {
+                addSpecifier(specifier);
+            }
+        },
+    });
+    visitor.visit(program);
+    return specifiers;
+}
+function normalizeSpecifier(raw) {
+    if (!raw)
+        return '';
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith('\0')) {
+        return '';
+    }
+    const queryIndex = trimmed.search(/[?#]/);
+    const withoutQuery = queryIndex === -1 ? trimmed : trimmed.slice(0, queryIndex);
+    if (!withoutQuery) {
+        return '';
+    }
+    if (/^[a-z][\w+.-]*:/i.test(withoutQuery) && !withoutQuery.startsWith('file:')) {
+        return '';
+    }
+    return withoutQuery;
+}
+function extractImportEqualsSpecifier(node) {
+    if (node.moduleReference.type === 'TSExternalModuleReference') {
+        return node.moduleReference.expression.value;
+    }
+    return undefined;
+}
+function getStringFromArgument(argument) {
+    if (!argument || argument.type === 'SpreadElement') {
+        return undefined;
+    }
+    return getStringFromExpression(argument);
+}
+function getStringFromExpression(expression) {
+    if (!expression) {
+        return undefined;
+    }
+    if (expression.type === 'Literal') {
+        const literalValue = expression.value;
+        return typeof literalValue === 'string' ? literalValue : undefined;
+    }
+    if (expression.type === 'TemplateLiteral' && expression.expressions.length === 0) {
+        const [first] = expression.quasis;
+        return first?.value.cooked ?? first?.value.raw ?? undefined;
+    }
+    return undefined;
+}
+function isRequireLikeCallee(expression) {
+    const target = unwrapExpression(expression);
+    if (target.type === 'Identifier') {
+        return target.name === 'require';
+    }
+    if (target.type === 'MemberExpression') {
+        const object = target.object;
+        if (object.type === 'Identifier') {
+            return object.name === 'require';
+        }
+    }
+    return false;
+}
+function unwrapExpression(expression) {
+    if (expression.type === 'ChainExpression') {
+        const inner = expression.expression;
+        if (inner.type === 'CallExpression') {
+            return unwrapExpression(inner.callee);
+        }
+        return unwrapExpression(inner);
+    }
+    if (expression.type === 'TSNonNullExpression') {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+}
+function normalizeResolverResult(result, cwd) {
+    if (!result) {
+        return undefined;
+    }
+    if (result.startsWith('file://')) {
+        try {
+            return (0, node_url_1.fileURLToPath)(new URL(result));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return node_path_1.default.isAbsolute(result) ? result : node_path_1.default.resolve(cwd, result);
+}
+function resolveWithFactory(factory, specifier, importer, extensions) {
+    if (specifier.startsWith('file://')) {
+        try {
+            return findExistingFile((0, node_url_1.fileURLToPath)(new URL(specifier)), extensions);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (/^[a-z][\w+.-]*:/i.test(specifier)) {
+        return undefined;
+    }
+    try {
+        const result = factory.resolveFileSync(importer, specifier);
+        return result?.path;
+    }
+    catch {
+        return undefined;
+    }
+}
+function createResolverFactory(cwd, extensions, scriptExtensions, graphOptions) {
+    const options = {
+        extensions,
+        conditionNames: graphOptions?.conditions,
+    };
+    const extensionAlias = buildExtensionAlias(scriptExtensions);
+    if (extensionAlias) {
+        options.extensionAlias = extensionAlias;
+    }
+    const tsconfigOption = resolveResolverTsconfig(graphOptions?.tsConfig, cwd);
+    if (tsconfigOption) {
+        options.tsconfig = tsconfigOption;
+    }
+    return new oxc_resolver_1.ResolverFactory(options);
+}
+function buildExtensionAlias(scriptExtensions) {
+    const alias = {};
+    const jsTargets = dedupeExtensions(scriptExtensions.filter(ext => ['.js', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts'].includes(ext)));
+    if (jsTargets.length > 0) {
+        for (const key of ['.js', '.mjs', '.cjs']) {
+            alias[key] = jsTargets;
+        }
+    }
+    const jsxTargets = dedupeExtensions(scriptExtensions.filter(ext => ext === '.jsx' || ext === '.tsx'));
+    if (jsxTargets.length > 0) {
+        alias['.jsx'] = jsxTargets;
+    }
+    return Object.keys(alias).length > 0 ? alias : undefined;
+}
+function resolveResolverTsconfig(input, cwd) {
+    if (!input || typeof input !== 'string') {
+        return undefined;
+    }
+    const resolved = resolveTsconfigPath(input, cwd);
+    if (!resolved) {
+        return undefined;
+    }
+    return { configFile: resolved };
+}
+function createTsconfigMatcher(input, cwd, extensions) {
+    const config = loadTsconfigPaths(input, cwd);
+    if (!config) {
+        return undefined;
+    }
+    const matchPath = (0, tsconfig_paths_1.createMatchPath)(config.absoluteBaseUrl, config.paths);
+    return (specifier) => {
+        const matched = matchPath(specifier, undefined, undefined, extensions);
+        if (!matched) {
+            return undefined;
+        }
+        return findExistingFile(matched, extensions) ?? matched;
+    };
+}
+function loadTsconfigPaths(input, cwd) {
+    if (!input) {
+        return undefined;
+    }
+    if (typeof input === 'string') {
+        const target = node_path_1.default.isAbsolute(input) ? input : node_path_1.default.resolve(cwd, input);
+        const cached = tsconfigResultCache.get(target);
+        if (cached !== undefined) {
+            return cached ?? undefined;
+        }
+        const result = (0, get_tsconfig_1.getTsconfig)(target, undefined, tsconfigFsCache);
+        if (!result) {
+            tsconfigResultCache.set(target, null);
+            return undefined;
+        }
+        const normalized = normalizeTsconfigCompilerOptions(result.config.compilerOptions, node_path_1.default.dirname(result.path));
+        tsconfigResultCache.set(target, normalized ?? null);
+        return normalized;
+    }
+    const compilerOptions = input.compilerOptions;
+    return normalizeTsconfigCompilerOptions(compilerOptions, cwd);
+}
+function normalizeTsconfigCompilerOptions(compilerOptions, configDir) {
+    if (!compilerOptions?.baseUrl || !compilerOptions.paths) {
+        return undefined;
+    }
+    const normalizedPaths = {};
+    for (const [pattern, replacements] of Object.entries(compilerOptions.paths)) {
+        if (!replacements || replacements.length === 0) {
+            continue;
+        }
+        normalizedPaths[pattern] = Array.isArray(replacements)
+            ? [...replacements]
+            : [replacements];
+    }
+    if (Object.keys(normalizedPaths).length === 0) {
+        return undefined;
+    }
+    const absoluteBaseUrl = node_path_1.default.isAbsolute(compilerOptions.baseUrl)
+        ? compilerOptions.baseUrl
+        : node_path_1.default.resolve(configDir, compilerOptions.baseUrl);
+    return { absoluteBaseUrl, paths: normalizedPaths };
+}
+function resolveTsconfigPath(tsconfigPath, cwd) {
+    const absolute = node_path_1.default.isAbsolute(tsconfigPath)
+        ? tsconfigPath
+        : node_path_1.default.resolve(cwd, tsconfigPath);
+    if (!(0, node_fs_1.existsSync)(absolute)) {
+        return undefined;
+    }
+    const stats = (0, node_fs_1.statSync)(absolute);
+    if (stats.isDirectory()) {
+        const candidate = node_path_1.default.join(absolute, 'tsconfig.json');
+        return (0, node_fs_1.existsSync)(candidate) ? candidate : undefined;
+    }
+    return absolute;
+}
+function findExistingFile(candidate, extensions) {
+    const candidateHasExt = hasExtension(candidate);
+    if (candidateHasExt && (0, node_fs_1.existsSync)(candidate)) {
+        return candidate;
+    }
+    if (!candidateHasExt) {
+        for (const ext of extensions) {
+            const withExt = `${candidate}${ext}`;
+            if ((0, node_fs_1.existsSync)(withExt)) {
+                return withExt;
+            }
+        }
+    }
+    if ((0, node_fs_1.existsSync)(candidate) && (0, node_fs_1.statSync)(candidate).isDirectory()) {
+        for (const ext of extensions) {
+            const indexPath = node_path_1.default.join(candidate, `index${ext}`);
+            if ((0, node_fs_1.existsSync)(indexPath)) {
+                return indexPath;
+            }
+        }
+    }
+    return undefined;
+}
+function hasExtension(filePath) {
+    return Boolean(node_path_1.default.extname(filePath));
+}

package/dist/cjs/moduleGraph.d.cts

@@ -0,0 +1,15 @@
+import type { CssResolver } from './types.cjs';
+export interface ModuleGraphOptions {
+    tsConfig?: string | Record<string, unknown>;
+    extensions?: string[];
+    conditions?: string[];
+}
+interface CollectOptions {
+    cwd: string;
+    styleExtensions: string[];
+    filter: (filePath: string) => boolean;
+    resolver?: CssResolver;
+    graphOptions?: ModuleGraphOptions;
+}
+export declare function collectStyleImports(entryPath: string, options: CollectOptions): Promise<string[]>;
+export {};

package/dist/cjs/sassInternals.cjs

@@ -24,8 +24,11 @@ function createSassImporter({ cwd, resolver, }) {
                     console.error('[knighted-css:sass] containing url:', context.containingUrl.href);
                 }
             }
+            const containingPath = context?.containingUrl
+                ? (0, node_url_1.fileURLToPath)(context.containingUrl)
+                : undefined;
             if (shouldNormalizeSpecifier(url)) {
-                const resolvedPath = await resolveAliasSpecifier(url, resolver, cwd);
+                const resolvedPath = await resolveAliasSpecifier(url, resolver, cwd, containingPath);
                 if (!resolvedPath) {
                     if (debug) {
                         console.error('[knighted-css:sass] resolver returned no result for', url);
@@ -61,8 +64,8 @@ function createSassImporter({ cwd, resolver, }) {
         },
     };
 }
-async function resolveAliasSpecifier(specifier, resolver, cwd) {
-    const resolved = await resolver(specifier, { cwd });
+async function resolveAliasSpecifier(specifier, resolver, cwd, from) {
+    const resolved = await resolver(specifier, { cwd, from });
     if (!resolved) {
         return undefined;
     }

package/dist/cjs/sassInternals.d.cts

@@ -1,6 +1,5 @@
-export type CssResolver = (specifier: string, ctx: {
-    cwd: string;
-}) => string | Promise<string | undefined>;
+import type { CssResolver } from './types.cjs';
+export type { CssResolver } from './types.cjs';
 export declare function createSassImporter({ cwd, resolver, }: {
     cwd: string;
     resolver?: CssResolver;
@@ -13,7 +12,7 @@ export declare function createSassImporter({ cwd, resolver, }: {
         syntax: "scss" | "indented";
     }>;
 } | undefined;
-export declare function resolveAliasSpecifier(specifier: string, resolver: CssResolver, cwd: string): Promise<string | undefined>;
+export declare function resolveAliasSpecifier(specifier: string, resolver: CssResolver, cwd: string, from?: string): Promise<string | undefined>;
 export declare function shouldNormalizeSpecifier(specifier: string): boolean;
 export declare function ensureSassPath(filePath: string): string | undefined;
 export declare function resolveRelativeSpecifier(specifier: string, containingUrl?: URL | null): string | undefined;

package/dist/cjs/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types.d.cts

@@ -0,0 +1,4 @@
+export type CssResolver = (specifier: string, ctx: {
+    cwd: string;
+    from?: string;
+}) => string | Promise<string | undefined>;

package/dist/css.d.ts

@@ -1,8 +1,9 @@
-import type { Options as DependencyTreeOpts } from 'dependency-tree';
 import { type TransformOptions as LightningTransformOptions } from 'lightningcss';
 import { type SpecificitySelector, type SpecificityStrategy } from './helpers.js';
-import type { CssResolver } from './sassInternals.js';
-export type { CssResolver } from './sassInternals.js';
+import type { ModuleGraphOptions } from './moduleGraph.js';
+import type { CssResolver } from './types.js';
+export type { CssResolver } from './types.js';
+export type { ModuleGraphOptions } from './moduleGraph.js';
 export declare const DEFAULT_EXTENSIONS: string[];
 type LightningCssConfig = boolean | Partial<Omit<LightningTransformOptions<never>, 'code'>>;
 type PeerLoader = (name: string) => Promise<unknown>;
@@ -16,7 +17,7 @@ export interface CssOptions {
         strategy?: SpecificityStrategy;
         match?: SpecificitySelector[];
     };
-    dependencyTree?: Partial<Omit<DependencyTreeOpts, 'filename' | 'directory'>>;
+    moduleGraph?: ModuleGraphOptions;
     resolver?: CssResolver;
     peerResolver?: PeerLoader;
 }

package/dist/css.js

@@ -1,8 +1,8 @@
 import path from 'node:path';
 import { existsSync, promises as fs } from 'node:fs';
-import dependencyTree from 'dependency-tree';
 import { composeVisitors, transform as lightningTransform, } from 'lightningcss';
 import { applyStringSpecificityBoost, buildSpecificityVisitor, } from './helpers.js';
+import { collectStyleImports } from './moduleGraph.js';
 import { createSassImporter } from './sassInternals.js';
 export const DEFAULT_EXTENSIONS = ['.css', '.scss', '.sass', '.less', '.css.ts'];
 export async function css(entry, options = {}) {
@@ -13,11 +13,12 @@ export async function cssWithMeta(entry, options = {}) {
     const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
     const entryPath = await resolveEntry(entry, cwd, options.resolver);
     const extensions = (options.extensions ?? DEFAULT_EXTENSIONS).map(ext => ext.toLowerCase());
-    const files = collectStyleDependencies(entryPath, {
+    const files = await collectStyleDependencies(entryPath, {
         cwd,
         extensions,
         filter: options.filter,
-        dependencyTreeOptions: options.dependencyTree,
+        graphOptions: options.moduleGraph,
+        resolver: options.resolver,
     });
     if (files.length === 0) {
         return { css: '', files: [] };
@@ -67,30 +68,33 @@ async function resolveEntry(entry, cwd, resolver) {
     }
     return path.resolve(cwd, entry);
 }
-function collectStyleDependencies(entryPath, { cwd, extensions, filter, dependencyTreeOptions, }) {
+async function collectStyleDependencies(entryPath, { cwd, extensions, filter, graphOptions, resolver, }) {
     const seen = new Set();
     const order = [];
     const shouldInclude = typeof filter === 'function'
         ? filter
         : (filePath) => !filePath.includes('node_modules');
     const entryIsStyle = Boolean(matchExtension(entryPath, extensions));
-    let treeList = [];
+    let discoveredStyles = [];
     if (!entryIsStyle) {
-        const dependencyConfig = {
-            ...dependencyTreeOptions,
-            filename: entryPath,
-            directory: cwd,
+        discoveredStyles = await collectStyleImports(entryPath, {
+            cwd,
+            styleExtensions: extensions,
             filter: shouldInclude,
-        };
-        treeList = dependencyTree.toList(dependencyConfig);
+            resolver,
+            graphOptions,
+        });
     }
-    const candidates = entryIsStyle ? [entryPath] : [entryPath, ...treeList];
+    const candidates = entryIsStyle ? [entryPath] : [entryPath, ...discoveredStyles];
     for (const candidate of candidates) {
         const match = matchExtension(candidate, extensions);
-        if (!match || seen.has(candidate))
+        if (!match)
+            continue;
+        const resolvedCandidate = path.resolve(candidate);
+        if (seen.has(resolvedCandidate))
             continue;
-        seen.add(candidate);
-        order.push({ path: path.resolve(candidate), ext: match });
+        seen.add(resolvedCandidate);
+        order.push({ path: resolvedCandidate, ext: match });
     }
     return order;
 }

package/dist/moduleGraph.d.ts

@@ -0,0 +1,15 @@
+import type { CssResolver } from './types.js';
+export interface ModuleGraphOptions {
+    tsConfig?: string | Record<string, unknown>;
+    extensions?: string[];
+    conditions?: string[];
+}
+interface CollectOptions {
+    cwd: string;
+    styleExtensions: string[];
+    filter: (filePath: string) => boolean;
+    resolver?: CssResolver;
+    graphOptions?: ModuleGraphOptions;
+}
+export declare function collectStyleImports(entryPath: string, options: CollectOptions): Promise<string[]>;
+export {};

package/dist/moduleGraph.js

@@ -0,0 +1,425 @@
+import path from 'node:path';
+import { builtinModules } from 'node:module';
+import { existsSync, promises as fs, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { parseSync, Visitor } from 'oxc-parser';
+import { ResolverFactory, } from 'oxc-resolver';
+import { createMatchPath } from 'tsconfig-paths';
+import { getTsconfig } from 'get-tsconfig';
+const SCRIPT_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
+const BUILTIN_SPECIFIERS = new Set([
+    ...builtinModules,
+    ...builtinModules.map(mod => `node:${mod}`),
+]);
+const tsconfigResultCache = new Map();
+const tsconfigFsCache = new Map();
+export async function collectStyleImports(entryPath, options) {
+    const { cwd, styleExtensions, filter, resolver, graphOptions } = options;
+    const normalizedStyles = normalizeExtensions(styleExtensions);
+    const scriptExtensions = normalizeExtensions([
+        ...SCRIPT_EXTENSIONS,
+        ...(graphOptions?.extensions ?? []),
+    ]);
+    const resolutionExtensions = dedupeExtensions([
+        ...scriptExtensions,
+        ...normalizedStyles,
+    ]);
+    const tsconfigMatcher = createTsconfigMatcher(graphOptions?.tsConfig, cwd, resolutionExtensions);
+    const seenScripts = new Set();
+    const seenStyles = new Set();
+    const styleOrder = [];
+    const resolutionCache = new Map();
+    const resolverFactory = createResolverFactory(cwd, resolutionExtensions, scriptExtensions, graphOptions);
+    async function walk(filePath) {
+        const absolutePath = path.resolve(filePath);
+        if (seenScripts.has(absolutePath)) {
+            return;
+        }
+        seenScripts.add(absolutePath);
+        const source = await readSourceFile(absolutePath);
+        if (!source) {
+            return;
+        }
+        const specifiers = extractModuleSpecifiers(source, absolutePath);
+        for (const specifier of specifiers) {
+            if (!specifier || isBuiltinSpecifier(specifier)) {
+                continue;
+            }
+            const resolved = await resolveImport(specifier, absolutePath);
+            if (!resolved) {
+                continue;
+            }
+            const normalized = path.resolve(resolved);
+            if (!filter(normalized)) {
+                continue;
+            }
+            if (isStyleExtension(normalized, normalizedStyles)) {
+                if (!seenStyles.has(normalized)) {
+                    seenStyles.add(normalized);
+                    styleOrder.push(normalized);
+                }
+                continue;
+            }
+            if (isScriptExtension(normalized, scriptExtensions)) {
+                await walk(normalized);
+            }
+        }
+    }
+    async function resolveImport(specifier, importer) {
+        const cacheKey = `${importer}::${specifier}`;
+        if (resolutionCache.has(cacheKey)) {
+            return resolutionCache.get(cacheKey);
+        }
+        let resolved;
+        if (resolver) {
+            resolved = normalizeResolverResult(await resolver(specifier, { cwd, from: importer }), cwd);
+        }
+        if (!resolved && tsconfigMatcher) {
+            resolved = tsconfigMatcher(specifier);
+        }
+        if (!resolved) {
+            resolved = resolveWithFactory(resolverFactory, specifier, importer, resolutionExtensions);
+        }
+        resolutionCache.set(cacheKey, resolved);
+        return resolved;
+    }
+    await walk(entryPath);
+    return styleOrder;
+}
+function normalizeExtensions(extensions) {
+    const result = new Set();
+    for (const ext of extensions) {
+        if (!ext)
+            continue;
+        const normalized = ext.startsWith('.') ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+        result.add(normalized);
+    }
+    return Array.from(result);
+}
+function dedupeExtensions(extensions) {
+    const result = new Set();
+    for (const ext of extensions) {
+        result.add(ext);
+    }
+    return Array.from(result);
+}
+function isBuiltinSpecifier(specifier) {
+    if (BUILTIN_SPECIFIERS.has(specifier)) {
+        return true;
+    }
+    if (specifier.startsWith('node:')) {
+        return true;
+    }
+    return false;
+}
+function isStyleExtension(filePath, extensions) {
+    const lower = filePath.toLowerCase();
+    return extensions.some(ext => lower.endsWith(ext));
+}
+function isScriptExtension(filePath, extensions) {
+    const ext = path.extname(filePath).toLowerCase();
+    return extensions.includes(ext);
+}
+async function readSourceFile(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractModuleSpecifiers(sourceText, filePath) {
+    let program;
+    try {
+        ;
+        ({ program } = parseSync(filePath, sourceText, { sourceType: 'unambiguous' }));
+    }
+    catch {
+        return [];
+    }
+    const specifiers = [];
+    const addSpecifier = (raw) => {
+        if (!raw) {
+            return;
+        }
+        const normalized = normalizeSpecifier(raw);
+        if (normalized) {
+            specifiers.push(normalized);
+        }
+    };
+    const visitor = new Visitor({
+        ImportDeclaration(node) {
+            addSpecifier(node.source?.value);
+        },
+        ExportNamedDeclaration(node) {
+            if (node.source) {
+                addSpecifier(node.source.value);
+            }
+        },
+        ExportAllDeclaration(node) {
+            addSpecifier(node.source?.value);
+        },
+        TSImportEqualsDeclaration(node) {
+            const specifier = extractImportEqualsSpecifier(node);
+            if (specifier) {
+                addSpecifier(specifier);
+            }
+        },
+        ImportExpression(node) {
+            const specifier = getStringFromExpression(node.source);
+            if (specifier) {
+                addSpecifier(specifier);
+            }
+        },
+        CallExpression(node) {
+            if (!isRequireLikeCallee(node.callee)) {
+                return;
+            }
+            const specifier = getStringFromArgument(node.arguments[0]);
+            if (specifier) {
+                addSpecifier(specifier);
+            }
+        },
+    });
+    visitor.visit(program);
+    return specifiers;
+}
+function normalizeSpecifier(raw) {
+    if (!raw)
+        return '';
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith('\0')) {
+        return '';
+    }
+    const queryIndex = trimmed.search(/[?#]/);
+    const withoutQuery = queryIndex === -1 ? trimmed : trimmed.slice(0, queryIndex);
+    if (!withoutQuery) {
+        return '';
+    }
+    if (/^[a-z][\w+.-]*:/i.test(withoutQuery) && !withoutQuery.startsWith('file:')) {
+        return '';
+    }
+    return withoutQuery;
+}
+function extractImportEqualsSpecifier(node) {
+    if (node.moduleReference.type === 'TSExternalModuleReference') {
+        return node.moduleReference.expression.value;
+    }
+    return undefined;
+}
+function getStringFromArgument(argument) {
+    if (!argument || argument.type === 'SpreadElement') {
+        return undefined;
+    }
+    return getStringFromExpression(argument);
+}
+function getStringFromExpression(expression) {
+    if (!expression) {
+        return undefined;
+    }
+    if (expression.type === 'Literal') {
+        const literalValue = expression.value;
+        return typeof literalValue === 'string' ? literalValue : undefined;
+    }
+    if (expression.type === 'TemplateLiteral' && expression.expressions.length === 0) {
+        const [first] = expression.quasis;
+        return first?.value.cooked ?? first?.value.raw ?? undefined;
+    }
+    return undefined;
+}
+function isRequireLikeCallee(expression) {
+    const target = unwrapExpression(expression);
+    if (target.type === 'Identifier') {
+        return target.name === 'require';
+    }
+    if (target.type === 'MemberExpression') {
+        const object = target.object;
+        if (object.type === 'Identifier') {
+            return object.name === 'require';
+        }
+    }
+    return false;
+}
+function unwrapExpression(expression) {
+    if (expression.type === 'ChainExpression') {
+        const inner = expression.expression;
+        if (inner.type === 'CallExpression') {
+            return unwrapExpression(inner.callee);
+        }
+        return unwrapExpression(inner);
+    }
+    if (expression.type === 'TSNonNullExpression') {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+}
+function normalizeResolverResult(result, cwd) {
+    if (!result) {
+        return undefined;
+    }
+    if (result.startsWith('file://')) {
+        try {
+            return fileURLToPath(new URL(result));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return path.isAbsolute(result) ? result : path.resolve(cwd, result);
+}
+function resolveWithFactory(factory, specifier, importer, extensions) {
+    if (specifier.startsWith('file://')) {
+        try {
+            return findExistingFile(fileURLToPath(new URL(specifier)), extensions);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (/^[a-z][\w+.-]*:/i.test(specifier)) {
+        return undefined;
+    }
+    try {
+        const result = factory.resolveFileSync(importer, specifier);
+        return result?.path;
+    }
+    catch {
+        return undefined;
+    }
+}
+function createResolverFactory(cwd, extensions, scriptExtensions, graphOptions) {
+    const options = {
+        extensions,
+        conditionNames: graphOptions?.conditions,
+    };
+    const extensionAlias = buildExtensionAlias(scriptExtensions);
+    if (extensionAlias) {
+        options.extensionAlias = extensionAlias;
+    }
+    const tsconfigOption = resolveResolverTsconfig(graphOptions?.tsConfig, cwd);
+    if (tsconfigOption) {
+        options.tsconfig = tsconfigOption;
+    }
+    return new ResolverFactory(options);
+}
+function buildExtensionAlias(scriptExtensions) {
+    const alias = {};
+    const jsTargets = dedupeExtensions(scriptExtensions.filter(ext => ['.js', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts'].includes(ext)));
+    if (jsTargets.length > 0) {
+        for (const key of ['.js', '.mjs', '.cjs']) {
+            alias[key] = jsTargets;
+        }
+    }
+    const jsxTargets = dedupeExtensions(scriptExtensions.filter(ext => ext === '.jsx' || ext === '.tsx'));
+    if (jsxTargets.length > 0) {
+        alias['.jsx'] = jsxTargets;
+    }
+    return Object.keys(alias).length > 0 ? alias : undefined;
+}
+function resolveResolverTsconfig(input, cwd) {
+    if (!input || typeof input !== 'string') {
+        return undefined;
+    }
+    const resolved = resolveTsconfigPath(input, cwd);
+    if (!resolved) {
+        return undefined;
+    }
+    return { configFile: resolved };
+}
+function createTsconfigMatcher(input, cwd, extensions) {
+    const config = loadTsconfigPaths(input, cwd);
+    if (!config) {
+        return undefined;
+    }
+    const matchPath = createMatchPath(config.absoluteBaseUrl, config.paths);
+    return (specifier) => {
+        const matched = matchPath(specifier, undefined, undefined, extensions);
+        if (!matched) {
+            return undefined;
+        }
+        return findExistingFile(matched, extensions) ?? matched;
+    };
+}
+function loadTsconfigPaths(input, cwd) {
+    if (!input) {
+        return undefined;
+    }
+    if (typeof input === 'string') {
+        const target = path.isAbsolute(input) ? input : path.resolve(cwd, input);
+        const cached = tsconfigResultCache.get(target);
+        if (cached !== undefined) {
+            return cached ?? undefined;
+        }
+        const result = getTsconfig(target, undefined, tsconfigFsCache);
+        if (!result) {
+            tsconfigResultCache.set(target, null);
+            return undefined;
+        }
+        const normalized = normalizeTsconfigCompilerOptions(result.config.compilerOptions, path.dirname(result.path));
+        tsconfigResultCache.set(target, normalized ?? null);
+        return normalized;
+    }
+    const compilerOptions = input.compilerOptions;
+    return normalizeTsconfigCompilerOptions(compilerOptions, cwd);
+}
+function normalizeTsconfigCompilerOptions(compilerOptions, configDir) {
+    if (!compilerOptions?.baseUrl || !compilerOptions.paths) {
+        return undefined;
+    }
+    const normalizedPaths = {};
+    for (const [pattern, replacements] of Object.entries(compilerOptions.paths)) {
+        if (!replacements || replacements.length === 0) {
+            continue;
+        }
+        normalizedPaths[pattern] = Array.isArray(replacements)
+            ? [...replacements]
+            : [replacements];
+    }
+    if (Object.keys(normalizedPaths).length === 0) {
+        return undefined;
+    }
+    const absoluteBaseUrl = path.isAbsolute(compilerOptions.baseUrl)
+        ? compilerOptions.baseUrl
+        : path.resolve(configDir, compilerOptions.baseUrl);
+    return { absoluteBaseUrl, paths: normalizedPaths };
+}
+function resolveTsconfigPath(tsconfigPath, cwd) {
+    const absolute = path.isAbsolute(tsconfigPath)
+        ? tsconfigPath
+        : path.resolve(cwd, tsconfigPath);
+    if (!existsSync(absolute)) {
+        return undefined;
+    }
+    const stats = statSync(absolute);
+    if (stats.isDirectory()) {
+        const candidate = path.join(absolute, 'tsconfig.json');
+        return existsSync(candidate) ? candidate : undefined;
+    }
+    return absolute;
+}
+function findExistingFile(candidate, extensions) {
+    const candidateHasExt = hasExtension(candidate);
+    if (candidateHasExt && existsSync(candidate)) {
+        return candidate;
+    }
+    if (!candidateHasExt) {
+        for (const ext of extensions) {
+            const withExt = `${candidate}${ext}`;
+            if (existsSync(withExt)) {
+                return withExt;
+            }
+        }
+    }
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+        for (const ext of extensions) {
+            const indexPath = path.join(candidate, `index${ext}`);
+            if (existsSync(indexPath)) {
+                return indexPath;
+            }
+        }
+    }
+    return undefined;
+}
+function hasExtension(filePath) {
+    return Boolean(path.extname(filePath));
+}

package/dist/sassInternals.d.ts

@@ -1,6 +1,5 @@
-export type CssResolver = (specifier: string, ctx: {
-    cwd: string;
-}) => string | Promise<string | undefined>;
+import type { CssResolver } from './types.js';
+export type { CssResolver } from './types.js';
 export declare function createSassImporter({ cwd, resolver, }: {
     cwd: string;
     resolver?: CssResolver;
@@ -13,7 +12,7 @@ export declare function createSassImporter({ cwd, resolver, }: {
         syntax: "scss" | "indented";
     }>;
 } | undefined;
-export declare function resolveAliasSpecifier(specifier: string, resolver: CssResolver, cwd: string): Promise<string | undefined>;
+export declare function resolveAliasSpecifier(specifier: string, resolver: CssResolver, cwd: string, from?: string): Promise<string | undefined>;
 export declare function shouldNormalizeSpecifier(specifier: string): boolean;
 export declare function ensureSassPath(filePath: string): string | undefined;
 export declare function resolveRelativeSpecifier(specifier: string, containingUrl?: URL | null): string | undefined;

package/dist/sassInternals.js

@@ -13,8 +13,11 @@ export function createSassImporter({ cwd, resolver, }) {
                     console.error('[knighted-css:sass] containing url:', context.containingUrl.href);
                 }
             }
+            const containingPath = context?.containingUrl
+                ? fileURLToPath(context.containingUrl)
+                : undefined;
             if (shouldNormalizeSpecifier(url)) {
-                const resolvedPath = await resolveAliasSpecifier(url, resolver, cwd);
+                const resolvedPath = await resolveAliasSpecifier(url, resolver, cwd, containingPath);
                 if (!resolvedPath) {
                     if (debug) {
                         console.error('[knighted-css:sass] resolver returned no result for', url);
@@ -50,8 +53,8 @@ export function createSassImporter({ cwd, resolver, }) {
         },
     };
 }
-export async function resolveAliasSpecifier(specifier, resolver, cwd) {
-    const resolved = await resolver(specifier, { cwd });
+export async function resolveAliasSpecifier(specifier, resolver, cwd, from) {
+    const resolved = await resolver(specifier, { cwd, from });
     if (!resolved) {
         return undefined;
     }

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export type CssResolver = (specifier: string, ctx: {
+    cwd: string;
+    from?: string;
+}) => string | Promise<string | undefined>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/css",
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0-rc.9",
   "description": "A build-time utility that traverses JavaScript/TypeScript module dependency graphs to extract, compile, and optimize all imported CSS into a single, in-memory string.",
   "type": "module",
   "main": "./dist/css.js",
@@ -76,15 +76,13 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "dependency-tree": "^11.2.0",
     "es-module-lexer": "^2.0.0",
     "lightningcss": "^1.30.2",
-    "node-module-type": "^1.0.1"
-  },
-  "overrides": {
-    "module-lookup-amd": {
-      "glob": "^9.0.0"
-    }
+    "node-module-type": "^1.0.1",
+    "get-tsconfig": "^4.13.0",
+    "oxc-parser": "^0.104.0",
+    "oxc-resolver": "^11.16.0",
+    "tsconfig-paths": "^4.2.0"
   },
   "peerDependencies": {
     "@vanilla-extract/integration": "^8.0.0",