@lh8ppl/claude-memory-kit 0.1.0 → 0.1.1

package/src/claude-md.mjs

@@ -1,212 +1,212 @@
-// claude-md.mjs — managed-block injection into the target project's CLAUDE.md.
-//
-// Public contract (tests assert this; internals can change freely):
-//
-//   injectClaudeMdBlock({
-//     projectRoot,   // <repo> root
-//     content,       // body of the block (without markers)
-//     version,       // kit version string, e.g. "0.1.0"
-//     force,         // allow downgrade (replace newer block with older)
-//   }) → {
-//     action:   'created'              // no CLAUDE.md before; one was created
-//             | 'appended'             // CLAUDE.md existed without our markers; block appended at EOF
-//             | 'replaced'             // same-version block content updated in place
-//             | 'upgraded'             // older-version block replaced (kit version is newer)
-//             | 'downgrade-blocked'    // newer-version block present and force not set
-//             | 'forced-downgrade'     // newer-version block replaced because force=true
-//             | 'unchanged',           // existing block content + version match the inputs exactly
-//     path:        string,             // absolute path to the CLAUDE.md
-//     oldVersion?: string,             // version of the block we replaced (when applicable)
-//   }
-//
-//   removeClaudeMdBlock({ projectRoot }) → {
-//     action:   'removed'              // managed block found + stripped
-//             | 'not-found'            // file exists but no managed markers
-//             | 'no-file',             // CLAUDE.md does not exist
-//     path:        string,
-//   }
-//
-// Design notes:
-//   - Deep module: the two boundary functions above are the only public
-//     surface. Internal helpers parse markers, compare versions, and
-//     splice the block — all private.
-//   - Markers wrap the kit-managed content. Everything outside markers is
-//     byte-preserved across inject + remove. This is what makes the
-//     installer safe to re-run.
-//   - Version comparison is semver-style (MAJOR.MINOR.PATCH). Prerelease
-//     suffixes (-dev, -alpha.1) are ignored when comparing.
-//   - Marker pattern is intentionally the same shape as the .gitignore
-//     marker pattern in install.mjs — same idea, same conventions.
-
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs';
-import { join } from 'node:path';
-
-const MARKER_START_RE =
-  /<!--\s*claude-memory-kit:start\s+v([\d.]+(?:-[\w.]+)?)\s*-->/;
-const MARKER_END_RE = /<!--\s*claude-memory-kit:end\s*-->/;
-
-/**
- * Wrap a content string with kit markers at the given version.
- */
-function buildBlock(content, version) {
-  return `<!-- claude-memory-kit:start v${version} -->\n${content.trim()}\n<!-- claude-memory-kit:end -->`;
-}
-
-/**
- * Find the start + end marker positions in the source text.
- *   - Returns null when no start marker is present (no managed block).
- *   - When a start marker is present but the end marker is missing or
- *     misplaced, treats the block as extending to EOF. This recovers
- *     gracefully from a corrupted block (e.g. the user accidentally
- *     deleted the end marker by hand).
- */
-function findManagedBlock(text) {
-  const startMatch = text.match(MARKER_START_RE);
-  if (!startMatch) return null;
-
-  const endMatch = text.match(MARKER_END_RE);
-  if (endMatch && startMatch.index < endMatch.index) {
-    return {
-      startIdx: startMatch.index,
-      endIdx: endMatch.index + endMatch[0].length,
-      version: startMatch[1],
-      fullText: text.slice(startMatch.index, endMatch.index + endMatch[0].length),
-      corrupted: false,
-    };
-  }
-
-  // Orphan start marker → treat the block as extending to EOF so we
-  // can replace it cleanly on the next install.
-  return {
-    startIdx: startMatch.index,
-    endIdx: text.length,
-    version: startMatch[1],
-    fullText: text.slice(startMatch.index),
-    corrupted: true,
-  };
-}
-
-/**
- * Strip trailing -prerelease, parse MAJOR.MINOR.PATCH integers.
- * Tolerates partial versions ("0.1" → [0,1,0]).
- */
-function parseVersion(v) {
-  const base = String(v).replace(/^v/, '').split('-')[0];
-  const parts = base.split('.').map((n) => parseInt(n, 10) || 0);
-  while (parts.length < 3) parts.push(0);
-  return parts.slice(0, 3);
-}
-
-/**
- * Semver-style comparator. Returns -1 / 0 / 1.
- *   compareVersions('0.1.0', '0.2.0') === -1
- *   compareVersions('1.0.0', '1.0.0') === 0
- *   compareVersions('2.0.0', '1.9.9') === 1
- */
-function compareVersions(a, b) {
-  const av = parseVersion(a);
-  const bv = parseVersion(b);
-  for (let i = 0; i < 3; i++) {
-    if (av[i] < bv[i]) return -1;
-    if (av[i] > bv[i]) return 1;
-  }
-  return 0;
-}
-
-export function injectClaudeMdBlock(opts = {}) {
-  const projectRoot = opts.projectRoot;
-  const content = String(opts.content || '');
-  const version = String(opts.version || '0.0.0');
-  const force = !!opts.force;
-  if (!projectRoot) throw new Error('injectClaudeMdBlock: projectRoot is required');
-
-  const claudeMdPath = join(projectRoot, 'CLAUDE.md');
-  const newBlock = buildBlock(content, version);
-
-  // Case 1 — no CLAUDE.md
-  if (!existsSync(claudeMdPath)) {
-    writeFileSync(claudeMdPath, newBlock + '\n', 'utf8');
-    return { action: 'created', path: claudeMdPath };
-  }
-
-  const existing = readFileSync(claudeMdPath, 'utf8');
-  const found = findManagedBlock(existing);
-
-  // Case 2 — file exists but no (or corrupted) managed block → append
-  if (!found) {
-    // If the file ends without a newline, add one before the block for
-    // readability. Trim trailing whitespace so we don't accumulate blank
-    // lines on repeated installs.
-    const sep = existing.endsWith('\n') ? '\n' : '\n\n';
-    writeFileSync(claudeMdPath, existing.replace(/\s+$/, '') + sep + newBlock + '\n', 'utf8');
-    return { action: 'appended', path: claudeMdPath };
-  }
-
-  // Case 3 — managed block present. Compare versions to choose action.
-  const cmp = compareVersions(version, found.version);
-  const before = existing.slice(0, found.startIdx);
-  const after = existing.slice(found.endIdx);
-
-  let action;
-  if (cmp === 0) {
-    if (found.fullText === newBlock) {
-      return { action: 'unchanged', path: claudeMdPath, oldVersion: found.version };
-    }
-    action = 'replaced';
-  } else if (cmp > 0) {
-    action = 'upgraded';
-  } else {
-    // cmp < 0 → incoming version is older than installed
-    if (!force) {
-      return {
-        action: 'downgrade-blocked',
-        path: claudeMdPath,
-        oldVersion: found.version,
-      };
-    }
-    action = 'forced-downgrade';
-  }
-
-  writeFileSync(claudeMdPath, before + newBlock + after, 'utf8');
-  return { action, path: claudeMdPath, oldVersion: found.version };
-}
-
-export function removeClaudeMdBlock(opts = {}) {
-  const projectRoot = opts.projectRoot;
-  if (!projectRoot) throw new Error('removeClaudeMdBlock: projectRoot is required');
-
-  const claudeMdPath = join(projectRoot, 'CLAUDE.md');
-
-  if (!existsSync(claudeMdPath)) {
-    return { action: 'no-file', path: claudeMdPath };
-  }
-
-  const existing = readFileSync(claudeMdPath, 'utf8');
-  const found = findManagedBlock(existing);
-
-  if (!found) {
-    return { action: 'not-found', path: claudeMdPath };
-  }
-
-  // Strip the block. If the block was followed by exactly one trailing
-  // newline (the one we wrote at injection time), strip it too so the
-  // surrounding content stays clean. We do NOT touch newlines that exist
-  // in the user's surrounding content.
-  let after = existing.slice(found.endIdx);
-  if (after.startsWith('\n') && (after.length === 1 || after[1] !== '\n')) {
-    after = after.slice(1);
-  }
-  const before = existing.slice(0, found.startIdx).replace(/\s+$/, '\n');
-
-  const next = (before + after).trimEnd() + (after.endsWith('\n') ? '\n' : '');
-
-  writeFileSync(claudeMdPath, next, 'utf8');
-  return { action: 'removed', path: claudeMdPath };
-}
-
-// Internal helpers are intentionally NOT exported — they're implementation
-// details. The boundary tests check the public actions + on-disk effects.
+// claude-md.mjs — managed-block injection into the target project's CLAUDE.md.
+//
+// Public contract (tests assert this; internals can change freely):
+//
+//   injectClaudeMdBlock({
+//     projectRoot,   // <repo> root
+//     content,       // body of the block (without markers)
+//     version,       // kit version string, e.g. "0.1.0"
+//     force,         // allow downgrade (replace newer block with older)
+//   }) → {
+//     action:   'created'              // no CLAUDE.md before; one was created
+//             | 'appended'             // CLAUDE.md existed without our markers; block appended at EOF
+//             | 'replaced'             // same-version block content updated in place
+//             | 'upgraded'             // older-version block replaced (kit version is newer)
+//             | 'downgrade-blocked'    // newer-version block present and force not set
+//             | 'forced-downgrade'     // newer-version block replaced because force=true
+//             | 'unchanged',           // existing block content + version match the inputs exactly
+//     path:        string,             // absolute path to the CLAUDE.md
+//     oldVersion?: string,             // version of the block we replaced (when applicable)
+//   }
+//
+//   removeClaudeMdBlock({ projectRoot }) → {
+//     action:   'removed'              // managed block found + stripped
+//             | 'not-found'            // file exists but no managed markers
+//             | 'no-file',             // CLAUDE.md does not exist
+//     path:        string,
+//   }
+//
+// Design notes:
+//   - Deep module: the two boundary functions above are the only public
+//     surface. Internal helpers parse markers, compare versions, and
+//     splice the block — all private.
+//   - Markers wrap the kit-managed content. Everything outside markers is
+//     byte-preserved across inject + remove. This is what makes the
+//     installer safe to re-run.
+//   - Version comparison is semver-style (MAJOR.MINOR.PATCH). Prerelease
+//     suffixes (-dev, -alpha.1) are ignored when comparing.
+//   - Marker pattern is intentionally the same shape as the .gitignore
+//     marker pattern in install.mjs — same idea, same conventions.
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+const MARKER_START_RE =
+  /<!--\s*claude-memory-kit:start\s+v([\d.]+(?:-[\w.]+)?)\s*-->/;
+const MARKER_END_RE = /<!--\s*claude-memory-kit:end\s*-->/;
+
+/**
+ * Wrap a content string with kit markers at the given version.
+ */
+function buildBlock(content, version) {
+  return `<!-- claude-memory-kit:start v${version} -->\n${content.trim()}\n<!-- claude-memory-kit:end -->`;
+}
+
+/**
+ * Find the start + end marker positions in the source text.
+ *   - Returns null when no start marker is present (no managed block).
+ *   - When a start marker is present but the end marker is missing or
+ *     misplaced, treats the block as extending to EOF. This recovers
+ *     gracefully from a corrupted block (e.g. the user accidentally
+ *     deleted the end marker by hand).
+ */
+function findManagedBlock(text) {
+  const startMatch = text.match(MARKER_START_RE);
+  if (!startMatch) return null;
+
+  const endMatch = text.match(MARKER_END_RE);
+  if (endMatch && startMatch.index < endMatch.index) {
+    return {
+      startIdx: startMatch.index,
+      endIdx: endMatch.index + endMatch[0].length,
+      version: startMatch[1],
+      fullText: text.slice(startMatch.index, endMatch.index + endMatch[0].length),
+      corrupted: false,
+    };
+  }
+
+  // Orphan start marker → treat the block as extending to EOF so we
+  // can replace it cleanly on the next install.
+  return {
+    startIdx: startMatch.index,
+    endIdx: text.length,
+    version: startMatch[1],
+    fullText: text.slice(startMatch.index),
+    corrupted: true,
+  };
+}
+
+/**
+ * Strip trailing -prerelease, parse MAJOR.MINOR.PATCH integers.
+ * Tolerates partial versions ("0.1" → [0,1,0]).
+ */
+function parseVersion(v) {
+  const base = String(v).replace(/^v/, '').split('-')[0];
+  const parts = base.split('.').map((n) => parseInt(n, 10) || 0);
+  while (parts.length < 3) parts.push(0);
+  return parts.slice(0, 3);
+}
+
+/**
+ * Semver-style comparator. Returns -1 / 0 / 1.
+ *   compareVersions('0.1.0', '0.2.0') === -1
+ *   compareVersions('1.0.0', '1.0.0') === 0
+ *   compareVersions('2.0.0', '1.9.9') === 1
+ */
+function compareVersions(a, b) {
+  const av = parseVersion(a);
+  const bv = parseVersion(b);
+  for (let i = 0; i < 3; i++) {
+    if (av[i] < bv[i]) return -1;
+    if (av[i] > bv[i]) return 1;
+  }
+  return 0;
+}
+
+export function injectClaudeMdBlock(opts = {}) {
+  const projectRoot = opts.projectRoot;
+  const content = String(opts.content || '');
+  const version = String(opts.version || '0.0.0');
+  const force = !!opts.force;
+  if (!projectRoot) throw new Error('injectClaudeMdBlock: projectRoot is required');
+
+  const claudeMdPath = join(projectRoot, 'CLAUDE.md');
+  const newBlock = buildBlock(content, version);
+
+  // Case 1 — no CLAUDE.md
+  if (!existsSync(claudeMdPath)) {
+    writeFileSync(claudeMdPath, newBlock + '\n', 'utf8');
+    return { action: 'created', path: claudeMdPath };
+  }
+
+  const existing = readFileSync(claudeMdPath, 'utf8');
+  const found = findManagedBlock(existing);
+
+  // Case 2 — file exists but no (or corrupted) managed block → append
+  if (!found) {
+    // If the file ends without a newline, add one before the block for
+    // readability. Trim trailing whitespace so we don't accumulate blank
+    // lines on repeated installs.
+    const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+    writeFileSync(claudeMdPath, existing.replace(/\s+$/, '') + sep + newBlock + '\n', 'utf8');
+    return { action: 'appended', path: claudeMdPath };
+  }
+
+  // Case 3 — managed block present. Compare versions to choose action.
+  const cmp = compareVersions(version, found.version);
+  const before = existing.slice(0, found.startIdx);
+  const after = existing.slice(found.endIdx);
+
+  let action;
+  if (cmp === 0) {
+    if (found.fullText === newBlock) {
+      return { action: 'unchanged', path: claudeMdPath, oldVersion: found.version };
+    }
+    action = 'replaced';
+  } else if (cmp > 0) {
+    action = 'upgraded';
+  } else {
+    // cmp < 0 → incoming version is older than installed
+    if (!force) {
+      return {
+        action: 'downgrade-blocked',
+        path: claudeMdPath,
+        oldVersion: found.version,
+      };
+    }
+    action = 'forced-downgrade';
+  }
+
+  writeFileSync(claudeMdPath, before + newBlock + after, 'utf8');
+  return { action, path: claudeMdPath, oldVersion: found.version };
+}
+
+export function removeClaudeMdBlock(opts = {}) {
+  const projectRoot = opts.projectRoot;
+  if (!projectRoot) throw new Error('removeClaudeMdBlock: projectRoot is required');
+
+  const claudeMdPath = join(projectRoot, 'CLAUDE.md');
+
+  if (!existsSync(claudeMdPath)) {
+    return { action: 'no-file', path: claudeMdPath };
+  }
+
+  const existing = readFileSync(claudeMdPath, 'utf8');
+  const found = findManagedBlock(existing);
+
+  if (!found) {
+    return { action: 'not-found', path: claudeMdPath };
+  }
+
+  // Strip the block. If the block was followed by exactly one trailing
+  // newline (the one we wrote at injection time), strip it too so the
+  // surrounding content stays clean. We do NOT touch newlines that exist
+  // in the user's surrounding content.
+  let after = existing.slice(found.endIdx);
+  if (after.startsWith('\n') && (after.length === 1 || after[1] !== '\n')) {
+    after = after.slice(1);
+  }
+  const before = existing.slice(0, found.startIdx).replace(/\s+$/, '\n');
+
+  const next = (before + after).trimEnd() + (after.endsWith('\n') ? '\n' : '');
+
+  writeFileSync(claudeMdPath, next, 'utf8');
+  return { action: 'removed', path: claudeMdPath };
+}
+
+// Internal helpers are intentionally NOT exported — they're implementation
+// details. The boundary tests check the public actions + on-disk effects.

package/src/doctor.mjs

@@ -142,13 +142,24 @@ function hc2Hooks({ projectRoot }) {
   const missing = [];
   for (const { event, command } of required) {
     const entries = Array.isArray(hooks[event]) ? hooks[event] : [];
-    // Each entry may be either a string command or {command: '...'}.
-    // Anthropic's hook format uses the object form; the kit's bin
-    // wrapper docs use it too. Accept both for resilience.
+    // An entry may be (a) a bare string command, (b) a flat object
+    // {command: '...'}, or (c) the canonical Anthropic / kit nested shape
+    // {hooks: [{type, command}, ...]}. The kit's own writers (cmk install
+    // + cmk repair --hooks via settings-hooks.mjs) emit form (c), so HC-2
+    // MUST traverse the nested hooks[] array — otherwise `cmk install`
+    // followed by `cmk doctor` reports HC-2 fail on hooks the kit itself
+    // just wrote (a separately-correct-jointly-broken composition bug
+    // caught while shipping Task 49; pre-Task-49 the doctor test only ever
+    // fed form (b), so the gap stayed latent).
     const found = entries.some((e) => {
       if (typeof e === 'string') return e.includes(command);
-      if (e && typeof e === 'object' && typeof e.command === 'string') {
-        return e.command.includes(command);
+      if (e && typeof e === 'object') {
+        if (typeof e.command === 'string' && e.command.includes(command)) return true;
+        if (Array.isArray(e.hooks)) {
+          return e.hooks.some(
+            (h) => h && typeof h.command === 'string' && h.command.includes(command),
+          );
+        }
       }
       return false;
     });

package/src/frontmatter.mjs

@@ -1,73 +1,73 @@
-// Canonical frontmatter serializer/parser. Single js-yaml-backed pair that
-// every kit module uses to read and write per-fact frontmatter + scratchpad
-// HTML-comment provenance (Layer 3+ will join).
-//
-// Per the Layer-2 review's I2 finding, the previous code had THREE different
-// naive parsers across four modules (split-on-first-colon read; verbatim
-// stringify write). Output and input weren't symmetric: booleans round-tripped
-// as strings, arrays didn't round-trip at all, strings with `:` truncated on
-// read. js-yaml fixes all of these AND lifts the B2 minimum-fix restriction
-// that PR-1 added — values with `\n` / `\r` / `:` are now quoted properly.
-//
-// Public surface:
-//   parse(text) → {frontmatter, body, parseError?}
-//     - text: full file contents (with or without `---` markers)
-//     - returns frontmatter as a typed object (string/number/bool/array/etc.)
-//     - returns body as the markdown after the closing `---\n` (or empty)
-//     - if no frontmatter block: frontmatter is null, body is the full text
-//     - if YAML parse fails: frontmatter is null, parseError carries the message
-//
-//   format({frontmatter, body}) → text
-//     - frontmatter: typed object; key order preserved per insertion
-//     - body: markdown; written verbatim after the closing `---\n`
-//     - if frontmatter is null/empty: just returns body
-//
-// js-yaml schema: CORE_SCHEMA (no implicit timestamp/Date conversion;
-// ISO strings stay as strings). Output uses flowLevel: 1 — top-level
-// mapping is block style; nested arrays render as `[a, b]` (matches the
-// pre-refactor visual format).
-
-import yaml from 'js-yaml';
-
-const DUMP_OPTIONS = Object.freeze({
-  schema: yaml.CORE_SCHEMA,
-  flowLevel: 1,
-  lineWidth: -1, // no line wrapping
-  noRefs: true, // never emit YAML anchors / refs
-  sortKeys: false, // preserve insertion order
-});
-
-const LOAD_OPTIONS = Object.freeze({
-  schema: yaml.CORE_SCHEMA,
-});
-
-export function parse(text) {
-  if (typeof text !== 'string') return { frontmatter: null, body: '' };
-  const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!m) return { frontmatter: null, body: text };
-  let frontmatter;
-  try {
-    frontmatter = yaml.load(m[1], LOAD_OPTIONS);
-  } catch (e) {
-    return { frontmatter: null, body: text, parseError: e.message };
-  }
-  if (frontmatter === undefined || frontmatter === null) {
-    return { frontmatter: null, body: m[2] ?? '' };
-  }
-  if (typeof frontmatter !== 'object' || Array.isArray(frontmatter)) {
-    return {
-      frontmatter: null,
-      body: text,
-      parseError: 'frontmatter is not a mapping',
-    };
-  }
-  return { frontmatter, body: m[2] ?? '' };
-}
-
-export function format({ frontmatter, body }) {
-  if (!frontmatter || (typeof frontmatter === 'object' && Object.keys(frontmatter).length === 0)) {
-    return body ?? '';
-  }
-  const yamlBody = yaml.dump(frontmatter, DUMP_OPTIONS);
-  return `---\n${yamlBody}---\n${body ?? ''}`;
-}
+// Canonical frontmatter serializer/parser. Single js-yaml-backed pair that
+// every kit module uses to read and write per-fact frontmatter + scratchpad
+// HTML-comment provenance (Layer 3+ will join).
+//
+// Per the Layer-2 review's I2 finding, the previous code had THREE different
+// naive parsers across four modules (split-on-first-colon read; verbatim
+// stringify write). Output and input weren't symmetric: booleans round-tripped
+// as strings, arrays didn't round-trip at all, strings with `:` truncated on
+// read. js-yaml fixes all of these AND lifts the B2 minimum-fix restriction
+// that PR-1 added — values with `\n` / `\r` / `:` are now quoted properly.
+//
+// Public surface:
+//   parse(text) → {frontmatter, body, parseError?}
+//     - text: full file contents (with or without `---` markers)
+//     - returns frontmatter as a typed object (string/number/bool/array/etc.)
+//     - returns body as the markdown after the closing `---\n` (or empty)
+//     - if no frontmatter block: frontmatter is null, body is the full text
+//     - if YAML parse fails: frontmatter is null, parseError carries the message
+//
+//   format({frontmatter, body}) → text
+//     - frontmatter: typed object; key order preserved per insertion
+//     - body: markdown; written verbatim after the closing `---\n`
+//     - if frontmatter is null/empty: just returns body
+//
+// js-yaml schema: CORE_SCHEMA (no implicit timestamp/Date conversion;
+// ISO strings stay as strings). Output uses flowLevel: 1 — top-level
+// mapping is block style; nested arrays render as `[a, b]` (matches the
+// pre-refactor visual format).
+
+import yaml from 'js-yaml';
+
+const DUMP_OPTIONS = Object.freeze({
+  schema: yaml.CORE_SCHEMA,
+  flowLevel: 1,
+  lineWidth: -1, // no line wrapping
+  noRefs: true, // never emit YAML anchors / refs
+  sortKeys: false, // preserve insertion order
+});
+
+const LOAD_OPTIONS = Object.freeze({
+  schema: yaml.CORE_SCHEMA,
+});
+
+export function parse(text) {
+  if (typeof text !== 'string') return { frontmatter: null, body: '' };
+  const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!m) return { frontmatter: null, body: text };
+  let frontmatter;
+  try {
+    frontmatter = yaml.load(m[1], LOAD_OPTIONS);
+  } catch (e) {
+    return { frontmatter: null, body: text, parseError: e.message };
+  }
+  if (frontmatter === undefined || frontmatter === null) {
+    return { frontmatter: null, body: m[2] ?? '' };
+  }
+  if (typeof frontmatter !== 'object' || Array.isArray(frontmatter)) {
+    return {
+      frontmatter: null,
+      body: text,
+      parseError: 'frontmatter is not a mapping',
+    };
+  }
+  return { frontmatter, body: m[2] ?? '' };
+}
+
+export function format({ frontmatter, body }) {
+  if (!frontmatter || (typeof frontmatter === 'object' && Object.keys(frontmatter).length === 0)) {
+    return body ?? '';
+  }
+  const yamlBody = yaml.dump(frontmatter, DUMP_OPTIONS);
+  return `---\n${yamlBody}---\n${body ?? ''}`;
+}