@plebeiantech/lat.md 0.12.3-fork.17 → 0.12.3-fork.20

package/dist/src/markdown-analysis.js

@@ -1,169 +0,0 @@
-import { performance } from 'node:perf_hooks';
-import { relative } from 'node:path';
-import { visit } from 'unist-util-visit';
-import { extractLinks, extractRefs, parseFrontmatter, parseSections, } from './lattice.js';
-import { parse } from './parser.js';
-import { toPosix } from './path.js';
-import { analyzeLocalMarkdownDiagnostics, } from './markdown-validation.js';
-function extractBlocks(tree) {
-    const block = (node) => {
-        if (node.position?.start.offset === undefined ||
-            node.position?.end.offset === undefined)
-            return;
-        return {
-            type: node.type,
-            start: node.position.start.offset,
-            end: node.position.end.offset,
-            startLine: node.position.start.line,
-            endLine: node.position.end.line,
-            ...('lang' in node && node.lang ? { language: node.lang } : {}),
-            children: [
-                'list',
-                'listItem',
-                'blockquote',
-                'table',
-                'tableRow',
-            ].includes(node.type)
-                ? ('children' in node ? node.children : [])
-                    .map(block)
-                    .filter((item) => !!item)
-                : [],
-        };
-    };
-    return tree.children
-        .map(block)
-        .filter((item) => !!item);
-}
-function elapsed(work) {
-    const start = performance.now();
-    return [work(), performance.now() - start];
-}
-function inlineText(node) {
-    if (node.type === 'wikiLink')
-        return node.data.alias ?? node.value;
-    if ('value' in node && typeof node.value === 'string')
-        return node.value;
-    if (node.type === 'image')
-        return node.alt ?? '';
-    if (!('children' in node) || !Array.isArray(node.children))
-        return '';
-    return node.children
-        .map((child) => inlineText(child))
-        .join('');
-}
-function extractParagraphs(content, tree) {
-    const result = [];
-    visit(tree, 'paragraph', (node) => {
-        const startLine = node.position?.start.line;
-        const endLine = node.position?.end.line;
-        if (!startLine || !endLine)
-            return;
-        const text = inlineText(node).replace(/\s+/g, ' ').trim();
-        const startOffset = node.position?.start.offset;
-        const endOffset = node.position?.end.offset;
-        result.push({
-            markdown: startOffset === undefined || endOffset === undefined
-                ? text
-                : content.slice(startOffset, endOffset),
-            startLine,
-            endLine,
-            text,
-        });
-    });
-    return result;
-}
-function extractHeadingTitles(tree) {
-    const titles = [];
-    visit(tree, 'heading', (node) => {
-        titles.push(inlineText(node));
-    });
-    return titles;
-}
-function extractDestinationLinks(tree) {
-    const definitions = new Map();
-    visit(tree, 'definition', (node) => {
-        definitions.set(node.identifier.toLowerCase(), node.url);
-    });
-    const links = [];
-    visit(tree, (node) => {
-        if (node.type !== 'link' &&
-            node.type !== 'image' &&
-            node.type !== 'linkReference' &&
-            node.type !== 'imageReference') {
-            return;
-        }
-        const line = node.position?.start.line;
-        if (!line)
-            return;
-        const url = node.type === 'link' || node.type === 'image'
-            ? node.url
-            : definitions.get(node.identifier.toLowerCase());
-        if (!url)
-            return;
-        links.push({
-            kind: node.type === 'image' || node.type === 'imageReference'
-                ? 'image'
-                : 'link',
-            line,
-            url,
-        });
-    });
-    return links;
-}
-function extractIndexEntries(content) {
-    const names = new Set();
-    const pattern = /^- \[\[([^\]]+?)(?:\|[^\]]+)?\]\]/gm;
-    let match;
-    while ((match = pattern.exec(content)) !== null)
-        names.add(match[1]);
-    return [...names];
-}
-/**
- * Parse and analyze one Markdown document. The syntax tree is deliberately
- * confined to this call so callers and workers only exchange serializable facts.
- */
-export function analyzeMarkdownFile(absolutePath, content, latDir, projectRoot) {
-    const [tree, parseMs] = elapsed(() => parse(content));
-    const [sections, sectionsMs] = elapsed(() => parseSections(absolutePath, content, projectRoot, tree));
-    const [wikiRefs, refsMs] = elapsed(() => extractRefs(absolutePath, content, projectRoot, tree, sections));
-    const [validationLinks, linksMs] = elapsed(() => extractLinks(content, tree));
-    const [[paragraphs, markdownLinks, headingTitles], paragraphsMs] = elapsed(() => [
-        extractParagraphs(content, tree),
-        extractDestinationLinks(tree),
-        extractHeadingTitles(tree),
-    ]);
-    const [frontmatter, frontmatterMs] = elapsed(() => parseFrontmatter(content));
-    const [indexEntries, indexEntriesMs] = elapsed(() => extractIndexEntries(content));
-    const [diagnostics, diagnosticsMs] = elapsed(() => analyzeLocalMarkdownDiagnostics(validationLinks, sections));
-    return {
-        absolutePath,
-        content,
-        path: toPosix(relative(latDir, absolutePath)),
-        projectPath: toPosix(relative(projectRoot, absolutePath)),
-        frontmatter,
-        sections,
-        headingTitles,
-        wikiRefs,
-        paragraphs,
-        blocks: extractBlocks(tree),
-        markdownLinks,
-        validationLinks,
-        indexEntries,
-        diagnostics,
-        timings: {
-            readMs: 0,
-            hashMs: 0,
-            cacheReadMs: 0,
-            cacheWriteMs: 0,
-            cacheStatus: 'disabled',
-            parseMs,
-            sectionsMs,
-            refsMs,
-            linksMs,
-            paragraphsMs,
-            frontmatterMs,
-            indexEntriesMs,
-            diagnosticsMs,
-        },
-    };
-}

package/dist/src/markdown-analyzer-loader.d.ts

@@ -1,4 +0,0 @@
-import type { analyzeMarkdownFile } from './markdown-analysis.js';
-import type { ParserImportObserver } from './parser-import.js';
-/** Load the Markdown analyzer at the cache-miss boundary and report its cost. */
-export declare function loadMarkdownAnalyzer(onParserImport?: ParserImportObserver, detail?: string): Promise<typeof analyzeMarkdownFile>;

package/dist/src/markdown-analyzer-loader.js

@@ -1,13 +0,0 @@
-import { performance } from 'node:perf_hooks';
-/** Load the Markdown analyzer at the cache-miss boundary and report its cost. */
-export async function loadMarkdownAnalyzer(onParserImport, detail) {
-    const started = performance.now();
-    const module = await import('./markdown-analysis.js');
-    onParserImport?.({
-        parser: 'Markdown analyzer',
-        imported: true,
-        durationMs: performance.now() - started,
-        detail,
-    });
-    return module.analyzeMarkdownFile;
-}

package/dist/src/markdown-validation.d.ts

@@ -1,25 +0,0 @@
-import { type MdLink, type Section } from './lattice-model.js';
-export declare const MAX_SECTION_SUMMARY_LENGTH = 250;
-export type LocalMarkdownDiagnostic = {
-    rule: 'markdown-reference-definition' | 'markdown-path-separator' | 'section-leading-paragraph';
-    line: number;
-    target: string;
-    message: string;
-    anchor?: string;
-    marker?: 'target' | 'line' | 'heading';
-};
-export type LocalMarkdownTarget = {
-    kind: 'target';
-    /** Decoded on-disk path, or null for a fragment in the current file. */
-    path: string | null;
-    /** Decoded fragment without `#`, or null when none was authored. */
-    fragment: string | null;
-} | {
-    kind: 'invalid-backslash';
-};
-/** Parse a local Markdown destination without confusing escaped #/? in paths. */
-export declare function parseLocalMarkdownTarget(url: string): LocalMarkdownTarget | null;
-/** Count summary text while excluding `[[...]]` markers and link content. */
-export declare function sectionSummaryLength(body: string): number;
-/** Validate rules that need no facts outside one parsed Markdown file. */
-export declare function analyzeLocalMarkdownDiagnostics(links: readonly MdLink[], sections: readonly Section[]): LocalMarkdownDiagnostic[];

package/dist/src/markdown-validation.js

@@ -1,104 +0,0 @@
-import { flattenSections } from './lattice-model.js';
-export const MAX_SECTION_SUMMARY_LENGTH = 250;
-function decodeLinkPart(value) {
-    try {
-        return decodeURIComponent(value);
-    }
-    catch {
-        return value;
-    }
-}
-/** Parse a local Markdown destination without confusing escaped #/? in paths. */
-export function parseLocalMarkdownTarget(url) {
-    const value = url.trim();
-    if (value.startsWith('/'))
-        return null;
-    const windowsDrivePath = /^[a-zA-Z]:\\/.test(value);
-    if (!windowsDrivePath && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) {
-        return null;
-    }
-    // Split before decoding: `%23` and `%3F` decode to `#` and `?`, which would
-    // then truncate a filename that legitimately contains them.
-    const queryAt = value.indexOf('?');
-    const fragmentAt = value.indexOf('#');
-    const pathEnd = Math.min(queryAt === -1 ? value.length : queryAt, fragmentAt === -1 ? value.length : fragmentAt);
-    const rawPath = value.slice(0, pathEnd);
-    const path = rawPath === '' ? null : decodeLinkPart(rawPath);
-    const fragment = fragmentAt === -1 ? null : decodeLinkPart(value.slice(fragmentAt + 1));
-    if (rawPath === '' && fragment === null)
-        return null;
-    if (path?.includes('\\'))
-        return { kind: 'invalid-backslash' };
-    return { kind: 'target', path, fragment };
-}
-/** Count summary text while excluding `[[...]]` markers and link content. */
-export function sectionSummaryLength(body) {
-    return body.replace(/\[\[[^\]]*\]\]/g, '').length;
-}
-/** Validate rules that need no facts outside one parsed Markdown file. */
-export function analyzeLocalMarkdownDiagnostics(links, sections) {
-    const diagnostics = [];
-    for (const link of links) {
-        if ('identifier' in link) {
-            const kind = link.kind === 'imageReference' ? 'image' : 'link';
-            const renderedKind = kind === 'image' ? 'an image' : 'a link';
-            const escapedSource = link.source.replace('[', '\\[');
-            diagnostics.push({
-                rule: 'markdown-reference-definition',
-                line: link.line,
-                target: link.identifier,
-                message: link.style === 'definition'
-                    ? `malformed reference definition (${link.source}) — ` +
-                        `write it as "[${link.identifier}]: <destination>" on its own line, ` +
-                        `or escape the opening bracket as "${escapedSource}" to keep it as literal text`
-                    : link.style === 'shortcut'
-                        ? `undefined shortcut ${kind} reference (${link.source}) — ` +
-                            `add a definition "[${link.identifier}]: <destination>" to make it ${renderedKind}, ` +
-                            `or escape the opening bracket as "${escapedSource}" to keep it as literal text`
-                        : `undefined ${kind} reference (${link.source}) — definition "[${link.identifier}]" not found`,
-                marker: 'line',
-            });
-            continue;
-        }
-        if (parseLocalMarkdownTarget(link.url)?.kind === 'invalid-backslash') {
-            const kind = link.kind === 'image' ? 'image' : 'link';
-            diagnostics.push({
-                rule: 'markdown-path-separator',
-                line: link.line,
-                target: link.url,
-                message: `invalid ${kind} (${link.url}) — backslashes are not path ` +
-                    'separators in Markdown; use "/" instead',
-            });
-        }
-    }
-    for (const section of flattenSections([...sections])) {
-        if (!section.firstParagraph) {
-            diagnostics.push({
-                rule: 'section-leading-paragraph',
-                line: section.startLine,
-                target: section.id,
-                message: `section "${section.id}" has no leading paragraph. ` +
-                    `Every section must start with a brief overview (≤${MAX_SECTION_SUMMARY_LENGTH} chars) ` +
-                    `summarizing what it documents — this powers search snippets and command output.`,
-                anchor: section.githubSlug,
-                marker: 'heading',
-            });
-            continue;
-        }
-        const length = sectionSummaryLength(section.firstParagraph);
-        if (length > MAX_SECTION_SUMMARY_LENGTH) {
-            diagnostics.push({
-                rule: 'section-leading-paragraph',
-                line: section.startLine,
-                target: section.id,
-                message: `section "${section.id}" leading paragraph is ${length} characters ` +
-                    `(max ${MAX_SECTION_SUMMARY_LENGTH}, excluding [[wiki links]]). ` +
-                    `Keep the first paragraph brief — it serves as the section's summary ` +
-                    `in search results and command output. Use subsequent paragraphs for details.`,
-                anchor: section.githubSlug,
-                marker: 'heading',
-            });
-        }
-    }
-    return diagnostics;
-}

package/dist/src/parser-cache.d.ts

@@ -1,17 +0,0 @@
-/** Version of persistent parser outputs and their shared on-disk contract. */
-export declare const PARSER_CACHE_VERSION = 3;
-export type ParsedCacheEntry = {
-    version: number;
-    contentHash: string;
-    value: unknown;
-};
-/** Hash complete parser input bytes for cache invalidation. */
-export declare function hashParserContent(content: string): string;
-/** Normalize an on-disk file into its project-relative parser identity. */
-export declare function parserCacheIdentity(absolutePath: string, projectRoot: string): string;
-/** Return the collision-safe, short-name-sharded cache path for an identity. */
-export declare function parsedCachePath(latDir: string, identity: string): string;
-/** Read and decode a cache entry, treating every malformed state as a miss. */
-export declare function readParsedCache(path: string): Promise<ParsedCacheEntry | null>;
-/** Atomically publish one disposable parser cache entry. */
-export declare function writeParsedCache(path: string, contentHash: string, value: unknown): Promise<void>;

package/dist/src/parser-cache.js

@@ -1,65 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { basename, dirname, extname, join, relative } from 'node:path';
-import { toPosix } from './path.js';
-/** Version of persistent parser outputs and their shared on-disk contract. */
-export const PARSER_CACHE_VERSION = 3;
-/** Hash complete parser input bytes for cache invalidation. */
-export function hashParserContent(content) {
-    return createHash('sha1').update(content).digest('hex');
-}
-/** Normalize an on-disk file into its project-relative parser identity. */
-export function parserCacheIdentity(absolutePath, projectRoot) {
-    return toPosix(relative(projectRoot, absolutePath)).normalize('NFC');
-}
-function readablePath(identity) {
-    const normalized = identity
-        .replace(/[^a-zA-Z0-9_-]+/g, '_')
-        .replace(/^_+|_+$/g, '')
-        .toLowerCase();
-    return (normalized || 'parsed').slice(-120);
-}
-function cacheShard(identity) {
-    const shortName = basename(identity);
-    const stem = shortName.slice(0, shortName.length - extname(shortName).length);
-    const firstTwo = [...stem.toLowerCase()].slice(0, 2).join('');
-    return firstTwo.replace(/[^a-z0-9]/g, '_') || '_';
-}
-/** Return the collision-safe, short-name-sharded cache path for an identity. */
-export function parsedCachePath(latDir, identity) {
-    const normalizedIdentity = toPosix(identity).normalize('NFC');
-    const digest = hashParserContent(normalizedIdentity);
-    return join(latDir, '.cache', 'parsed', cacheShard(normalizedIdentity), `${digest}_${readablePath(normalizedIdentity)}`);
-}
-/** Read and decode a cache entry, treating every malformed state as a miss. */
-export async function readParsedCache(path) {
-    try {
-        const serialized = await readFile(path, 'utf8');
-        const newline = serialized.indexOf('\n');
-        if (newline < 0)
-            return null;
-        const match = /^v(\d+):([a-f0-9]{40})$/.exec(serialized.slice(0, newline).trim());
-        if (!match)
-            return null;
-        return {
-            version: Number(match[1]),
-            contentHash: match[2],
-            value: JSON.parse(serialized.slice(newline + 1)),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/** Atomically publish one disposable parser cache entry. */
-export async function writeParsedCache(path, contentHash, value) {
-    await mkdir(dirname(path), { recursive: true });
-    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-        await writeFile(temp, `v${PARSER_CACHE_VERSION}:${contentHash}\n${JSON.stringify(value)}\n`);
-        await rename(temp, path);
-    }
-    finally {
-        await rm(temp, { force: true }).catch(() => { });
-    }
-}

package/dist/src/parser-import.d.ts

@@ -1,8 +0,0 @@
-/** One observable decision to load or skip a lazily imported parser module. */
-export type ParserImportEvent = {
-    parser: 'AsciiDoc parser' | 'Markdown analyzer' | 'reStructuredText parser';
-    imported: boolean;
-    durationMs: number;
-    detail?: string;
-};
-export type ParserImportObserver = (event: ParserImportEvent) => void;

package/dist/src/parser-import.js

@@ -1 +0,0 @@
-export {};

package/dist/src/parser.d.ts

@@ -1,3 +0,0 @@
-import type { Root } from 'mdast';
-export declare function parse(markdown: string): Root;
-export declare function toMarkdown(tree: Root): string;

package/dist/src/parser.js

@@ -1,93 +0,0 @@
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkStringify from 'remark-stringify';
-import remarkFrontmatter from 'remark-frontmatter';
-import remarkMath from 'remark-math';
-import { gfmAutolinkLiteralFromMarkdown } from 'mdast-util-gfm-autolink-literal';
-import { gfmFootnoteFromMarkdown, gfmFootnoteToMarkdown, } from 'mdast-util-gfm-footnote';
-import { gfmStrikethroughFromMarkdown, gfmStrikethroughToMarkdown, } from 'mdast-util-gfm-strikethrough';
-import { gfmTableFromMarkdown, gfmTableToMarkdown } from 'mdast-util-gfm-table';
-import { gfmTaskListItemFromMarkdown, gfmTaskListItemToMarkdown, } from 'mdast-util-gfm-task-list-item';
-import { gfmAutolinkLiteral } from 'micromark-extension-gfm-autolink-literal';
-import { gfmFootnote } from 'micromark-extension-gfm-footnote';
-import { gfmStrikethrough } from 'micromark-extension-gfm-strikethrough';
-import { gfmTable } from 'micromark-extension-gfm-table';
-import { gfmTaskListItem } from 'micromark-extension-gfm-task-list-item';
-import { visit } from 'unist-util-visit';
-import { alertMarkerToMarkdown, markAlertMarkers, } from './extensions/alert-marker.js';
-import { wikiLinkSyntax, wikiLinkFromMarkdown, wikiLinkToMarkdown, } from './extensions/wiki-link/index.js';
-const processor = unified()
-    .use(remarkParse)
-    .use(remarkFrontmatter)
-    .use(remarkMath)
-    .use(remarkStringify)
-    .data('micromarkExtensions', [
-    gfmAutolinkLiteral(),
-    gfmFootnote(),
-    gfmStrikethrough(),
-    gfmTable(),
-    gfmTaskListItem(),
-    wikiLinkSyntax(),
-])
-    .data('fromMarkdownExtensions', [
-    gfmAutolinkLiteralFromMarkdown(),
-    gfmFootnoteFromMarkdown(),
-    gfmStrikethroughFromMarkdown(),
-    gfmTableFromMarkdown(),
-    gfmTaskListItemFromMarkdown(),
-    wikiLinkFromMarkdown(),
-])
-    .data('toMarkdownExtensions', [
-    alertMarkerToMarkdown(),
-    gfmFootnoteToMarkdown(),
-    gfmStrikethroughToMarkdown(),
-    gfmTableToMarkdown(),
-    gfmTaskListItemToMarkdown(),
-    wikiLinkToMarkdown(),
-]);
-const BARE_AUTOLINK_DATA_KEY = 'latBareAutolink';
-function bareAutolinkText(node) {
-    if (node.children.length !== 1 || node.children[0].type !== 'text') {
-        return null;
-    }
-    const text = node.children[0].value;
-    if (node.url !== text &&
-        node.url !== `http://${text}` &&
-        node.url !== `mailto:${text}`) {
-        return null;
-    }
-    return text;
-}
-export function parse(markdown) {
-    const tree = processor.parse(markdown);
-    markAlertMarkers(tree);
-    visit(tree, 'link', (node) => {
-        const text = bareAutolinkText(node);
-        const sourceLength = node.position?.end.offset !== undefined &&
-            node.position.start.offset !== undefined
-            ? node.position.end.offset - node.position.start.offset
-            : null;
-        if (text === null || sourceLength !== text.length)
-            return;
-        node.data = {
-            ...node.data,
-            [BARE_AUTOLINK_DATA_KEY]: true,
-        };
-    });
-    return tree;
-}
-export function toMarkdown(tree) {
-    const serializable = structuredClone(tree);
-    visit(serializable, 'link', (node, index, parent) => {
-        if (index === undefined ||
-            !parent ||
-            node.data?.[BARE_AUTOLINK_DATA_KEY] !== true) {
-            return;
-        }
-        const text = bareAutolinkText(node);
-        if (text === null)
-            return;
-        parent.children[index] = { type: 'text', value: text };
-    });
-    return processor.stringify(serializable);
-}

package/dist/src/path.d.ts

@@ -1,2 +0,0 @@
-/** Normalize path separators for stable project-relative identities. */
-export declare function toPosix(path: string): string;

package/dist/src/path.js

@@ -1,4 +0,0 @@
-/** Normalize path separators for stable project-relative identities. */
-export function toPosix(path) {
-    return path.replace(/\\/g, '/');
-}

package/dist/src/profiler.d.ts

@@ -1,16 +0,0 @@
-export type Profiler = {
-    time<T>(label: string, work: () => Promise<T>, detail?: string): Promise<T>;
-    timeSync<T>(label: string, work: () => T, detail?: string): T;
-    record(label: string, durationMs: number, detail?: string): void;
-};
-export declare class TimingProfiler implements Profiler {
-    private readonly root;
-    private readonly activeNode;
-    private node;
-    time<T>(label: string, work: () => Promise<T>, detail?: string): Promise<T>;
-    timeSync<T>(label: string, work: () => T, detail?: string): T;
-    record(label: string, durationMs: number, detail?: string): void;
-    private recordNode;
-    format(totalMs: number): string[];
-    private formatNode;
-}

package/dist/src/profiler.js

@@ -1,81 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { performance } from 'node:perf_hooks';
-export class TimingProfiler {
-    root = {
-        label: '',
-        calls: 0,
-        totalMs: 0,
-        maxMs: 0,
-        children: new Map(),
-    };
-    activeNode = new AsyncLocalStorage();
-    node(label) {
-        const parent = this.activeNode.getStore() ?? this.root;
-        let node = parent.children.get(label);
-        if (!node) {
-            node = {
-                label,
-                calls: 0,
-                totalMs: 0,
-                maxMs: 0,
-                children: new Map(),
-            };
-            parent.children.set(label, node);
-        }
-        return node;
-    }
-    async time(label, work, detail) {
-        const node = this.node(label);
-        const start = performance.now();
-        try {
-            return await this.activeNode.run(node, work);
-        }
-        finally {
-            this.recordNode(node, performance.now() - start, detail);
-        }
-    }
-    timeSync(label, work, detail) {
-        const node = this.node(label);
-        const start = performance.now();
-        try {
-            return this.activeNode.run(node, work);
-        }
-        finally {
-            this.recordNode(node, performance.now() - start, detail);
-        }
-    }
-    record(label, durationMs, detail) {
-        this.recordNode(this.node(label), durationMs, detail);
-    }
-    recordNode(node, durationMs, detail) {
-        node.calls++;
-        node.totalMs += durationMs;
-        if (durationMs > node.maxMs) {
-            node.maxMs = durationMs;
-            node.maxDetail = detail;
-        }
-    }
-    format(totalMs) {
-        const lines = [`Profile (${totalMs.toFixed(1)}ms total):`];
-        for (const node of this.root.children.values()) {
-            this.formatNode(node, 1, lines);
-        }
-        return lines;
-    }
-    formatNode(node, depth, lines) {
-        const indent = '  '.repeat(depth);
-        let summary = `${indent}${node.label}: ${node.totalMs.toFixed(1)}ms`;
-        if (node.calls > 1) {
-            summary +=
-                ` total across ${node.calls} calls` +
-                    ` (${(node.totalMs / node.calls).toFixed(1)}ms avg,` +
-                    ` ${node.maxMs.toFixed(1)}ms max` +
-                    (node.maxDetail ? `: ${node.maxDetail}` : '') +
-                    ')';
-        }
-        lines.push(summary);
-        for (const child of node.children.values()) {
-            this.formatNode(child, depth + 1, lines);
-        }
-    }
-}