knip 6.22.0 → 6.24.0

package/LICENSE

@@ -1,6 +1,6 @@
 ISC License (ISC)
 
-Copyright 2022-2025 Lars Kappert
+Copyright 2022-2026 Lars Kappert
 
 Permission to use, copy, modify, and/or distribute this software for any purpose
 with or without fee is hereby granted, provided that the above copyright notice

package/dist/ConfigurationChief.d.ts

@@ -72,6 +72,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'astro-markdoc'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'astro-og-canvas'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -867,6 +872,7 @@ export declare class ConfigurationChief {
         angular?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         astro?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "astro-db"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "astro-markdoc"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "astro-og-canvas"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         ava?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         babel?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ProjectPrincipal.js

@@ -130,11 +130,9 @@ export class ProjectPrincipal {
     }
     async runAsyncCompilers() {
         const add = timerify(this.fileManager.compileAndAddSourceFile.bind(this.fileManager));
-        const extensions = Array.from(this.asyncCompilers.keys());
-        const files = Array.from(this.projectPaths).filter(filePath => extensions.includes(extname(filePath)));
-        for (const filePath of files) {
-            await add(filePath);
-        }
+        for (const filePath of this.projectPaths)
+            if (this.asyncCompilers.has(extname(filePath)))
+                await add(filePath);
     }
     walkAndAnalyze(analyzeFile) {
         this.resolvedFiles.clear();

package/dist/WorkspaceWorker.d.ts

@@ -17,6 +17,7 @@ type WorkspaceManagerOptions = {
     rootManifest: Manifest | undefined;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
     readFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -38,6 +39,7 @@ export declare class WorkspaceWorker {
     dependencies: DependencySet;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
     readFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -47,7 +49,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -32,6 +32,7 @@ export class WorkspaceWorker {
     dependencies;
     handleInput;
     findWorkspaceByFilePath;
+    getManifest;
     readFile;
     negatedWorkspacePatterns = [];
     ignoredWorkspacePatterns = [];
@@ -41,7 +42,7 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -54,6 +55,7 @@ export class WorkspaceWorker {
         this.configFilesMap = configFilesMap;
         this.handleInput = handleInput;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
+        this.getManifest = getManifest;
         this.readFile = readFile;
         this.options = options;
         this.cache = new CacheConsultant(`plugins-${name}`, options);
@@ -211,7 +213,8 @@ export class WorkspaceWorker {
         const isProduction = this.options.isProduction;
         const knownBinsOnly = false;
         const rootManifest = this.rootManifest;
-        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        const getManifest = this.getManifest;
+        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly, getManifest };
         const baseScriptOptions = { ...baseOptions, isProduction, enabledPlugins: this.enabledPlugins };
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);

package/dist/binaries/resolvers/index.d.ts

@@ -1,6 +1,8 @@
 declare const _default: {
     bun: import("../../types/config.ts").BinaryResolver;
     bunx: import("../../types/config.ts").BinaryResolver;
+    nub: import("../../types/config.ts").BinaryResolver;
+    nubx: import("../../types/config.ts").BinaryResolver;
     find: import("../../types/config.ts").BinaryResolver;
     npm: import("../../types/config.ts").BinaryResolver;
     npx: import("../../types/config.ts").BinaryResolver;

package/dist/binaries/resolvers/index.js

@@ -3,12 +3,15 @@ import * as bunx from './bunx.js';
 import * as find from './find.js';
 import * as npm from './npm.js';
 import * as npx from './npx.js';
+import * as nub from './nub.js';
 import * as pnpm from './pnpm.js';
 import * as pnpx from './pnpx.js';
 import * as yarn from './yarn.js';
 export default {
     bun: bun.resolve,
     bunx: bunx.resolve,
+    nub: nub.resolve,
+    nubx: bunx.resolve,
     find: find.resolve,
     npm: npm.resolve,
     npx: npx.resolve,

package/dist/binaries/resolvers/nub.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../../types/config.ts';
+export declare const resolve: BinaryResolver;

package/dist/binaries/resolvers/nub.js

@@ -0,0 +1,46 @@
+import parseArgs from '../../util/parse-args.js';
+import { toBinary, toEntry } from '../../util/input.js';
+import { isAbsolute, join } from '../../util/path.js';
+import { _resolveSync } from '../../util/resolve.js';
+import { resolveX } from './bunx.js';
+const runtimes = new Set(['x', 'dlx', 'exec']);
+const runners = new Set(['run', 'watch']);
+const commands = new Set([
+    'add',
+    'approve-builds',
+    'audit',
+    'ci',
+    'create',
+    'init',
+    'install',
+    'link',
+    'node',
+    'outdated',
+    'pm',
+    'publish',
+    'remove',
+    'unlink',
+    'update',
+    'why',
+]);
+export const resolve = (_binary, args, options) => {
+    const binary = toBinary(_binary);
+    const { manifest, cwd, fromArgs } = options;
+    const parsed = parseArgs(args, { string: ['filter'], boolean: ['recursive'], alias: { recursive: 'r' } });
+    const [command, script] = parsed._;
+    if (runtimes.has(command)) {
+        const rest = args.filter(arg => arg !== command);
+        return [binary, ...resolveX(rest, options)];
+    }
+    if (parsed.recursive || parsed.filter)
+        return [binary];
+    if (runners.has(command)) {
+        if (!script || manifest.scriptNames.has(script))
+            return [binary];
+        const resolved = _resolveSync(isAbsolute(script) ? script : join(cwd, script), cwd);
+        return resolved ? [binary, toEntry(resolved)] : [binary];
+    }
+    if (command && (commands.has(command) || manifest.scriptNames.has(command)))
+        return [binary];
+    return [binary, ...fromArgs(['node', ...args])];
+};

package/dist/binaries/resolvers/yarn.js

@@ -49,15 +49,16 @@ const resolveDlx = (args, options) => {
     return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
 };
 export const resolve = (_binary, args, options) => {
-    const { manifest, fromArgs, cwd, rootCwd } = options;
+    const { manifest, fromArgs, cwd, rootCwd, getManifest } = options;
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
     if (!command && !binary)
         return [];
+    const dirManifest = (dir && getManifest(dir)) || manifest;
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (manifest.scriptNames.has(binary))
+        if (dirManifest.scriptNames.has(binary))
             return _childArgs;
         const bin = toBinary(binary, { optional: true });
         if (dir)
@@ -70,7 +71,7 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if ((!dir && manifest.scriptNames.has(command)) || commands.includes(command))
+    if (dirManifest.scriptNames.has(command) || commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);

package/dist/compilers/compilers.d.ts

@@ -2,10 +2,12 @@ import type { CompilerSync } from './types.ts';
 export declare const fencedCodeBlockMatcher: RegExp;
 export declare const inlineCodeMatcher: RegExp;
 export declare const scriptExtractor: RegExp;
+export declare const styleExtractor: RegExp;
 export declare const blockCommentMatcher: RegExp;
 export declare const lineCommentMatcher: RegExp;
 export declare const importMatcher: RegExp;
 export declare const importsWithinScripts: CompilerSync;
 export declare const scriptBodies: CompilerSync;
+export declare const getStyleLang: (attrs: string) => string | undefined;
 export declare const frontmatterMatcher: RegExp;
 export declare const importsWithinFrontmatter: (text: string, keys?: string[]) => string;

package/dist/compilers/compilers.js

@@ -1,26 +1,37 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
 export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
+const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
 export const importMatcher = /import(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const importsWithinScripts = (text) => {
     const scripts = [];
-    for (const [, , scriptBody] of text.matchAll(scriptExtractor)) {
+    scriptExtractor.lastIndex = 0;
+    let scriptMatch;
+    while ((scriptMatch = scriptExtractor.exec(text))) {
+        const scriptBody = scriptMatch[2];
         const body = scriptBody.replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
-        for (const importMatch of body.matchAll(importMatcher))
-            scripts.push(importMatch);
+        let importMatch;
+        importMatcher.lastIndex = 0;
+        while ((importMatch = importMatcher.exec(body)))
+            scripts.push(importMatch[0]);
     }
     return scripts.join(';\n');
 };
 export const scriptBodies = (text) => {
     const scripts = [];
-    for (const [, , body] of text.matchAll(scriptExtractor)) {
+    scriptExtractor.lastIndex = 0;
+    let match;
+    while ((match = scriptExtractor.exec(text))) {
+        const body = match[2];
         if (body)
             scripts.push(body);
     }
     return scripts.join(';\n');
 };
+export const getStyleLang = (attrs) => attrs.match(langAttrMatcher)?.[1]?.toLowerCase();
 export const frontmatterMatcher = /^---\r?\n([\s\S]*?)\r?\n---/;
 export const importsWithinFrontmatter = (text, keys = []) => {
     const frontmatter = text.match(frontmatterMatcher)?.[1];

package/dist/compilers/index.d.ts

@@ -18,6 +18,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'astro-markdoc'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     'astro-og-canvas'?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -820,6 +825,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'astro-markdoc'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'astro-og-canvas'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1601,5 +1611,5 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     syncCompilers: Record<string, true | CompilerSync>;
     asyncCompilers: Record<string, CompilerAsync>;
 };
-export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet) => Compilers;
+export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet, onReferencedDependency?: (packageName: string) => void) => Compilers;
 export declare const getCompilerExtensions: (compilers: [SyncCompilers, AsyncCompilers]) => string[];

package/dist/compilers/index.js

@@ -1,5 +1,7 @@
+import LESS from './less.js';
 import MDX from './mdx.js';
 import SCSS from './scss.js';
+import STYLUS from './stylus.js';
 const isAsyncCompiler = (fn) => (fn ? fn.constructor.name === 'AsyncFunction' : false);
 export const normalizeCompilerExtension = (ext) => ext.replace(/^\.*/, '.');
 export const partitionCompilers = (rawLocalConfig) => {
@@ -26,16 +28,29 @@ export const partitionCompilers = (rawLocalConfig) => {
     }
     return { ...rawLocalConfig, syncCompilers, asyncCompilers };
 };
-const compilers = new Map([
-    ['.mdx', MDX],
-    ['.sass', SCSS],
-    ['.scss', SCSS],
-]);
-export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
-    const hasDependency = (packageName) => dependencies.has(packageName);
-    for (const [extension, { condition, compiler }] of compilers) {
-        if ((!syncCompilers.has(extension) && condition(hasDependency)) || syncCompilers.get(extension) === true) {
-            syncCompilers.set(extension, compiler);
+const compilers = [
+    { extensions: ['.mdx'], ...MDX },
+    { extensions: ['.sass', '.scss'], ...SCSS },
+    { extensions: ['.less'], ...LESS },
+    { extensions: ['.styl', '.stylus'], ...STYLUS },
+];
+export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies, onReferencedDependency) => {
+    for (const { extensions, dependencies: compilerDependencies, compiler } of compilers) {
+        let hasCompilerDependency = false;
+        for (const dependency of compilerDependencies) {
+            if (dependencies.has(dependency)) {
+                hasCompilerDependency = true;
+                if (onReferencedDependency)
+                    onReferencedDependency(dependency);
+                else
+                    break;
+            }
+        }
+        for (const extension of extensions) {
+            const existingCompiler = syncCompilers.get(extension);
+            if (existingCompiler === true || (existingCompiler === undefined && hasCompilerDependency)) {
+                syncCompilers.set(extension, compiler);
+            }
         }
     }
     return [syncCompilers, asyncCompilers];

package/dist/compilers/less.d.ts

@@ -0,0 +1,7 @@
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
+declare const _default: {
+    dependencies: string[];
+    compiler: CompilerSync;
+};
+export default _default;

package/dist/compilers/less.js

@@ -0,0 +1,37 @@
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['less'];
+const importMatcher = /@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
+const isExternalUrl = (s) => s.startsWith('//') || s.startsWith('http://') || s.startsWith('https://');
+const candidates = (specifier) => {
+    const { dir, name } = splitSpec(specifier);
+    if (name.endsWith('.less') || name.endsWith('.css'))
+        return [`${dir}/${name}`];
+    return [`${dir}/${name}.less`];
+};
+export const compiler = text => {
+    if (!text.includes('@import'))
+        return '';
+    const out = [];
+    let i = 0;
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
+        let spec = match[1] ?? match[2];
+        if (!spec || isExternalUrl(spec))
+            continue;
+        let isBare = isScopedPackage(spec);
+        if (isTildePackage(spec)) {
+            spec = spec.slice(1);
+            isBare = true;
+        }
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
+    }
+    return out.join('\n');
+};
+export default { dependencies, compiler };

package/dist/compilers/mdx.d.ts

@@ -1,6 +1,5 @@
-import type { HasDependency } from './types.ts';
 declare const _default: {
-    condition: (hasDependency: HasDependency) => boolean;
+    dependencies: string[];
     compiler: (text: string) => string;
 };
 export default _default;

package/dist/compilers/mdx.js

@@ -1,5 +1,5 @@
 import { fencedCodeBlockMatcher, frontmatterMatcher, inlineCodeMatcher } from './compilers.js';
-const mdxDependencies = [
+const dependencies = [
     '@mdx-js/esbuild',
     '@mdx-js/loader',
     '@mdx-js/mdx',
@@ -10,13 +10,19 @@ const mdxDependencies = [
     '@mdx-js/vue',
     'remark-mdx',
 ];
-const condition = (hasDependency) => mdxDependencies.some(hasDependency);
 const mdxImportMatcher = /^import[^'"]+['"][^'"]+['"]/gm;
-const compiler = (text) => [
-    ...text
+const compiler = (text) => {
+    if (!text.includes('import'))
+        return '';
+    const imports = [];
+    const source = text
         .replace(frontmatterMatcher, '')
         .replace(fencedCodeBlockMatcher, '')
-        .replace(inlineCodeMatcher, '')
-        .matchAll(mdxImportMatcher),
-].join('\n');
-export default { condition, compiler };
+        .replace(inlineCodeMatcher, '');
+    let match;
+    mdxImportMatcher.lastIndex = 0;
+    while ((match = mdxImportMatcher.exec(source)))
+        imports.push(match[0]);
+    return imports.join('\n');
+};
+export default { dependencies, compiler };

package/dist/compilers/scss.d.ts

@@ -1,6 +1,7 @@
-import type { CompilerSync, HasDependency } from './types.ts';
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
 declare const _default: {
-    condition: (hasDependency: HasDependency) => boolean;
+    dependencies: string[];
     compiler: CompilerSync;
 };
 export default _default;

package/dist/compilers/scss.js

@@ -1,13 +1,8 @@
-import { basename, dirname } from '../util/path.js';
-const condition = (hasDependency) => hasDependency('sass') || hasDependency('sass-embedded') || hasDependency('node-sass');
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['sass', 'sass-embedded', 'node-sass'];
 const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
-const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
-const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
-const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
 const candidates = (specifier) => {
-    const spec = specifier.startsWith('.') || isAlias(specifier) ? specifier : `./${specifier}`;
-    const name = basename(spec);
-    const dir = dirname(spec);
+    const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');
     const bases = hasExt ? [name] : [`${name}.scss`, `${name}.sass`];
     const out = [];
@@ -18,10 +13,14 @@ const candidates = (specifier) => {
     }
     return out;
 };
-const compiler = text => {
+export const compiler = text => {
+    if (!text.includes('@use') && !text.includes('@import') && !text.includes('@forward'))
+        return '';
     const out = [];
     let i = 0;
-    for (const match of text.matchAll(importMatcher)) {
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
         let spec = match[2];
         if (!spec || spec.startsWith('sass:'))
             continue;
@@ -30,10 +29,14 @@ const compiler = text => {
             spec = spec.slice(1);
             isBare = true;
         }
-        const specs = isBare ? [spec] : candidates(spec);
-        for (const s of specs)
-            out.push(`import _$${i++} from '${s}';`);
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
     }
     return out.join('\n');
 };
-export default { condition, compiler };
+export default { dependencies, compiler };

package/dist/compilers/shared.d.ts

@@ -0,0 +1,6 @@
+export declare const isScopedPackage: (s: string) => boolean;
+export declare const isTildePackage: (s: string) => boolean;
+export declare const splitSpec: (specifier: string) => {
+    dir: string;
+    name: string;
+};

package/dist/compilers/shared.js

@@ -0,0 +1,9 @@
+import { basename, dirname } from '../util/path.js';
+const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
+export const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
+export const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
+const ensureRelative = (spec) => (spec.startsWith('.') || isAlias(spec) ? spec : `./${spec}`);
+export const splitSpec = (specifier) => {
+    const spec = ensureRelative(specifier);
+    return { dir: dirname(spec), name: basename(spec) };
+};

package/dist/compilers/style-preprocessors.d.ts

@@ -0,0 +1,2 @@
+import type { CompilerSync } from './types.ts';
+export declare const stylePreprocessorImports: CompilerSync;

package/dist/compilers/style-preprocessors.js

@@ -0,0 +1,41 @@
+import { getStyleLang, styleExtractor } from './compilers.js';
+import { compiler as lessCompiler } from './less.js';
+import { compiler as scssCompiler } from './scss.js';
+import { compiler as stylusCompiler } from './stylus.js';
+export const stylePreprocessorImports = (text, path) => {
+    let scss = '';
+    let less = '';
+    let stylus = '';
+    styleExtractor.lastIndex = 0;
+    let match;
+    while ((match = styleExtractor.exec(text))) {
+        const attrs = match[1];
+        const body = match[2];
+        if (!body)
+            continue;
+        switch (getStyleLang(attrs)) {
+            case 'scss':
+            case 'sass':
+                scss = scss ? `${scss}\n${body}` : body;
+                break;
+            case 'less':
+                less = less ? `${less}\n${body}` : body;
+                break;
+            case 'styl':
+            case 'stylus':
+                stylus = stylus ? `${stylus}\n${body}` : body;
+        }
+    }
+    let out = scss ? scssCompiler(scss, path) : '';
+    if (less) {
+        const imports = lessCompiler(less, path);
+        if (imports)
+            out = out ? `${out}\n${imports}` : imports;
+    }
+    if (stylus) {
+        const imports = stylusCompiler(stylus, path);
+        if (imports)
+            out = out ? `${out}\n${imports}` : imports;
+    }
+    return out;
+};

package/dist/compilers/stylus.d.ts

@@ -0,0 +1,7 @@
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
+declare const _default: {
+    dependencies: string[];
+    compiler: CompilerSync;
+};
+export default _default;

package/dist/compilers/stylus.js

@@ -0,0 +1,36 @@
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['stylus'];
+const importMatcher = /@(?:import|require)\s+['"]([^'"]+)['"]/g;
+const candidates = (specifier) => {
+    const { dir, name } = splitSpec(specifier);
+    if (name.endsWith('.styl') || name.endsWith('.stylus') || name.endsWith('.css'))
+        return [`${dir}/${name}`];
+    return [`${dir}/${name}.styl`, `${dir}/${name}/index.styl`];
+};
+export const compiler = text => {
+    if (!text.includes('@import') && !text.includes('@require'))
+        return '';
+    const out = [];
+    let i = 0;
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
+        let spec = match[1];
+        if (!spec || spec.includes('*'))
+            continue;
+        let isBare = isScopedPackage(spec);
+        if (isTildePackage(spec)) {
+            spec = spec.slice(1);
+            isBare = true;
+        }
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
+    }
+    return out.join('\n');
+};
+export default { dependencies, compiler };

package/dist/constants.js

@@ -84,6 +84,8 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'npm',
     'nproc',
     'npx',
+    'nub',
+    'nubx',
     'paste',
     'pnpm',
     'pnpx',
@@ -153,6 +155,8 @@ export const FOREIGN_FILE_EXTENSIONS = new Set([
     '.sass',
     '.scss',
     '.sh',
+    '.styl',
+    '.stylus',
     '.svg',
     '.ttf',
     '.webp',