madr-lint 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.4.2
+
+### Patch Changes
+
+- [#127](https://github.com/knktkc/madr-lint/pull/127) [`ac0883e`](https://github.com/knktkc/madr-lint/commit/ac0883e1b9c015cf328ea2d4e806c564cc42489f) Thanks [@knktkc](https://github.com/knktkc)! - Bypass gray-matter's content-keyed parse cache ([#122](https://github.com/knktkc/madr-lint/issues/122)). gray-matter 4.0.3 memoizes a parse only when it is called with no options, in a plain object keyed by the *whole document* (`matter.cache[content]`). Both parser call sites now pass a shared, frozen options object, which turns that memoization off.
+  
+  - **A document whose entire content is any `Object.prototype` member name (`constructor`, `toString`, `valueOf`, `__proto__`, …) no longer crashes.** Every one of those twelve lookups hit an inherited member, which gray-matter accepted as a cache hit and returned as a file with `content: undefined` — so `parseFile` threw `TypeError: Cannot convert undefined or null to object` and `frontmatterOffset` threw `TypeError: Cannot read properties of undefined (reading 'length')`. The throw escaped `lintFiles`, so `madr-lint docs/adr` on a directory holding such a file exited with a stack trace instead of reporting; it now reports the file's violations like any other. Only those exact bodies were affected — a trailing newline made the key an ordinary miss.
+  - **madr-lint no longer keeps every parsed document in memory.** The cache retained each document's full content for the process lifetime, as the key, the stripped body, and an `orig` Buffer. Measured over 1,000 distinct 8.4 KB documents: 16.9 MB retained before (8.9 MB heap + 8.0 MB buffers, about 2.1x the corpus), 0 MB now. Per-file lint throughput is unchanged (-1% to +3% across the rule benches, i.e. noise). `--fix` now performs a real second parse in `frontmatterOffset` where it previously got a memo hit — about +3 µs per file per pass, measured on this repo's own ADRs; correctness is unaffected.
+
+- [#134](https://github.com/knktkc/madr-lint/pull/134) [`7512968`](https://github.com/knktkc/madr-lint/commit/7512968fc1420e232bd60cb977b5f7cb091be5aa) Thanks [@knktkc](https://github.com/knktkc)! - Read the fields below a bullet-marker change in a MADR v2 metadata block ([#115](https://github.com/knktkc/madr-lint/issues/115)). `* Status: accepted` followed by `- Date: 2026/07/06` is two CommonMark lists with no node between them, so the HTML-comment bridge added for [#73](https://github.com/knktkc/madr-lint/issues/73) could not reach the second one and every field below the marker change vanished from metadata.
+  
+  - **A marker change no longer drops fields.** An adjacent list now joins the metadata block when *every* one of its items reads as a `Key: value` pair, so the `Date` above is parsed, keeps its own line number, is targetable by `madr-lint-disable-next-line`, and is repaired by `--fix` — instead of degrading a line-suppressible `invalidDate` into an unsuppressible file-level `missingDate`. The gate is shape, not marker: an ordered list (`1. Date: …`) after an unordered one merges on the same terms; a list with any non-`Key: value` item is prose and still ends the block, as do a paragraph, a code fence, a thematic break, a blockquote, a heading of any depth, and visible HTML.
+  - **`extractListMetadata` (public export) returns more keys for some documents.** The accepted cost of a shape-only gate is over-merging: a genuine prose list whose every bullet happens to read `Key: value` (`- Option A: do nothing`) is now merged into the block, so its keys appear in `listMetadata` / `metadata`. Merging can only add keys — duplicates still resolve first-wins, so an earlier field always shadows a later one and no document loses a key it had. The recognized-key gate (`status`, `date`, `deciders`, `decision-makers`, `consulted`, `informed`) is unchanged as a mechanism, but its outcome can change: a document whose only recognized key sits in the adjacent list now returns metadata where it previously returned `null` (which also lets `madr-lint init` cast a v2 version vote for it). Absorbed junk keys on their own never flip that gate.
+  - **Upgrading with a baseline**: a v2 field below a marker change was reported as a file-level `missingDate` / `missingStatus`; it is now reported as `invalidDate` / `invalidStatus` on the field's own line. If you baselined the old entry, re-run `madr-lint --update-baseline` — the stored entry no longer absorbs the new diagnostic, and the file goes red on an otherwise unchanged tree.
+
+- [#135](https://github.com/knktkc/madr-lint/pull/135) [`eba7822`](https://github.com/knktkc/madr-lint/commit/eba78224ea23a018b6d1102c5de4af1a114903ca) Thanks [@knktkc](https://github.com/knktkc)! - Resolve `madr-lint-disable-next-line` from the comment's last line ([#116](https://github.com/knktkc/madr-lint/issues/116)). A directive spelled as a multi-line `<!--` … `-->` block parsed correctly, but the suppression layer counted its target from the html node's **start** line, so it landed on the comment's own interior instead of the content below `-->`. Directives now carry the node's end line and count from there.
+  
+  - **A multi-line directive now reaches the line it points at.** Previously the diagnostic below `-->` was reported despite the directive — for the issue's document (a `disable-next-line madr/date-iso8601` split across three lines between two MADR v2 metadata items), `invalidDate` on the `* Date:` line was reported, not suppressed. A blank line between `-->` and the content is skipped, exactly as it is for a one-line directive.
+  - **Single-line directives are unchanged**: a one-line comment's end line *is* its start line, so nothing about the existing spelling moves. `disable` / `enable` ranges still open and close at the comment's **start** line, which is what preserves their pre-existing behavior. That choice is observable: an inline multi-line comment shares its start line with the content beside it — `[gone](./nope.md) <!--` … `-->` spans three lines while `madr/no-broken-links` reports the link on the first — so counting a range from the end line would stop such a `disable` from covering its own line.
+  - **The docs no longer ask you to keep a directive on one line.** The suppression guide (en/ja) and the `adopt-madr-lint` / `new-adr` skills previously called the multi-line spelling a miss; they now document it as working.
+
+- [#123](https://github.com/knktkc/madr-lint/pull/123) [`657e3ef`](https://github.com/knktkc/madr-lint/commit/657e3ef7ab641fc8055796d22c8303a2b931b4b0) Thanks [@knktkc](https://github.com/knktkc)! - Make filename- and document-derived record keys prototype-safe ([#56](https://github.com/knktkc/madr-lint/issues/56)). Both the cache manifest and the MADR v2 metadata parser accumulated untrusted keys on plain objects, where a key that names an `Object.prototype` member is read and written *through* the prototype instead of stored as data.
+  
+  - **Cache manifest keys are now prototype-safe.** `manifest.files` is a null-prototype map on both the cold path and rehydration, so a file whose relative path is `__proto__` caches, serializes, and cache-hits like any other. Previously the write went through the inherited `__proto__` setter — the entry never reached `manifest.json` and every run was a cold miss. No user-facing bug is fixed: the key is unreachable from the CLI (`findAdrFiles` drops every non-`.md` target, and a `__proto__.md` file keys as `__proto__.md`) and from the published API (`lintFiles` is not exported from `madr-lint`). This is hardening for the internal `lintFiles` seam and any future entry point that passes explicit paths. It was never a global pollution vector either: plain assignment swapped that one record's prototype rather than mutating `Object.prototype`. `saveManifest` output is byte-identical for ordinary keys, so existing manifests stay valid — no `CACHE_SCHEMA_VERSION` bump.
+  - **A v2 body-list key named `constructor` is now read.** The leading metadata block de-duplicates with `Object.hasOwn` instead of `in`, so `* Constructor: x` lands in `metadata.constructor` (with its body position and value offset) rather than being silently skipped because `'constructor' in {}` is true through inheritance. `constructor` is the only reachable case: key normalization lowercases, so `toString` arrives as `tostring` (not a member), and `__proto__` never matches the key pattern, which requires a leading letter. No rule reads these fields — the fix is for library consumers of `extractListMetadata` and `ParsedFile`, which previously got `Object` back for such a key. The returned records keep an ordinary prototype, so `hasOwnProperty` still works on them.
+  - **A frontmatter key named `__proto__` survives the v2 merge.** When a file carries both YAML frontmatter and a v2 body list, the merge step that drops explicit `null`/`undefined` now builds its record on a null prototype, so `__proto__: x` reaches `metadata.__proto__` as data instead of being swallowed by the inherited setter. The merged `metadata` is still a plain object.
+
+## 0.4.1
+
+### Patch Changes
+
+- [#114](https://github.com/knktkc/madr-lint/pull/114) [`e7d3a30`](https://github.com/knktkc/madr-lint/commit/e7d3a30fc84e0cbc4f2f76bcdc50a7681a38b8fc) Thanks [@knktkc](https://github.com/knktkc)! - Fix v2 metadata being silently dropped after an HTML comment ([#73](https://github.com/knktkc/madr-lint/issues/73)). A suppression comment placed _between_ MADR v2 metadata-list items splits the Markdown list in two (CommonMark), and the v2 bridge previously read only the first segment — so a field below the comment vanished from `context.metadata`, turning a line-suppressible `invalidDate` into an unsuppressible file-level `missingDate`. Suppressing was strictly worse than not suppressing.
+
+  - **The v2 metadata block is now the leading run of lists joined across HTML comments.** A comment renders as nothing, so it can no longer end the block. A key below a comment now behaves exactly like one above it: it keeps its own body line, so `<!-- madr-lint-disable-next-line madr/date-iso8601 -->` between items reaches the field below it, and it carries the same value offsets, so — with no directive above it — `--fix` rewrites that field in place (`madr/status-enum`, `madr/date-iso8601`). Not both: `--fix` never rewrites a suppressed problem. Blank lines around the comment do not matter — `disable-next-line` already targets the next non-blank line.
+  - **Only comments bridge.** Visible HTML (`<div>`, `<details>`, or a node like `<!-- a --> visible` that is not purely a comment), a paragraph, a code fence, a thematic break, a blockquote, and a heading of any depth all still end the metadata block — it must lead. Two lists with no comment between them (a bullet-marker change, `* Status:` then `- Date:`) are still two lists, and the second is still not metadata.
+  - **Public API**: `extractListMetadata` now reads list segments separated only by HTML comments. The signature is unchanged and the change is additive — merging can only add keys (duplicate keys still resolve first-wins), so it never returns fewer than before. Two consequences worth knowing: a document whose recognized MADR key sits only in a later segment now returns metadata where it previously returned `null` (which also lets `madr-lint init` cast a v2 version vote for it), and a prose list placed after the metadata block with only a comment between them, before the next heading of any depth, can contribute an extra key.
+  - **Upgrading with a baseline**: a v2 field hidden by this bug was reported as a file-level `missingDate` / `missingStatus`; it is now reported as `invalidDate` / `invalidStatus` on the field's own line. If you baselined the old entry, re-run `madr-lint --update-baseline` — the stored entry no longer absorbs the new diagnostic, and the file goes red on an otherwise unchanged tree.
+  - **Not fixed here**: a directive written as a multi-line `<!--` … `-->` block still resolves to its own second line, so keep `disable-next-line` on a single line. `<div>`-style HTML on the line directly above a metadata item swallows that line into the HTML block, so the item never reaches the AST at all.
+
 ## 0.4.0
 
 ### Minor Changes

package/README.md

@@ -31,12 +31,12 @@ A fast, configurable linter for [MADR](https://adr.github.io/madr/) (Markdown Ar
 
 [MADR](https://github.com/adr/madr) ships no official linter, and the general-purpose tools each cover only part of what an ADR collection needs:
 
-| Tool | Markdown style | Inter-doc links | ADR numbering | Status enum | Date format | Supersedes graph | v2 bold-list |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [markdownlint-cli2](https://github.com/DavidAnson/markdownlint-cli2) | ✅ | — | — | — | — | — | n/a |
-| [lychee](https://github.com/lycheeverse/lychee) | — | ✅ | — | — | — | — | n/a |
-| [adrs (rust)](https://crates.io/crates/adrs) | — | — | ✅ (init) | — | — | ~ | — |
-| **madr-lint** | —¹ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Tool | Markdown style | Inter-doc links | ADR numbering | Status enum | Date format | Supersedes graph | v2 bold-list | Autofix |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [markdownlint-cli2](https://github.com/DavidAnson/markdownlint-cli2) | ✅ | — | — | — | — | — | n/a | ✅ |
+| [lychee](https://github.com/lycheeverse/lychee) | — | ✅ | — | — | — | — | n/a | — |
+| [adrs (rust)](https://crates.io/crates/adrs) | — | — | ✅ (init) | — | — | ~ | — | — |
+| **madr-lint** | —¹ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ~ (3/8 rules) |
 
 ¹ Deliberately *not* Markdown style — pair it with `markdownlint-cli2` if you want both. `madr-lint` owns the ADR-specific semantics.
 
@@ -44,6 +44,7 @@ A fast, configurable linter for [MADR](https://adr.github.io/madr/) (Markdown Ar
 - **ESLint-style rules** — named `madr/*` rules with `error` / `warn` / `off` and per-rule options validated by a JSON Schema.
 - **Per-file & cross-file** — fast single-pass checks plus project rules for unique numbering, the supersedes graph, and link rot.
 - **CLI, library & CI** — `text` / `json` / `sarif` / `github` reporters, a programmatic API, and a drop-in GitHub Actions step.
+- **Autofix** — `--fix` / `--fix-dry-run` mechanically repair the violations that have a safe, unambiguous correction (3 of 8 rules today); everything else still reports with a `suggestion`.
 - **Gradual adoption** — [inline suppression comments](https://knktkc.github.io/madr-lint/guides/suppressing-rules/) for one-off exceptions and a [baseline file](https://knktkc.github.io/madr-lint/guides/adopting-existing-repo/) to snapshot legacy debt so only new violations fail the build.
 
 ## Install
@@ -57,9 +58,15 @@ Node.js 22+. ESM-only. Ships TypeScript types.
 ## Quick start
 
 ```bash
+# Scaffold a config — detects your ADR directory and MADR version
+npx madr-lint init
+
 # Lint the configured adrDir (default: docs/adr)
 npx madr-lint
 
+# Auto-repair what's mechanically fixable, then re-lint
+npx madr-lint --fix
+
 # Explicit paths (files or directories; directories are searched recursively)
 npx madr-lint docs/adr libs/x/adr
 
@@ -92,17 +99,17 @@ Rule values are a severity (`'error' | 'warn' | 'off'`) or a `[severity, options
 
 ## Rules
 
-8 rules — 7 enabled by `recommended`, 1 opt-in. Each page documents its options, examples, and MADR-version compatibility.
+8 rules — 7 enabled by `recommended`, 1 opt-in. 🔧 marks the 3 rules `--fix` can repair. Each page documents its options, examples, and MADR-version compatibility.
 
 | Rule | Type | Default | Checks |
 |---|---|:---:|---|
 | [`madr/required-sections`](https://knktkc.github.io/madr-lint/rules/required-sections/) | per-file | `error` | Required heading sections are present |
-| [`madr/status-enum`](https://knktkc.github.io/madr-lint/rules/status-enum/) | per-file | `error` | `status` is one of the allowed values |
-| [`madr/date-iso8601`](https://knktkc.github.io/madr-lint/rules/date-iso8601/) | per-file | `error` | `date` is a valid ISO-8601 calendar date |
+| [`madr/status-enum`](https://knktkc.github.io/madr-lint/rules/status-enum/) 🔧 | per-file | `error` | `status` is one of the allowed values |
+| [`madr/date-iso8601`](https://knktkc.github.io/madr-lint/rules/date-iso8601/) 🔧 | per-file | `error` | `date` is a valid ISO-8601 calendar date |
 | [`madr/filename-format`](https://knktkc.github.io/madr-lint/rules/filename-format/) | per-file | `error` | Filename matches the ADR convention |
 | [`madr/no-broken-links`](https://knktkc.github.io/madr-lint/rules/no-broken-links/) | project | `error` | Relative links resolve to existing files |
 | [`madr/no-duplicate-numbering`](https://knktkc.github.io/madr-lint/rules/no-duplicate-numbering/) | project | `error` | ADR numbers are unique |
-| [`madr/supersedes-bidirectional`](https://knktkc.github.io/madr-lint/rules/supersedes-bidirectional/) | project | `error` | `supersedes` / `superseded-by` agree |
+| [`madr/supersedes-bidirectional`](https://knktkc.github.io/madr-lint/rules/supersedes-bidirectional/) 🔧 | project | `error` | `supersedes` / `superseded-by` agree |
 | [`madr/no-numbering-gap`](https://knktkc.github.io/madr-lint/rules/no-numbering-gap/) | project | `off` | ADR numbers are contiguous (opt-in) |
 
 ## Use in CI
@@ -125,7 +132,7 @@ jobs:
 ```
 
 > The floating `v0` tag tracks the latest v0.x release; for stricter
-> reproducibility, pin an exact tag like `@v0.3.0`.
+> reproducibility, pin an exact tag like `@v0.4.0`.
 
 Or run it via `npx` in any CI provider:
 

package/dist/cli.js

@@ -130,11 +130,19 @@ import { join as join2, resolve as resolve2 } from "path";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toString } from "mdast-util-to-string";
 import grayMatter from "gray-matter";
+
+// src/core/null-proto-map.ts
+function nullProtoMap() {
+  return /* @__PURE__ */ Object.create(null);
+}
+
+// src/core/parser.ts
+var GRAY_MATTER_OPTIONS = Object.freeze({});
 function frontmatterOffset(content) {
-  return content.length - grayMatter(content).content.length;
+  return content.length - grayMatter(content, GRAY_MATTER_OPTIONS).content.length;
 }
 function parseFile(content) {
-  const matter = grayMatter(content);
+  const matter = grayMatter(content, GRAY_MATTER_OPTIONS);
   const data = matter.data;
   const frontmatter = Object.keys(data).length > 0 ? data : null;
   const ast = fromMarkdown(matter.content);
@@ -144,7 +152,7 @@ function parseFile(content) {
   let metadataLoc = listResult && Object.keys(listResult.loc).length > 0 ? { ...listResult.loc } : null;
   let metadataValueLoc = listResult && Object.keys(listResult.valueOffsets).length > 0 ? { ...listResult.valueOffsets } : null;
   if (frontmatter && listMetadata) {
-    const frontmatterDefined = {};
+    const frontmatterDefined = nullProtoMap();
     for (const [k, v] of Object.entries(frontmatter)) {
       if (v !== null && v !== void 0) frontmatterDefined[k] = v;
     }
@@ -180,39 +188,65 @@ var RECOGNIZED_METADATA_KEYS = /* @__PURE__ */ new Set([
   "consulted",
   "informed"
 ]);
+function isHtmlComment(value) {
+  let rest = value.trim();
+  if (rest.length === 0) return false;
+  while (rest.length > 0) {
+    if (!rest.startsWith("<!--")) return false;
+    const end = rest.indexOf("-->", 2);
+    if (end === -1) return false;
+    rest = rest.slice(end + 3).trim();
+  }
+  return true;
+}
 function extractListMetadataWithLoc(ast, body) {
-  let firstList = null;
+  const segments = [];
+  let bridged = false;
   for (const child of ast.children) {
-    if (child.type === "heading") {
-      if (child.depth >= 2) break;
+    if (segments.length === 0) {
+      if (child.type === "heading") {
+        if (child.depth >= 2) break;
+        continue;
+      }
+      if (child.type === "html") continue;
+      if (child.type === "list") {
+        segments.push(child);
+        continue;
+      }
+      break;
+    }
+    if (child.type === "html" && isHtmlComment(child.value)) {
+      bridged = true;
       continue;
     }
-    if (child.type === "html") continue;
-    if (child.type === "list") {
-      firstList = child;
-      break;
+    if (child.type === "list" && (bridged || child.children.length > 0 && child.children.every((item) => extractListItemKV(item)))) {
+      segments.push(child);
+      bridged = false;
+      continue;
     }
     break;
   }
-  if (!firstList) return null;
-  const values = {};
-  const loc = {};
-  const valueOffsets = {};
-  for (const item of firstList.children) {
-    const pair = extractListItemKV(item);
-    if (pair && !(pair.key in values)) {
-      values[pair.key] = pair.value;
-      const start = item.position?.start;
-      if (start) loc[pair.key] = { line: start.line, column: start.column };
-      if (body !== void 0 && pair.valueOffset && body.slice(pair.valueOffset.start, pair.valueOffset.end) === pair.value) {
-        valueOffsets[pair.key] = pair.valueOffset;
+  if (segments.length === 0) return null;
+  const values = nullProtoMap();
+  const loc = nullProtoMap();
+  const valueOffsets = nullProtoMap();
+  for (const list of segments) {
+    for (const item of list.children) {
+      const pair = extractListItemKV(item);
+      if (pair && !Object.hasOwn(values, pair.key)) {
+        values[pair.key] = pair.value;
+        const start = item.position?.start;
+        if (start) loc[pair.key] = { line: start.line, column: start.column };
+        if (body !== void 0 && pair.valueOffset && body.slice(pair.valueOffset.start, pair.valueOffset.end) === pair.value) {
+          valueOffsets[pair.key] = pair.valueOffset;
+        }
       }
     }
   }
   const hasRecognizedKey = Object.keys(values).some(
     (k) => RECOGNIZED_METADATA_KEYS.has(k)
   );
-  return hasRecognizedKey ? { values, loc, valueOffsets } : null;
+  return hasRecognizedKey ? { values: { ...values }, loc, valueOffsets } : null;
 }
 var KEY_PATTERN = /^[A-Za-z][A-Za-z0-9 \-_]*$/;
 var SEPARATOR_PATTERN = /^\s*:\s*/;
@@ -419,9 +453,6 @@ var BASELINE_DISPLAY_PATH = ".madr-lint/baseline.json";
 function baselinePath(cwd) {
   return join3(cwd, ".madr-lint", "baseline.json");
 }
-function nullProtoMap() {
-  return /* @__PURE__ */ Object.create(null);
-}
 function buildBaseline(diagnostics) {
   const entries = nullProtoMap();
   for (const d of diagnostics) {
@@ -579,7 +610,13 @@ function loadManifest(path) {
     ) {
       return null;
     }
-    return data;
+    const files = nullProtoMap();
+    for (const [key, entry] of Object.entries(
+      data.files
+    )) {
+      files[key] = entry;
+    }
+    return { ...data, files };
   } catch {
     return null;
   }
@@ -786,7 +823,7 @@ var DIRECTIVE_KINDS = /* @__PURE__ */ new Set([
   "disable-next-line"
 ]);
 var DIRECTIVE_PREFIX = "madr-lint-";
-function parseDirective(value, line) {
+function parseDirective(value, line, endLine) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("<!--") || !trimmed.endsWith("-->")) return null;
   const inner = trimmed.slice(4, -3).trim();
@@ -797,7 +834,12 @@ function parseDirective(value, line) {
   const keyword = wsIndex === -1 ? afterPrefix : afterPrefix.slice(0, wsIndex);
   if (!DIRECTIVE_KINDS.has(keyword)) return null;
   const rest = wsIndex === -1 ? "" : afterPrefix.slice(wsIndex);
-  return { kind: keyword, rules: parseRuleList(rest), line };
+  return {
+    kind: keyword,
+    rules: parseRuleList(rest),
+    line,
+    endLine
+  };
 }
 function parseRuleList(rest) {
   const trimmed = rest.trim();
@@ -808,8 +850,9 @@ function parseRuleList(rest) {
 function walkHtml(node, out) {
   if (node.type === "html") {
     const line = node.position?.start.line;
-    if (typeof line === "number") {
-      const directive = parseDirective(node.value, line);
+    const endLine = node.position?.end.line;
+    if (typeof line === "number" && typeof endLine === "number") {
+      const directive = parseDirective(node.value, line, endLine);
       if (directive) out.push(directive);
     }
   }
@@ -848,7 +891,7 @@ function collectDirectives(ast, body) {
         break;
       }
       case "disable-next-line": {
-        const target = nextNonBlankLine(directive.line);
+        const target = nextNonBlankLine(directive.endLine);
         if (target === null) break;
         let entry = index.nextLine.get(target);
         if (!entry) {
@@ -1160,7 +1203,7 @@ function lintFiles(opts) {
         schemaVersion: CACHE_SCHEMA_VERSION,
         version: opts.cache.pkgVersion,
         configHash: opts.cache.configHash,
-        files: {}
+        files: nullProtoMap()
       };
     }
   }