knip 6.29.0 → 6.31.0

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');
+};

package/dist/constants.d.ts

@@ -16,7 +16,7 @@ export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: Set<string>;
-export declare const ISSUE_TYPES: readonly ['files', 'dependencies', 'devDependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved', 'exports', 'nsExports', 'types', 'nsTypes', 'enumMembers', 'namespaceMembers', 'duplicates', 'catalog', 'cycles'];
+export declare const ISSUE_TYPES: readonly ['files', 'dependencies', 'devDependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved', 'exports', 'nsExports', 'types', 'nsTypes', 'enumMembers', 'namespaceMembers', 'duplicates', 'catalog', 'catalogReferences', 'cycles'];
 export declare const ISSUE_TYPE_TITLE: {
     readonly files: 'Unused files';
     readonly dependencies: 'Unused dependencies';
@@ -33,6 +33,7 @@ export declare const ISSUE_TYPE_TITLE: {
     readonly namespaceMembers: 'Unused exported namespace members';
     readonly duplicates: 'Duplicate exports';
     readonly catalog: 'Unused catalog entries';
+    readonly catalogReferences: 'Unresolved catalog references';
     readonly cycles: 'Circular dependencies';
 };
 export declare const SYMBOL_TYPE: {
@@ -54,6 +55,7 @@ export declare const FIX_FLAGS: {
 };
 export declare const SIDE_EFFECTS = "__side-effects";
 export declare const OPAQUE = "__opaque";
+export declare const LOADER_DEFAULT = "__loader-default";
 export declare const SCRIPT_INTERPOLATION = "$__knip__";
 export declare const IMPORT_FLAGS: {
     readonly NONE: 0;
@@ -66,4 +68,5 @@ export declare const IMPORT_FLAGS: {
     readonly OPAQUE: number;
     readonly AUGMENT: number;
     readonly DYNAMIC: number;
+    readonly LOADER: number;
 };

package/dist/constants.js

@@ -219,6 +219,7 @@ export const ISSUE_TYPES = [
     'namespaceMembers',
     'duplicates',
     'catalog',
+    'catalogReferences',
     'cycles',
 ];
 export const ISSUE_TYPE_TITLE = {
@@ -237,6 +238,7 @@ export const ISSUE_TYPE_TITLE = {
     namespaceMembers: 'Unused exported namespace members',
     duplicates: 'Duplicate exports',
     catalog: 'Unused catalog entries',
+    catalogReferences: 'Unresolved catalog references',
     cycles: 'Circular dependencies',
 };
 export const SYMBOL_TYPE = {
@@ -258,6 +260,7 @@ export const FIX_FLAGS = {
 };
 export const SIDE_EFFECTS = '__side-effects';
 export const OPAQUE = '__opaque';
+export const LOADER_DEFAULT = '__loader-default';
 export const SCRIPT_INTERPOLATION = '$__knip__';
 export const IMPORT_FLAGS = {
     NONE: 0,
@@ -270,4 +273,5 @@ export const IMPORT_FLAGS = {
     OPAQUE: 1 << 6,
     AUGMENT: 1 << 7,
     DYNAMIC: 1 << 8,
+    LOADER: 1 << 9,
 };

package/dist/graph/analyze.js

@@ -154,7 +154,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             }
                         }
                         const [hasStrictlyNsRefs, namespace] = explorer.hasStrictlyNsReferences(filePath, identifier);
-                        const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
+                        const isType = exportedItem.type === 'enum' || exportedItem.type === 'type' || exportedItem.type === 'interface';
                         if (isIgnored ||
                             exportedItem.hasRefsInFile ||
                             exportedItem.isRegistered ||
@@ -195,7 +195,10 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     for (const extImport of file.imports.external) {
                         const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
                         const isHandled = packageName &&
-                            deputy.maybeAddReferencedExternalDependency(ws, packageName, undefined, extImport.isTypeOnly, extImport.filePath !== undefined);
+                            deputy.maybeAddReferencedExternalDependency(ws, packageName, {
+                                isTypeOnly: extImport.isTypeOnly,
+                                isResolved: extImport.filePath !== undefined,
+                            });
                         if (!isHandled)
                             collector.addIssue({
                                 type: 'unlisted',

package/dist/graph/build.d.ts

@@ -1,3 +1,4 @@
+import type { ScriptParserContext } from '../binaries/create-script-parser-context.ts';
 import type { CatalogCounselor } from '../CatalogCounselor.ts';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
 import type { ConsoleStreamer } from '../ConsoleStreamer.ts';
@@ -13,11 +14,12 @@ interface BuildOptions {
     deputy: DependencyDeputy;
     principal: ProjectPrincipal;
     isGitIgnored: (path: string) => boolean;
+    scriptParserContext: ScriptParserContext;
     streamer: ConsoleStreamer;
     workspaces: Workspace[];
     options: MainOptions;
 }
-export declare function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }: BuildOptions): Promise<{
+export declare function build({ chief, collector, counselor, deputy, principal, isGitIgnored, scriptParserContext, streamer, workspaces, options, }: BuildOptions): Promise<{
     graph: ModuleGraph;
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;

package/dist/graph/build.js

@@ -9,9 +9,10 @@ import picomatch from 'picomatch';
 import { tryRealpath } from '../util/fs.js';
 import { createManifest } from '../util/package-json.js';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
-import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { isAlias, isCatalog, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { isAmbientDeclarationFile } from '../typescript/ast-nodes.js';
 import { resolveImportGlobs } from '../typescript/glob-imports.js';
+import { createPublishedTypeDependencyAnalyzer } from '../typescript/get-published-type-dependencies.js';
 import { loadTSConfig } from '../util/load-tsconfig.js';
 import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
@@ -21,7 +22,7 @@ import { dirname, extname, isAbsolute, isInNodeModules, join, relative } from '.
 import { extensionAlias } from '../util/resolve.js';
 import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
-export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }) {
+export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, scriptParserContext, streamer, workspaces, options, }) {
     const configFilesMap = new Map();
     const enabledPluginsStore = new Map();
     const registeredVisitorPlugins = new Set();
@@ -29,19 +30,10 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
     const externalRefsFromInputs = options.isSession ? new Map() : undefined;
     const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
-    const rawRootManifest = chief.getManifestForWorkspace('.');
-    const rootManifest = rawRootManifest ? createManifest(rawRootManifest) : undefined;
-    const manifestsByWorkspaceName = new Map();
-    const getManifest = (dir) => {
-        const workspace = chief.findWorkspaceByFilePath(`${dir}/`);
-        if (!workspace)
-            return undefined;
-        if (!manifestsByWorkspaceName.has(workspace.name)) {
-            const raw = chief.getManifestForWorkspace(workspace.name);
-            manifestsByWorkspaceName.set(workspace.name, raw ? createManifest(raw) : undefined);
-        }
-        return manifestsByWorkspaceName.get(workspace.name);
-    };
+    const getPublishedTypeDependencies = options.isReportDependencies
+        ? createPublishedTypeDependencyAnalyzer()
+        : undefined;
+    const { rootManifest, getManifest } = scriptParserContext;
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
@@ -56,7 +48,6 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             manifest,
             ...chief.getIgnores(name),
         });
-        counselor.addWorkspace(manifest);
     }
     deputy.setWorkspacePkgNames(chief.availableWorkspacePkgNames);
     collector.addIgnorePatterns(chief.config.ignore.map(id => ({ pattern: prependDir(options.cwd, id), id })));
@@ -65,13 +56,12 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         principal.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
     }
     for (const workspace of workspaces) {
-        const { name, dir, ancestors, manifestPath: filePath } = workspace;
+        const { name, dir, ancestors, config: baseConfig, manifestPath: filePath } = workspace;
         streamer.cast('Analyzing workspace', name);
         const manifest = chief.getManifestForWorkspace(name);
         if (!manifest)
             continue;
         const dependencies = deputy.getDependencies(name);
-        const baseConfig = chief.getConfigForWorkspace(name);
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
         const { isFile, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths: tsConfigPaths, } = await loadTSConfig(tsConfigFilePath);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
@@ -124,6 +114,28 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             if (!isGitIgnored(filePath))
                 inputs.add(toProductionEntry(filePath));
         }
+        if (getPublishedTypeDependencies && !manifest.private && !manifest.publishConfig?.directory) {
+            for (const dependency of getPublishedTypeDependencies(workspace, manifest)) {
+                const isHandled = deputy.maybeAddReferencedExternalDependency(workspace, dependency.packageName, {
+                    isTypeOnly: true,
+                    isResolved: dependency.isResolved,
+                    isPublishedType: true,
+                });
+                if (!isHandled) {
+                    addIssue({
+                        type: 'unlisted',
+                        filePath: dependency.containingFilePath,
+                        workspace: name,
+                        symbol: dependency.packageName,
+                        specifier: dependency.specifier,
+                        pos: dependency.pos,
+                        line: dependency.line,
+                        col: dependency.col,
+                        fixes: [],
+                    });
+                }
+            }
+        }
         for (const identifier of entrySpecifiersFromManifest) {
             if (identifier.startsWith('!') || isGitIgnored(join(dir, identifier)))
                 continue;
@@ -175,7 +187,10 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             if (input.group)
                 groups.add(input.group);
             const specifier = input.specifier;
-            if (isEntry(input)) {
+            if (isCatalog(input)) {
+                counselor.addReference({ catalogName: input.catalogName, packageName: specifier });
+            }
+            else if (isEntry(input)) {
                 const targetMap = input.skipExportsAnalysis ? entryPatternsSkipExports : entryPatterns;
                 addPattern(targetMap, input, toWorkspaceRelative(specifier));
             }
@@ -390,6 +405,10 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 };
                 const inputs = _getInputsFromScripts(file.scripts, opts);
                 for (const input of inputs) {
+                    if (isCatalog(input)) {
+                        counselor.addReference({ catalogName: input.catalogName, packageName: input.specifier });
+                        continue;
+                    }
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
                     const specifierFilePath = handleInput(input, workspace);

package/dist/graph-explorer/operations/build-exports-tree.js

@@ -1,3 +1,4 @@
+import { substringBefore } from '../../util/string.js';
 import { CONTINUE } from '../constants.js';
 import { walkDown } from '../walk-down.js';
 export const buildExportsTree = (graph, entryPaths, options) => {
@@ -38,7 +39,7 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
     walkDown(graph, filePath, identifier, (sourceFile, sourceId, importingFile, id, isEntry, via) => {
         const importMaps = graph.get(importingFile)?.imports.internal.get(sourceFile);
         const importRefs = importMaps?.refs;
-        const ns = id.split('.')[0];
+        const ns = substringBefore(id, '.');
         if (via === 'importNS' && !hasRelevantRef(importRefs, id) && !isNsReExported(importMaps, ns))
             return CONTINUE;
         const key = `${importingFile}:${id}`;

package/dist/graph-explorer/operations/is-referenced.js

@@ -1,4 +1,4 @@
-import { OPAQUE } from '../../constants.js';
+import { LOADER_DEFAULT, OPAQUE } from '../../constants.js';
 import { getAliasReExportMap, getNamespaceReExportSources, getPassThroughReExportSources, getStarReExportSources, } from '../visitors.js';
 const hasOnlyNsRefs = (file) => {
     if (file.importNs.size === 0)
@@ -33,8 +33,9 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
             isReferenced = true;
             return hasCompleteResult();
         }
-        const file = graph.get(path)?.importedBy;
-        if (!identifier || !file) {
+        const node = graph.get(path);
+        const file = node?.importedBy;
+        if (!identifier || !node || !file) {
             return false;
         }
         const follow = (sources, nextId, nextViaStar = viaStar) => {
@@ -45,7 +46,9 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
             return false;
         };
         if (!isReferenced) {
-            const hasDirectReference = (file.import.get(OPAQUE) && !hasOnlyNsRefs(file)) ||
+            const isLoaderImport = file.import.has(LOADER_DEFAULT);
+            const hasDirectReference = ((file.import.get(OPAQUE) || (isLoaderImport && !node.exports.has('default'))) && !hasOnlyNsRefs(file)) ||
+                (isLoaderImport && identifier === 'default') ||
                 ((identifier === id || (identifier !== id && file.refs.has(id))) &&
                     (file.import.has(identifier) || file.importAs.has(identifier)));
             if (hasDirectReference) {

package/dist/graph-explorer/utils.js

@@ -1,4 +1,4 @@
-import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE, SIDE_EFFECTS } from '../constants.js';
+import { IMPORT_FLAGS, IMPORT_STAR, LOADER_DEFAULT, OPAQUE, SIDE_EFFECTS } from '../constants.js';
 import { getCachedExportedIdentifiers, setCachedExportedIdentifiers } from './cache.js';
 import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from './visitors.js';
 const IGNORED_CYCLE_IMPORT_FLAGS = IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.DYNAMIC;
@@ -79,7 +79,7 @@ const getImportKind = (importMaps, identifier, modifiers) => {
         return 'importNS';
     if (identifier && importMaps.importAs.has(identifier))
         return 'importAs';
-    if (identifier === OPAQUE)
+    if (identifier === OPAQUE || identifier === LOADER_DEFAULT)
         return 'dynamicImport';
     if (identifier === SIDE_EFFECTS)
         return 'sideEffectImport';

package/dist/plugins/_template/index.js

@@ -8,7 +8,7 @@ const entry = [];
 const production = [];
 const resolveConfig = async (config) => {
     const inputs = config?.plugins ?? [];
-    return [...inputs].map(id => toDeferResolve(id));
+    return Array.from(inputs, id => toDeferResolve(id));
 };
 const plugin = {
     title,

package/dist/plugins/astro-markdoc/index.js

@@ -1,17 +1,18 @@
 import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { substringBefore } from '../../util/string.js';
 const title = 'Astro Markdoc';
 const enablers = ['@astrojs/markdoc'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['markdoc.config.{js,ts,mjs,mts}'];
 const extractSpecifiers = (renderField) => {
     if (typeof renderField === 'string') {
-        return [renderField.split('#')[0]];
+        return [substringBefore(renderField, '#')];
     }
     if (renderField && typeof renderField === 'object') {
         for (const key of ['Component', 'file', 'path']) {
             if (typeof renderField[key] === 'string') {
-                return [renderField[key].split('#')[0]];
+                return [substringBefore(renderField[key], '#')];
             }
         }
     }

package/dist/plugins/eleventy/index.js

@@ -17,7 +17,7 @@ const resolveConfig = async (localConfig, options) => {
     const inputDir = localConfig?.dir?.input || defaultEleventyConfig.dir.input;
     const dataDir = localConfig?.dir?.data || defaultEleventyConfig.dir.data;
     const templateFormats = localConfig?.templateFormats || defaultEleventyConfig.templateFormats;
-    const exts = [...DEFAULT_EXTENSIONS].map(extname => extname.slice(1)).join(',');
+    const exts = Array.from(DEFAULT_EXTENSIONS, extname => extname.slice(1)).join(',');
     const copiedEntries = new Set();
     const copiedPackages = new Set();
     for (const path of Object.keys(dummyUserConfig.passthroughCopies)) {

package/dist/plugins/esbuild/index.js

@@ -6,7 +6,7 @@ const title = 'esbuild';
 const enablers = ['esbuild'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['esbuild.config.{js,mjs,cjs,ts,mts,cts}', 'esbuild.{js,mjs,cjs,ts,mts,cts}'];
-const resolveFromAST = (program, { configFileDir }) => [...collectPropertyValues(program, 'entryPoints')].map(id => toProductionEntry(join(configFileDir, id)));
+const resolveFromAST = (program, { configFileDir }) => Array.from(collectPropertyValues(program, 'entryPoints'), id => toProductionEntry(join(configFileDir, id)));
 const plugin = {
     title,
     enablers,

package/dist/plugins/eslint/helpers.js

@@ -2,6 +2,7 @@ import { compact } from '../../util/array.js';
 import { toConfig, toDeferResolve, toDependency } from '../../util/input.js';
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../../util/modules.js';
 import { extname, isAbsolute, isInternal } from '../../util/path.js';
+import { substringBefore } from '../../util/string.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 export const isFlatConfig = (fileName) => /eslint\.config/.test(fileName);
 export const getInputs = (config, options) => {
@@ -41,7 +42,7 @@ const resolveSpecifier = (namespace, rawSpecifier) => {
     if (!specifier.startsWith('@')) {
         const id = rawSpecifier.startsWith('plugin:')
             ? getPackageNameFromModuleSpecifier(specifier)
-            : specifier.split('/')[0];
+            : substringBefore(specifier, '/');
         return `${namespace}-${id}`;
     }
     const [scope, name, ...rest] = specifier.split('/');

package/dist/plugins/gatsby/index.js

@@ -14,12 +14,12 @@ const production = [
 ];
 const resolveConfig = async (localConfig, options) => {
     const { configFileName } = options;
-    if (/gatsby-config/.test(configFileName)) {
+    if (configFileName.includes('gatsby-config')) {
         return localConfig.plugins
             .map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve))
             .map(id => toDeferResolve(id));
     }
-    if (/gatsby-node/.test(configFileName)) {
+    if (configFileName.includes('gatsby-node')) {
         const plugins = new Set();
         const actions = { setBabelPlugin: plugin => plugins.add(plugin.name) };
         const _config = localConfig;

package/dist/plugins/index.d.ts

@@ -63,6 +63,7 @@ export declare const Plugins: {
     'lost-pixel': import("../types/config.ts").Plugin;
     lunaria: import("../types/config.ts").Plugin;
     markdownlint: import("../types/config.ts").Plugin;
+    marko: import("../types/config.ts").Plugin;
     mdx: import("../types/config.ts").Plugin;
     mdxlint: import("../types/config.ts").Plugin;
     metro: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -57,6 +57,7 @@ import { default as lockfileLint } from './lockfile-lint/index.js';
 import { default as lostPixel } from './lost-pixel/index.js';
 import { default as lunaria } from './lunaria/index.js';
 import { default as markdownlint } from './markdownlint/index.js';
+import { default as marko } from './marko/index.js';
 import { default as mdx } from './mdx/index.js';
 import { default as mdxlint } from './mdxlint/index.js';
 import { default as metro } from './metro/index.js';
@@ -236,6 +237,7 @@ export const Plugins = {
     'lost-pixel': lostPixel,
     lunaria,
     markdownlint,
+    marko,
     mdx,
     mdxlint,
     metro,

package/dist/plugins/jest/helpers.js

@@ -35,7 +35,7 @@ export const getReportersDependencies = (config, options) => {
     const reporters = config.reporters
         ? config.reporters
             .map(reporter => (typeof reporter === 'string' ? reporter : reporter[0]))
-            .filter(reporter => !['default', 'github-actions', 'summary'].includes(reporter))
+            .filter(reporter => reporter !== 'default' && reporter !== 'github-actions' && reporter !== 'summary')
         : [];
     return [...reporters, ...jUnitReporterDeps];
 };

package/dist/plugins/marko/compiler.d.ts

@@ -0,0 +1,2 @@
+import type { CompilerSync } from '../../compilers/types.ts';
+export declare const createCompiler: (tagDependencies?: Map<string, string[]>, fallbackDependencies?: string[]) => CompilerSync;

package/dist/plugins/marko/compiler.js

@@ -0,0 +1,85 @@
+import { getStyleLang, styleExtractor } from '../../compilers/compilers.js';
+import { compiler as lessCompiler } from '../../compilers/less.js';
+import { compiler as scssCompiler } from '../../compilers/scss.js';
+import { compiler as stylusCompiler } from '../../compilers/stylus.js';
+const commentMatcher = /<!--[\s\S]*?-->|\/\*[\s\S]*?\*\/|^[ \t]*\/\/.*$/gm;
+const conciseStyleMatcher = /^[ \t]*style(?:\.([\w.-]+))?[^\n{]*\{([\s\S]*?)^[ \t]*\}/gm;
+const htmlTagMatcher = /<([a-z][\w.-]*)(?=[\s/|>])/g;
+const conciseTagMatcher = /^[ \t]*([a-z][\w.-]*)(?=[ \t/|]|--|$)/gm;
+const tagImportMatcher = /^[ \t]*(?:(?:server|client|static|\$)[ \t]+)?import[ \t\r\n]+(?:type[ \t\r\n]+)?(?:[$\w]+(?:[ \t\r\n]*,[ \t\r\n]*(?:\*[ \t\r\n]+as[ \t\r\n]+[$\w]+|\{[^}]*\}))?|\*[ \t\r\n]+as[ \t\r\n]+[$\w]+|\{[^}]*\})[ \t\r\n]+from[ \t\r\n]*(["'])<[^"'\r\n]+>\1(?:[ \t\r\n]+with[ \t\r\n]*\{(?:[^}"']+|"[^"]*"|'[^']*')*\})?[ \t]*;?[ \t]*(?:\r?\n|$)/gm;
+const markupLineMatcher = /^[ \t]*<.*$/gm;
+const markoPrefixMatcher = /^([ \t]*)(?:server|client|\$)[ \t]+/gm;
+const staticPrefixMatcher = /^([ \t]*)static[ \t]+(?=(?:import|export|const|let|var|function|class|interface|type|enum|namespace|async[ \t]+function)\b)/gm;
+const staticBlockPrefixMatcher = /^([ \t]*)static[ \t]+(?=\{)/gm;
+const classBodyMatcher = /^([ \t]*)class\b[^{]*\{[\s\S]*?^\1\}/gm;
+const classStaticBlockMatcher = /^([ \t]*)static(?=[ \t]*\{)/gm;
+const classStaticBlockPlaceholder = '__MARKO_CLASS_STATIC_BLOCK__';
+const anonymousClassMatcher = /^([ \t]*)class[ \t]*\{/gm;
+const localExportDeclarationMatcher = /^([ \t]*)export[ \t]+(?:default[ \t]+)?(?=(?:(?:declare|abstract|async)[ \t]+)*(?:interface|type[ \t]+[$\w]+|const|let|var|function|class|enum|namespace)\b)/gm;
+const localExportListMatcher = /^[ \t]*export[ \t]+(?:type[ \t]+)?\{[^}]*\}(?![ \t\r\n]*from\b)[ \t]*;?[ \t]*(?=\r?$)/gm;
+const compileStyle = (body, lang, path) => {
+    switch (lang) {
+        case 'less':
+            return lessCompiler(body, path);
+        case 'styl':
+        case 'stylus':
+            return stylusCompiler(body, path);
+        default:
+            return scssCompiler(body, path);
+    }
+};
+const collectStyles = (text, path) => {
+    const imports = [];
+    styleExtractor.lastIndex = 0;
+    let match;
+    while ((match = styleExtractor.exec(text))) {
+        const lang = getStyleLang(match[1]) ?? match[1].match(/\.([\w-]+)/)?.[1];
+        const output = compileStyle(match[2], lang, path);
+        if (output)
+            imports.push(output);
+    }
+    conciseStyleMatcher.lastIndex = 0;
+    while ((match = conciseStyleMatcher.exec(text))) {
+        const output = compileStyle(match[2], match[1]?.split('.').pop(), path);
+        if (output)
+            imports.push(output);
+    }
+    return imports;
+};
+const sanitize = (text) => {
+    const source = text
+        .replace(styleExtractor, '')
+        .replace(conciseStyleMatcher, '')
+        .replace(tagImportMatcher, '')
+        .replace(markupLineMatcher, '')
+        .replace(markoPrefixMatcher, '$1')
+        .replace(staticPrefixMatcher, '$1')
+        .replace(localExportDeclarationMatcher, '$1')
+        .replace(localExportListMatcher, '');
+    return source
+        .replace(classBodyMatcher, body => body.replace(classStaticBlockMatcher, `$1${classStaticBlockPlaceholder}`))
+        .replace(staticBlockPrefixMatcher, '$1')
+        .replaceAll(classStaticBlockPlaceholder, 'static')
+        .replace(anonymousClassMatcher, '$1class MarkoComponent {');
+};
+const collectTagDependencies = (text, tagDependencies, fallbackDependencies) => {
+    const dependencies = new Set(fallbackDependencies);
+    for (const matcher of [htmlTagMatcher, conciseTagMatcher]) {
+        matcher.lastIndex = 0;
+        let match;
+        while ((match = matcher.exec(text))) {
+            for (const dependency of tagDependencies.get(match[1]) ?? [])
+                dependencies.add(dependency);
+        }
+    }
+    return Array.from(dependencies, dependency => `import "${dependency}";`);
+};
+export const createCompiler = (tagDependencies = new Map(), fallbackDependencies = []) => (text, path) => {
+    const source = text.replace(commentMatcher, '');
+    return [
+        'import "marko";',
+        ...collectTagDependencies(source, tagDependencies, fallbackDependencies),
+        ...collectStyles(source, path),
+        sanitize(source),
+    ].join('\n');
+};

package/dist/plugins/marko/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/marko/index.js

@@ -0,0 +1,63 @@
+import { toDeferResolve, toProductionEntry } from '../../util/input.js';
+import { join, relative } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { createCompiler } from './compiler.js';
+import { getTaglibDependencies } from './taglibs.js';
+const title = 'Marko';
+const enablers = ['marko'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['**/marko.json', '**/marko-tag.json'];
+const tagDiscoveryDirs = ['components', 'tags'];
+const scriptExtensions = '{js,jsx,ts,tsx,mjs,cjs,mts,cts}';
+const styleExtensions = '{css,less,scss,sass,styl,stylus}';
+const tagFilePatterns = [
+    '**/*.marko',
+    `**/{component,component-browser}.${scriptExtensions}`,
+    `**/*.{component,component-browser}.${scriptExtensions}`,
+    `**/style.${styleExtensions}`,
+    `**/*.style.${styleExtensions}`,
+];
+const tagProduction = tagFilePatterns.map(pattern => `**/{${tagDiscoveryDirs.join(',')}}/${pattern}`);
+const production = tagProduction;
+const tagDefFields = [
+    'template',
+    'renderer',
+    'parse',
+    'migrate',
+    'transform',
+    'analyze',
+    'translate',
+];
+const resolveConfig = (localConfig, options) => {
+    const { configFileName, configFileDir, cwd } = options;
+    const inputs = [];
+    if (!localConfig)
+        return inputs;
+    if (configFileName === 'marko.json') {
+        const dir = relative(cwd, configFileDir);
+        return tagProduction.map(pattern => toProductionEntry(join(dir, pattern)));
+    }
+    for (const field of tagDefFields) {
+        for (const id of [localConfig[field]].flat()) {
+            if (typeof id === 'string')
+                inputs.push(toDeferResolve(join(configFileDir, id)));
+        }
+    }
+    return inputs;
+};
+const registerCompilers = async ({ cwd, registerCompiler, hasDependency }) => {
+    if (hasDependency('marko')) {
+        const { tagDependencies, fallbackDependencies } = await getTaglibDependencies(cwd);
+        registerCompiler({ extension: '.marko', compiler: createCompiler(tagDependencies, fallbackDependencies) });
+    }
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveConfig,
+    registerCompilers,
+};
+export default plugin;

package/dist/plugins/marko/taglibs.d.ts

@@ -0,0 +1,4 @@
+export declare const getTaglibDependencies: (cwd: string) => Promise<{
+    tagDependencies: Map<string, string[]>;
+    fallbackDependencies: string[];
+}>;