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

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;
+        this.records = records;
     }
-    run() {
-        this.value("document");
-    }
-    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);
+            }
+            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 (this.text[this.at] === ",") {
-                this.at += 1;
+            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,6 +233,11 @@ 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/kinds.js

@@ -1,12 +1,5 @@
 import { KIND_ROWS } from "./contract/contract.generated.js";
 /** Every live row of the issue-kind vocabulary, by its code, in ascending code order. */
 export const KINDS = new Map(KIND_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.
- */
-export const LIVE_CODES = KIND_ROWS.map((one) => one.code);
 /** The issue-kind codes whose severity the Contract fixes, in ascending order. */
 export const FIXED_SEVERITY_CODES = KIND_ROWS.filter((one) => one.fixed).map((one) => one.code);

package/dist/src/print.js

@@ -1,84 +1,15 @@
-import { renderOrigin, } from "./config.js";
+import { renderOrigin } from "./config.js";
 import { bytewise } from "./text/compare.js";
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return { symbol: entry.symbol };
-        case "module":
-            return { module: entry.module, name: entry.name };
-        case "global":
-            return { global: entry.global };
-    }
-}
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry) {
-    const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-    if (entry.shape === "installed") {
-        return installed;
-    }
-    return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
 export function printConfig(config, provenance) {
-    const document = {
-        contract_version: config.contractVersion,
-        target: { kind: config.targetKind },
-        analysis: {
-            languages: config.analysis.languages,
-            min_confidence: config.analysis.minConfidence,
-            generated_files: config.analysis.generatedFiles,
-            consumer_tests: config.analysis.consumerTests,
-            configurations: config.analysis.configurations.map((entry) => entry.shape === "project"
-                ? { id: entry.id, project: entry.project }
-                : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags }),
-            matrix: { complete: config.analysis.matrixComplete },
-            template_dirs: config.analysis.templateDirs,
-            template_delimiters: {
-                left: config.analysis.templateDelimiters.left,
-                right: config.analysis.templateDelimiters.right,
-            },
-        },
-        consumers: { complete: config.consumersComplete },
-        roots: { patterns: config.rootPatterns },
-        severity: Object.fromEntries([...config.severity].sort(([a], [b]) => bytewise(a, b))),
-        exemptions: { disabled: config.exemptionsDisabled },
-        reporters: {
-            formats: config.reporters.formats,
-            sort: config.reporters.sort,
-            cascade: config.reporters.cascade,
-            max_findings: config.reporters.maxFindings,
-            fail_on: config.reporters.failOn,
-        },
-        providers: { analyzers: config.providers.analyzers.map(providerOf) },
-        go: {},
-        ts: {
-            test_files: config.ts.testFiles,
-            entry_files: config.ts.entryFiles,
-            component_extensions: config.ts.componentExtensions,
-            disabled_conventions: config.ts.disabledConventions,
-            injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-            lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-                components: entry.components.map(declarationOf),
-                bases: entry.bases.map(declarationOf),
-                members: entry.members,
-            })),
-            serializers: config.ts.serializers.map(declarationOf),
-            roots_complete: config.ts.rootsComplete,
-        },
-        provenance: Object.fromEntries([...provenance]
-            .sort(([a], [b]) => bytewise(a, b))
-            .map(([path, origin]) => [path, renderOrigin(origin)])),
-    };
-    return `${JSON.stringify(document, undefined, 2)}\n`;
+    const origins = [...provenance]
+        .sort(([a], [b]) => bytewise(a, b))
+        .map(([path, origin]) => [path, renderOrigin(origin)]);
+    return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }

package/dist/src/report-schema.js

@@ -1,231 +1,10 @@
 /**
  * Holds a report to `contract/report.schema.json` and `contract/finding.schema.json`
  * before it is written, reading the schemas the generator copies from the Contract, so
- * this analyzer never writes a document a reader refuses. It evaluates the keywords the
- * Contract's schemas use; the schemas' patterns are written to match alike in RE2 and in
- * ECMAScript.
+ * this analyzer never writes a document a reader refuses.
  */
 import { REPORT_SCHEMAS } from "./contract/report.generated.js";
-import { bytewise } from "./text/compare.js";
-import { isRecord } from "./json-document.js";
-/**
- * Every keyword the validator evaluates or knows to carry no assertion. A schema naming
- * another fails every check rather than passing values the keyword would refuse.
- */
-const KEYWORDS = new Set([
-    ...["$schema", "$id", "$comment", "$defs", "title", "description", "default", "examples"],
-    ...["$ref", "type", "enum", "const", "pattern", "minLength", "minimum", "maximum"],
-    ...["properties", "additionalProperties", "required", "minProperties"],
-    ...["items", "minItems", "maxItems", "uniqueItems"],
-    ...["allOf", "anyOf", "oneOf", "not", "if", "then", "else"],
-]);
-const patterns = new Map();
-function pattern(source) {
-    let held = patterns.get(source);
-    if (held === undefined) {
-        held = new RegExp(source, "u");
-        patterns.set(source, held);
-    }
-    return held;
-}
-function typeOf(value) {
-    if (value === null) {
-        return "null";
-    }
-    if (Array.isArray(value)) {
-        return "array";
-    }
-    if (typeof value === "number") {
-        return Number.isInteger(value) ? "integer" : "number";
-    }
-    return typeof value;
-}
-function hasType(value, name) {
-    const held = typeOf(value);
-    return held === name || (name === "number" && held === "integer");
-}
-/** One value's encoding with object members sorted, so two equal values encode alike. */
-function canonical(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(canonical).join(",")}]`;
-    }
-    if (isRecord(value)) {
-        return `{${Object.keys(value)
-            .sort(bytewise)
-            .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
-            .join(",")}}`;
-    }
-    return JSON.stringify(value);
-}
-/** A string's length in code points, which JSON Schema's minLength counts. */
-function codePoints(value) {
-    let counted = 0;
-    for (const _point of value) {
-        counted += 1;
-    }
-    return counted;
-}
-const escape = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
-/** A schema evaluated in the document it is read from, so a relative `$ref` resolves there. */
-class Checker {
-    documents;
-    constructor(documents) {
-        this.documents = documents;
-    }
-    resolve(doc, ref) {
-        const [file = "", pointer = ""] = ref.split("#");
-        const target = file === "" ? doc : file;
-        let schema = this.documents[target];
-        for (const token of pointer.split("/").filter((one) => one !== "")) {
-            schema = isRecord(schema)
-                ? schema[token.replaceAll("~1", "/").replaceAll("~0", "~")]
-                : undefined;
-        }
-        if (!isRecord(schema)) {
-            throw new Error(`report schema: ${ref} names no schema`);
-        }
-        return [target, schema];
-    }
-    matches(doc, schema, value, at) {
-        const found = [];
-        this.check(doc, schema, value, at, found);
-        return found.length === 0;
-    }
-    check(doc, schema, value, at, found) {
-        for (const keyword of Object.keys(schema)) {
-            if (!KEYWORDS.has(keyword) && !keyword.startsWith("x-")) {
-                throw new Error(`report schema: the keyword ${keyword} is not one this validator evaluates`);
-            }
-        }
-        const refuse = (keyword, reason, pointer = at) => {
-            found.push({ pointer, keyword, reason });
-        };
-        if (typeof schema["$ref"] === "string") {
-            const [target, referenced] = this.resolve(doc, schema["$ref"]);
-            this.check(target, referenced, value, at, found);
-        }
-        const types = schema["type"];
-        const named = types === undefined ? [] : Array.isArray(types) ? types : [types];
-        if (named.length > 0 && !named.some((one) => hasType(value, String(one)))) {
-            refuse("type", `the value is ${typeOf(value)}, want ${named.join(", ")}`);
-            return;
-        }
-        this.checkValue(schema, value, refuse);
-        if (Array.isArray(value)) {
-            this.checkArray(doc, schema, value, at, found, refuse);
-        }
-        else if (isRecord(value)) {
-            this.checkObject(doc, schema, value, at, found, refuse);
-        }
-        this.checkApplicators(doc, schema, value, at, found, refuse);
-    }
-    checkValue(schema, value, refuse) {
-        const values = schema["enum"];
-        if (Array.isArray(values) && !values.some((one) => canonical(one) === canonical(value))) {
-            refuse("enum", `${canonical(value)} is not one of the values the schema lists`);
-        }
-        if (schema["const"] !== undefined && canonical(schema["const"]) !== canonical(value)) {
-            refuse("const", `${canonical(value)} is not ${canonical(schema["const"])}`);
-        }
-        if (typeof value === "string") {
-            if (typeof schema["pattern"] === "string" && !pattern(schema["pattern"]).test(value)) {
-                refuse("pattern", `${JSON.stringify(value)} does not match ${schema["pattern"]}`);
-            }
-            if (typeof schema["minLength"] === "number" && codePoints(value) < schema["minLength"]) {
-                refuse("minLength", `${JSON.stringify(value)} is shorter than ${String(schema["minLength"])} characters`);
-            }
-        }
-        if (typeof value === "number") {
-            if (typeof schema["minimum"] === "number" && value < schema["minimum"]) {
-                refuse("minimum", `${String(value)} is below ${String(schema["minimum"])}`);
-            }
-            if (typeof schema["maximum"] === "number" && value > schema["maximum"]) {
-                refuse("maximum", `${String(value)} is above ${String(schema["maximum"])}`);
-            }
-        }
-    }
-    checkObject(doc, schema, value, at, found, refuse) {
-        const properties = isRecord(schema["properties"]) ? schema["properties"] : {};
-        const additional = schema["additionalProperties"];
-        for (const name of Object.keys(value).sort(bytewise)) {
-            const member = `${at}/${escape(name)}`;
-            const declared = properties[name];
-            if (isRecord(declared)) {
-                this.check(doc, declared, value[name], member, found);
-            }
-            else if (additional === false) {
-                refuse("additionalProperties", `the member ${JSON.stringify(name)} is not one the schema declares`);
-            }
-            else if (isRecord(additional)) {
-                this.check(doc, additional, value[name], member, found);
-            }
-        }
-        for (const name of Array.isArray(schema["required"]) ? schema["required"] : []) {
-            if (!Object.hasOwn(value, name)) {
-                refuse("required", `the member ${JSON.stringify(name)} is absent`);
-            }
-        }
-        const fewest = schema["minProperties"];
-        if (typeof fewest === "number" && Object.keys(value).length < fewest) {
-            refuse("minProperties", `the object holds ${String(Object.keys(value).length)} members, fewer than ${String(fewest)}`);
-        }
-    }
-    checkArray(doc, schema, value, at, found, refuse) {
-        const items = schema["items"];
-        if (isRecord(items)) {
-            value.forEach((item, i) => {
-                this.check(doc, items, item, `${at}/${String(i)}`, found);
-            });
-        }
-        if (typeof schema["minItems"] === "number" && value.length < schema["minItems"]) {
-            refuse("minItems", `the array holds ${String(value.length)} items, fewer than ${String(schema["minItems"])}`);
-        }
-        if (typeof schema["maxItems"] === "number" && value.length > schema["maxItems"]) {
-            refuse("maxItems", `the array holds ${String(value.length)} items, more than ${String(schema["maxItems"])}`);
-        }
-        if (schema["uniqueItems"] === true && new Set(value.map(canonical)).size !== value.length) {
-            refuse("uniqueItems", "the array lists one value twice");
-        }
-    }
-    checkApplicators(doc, schema, value, at, found, refuse) {
-        const list = (keyword) => Array.isArray(schema[keyword]) ? schema[keyword] : [];
-        for (const each of list("allOf")) {
-            this.check(doc, each, value, at, found);
-        }
-        const matching = (keyword) => list(keyword).filter((each) => this.matches(doc, each, value, at)).length;
-        if (schema["anyOf"] !== undefined && matching("anyOf") === 0) {
-            refuse("anyOf", "the value matches none of the alternatives");
-        }
-        if (schema["oneOf"] !== undefined && matching("oneOf") !== 1) {
-            refuse("oneOf", `the value matches ${String(matching("oneOf"))} of the alternatives, want exactly one`);
-        }
-        if (isRecord(schema["not"]) && this.matches(doc, schema["not"], value, at)) {
-            refuse("not", "the value matches a schema it must not match");
-        }
-        if (isRecord(schema["if"])) {
-            const branch = this.matches(doc, schema["if"], value, at) ? schema["then"] : schema["else"];
-            if (isRecord(branch)) {
-                this.check(doc, branch, value, at, found);
-            }
-        }
-    }
-}
-/**
- * A validator over one set of schema documents, each named as a `$ref` names it, rooted
- * at one of them: what it refuses in a value, none for an instance.
- */
-export function schemaRefusals(documents, root) {
-    const checker = new Checker(documents);
-    const top = documents[root];
-    if (top === undefined) {
-        throw new Error(`the schema set holds no document ${root}`);
-    }
-    return (value) => {
-        const found = [];
-        checker.check(root, top, value, "", found);
-        return found;
-    };
-}
+import { schemaRefusals } from "./schema.js";
 const reportSchema = schemaRefusals(REPORT_SCHEMAS, "report.schema.json");
 /**
  * What the report schema refuses in one report document, none for an instance, and, as
@@ -242,7 +21,7 @@ function listingRefusals(report) {
         return [];
     }
     const refuse = (pointer, reason) => [
-        { pointer, keyword: "components", reason },
+        { pointer, keyword: "components", reason, member: "" },
     ];
     const listed = new Set();
     for (const [i, entry] of report.components.entries()) {