knip 6.15.0 → 6.16.1

package/dist/ConfigurationChief.d.ts

@@ -112,6 +112,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        catalyst?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         changelogen?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -212,6 +217,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fast?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -287,6 +297,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        lit?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'lockfile-lint'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -826,6 +841,7 @@ export declare class ConfigurationChief {
         ignoreDependencies?: (string | RegExp)[] | undefined;
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
+        ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
         includeEntryExports?: boolean | undefined;
     };
     getIgnores(workspaceName: string): {
@@ -839,6 +855,7 @@ export declare class ConfigurationChief {
         paths: Record<string, string[]>;
         ignore: string[];
         ignoreFiles: string[];
+        ignoreExportsUsedInFile: Record<string, boolean | undefined> | import("./types/config.ts").IgnoreExportsUsedInFile;
         isIncludeEntryExports: boolean;
         angular?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         astro?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -851,6 +868,7 @@ export declare class ConfigurationChief {
         bun?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         c8?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         capacitor?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        catalyst?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         changelogen?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         changelogithub?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         changesets?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -871,6 +889,7 @@ export declare class ConfigurationChief {
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-actions"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -886,6 +905,7 @@ export declare class ConfigurationChief {
         lefthook?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lint-staged"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         linthtml?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        lit?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lockfile-lint"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lost-pixel"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         markdownlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -332,6 +332,7 @@ export class ConfigurationChief {
         const paths = workspaceConfig.paths ?? {};
         const ignore = arrayify(workspaceConfig.ignore);
         const ignoreFiles = arrayify(workspaceConfig.ignoreFiles);
+        const ignoreExportsUsedInFile = workspaceConfig.ignoreExportsUsedInFile ?? this.config.ignoreExportsUsedInFile;
         const isIncludeEntryExports = workspaceConfig.includeEntryExports ?? this.config.isIncludeEntryExports;
         const plugins = {};
         for (const [pluginName, pluginConfig] of Object.entries(this.config.rootPluginConfigs)) {
@@ -343,7 +344,7 @@ export class ConfigurationChief {
                 plugins[pluginName] = normalizePluginConfig(pluginConfig);
             }
         }
-        return { entry, project, paths, ignore, ignoreFiles, isIncludeEntryExports, ...plugins };
+        return { entry, project, paths, ignore, ignoreFiles, ignoreExportsUsedInFile, isIncludeEntryExports, ...plugins };
     }
     findWorkspaceByFilePath(filePath) {
         if (this.workspaceByFileCache.has(filePath))

package/dist/ProjectPrincipal.d.ts

@@ -15,9 +15,11 @@ export declare class ProjectPrincipal {
     pluginCtx: PluginVisitorContext;
     pluginVisitorObjects: PluginVisitorObject[];
     private _visitor;
+    private _localRefsVisitor;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     private paths;
+    private rootDirs;
     private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
@@ -29,7 +31,8 @@ export declare class ProjectPrincipal {
     private onPathAdded;
     constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
-    addPaths(paths: Paths, basePath: string): void;
+    addPaths(paths: Paths, basePath: string, scope: string): void;
+    addRootDirs(rootDirs: string[] | undefined, scope: string): void;
     init(): void;
     readFile(filePath: string): string;
     private hasAcceptedExtension;

package/dist/ProjectPrincipal.js

@@ -21,12 +21,15 @@ export class ProjectPrincipal {
         sourceText: '',
         addScript: () => { },
         addImport: () => { },
+        markExportRegistered: () => { },
     };
     pluginVisitorObjects = [];
     _visitor;
+    _localRefsVisitor;
     syncCompilers = new Map();
     asyncCompilers = new Map();
-    paths = {};
+    paths = new Map();
+    rootDirs = new Map();
     extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
@@ -60,18 +63,21 @@ export class ProjectPrincipal {
             }
         }
     }
-    addPaths(paths, basePath) {
+    addPaths(paths, basePath, scope) {
         if (!paths)
             return;
+        const scoped = this.paths.get(scope) ?? {};
         for (const key in paths) {
             const prefixes = paths[key].map(prefix => toAbsolute(prefix, basePath));
-            if (key in this.paths) {
-                this.paths[key] = compact([...this.paths[key], ...prefixes]);
-            }
-            else {
-                this.paths[key] = prefixes;
-            }
+            scoped[key] = key in scoped ? compact([...scoped[key], ...prefixes]) : prefixes;
         }
+        this.paths.set(scope, scoped);
+    }
+    addRootDirs(rootDirs, scope) {
+        if (!rootDirs?.length)
+            return;
+        const scoped = this.rootDirs.get(scope) ?? [];
+        this.rootDirs.set(scope, compact([...scoped, ...rootDirs]));
     }
     init() {
         this.extensions = new Set([
@@ -79,8 +85,9 @@ export class ProjectPrincipal {
             ...getCompilerExtensions([this.syncCompilers, this.asyncCompilers]),
         ]);
         const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
-        const pathsOrUndefined = Object.keys(this.paths).length > 0 ? this.paths : undefined;
-        this.resolveModule = createCustomModuleResolver({ paths: pathsOrUndefined }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
+        const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
+        const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
+        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
     }
     readFile(filePath) {
         return this.fileManager.readFile(filePath);
@@ -215,9 +222,10 @@ export class ProjectPrincipal {
                 options = { ...options, isFixExports: false, isFixTypes: false };
             }
         }
-        if (!this._visitor)
-            this._visitor = buildVisitor(this.pluginVisitorObjects, !!ignoreExportsUsedInFile);
-        return _getImportsAndExports(filePath, sourceText, this.resolveModule, options, ignoreExportsUsedInFile, skipExports, this._visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
+        const visitor = ignoreExportsUsedInFile
+            ? (this._localRefsVisitor ??= buildVisitor(this.pluginVisitorObjects, true))
+            : (this._visitor ??= buildVisitor(this.pluginVisitorObjects, false));
+        return _getImportsAndExports(filePath, sourceText, this.resolveModule, options, ignoreExportsUsedInFile, skipExports, visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
     }
     invalidateFile(filePath) {
         this.fileManager.invalidate(filePath);

package/dist/binaries/fallback.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../util/parse-args.js';
 import { compact } from '../util/array.js';
 import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
 import { isValidBinary } from '../util/modules.js';

package/dist/binaries/plugins.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../util/parse-args.js';
 import { pluginArgsMap } from '../plugins.js';
 import { compact } from '../util/array.js';
 import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';

package/dist/binaries/resolvers/bun.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+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';

package/dist/binaries/resolvers/bunx.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';

package/dist/binaries/resolvers/npm.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 export const resolve = (_binary, args, options) => {
     const { fromArgs, manifest } = options;
     const parsed = parseArgs(args, { '--': true });

package/dist/binaries/resolvers/npx.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';

package/dist/binaries/resolvers/pnpm.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary } from '../../util/input.js';
 import { isValidBinary } from '../../util/modules.js';
 import { resolveDlx } from './pnpx.js';

package/dist/binaries/resolvers/pnpx.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 export const resolveDlx = (args, options) => {

package/dist/binaries/resolvers/yarn.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';

package/dist/binaries/util.d.ts

@@ -1,3 +1,2 @@
-import parseArgs from 'minimist';
 export declare const argsFrom: (args: string[], from: string) => string[];
-export declare const parseNodeArgs: (args: string[]) => parseArgs.ParsedArgs;
+export declare const parseNodeArgs: (args: string[]) => import("../util/parse-args.ts").ParsedArgs;

package/dist/binaries/util.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../util/parse-args.js';
 export const argsFrom = (args, from) => args.slice(args.indexOf(from));
 export const parseNodeArgs = (args) => parseArgs(args, {
     string: ['r'],

package/dist/compilers/index.d.ts

@@ -58,6 +58,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    catalyst?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     changelogen?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -158,6 +163,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    fast?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     gatsby?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -233,6 +243,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    lit?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     'lockfile-lint'?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -840,6 +855,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        catalyst?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         changelogen?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -940,6 +960,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fast?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1015,6 +1040,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        lit?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'lockfile-lint'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1554,6 +1584,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignoreDependencies?: (string | RegExp)[] | undefined;
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
+        ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
         includeEntryExports?: boolean | undefined;
     }> | undefined;
     syncCompilers: Record<string, true | CompilerSync>;

package/dist/graph/analyze.js

@@ -11,8 +11,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
     const explorer = createGraphExplorer(graph, entryPaths);
-    const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
-    const isReferencedInUsedExport = (exportedItem, filePath, includeEntryExports, visited) => {
+    const isReferencedInUsedExport = (exportedItem, filePath, includeEntryExports, ignoreExportsUsedInFile, visited) => {
         if (!exportedItem.referencedIn)
             return false;
         const file = graph.get(filePath);
@@ -26,7 +25,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 !shouldCountRefs(ignoreExportsUsedInFile, inExport.type)) {
                 continue;
             }
-            if (inExport.hasRefsInFile)
+            if (inExport.hasRefsInFile || inExport.isRegistered)
                 return true;
             if (explorer.isReferenced(filePath, containingExport, { traverseEntries: includeEntryExports })[0])
                 return true;
@@ -34,7 +33,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 const v = visited ?? new Set();
                 if (!v.has(containingExport)) {
                     v.add(containingExport);
-                    if (isReferencedInUsedExport(inExport, filePath, includeEntryExports, v))
+                    if (isReferencedInUsedExport(inExport, filePath, includeEntryExports, ignoreExportsUsedInFile, v))
                         return true;
                 }
             }
@@ -50,7 +49,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     continue;
                 const workspace = chief.findWorkspaceByFilePath(filePath);
                 if (workspace) {
-                    const { isIncludeEntryExports } = workspace.config;
+                    const { isIncludeEntryExports, ignoreExportsUsedInFile } = workspace.config;
                     const isEntry = entryPaths.has(filePath);
                     if (!isIncludeEntryExports && isEntry) {
                         continue;
@@ -66,7 +65,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 traverseEntries: isIncludeEntryExports,
                             });
                             if (isIgnored &&
-                                (isReferenced || isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports))) {
+                                (isReferenced ||
+                                    isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports, ignoreExportsUsedInFile))) {
                                 for (const tagName of exportedItem.jsDocTags) {
                                     if (options.tags[1].includes(tagName) || (isInternalProd && tagName === INTERNAL_TAG)) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
@@ -140,7 +140,8 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
                         if (isIgnored ||
                             exportedItem.hasRefsInFile ||
-                            isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports) ||
+                            exportedItem.isRegistered ||
+                            isReferencedInUsedExport(exportedItem, filePath, isIncludeEntryExports, ignoreExportsUsedInFile) ||
                             (hasStrictlyNsRefs &&
                                 ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))) {
                             continue;

package/dist/graph/build.js

@@ -128,7 +128,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         }
         for (const dep of getManifestImportDependencies(manifest))
             deputy.addReferencedDependency(name, dep);
-        principal.addPaths(config.paths, dir);
+        principal.addPaths(config.paths, dir, dir);
+        principal.addRootDirs(compilerOptions.rootDirs, dir);
         const inputsFromPlugins = await worker.runPlugins();
         for (const id of inputsFromPlugins)
             inputs.add(Object.assign(id, { skipExportsAnalysis: !id.allowIncludeExports }));
@@ -168,7 +169,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 projectFilePatterns.add(toWorkspaceRelative(specifier));
             }
             else if (isAlias(input)) {
-                principal.addPaths({ [input.specifier]: input.prefixes }, input.dir ?? dir);
+                principal.addPaths({ [input.specifier]: input.prefixes }, input.dir ?? dir, dir);
             }
             else if (isIgnore(input)) {
                 if (input.issueType === 'dependencies' || input.issueType === 'unlisted') {
@@ -302,7 +303,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const file = pp.analyzeSourceFile(filePath, analyzeOpts, chief.config.ignoreExportsUsedInFile, parseResult, sourceText, cachedFile);
+            const file = pp.analyzeSourceFile(filePath, analyzeOpts, workspace.config.ignoreExportsUsedInFile, parseResult, sourceText, cachedFile);
             const unresolvedImports = new Set();
             for (const unresolvedImport of file.imports.unresolved) {
                 const { specifier } = unresolvedImport;

package/dist/plugins/_custom-elements/custom-element-visitor.d.ts

@@ -0,0 +1,7 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../types/config.ts';
+interface CustomElementVisitorOptions {
+    decoratorName?: string;
+    baseClassName?: string;
+}
+export declare function createCustomElementVisitor(ctx: PluginVisitorContext, isRegistrationSpecifier: (specifier: string) => boolean, { decoratorName, baseClassName }?: CustomElementVisitorOptions): PluginVisitorObject;
+export {};

package/dist/plugins/_custom-elements/custom-element-visitor.js

@@ -0,0 +1,106 @@
+function isCustomElementDecorated(node, names, namespaces, decoratorName) {
+    const decorators = node.decorators;
+    if (!decorators || decorators.length === 0)
+        return false;
+    for (const decorator of decorators) {
+        const expression = decorator.expression;
+        if (expression?.type === 'Identifier') {
+            if (names.has(expression.name))
+                return true;
+            continue;
+        }
+        if (expression?.type !== 'CallExpression')
+            continue;
+        const callee = expression.callee;
+        if (callee.type === 'Identifier') {
+            if (names.has(callee.name))
+                return true;
+        }
+        else if (callee.type === 'MemberExpression' &&
+            !callee.computed &&
+            callee.object.type === 'Identifier' &&
+            callee.property.type === 'Identifier' &&
+            callee.property.name === decoratorName &&
+            namespaces.has(callee.object.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function extendsBaseClass(node, baseNames) {
+    const superClass = node.superClass;
+    if (!superClass)
+        return false;
+    if (superClass.type === 'Identifier')
+        return baseNames.has(superClass.name);
+    if (superClass.type === 'CallExpression') {
+        for (const arg of superClass.arguments) {
+            if (arg.type === 'Identifier' && baseNames.has(arg.name))
+                return true;
+        }
+    }
+    return false;
+}
+export function createCustomElementVisitor(ctx, isRegistrationSpecifier, { decoratorName = 'customElement', baseClassName } = {}) {
+    const decoratorNames = new Set();
+    const namespaces = new Set();
+    const baseNames = new Set();
+    const definedClasses = new Set();
+    let depth = 0;
+    const visitor = {
+        Program() {
+            decoratorNames.clear();
+            namespaces.clear();
+            baseNames.clear();
+            definedClasses.clear();
+            depth = 0;
+        },
+        BlockStatement() {
+            depth++;
+        },
+        'BlockStatement:exit'() {
+            depth--;
+        },
+        ImportDeclaration(node) {
+            if (!node.source || !isRegistrationSpecifier(node.source.value))
+                return;
+            for (const spec of node.specifiers ?? []) {
+                if (spec.type === 'ImportSpecifier' && spec.imported.type === 'Identifier') {
+                    if (spec.imported.name === decoratorName)
+                        decoratorNames.add(spec.local.name);
+                    else if (baseClassName && spec.imported.name === baseClassName)
+                        baseNames.add(spec.local.name);
+                }
+                else if (spec.type === 'ImportNamespaceSpecifier') {
+                    namespaces.add(spec.local.name);
+                }
+            }
+        },
+        ClassDeclaration(node) {
+            if (depth !== 0 || !node.id?.name)
+                return;
+            if (isCustomElementDecorated(node, decoratorNames, namespaces, decoratorName))
+                ctx.markExportRegistered(node.id.name);
+            else if (baseClassName && extendsBaseClass(node, baseNames))
+                definedClasses.add(node.id.name);
+        },
+        ExportDefaultDeclaration(node) {
+            if (node.declaration.type === 'ClassDeclaration' &&
+                isCustomElementDecorated(node.declaration, decoratorNames, namespaces, decoratorName))
+                ctx.markExportRegistered('default');
+        },
+    };
+    if (baseClassName) {
+        visitor.CallExpression = node => {
+            const callee = node.callee;
+            if (callee.type === 'MemberExpression' &&
+                !callee.computed &&
+                callee.object.type === 'Identifier' &&
+                callee.property.type === 'Identifier' &&
+                (callee.property.name === 'define' || callee.property.name === 'defineAsync') &&
+                definedClasses.has(callee.object.name))
+                ctx.markExportRegistered(callee.object.name);
+        };
+    }
+    return visitor;
+}

package/dist/plugins/bun/index.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toDeferResolve, toEntry } from '../../util/input.js';
 const title = 'Bun';
 const enablers = ['bun'];

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

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

package/dist/plugins/catalyst/index.js

@@ -0,0 +1,16 @@
+import { hasDependency } from '../../util/plugin.js';
+import { createCustomElementVisitor } from '../_custom-elements/custom-element-visitor.js';
+const title = 'Catalyst';
+const enablers = ['@github/catalyst'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const isCatalystSpecifier = (specifier) => specifier === '@github/catalyst';
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createCustomElementVisitor(ctx, isCatalystSpecifier, { decoratorName: 'controller' }));
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    registerVisitors,
+};
+export default plugin;

package/dist/plugins/execa/visitors/execa.js

@@ -1,4 +1,4 @@
-import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { getSafeScriptFromArgs, getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 const tags = new Set(['$', '$sync']);
 const methods = new Set(['execa', 'execaSync', 'execaCommand', 'execaCommandSync', '$sync']);
 export function createExecaVisitor(ctx) {
@@ -29,22 +29,9 @@ export function createExecaVisitor(ctx) {
                 }
             }
             else {
-                const executable = node.arguments[0];
-                if (executable && isStringLiteral(executable)) {
-                    const executableStr = getStringValue(executable);
-                    const args = node.arguments[1];
-                    if (args?.type === 'ArrayExpression') {
-                        const argStrings = [];
-                        for (const a of args.elements) {
-                            if (a && isStringLiteral(a))
-                                argStrings.push(getStringValue(a));
-                        }
-                        ctx.addScript([executableStr, ...argStrings].join(' '));
-                    }
-                    else {
-                        ctx.addScript(executableStr);
-                    }
-                }
+                const script = getSafeScriptFromArgs(node.arguments[0], node.arguments[1]);
+                if (script)
+                    ctx.addScript(script);
             }
         },
     };

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

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

package/dist/plugins/fast/index.js

@@ -0,0 +1,16 @@
+import { hasDependency } from '../../util/plugin.js';
+import { createCustomElementVisitor } from '../_custom-elements/custom-element-visitor.js';
+const title = 'FAST';
+const enablers = ['@microsoft/fast-element'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const isFastSpecifier = (specifier) => specifier === '@microsoft/fast-element';
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createCustomElementVisitor(ctx, isFastSpecifier, { baseClassName: 'FASTElement' }));
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    registerVisitors,
+};
+export default plugin;