knip 6.29.0 → 6.30.0

package/dist/CatalogCounselor.d.ts

@@ -1,5 +1,6 @@
 import type { Issue } from './types/issues.ts';
-import type { Catalog, Catalogs, PackageJson } from './types/package-json.ts';
+import type { Catalog, Catalogs, WorkspacePackage } from './types/package-json.ts';
+import { type CatalogReference } from './util/catalog.ts';
 import type { MainOptions } from './util/create-options.ts';
 export type CatalogContainer = {
     filePath: string;
@@ -10,9 +11,11 @@ export declare class CatalogCounselor {
     private filePath;
     private entries;
     private referencedEntries;
+    private referenceIssues;
     private fileContent?;
     constructor(options: MainOptions);
     private addReferencedCatalogEntry;
-    addWorkspace(manifest: PackageJson): void;
+    addReference({ catalogName, packageName }: CatalogReference): void;
+    addWorkspace({ name: workspace, manifest, manifestPath: filePath, manifestStr, }: Pick<WorkspacePackage, 'name' | 'manifest' | 'manifestPath' | 'manifestStr'>): void;
     settleCatalogIssues(options: MainOptions): Promise<Issue[]>;
 }

package/dist/CatalogCounselor.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { JsonCatalogPeeker } from './JsonCatalogPeeker.js';
+import { PackagePeeker } from './PackagePeeker.js';
 import { extractCatalogReferences, parseCatalog } from './util/catalog.js';
 import { extname } from './util/path.js';
 import { YamlCatalogPeeker } from './YamlCatalogPeeker.js';
@@ -8,6 +9,7 @@ export class CatalogCounselor {
     filePath;
     entries = new Set();
     referencedEntries = new Set();
+    referenceIssues = [];
     fileContent;
     constructor(options) {
         this.filePath = options.catalog.filePath;
@@ -16,20 +18,36 @@ export class CatalogCounselor {
     addReferencedCatalogEntry(entryName) {
         this.referencedEntries.add(entryName);
     }
-    addWorkspace(manifest) {
-        if (this.entries.size === 0)
-            return;
+    addReference({ catalogName, packageName }) {
+        this.addReferencedCatalogEntry(`${catalogName}:${packageName}`);
+    }
+    addWorkspace({ name: workspace, manifest, manifestPath: filePath, manifestStr, }) {
         const catalogReferences = extractCatalogReferences(manifest);
-        for (const catalogEntryName of catalogReferences)
+        if (catalogReferences.length === 0)
+            return;
+        const peeker = new PackagePeeker(manifestStr);
+        for (const { catalogName, packageName } of catalogReferences) {
+            const catalogEntryName = `${catalogName}:${packageName}`;
             this.addReferencedCatalogEntry(catalogEntryName);
+            if (!this.entries.has(catalogEntryName)) {
+                const pos = peeker.getCatalogReferenceLocation(packageName, catalogName);
+                this.referenceIssues.push({
+                    type: 'catalogReferences',
+                    filePath,
+                    workspace,
+                    symbol: packageName,
+                    parentSymbol: catalogName,
+                    fixes: [],
+                    ...pos,
+                });
+            }
+        }
     }
     async settleCatalogIssues(options) {
-        if (this.entries.size === 0)
-            return [];
         const filePath = this.filePath;
         const workspace = ROOT_WORKSPACE_NAME;
         const catalogIssues = [];
-        if (this.entries.size > this.referencedEntries.size) {
+        if (this.entries.size > 0) {
             this.fileContent = await readFile(filePath, 'utf-8');
             const isYaml = ['.yml', '.yaml'].includes(extname(filePath));
             const Peeker = isYaml ? YamlCatalogPeeker : JsonCatalogPeeker;
@@ -45,6 +63,6 @@ export class CatalogCounselor {
                 }
             }
         }
-        return catalogIssues;
+        return [...catalogIssues, ...this.referenceIssues];
     }
 }

package/dist/ConfigurationChief.d.ts

@@ -957,7 +957,7 @@ export declare class ConfigurationChief {
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-        ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+        ignoreIssues?: Record<string, ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     };
     getIgnores(workspaceName: string): {

package/dist/ConfigurationChief.js

@@ -184,16 +184,16 @@ export class ConfigurationChief {
         const patterns = workspaceKeys.filter(key => key.includes('*'));
         const dirs = workspaceKeys.filter(key => !key.includes('*'));
         const globbedDirs = await _dirGlob({ patterns, cwd: this.cwd });
-        return new Set([...dirs, ...globbedDirs].filter(name => name !== ROOT_WORKSPACE_NAME &&
-            !this.workspacePackages.has(name) &&
-            !picomatch.isMatch(name, this.ignoredWorkspacePatterns)));
+        const isIgnored = picomatch(this.ignoredWorkspacePatterns);
+        return new Set([...dirs, ...globbedDirs].filter(name => name !== ROOT_WORKSPACE_NAME && !isIgnored(name)));
     }
     getAvailableWorkspaceNames(names) {
         const availableWorkspaceNames = [];
         const [ignore, patterns] = partition(this.ignoredWorkspacePatterns, pattern => pattern.startsWith('!'));
         const ignoreSliced = ignore.map(pattern => pattern.slice(1));
+        const isIgnored = picomatch(patterns, { ignore: ignoreSliced });
         for (const name of names) {
-            if (!picomatch.isMatch(name, patterns, { ignore: ignoreSliced })) {
+            if (!isIgnored(name)) {
                 availableWorkspaceNames.push(name);
             }
         }
@@ -206,40 +206,33 @@ export class ConfigurationChief {
         const workspaceNames = selectedWorkspaces
             ? Array.from(selectedWorkspaces).flatMap(name => [...getAncestors(name), name])
             : this.availableWorkspaceNames;
-        const ws = new Set();
-        if (selectedWorkspaces && this.isStrict) {
-            for (const name of selectedWorkspaces)
-                ws.add(name);
-        }
-        else if (selectedWorkspaces) {
+        const ws = new Set(selectedWorkspaces && this.isStrict ? selectedWorkspaces : workspaceNames);
+        if (selectedWorkspaces && !this.isStrict) {
             const graph = this.workspaceGraph;
-            if (graph) {
-                const seen = new Set();
-                const initialWorkspaces = new Set(workspaceNames.map(name => join(this.cwd, name)));
-                const workspaceDirsWithDependents = new Set(initialWorkspaces);
-                const addDependents = (dir) => {
-                    seen.add(dir);
-                    const dirs = graph.get(dir);
-                    if (!dirs || dirs.size === 0)
-                        return;
-                    for (const d of dirs)
-                        if (initialWorkspaces.has(d)) {
-                            workspaceDirsWithDependents.add(dir);
-                            break;
-                        }
-                    for (const dir of dirs)
-                        if (!seen.has(dir))
-                            addDependents(dir);
-                };
-                for (const dir of this.availableWorkspaceDirs)
-                    addDependents(dir);
-                for (const dir of workspaceDirsWithDependents)
-                    ws.add(relative(this.cwd, dir));
+            const initialWorkspaceDirs = new Set(workspaceNames.map(name => join(this.cwd, name)));
+            const includedWorkspaceDirs = new Set(initialWorkspaceDirs);
+            const pendingWorkspaceDirs = [...initialWorkspaceDirs];
+            for (let index = 0; index < pendingWorkspaceDirs.length; index++) {
+                const dependencies = graph.get(pendingWorkspaceDirs[index]);
+                if (!dependencies)
+                    continue;
+                for (const dependency of dependencies) {
+                    if (!graph.has(dependency) || includedWorkspaceDirs.has(dependency))
+                        continue;
+                    includedWorkspaceDirs.add(dependency);
+                    pendingWorkspaceDirs.push(dependency);
+                }
             }
-        }
-        else {
-            for (const name of workspaceNames)
-                ws.add(name);
+            for (const [dir, dependencies] of graph) {
+                for (const dependency of dependencies) {
+                    if (!initialWorkspaceDirs.has(dependency))
+                        continue;
+                    includedWorkspaceDirs.add(dir);
+                    break;
+                }
+            }
+            for (const dir of includedWorkspaceDirs)
+                ws.add(relative(this.cwd, dir));
         }
         return Array.from(ws)
             .sort(byPathDepth)

package/dist/DependencyDeputy.d.ts

@@ -3,6 +3,12 @@ import type { ConfigurationHint, Counters, Issue, Issues, IssueType } from './ty
 import type { PackageJson } from './types/package-json.ts';
 import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.ts';
 import type { MainOptions } from './util/create-options.ts';
+interface DependencyReferenceOptions {
+    isDevOnly?: boolean;
+    isTypeOnly?: boolean;
+    isResolved?: boolean;
+    isPublishedType?: boolean;
+}
 export declare class DependencyDeputy {
     isProduction: boolean;
     isStrict: boolean;
@@ -58,7 +64,7 @@ export declare class DependencyDeputy {
         isPeerOptional: boolean;
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencySet;
-    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean, isTypeOnly?: boolean, isResolved?: boolean): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, { isDevOnly, isTypeOnly, isResolved, isPublishedType }?: DependencyReferenceOptions): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {
@@ -78,3 +84,4 @@ export declare class DependencyDeputy {
     addIgnoredBinaries(workspaceName: string, identifier: string): void;
     addIgnoredUnresolved(workspaceName: string, identifier: string): void;
 }
+export {};

package/dist/DependencyDeputy.js

@@ -122,7 +122,7 @@ export class DependencyDeputy {
     getOptionalPeerDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
-    maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly, isTypeOnly, isResolved) {
+    maybeAddReferencedExternalDependency(workspace, packageName, { isDevOnly, isTypeOnly, isResolved, isPublishedType } = {}) {
         if (!this.isReportDependencies)
             return true;
         if (packageName.startsWith('node:') || isBuiltin(packageName))
@@ -131,8 +131,8 @@ export class DependencyDeputy {
             return true;
         if (packageName === workspace.pkgName)
             return true;
-        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
-        const isDevOrTypeOnly = isDevOnly || isTypeOnly;
+        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...workspace.ancestors.toReversed()];
+        const isDevOrTypeOnly = isDevOnly || (isTypeOnly && !isPublishedType);
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName, isDevOrTypeOnly));
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
         const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName, isDevOrTypeOnly));
@@ -169,7 +169,7 @@ export class DependencyDeputy {
         if (!this.isReportDependencies)
             return new Set();
         this.addReferencedBinary(workspace.name, binaryName);
-        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
+        const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...workspace.ancestors.toReversed()];
         for (const name of workspaceNames) {
             const binaries = this.installedBinaries.get(name);
             if (binaries?.has(binaryName)) {
@@ -219,7 +219,7 @@ export class DependencyDeputy {
                         ...this.getHostDependenciesFor(workspace, typedPackageName),
                     ];
                     if (hostDependencies.length)
-                        return !!hostDependencies.find(host => isReferencedDependency(host.name, visited));
+                        return hostDependencies.some(host => isReferencedDependency(host.name, visited));
                     if (!referencedDependencies?.has(dependency))
                         return false;
                     return referencedDependencies.has(typedPackageName);

package/dist/PackagePeeker.d.ts

@@ -10,4 +10,9 @@ export declare class PackagePeeker {
         col: number;
         pos: number;
     } | undefined;
+    getCatalogReferenceLocation(packageName: string, catalogName: string): {
+        line: number;
+        col: number;
+        pos: number;
+    } | undefined;
 }

package/dist/PackagePeeker.js

@@ -11,11 +11,11 @@ export class PackagePeeker {
         let pos = 0;
         for (let i = 0; i < this.lines.length; i++) {
             const line = this.lines[i];
-            const section = line.indexOf('"dependencies"') !== -1
+            const section = line.includes('"dependencies"')
                 ? 'dependencies'
-                : line.indexOf('"devDependencies"') !== -1
+                : line.includes('"devDependencies"')
                     ? 'devDependencies'
-                    : line.indexOf('"optionalPeerDependencies"') !== -1
+                    : line.includes('"optionalPeerDependencies"')
                         ? 'optionalPeerDependencies'
                         : undefined;
             if (section)
@@ -41,4 +41,32 @@ export class PackagePeeker {
             pos += line.length + 1;
         }
     }
+    getCatalogReferenceLocation(packageName, catalogName) {
+        const property = `"${packageName}"`;
+        const value = `"catalog:${catalogName === 'default' ? '' : catalogName}"`;
+        let propertyPos = this.manifestStr.indexOf(property);
+        while (propertyPos !== -1) {
+            const colonPos = this.manifestStr.indexOf(':', propertyPos + property.length);
+            let valuePos = colonPos + 1;
+            while (valuePos > 0 && this.manifestStr[valuePos]?.trim() === '')
+                valuePos++;
+            if (colonPos !== -1 && this.manifestStr.startsWith(value, valuePos)) {
+                const pos = propertyPos + 1;
+                let line = 1;
+                let lineStart = 0;
+                for (let index = 0; index < pos; index++) {
+                    if (this.manifestStr[index] === '\n') {
+                        line++;
+                        lineStart = index + 1;
+                    }
+                }
+                return {
+                    line,
+                    col: pos - lineStart + 1,
+                    pos,
+                };
+            }
+            propertyPos = this.manifestStr.indexOf(property, propertyPos + property.length);
+        }
+    }
 }

package/dist/WorkspaceWorker.d.ts

@@ -44,7 +44,7 @@ export declare class WorkspaceWorker {
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
     options: MainOptions;
-    enabledPluginsMap: Record<PluginName, boolean>;
+    enabledPluginsMap: Partial<Record<PluginName, boolean>>;
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;

package/dist/WorkspaceWorker.js

@@ -11,9 +11,8 @@ import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
-import { isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
+import { isCatalog, isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
 import { getPackageNameFromSpecifier } from './util/modules.js';
-import { getKeysByValue } from './util/object.js';
 import { timerify } from './util/Performance.js';
 import { basename, dirname, isInternal, join, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
@@ -22,7 +21,6 @@ import { logError } from './util/log.js';
 import { loadConfigForPlugin } from './util/plugin.js';
 import { ELLIPSIS } from './util/string.js';
 const nullConfig = { config: null, entry: null, project: null };
-const initEnabledPluginsMap = () => Object.keys(Plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
 export class WorkspaceWorker {
     name;
     dir;
@@ -37,7 +35,7 @@ export class WorkspaceWorker {
     negatedWorkspacePatterns = [];
     ignoredWorkspacePatterns = [];
     options;
-    enabledPluginsMap = initEnabledPluginsMap();
+    enabledPluginsMap = {};
     enabledPlugins = [];
     enabledPluginsInAncestors;
     cache;
@@ -66,6 +64,7 @@ export class WorkspaceWorker {
     }
     async determineEnabledPlugins() {
         const manifest = this.manifest;
+        const enabledPlugins = [];
         for (const [pluginName, plugin] of PluginEntries) {
             if (this.config[pluginName] === false)
                 continue;
@@ -73,6 +72,7 @@ export class WorkspaceWorker {
                 continue;
             if (this.config[pluginName]) {
                 this.enabledPluginsMap[pluginName] = true;
+                enabledPlugins.push(pluginName);
                 continue;
             }
             const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
@@ -80,9 +80,10 @@ export class WorkspaceWorker {
                 (typeof plugin.isEnabled === 'function' &&
                     (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies: this.dependencies, config: this.config })))) {
                 this.enabledPluginsMap[pluginName] = true;
+                enabledPlugins.push(pluginName);
             }
         }
-        return getKeysByValue(this.enabledPluginsMap, true);
+        return enabledPlugins;
     }
     getConfigForPlugin(pluginName) {
         const config = this.config[pluginName];
@@ -257,7 +258,10 @@ export class WorkspaceWorker {
             }
         };
         for (const input of [...inputsFromManifest, ...productionInputsFromManifest]) {
-            if (isConfig(input)) {
+            if (isCatalog(input)) {
+                inputs.push({ ...input, containingFilePath });
+            }
+            else if (isConfig(input)) {
                 storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
             }
             else if (!isProduction || (isProduction && (input.production || hasProductionInput(input)))) {
@@ -302,7 +306,7 @@ export class WorkspaceWorker {
                     inputs.push(toInput(id));
             }
             else if ((!plugin.resolveConfig && !plugin.resolveFromAST) ||
-                (configFilePaths.filter(path => basename(path) !== 'package.json').length === 0 &&
+                (!configFilePaths.some(path => basename(path) !== 'package.json') &&
                     (!this.configFilesMap.get(wsName)?.get(pluginName) ||
                         this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
                 if (plugin.entry)

package/dist/binaries/bash-parser.js

@@ -4,7 +4,7 @@ import { debugLogObject } from '../util/debug.js';
 import { toBinary, toDeferResolve } from '../util/input.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
-import { truncate } from '../util/string.js';
+import { substringBefore, truncate } from '../util/string.js';
 import { walkCommands } from '../util/scripts.js';
 import { resolve as fallbackResolve } from './fallback.js';
 import KnownResolvers from './resolvers/index.js';
@@ -30,7 +30,7 @@ export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
     const fromArgs = (args, opts) => {
-        if (args.length === 0 || !isValidBinary(args[0].split(' ')[0]))
+        if (args.length === 0 || !isValidBinary(substringBefore(args[0], ' ')))
             return [];
         return getDependenciesFromScript(args.filter(arg => arg !== '--').join(' '), {
             ...options,
@@ -72,7 +72,7 @@ export const getDependenciesFromScript = (script, options) => {
         if (definedFunctions.has(binary))
             return [];
         const args = node.suffix.map(w => w.value);
-        if (['!', 'test'].includes(binary))
+        if (binary === '!' || binary === 'test')
             return fromArgs(args);
         const fromNodeOptions = node.prefix
             .filter(a => a.name === 'NODE_OPTIONS' && a.value)

package/dist/binaries/create-script-parser-context.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigurationChief } from '../ConfigurationChief.ts';
+import { type Manifest } from '../util/package-json.ts';
+export type ScriptParserContext = {
+    rootManifest: Manifest | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
+};
+export declare const createScriptParserContext: (chief: ConfigurationChief) => ScriptParserContext;

package/dist/binaries/create-script-parser-context.js

@@ -0,0 +1,17 @@
+import { createManifest } from '../util/package-json.js';
+export const createScriptParserContext = (chief) => {
+    const rawRootManifest = chief.getManifestForWorkspace('.');
+    const rootManifest = rawRootManifest ? createManifest(rawRootManifest) : undefined;
+    const manifests = new Map();
+    const getManifest = (dir) => {
+        const workspace = chief.findWorkspaceByFilePath(`${dir}/`);
+        if (!workspace)
+            return;
+        if (!manifests.has(workspace.name)) {
+            const manifest = chief.getManifestForWorkspace(workspace.name);
+            manifests.set(workspace.name, manifest ? createManifest(manifest) : undefined);
+        }
+        return manifests.get(workspace.name);
+    };
+    return { rootManifest, getManifest };
+};

package/dist/binaries/resolvers/pnpx.js

@@ -1,17 +1,22 @@
 import parseArgs from '../../util/parse-args.js';
-import { toDependency } from '../../util/input.js';
+import { getCatalogReference } from '../../util/catalog.js';
+import { toCatalog, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
+const toDependencyInputs = (packageSpecifier) => {
+    const dependency = toDependency(stripVersionFromSpecifier(packageSpecifier), { optional: true });
+    const reference = getCatalogReference(packageSpecifier);
+    return reference ? [dependency, toCatalog(reference.packageName, reference.catalogName)] : [dependency];
+};
 export const resolveDlx = (args, options) => {
     const parsed = parseArgs(args, {
         boolean: ['silent'],
         alias: { package: 'p', 'shell-mode': 'c' },
     });
     const packageSpecifier = parsed._[0];
-    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
-    const packages = parsed.package && !parsed.yes ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    const packages = parsed.package && !parsed.yes ? [parsed.package].flat() : [];
     const command = parsed['shell-mode'] ? options.fromArgs([parsed['shell-mode']]) : [];
-    const dependency = specifier ? [toDependency(specifier, { optional: true })] : [];
-    return [...dependency, ...packages.map(id => toDependency(id, { optional: true })), ...command];
+    const dependencyInputs = packageSpecifier ? toDependencyInputs(packageSpecifier) : [];
+    return [...dependencyInputs, ...packages.flatMap(toDependencyInputs), ...command];
 };
 export const resolve = (_binary, args, options) => {
     return resolveDlx(args, options);

package/dist/compilers/index.d.ts

@@ -894,7 +894,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         project?: string | string[] | undefined;
     } | undefined;
     $schema?: string | undefined;
-    rules?: Partial<Record<"binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved", "error" | "off" | "warn">> | undefined;
+    rules?: Partial<Record<"binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved", "error" | "off" | "warn">> | undefined;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
@@ -905,7 +905,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreUnresolved?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-    ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+    ignoreIssues?: Record<string, ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
     cycles?: {
         allow?: string[][] | undefined;
         dynamicImports?: boolean | undefined;
@@ -916,8 +916,8 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     tags?: string[] | undefined;
     treatConfigHintsAsErrors?: boolean | undefined;
     treatTagHintsAsErrors?: boolean | undefined;
-    include?: ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
-    exclude?: ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
+    include?: ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
+    exclude?: ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
     workspaces?: Record<string, {
         angular?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -1819,7 +1819,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-        ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+        ignoreIssues?: Record<string, ("binaries" | "catalog" | "catalogReferences" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     }> | undefined;
     syncCompilers: Record<string, true | CompilerSync>;

package/dist/compilers/scss.js

@@ -1,6 +1,26 @@
-import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+import { ensureRelative, isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['sass', 'sass-embedded', 'node-sass'];
-const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
+const dependencyMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*(?:[\r\n]|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]|url\(\s*(?:["']([^"']*)["']|([^'")\s]+))\s*\)/g;
+const urlSchemeMatcher = /^[a-z][a-z\d+.-]*:/i;
+const getUrlSpecifier = (url) => {
+    if (!url ||
+        url.startsWith('//') ||
+        url.startsWith('/') ||
+        url.startsWith('#') ||
+        urlSchemeMatcher.test(url) ||
+        url.includes('$') ||
+        url.includes('#{'))
+        return;
+    let end = url.length;
+    const queryIndex = url.indexOf('?');
+    if (queryIndex !== -1)
+        end = queryIndex;
+    const fragmentIndex = url.indexOf('#');
+    if (fragmentIndex !== -1 && fragmentIndex < end)
+        end = fragmentIndex;
+    const path = url.slice(0, end);
+    return path ? ensureRelative(path) : undefined;
+};
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');
@@ -14,13 +34,20 @@ const candidates = (specifier) => {
     return out;
 };
 export const compiler = text => {
-    if (!text.includes('@use') && !text.includes('@import') && !text.includes('@forward'))
+    if (!text.includes('@use') && !text.includes('@import') && !text.includes('@forward') && !text.includes('url('))
         return '';
     const out = [];
     let i = 0;
     let match;
-    importMatcher.lastIndex = 0;
-    while ((match = importMatcher.exec(text))) {
+    dependencyMatcher.lastIndex = 0;
+    while ((match = dependencyMatcher.exec(text))) {
+        const url = match[3] ?? match[4];
+        if (url !== undefined) {
+            const spec = getUrlSpecifier(url);
+            if (spec)
+                out.push(`import _$${i++} from '${spec}';`);
+            continue;
+        }
         let spec = match[2];
         if (!spec || spec.startsWith('sass:'))
             continue;

package/dist/compilers/shared.d.ts

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

package/dist/compilers/shared.js

@@ -2,7 +2,7 @@ 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 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/svelte.d.ts

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

package/dist/compilers/svelte.js

@@ -0,0 +1,22 @@
+import { scriptExtractor, styleExtractor } from './compilers.js';
+const htmlCommentMatcher = /<!--[\s\S]*?-->/g;
+const dynamicImportMatcher = /(?<![.\w$#])import(?:\s|\/\/[^\r\n\u2028\u2029]*(?:[\r\n\u2028\u2029]|$)|\/\*[\s\S]*?(?:\*\/|$))*\((?:\s|\/\/[^\r\n\u2028\u2029]*(?:[\r\n\u2028\u2029]|$)|\/\*[\s\S]*?(?:\*\/|$))*(?:"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|`(?:\\[\s\S]|[^`\\$]|\$(?!\{))*`)[^)]*\)/g;
+const svelteExpressionMatcher = /{(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*}/g;
+const javascriptNonCodeMatcher = /"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|`(?:\\[\s\S]|[^`\\$]|\$(?!\{))*`|\/\/[^\r\n\u2028\u2029]*|\/\*[\s\S]*?(?:\*\/|$)/g;
+export const dynamicImportsWithinTemplate = text => {
+    const template = text.replace(scriptExtractor, '').replace(styleExtractor, '').replace(htmlCommentMatcher, '');
+    if (!template.includes('import'))
+        return '';
+    const imports = [];
+    for (const expressionMatch of template.matchAll(svelteExpressionMatcher)) {
+        const expression = expressionMatch[0];
+        const code = expression.replace(javascriptNonCodeMatcher, match => ' '.repeat(match.length));
+        dynamicImportMatcher.lastIndex = 0;
+        let importMatch;
+        while ((importMatch = dynamicImportMatcher.exec(expression))) {
+            if (code.startsWith('import', importMatch.index))
+                imports.push(importMatch[0]);
+        }
+    }
+    return imports.join(';\n');
+};