@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.8

package/dist/src/git-ignore.js

@@ -1,10 +1,11 @@
 /**
- * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * Which files git ignores below a tree's root, read as git reads its ignore files:
  * https://git-scm.com/docs/gitignore#_pattern_format
  */
-import { globExpression } from "./glob.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-/** The rules one `.gitignore` text writes, in order. */
+import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.js";
+import { gitignoreExpression } from "./text/glob.js";
+import { repositoryOf } from "./fs/tree.js";
+/** The rules one ignore file's text writes, in order. */
 function rulesOf(text) {
     const rules = [];
     for (const raw of text.split(/\r?\n/u)) {
@@ -13,7 +14,7 @@ function rulesOf(text) {
             continue;
         }
         const negated = line.startsWith("!");
-        line = negated || line.startsWith("\\") ? line.slice(1) : line;
+        line = negated ? line.slice(1) : line;
         const directoryOnly = line.endsWith("/");
         line = line.replace(/\/+$/u, "");
         if (line === "") {
@@ -26,43 +27,51 @@ function rulesOf(text) {
         rules.push({
             negated,
             directoryOnly,
-            expression: globExpression(anchored ? pattern : `**/${pattern}`),
+            expression: gitignoreExpression(anchored ? pattern : `**/${pattern}`),
         });
     }
     return rules;
 }
+function rulesIn(host, path) {
+    try {
+        return rulesOf(host.readFile(path));
+    }
+    catch {
+        return [];
+    }
+}
 /**
- * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
- * outside `root` is not ignored, and a file below an ignored directory stays ignored
- * whatever a later pattern says, as git cannot re-include it.
+ * Whether git ignores one absolute path below `root`: by the repository's `info/exclude`,
+ * then the `.gitignore` files from the repository's root down to the path's directory, a
+ * later pattern overriding an earlier one. A path outside `root` is not ignored, and a file
+ * below an ignored directory stays ignored whatever a later pattern says, as git cannot
+ * re-include it. With no repository at or above `root`, the files at and below it are read;
+ * with one, the directories above `root` give patterns but are not themselves tested.
  */
 export function gitIgnored(host, root) {
+    const found = repositoryOf(host, root);
+    const repository = found?.root;
+    const above = repository === undefined ? [] : [...ancestors(dirnamePath(root), repository)].reverse();
+    const excluded = found?.exclude === undefined ? [] : rulesIn(host, found.exclude);
     const read = new Map();
     const rulesAt = (dir) => {
         let rules = read.get(dir);
         if (rules === undefined) {
-            try {
-                rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
-            }
-            catch {
-                rules = [];
-            }
+            rules = rulesIn(host, joinPath(dir, ".gitignore"));
             read.set(dir, rules);
         }
         return rules;
     };
-    /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
     const decided = (path, directory) => {
-        const dirs = [];
-        for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-            dirs.unshift(at);
-        }
-        dirs.unshift(root);
+        const sources = [
+            ...(repository === undefined ? [] : [[repository, excluded]]),
+            ...[...above, ...[...ancestors(dirnamePath(path), root)].reverse()].map((dir) => [dir, rulesAt(dir)]),
+        ];
         let ignored = false;
-        for (const dir of dirs) {
-            const below = relativePath(dir, path);
-            for (const rule of below === undefined ? [] : rulesAt(dir)) {
-                if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+        for (const [dir, rules] of sources) {
+            const below = relativePath(dir, path) ?? "";
+            for (const rule of rules) {
+                if ((directory || !rule.directoryOnly) && rule.expression.test(below)) {
                     ignored = !rule.negated;
                 }
             }

package/dist/src/html-entries.js

@@ -5,9 +5,9 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { filesBelow } from "./fs/tree.js";
+import { holdsManifest } from "./fs/manifest.js";
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 /** The end tag an inline module script's content runs to. */
@@ -20,29 +20,6 @@ const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
 const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"];
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(host, dir) {
-    let entries;
-    try {
-        entries = host.readDirectory(dir);
-    }
-    catch {
-        return [];
-    }
-    const found = [];
-    for (const entry of entries) {
-        const path = joinPath(dir, entry.name);
-        if (entry.directory) {
-            if (entry.name !== SKIPPED) {
-                found.push(...htmlFiles(host, path));
-            }
-        }
-        else if (entry.name.endsWith(".html")) {
-            found.push(path);
-        }
-    }
-    return found.sort();
-}
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text) {
     const found = new Map();
@@ -98,12 +75,7 @@ function scriptValues(parse, path, text) {
 }
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host, root, dir) {
-    for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "package.json")) === "file") {
-            return at;
-        }
-    }
-    return root;
+    return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 /**
  * The own files the scripts of every HTML file below the target root load. A value
@@ -115,7 +87,8 @@ function manifestDirectory(host, root, dir) {
 export function htmlEntries(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const found = [];
-    for (const path of htmlFiles(host, root)) {
+    for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+        const path = joinPath(root, below);
         let text;
         try {
             text = host.readFile(path);

package/dist/src/in-operands.js

@@ -5,6 +5,7 @@
  */
 import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { sourceFilesOf } from "./source-files.js";
+import { bytewise } from "./text/compare.js";
 /**
  * The text of each string literal, or template literal with no substitution, written as
  * the left operand of an `in` expression in a file of the project that is no test file.
@@ -26,5 +27,5 @@ export function inOperandNames(project, targetRoot, testFiles) {
             file.forEachChild(visit);
         }
     }
-    return [...found].sort();
+    return [...found].sort(bytewise);
 }

package/dist/src/injection-container.js

@@ -24,7 +24,7 @@ function isInjected(node) {
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations(input) {
     const { project, held } = input;
-    const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+    const resolved = resolveEntries(project, held, input.ts.injection_registrations);
     if (!resolved.some(namesADeclaration)) {
         return [];
     }

package/dist/src/intra-function-parts.js

@@ -14,6 +14,7 @@ import { importRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
 import { spellsNoBinding } from "./spelled-names.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The result types that carry no value, as the checker spells them. */
 const NO_VALUE = new Set([
     "void",
@@ -29,17 +30,13 @@ function spanOf(file, root, node) {
     const endLine = file.getLineAndCharacterOfPosition(node.end).line + 1;
     return { ...start, endLine };
 }
-/** The parenthesized expression's content, through every pair of parentheses. */
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** The node the parentheses around one expression sit in. */
 function outerParent(node) {
     return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
 }
 /** The name a call is made through: the identifier, or the member a property access names. */
 function calleeName(call) {
-    const callee = unwrapped(call.expression);
+    const callee = parenthesesRemoved(call.expression);
     if (isIdentifier(callee)) {
         return callee;
     }
@@ -94,7 +91,7 @@ function unreachableExempt(statement) {
 }
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
         return `s:${node.text}`;
     }
@@ -205,7 +202,7 @@ function extendedNames(files) {
                     named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
                 }
                 else {
-                    const expression = unwrapped(type.expression);
+                    const expression = parenthesesRemoved(type.expression);
                     named = isPropertyAccessExpression(expression) ? expression.name : expression;
                 }
                 if (isIdentifier(named)) {
@@ -249,7 +246,7 @@ function decoratorFixes(constructor) {
 }
 /** The name an expression spells a class by: an identifier, or the member a property access names. */
 function spelledName(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isIdentifier(node)) {
         return node;
     }
@@ -442,8 +439,8 @@ export function projectParts(project, held, references, targetRoot) {
             if ((isImportClause(node) || isNamespaceImport(node)) && node.name !== undefined) {
                 specifiers.add(position(node.name));
             }
-            if (isExportAssignment(node) && isIdentifier(unwrapped(node.expression))) {
-                specifiers.add(position(unwrapped(node.expression)));
+            if (isExportAssignment(node) && isIdentifier(parenthesesRemoved(node.expression))) {
+                specifiers.add(position(parenthesesRemoved(node.expression)));
             }
             if (isSwitchStatement(node)) {
                 const holder = holderOf(node);
@@ -946,7 +943,7 @@ function isPlainWrite(use) {
     const parent = outerParent(use);
     return (isBinaryExpression(parent) &&
         parent.operatorToken.kind === SyntaxKind.EqualsToken &&
-        unwrapped(parent.left) === use);
+        parenthesesRemoved(parent.left) === use);
 }
 /**
  * The writes to the locals of one block that no read reaches. A write is a declaration's
@@ -992,12 +989,12 @@ function deadStores(file, root, block, holder, locals, ids) {
             if (!isExpressionStatement(statement)) {
                 return undefined;
             }
-            const expression = unwrapped(statement.expression);
+            const expression = parenthesesRemoved(statement.expression);
             if (!isBinaryExpression(expression) ||
                 expression.operatorToken.kind !== SyntaxKind.EqualsToken) {
                 return undefined;
             }
-            const target = unwrapped(expression.left);
+            const target = parenthesesRemoved(expression.left);
             return isIdentifier(target) && uses.includes(target)
                 ? { target, value: expression.right }
                 : undefined;

package/dist/src/inventory.js

@@ -3,7 +3,7 @@ import { dirnamePath, joinPath, relativePath } from "./paths.js";
 import { byPosition, positionKey, renderPosition, writtenLength, } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
-const MANIFEST = "package.json";
+import { manifestAt } from "./fs/manifest.js";
 /**
  * Resolves each file's package scope: the name of the nearest manifest at or above
  * its directory up to the target root, and the file's path below that manifest.
@@ -17,26 +17,7 @@ const MANIFEST = "package.json";
 export function packageScope(host, root) {
     const named = new Map();
     const manifestName = (dir) => {
-        let text;
-        try {
-            text = host.readFile(joinPath(root, dir, MANIFEST));
-        }
-        catch {
-            return undefined;
-        }
-        let value;
-        try {
-            value = JSON.parse(text);
-        }
-        catch {
-            // A manifest this program cannot read names no package, which is the same
-            // answer as an absent one: the file is then scoped by the target root.
-            return undefined;
-        }
-        if (typeof value !== "object" || value === null) {
-            return undefined;
-        }
-        const name = value["name"];
+        const name = manifestAt(host, joinPath(root, dir))?.["name"];
         return typeof name === "string" && name !== "" ? name : undefined;
     };
     const nearest = (dir) => {

package/dist/src/json-document.js

@@ -1,106 +1,228 @@
 /**
- * A read of a strict JSON document beside its parse: what a parse into a value cannot
- * report, the offset of each record of one array and a member written twice.
+ * A text that is not one strict JSON document: a syntax error, data after the value, a
+ * member one object writes twice, or nesting past {@link MAX_DEPTH}. `place` is the
+ * value the fault is in, followed by the member written twice.
  */
-/** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
-class Walk {
-    starts = [];
-    /** The member written twice, where one is, as the offset of its name. */
-    twice;
-    text;
-    array;
+export class StrictJSONError extends Error {
+    offset;
+    place;
+    constructor(reason, offset, place) {
+        super(reason);
+        this.name = "StrictJSONError";
+        this.offset = offset;
+        this.place = place;
+    }
+}
+/**
+ * How deep values may nest. A document this analyzer reads nests a few levels, and a
+ * bound turns a document built to exhaust the stack into a refusal.
+ */
+const MAX_DEPTH = 1000;
+const SPACE = /[ \t\n\r]*/uy;
+const STRING = /"(?:[ !#$%&'()*+,\-./0-9:;<=>?@A-Z[\]-\u{10FFFF}]|\\(?:["\\/bfnrt]|u[0-9A-Fa-f]{4}))*"/uy;
+const NUMBER = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/uy;
+const LITERALS = new Map([
+    ["true", true],
+    ["false", false],
+    ["null", null],
+]);
+/** One member name spelled as a JSON Pointer token. */
+const escaped = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
+/** The member names and indexes a JSON Pointer holds, unescaped. */
+export function pointerSegments(pointer) {
+    return pointer === ""
+        ? []
+        : pointer
+            .slice(1)
+            .split("/")
+            .map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+/** The JSON Pointer of a place written as segments. */
+export function pointerOf(segments) {
+    return segments.map((segment) => `/${escaped(segment)}`).join("");
+}
+/**
+ * The place a JSON Pointer names inside `value`, followed by `member` where it is not
+ * empty: a pointer's text does not say whether a segment of digits is an index, so the
+ * value it points into does.
+ */
+export function placeIn(value, pointer, member = "") {
+    const place = [];
+    let held = value;
+    for (const segment of pointerSegments(pointer)) {
+        if (Array.isArray(held)) {
+            place.push(Number(segment));
+            held = held[Number(segment)];
+        }
+        else {
+            place.push(segment);
+            held = isRecord(held) ? held[segment] : undefined;
+        }
+    }
+    return member === "" ? place : [...place, member];
+}
+/**
+ * A place as a refusal names it: member names joined by full stops and an index in
+ * square brackets, as `ts.serializers[0].returns`.
+ */
+export function dotted(place) {
+    let path = "";
+    for (const segment of place) {
+        path +=
+            typeof segment === "number" ? `[${String(segment)}]` : path === "" ? segment : `.${segment}`;
+    }
+    return path;
+}
+class Reader {
     at = 0;
-    constructor(text, array) {
+    path = [];
+    fractions = new Map();
+    starts = new Map();
+    text;
+    records;
+    constructor(text, records) {
         this.text = text;
-        this.array = array;
-    }
-    run() {
-        this.value("document");
+        this.records = records;
     }
-    skip() {
-        while (/[ \t\r\n]/u.test(this.text[this.at] ?? "")) {
-            this.at += 1;
+    read() {
+        const value = this.value(0);
+        this.match(SPACE);
+        if (this.at < this.text.length) {
+            this.fail("data follows the document's value");
         }
+        return value;
     }
-    string() {
-        const start = this.at;
-        this.at += 1;
-        while (this.text[this.at] !== '"') {
-            this.at += this.text[this.at] === "\\" ? 2 : 1;
+    fail(reason, offset = this.at, member = "") {
+        throw new StrictJSONError(reason, offset, member === "" ? [...this.path] : [...this.path, member]);
+    }
+    match(pattern) {
+        pattern.lastIndex = this.at;
+        const found = pattern.exec(this.text)?.[0];
+        this.at = found === undefined ? this.at : pattern.lastIndex;
+        return found;
+    }
+    expect(char, what) {
+        this.match(SPACE);
+        if (this.text[this.at] !== char) {
+            this.fail(`${what} is expected`);
         }
         this.at += 1;
-        return JSON.parse(this.text.slice(start, this.at));
     }
-    value(role) {
-        this.skip();
-        if (role === "record") {
-            this.starts.push(this.at);
+    value(depth) {
+        this.match(SPACE);
+        if (depth > MAX_DEPTH) {
+            this.fail(`values nest deeper than ${String(MAX_DEPTH)} levels`);
         }
         const char = this.text[this.at];
         if (char === "{") {
-            this.object(role);
+            return this.object(depth);
         }
-        else if (char === "[") {
-            this.list(role === "array" ? "record" : "other");
+        if (char === "[") {
+            return this.array(depth);
         }
-        else if (char === '"') {
-            this.string();
+        const string = this.match(STRING);
+        if (string !== undefined) {
+            return JSON.parse(string);
         }
-        else {
-            while (this.at < this.text.length && !/[,\]} \t\r\n]/u.test(this.text[this.at] ?? "")) {
-                this.at += 1;
+        NUMBER.lastIndex = this.at;
+        const number = NUMBER.exec(this.text);
+        if (number !== null) {
+            this.at = NUMBER.lastIndex;
+            if (number[1] !== undefined || number[2] !== undefined) {
+                this.fractions.set(pointerOf(this.path.map(String)), number[0]);
             }
+            return Number(number[0]);
         }
+        for (const [literal, held] of LITERALS) {
+            if (this.text.startsWith(literal, this.at)) {
+                this.at += literal.length;
+                return held;
+            }
+        }
+        return this.fail(char === undefined ? "the document ends where a value is expected" : "a value is expected");
     }
-    object(role) {
-        const seen = new Set();
+    object(depth) {
+        const held = {};
         this.at += 1;
+        this.match(SPACE);
+        if (this.text[this.at] === "}") {
+            this.at += 1;
+            return held;
+        }
         for (;;) {
-            this.skip();
-            if (this.text[this.at] === "}") {
-                this.at += 1;
-                return;
+            this.match(SPACE);
+            const offset = this.at;
+            const spelled = this.match(STRING);
+            if (spelled === undefined) {
+                return this.fail("a member name is expected");
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
-                this.skip();
+            const name = JSON.parse(spelled);
+            if (Object.hasOwn(held, name)) {
+                this.fail(`the member ${JSON.stringify(name)} is written twice, so neither value is chosen`, offset, name);
             }
-            const offset = this.at;
-            const name = this.string();
-            if (seen.has(name) && this.twice === undefined) {
-                this.twice = { name, offset };
+            this.expect(":", "a colon after the member name");
+            if (depth === 1 && this.path[0] === this.records) {
+                this.match(SPACE);
+                this.starts.set(name, this.at);
             }
-            seen.add(name);
-            this.skip();
+            this.path.push(name);
+            Object.defineProperty(held, name, {
+                value: this.value(depth + 1),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            this.path.pop();
+            this.match(SPACE);
+            const next = this.text[this.at];
             this.at += 1;
-            this.value(role === "document" && name === this.array ? "array" : "other");
+            if (next === "}") {
+                return held;
+            }
+            if (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing brace is expected");
+            }
         }
     }
-    list(element) {
+    array(depth) {
+        const held = [];
+        const records = depth === 1 && this.path[0] === this.records;
         this.at += 1;
+        this.match(SPACE);
+        if (this.text[this.at] === "]") {
+            this.at += 1;
+            return held;
+        }
         for (;;) {
-            this.skip();
-            if (this.text[this.at] === "]") {
-                this.at += 1;
-                return;
+            this.match(SPACE);
+            if (records) {
+                this.starts.set(held.length, this.at);
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
+            this.path.push(held.length);
+            held.push(this.value(depth + 1));
+            this.path.pop();
+            this.match(SPACE);
+            const next = this.text[this.at];
+            this.at += 1;
+            if (next === "]") {
+                return held;
+            }
+            if (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing bracket is expected");
             }
-            this.value(element);
         }
     }
 }
 /**
- * Walks a document `JSON.parse` accepted, whose top-level member `array` holds the
- * records. A member one object writes twice reads as though it were written once, its
- * later value silently replacing the earlier one, so a document holding one is one a
- * reader names rather than reads.
+ * Reads `text` as one strict JSON document, or throws a {@link StrictJSONError}.
+ * `records` names the top-level member whose values' offsets the read keeps.
  */
-export function walkDocument(text, array) {
-    const walk = new Walk(text, array);
-    walk.run();
-    return { starts: walk.starts, twice: walk.twice };
+export function readStrict(text, records) {
+    const reader = new Reader(text, records);
+    const value = reader.read();
+    return { value, fractions: reader.fractions, starts: reader.starts };
 }
 /**
  * One offset of a document as a finding carries it: the line counted from one, and the
@@ -111,3 +233,12 @@ export function positionAt(text, file, offset) {
     const lineStart = before.lastIndexOf("\n") + 1;
     return { path: file, line: before.split("\n").length, column: offset - lineStart + 1 };
 }
+/** A strict read's fault with the line and column it is at, as a refusal states it. */
+export function locatedFault(text, error) {
+    const { line, column } = positionAt(text, "", error.offset);
+    return `line ${String(line)}, column ${String(column)}: ${error.message}`;
+}
+/** Whether a decoded JSON value is an object: not `null` and not an array. */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/keyof-comparisons.js

@@ -4,11 +4,12 @@
  * that holds `keyof X`, the literal the other side has names the member of `X` under that
  * key, because deleting the member makes the comparison a type error.
  */
-import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isParenthesizedExpression, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The operators that compare their operands for equality. */
 const EQUALITIES = new Set([
     SyntaxKind.EqualsEqualsEqualsToken,
@@ -16,12 +17,9 @@ const EQUALITIES = new Set([
     SyntaxKind.EqualsEqualsToken,
     SyntaxKind.ExclamationEqualsToken,
 ]);
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** The name node an operand's symbol is read at: an identifier, or a property access's name. */
 function nameOf(node) {
-    const at = unwrapped(node);
+    const at = parenthesesRemoved(node);
     if (isIdentifier(at)) {
         return at;
     }
@@ -96,7 +94,7 @@ export function keyofComparisonReferences(project, held, chains, root, testFiles
     }
     const named = comparisons.flatMap((one) => {
         const name = nameOf(one.keyed);
-        return name === undefined || isElementAccessExpression(unwrapped(one.other))
+        return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
             ? []
             : [{ ...one, name }];
     });