@ankhorage/paradox 0.0.10 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.1
+
+### Patch Changes
+
+- 3a7c982: Render sequence diagrams from call flow instead of import topology.
+
+## 0.1.0
+
+### Minor Changes
+
+- dd41897: Generate compact README docs from `@readme` symbols.
+
 ## 0.0.10
 
 ### Patch Changes

package/README.md

@@ -1,15 +1,55 @@
+<!-- markdownlint-disable MD013 MD033 -->
+<!-- This file is generated by Paradox. Do not edit manually. -->
+
 # @ankhorage/paradox
 
-![license: MIT](./paradox/badges/license.svg) ![npm: v0.0.9](./paradox/badges/npm.svg) ![runtime: bun](./paradox/badges/runtime.svg) ![typescript: strict](./paradox/badges/typescript.svg) ![eslint: checked](./paradox/badges/eslint.svg) ![prettier: checked](./paradox/badges/prettier.svg) ![build: checked](./paradox/badges/build.svg) ![tests: checked](./paradox/badges/tests.svg) ![docs: paradox](./paradox/badges/docs.svg)
+![license: MIT](./paradox/badges/license.svg) ![npm: v0.1.0](./paradox/badges/npm.svg) ![runtime: bun](./paradox/badges/runtime.svg) ![typescript: strict](./paradox/badges/typescript.svg) ![eslint: checked](./paradox/badges/eslint.svg) ![prettier: checked](./paradox/badges/prettier.svg) ![build: checked](./paradox/badges/build.svg) ![tests: checked](./paradox/badges/tests.svg) ![docs: paradox](./paradox/badges/docs.svg)
 
 Deterministic documentation generator for TypeScript packages.
 
-## Usage
+## Installation
+
+```bash
+bunx @ankhorage/paradox
+```
+
+## CLI
+
+### paradox
+
+Runs the Paradox CLI.
+
+The command discovers the nearest Paradox config, resolves the package and output roots,
+analyzes the package, builds the documentation model, renders all documentation artifacts,
+and writes them to the configured output directory.
 
 ```bash
 bunx @ankhorage/paradox
 ```
 
+## Documentation Tags
+
+<details>
+<summary>@readme</summary>
+
+Includes a documentation block or exported symbol in README output.
+
+</details>
+
+<details>
+<summary>@config</summary>
+
+Marks a type or interface as part of the Paradox configuration model. `@config` alone does not imply README inclusion; use `@config` plus `@readme` for README output.
+
+</details>
+
+<details>
+<summary>@example</summary>
+
+Adds a titled fenced code example to the generated documentation for a symbol.
+
+</details>
+
 ## Configuration
 
 Create a `paradox.config.ts` file:
@@ -22,14 +62,17 @@ export default defineParadoxConfig({
 });
 ```
 
-### Configuration options
+<details>
+<summary>Configuration options</summary>
 
 | Field   | Type                                                      | Required | Default | Description |
 | ------- | --------------------------------------------------------- | -------- | ------- | ----------- |
-| mode    | `'safe' \| 'write' \| undefined`                          | no       |         |             |
-| docs    | `{ title?: string; description?: string; } \| undefined`  | no       |         |             |
-| package | `{ root?: string; entrypoints?: string[]; } \| undefined` | no       |         |             |
-| output  | `{ dir?: string; } \| undefined`                          | no       |         |             |
+| mode    | `'safe' \| 'write' \| undefined`                          | no       | —       |             |
+| docs    | `{ title?: string; description?: string; } \| undefined`  | no       | —       |             |
+| package | `{ root?: string; entrypoints?: string[]; } \| undefined` | no       | —       |             |
+| output  | `{ dir?: string; } \| undefined`                          | no       | —       |             |
+
+</details>
 
 ## Generated documentation
 
@@ -39,10 +82,12 @@ export default defineParadoxConfig({
 - [Architecture overview](./paradox/diagrams/architecture-overview.mmd)
 - [Module relationships](./paradox/diagrams/module-relationships.mmd)
 - [Export graph](./paradox/diagrams/export-graph.mmd)
-- [Entrypoint sequence](./paradox/diagrams/entrypoint-sequence.mmd)
 
 ## Architecture preview
 
+<details>
+<summary>Architecture overview</summary>
+
 ```mermaid
 graph TD
   package__ankhorage_paradox["@ankhorage/paradox"]
@@ -58,6 +103,7 @@ graph TD
   module_src_analyze_analyze_ts --> module_src_analyze_semantic_createTypeScriptProgram_ts
   module_src_analyze_analyze_ts --> module_src_analyze_semantic_exports_ts
   module_src_analyze_analyze_ts --> module_src_analyze_semantic_graphs_ts
+  module_src_analyze_analyze_ts --> module_src_analyze_sequenceScenarios_ts
   module_src_analyze_analyze_ts --> module_src_analyze_types_ts
   module_src_analyze_analyze_ts --> module_src_analyze_usage_ts
   module_src_analyze_analyze_ts --> module_src_config_types_ts
@@ -133,6 +179,13 @@ graph TD
   package__ankhorage_paradox -.-> module_src_analyze_semantic_tagRegistry_ts
   module_src_analyze_semantic_utils_ts["src/analyze/semantic/utils.ts"]
   package__ankhorage_paradox -.-> module_src_analyze_semantic_utils_ts
+  module_src_analyze_sequenceScenarios_ts["src/analyze/sequenceScenarios.ts"]
+  package__ankhorage_paradox -.-> module_src_analyze_sequenceScenarios_ts
+  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_semantic_utils_ts
+  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_types_ts
+  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_usage_ts
+  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_utils_getParadoxComment_ts
+  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_utils_parseParadoxComment_ts
   module_src_analyze_types_ts["src/analyze/types.ts"]
   package__ankhorage_paradox -.-> module_src_analyze_types_ts
   module_src_analyze_usage_ts["src/analyze/usage.ts"]
@@ -212,6 +265,8 @@ graph TD
   module_src_write_write_ts --> module_src_render_types_ts
 ```
 
+</details>
+
 ## Path resolution
 
 - Config discovery: searches upward from `process.cwd()` for `paradox.config.ts/js/mjs/cjs` (required; no fallback).
@@ -223,21 +278,29 @@ graph TD
 
 ## Public API
 
-### defineParadoxConfig
+### Configuration
+
+<details>
+<summary>defineParadoxConfig</summary>
+
+```ts
+defineParadoxConfig(config: ParadoxConfig) => ParadoxConfig
+```
 
 Defines a Paradox configuration object without changing its shape.
 
-- Kind: `function`
-- Module: `src/config/defineParadoxConfig.ts`
-- Source: `src/config/defineParadoxConfig.ts:6:1`
-- Export paths: `src/index.ts`
-- Related symbols: `ParadoxConfig`
+Module: `src/config/defineParadoxConfig.ts`
+Source: `src/config/defineParadoxConfig.ts:8:1`
+Related symbols: `ParadoxConfig`
+
+</details>
 
-### ParadoxConfig
+<details>
+<summary>ParadoxConfig</summary>
 
 Configuration for running Paradox.
 
-- Kind: `type`
-- Module: `src/config/types.ts`
-- Source: `src/config/types.ts:6:1`
-- Export paths: `src/index.ts`
+Module: `src/config/types.ts`
+Source: `src/config/types.ts:7:1`
+
+</details>

package/dist/analyze/analyze.d.ts

@@ -1,8 +1,5 @@
 import type { ParadoxConfig } from '../config/types.js';
 import type { AnalysisResult } from './types.js';
-/***
- * Runs the source analysis pipeline for a configured package.
- */
 export declare function analyze(config: ParadoxConfig, runtime: {
     packageRoot: string;
 }): Promise<AnalysisResult>;

package/dist/analyze/analyze.js

@@ -8,10 +8,8 @@ import { createProject } from './project.js';
 import { createTypeScriptProgram } from './semantic/createTypeScriptProgram.js';
 import { collectTypeMembers, resolveTypeReference } from './semantic/exports.js';
 import { collectCallGraph, collectComponentCompositionGraph, collectImportGraph, } from './semantic/graphs.js';
+import { analyzeSequenceScenarios } from './sequenceScenarios.js';
 import { createUsageFromPackageJson } from './usage.js';
-/***
- * Runs the source analysis pipeline for a configured package.
- */
 export async function analyze(config, runtime) {
     const root = runtime.packageRoot;
     const pkg = await readPackageJson(root);
@@ -20,15 +18,10 @@ export async function analyze(config, runtime) {
     const project = createProject(root);
     const entrypoints = config.package?.entrypoints ?? ['src/index.ts'];
     const program = createTypeScriptProgram({ root, entrypoints, project });
-    const { config: configMetadata, exports } = analyzeExports(project, {
-        root,
-        entrypoints,
-    });
+    const { config: configMetadata, exports } = analyzeExports(project, { root, entrypoints });
     const components = analyzeComponents(exports, { program });
-    const modules = analyzeModules(project, {
-        root,
-        entrypoints,
-    });
+    const modules = analyzeModules(project, { root, entrypoints });
+    const sequenceScenarios = analyzeSequenceScenarios({ project, root, pkg, exports });
     const configExport = configMetadata
         ? (exports.find((entry) => entry.name === configMetadata.exportName) ?? null)
         : null;
@@ -59,10 +52,12 @@ export async function analyze(config, runtime) {
         entrypoints: entrypoints.map((entrypoint) => entrypoint.replaceAll('\\', '/')).sort(),
         modules,
         badges,
+        sequenceScenarios,
         usage,
         config: configMetadata
             ? {
                 exportName: configMetadata.exportName,
+                isReadme: configMetadata.isReadme,
                 members: mapTypeMembers(configMembers),
             }
             : null,

package/dist/analyze/components.js

@@ -17,6 +17,7 @@ export function analyzeComponents(exports, options = {}) {
             name: member.name,
             type: member.type,
             required: member.required,
+            ...(member.defaultValue !== undefined ? { defaultValue: member.defaultValue } : {}),
             description: member.description ?? null,
         })) ?? [];
         const propsType = getComponentPropsType(e.node);
@@ -25,6 +26,8 @@ export function analyzeComponents(exports, options = {}) {
         components.push({
             name: e.name,
             description: e.description,
+            isReadme: e.isReadme,
+            examples: e.examples,
             modulePath: e.modulePath,
             sourceLocation: e.sourceLocation,
             exportPaths: e.exportPaths,

package/dist/analyze/exports.d.ts

@@ -4,6 +4,7 @@ interface AnalyzeExportsResult {
     exports: AnalysisExport[];
     config: {
         exportName: string;
+        isReadme: boolean;
     } | null;
 }
 /***

package/dist/analyze/exports.js

@@ -19,13 +19,12 @@ export function analyzeExports(project, options) {
                 continue;
             }
             const rawComment = getParadoxComment(decl);
-            const parsed = rawComment
-                ? parseParadoxComment(rawComment)
-                : { description: null, isConfig: false, params: {}, returns: null };
+            const parsed = rawComment ? parseParadoxComment(rawComment) : createEmptyMetadata();
             const name = resolved.getName();
             if (parsed.isConfig) {
                 config = {
                     exportName: name,
+                    isReadme: parsed.isReadme,
                 };
             }
             const metadata = getExportMetadata({
@@ -40,6 +39,8 @@ export function analyzeExports(project, options) {
                 ? {
                     ...existing,
                     description: existing.description ?? parsed.description,
+                    isReadme: existing.isReadme || parsed.isReadme,
+                    examples: existing.examples.length > 0 ? existing.examples : parsed.examples,
                     exportPaths: uniqueSorted([...existing.exportPaths, ...metadata.exportPaths]),
                     relatedSymbols: uniqueSorted([
                         ...existing.relatedSymbols,
@@ -52,6 +53,8 @@ export function analyzeExports(project, options) {
                     name,
                     node: decl,
                     description: parsed.description,
+                    isReadme: parsed.isReadme,
+                    examples: parsed.examples,
                     kind: inferKind(decl),
                     ...metadata,
                 });
@@ -87,3 +90,13 @@ function uniqueSorted(values) {
 function toPosixPath(path) {
     return path.replaceAll('\\', '/');
 }
+function createEmptyMetadata() {
+    return {
+        description: null,
+        isConfig: false,
+        isReadme: false,
+        examples: [],
+        params: {},
+        returns: null,
+    };
+}

package/dist/analyze/sequenceScenarios.d.ts

@@ -0,0 +1,14 @@
+import { type Project } from 'ts-morph';
+import type { AnalysisExport, AnalysisSequenceScenario } from './types.js';
+import type { PackageJsonModel } from './usage.js';
+interface AnalyzeSequenceScenariosOptions {
+    project: Project;
+    root: string;
+    pkg: PackageJsonModel;
+    exports: readonly AnalysisExport[];
+}
+/***
+ * Finds scenario roots that can be rendered as sequence diagrams.
+ */
+export declare function analyzeSequenceScenarios({ project, root, pkg, exports, }: AnalyzeSequenceScenariosOptions): AnalysisSequenceScenario[];
+export {};

package/dist/analyze/sequenceScenarios.js

@@ -0,0 +1,174 @@
+import { isAbsolute, join, normalize } from 'node:path';
+import { Node as MorphNode, } from 'ts-morph';
+import { relativeToRoot, toPosixPath } from './semantic/utils.js';
+import { getParadoxComment } from './utils/getParadoxComment.js';
+import { parseParadoxComment } from './utils/parseParadoxComment.js';
+/***
+ * Finds scenario roots that can be rendered as sequence diagrams.
+ */
+export function analyzeSequenceScenarios({ project, root, pkg, exports, }) {
+    return uniqueScenarios([
+        ...analyzeBinSequenceScenarios(project, root, pkg),
+        ...analyzeExportSequenceScenarios(exports),
+    ]);
+}
+function analyzeBinSequenceScenarios(project, root, pkg) {
+    return getBinEntries(pkg).flatMap((entry) => {
+        const sourceFile = resolveBinSourceFile(project, root, entry.targetPath);
+        if (!sourceFile)
+            return [];
+        const callableRoot = findTopLevelInvokedLocalCallable(sourceFile);
+        if (callableRoot === null)
+            return [];
+        return [
+            {
+                kind: 'bin',
+                name: entry.name,
+                sourcePath: relativeToRoot(root, sourceFile.getFilePath()),
+                symbolName: callableRoot.symbolName,
+                description: callableRoot.description,
+                isReadme: callableRoot.isReadme,
+            },
+        ];
+    });
+}
+function analyzeExportSequenceScenarios(exports) {
+    return exports.flatMap((entry) => {
+        if (entry.signatures.length === 0)
+            return [];
+        return [
+            {
+                kind: 'export',
+                name: entry.name,
+                sourcePath: entry.modulePath,
+                symbolName: entry.name,
+                description: entry.description,
+                isReadme: entry.isReadme,
+            },
+        ];
+    });
+}
+function getBinEntries(pkg) {
+    if (pkg.bin == null)
+        return [];
+    if (typeof pkg.bin === 'string') {
+        return [
+            {
+                name: getPackageBaseName(pkg.name),
+                targetPath: pkg.bin,
+            },
+        ];
+    }
+    return Object.entries(pkg.bin)
+        .map(([name, targetPath]) => ({ name, targetPath }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function resolveBinSourceFile(project, root, targetPath) {
+    for (const candidate of getBinSourceCandidates(targetPath)) {
+        const sourceFile = getSourceFileByRelativePath(project, root, candidate);
+        if (sourceFile)
+            return sourceFile;
+    }
+    return null;
+}
+function getBinSourceCandidates(targetPath) {
+    const normalized = toPosixPath(targetPath).replace(/^\.\//, '');
+    const candidates = [];
+    if (/^src\/.*\.tsx?$/.test(normalized)) {
+        candidates.push(normalized);
+    }
+    if (/^dist\/.*\.jsx?$/.test(normalized)) {
+        candidates.push(normalized.replace(/^dist\//, 'src/').replace(/\.jsx?$/, '.ts'));
+        candidates.push(normalized.replace(/^dist\//, 'src/').replace(/\.jsx?$/, '.tsx'));
+    }
+    if (/\.jsx?$/.test(normalized)) {
+        candidates.push(normalized.replace(/\.jsx?$/, '.ts'));
+        candidates.push(normalized.replace(/\.jsx?$/, '.tsx'));
+    }
+    return uniqueSorted(candidates);
+}
+function getSourceFileByRelativePath(project, root, relativePath) {
+    const absolutePath = normalize(isAbsolute(relativePath) ? relativePath : join(root, relativePath));
+    return project.getSourceFile(absolutePath) ?? null;
+}
+function findTopLevelInvokedLocalCallable(sourceFile) {
+    const candidates = [];
+    sourceFile.forEachDescendant((node) => {
+        if (!MorphNode.isCallExpression(node))
+            return;
+        if (isInsideCallable(node))
+            return;
+        const callableDeclaration = getLocalFunctionDeclarationForCall(sourceFile, node);
+        if (callableDeclaration !== null) {
+            candidates.push(callableDeclaration);
+        }
+    });
+    const uniqueCandidates = uniqueByFunctionName(candidates);
+    const declaration = uniqueCandidates.length === 1 ? uniqueCandidates[0] : undefined;
+    if (declaration === undefined)
+        return null;
+    const parsedComment = getParsedParadoxComment(declaration);
+    return {
+        symbolName: declaration.getName() ?? 'main',
+        description: parsedComment.description,
+        isReadme: parsedComment.isReadme,
+    };
+}
+function getParsedParadoxComment(declaration) {
+    const comment = getParadoxComment(declaration);
+    if (comment === null) {
+        return { description: null, isReadme: false };
+    }
+    const parsed = parseParadoxComment(comment);
+    return {
+        description: parsed.description,
+        isReadme: parsed.isReadme,
+    };
+}
+function getLocalFunctionDeclarationForCall(sourceFile, node) {
+    const expression = node.getExpression();
+    const symbol = expression.getSymbol() ?? expression.getType().getSymbol();
+    if (!symbol)
+        return null;
+    for (const declaration of symbol.getDeclarations()) {
+        if (declaration.getSourceFile().getFilePath() !== sourceFile.getFilePath())
+            continue;
+        if (!MorphNode.isFunctionDeclaration(declaration))
+            continue;
+        return declaration;
+    }
+    return null;
+}
+function isInsideCallable(node) {
+    return Boolean(node.getFirstAncestor((candidate) => MorphNode.isFunctionDeclaration(candidate) ||
+        MorphNode.isMethodDeclaration(candidate) ||
+        MorphNode.isFunctionExpression(candidate) ||
+        MorphNode.isArrowFunction(candidate) ||
+        MorphNode.isClassDeclaration(candidate)));
+}
+function getPackageBaseName(packageName) {
+    return packageName.split('/').pop() ?? packageName;
+}
+function uniqueScenarios(scenarios) {
+    const seen = new Set();
+    return scenarios.filter((scenario) => {
+        const key = `${scenario.kind}:${scenario.name}:${scenario.sourcePath}:${scenario.symbolName}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function uniqueByFunctionName(declarations) {
+    const seen = new Set();
+    return declarations.filter((declaration) => {
+        const name = declaration.getName();
+        if (name === undefined || seen.has(name))
+            return false;
+        seen.add(name);
+        return true;
+    });
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}

package/dist/analyze/types.d.ts

@@ -1,4 +1,9 @@
 import type { Node } from 'ts-morph';
+interface AnalysisExample {
+    title: string | null;
+    language: string | null;
+    code: string;
+}
 /***
  * Describes one exported declaration discovered in a package.
  */
@@ -33,6 +38,8 @@ export interface AnalysisExport {
     name: string;
     node: Node;
     description: string | null;
+    isReadme: boolean;
+    examples: AnalysisExample[];
     kind: 'function' | 'type' | 'unknown';
     modulePath: string;
     sourceLocation: AnalysisSourceLocation;
@@ -47,6 +54,8 @@ export interface AnalysisExport {
 export interface AnalysisComponent {
     name: string;
     description: string | null;
+    isReadme: boolean;
+    examples: AnalysisExample[];
     modulePath: string;
     sourceLocation: AnalysisSourceLocation;
     exportPaths: string[];
@@ -54,6 +63,7 @@ export interface AnalysisComponent {
         name: string;
         type: string;
         required: boolean;
+        defaultValue?: string;
         description: string | null;
     }[];
 }
@@ -77,6 +87,14 @@ export interface AnalysisModule {
     dependencies: string[];
     exports: string[];
 }
+export interface AnalysisSequenceScenario {
+    kind: 'bin' | 'export';
+    name: string;
+    sourcePath: string;
+    symbolName: string;
+    description: string | null;
+    isReadme: boolean;
+}
 interface AnalysisTypeMember {
     name: string;
     type: string;
@@ -126,9 +144,11 @@ export interface AnalysisResult {
     entrypoints: string[];
     modules: AnalysisModule[];
     badges: AnalysisBadge[];
+    sequenceScenarios: AnalysisSequenceScenario[];
     usage: AnalysisUsage | null;
     config: {
         exportName: string;
+        isReadme: boolean;
         members: AnalysisTypeMember[];
     } | null;
     graphs: AnalysisGraphs;

package/dist/analyze/utils/parseParadoxComment.d.ts

@@ -4,9 +4,16 @@
 interface ParsedParadoxComment {
     description: string | null;
     isConfig: boolean;
+    isReadme: boolean;
+    examples: ParsedExample[];
     params: Record<string, string>;
     returns: string | null;
 }
+interface ParsedExample {
+    title: string | null;
+    language: string | null;
+    code: string;
+}
 /***
  * Parses a Paradox doc comment into structured metadata.
  */

package/dist/analyze/utils/parseParadoxComment.js

@@ -2,20 +2,29 @@
  * Parses a Paradox doc comment into structured metadata.
  */
 export function parseParadoxComment(rawComment) {
-    const lines = rawComment
-        .replace(/^\/\*\*\*/, '')
-        .replace(/\*\/$/, '')
-        .split('\n')
-        .map((line) => line.replace(/^\s*\*\s?/, '').trimEnd());
+    const lines = normalizeCommentLines(rawComment);
+    const descriptionLines = [];
+    const examples = [];
     let isConfig = false;
+    let isReadme = false;
     const params = {};
     let returns = null;
-    const description = lines
-        .filter((line) => {
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
         const trimmed = line.trimStart();
         if (trimmed.startsWith('@config')) {
             isConfig = true;
-            return false;
+            continue;
+        }
+        if (trimmed.startsWith('@readme')) {
+            isReadme = true;
+            continue;
+        }
+        if (trimmed.startsWith('@example')) {
+            const parsed = parseExample(lines, index);
+            examples.push(parsed.example);
+            index = parsed.nextIndex;
+            continue;
         }
         if (trimmed.startsWith('@param ')) {
             const paramBody = trimmed.slice('@param '.length).trim();
@@ -23,21 +32,59 @@ export function parseParadoxComment(rawComment) {
             if (name) {
                 params[name] = descriptionParts.join(' ').trim();
             }
-            return false;
+            continue;
         }
         if (trimmed.startsWith('@returns') || trimmed.startsWith('@return')) {
             const returnBody = trimmed.replace(/^@returns?/, '').trim();
             returns = returnBody.length > 0 ? returnBody : null;
-            return false;
+            continue;
         }
-        return true;
-    })
-        .join('\n')
-        .trim();
+        descriptionLines.push(line);
+    }
+    const description = descriptionLines.join('\n').trim();
     return {
         description: description.length > 0 ? description : null,
         isConfig,
+        isReadme,
+        examples,
         params,
         returns,
     };
 }
+function parseExample(lines, startIndex) {
+    const header = lines[startIndex]?.trimStart() ?? '';
+    const title = header.slice('@example'.length).trim();
+    let language = null;
+    const codeLines = [];
+    let index = startIndex + 1;
+    while (index < lines.length && (lines[index] ?? '').trim() === '') {
+        index += 1;
+    }
+    const firstCodeLine = lines[index]?.trim() ?? '';
+    if (firstCodeLine.startsWith('```')) {
+        language = firstCodeLine.slice('```'.length).trim() || null;
+        index += 1;
+        while (index < lines.length) {
+            const current = lines[index] ?? '';
+            if (current.trim() === '```')
+                break;
+            codeLines.push(current);
+            index += 1;
+        }
+    }
+    return {
+        example: {
+            title: title.length > 0 ? title : null,
+            language,
+            code: codeLines.join('\n').trimEnd(),
+        },
+        nextIndex: index,
+    };
+}
+function normalizeCommentLines(rawComment) {
+    return rawComment
+        .replace(/^\/\*\*\*/, '')
+        .replace(/\*\/$/, '')
+        .split('\n')
+        .map((line) => line.replace(/^\s*\*\s?/, '').trimEnd());
+}