@cplieger/deadset-ts 7.2.0-dev.3 → 7.2.0-dev.4

package/dist/src/version-range.js

@@ -38,10 +38,12 @@ function partialOf(text) {
         parts.push(Number(part));
     }
     const prerelease = prereleaseOf(match[4]);
-    if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+    if (prerelease === undefined) {
         return undefined;
     }
-    return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+    // node-semver drops the prerelease of a version with a wildcard part (`1.2.x-beta` is `1.2.x`):
+    // https://github.com/npm/node-semver/blob/v7.8.5/classes/range.js#L409-L430
+    return { major: parts[0], minor: parts[1], patch: parts[2], prerelease: wild ? [] : prerelease };
 }
 /** One exact version, or `undefined` where the text is not one. */
 function versionOf(text) {
@@ -111,11 +113,14 @@ function passes(version, comparator) {
             return order === 0;
     }
 }
-/** The comparators a version with missing parts stands for: any value of each. */
+/**
+ * The comparators a version with missing parts stands for: any value of each. A wildcard
+ * major is no comparator, so it never refuses a 0.0.0 prerelease another comparator admits.
+ */
 function anyOf(partial) {
     const { major, minor } = partial;
     if (major === undefined) {
-        return [{ operator: ">=", version: exact(0, 0, 0) }];
+        return [];
     }
     if (minor === undefined) {
         return [
@@ -165,7 +170,7 @@ function primitive(operator, partial) {
     if (major === undefined) {
         return operator === "<" || operator === ">"
             ? [{ operator: "<", version: floorOf(0, 0, 0) }]
-            : [{ operator: ">=", version: exact(0, 0, 0) }];
+            : [];
     }
     if (minor !== undefined && patch !== undefined) {
         return [{ operator, version: lowest(partial) }];

package/dist/src/workspace-resolution.js

@@ -19,6 +19,7 @@ const DEPENDENCY_MEMBERS = [
     "optionalDependencies",
 ];
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
+const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -42,9 +43,17 @@ function inside(dir, path) {
 }
 /** The `exports` entry one subpath selects, with what a pattern's `*` matched. */
 function exportsEntry(exportsField, subpath) {
-    const map = isRecord(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."))
-        ? exportsField
-        : { ".": exportsField };
+    const keys = isRecord(exportsField) ? Object.keys(exportsField) : [];
+    const dotted = keys.filter((key) => key.startsWith(".")).length;
+    // An object mixing subpath keys with others is invalid to Node; the compiler still
+    // answers `.` from its `"."` key and no other subpath:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L673-L695
+    if (isRecord(exportsField) && dotted > 0 && dotted < keys.length) {
+        return subpath === "." && Object.hasOwn(exportsField, ".")
+            ? { value: exportsField["."] }
+            : undefined;
+    }
+    const map = isRecord(exportsField) && dotted > 0 ? exportsField : { ".": exportsField };
     if (Object.hasOwn(map, subpath)) {
         return { value: map[subpath] };
     }
@@ -286,6 +295,13 @@ export function workspaceResolver(host, workspace) {
             if (answered !== undefined) {
                 return { kind: "default" };
             }
+            // A stylesheet or another asset is no module with a source, so the import of one
+            // keeps the compiler's resolution.
+            if (targets.some((target) => !SOURCE.test(target) &&
+                !OUTPUT.test(target) &&
+                host.kindOf(joinPath(member.dir, target)) === "file")) {
+                return { kind: "default" };
+            }
             const named = targets.length === 0 ? "no target" : targets.join(", ");
             const built = targets.some((target) => host.kindOf(joinPath(member.dir, target)) === "file");
             return {

package/dist/src/workspace.js

@@ -205,7 +205,7 @@ function memberDirectories(host, root, patterns) {
 /** Whether a workspace's patterns name one directory below its root, read without listing any. */
 function namesDirectory(root, patterns, dir) {
     const below = relativePath(root, dir);
-    if (below === undefined || below.startsWith("..")) {
+    if (below === undefined) {
         return false;
     }
     const path = below.split("/");

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.3",
+  "version": "7.2.0-dev.4",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.3",
+  "version": "7.2.0-dev.4",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/analysis.ts

@@ -80,7 +80,14 @@ import {
   type Matrix,
   type SweepResult,
 } from "./matrix.ts";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
+import {
+  dirnamePath,
+  extensionOf,
+  joinPath,
+  normalizePath,
+  relativePath,
+  resolvePath,
+} from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import { LANGUAGE, type TypeErrorSkip, type UnansweredCount } from "./report.ts";
@@ -232,6 +239,8 @@ interface ReadProjects<Answer> {
   readonly unanswered: readonly UnansweredQuestion[];
   /** Per configuration whose component files the run cannot read, the reason. */
   readonly componentsUnread: readonly ComponentsUnread[];
+  /** Per analyzed configuration, each library it names that the compiler cannot find. */
+  readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
@@ -394,6 +403,7 @@ function readProjects<Answer>(
   const failures: LocatedDiagnostic[] = [];
   const unbuildable: SetupFailure[] = [];
   const setupDropped: SetupFailure[] = [];
+  const librariesUnfound: LibraryUnfound[] = [];
   const consumed = new Map<string, Reference>();
   const heldFiles = new Set<string>();
   let outsideTests: readonly OutsideTest[] = [];
@@ -458,10 +468,6 @@ function readProjects<Answer>(
             : resolvePath(host.workingDirectory(), consumer.path),
         paths: pathsOf(engine, project.configFile),
       });
-      if (reading.failing.length > 0) {
-        failures.push(...reading.failing);
-        return undefined;
-      }
       if (consumer !== undefined && reading.missing.length > 0) {
         unbuildable.push(
           ...reading.missing.map((one) => ({
@@ -502,6 +508,12 @@ function readProjects<Answer>(
         }
         return undefined;
       }
+      librariesUnfound.push(
+        ...raw.unfound.map((one) => ({
+          configFile: project.configFile,
+          error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
+        })),
+      );
       const configuration = ids.get(project.configFile) ?? project.configFile;
       const read = (): ProjectRead => {
         const held = inventory(project, host, targetRoot);
@@ -589,6 +601,7 @@ function readProjects<Answer>(
     notBuilt,
     unanswered: session.unanswered,
     componentsUnread: workspace?.componentsUnread ?? [],
+    librariesUnfound,
     conventionsApplied: conventions.applied,
     conventionUses: conventions.uses,
     memberDirs,
@@ -775,6 +788,8 @@ interface ReadRun<Extra> {
   readonly unanswered: readonly UnansweredQuestion[];
   /** Per configuration whose component files the run cannot read, the reason. */
   readonly componentsUnread: readonly ComponentsUnread[];
+  /** Per analyzed configuration, each library it names that the compiler cannot find. */
+  readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
@@ -842,7 +857,7 @@ function readRun<Extra>(
       evidence,
       componentFiles: components.map(pathOf),
       componentWarnings: components.flatMap((file) =>
-        readComponent(file.originalText).warnings.map((warning) => ({
+        readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
           path: pathOf(file),
           line: lineOf(file.originalText, warning.offset),
           reason: warning.reason,
@@ -942,6 +957,7 @@ function readRun<Extra>(
     notBuilt: read.notBuilt,
     unanswered: read.unanswered,
     componentsUnread: read.componentsUnread,
+    librariesUnfound: read.librariesUnfound,
     conventionsApplied: read.conventionsApplied,
     conventionUses: read.conventionUses,
     memberDirs: read.memberDirs,
@@ -1341,6 +1357,7 @@ function readAnalysis(
       notBuilt: read.notBuilt,
       unanswered: read.unanswered,
       componentsUnread: read.componentsUnread,
+      librariesUnfound: read.librariesUnfound,
       conventionsApplied: read.conventionsApplied,
     },
     configured: read.projects.map((one) => one.configured),
@@ -1418,6 +1435,8 @@ interface RunFacts {
   readonly componentWarnings: readonly ComponentWarning[];
   /** Per configuration whose component files the run cannot read, the reason. */
   readonly componentsUnread: readonly ComponentsUnread[];
+  /** Per analyzed configuration, each library it names that the compiler cannot find. */
+  readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
 }
@@ -1428,6 +1447,13 @@ interface ComponentsUnread {
   readonly reason: string;
 }
 
+/** One library an analyzed configuration names that the compiler cannot find. */
+interface LibraryUnfound {
+  readonly configFile: string;
+  /** The compiler's error, rendered as a dropped configuration's is. */
+  readonly error: string;
+}
+
 /** The findings of one run, beside what a report states about the run itself. */
 export interface RunAnalysis {
   readonly result: PassResult;

package/src/component-files.ts

@@ -188,18 +188,25 @@ function scriptTagAt(text: string, offset: number): boolean {
   );
 }
 
+/** Where the braces opening at one offset end, and whether a `}` matched them. */
+interface Braces {
+  /** Past the matching `}`, or where the scan stopped: a line-start `<script` or the end. */
+  readonly end: number;
+  readonly closed: boolean;
+}
+
 /**
- * The offset past the `}` matching the `{` at `from`, quoted strings skipped, or -1 where
- * none matches before the end or before a `<script` start tag that begins a line, so a
- * stray brace in markup never hides a block.
+ * The braces opening at `from`, quoted strings skipped. The scan stops unclosed at the
+ * end, or before a `<script` start tag that begins a line, so a stray brace in markup
+ * never hides a block.
  */
-function pastBraces(text: string, from: number): number {
+function scanBraces(text: string, from: number): Braces {
   let depth = 0;
   let at = from;
   while (at < text.length) {
     const code = text.charCodeAt(at);
     if (scriptTagAt(text, at)) {
-      return -1;
+      return { end: at, closed: false };
     }
     if (code === 0x22 || code === 0x27 || code === 0x60) {
       at = pastQuoted(text, at);
@@ -210,12 +217,59 @@ function pastBraces(text: string, from: number): number {
     } else if (code === 0x7d) {
       depth -= 1;
       if (depth === 0) {
-        return at + 1;
+        return { end: at + 1, closed: true };
       }
     }
     at += 1;
   }
-  return -1;
+  return { end: text.length, closed: false };
+}
+
+/** The offset past the `}` matching the `{` at `from`, or -1 where {@link scanBraces} finds none. */
+function pastBraces(text: string, from: number): number {
+  const braces = scanBraces(text, from);
+  return braces.closed ? braces.end : -1;
+}
+
+/** How one framework's parser reads the forms the frameworks disagree on. */
+interface Dialect {
+  /** Whether `<!-->`, `<!--->` and `--!>` end a comment, the opening dashes counted. */
+  readonly shortComments: boolean;
+  /** Whether a start tag's unmatched `{` is a character of an attribute name or value. */
+  readonly braceIsText: boolean;
+}
+
+/**
+ * The dialect each framework's parser reads: Vue's tokenizer, Svelte's parser and Astro's
+ * tokenizer, the last for any other extension too. `.vue` also closes `--!>`, which Vue
+ * does not, so a block Vue drops there is still read.
+ * https://github.com/vuejs/core/blob/main/packages/compiler-core/src/tokenizer.ts
+ * https://github.com/sveltejs/svelte/blob/main/packages/svelte/src/compiler/phases/1-parse/state/element.js
+ * https://github.com/withastro/compiler/blob/main/internal/token.go
+ */
+function dialectOf(extension: string): Dialect {
+  switch (extension.toLowerCase()) {
+    case ".svelte":
+      return { shortComments: false, braceIsText: false };
+    case ".vue":
+      return { shortComments: true, braceIsText: true };
+    default:
+      return { shortComments: true, braceIsText: false };
+  }
+}
+
+/** The offset past the comment whose `<!--` is at `lt`, or the text's length where none ends it. */
+function pastComment(text: string, lt: number, dialect: Dialect): number {
+  if (!dialect.shortComments) {
+    const close = text.indexOf("-->", lt + 4);
+    return close < 0 ? text.length : close + 3;
+  }
+  const dashes = text.indexOf("-->", lt + 2);
+  const bang = text.indexOf("--!>", lt + 2);
+  if (bang >= 0 && (dashes < 0 || bang < dashes)) {
+    return bang + 4;
+  }
+  return dashes < 0 ? text.length : dashes + 3;
 }
 
 interface Attribute {
@@ -234,17 +288,43 @@ interface StartTag {
   readonly attributes: readonly Attribute[];
 }
 
-/** The start tag whose `<` is at `from`, to its `>`. A quoted or braced value may hold `>`. */
-function readStartTag(text: string, from: number, nameStop: number): StartTag {
+/**
+ * Where an unmatched `{` of a start tag ends its braced value: at the first `>`, or where
+ * the brace scan stopped where that comes first.
+ */
+function unmatchedBraceEnd(text: string, from: number, braces: Braces): number {
+  const close = text.indexOf(">", from);
+  return close >= 0 && close < braces.end ? close : braces.end;
+}
+
+/**
+ * The start tag whose `<` is at `from`, to its `>`. A quoted or braced value may hold `>`.
+ * Past an unmatched `{`, the tag also ends before a `<script` start tag that begins a line.
+ */
+function readStartTag(text: string, from: number, nameStop: number, dialect: Dialect): StartTag {
   const name = text.slice(from + 1, nameStop).toLowerCase();
   const attributes: Attribute[] = [];
   let at = nameStop;
   let selfClosing = false;
+  let unmatched = false;
+  /** The braces opening at `at`, and whether they make a braced value rather than text. */
+  const bracesAt = (): { readonly braces: Braces; readonly value: boolean } | undefined => {
+    if (text.charCodeAt(at) !== 0x7b) {
+      return undefined;
+    }
+    const braces = scanBraces(text, at);
+    return { braces, value: braces.closed || !dialect.braceIsText };
+  };
+  const bracedEnd = (braces: Braces): number =>
+    braces.closed ? braces.end : unmatchedBraceEnd(text, at, braces);
   while (at < text.length) {
     const code = text.charCodeAt(at);
     if (code === 0x3e) {
       return { name, end: at + 1, selfClosing, attributes };
     }
+    if (unmatched && scriptTagAt(text, at)) {
+      return { name, end: at, selfClosing, attributes };
+    }
     if (isSpace(code)) {
       at += 1;
       continue;
@@ -256,12 +336,13 @@ function readStartTag(text: string, from: number, nameStop: number): StartTag {
     }
     selfClosing = false;
     const start = at;
-    if (code === 0x7b) {
-      const past = pastBraces(text, at);
-      at = past < 0 ? text.length : past;
+    const bare = bracesAt();
+    unmatched ||= bare?.braces.closed === false;
+    if (bare?.value === true) {
+      at = bracedEnd(bare.braces);
       attributes.push({
         name: "",
-        value: text.slice(start + 1, at - 1),
+        value: text.slice(start + 1, bare.braces.closed ? at - 1 : at),
         start,
         end: at,
         valueStart: start + 1,
@@ -287,16 +368,18 @@ function readStartTag(text: string, from: number, nameStop: number): StartTag {
         at += 1;
       }
       const opening = text.charCodeAt(at);
+      const braced = bracesAt();
+      unmatched ||= braced?.braces.closed === false;
       if (opening === 0x22 || opening === 0x27) {
-        const past = pastQuoted(text, at);
+        // An attribute value has no escapes: a backslash before its quote is text.
+        const close = text.indexOf(text.charAt(at), at + 1);
         valueStart = at + 1;
-        value = text.slice(at + 1, Math.max(past - 1, at + 1));
-        at = past;
-      } else if (opening === 0x7b) {
-        const past = pastBraces(text, at);
-        const stop = past < 0 ? text.length : past;
+        value = text.slice(at + 1, close < 0 ? text.length : close);
+        at = close < 0 ? text.length : close + 1;
+      } else if (braced?.value === true) {
+        const stop = bracedEnd(braced.braces);
         valueStart = at + 1;
-        value = text.slice(at + 1, Math.max(stop - 1, at + 1));
+        value = text.slice(at + 1, braced.braces.closed ? stop - 1 : stop);
         at = stop;
       } else {
         valueStart = at;
@@ -410,9 +493,11 @@ function scriptsInside(text: string, from: number, to: number): number[] {
  * The scan keeps a stack of open elements. A comment, a doctype or processing instruction and
  * an expression in braces are text, and an end tag closes back to the nearest open element of
  * its name. A raw-text element at the top level runs to its own end tag, and only a `script`
- * element whose start tag begins a line at the top level is a block.
+ * element whose start tag begins a line at the top level is a block. The file's extension
+ * names the framework whose reading of a comment and of a stray brace applies.
  */
-export function readComponent(text: string): ComponentFile {
+export function readComponent(text: string, extension: string): ComponentFile {
+  const dialect = dialectOf(extension);
   const blocks: Block[] = [];
   const imports: SourceImport[] = [];
   const warnings: ComponentWarning[] = [];
@@ -442,8 +527,7 @@ export function readComponent(text: string): ComponentFile {
     }
     const lt = at;
     if (text.startsWith("<!--", lt)) {
-      const close = text.indexOf("-->", lt + 4);
-      at = close < 0 ? text.length : close + 3;
+      at = pastComment(text, lt, dialect);
       continue;
     }
     const next = text.charCodeAt(lt + 1);
@@ -467,7 +551,7 @@ export function readComponent(text: string): ComponentFile {
       at = lt + 1;
       continue;
     }
-    const tag = readStartTag(text, lt, nameStop);
+    const tag = readStartTag(text, lt, nameStop, dialect);
     const rawText = open.length === 0 && RAW_TEXT.has(tag.name);
     for (const attribute of rawText ? [] : tag.attributes) {
       if (attribute.value !== "") {
@@ -542,9 +626,9 @@ export function readComponent(text: string): ComponentFile {
 }
 
 /**
- * Whether the module's text exports a default at its top level: an `export default`
- * or an export clause naming `default`, outside every comment, string, template and
- * regular expression, and outside every bracket.
+ * Whether the module's text exports a default at its top level: an `export default`, an
+ * `export * as default`, or an export clause naming `default`, outside every comment,
+ * string, template and regular expression, and outside every bracket.
  */
 export function exportsDefault(text: string): boolean {
   const words: string[] = [];
@@ -633,7 +717,8 @@ export function exportsDefault(text: string): boolean {
     const matched = word.exec(text);
     if (matched !== null) {
       const name = matched[0];
-      if (depth === 0 && words.at(-1) === "export" && name === "default") {
+      const starAs = words.at(-3) === "export" && words.at(-2) === "*" && words.at(-1) === "as";
+      if (depth === 0 && (words.at(-1) === "export" || starAs) && name === "default") {
         return true;
       }
       if (clause && name === "default") {
@@ -662,8 +747,8 @@ export function exportsDefault(text: string): boolean {
 }
 
 /** The module one component file's text is read as, and the span map back to the file. */
-export function componentModule(text: string): ComponentModule {
-  const { blocks, imports } = readComponent(text);
+export function componentModule(text: string, fileExtension: string): ComponentModule {
+  const { blocks, imports } = readComponent(text, fileExtension);
   const out: string[] = [];
   let at = 0;
   let language: BlockLanguage | undefined;

package/src/configuration-files.ts

@@ -278,8 +278,15 @@ function readDocument(host: Host, path: string): unknown {
 
 /** The configuration files one project holds and sits beside. */
 interface ConfigurationFiles {
-  /** Every own file that is a configuration module, with the form its name has. */
-  readonly modules: readonly { readonly file: SourceFile; readonly form: string }[];
+  /**
+   * Every own file that is a configuration module, with the form its name has and the
+   * directory of the manifest whose dependencies its strings are read against.
+   */
+  readonly modules: readonly {
+    readonly file: SourceFile;
+    readonly form: string;
+    readonly manifestDir: string;
+  }[];
   /**
    * Every configuration module in a directory of the project that the program does not
    * hold, and every file such a file imports or re-exports by a relative specifier that
@@ -345,12 +352,13 @@ export function configurationFiles(
     return held;
   };
 
-  const modules: { file: SourceFile; form: string }[] = [];
+  const modules: { file: SourceFile; form: string; manifestDir: string }[] = [];
   const dirs = new Set<string>([root]);
   for (const file of files.byPath.values()) {
     const form = configurationModuleForm(basename(file.fileName));
-    if (form !== undefined && holdsManifest(dirnamePath(file.fileName))) {
-      modules.push({ file, form });
+    const fileDir = dirnamePath(file.fileName);
+    if (form !== undefined && holdsManifest(fileDir)) {
+      modules.push({ file, form, manifestDir: fileDir });
     }
     for (
       let dir = dirnamePath(file.fileName);
@@ -383,7 +391,7 @@ export function configurationFiles(
       if (path.endsWith(".json")) {
         pending.push({ path, manifestDir: dir });
       } else if (held !== undefined) {
-        modules.push({ file: held, form: "a script's configuration flag" });
+        modules.push({ file: held, form: "a script's configuration flag", manifestDir: dir });
       } else {
         named.push({ path, manifestDir: dir });
       }

package/src/configured-declarations.ts

@@ -20,7 +20,7 @@ import { SymbolFlags, type NodeHandle, type Symbol as TSSymbol } from "@typescri
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
 import type { Config, DeclarationEntry } from "./config.ts";
-import type { Inventory } from "./inventory.ts";
+import { declaredComponent, type Inventory } from "./inventory.ts";
 import { must, Unanswerable } from "./query.ts";
 import { nameComponent } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
@@ -118,15 +118,44 @@ function candidatesOf<Brand>(
   ];
 }
 
-/** The member of one container a path component spells, followed through any alias. */
+/**
+ * The properties of the type one container declares, or of its constructor's type for a
+ * static member. A member a symbol keys is bound to that type later than the container's
+ * symbol table is built, so the table does not hold it.
+ */
+function typeMembersOf<Brand>(
+  project: ProjectView<Brand>,
+  container: TSSymbol,
+  isStatic: boolean,
+): readonly TSSymbol[] {
+  const queries = project.queries;
+  const type = must(isStatic ? queries.typeOfSymbol(container) : queries.declaredTypeOf(container));
+  return type === undefined ? [] : must(queries.propertiesOf(type));
+}
+
+/**
+ * The member of one container a path component spells, followed through any alias. A
+ * component in brackets is a computed key, compared with the key each declaration of a
+ * candidate writes: the checker names a member a symbol keys by no spelling of its own.
+ */
 function memberOf<Brand>(
   project: ProjectView<Brand>,
   container: TSSymbol,
   component: string,
   isStatic: boolean,
 ): TSSymbol | undefined {
-  const member = candidatesOf(project, container, isStatic).find(
-    (candidate) => nameComponent(candidate.name) === component,
+  const computed = component.startsWith("[");
+  const candidates = candidatesOf(project, container, isStatic);
+  const member = (
+    computed ? [...candidates, ...typeMembersOf(project, container, isStatic)] : candidates
+  ).find(
+    (candidate) =>
+      nameComponent(candidate.name) === component ||
+      (computed &&
+        candidate.declarations.some((handle) => {
+          const node = project.declarationAt(handle)?.node;
+          return node !== undefined && declaredComponent(node) === component;
+        })),
   );
   return member === undefined ? undefined : unaliased(project, member);
 }

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "5.2.0",
     result: "pass",
-    digest: "sha256:4050d1b67fb757bc12a60f8ece7317a3e8485d3383ec52919cd24b9dfd5509dc",
+    digest: "sha256:012872542679539ec105f49b5ee502b0a9fa35c6bbd9ef3983b5f6e53af83d8e",
   },
   gaps: [],
 } as const;