@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/component-files.js

@@ -109,17 +109,17 @@ function scriptTagAt(text, offset) {
         /^<script[\s/>]/iu.test(text.slice(offset, offset + 8)));
 }
 /**
- * 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, from) {
+function scanBraces(text, from) {
     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);
@@ -131,24 +131,84 @@ function pastBraces(text, from) {
         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, from) {
+    const braces = scanBraces(text, from);
+    return braces.closed ? braces.end : -1;
+}
+/**
+ * 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) {
+    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, lt, dialect) {
+    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;
+}
+/**
+ * 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, from, braces) {
+    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 `>`. */
-function readStartTag(text, from, nameStop) {
+/**
+ * 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, from, nameStop, dialect) {
     const name = text.slice(from + 1, nameStop).toLowerCase();
     const attributes = [];
     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 = () => {
+        if (text.charCodeAt(at) !== 0x7b) {
+            return undefined;
+        }
+        const braces = scanBraces(text, at);
+        return { braces, value: braces.closed || !dialect.braceIsText };
+    };
+    const bracedEnd = (braces) => 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;
@@ -160,12 +220,13 @@ function readStartTag(text, from, nameStop) {
         }
         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,
@@ -191,17 +252,19 @@ function readStartTag(text, from, nameStop) {
                 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;
+                value = text.slice(at + 1, close < 0 ? text.length : close);
+                at = close < 0 ? text.length : close + 1;
             }
-            else if (opening === 0x7b) {
-                const past = pastBraces(text, at);
-                const stop = past < 0 ? text.length : past;
+            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 {
@@ -305,9 +368,11 @@ function scriptsInside(text, from, to) {
  * 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) {
+export function readComponent(text, extension) {
+    const dialect = dialectOf(extension);
     const blocks = [];
     const imports = [];
     const warnings = [];
@@ -337,8 +402,7 @@ export function readComponent(text) {
         }
         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);
@@ -362,7 +426,7 @@ export function readComponent(text) {
             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 !== "") {
@@ -435,9 +499,9 @@ export function readComponent(text) {
     }
 }
 /**
- * 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) {
     const words = [];
@@ -525,7 +589,8 @@ export function exportsDefault(text) {
         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") {
@@ -554,8 +619,8 @@ export function exportsDefault(text) {
     return false;
 }
 /** The module one component file's text is read as, and the span map back to the file. */
-export function componentModule(text) {
-    const { blocks, imports } = readComponent(text);
+export function componentModule(text, fileExtension) {
+    const { blocks, imports } = readComponent(text, fileExtension);
     const out = [];
     let at = 0;
     let language;

package/dist/src/components.js

@@ -129,12 +129,12 @@ function linesSpanned(symbols) {
     return total;
 }
 /**
- * The dead declarations by subgraph place (`at`, and `position` per graph declaration),
- * a test file's only where it tests dead code or nothing the tests reach. `adjacent` holds
- * each reference one makes to another, except an unreferenced test-file declaration's to
- * production code, which decides nothing of its target; an edge each way between a dead
- * member and its dead container; and one back from each production target of an admitted
- * test, which puts the test in its subject's component. `references` holds the first alone.
+ * The dead declarations by subgraph place (`at`, and `position` per graph declaration), a
+ * test file's only where it tests dead code or nothing the tests reach. `adjacent` holds each
+ * reference one makes to another, but an unreferenced test-file declaration's to production
+ * code, which decides nothing; an edge each way between a dead member and its dead container;
+ * and one back from each non-ambient production target of an admitted test, which puts the
+ * test in its subject's component. `references` holds the first alone.
  */
 function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
     const at = [];
@@ -158,6 +158,7 @@ function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
             references[from]?.push(to);
             if (testOfDeadCode[index] === true &&
                 graph.test[edge.to] !== true &&
+                graph.ambient[edge.to] !== true &&
                 graph.subject[edge.to] === true) {
                 adjacent[to]?.push(from);
             }

package/dist/src/config.js

@@ -66,6 +66,7 @@ export function defaultConfig() {
             injectionRegistrations: [],
             lifecycleContracts: [],
             serializers: [],
+            rootsComplete: false,
         },
     };
 }

package/dist/src/configuration-files.js

@@ -6,7 +6,7 @@
  * every string either holds as it likes, so each one that spells a declared dependency
  * uses it and each relative one that names a source file of the program roots the file.
  */
-import { isExportDeclaration, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { isCallExpression, isExportDeclaration, isIdentifier, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 const MANIFEST = "package.json";
 /** A configuration module's name, each form with the spelling a root reports it by. */
@@ -270,8 +270,9 @@ export function configurationFiles(host, targetRoot, files, parse) {
     const dirs = new Set([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); relativePath(root, dir) !== undefined && !dirs.has(dir); dir = dirnamePath(dir)) {
             dirs.add(dir);
@@ -301,7 +302,7 @@ export function configurationFiles(host, targetRoot, files, parse) {
                 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 });
@@ -345,18 +346,56 @@ export function configurationFiles(host, targetRoot, files, parse) {
             : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
     };
 }
-/** The relative specifiers one file's imports and re-exports name. */
-function relativeSpecifiers(file) {
-    return file.statements.flatMap((statement) => {
-        const specifier = isImportDeclaration(statement) || isExportDeclaration(statement)
+/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
+function calledSpecifier(node) {
+    if (!isCallExpression(node) || node.arguments.length !== 1) {
+        return undefined;
+    }
+    const callee = node.expression;
+    const loads = callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
+    return loads ? node.arguments[0] : undefined;
+}
+/**
+ * The relative specifiers one file's imports and re-exports name, and those its
+ * `require(...)` and `import(...)` calls name by a literal.
+ */
+export function relativeSpecifiers(file) {
+    const known = specifiersOf.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = [];
+    const named = (specifier) => {
+        if (specifier !== undefined &&
+            (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
+            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))) {
+            found.push(specifier.text);
+        }
+    };
+    const visit = (node) => {
+        named(calledSpecifier(node));
+        node.forEachChild(visit);
+    };
+    for (const statement of file.statements) {
+        named(isImportDeclaration(statement) || isExportDeclaration(statement)
             ? statement.moduleSpecifier
-            : undefined;
-        return specifier !== undefined &&
-            isStringLiteral(specifier) &&
-            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
-            ? [specifier.text]
-            : [];
-    });
+            : undefined);
+        visit(statement);
+    }
+    specifiersOf.set(file, found);
+    return found;
+}
+/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
+const specifiersOf = new WeakMap();
+/**
+ * The files no program holds that a chain from `seeds` reads: each seed, and each file
+ * below the target root one imports, re-exports or loads by a relative specifier that no
+ * program holds either, until no further file joins, each read against the manifest
+ * directory its seed names. A file that cannot be read is skipped.
+ */
+export function outsideChain(host, targetRoot, files, parse, seeds) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return outsideModules(host, root, [], files, () => false, parse, seeds);
 }
 /**
  * The paths one relative specifier from a configuration file may reach, in the order they

package/dist/src/configured-declarations.js

@@ -7,6 +7,7 @@
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { resolvedTargets } from "./calls.js";
+import { declaredComponent } from "./inventory.js";
 import { must, Unanswerable } from "./query.js";
 import { nameComponent } from "./ref.js";
 /** The meanings a name of the global scope is looked up under: any of them. */
@@ -80,9 +81,30 @@ function candidatesOf(project, container, isStatic) {
         ...exported.filter((member) => !isClass || !isClassMember(member)),
     ];
 }
-/** 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(project, container, isStatic) {
+    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(project, container, component, isStatic) {
-    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);
 }
 /** The declaration a path names from one starting symbol, component by component. */

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "5.2.0",
+        corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:4050d1b67fb757bc12a60f8ece7317a3e8485d3383ec52919cd24b9dfd5509dc",
+        digest: "sha256:76c07ac14bda6e302444918d832b01844bac6f29b6f22a742d538804480c0769",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -196,12 +196,13 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     };
     const calls = new Map();
     /**
-     * The parameter and return types of a type's one call signature, or of its one construct
-     * signature where it has no call signature, read once per type.
+     * The parameter and return types of each of a type's call signatures, or of each of its
+     * construct signatures where it has no call signature, read once per type.
      */
-    const callOf = (type) => {
-        if (calls.has(type.id)) {
-            return calls.get(type.id);
+    const callsOf = (type) => {
+        const known = calls.get(type.id);
+        if (known !== undefined) {
+            return known;
         }
         lookups += 1;
         let kind = SignatureKind.Call;
@@ -211,28 +212,26 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             kind = SignatureKind.Construct;
             signatures = queries.signaturesOf(type, kind);
         }
-        let called;
-        const [signature, ...more] = isAnswered(signatures) ? signatures : [];
-        if (signature !== undefined && more.length === 0) {
+        const called = (isAnswered(signatures) ? signatures : []).map((signature) => {
             const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
             const result = queries.returnTypeOf(signature);
             lookups += parameters.length + 1;
-            called = {
+            return {
                 kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
                 result: isAnswered(result) ? result : undefined,
             };
-        }
+        });
         calls.set(type.id, called);
         return called;
     };
     /**
      * Each object type a value of `source` is checked as against the object types of
-     * `target`: the value's own, and through array elements, a function's parameters,
-     * checked the other way, and result, and the type arguments two instantiations share
-     * by place, an array among them, as an array reaches `Iterable<T>`.
-     * A source that is one of the target's own object types matches it as it stands. Each
-     * pair is compared once, which ends the walk over a recursive type.
+     * `target`: the value's own, and through array elements, every pair of signatures
+     * (parameters checked the other way, then results), which reads more than the overload
+     * the checker picks, and the type arguments of two instantiations by place, as an array
+     * reaches `Iterable<T>`. A source that is one of the target's own object types matches
+     * it as it stands. Each pair is compared once, which ends the walk over a recursive type.
      */
     const compared = (source, target, into, seen) => {
         const key = `${String(source?.id)}>${String(target?.id)}`;
@@ -253,7 +252,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 into.push({ source: one, targets, outside: true });
             }
             const element = elementOf(one);
-            const called = element === undefined ? callOf(one) : undefined;
+            const called = element === undefined ? callsOf(one) : [];
             const sourceArguments = typeArgumentsOf(one);
             for (const part of targets) {
                 const partElement = elementOf(part);
@@ -267,17 +266,17 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 sourceArguments.slice(0, targetArguments.length).forEach((argument, index) => {
                     compared(argument, targetArguments[index], into, seen);
                 });
-                if (element !== undefined) {
+                if (element !== undefined || called.length === 0) {
                     continue;
                 }
-                const other = called === undefined ? undefined : callOf(part);
-                if (called === undefined || other?.kind !== called.kind) {
-                    continue;
+                for (const other of callsOf(part)) {
+                    for (const signature of called.filter((one) => one.kind === other.kind)) {
+                        other.parameters.forEach((parameter, index) => {
+                            compared(parameter, signature.parameters[index], into, seen);
+                        });
+                        compared(signature.result, other.result, into, seen);
+                    }
                 }
-                other.parameters.forEach((parameter, index) => {
-                    compared(parameter, called.parameters[index], into, seen);
-                });
-                compared(called.result, other.result, into, seen);
             }
         }
     };
@@ -298,7 +297,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             if (element !== undefined) {
                 return mayCarry(element, seen);
             }
-            return callOf(part) !== undefined || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
+            return callsOf(part).length > 0 || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
         });
     };
     const sourced = carried.flatMap((flow, index) => {
@@ -330,10 +329,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 continue;
             }
             for (const [name, member] of sourceMembers) {
+                // A member the position shares with the source is no read of it. A member with no
+                // declaration, as a mapped type over literal keys has, is never one it shares.
                 const read = tables.some((table) => {
                     const declared = table.get(name);
                     return (declared !== undefined &&
-                        declared.handles.size > 0 &&
                         ![...declared.handles].some((handle) => member.handles.has(handle)));
                 });
                 if (read) {

package/dist/src/convention-rows.js

@@ -10,6 +10,8 @@ const SCRIPT = "{js,jsx,ts,tsx}";
 const MODULE = "{js,mjs,ts,mts}";
 const ANY_MODULE = "{js,mjs,cjs,ts,mts,cts}";
 const VITE_CONFIG = `vite.config.${ANY_MODULE}`;
+/** The legacy configuration files of ESLint that hold JSON or a CommonJS module. */
+const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{js,cjs}"];
 const SVELTEKIT_ROUTE_FILES = "+{page,layout,server,page.server,layout.server,error}";
 /** SvelteKit's entries other than its parameter matchers. */
 const SVELTEKIT_ENTRIES = [
@@ -111,6 +113,25 @@ export const CONVENTION_ROWS = [
             package: "@babel/runtime",
         })),
     },
+    {
+        name: "docusaurus",
+        package: "@docusaurus/core",
+        range: ">=2.0.0 <4.0.0",
+        entries: [`src/pages/**/*.${SCRIPT}`, `src/theme/**/*.${SCRIPT}`],
+        moves: [],
+    },
+    {
+        name: "eslint",
+        package: "eslint",
+        range: ">=4.0.0 <10.0.0",
+        entries: [],
+        moves: [],
+        prefixedNames: [
+            { property: "plugins", files: ESLINTRC, prefix: "eslint-plugin" },
+            { property: "extends", files: ESLINTRC, prefix: "eslint-plugin", marker: "plugin:" },
+            { property: "extends", files: ESLINTRC, prefix: "eslint-config" },
+        ],
+    },
     {
         name: "eslint",
         package: "eslint",
@@ -118,6 +139,13 @@ export const CONVENTION_ROWS = [
         entries: [`**/eslint.config.${ANY_MODULE}`],
         moves: [],
     },
+    {
+        name: "expo",
+        package: "expo",
+        range: ">=44.0.0 <60.0.0",
+        entries: [`{index,App}.${SCRIPT}`],
+        moves: [],
+    },
     {
         name: "expo-router",
         package: "expo-router",
@@ -202,6 +230,28 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "oclif",
+        package: "@oclif/core",
+        range: ">=1.0.0 <5.0.0",
+        entries: [`src/{commands,hooks}/**/*.${SCRIPT}`],
+        moves: [],
+        manifestEntries: [
+            { key: "oclif.commands", directory: true },
+            { key: "oclif.hooks", directory: false },
+        ],
+    },
+    {
+        name: "parcel",
+        package: "parcel",
+        range: ">=2.0.0 <3.0.0",
+        entries: [],
+        moves: [],
+        manifestEntries: [
+            { key: "source", directory: false },
+            { key: "targets.*.source", directory: false },
+        ],
+    },
     {
         name: "prettier",
         package: "prettier",
@@ -493,6 +543,31 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "tanstack-router",
+        package: "@tanstack/router-plugin",
+        range: ">=1.0.0 <2.0.0",
+        entries: [`<routes>/**/*.${SCRIPT}`],
+        moves: [
+            {
+                id: "routes",
+                defaults: ["src/routes"],
+                readings: [
+                    { property: "routesDirectory", files: ["tsr.config.json"] },
+                    {
+                        property: "routesDirectory",
+                        files: [VITE_CONFIG],
+                        call: { module: "@tanstack/router-plugin/vite", export: "tanstackRouter" },
+                    },
+                    {
+                        property: "routesDirectory",
+                        files: [VITE_CONFIG],
+                        call: { module: "@tanstack/router-plugin/vite", export: "TanStackRouterVite" },
+                    },
+                ],
+            },
+        ],
+    },
     {
         name: "vite",
         package: "vite",