@cplieger/deadset-ts 3.6.0 → 3.7.0

package/dist/src/finding.js

@@ -1,12 +1 @@
-/**
- * The members of a finding its emitter decides: the code, where the subject is,
- * what the subject is, and the sentence the finding reports. They are the
- * Contract's finding members of the same names, spelled in this language's case.
- *
- * Every other member the finding schema requires follows from these and from the
- * run: the kind's name, its fixability and its ceiling come from the code's row of
- * the issue-kind vocabulary, the severity and the confidence from the resolved
- * configuration, the language from the analyzer. A report completes them, so an
- * emitter cannot state one that disagrees with the vocabulary.
- */
 export {};

package/dist/src/findings/completion.js

@@ -1,23 +1,23 @@
 /**
- * What a finding about a declaration carries beyond what its emitter decides, read from
- * the run: the reachability class and the confidence, the relation that decided the
- * subject, the dead component it falls in, the configurations it holds in, and the
- * severity the configuration gives its code. The dials withhold what they name and
- * every finding that falls with a root they withhold.
+ * What every finding carries beyond what its emitter decides, read from the run and from
+ * the code's row of the issue-kind vocabulary, and the dials that withhold a finding
+ * together with every finding that falls with a root they withhold.
  */
 import { componentId } from "../components.js";
+import { OUTSIDE } from "../graph.js";
+import { KINDS } from "../kinds.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
 /** The classes ranked by the claim each makes, the strongest highest. */
-export const RANK = { certain: 3, probable: 2, possible: 1 };
+const RANK = { certain: 3, probable: 2, possible: 1 };
 /** The weaker of two classes, which is a class capped by a ceiling. */
-export function capped(found, ceiling) {
+function capped(found, ceiling) {
     return RANK[found] <= RANK[ceiling] ? found : ceiling;
 }
 /**
  * The severity the configuration gives one code: the key naming the code, else the key
  * naming its family, else the code's default.
  */
-export function severityOf(config, code, fallback) {
+function severityOf(config, code, fallback) {
     return (config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback);
 }
 /**
@@ -27,7 +27,7 @@ export function severityOf(config, code, fallback) {
  * in the loaded program, a private member and a `#private` name among them, and is
  * `certain`.
  */
-export function reachabilityClasses(swept) {
+function reachabilityClasses(swept) {
     const union = swept.matrix.union;
     const published = new Set(union.rooted
         .filter((root) => root.kind === "published-api")
@@ -35,7 +35,7 @@ export function reachabilityClasses(swept) {
     return (id) => (published.has(id) ? "possible" : "certain");
 }
 /** The component each dead declaration of the run falls in, and none for a live one. */
-export function findingComponents(swept) {
+function findingComponents(swept) {
     const held = new Map();
     for (const component of swept.sweep.components) {
         for (const member of component.members) {
@@ -55,31 +55,67 @@ export function findingComponents(swept) {
     };
 }
 /**
- * Every finding of the run, each with its component, in the order given: the dead
- * component its subject falls in. A subject in none, a live declaration, a file no
- * program builds or a manifest row, falls with nothing and is given a component of its
- * own, numbered past the run's computed components in the order the findings come, so
- * no two families mint one identifier.
+ * Every finding of the run completed, in the order given. A dead declaration carries its
+ * candidate's relation, counts, configurations and component; a live one carries no
+ * relation and holds where it is declared; a file or a manifest row is `certain` and
+ * holds in every configuration. A subject in no dead component gets one of its own,
+ * numbered past the computed ones in finding order, so no two families mint one.
  */
-export function placed(swept, findings) {
+export function completed(input, findings) {
+    const { swept } = input;
+    const union = swept.matrix.union;
+    const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
+    const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+    const classOf = reachabilityClasses(swept);
     const componentOf = findingComponents(swept);
-    const ids = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.ref, symbol.id]));
     let minted = swept.sweep.components.length;
     return findings.map((finding) => {
-        const id = ids.get(finding.symbol.ref);
-        const component = id === undefined ? undefined : componentOf(id);
-        if (component !== undefined) {
-            return { ...finding, component };
+        const row = KINDS.get(finding.code);
+        if (row === undefined) {
+            throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
         }
-        minted += 1;
-        return {
-            ...finding,
-            component: {
+        const at = positions.get(finding.symbol.ref) ?? OUTSIDE;
+        const symbol = union.symbols[at];
+        const judged = union.subject[at] === true ? symbol : undefined;
+        const candidate = judged === undefined ? undefined : candidates.get(judged.id);
+        const found = symbol === undefined ? undefined : componentOf(symbol.id);
+        if (candidate !== undefined && found === undefined) {
+            throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
+        }
+        let component = found;
+        if (component === undefined) {
+            minted += 1;
+            component = {
                 id: componentId(minted),
                 root: true,
                 symbolCount: 1,
                 deletableLines: finding.symbol.sizeLines,
-            },
+            };
+        }
+        const counts = candidate === undefined
+            ? union.made[at]
+            : { production: candidate.productionRefs, test: candidate.testRefs };
+        const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+        return {
+            code: finding.code,
+            kind: row.name,
+            language: "ts",
+            position: finding.position,
+            symbol: finding.symbol,
+            reachabilityClass,
+            confidence: capped(reachabilityClass, row.maxClass),
+            ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
+            testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
+            generated: false,
+            component,
+            retainedBy: [],
+            configurations: candidate?.configurations ??
+                (judged === undefined ? swept.matrix.configurations : (swept.matrix.heldIn[at] ?? [])),
+            consumersLoaded: input.boundary.consumers.loaded,
+            fixability: row.fixability,
+            severity: severityOf(input.config, finding.code, row.defaultSeverity),
+            message: finding.message,
+            details: finding.details ?? {},
         };
     });
 }

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -1,8 +1,5 @@
 import { renderRef } from "../ref.js";
-import { severityOf } from "./completion.js";
 const UNUSED_DEPENDENCY = "DS1601";
-/** The severity the kind ships at, which the configuration's keys override. */
-const UNUSED_DEPENDENCY_SEVERITY = "deny";
 const MESSAGES = {
     dependency: "no import in the target needs the declared dependency",
     "dev-dependency": "no import in the target needs the declared development dependency",
@@ -34,14 +31,9 @@ function neededBy(dependencies) {
 }
 /**
  * A dependency, development dependency or peer dependency of the target's manifest
- * that the target does not need, at the position of its key. Nothing is reported at
- * `allow`. Every subject is a manifest entry, which is `certain` whatever the
- * consumers, so no minimum confidence withholds one.
+ * that the target does not need, at the position of its key.
  */
-function unusedDependencies(config, dependencies) {
-    if (severityOf(config, UNUSED_DEPENDENCY, UNUSED_DEPENDENCY_SEVERITY) === "allow") {
-        return [];
-    }
+function unusedDependencies(dependencies) {
     const needed = neededBy(dependencies);
     return dependencies.declared
         .filter((dependency) => !needed.has(dependency.name))
@@ -63,4 +55,4 @@ function unusedDependencies(config, dependencies) {
     }));
 }
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
-export const dependenciesAndModuleMachinery = ({ config, dependencies }) => unusedDependencies(config, dependencies);
+export const dependenciesAndModuleMachinery = ({ dependencies }) => unusedDependencies(dependencies);

package/dist/src/findings/emitters.js

@@ -1,5 +1,5 @@
 import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machinery.js";
-import { placed } from "./completion.js";
+import { completed, reportable } from "./completion.js";
 import { interfaces } from "./interfaces.js";
 import { intraFunction } from "./intra-function.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
@@ -19,9 +19,11 @@ export const EMITTERS = new Map([
     ["intra-function", intraFunction],
 ]);
 /**
- * Every finding of the run, each family's in table order, each placed in its component
- * by the one step that numbers the components minted for subjects that fall with none.
+ * Every finding of the run the dials do not withhold, each family's in table order: every
+ * family's findings completed by one step, then withheld by one step, so a root one
+ * family reports withholds what another family reports in its component.
  */
 export function findingsOf(input) {
-    return placed(input.swept, [...EMITTERS.values()].flatMap((emit) => emit(input)));
+    const found = [...EMITTERS.values()].flatMap((emit) => emit(input));
+    return reportable(completed(input, found), input.config.analysis.minConfidence);
 }

package/dist/src/findings/reads-and-writes.js

@@ -1,28 +1,12 @@
 import { positionKey } from "../position.js";
-import { findingComponents, RANK, reachabilityClasses, severityOf, } from "./completion.js";
-/**
- * Each code's severity where the configuration sets none, as the issue-kind vocabulary
- * states it.
- */
-export const DEFAULT_SEVERITY = {
-    DS1301: "deny",
-    DS1302: "deny",
-    DS1303: "deny",
-};
 /** The containers whose type parameters `DS1303` reports: a function and a class method. */
 const SIGNATURES = new Set(["function", "method"]);
-/** The severity the configuration gives one code of the family. */
-function severityIn(input, code) {
-    return severityOf(input.config, code, DEFAULT_SEVERITY[code]);
-}
 function indexed(input) {
     const { matrix, sweep } = input.swept;
     return {
         input,
         symbols: new Map(matrix.union.symbols.map((symbol) => [symbol.id, symbol])),
         candidates: new Map(sweep.candidates.map((candidate) => [candidate.id, candidate])),
-        componentOf: findingComponents(input.swept),
-        classOf: reachabilityClasses(input.swept),
     };
 }
 /** Where one declaration is, as a finding states it. */
@@ -34,11 +18,9 @@ function positionOf(symbol) {
         endLine: Math.max(symbol.position.line, symbol.endLine),
     };
 }
-/** The finding about one declaration, every member the family decides filled in. */
-function findingAbout(run, symbol, code, message, facts) {
+/** The finding one code makes about one declaration. */
+function findingAbout(symbol, code, message, details) {
     const position = positionOf(symbol);
-    const reachabilityClass = run.classOf(symbol.id);
-    const component = run.componentOf(symbol.id);
     return {
         code,
         position,
@@ -49,14 +31,7 @@ function findingAbout(run, symbol, code, message, facts) {
             sizeLines: position.endLine - position.line + 1,
         },
         message,
-        reachabilityClass,
-        confidence: reachabilityClass,
-        ...(facts.livenessRelation === undefined ? {} : { livenessRelation: facts.livenessRelation }),
-        testOnly: facts.testOnly,
-        ...(component === undefined ? {} : { component }),
-        configurations: facts.configurations,
-        severity: severityIn(run.input, code),
-        details: facts.details,
+        ...(details === undefined ? {} : { details }),
     };
 }
 /**
@@ -85,15 +60,9 @@ function writeOnlySymbols(run) {
     for (const reference of stores.references) {
         let held = uses.get(reference.to);
         if (held === undefined) {
-            held = { writes: [], reads: 0, production: 0, test: 0 };
+            held = { writes: [], reads: 0 };
             uses.set(reference.to, held);
         }
-        if (reference.test) {
-            held.test += 1;
-        }
-        else {
-            held.production += 1;
-        }
         if (reference.use !== "write") {
             held.reads += 1;
             continue;
@@ -105,7 +74,7 @@ function writeOnlySymbols(run) {
         }
     }
     const found = [];
-    matrix.union.symbols.forEach((symbol, at) => {
+    for (const symbol of matrix.union.symbols) {
         const held = uses.get(symbol.id);
         if (held === undefined ||
             held.writes.length === 0 ||
@@ -113,16 +82,14 @@ function writeOnlySymbols(run) {
             !writable(run, symbol) ||
             stores.exempt.has(symbol.id) ||
             run.candidates.has(symbol.id)) {
-            return;
+            continue;
         }
         const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
         const word = symbol.kind === "variable" ? "variable" : "member";
-        found.push(findingAbout(run, symbol, "DS1301", `${word} ${symbol.name} is written ${writes} and never read`, {
-            testOnly: held.production === 0 && held.test > 0,
-            configurations: matrix.heldIn[at] ?? [],
-            details: { writePositions: held.writes },
+        found.push(findingAbout(symbol, "DS1301", `${word} ${symbol.name} is written ${writes} and never read`, {
+            writePositions: held.writes,
         }));
-    });
+    }
     return found;
 }
 /**
@@ -139,7 +106,7 @@ function unnamed(run, kind) {
             run.candidates.has(symbol.parent)) {
             return [];
         }
-        return [[candidate, symbol]];
+        return [symbol];
     });
 }
 /**
@@ -148,12 +115,7 @@ function unnamed(run, kind) {
  * this kind.
  */
 function unusedEnumMembers(run) {
-    return unnamed(run, "enum-member").map(([candidate, symbol]) => findingAbout(run, symbol, "DS1302", `enum member ${symbol.name} is named nowhere`, {
-        livenessRelation: candidate.relation,
-        testOnly: false,
-        configurations: candidate.configurations,
-        details: {},
-    }));
+    return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`));
 }
 /**
  * `DS1303`: a type parameter of a function or a class method that neither the
@@ -163,13 +125,8 @@ function unusedEnumMembers(run) {
  */
 function unusedTypeParameters(run) {
     return unnamed(run, "type-parameter")
-        .filter(([, symbol]) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
-        .map(([candidate, symbol]) => findingAbout(run, symbol, "DS1303", `type parameter ${symbol.name} is named in neither its signature nor its body`, {
-        livenessRelation: candidate.relation,
-        testOnly: false,
-        configurations: candidate.configurations,
-        details: {},
-    }));
+        .filter((symbol) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
+        .map((symbol) => findingAbout(symbol, "DS1303", `type parameter ${symbol.name} is named in neither its signature nor its body`));
 }
 /**
  * The references of the declarations the write-only kind reports, whatever the
@@ -179,21 +136,11 @@ function unusedTypeParameters(run) {
 export function writeOnlyDeclarations(input) {
     return new Set(writeOnlySymbols(indexed(input)).map((finding) => finding.symbol.ref));
 }
-/** Each code's rule, in code order. */
-const RULES = [
-    ["DS1301", writeOnlySymbols],
-    ["DS1302", unusedEnumMembers],
-    ["DS1303", unusedTypeParameters],
-];
 /**
- * The findings of the reads-and-writes family, `DS1300` to `DS1399`, each code's in site
- * order. A code the configuration sets to `allow` reports nothing, and a finding whose
- * confidence is below the configured minimum is withheld.
+ * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
+ * each code's in site order.
  */
 export const readsAndWrites = (input) => {
     const run = indexed(input);
-    const least = RANK[input.config.analysis.minConfidence];
-    return RULES.flatMap(([code, rule]) => severityIn(input, code) === "allow"
-        ? []
-        : rule(run).filter((finding) => RANK[finding.confidence] >= least));
+    return [...writeOnlySymbols(run), ...unusedEnumMembers(run), ...unusedTypeParameters(run)];
 };

package/dist/src/findings/unused-declarations.js

@@ -1,14 +1,4 @@
-import { capped, findingComponents, reachabilityClasses, reportable, severityOf, } from "./completion.js";
 import { unreachableExports } from "./visibility-narrowing.js";
-/** The codes of the unused-declarations family, each by its row of the vocabulary. */
-export const UNUSED_DECLARATION_KINDS = new Map([
-    ["DS1001", { defaultSeverity: "deny", maxClass: "certain" }],
-    ["DS1002", { defaultSeverity: "deny", maxClass: "certain" }],
-    ["DS1003", { defaultSeverity: "deny", maxClass: "certain" }],
-    ["DS1004", { defaultSeverity: "deny", maxClass: "certain" }],
-    ["DS1005", { defaultSeverity: "deny", maxClass: "certain" }],
-    ["DS1006", { defaultSeverity: "deny", maxClass: "certain" }],
-]);
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
     "method",
@@ -120,19 +110,13 @@ function messageOf(code, judged) {
     }
     return `${subject} has no reference in the target`;
 }
-/**
- * The findings of the unused-declarations family, `DS1000` to `DS1099`, completed and
- * with what the dials withhold left out.
- */
-export function unusedDeclarationFindings(input) {
-    const { config, swept } = input;
-    const union = swept.matrix.union;
-    const dead = new Set(swept.sweep.candidates.map((candidate) => candidate.id));
-    const classOf = reachabilityClasses(swept);
-    const componentOf = findingComponents(swept);
+/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+export const unusedDeclarations = (input) => {
+    const union = input.swept.matrix.union;
+    const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
     const found = [];
-    for (const candidate of swept.sweep.candidates) {
+    for (const candidate of input.swept.sweep.candidates) {
         const at = union.at(candidate.id);
         const symbol = union.symbols[at];
         if (symbol === undefined) {
@@ -147,16 +131,10 @@ export function unusedDeclarationFindings(input) {
             unreachable: unreachable.has(symbol.id),
         };
         const code = codeOf(judged);
-        const row = code === undefined ? undefined : UNUSED_DECLARATION_KINDS.get(code);
-        if (code === undefined || row === undefined) {
+        if (code === undefined) {
             continue;
         }
-        const component = componentOf(symbol.id);
-        if (component === undefined) {
-            throw new Error(`${symbol.id} is reported dead and falls in no dead component`);
-        }
         const endLine = Math.max(symbol.position.line, symbol.endLine);
-        const reachabilityClass = classOf(symbol.id);
         found.push({
             code,
             position: { ...symbol.position, endLine },
@@ -167,17 +145,7 @@ export function unusedDeclarationFindings(input) {
                 sizeLines: endLine - symbol.position.line + 1,
             },
             message: messageOf(code, judged),
-            reachabilityClass,
-            confidence: capped(reachabilityClass, row.maxClass),
-            livenessRelation: candidate.relation,
-            testOnly: candidate.productionRefs === 0 && candidate.testRefs > 0,
-            component,
-            configurations: candidate.configurations,
-            severity: severityOf(config, code, row.defaultSeverity),
-            details: {},
         });
     }
-    return reportable(found, config.analysis.minConfidence);
-}
-/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations = unusedDeclarationFindings;
+    return found;
+};

package/dist/src/kinds.js

@@ -1,52 +1,54 @@
 /**
- * The issue-kind codes whose severity the Contract fixes. A severity key naming
- * one, or a family prefix whose range holds one, is an unimplemented key rather
- * than a setting.
- *
- * The codes are written out rather than read from the Contract at run time: the
- * Contract is data a reader outside this program consults, and a product that
- * read it while running would need it installed beside itself. A test compares
- * this list against the Contract release the analyzer is written against, so a
- * code the Contract fixes arrives here as a failing test.
+ * Every live row of the issue-kind vocabulary, in ascending code order, written out
+ * rather than read at run time, because a product that read the Contract while running
+ * would need it installed beside itself. A test compares this table against the
+ * Contract release the analyzer is written against.
  */
-export const FIXED_SEVERITY_CODES = ["DS1703", "DS1704"];
+const ROWS = [
+    row("DS1001", "unused-exported", "deny", "deletable"),
+    row("DS1002", "unused-unexported", "deny", "deletable"),
+    row("DS1003", "unused-member", "deny", "deletable"),
+    row("DS1004", "test-only-use", "deny", "deletable"),
+    row("DS1005", "test-of-dead-code", "deny", "deletable"),
+    row("DS1006", "deprecated-unused", "deny", "deletable"),
+    row("DS1101", "unnecessary-export", "warn", "narrowable"),
+    row("DS1102", "unnecessary-exposure", "warn", "narrowable"),
+    row("DS1103", "unreachable-export", "deny", "deletable"),
+    row("DS1104", "redundant-export-keyword", "warn", "narrowable"),
+    row("DS1201", "unused-interface", "deny", "deletable"),
+    row("DS1203", "uncalled-interface-method", "warn", "manual"),
+    row("DS1204", "unused-satisfaction-assertion", "deny", "deletable"),
+    row("DS1301", "write-only-symbol", "deny", "deletable"),
+    row("DS1302", "unused-enum-member", "deny", "deletable"),
+    row("DS1303", "unused-type-parameter", "deny", "deletable"),
+    row("DS1501", "file-never-built", "deny", "deletable"),
+    row("DS1502", "file-never-imported", "deny", "deletable"),
+    row("DS1601", "unused-dependency", "deny", "manual"),
+    row("DS1605", "unused-module-directive", "warn", "deletable"),
+    row("DS1701", "suppression-without-reason", "deny", "none"),
+    row("DS1702", "unscoped-ignore-entry", "deny", "none"),
+    { ...row("DS1703", "stale-suppression", "deny", "none"), fixed: true },
+    { ...row("DS1704", "unmatched-root", "deny", "none"), fixed: true },
+    row("DS1705", "stale-cross-language-edge", "deny", "none"),
+    row("DS1801", "unused-parameter", "warn", "manual"),
+    row("DS1802", "unused-receiver", "warn", "deletable"),
+    row("DS1803", "unused-result", "warn", "manual"),
+    row("DS1805", "unreachable-statement", "deny", "deletable"),
+    row("DS1807", "dead-store", "deny", "deletable"),
+    row("DS1809", "unreachable-case", "deny", "deletable"),
+];
+/** A row at the `certain` ceiling whose severity a configuration may set. */
+function row(code, name, defaultSeverity, fixability) {
+    return { code, name, defaultSeverity, maxClass: "certain", fixability, fixed: false };
+}
+/** Every live row of the issue-kind vocabulary, by its code, in ascending code order. */
+export const KINDS = new Map(ROWS.map((one) => [one.code, one]));
 /**
  * The code of every live issue kind, in ascending order. A severity key names one of
  * them or a family prefix whose range holds one; a key naming a retired code, an
  * unassigned code or a range holding no live kind is an unimplemented key, so every
- * severity a configuration sets is one some analyzer reports under. A test compares
- * this list against the Contract release the analyzer is written against.
+ * severity a configuration sets is one some analyzer reports under.
  */
-export const LIVE_CODES = [
-    "DS1001",
-    "DS1002",
-    "DS1003",
-    "DS1004",
-    "DS1005",
-    "DS1006",
-    "DS1101",
-    "DS1102",
-    "DS1103",
-    "DS1104",
-    "DS1201",
-    "DS1203",
-    "DS1204",
-    "DS1301",
-    "DS1302",
-    "DS1303",
-    "DS1501",
-    "DS1502",
-    "DS1601",
-    "DS1605",
-    "DS1701",
-    "DS1702",
-    "DS1703",
-    "DS1704",
-    "DS1705",
-    "DS1801",
-    "DS1802",
-    "DS1803",
-    "DS1805",
-    "DS1807",
-    "DS1809",
-];
+export const LIVE_CODES = ROWS.map((one) => one.code);
+/** The issue-kind codes whose severity the Contract fixes, in ascending order. */
+export const FIXED_SEVERITY_CODES = ROWS.filter((one) => one.fixed).map((one) => one.code);

package/jsr.json

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

package/package.json

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