@knighted/css 1.0.0-rc.4 → 1.0.0-rc.6

package/dist/cjs/css.cjs

@@ -12,6 +12,7 @@ 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 sassInternals_js_1 = require("./sassInternals.cjs");
 exports.DEFAULT_EXTENSIONS = ['.css', '.scss', '.sass', '.less', '.css.ts'];
 async function css(entry, options = {}) {
     const { css: output } = await cssWithMeta(entry, options);
@@ -35,6 +36,7 @@ async function cssWithMeta(entry, options = {}) {
         const chunk = await compileStyleModule(file, {
             cwd,
             peerResolver: options.peerResolver,
+            resolver: options.resolver,
         });
         if (chunk) {
             chunks.push(chunk);
@@ -105,13 +107,17 @@ function matchExtension(filePath, extensions) {
     const lower = filePath.toLowerCase();
     return extensions.find(ext => lower.endsWith(ext));
 }
-async function compileStyleModule(file, { cwd, peerResolver }) {
+async function compileStyleModule(file, { cwd, peerResolver, resolver, }) {
     switch (file.ext) {
         case '.css':
             return node_fs_1.promises.readFile(file.path, 'utf8');
         case '.scss':
         case '.sass':
-            return compileSass(file.path, file.ext === '.sass', peerResolver);
+            return compileSass(file.path, file.ext === '.sass', {
+                cwd,
+                peerResolver,
+                resolver,
+            });
         case '.less':
             return compileLess(file.path, peerResolver);
         case '.css.ts':
@@ -120,12 +126,14 @@ async function compileStyleModule(file, { cwd, peerResolver }) {
             return '';
     }
 }
-async function compileSass(filePath, indented, peerResolver) {
+async function compileSass(filePath, indented, { cwd, peerResolver, resolver, }) {
     const sassModule = await optionalPeer('sass', 'Sass', peerResolver);
     const sass = sassModule;
-    const result = sass.compile(filePath, {
+    const importer = (0, sassInternals_js_1.createSassImporter)({ cwd, resolver });
+    const result = await sass.compileAsync(filePath, {
         style: 'expanded',
         loadPaths: buildSassLoadPaths(filePath),
+        importers: importer ? [importer] : undefined,
     });
     return result.css;
 }

package/dist/cjs/css.d.cts

@@ -1,11 +1,10 @@
 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';
 export declare const DEFAULT_EXTENSIONS: string[];
 type LightningCssConfig = boolean | Partial<Omit<LightningTransformOptions<never>, 'code'>>;
-export type CssResolver = (specifier: string, ctx: {
-    cwd: string;
-}) => string | Promise<string | undefined>;
 type PeerLoader = (name: string) => Promise<unknown>;
 export interface CssOptions {
     extensions?: string[];
@@ -35,4 +34,3 @@ export interface CssResult {
 export declare function css(entry: string, options?: CssOptions): Promise<string>;
 export declare function cssWithMeta(entry: string, options?: CssOptions): Promise<CssResult>;
 export declare function compileVanillaModule(filePath: string, cwd: string, peerResolver?: PeerLoader): Promise<VanillaCompileResult>;
-export {};

package/dist/cjs/loader.cjs

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pitch = void 0;
 const css_js_1 = require("./css.cjs");
+const moduleInfo_js_1 = require("./moduleInfo.cjs");
+const loaderInternals_js_1 = require("./loaderInternals.cjs");
 const DEFAULT_EXPORT_NAME = 'knightedCss';
-const COMBINED_QUERY_FLAG = 'combined';
 const loader = async function loader(source) {
     const { cssOptions, vanillaOptions } = resolveLoaderOptions(this);
     const css = await extractCss(this, cssOptions);
@@ -47,7 +48,18 @@ const pitch = function pitch() {
     }
     const request = buildProxyRequest(this);
     const { cssOptions } = resolveLoaderOptions(this);
-    return extractCss(this, cssOptions).then(css => createCombinedModule(request, css));
+    const skipSyntheticDefault = hasNamedOnlyQueryFlag(this.resourceQuery);
+    const defaultSignalPromise = skipSyntheticDefault
+        ? Promise.resolve('unknown')
+        : (0, moduleInfo_js_1.detectModuleDefaultExport)(this.resourcePath);
+    return Promise.all([extractCss(this, cssOptions), defaultSignalPromise]).then(([css, defaultSignal]) => {
+        const emitDefault = (0, loaderInternals_js_1.shouldEmitCombinedDefault)({
+            request,
+            skipSyntheticDefault,
+            detection: defaultSignal,
+        });
+        return createCombinedModule(request, css, { emitDefault });
+    });
 };
 exports.pitch = pitch;
 loader.pitch = exports.pitch;
@@ -87,10 +99,16 @@ function hasCombinedQuery(query) {
     return trimmed
         .split('&')
         .filter(Boolean)
-        .some(part => isQueryFlag(part, COMBINED_QUERY_FLAG));
+        .some(part => (0, loaderInternals_js_1.isQueryFlag)(part, loaderInternals_js_1.COMBINED_QUERY_FLAG));
+}
+function hasNamedOnlyQueryFlag(query) {
+    if (!query)
+        return false;
+    const entries = (0, loaderInternals_js_1.splitQuery)(query);
+    return entries.some(part => loaderInternals_js_1.NAMED_ONLY_QUERY_FLAGS.some(flag => (0, loaderInternals_js_1.isQueryFlag)(part, flag)));
 }
 function buildProxyRequest(ctx) {
-    const sanitizedQuery = buildSanitizedQuery(ctx.resourceQuery);
+    const sanitizedQuery = (0, loaderInternals_js_1.buildSanitizedQuery)(ctx.resourceQuery);
     const rawRequest = getRawRequest(ctx);
     if (rawRequest) {
         const stripped = stripResourceQuery(rawRequest);
@@ -115,36 +133,14 @@ function stripResourceQuery(request) {
     const idx = request.indexOf('?');
     return idx >= 0 ? request.slice(0, idx) : request;
 }
-function buildSanitizedQuery(query) {
-    if (!query)
-        return '';
-    const entries = splitQuery(query).filter(part => {
-        return !isQueryFlag(part, COMBINED_QUERY_FLAG) && !isQueryFlag(part, 'knighted-css');
-    });
-    return entries.length > 0 ? `?${entries.join('&')}` : '';
-}
-function splitQuery(query) {
-    const trimmed = query.startsWith('?') ? query.slice(1) : query;
-    if (!trimmed)
-        return [];
-    return trimmed.split('&').filter(Boolean);
-}
-function isQueryFlag(entry, flag) {
-    const [rawKey] = entry.split('=');
-    try {
-        return decodeURIComponent(rawKey) === flag;
-    }
-    catch {
-        return rawKey === flag;
-    }
-}
-function createCombinedModule(request, css) {
+function createCombinedModule(request, css, options) {
+    const shouldEmitDefault = options?.emitDefault ?? (0, loaderInternals_js_1.shouldForwardDefaultExport)(request);
     const requestLiteral = JSON.stringify(request);
     const lines = [
         `import * as __knightedModule from ${requestLiteral};`,
         `export * from ${requestLiteral};`,
     ];
-    if (shouldForwardDefaultExport(request)) {
+    if (shouldEmitDefault) {
         lines.push(`const __knightedDefault =
 typeof __knightedModule.default !== 'undefined'
   ? __knightedModule.default
@@ -153,13 +149,3 @@ typeof __knightedModule.default !== 'undefined'
     lines.push(buildInjection(css));
     return lines.join('\n');
 }
-function shouldForwardDefaultExport(request) {
-    const [pathPart] = request.split('?');
-    if (!pathPart)
-        return true;
-    const lower = pathPart.toLowerCase();
-    if (lower.endsWith('.css.ts') || lower.endsWith('.css.js')) {
-        return false;
-    }
-    return true;
-}

package/dist/cjs/loaderInternals.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__loaderInternals = exports.NAMED_ONLY_QUERY_FLAGS = exports.COMBINED_QUERY_FLAG = void 0;
+exports.splitQuery = splitQuery;
+exports.isQueryFlag = isQueryFlag;
+exports.buildSanitizedQuery = buildSanitizedQuery;
+exports.shouldForwardDefaultExport = shouldForwardDefaultExport;
+exports.shouldEmitCombinedDefault = shouldEmitCombinedDefault;
+exports.COMBINED_QUERY_FLAG = 'combined';
+exports.NAMED_ONLY_QUERY_FLAGS = ['named-only', 'no-default'];
+function splitQuery(query) {
+    const trimmed = query.startsWith('?') ? query.slice(1) : query;
+    if (!trimmed)
+        return [];
+    return trimmed.split('&').filter(Boolean);
+}
+function isQueryFlag(entry, flag) {
+    const [rawKey] = entry.split('=');
+    try {
+        return decodeURIComponent(rawKey) === flag;
+    }
+    catch {
+        return rawKey === flag;
+    }
+}
+function buildSanitizedQuery(query) {
+    if (!query)
+        return '';
+    const entries = splitQuery(query).filter(part => {
+        if (isQueryFlag(part, exports.COMBINED_QUERY_FLAG)) {
+            return false;
+        }
+        if (isQueryFlag(part, 'knighted-css')) {
+            return false;
+        }
+        if (exports.NAMED_ONLY_QUERY_FLAGS.some(flag => isQueryFlag(part, flag))) {
+            return false;
+        }
+        return true;
+    });
+    return entries.length > 0 ? `?${entries.join('&')}` : '';
+}
+function shouldForwardDefaultExport(request) {
+    const [pathPart] = request.split('?');
+    if (!pathPart)
+        return true;
+    const lower = pathPart.toLowerCase();
+    if (lower.endsWith('.css.ts') || lower.endsWith('.css.js')) {
+        return false;
+    }
+    return true;
+}
+function shouldEmitCombinedDefault(options) {
+    if (options.skipSyntheticDefault) {
+        return false;
+    }
+    if (!shouldForwardDefaultExport(options.request)) {
+        return false;
+    }
+    if (options.detection === 'has-default') {
+        return true;
+    }
+    if (options.detection === 'no-default') {
+        return false;
+    }
+    return true;
+}
+exports.__loaderInternals = {
+    buildSanitizedQuery,
+    shouldEmitCombinedDefault,
+};

package/dist/cjs/loaderInternals.d.cts

@@ -0,0 +1,16 @@
+import type { ModuleDefaultSignal } from './moduleInfo.cjs';
+export declare const COMBINED_QUERY_FLAG = "combined";
+export declare const NAMED_ONLY_QUERY_FLAGS: readonly ["named-only", "no-default"];
+export declare function splitQuery(query: string): string[];
+export declare function isQueryFlag(entry: string, flag: string): boolean;
+export declare function buildSanitizedQuery(query?: string | null): string;
+export declare function shouldForwardDefaultExport(request: string): boolean;
+export declare function shouldEmitCombinedDefault(options: {
+    detection: ModuleDefaultSignal;
+    request: string;
+    skipSyntheticDefault: boolean;
+}): boolean;
+export declare const __loaderInternals: {
+    buildSanitizedQuery: typeof buildSanitizedQuery;
+    shouldEmitCombinedDefault: typeof shouldEmitCombinedDefault;
+};

package/dist/cjs/moduleInfo.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__moduleInfoInternals = void 0;
+exports.detectModuleDefaultExport = detectModuleDefaultExport;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const es_module_lexer_1 = require("es-module-lexer");
+const DETECTABLE_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts',
+]);
+let lexerInit;
+let lexerOverrides;
+function ensureLexerInitialized() {
+    if (!lexerInit) {
+        lexerInit = es_module_lexer_1.init;
+    }
+    return lexerInit;
+}
+async function detectModuleDefaultExport(filePath) {
+    if (!DETECTABLE_EXTENSIONS.has(node_path_1.default.extname(filePath))) {
+        return 'unknown';
+    }
+    let source;
+    try {
+        source = await (0, promises_1.readFile)(filePath, 'utf8');
+    }
+    catch {
+        return 'unknown';
+    }
+    try {
+        await ensureLexerInitialized();
+        const [, exports] = (lexerOverrides?.parse ?? es_module_lexer_1.parse)(source, filePath);
+        if (exports.some(entry => entry.n === 'default')) {
+            return 'has-default';
+        }
+        if (exports.length === 0) {
+            return 'unknown';
+        }
+        return 'no-default';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+exports.__moduleInfoInternals = {
+    setLexerOverrides(overrides) {
+        lexerOverrides = overrides;
+        if (!overrides) {
+            lexerInit = undefined;
+        }
+    },
+};

package/dist/cjs/moduleInfo.d.cts

@@ -0,0 +1,10 @@
+import { parse } from 'es-module-lexer';
+export type ModuleDefaultSignal = 'has-default' | 'no-default' | 'unknown';
+type LexerOverrides = {
+    parse?: typeof parse;
+};
+export declare function detectModuleDefaultExport(filePath: string): Promise<ModuleDefaultSignal>;
+export declare const __moduleInfoInternals: {
+    setLexerOverrides(overrides?: LexerOverrides): void;
+};
+export {};

package/dist/cjs/sassInternals.cjs

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__sassInternals = void 0;
+exports.createSassImporter = createSassImporter;
+exports.resolveAliasSpecifier = resolveAliasSpecifier;
+exports.shouldNormalizeSpecifier = shouldNormalizeSpecifier;
+exports.ensureSassPath = ensureSassPath;
+exports.resolveRelativeSpecifier = resolveRelativeSpecifier;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_url_1 = require("node:url");
+function createSassImporter({ cwd, resolver, }) {
+    if (!resolver)
+        return undefined;
+    const debug = process.env.KNIGHTED_CSS_DEBUG_SASS === '1';
+    return {
+        async canonicalize(url, context) {
+            if (debug) {
+                console.error('[knighted-css:sass] canonicalize request:', url);
+                if (context?.containingUrl) {
+                    console.error('[knighted-css:sass] containing url:', context.containingUrl.href);
+                }
+            }
+            if (shouldNormalizeSpecifier(url)) {
+                const resolvedPath = await resolveAliasSpecifier(url, resolver, cwd);
+                if (!resolvedPath) {
+                    if (debug) {
+                        console.error('[knighted-css:sass] resolver returned no result for', url);
+                    }
+                    return null;
+                }
+                const fileUrl = (0, node_url_1.pathToFileURL)(resolvedPath);
+                if (debug) {
+                    console.error('[knighted-css:sass] canonical url:', fileUrl.href);
+                }
+                return fileUrl;
+            }
+            const relativePath = resolveRelativeSpecifier(url, context?.containingUrl);
+            if (relativePath) {
+                const fileUrl = (0, node_url_1.pathToFileURL)(relativePath);
+                if (debug) {
+                    console.error('[knighted-css:sass] canonical url:', fileUrl.href);
+                }
+                return fileUrl;
+            }
+            return null;
+        },
+        async load(canonicalUrl) {
+            if (debug) {
+                console.error('[knighted-css:sass] load request:', canonicalUrl.href);
+            }
+            const filePath = (0, node_url_1.fileURLToPath)(canonicalUrl);
+            const contents = await node_fs_1.promises.readFile(filePath, 'utf8');
+            return {
+                contents,
+                syntax: inferSassSyntax(filePath),
+            };
+        },
+    };
+}
+async function resolveAliasSpecifier(specifier, resolver, cwd) {
+    const resolved = await resolver(specifier, { cwd });
+    if (!resolved) {
+        return undefined;
+    }
+    if (resolved.startsWith('file://')) {
+        return ensureSassPath((0, node_url_1.fileURLToPath)(new URL(resolved)));
+    }
+    const normalized = node_path_1.default.isAbsolute(resolved) ? resolved : node_path_1.default.resolve(cwd, resolved);
+    return ensureSassPath(normalized);
+}
+function shouldNormalizeSpecifier(specifier) {
+    const schemeMatch = specifier.match(/^([a-z][\w+.-]*):/i);
+    if (!schemeMatch) {
+        return false;
+    }
+    const scheme = schemeMatch[1].toLowerCase();
+    if (scheme === 'file' ||
+        scheme === 'http' ||
+        scheme === 'https' ||
+        scheme === 'data' ||
+        scheme === 'sass') {
+        return false;
+    }
+    return true;
+}
+function inferSassSyntax(filePath) {
+    return filePath.endsWith('.sass') ? 'indented' : 'scss';
+}
+function ensureSassPath(filePath) {
+    if ((0, node_fs_1.existsSync)(filePath)) {
+        return filePath;
+    }
+    const ext = node_path_1.default.extname(filePath);
+    const dir = node_path_1.default.dirname(filePath);
+    const base = node_path_1.default.basename(filePath, ext);
+    const partialCandidate = node_path_1.default.join(dir, `_${base}${ext}`);
+    if (ext && (0, node_fs_1.existsSync)(partialCandidate)) {
+        return partialCandidate;
+    }
+    const indexCandidate = node_path_1.default.join(dir, base, `index${ext}`);
+    if (ext && (0, node_fs_1.existsSync)(indexCandidate)) {
+        return indexCandidate;
+    }
+    const partialIndexCandidate = node_path_1.default.join(dir, base, `_index${ext}`);
+    if (ext && (0, node_fs_1.existsSync)(partialIndexCandidate)) {
+        return partialIndexCandidate;
+    }
+    return undefined;
+}
+function resolveRelativeSpecifier(specifier, containingUrl) {
+    if (!containingUrl || containingUrl.protocol !== 'file:') {
+        return undefined;
+    }
+    if (/^[a-z][\w+.-]*:/i.test(specifier)) {
+        return undefined;
+    }
+    const containingPath = (0, node_url_1.fileURLToPath)(containingUrl);
+    const baseDir = node_path_1.default.dirname(containingPath);
+    const candidate = node_path_1.default.resolve(baseDir, specifier);
+    return ensureSassPath(candidate);
+}
+exports.__sassInternals = {
+    createSassImporter,
+    resolveAliasSpecifier,
+    shouldNormalizeSpecifier,
+    ensureSassPath,
+    resolveRelativeSpecifier,
+};

package/dist/cjs/sassInternals.d.cts

@@ -0,0 +1,26 @@
+export type CssResolver = (specifier: string, ctx: {
+    cwd: string;
+}) => string | Promise<string | undefined>;
+export declare function createSassImporter({ cwd, resolver, }: {
+    cwd: string;
+    resolver?: CssResolver;
+}): {
+    canonicalize(url: string, context?: {
+        containingUrl?: URL | null;
+    }): Promise<import("node:url").URL | null>;
+    load(canonicalUrl: URL): Promise<{
+        contents: string;
+        syntax: "scss" | "indented";
+    }>;
+} | undefined;
+export declare function resolveAliasSpecifier(specifier: string, resolver: CssResolver, cwd: 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;
+export declare const __sassInternals: {
+    createSassImporter: typeof createSassImporter;
+    resolveAliasSpecifier: typeof resolveAliasSpecifier;
+    shouldNormalizeSpecifier: typeof shouldNormalizeSpecifier;
+    ensureSassPath: typeof ensureSassPath;
+    resolveRelativeSpecifier: typeof resolveRelativeSpecifier;
+};

package/dist/css.d.ts

@@ -1,11 +1,10 @@
 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';
 export declare const DEFAULT_EXTENSIONS: string[];
 type LightningCssConfig = boolean | Partial<Omit<LightningTransformOptions<never>, 'code'>>;
-export type CssResolver = (specifier: string, ctx: {
-    cwd: string;
-}) => string | Promise<string | undefined>;
 type PeerLoader = (name: string) => Promise<unknown>;
 export interface CssOptions {
     extensions?: string[];
@@ -35,4 +34,3 @@ export interface CssResult {
 export declare function css(entry: string, options?: CssOptions): Promise<string>;
 export declare function cssWithMeta(entry: string, options?: CssOptions): Promise<CssResult>;
 export declare function compileVanillaModule(filePath: string, cwd: string, peerResolver?: PeerLoader): Promise<VanillaCompileResult>;
-export {};

package/dist/css.js

@@ -3,6 +3,7 @@ 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 { createSassImporter } from './sassInternals.js';
 export const DEFAULT_EXTENSIONS = ['.css', '.scss', '.sass', '.less', '.css.ts'];
 export async function css(entry, options = {}) {
     const { css: output } = await cssWithMeta(entry, options);
@@ -26,6 +27,7 @@ export async function cssWithMeta(entry, options = {}) {
         const chunk = await compileStyleModule(file, {
             cwd,
             peerResolver: options.peerResolver,
+            resolver: options.resolver,
         });
         if (chunk) {
             chunks.push(chunk);
@@ -96,13 +98,17 @@ function matchExtension(filePath, extensions) {
     const lower = filePath.toLowerCase();
     return extensions.find(ext => lower.endsWith(ext));
 }
-async function compileStyleModule(file, { cwd, peerResolver }) {
+async function compileStyleModule(file, { cwd, peerResolver, resolver, }) {
     switch (file.ext) {
         case '.css':
             return fs.readFile(file.path, 'utf8');
         case '.scss':
         case '.sass':
-            return compileSass(file.path, file.ext === '.sass', peerResolver);
+            return compileSass(file.path, file.ext === '.sass', {
+                cwd,
+                peerResolver,
+                resolver,
+            });
         case '.less':
             return compileLess(file.path, peerResolver);
         case '.css.ts':
@@ -111,12 +117,14 @@ async function compileStyleModule(file, { cwd, peerResolver }) {
             return '';
     }
 }
-async function compileSass(filePath, indented, peerResolver) {
+async function compileSass(filePath, indented, { cwd, peerResolver, resolver, }) {
     const sassModule = await optionalPeer('sass', 'Sass', peerResolver);
     const sass = sassModule;
-    const result = sass.compile(filePath, {
+    const importer = createSassImporter({ cwd, resolver });
+    const result = await sass.compileAsync(filePath, {
         style: 'expanded',
         loadPaths: buildSassLoadPaths(filePath),
+        importers: importer ? [importer] : undefined,
     });
     return result.css;
 }

package/dist/loader.js

@@ -1,6 +1,7 @@
 import { cssWithMeta, compileVanillaModule } from './css.js';
+import { detectModuleDefaultExport } from './moduleInfo.js';
+import { buildSanitizedQuery, COMBINED_QUERY_FLAG, isQueryFlag, NAMED_ONLY_QUERY_FLAGS, shouldEmitCombinedDefault, shouldForwardDefaultExport, splitQuery, } from './loaderInternals.js';
 const DEFAULT_EXPORT_NAME = 'knightedCss';
-const COMBINED_QUERY_FLAG = 'combined';
 const loader = async function loader(source) {
     const { cssOptions, vanillaOptions } = resolveLoaderOptions(this);
     const css = await extractCss(this, cssOptions);
@@ -44,7 +45,18 @@ export const pitch = function pitch() {
     }
     const request = buildProxyRequest(this);
     const { cssOptions } = resolveLoaderOptions(this);
-    return extractCss(this, cssOptions).then(css => createCombinedModule(request, css));
+    const skipSyntheticDefault = hasNamedOnlyQueryFlag(this.resourceQuery);
+    const defaultSignalPromise = skipSyntheticDefault
+        ? Promise.resolve('unknown')
+        : detectModuleDefaultExport(this.resourcePath);
+    return Promise.all([extractCss(this, cssOptions), defaultSignalPromise]).then(([css, defaultSignal]) => {
+        const emitDefault = shouldEmitCombinedDefault({
+            request,
+            skipSyntheticDefault,
+            detection: defaultSignal,
+        });
+        return createCombinedModule(request, css, { emitDefault });
+    });
 };
 loader.pitch = pitch;
 export default loader;
@@ -85,6 +97,12 @@ function hasCombinedQuery(query) {
         .filter(Boolean)
         .some(part => isQueryFlag(part, COMBINED_QUERY_FLAG));
 }
+function hasNamedOnlyQueryFlag(query) {
+    if (!query)
+        return false;
+    const entries = splitQuery(query);
+    return entries.some(part => NAMED_ONLY_QUERY_FLAGS.some(flag => isQueryFlag(part, flag)));
+}
 function buildProxyRequest(ctx) {
     const sanitizedQuery = buildSanitizedQuery(ctx.resourceQuery);
     const rawRequest = getRawRequest(ctx);
@@ -111,36 +129,14 @@ function stripResourceQuery(request) {
     const idx = request.indexOf('?');
     return idx >= 0 ? request.slice(0, idx) : request;
 }
-function buildSanitizedQuery(query) {
-    if (!query)
-        return '';
-    const entries = splitQuery(query).filter(part => {
-        return !isQueryFlag(part, COMBINED_QUERY_FLAG) && !isQueryFlag(part, 'knighted-css');
-    });
-    return entries.length > 0 ? `?${entries.join('&')}` : '';
-}
-function splitQuery(query) {
-    const trimmed = query.startsWith('?') ? query.slice(1) : query;
-    if (!trimmed)
-        return [];
-    return trimmed.split('&').filter(Boolean);
-}
-function isQueryFlag(entry, flag) {
-    const [rawKey] = entry.split('=');
-    try {
-        return decodeURIComponent(rawKey) === flag;
-    }
-    catch {
-        return rawKey === flag;
-    }
-}
-function createCombinedModule(request, css) {
+function createCombinedModule(request, css, options) {
+    const shouldEmitDefault = options?.emitDefault ?? shouldForwardDefaultExport(request);
     const requestLiteral = JSON.stringify(request);
     const lines = [
         `import * as __knightedModule from ${requestLiteral};`,
         `export * from ${requestLiteral};`,
     ];
-    if (shouldForwardDefaultExport(request)) {
+    if (shouldEmitDefault) {
         lines.push(`const __knightedDefault =
 typeof __knightedModule.default !== 'undefined'
   ? __knightedModule.default
@@ -149,13 +145,3 @@ typeof __knightedModule.default !== 'undefined'
     lines.push(buildInjection(css));
     return lines.join('\n');
 }
-function shouldForwardDefaultExport(request) {
-    const [pathPart] = request.split('?');
-    if (!pathPart)
-        return true;
-    const lower = pathPart.toLowerCase();
-    if (lower.endsWith('.css.ts') || lower.endsWith('.css.js')) {
-        return false;
-    }
-    return true;
-}

package/dist/loaderInternals.d.ts

@@ -0,0 +1,16 @@
+import type { ModuleDefaultSignal } from './moduleInfo.js';
+export declare const COMBINED_QUERY_FLAG = "combined";
+export declare const NAMED_ONLY_QUERY_FLAGS: readonly ["named-only", "no-default"];
+export declare function splitQuery(query: string): string[];
+export declare function isQueryFlag(entry: string, flag: string): boolean;
+export declare function buildSanitizedQuery(query?: string | null): string;
+export declare function shouldForwardDefaultExport(request: string): boolean;
+export declare function shouldEmitCombinedDefault(options: {
+    detection: ModuleDefaultSignal;
+    request: string;
+    skipSyntheticDefault: boolean;
+}): boolean;
+export declare const __loaderInternals: {
+    buildSanitizedQuery: typeof buildSanitizedQuery;
+    shouldEmitCombinedDefault: typeof shouldEmitCombinedDefault;
+};

package/dist/loaderInternals.js

@@ -0,0 +1,63 @@
+export const COMBINED_QUERY_FLAG = 'combined';
+export const NAMED_ONLY_QUERY_FLAGS = ['named-only', 'no-default'];
+export function splitQuery(query) {
+    const trimmed = query.startsWith('?') ? query.slice(1) : query;
+    if (!trimmed)
+        return [];
+    return trimmed.split('&').filter(Boolean);
+}
+export function isQueryFlag(entry, flag) {
+    const [rawKey] = entry.split('=');
+    try {
+        return decodeURIComponent(rawKey) === flag;
+    }
+    catch {
+        return rawKey === flag;
+    }
+}
+export function buildSanitizedQuery(query) {
+    if (!query)
+        return '';
+    const entries = splitQuery(query).filter(part => {
+        if (isQueryFlag(part, COMBINED_QUERY_FLAG)) {
+            return false;
+        }
+        if (isQueryFlag(part, 'knighted-css')) {
+            return false;
+        }
+        if (NAMED_ONLY_QUERY_FLAGS.some(flag => isQueryFlag(part, flag))) {
+            return false;
+        }
+        return true;
+    });
+    return entries.length > 0 ? `?${entries.join('&')}` : '';
+}
+export function shouldForwardDefaultExport(request) {
+    const [pathPart] = request.split('?');
+    if (!pathPart)
+        return true;
+    const lower = pathPart.toLowerCase();
+    if (lower.endsWith('.css.ts') || lower.endsWith('.css.js')) {
+        return false;
+    }
+    return true;
+}
+export function shouldEmitCombinedDefault(options) {
+    if (options.skipSyntheticDefault) {
+        return false;
+    }
+    if (!shouldForwardDefaultExport(options.request)) {
+        return false;
+    }
+    if (options.detection === 'has-default') {
+        return true;
+    }
+    if (options.detection === 'no-default') {
+        return false;
+    }
+    return true;
+}
+export const __loaderInternals = {
+    buildSanitizedQuery,
+    shouldEmitCombinedDefault,
+};

package/dist/moduleInfo.d.ts

@@ -0,0 +1,10 @@
+import { parse } from 'es-module-lexer';
+export type ModuleDefaultSignal = 'has-default' | 'no-default' | 'unknown';
+type LexerOverrides = {
+    parse?: typeof parse;
+};
+export declare function detectModuleDefaultExport(filePath: string): Promise<ModuleDefaultSignal>;
+export declare const __moduleInfoInternals: {
+    setLexerOverrides(overrides?: LexerOverrides): void;
+};
+export {};

package/dist/moduleInfo.js

@@ -0,0 +1,55 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { init, parse } from 'es-module-lexer';
+const DETECTABLE_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts',
+]);
+let lexerInit;
+let lexerOverrides;
+function ensureLexerInitialized() {
+    if (!lexerInit) {
+        lexerInit = init;
+    }
+    return lexerInit;
+}
+export async function detectModuleDefaultExport(filePath) {
+    if (!DETECTABLE_EXTENSIONS.has(path.extname(filePath))) {
+        return 'unknown';
+    }
+    let source;
+    try {
+        source = await readFile(filePath, 'utf8');
+    }
+    catch {
+        return 'unknown';
+    }
+    try {
+        await ensureLexerInitialized();
+        const [, exports] = (lexerOverrides?.parse ?? parse)(source, filePath);
+        if (exports.some(entry => entry.n === 'default')) {
+            return 'has-default';
+        }
+        if (exports.length === 0) {
+            return 'unknown';
+        }
+        return 'no-default';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export const __moduleInfoInternals = {
+    setLexerOverrides(overrides) {
+        lexerOverrides = overrides;
+        if (!overrides) {
+            lexerInit = undefined;
+        }
+    },
+};

package/dist/sassInternals.d.ts

@@ -0,0 +1,26 @@
+export type CssResolver = (specifier: string, ctx: {
+    cwd: string;
+}) => string | Promise<string | undefined>;
+export declare function createSassImporter({ cwd, resolver, }: {
+    cwd: string;
+    resolver?: CssResolver;
+}): {
+    canonicalize(url: string, context?: {
+        containingUrl?: URL | null;
+    }): Promise<import("node:url").URL | null>;
+    load(canonicalUrl: URL): Promise<{
+        contents: string;
+        syntax: "scss" | "indented";
+    }>;
+} | undefined;
+export declare function resolveAliasSpecifier(specifier: string, resolver: CssResolver, cwd: 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;
+export declare const __sassInternals: {
+    createSassImporter: typeof createSassImporter;
+    resolveAliasSpecifier: typeof resolveAliasSpecifier;
+    shouldNormalizeSpecifier: typeof shouldNormalizeSpecifier;
+    ensureSassPath: typeof ensureSassPath;
+    resolveRelativeSpecifier: typeof resolveRelativeSpecifier;
+};

package/dist/sassInternals.js

@@ -0,0 +1,121 @@
+import path from 'node:path';
+import { existsSync, promises as fs } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+export function createSassImporter({ cwd, resolver, }) {
+    if (!resolver)
+        return undefined;
+    const debug = process.env.KNIGHTED_CSS_DEBUG_SASS === '1';
+    return {
+        async canonicalize(url, context) {
+            if (debug) {
+                console.error('[knighted-css:sass] canonicalize request:', url);
+                if (context?.containingUrl) {
+                    console.error('[knighted-css:sass] containing url:', context.containingUrl.href);
+                }
+            }
+            if (shouldNormalizeSpecifier(url)) {
+                const resolvedPath = await resolveAliasSpecifier(url, resolver, cwd);
+                if (!resolvedPath) {
+                    if (debug) {
+                        console.error('[knighted-css:sass] resolver returned no result for', url);
+                    }
+                    return null;
+                }
+                const fileUrl = pathToFileURL(resolvedPath);
+                if (debug) {
+                    console.error('[knighted-css:sass] canonical url:', fileUrl.href);
+                }
+                return fileUrl;
+            }
+            const relativePath = resolveRelativeSpecifier(url, context?.containingUrl);
+            if (relativePath) {
+                const fileUrl = pathToFileURL(relativePath);
+                if (debug) {
+                    console.error('[knighted-css:sass] canonical url:', fileUrl.href);
+                }
+                return fileUrl;
+            }
+            return null;
+        },
+        async load(canonicalUrl) {
+            if (debug) {
+                console.error('[knighted-css:sass] load request:', canonicalUrl.href);
+            }
+            const filePath = fileURLToPath(canonicalUrl);
+            const contents = await fs.readFile(filePath, 'utf8');
+            return {
+                contents,
+                syntax: inferSassSyntax(filePath),
+            };
+        },
+    };
+}
+export async function resolveAliasSpecifier(specifier, resolver, cwd) {
+    const resolved = await resolver(specifier, { cwd });
+    if (!resolved) {
+        return undefined;
+    }
+    if (resolved.startsWith('file://')) {
+        return ensureSassPath(fileURLToPath(new URL(resolved)));
+    }
+    const normalized = path.isAbsolute(resolved) ? resolved : path.resolve(cwd, resolved);
+    return ensureSassPath(normalized);
+}
+export function shouldNormalizeSpecifier(specifier) {
+    const schemeMatch = specifier.match(/^([a-z][\w+.-]*):/i);
+    if (!schemeMatch) {
+        return false;
+    }
+    const scheme = schemeMatch[1].toLowerCase();
+    if (scheme === 'file' ||
+        scheme === 'http' ||
+        scheme === 'https' ||
+        scheme === 'data' ||
+        scheme === 'sass') {
+        return false;
+    }
+    return true;
+}
+function inferSassSyntax(filePath) {
+    return filePath.endsWith('.sass') ? 'indented' : 'scss';
+}
+export function ensureSassPath(filePath) {
+    if (existsSync(filePath)) {
+        return filePath;
+    }
+    const ext = path.extname(filePath);
+    const dir = path.dirname(filePath);
+    const base = path.basename(filePath, ext);
+    const partialCandidate = path.join(dir, `_${base}${ext}`);
+    if (ext && existsSync(partialCandidate)) {
+        return partialCandidate;
+    }
+    const indexCandidate = path.join(dir, base, `index${ext}`);
+    if (ext && existsSync(indexCandidate)) {
+        return indexCandidate;
+    }
+    const partialIndexCandidate = path.join(dir, base, `_index${ext}`);
+    if (ext && existsSync(partialIndexCandidate)) {
+        return partialIndexCandidate;
+    }
+    return undefined;
+}
+export function resolveRelativeSpecifier(specifier, containingUrl) {
+    if (!containingUrl || containingUrl.protocol !== 'file:') {
+        return undefined;
+    }
+    if (/^[a-z][\w+.-]*:/i.test(specifier)) {
+        return undefined;
+    }
+    const containingPath = fileURLToPath(containingUrl);
+    const baseDir = path.dirname(containingPath);
+    const candidate = path.resolve(baseDir, specifier);
+    return ensureSassPath(candidate);
+}
+export const __sassInternals = {
+    createSassImporter,
+    resolveAliasSpecifier,
+    shouldNormalizeSpecifier,
+    ensureSassPath,
+    resolveRelativeSpecifier,
+};

package/loader-queries.d.ts

@@ -19,3 +19,11 @@ declare module '*?knighted-css&combined' {
   export default combined
   export const knightedCss: string
 }
+
+declare module '*?knighted-css&combined&named-only*' {
+  export const knightedCss: string
+}
+
+declare module '*?knighted-css&combined&no-default*' {
+  export const knightedCss: string
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/css",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.6",
   "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",
@@ -66,6 +66,7 @@
   },
   "dependencies": {
     "dependency-tree": "^11.2.0",
+    "es-module-lexer": "^2.0.0",
     "lightningcss": "^1.30.2"
   },
   "overrides": {