@functional-examples/documentation 0.0.0-alpha.3 → 0.0.1

package/dist/commands/generate.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedConfig } from '@functional-examples/devkit';
+import type { ResolvedDocumentationPluginOptions } from '../schema.js';
+export declare function createGenerateCommand(config: ResolvedConfig, pluginOpts: ResolvedDocumentationPluginOptions): import("cli-forge").CLI<{
+    unmatched: string[];
+    '--'?: string[];
+} & {} & {
+    output: string;
+} & {} & {
+    format: string;
+} & {
+    templates?: string | undefined;
+} & {} & {
+    filter?: string | undefined;
+} & {} & {} & {
+    "dry-run": boolean;
+} & {} & {
+    clean: boolean;
+} & {} & {
+    check: boolean;
+}, Promise<void>, {}, undefined>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/commands/generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAK3E,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,cAAc,CAAC;AA6CvE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,kCAAkC;;;;;;;;;;;;;;;;;sCAiP/C"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/commands/generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAK3E,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,cAAc,CAAC;AA6CvE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,kCAAkC;;;;;;;;;;;;;;;;;iCAiP/C"}

package/dist/commands/index.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedConfig } from '@functional-examples/devkit';
+import type { ResolvedDocumentationPluginOptions } from '../schema.js';
+export declare function createDocumentationCommands(config: ResolvedConfig, pluginOpts: ResolvedDocumentationPluginOptions): import("cli-forge").CLI<{
+    unmatched: string[];
+    '--'?: string[];
+} & {} & {
+    output: string;
+} & {} & {
+    format: string;
+} & {
+    templates?: string | undefined;
+} & {} & {
+    filter?: string | undefined;
+} & {} & {} & {
+    "dry-run": boolean;
+} & {} & {
+    clean: boolean;
+} & {} & {
+    check: boolean;
+}, Promise<void>, {}, undefined>[];
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,cAAc,CAAC;AAGvE,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,kCAAkC;;;;;;;;;;;;;;;;;wCAG/C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,cAAc,CAAC;AAGvE,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,kCAAkC;;;;;;;;;;;;;;;;;mCAG/C"}

package/dist/extractor/extractor.d.ts

@@ -0,0 +1,9 @@
+import type { Extractor } from '@functional-examples/devkit';
+/**
+ * Create a markdown frontmatter extractor.
+ *
+ * Scans for .md files with YAML frontmatter containing at least `id` and `title`.
+ * Treats each matching file as a single-file example.
+ */
+export declare function createMarkdownExtractor(): Extractor;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { Plugin } from '@functional-examples/devkit';
+import type { DocsMetadataSchemaType, DocumentationPluginOptions } from './schema.js';
+/**
+ * Create the documentation plugin.
+ *
+ * @example
+ * ```typescript
+ * import { createDocumentationPlugin } from '@functional-examples/documentation';
+ *
+ * const config = {
+ *   plugins: [
+ *     createDocumentationPlugin({
+ *       outputDir: './docs',
+ *       format: 'markdown',
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export declare function createDocumentationPlugin(options?: DocumentationPluginOptions): Plugin<DocsMetadataSchemaType>;
+export type { DocumentationPluginOptions, DocsMetadata, ResolvedDocumentationPluginOptions, DocsMetadataSchemaType, } from './schema.js';
+export type { TemplateData, TemplateDescriptor, RenderedFile, IndexTemplateData, ProseRenderResult, } from './templates/engine.js';
+export type { TemplateHelpers } from './templates/helpers.js';
+export type { ProseHelpers } from './templates/prose-helpers.js';
+export { createMarkdownExtractor } from './extractor/extractor.js';
+export { renderTemplate, buildTemplateData, renderProseFiles, loadTemplates, parseTemplateName, substituteVars, renderItemTemplate, renderIndexTemplate, getBuiltinTemplatesDir, } from './templates/engine.js';
+export { templateHelpers } from './templates/helpers.js';
+export { ConsumptionTracker } from './templates/consumption-tracker.js';
+export { createProseHelpers, fencedBlock } from './templates/prose-helpers.js';
+export { createGuideRenderer } from './templates/guide-renderer.js';
+export type { GuideRenderer, ExampleAccessor } from './templates/guide-renderer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schema.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import type { ValidationResult } from '@functional-examples/devkit';
+/**
+ * Zod schema for documentation-specific metadata.
+ */
+export declare const docsMetadataSchema: z.ZodObject<{
+    docs: z.ZodOptional<z.ZodObject<{
+        template: z.ZodOptional<z.ZodString>;
+        skip: z.ZodOptional<z.ZodBoolean>;
+        outputName: z.ZodOptional<z.ZodString>;
+        /** Descriptions for specific hunks/regions, keyed by hunk ID */
+        hunks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type DocsMetadataSchemaType = z.infer<typeof docsMetadataSchema>;
+/** JSON Schema for metadata plugin registration */
+export declare const DOCS_METADATA_JSON_SCHEMA: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    docs: z.ZodOptional<z.ZodObject<{
+        template: z.ZodOptional<z.ZodString>;
+        skip: z.ZodOptional<z.ZodBoolean>;
+        outputName: z.ZodOptional<z.ZodString>;
+        /** Descriptions for specific hunks/regions, keyed by hunk ID */
+        hunks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>>;
+/**
+ * Zod schema for documentation plugin options.
+ * Fields with defaults are resolved via `docsOptionsSchema.parse(...)`.
+ */
+export declare const docsOptionsSchema: z.ZodObject<{
+    outputDir: z.ZodDefault<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        mdoc: "mdoc";
+    }>>;
+    templates: z.ZodOptional<z.ZodString>;
+    enableExtractor: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/** JSON Schema for options plugin registration */
+export declare const DOCS_OPTIONS_JSON_SCHEMA: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    outputDir: z.ZodDefault<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        mdoc: "mdoc";
+    }>>;
+    templates: z.ZodOptional<z.ZodString>;
+    enableExtractor: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+/**
+ * Validate documentation metadata using Zod schema.
+ */
+export declare function validateDocsMetadata(metadata: unknown): ValidationResult;
+/** Options for the documentation plugin factory (input — all optional). */
+export type DocumentationPluginOptions = z.input<typeof docsOptionsSchema>;
+/** Resolved options with defaults applied (output of parsing). */
+export type ResolvedDocumentationPluginOptions = z.output<typeof docsOptionsSchema>;
+/**
+ * Documentation-specific metadata that examples can declare.
+ */
+export interface DocsMetadata {
+    docs?: DocsMetadataSchemaType;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/templates/consumption-tracker.d.ts

@@ -0,0 +1,16 @@
+import type { ExampleFile } from '@functional-examples/devkit';
+/**
+ * Tracks which example files have been "consumed" by prose template helpers
+ * (e.g. `file()` or `region()`). Consumed files are excluded from the
+ * "remaining files" section in the rendered output.
+ */
+export declare class ConsumptionTracker {
+    private consumed;
+    /** Mark a file as consumed by its relative path. */
+    consume(relativePath: string): void;
+    /** Check whether a file has been consumed. */
+    isConsumed(relativePath: string): boolean;
+    /** Return only those files that have NOT been consumed. */
+    getUnconsumedFiles(files: ExampleFile[]): ExampleFile[];
+}
+//# sourceMappingURL=consumption-tracker.d.ts.map

package/dist/templates/engine.d.ts

@@ -0,0 +1,123 @@
+import type { Example, ExampleFile } from '@functional-examples/devkit';
+import { type TemplateHelpers } from './helpers.js';
+/**
+ * Template data model passed to Eta per-item templates as `it`.
+ */
+export interface TemplateData {
+    /** Example unique identifier */
+    id: string;
+    /** Example title */
+    title: string;
+    /** Example description */
+    description?: string;
+    /** Full metadata object */
+    metadata: Record<string, unknown>;
+    /** Example files */
+    files: ExampleFile[];
+    /** Template helper functions */
+    helpers: TemplateHelpers;
+    /** Prose files rendered through Eta (with file/region helpers expanded) */
+    renderedProse: string[];
+    /** Files not consumed by prose helpers — the "remaining" code files */
+    unconsumedFiles: ExampleFile[];
+}
+/** Data model for aggregate (index) templates. */
+export interface IndexTemplateData {
+    examples: {
+        id: string;
+        title: string;
+        description?: string;
+    }[];
+    format: string;
+    helpers: TemplateHelpers;
+}
+/** Parsed template file descriptor. */
+export interface TemplateDescriptor {
+    /** Absolute path to the .template source file */
+    sourcePath: string;
+    /** Filename minus '.template', e.g. '@slug.md' */
+    outputPattern: string;
+    /** File extension, e.g. '.md' or '.mdoc' */
+    format: string;
+    /** Whether the filename contains an @var placeholder */
+    perItem: boolean;
+    /** Variable name (e.g. 'slug') when perItem is true */
+    variable?: string;
+    /** Raw Eta template content */
+    content: string;
+}
+/** Rendered output ready to write. */
+export interface RenderedFile {
+    /** Relative path for the output file */
+    relativePath: string;
+    /** Rendered content */
+    content: string;
+}
+/** Result of rendering prose files through Eta. */
+export interface ProseRenderResult {
+    /** Rendered prose content strings (one per prose file). */
+    renderedProse: string[];
+    /** Files not consumed by prose file/region helpers. */
+    unconsumedFiles: ExampleFile[];
+}
+/**
+ * Render prose files through Eta, expanding `file()` and `region()` helpers,
+ * and return which files remain unconsumed.
+ */
+export declare function renderProseFiles(files: ExampleFile[], metadata: Record<string, unknown>): ProseRenderResult;
+/**
+ * Build the template data model from an Example.
+ */
+export declare function buildTemplateData(example: Example): TemplateData;
+/**
+ * Resolve the built-in templates directory relative to this file.
+ * At runtime, this file lives at `dist/templates/engine.js`.
+ * The templates directory is at `packages/documentation/templates/`
+ * — two levels up from `dist/templates/`.
+ */
+export declare function getBuiltinTemplatesDir(): string;
+/**
+ * Parse a template's relative path into its descriptor fields.
+ *
+ * The `@var` convention can appear in any path segment — either in the
+ * filename itself or in a directory name:
+ * - `@slug.md.template` → variable `slug` (flat, filename)
+ * - `examples/@example/index.md.template` → variable `example` (nested, directory)
+ *
+ * @param relativePath - Path relative to the templates root, e.g. `examples/@example/index.md.template`
+ */
+export declare function parseTemplateName(relativePath: string): Pick<TemplateDescriptor, 'outputPattern' | 'format' | 'perItem' | 'variable'>;
+/**
+ * Replace `@var` placeholders in a pattern with values from a vars map.
+ *
+ * Example: `substituteVars('@slug.md', { slug: 'getting-started' })` → `getting-started.md`
+ */
+export declare function substituteVars(pattern: string, vars: Record<string, string>): string;
+/**
+ * Load all `.template` files from a directory (recursively) and parse their paths.
+ *
+ * Supports nested directory structures like:
+ * ```
+ * templates/
+ *   index.md.template
+ *   examples/@example/index.md.template
+ * ```
+ */
+export declare function loadTemplates(dir?: string): Promise<TemplateDescriptor[]>;
+/**
+ * Render a per-item template for a single example.
+ */
+export declare function renderItemTemplate(template: TemplateDescriptor, example: Example): Promise<RenderedFile>;
+/**
+ * Render an aggregate template with all examples.
+ */
+export declare function renderIndexTemplate(template: TemplateDescriptor, examples: Example[]): Promise<RenderedFile>;
+/**
+ * Render an example using the default or a custom template file.
+ *
+ * @param example - The example to render
+ * @param templatePath - Optional path to a custom .eta template file
+ * @returns Rendered string
+ */
+export declare function renderTemplate(example: Example, templatePath?: string): Promise<string>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/templates/guide-renderer.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Guide hydration renderer — expands example references in standalone
+ * markdown guides that reference files/regions from *any* scanned example.
+ *
+ * Unlike prose helpers (scoped to a single example), the guide renderer
+ * creates a cross-example lookup so authors can write:
+ *
+ * ```markdown
+ * <%= example('basic-usage').file('scan.ts') %>
+ * <%= example('basic-usage').region('config-setup') %>
+ * ```
+ */
+import type { ExampleFile, ScannedExample } from '@functional-examples/devkit';
+/**
+ * A renderer that expands example references in guide markdown.
+ */
+export interface GuideRenderer {
+    /** Render a markdown string, expanding example references. */
+    render(markdown: string): string;
+    /** Read a markdown file and render it, expanding example references. */
+    renderFile(filePath: string): Promise<string>;
+}
+/**
+ * Scoped API returned by `example(id)` inside guide templates.
+ */
+export interface ExampleAccessor {
+    /** Render a file as a fenced code block. */
+    file(relativePath: string): string;
+    /** Render a region/hunk as a fenced code block. */
+    region(regionId: string): string;
+    /** All files in the example. */
+    files: ExampleFile[];
+    /** The example's metadata. */
+    metadata: Record<string, unknown>;
+    /** The example's title. */
+    title: string;
+    /** The example's description. */
+    description?: string;
+}
+/**
+ * Create a guide renderer bound to a set of scanned examples.
+ *
+ * Guide templates can reference any example by ID:
+ * ```markdown
+ * <%= example('basic-usage').file('scan.ts') %>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { createGuideRenderer } from '@functional-examples/documentation';
+ * import { scan } from 'functional-examples';
+ *
+ * const { examples } = await scan({ root: workspaceRoot });
+ * const renderer = createGuideRenderer(examples);
+ * const html = await renderer.renderFile('docs/guides/getting-started.md');
+ * ```
+ */
+export declare function createGuideRenderer(examples: ScannedExample[]): GuideRenderer;
+//# sourceMappingURL=guide-renderer.d.ts.map

package/dist/templates/helpers.d.ts

@@ -0,0 +1,45 @@
+import type { ExampleFile } from '@functional-examples/devkit';
+/**
+ * Infer a code fence language identifier from a file path's extension.
+ */
+export declare function langFromPath(filePath: string): string;
+/**
+ * Select a specific hunk (region) by ID across all files.
+ * Returns the first matching hunk or undefined.
+ */
+export declare function region(files: ExampleFile[], regionId: string): {
+    file: ExampleFile;
+    content: string;
+} | undefined;
+/**
+ * Filter files by extension.
+ */
+export declare function filesByExt(files: ExampleFile[], ext: string): ExampleFile[];
+/**
+ * Check whether a file is a prose/documentation file (e.g. README.md).
+ */
+export declare function isProseFile(file: ExampleFile): boolean;
+/**
+ * Look up a hunk description from the docs metadata.
+ * Returns the description string or undefined.
+ */
+export declare function hunkDescription(metadata: Record<string, unknown>, hunkId: string): string | undefined;
+/**
+ * Convert a string to a URL-friendly slug.
+ * Strips backticks, lowercases, replaces non-alphanumeric runs with dashes,
+ * and trims leading/trailing dashes.
+ */
+export declare function slugify(text: string): string;
+/**
+ * Collected template helpers exposed as `it.helpers`.
+ */
+export declare const templateHelpers: {
+    readonly langFromPath: typeof langFromPath;
+    readonly region: typeof region;
+    readonly filesByExt: typeof filesByExt;
+    readonly isProseFile: typeof isProseFile;
+    readonly hunkDescription: typeof hunkDescription;
+    readonly slugify: typeof slugify;
+};
+export type TemplateHelpers = typeof templateHelpers;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/templates/prose-helpers.d.ts

@@ -0,0 +1,26 @@
+import type { ExampleFile } from '@functional-examples/devkit';
+import { ConsumptionTracker } from './consumption-tracker.js';
+import { templateHelpers } from './helpers.js';
+/** Helpers injected into prose Eta templates as top-level variables. */
+export interface ProseHelpers {
+    /** Render a file as a fenced code block and mark it consumed. */
+    file: (relativePath: string) => string;
+    /** Render a region/hunk as a fenced code block and mark its file consumed. */
+    region: (regionId: string) => string;
+    /** All example files (read-only). */
+    files: ExampleFile[];
+    /** Standard template helpers (langFromPath, slugify, etc.). */
+    helpers: typeof templateHelpers;
+}
+/**
+ * Build a fenced code block string for a given language and content.
+ */
+export declare function fencedBlock(lang: string, content: string): string;
+/**
+ * Create prose-template helpers bound to a specific set of files and tracker.
+ *
+ * These helpers are injected into Eta prose templates via `functionHeader`
+ * so authors can write `<%= file('utils.ts') %>` instead of `<%= it.file('utils.ts') %>`.
+ */
+export declare function createProseHelpers(files: ExampleFile[], tracker: ConsumptionTracker): ProseHelpers;
+//# sourceMappingURL=prose-helpers.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@functional-examples/documentation",
-  "version": "0.0.0-alpha.3",
+  "version": "0.0.1",
   "type": "module",
   "description": "Documentation generation plugin for functional-examples",
   "publishConfig": {
@@ -20,7 +20,7 @@
     "templates"
   ],
   "peerDependencies": {
-    "functional-examples": "0.0.0-alpha.3"
+    "functional-examples": "0.0.1"
   },
   "peerDependenciesMeta": {
     "yaml": {
@@ -31,15 +31,15 @@
     "cli-forge": "1.2.0",
     "eta": "^3.5.0",
     "zod": "4.3.6",
-    "@functional-examples/devkit": "0.0.0-alpha.3"
+    "@functional-examples/devkit": "0.0.1"
   },
   "devDependencies": {
     "@types/node": "22.19.8",
     "typescript": "^5.7.2",
     "vitest": "^1.3.1",
     "yaml": "^2.7.1",
-    "functional-examples": "0.0.0-alpha.3",
-    "@functional-examples/devkit": "0.0.0-alpha.3"
+    "@functional-examples/devkit": "0.0.1",
+    "functional-examples": "0.0.1"
   },
   "license": "MIT",
   "author": {

package/dist/renderers/markdoc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdoc.d.ts","sourceRoot":"","sources":["../../src/renderers/markdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,IAAI,QAAQ,CAkChD"}

package/dist/renderers/markdoc.js

@@ -1,42 +0,0 @@
-/**
- * Markdoc renderer — wraps code blocks with Markdoc-style fence annotations.
- *
- * Converts standard Markdown code fences into Markdoc-annotated fences:
- *   ```typescript        →  ```typescript {% process=true %}
- *   code                     code
- *   ```                      ```
- *
- * Also converts headings to Markdoc-annotated headings with auto-generated IDs.
- */
-export function createMarkdocRenderer() {
-    return {
-        extension: '.mdoc',
-        render(content) {
-            const lines = content.split('\n');
-            const result = [];
-            for (const line of lines) {
-                // Annotate code fences with Markdoc attributes
-                const fenceMatch = line.match(/^(```\w+)\s*$/);
-                if (fenceMatch) {
-                    result.push(`${fenceMatch[1]} {% process=true %}`);
-                    continue;
-                }
-                // Annotate headings with auto-generated IDs
-                const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-                if (headingMatch) {
-                    const [, hashes, text] = headingMatch;
-                    const id = text
-                        .replace(/`/g, '')
-                        .toLowerCase()
-                        .replace(/[^a-z0-9]+/g, '-')
-                        .replace(/^-|-$/g, '');
-                    result.push(`${hashes} ${text} {% #${id} %}`);
-                    continue;
-                }
-                result.push(line);
-            }
-            return result.join('\n');
-        },
-    };
-}
-//# sourceMappingURL=markdoc.js.map

package/dist/renderers/markdoc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdoc.js","sourceRoot":"","sources":["../../src/renderers/markdoc.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,SAAS,EAAE,OAAO;QAClB,MAAM,CAAC,OAAe;YACpB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAClC,MAAM,MAAM,GAAa,EAAE,CAAC;YAE5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,+CAA+C;gBAC/C,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;gBAC/C,IAAI,UAAU,EAAE,CAAC;oBACf,MAAM,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;oBACnD,SAAS;gBACX,CAAC;gBAED,4CAA4C;gBAC5C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;gBACrD,IAAI,YAAY,EAAE,CAAC;oBACjB,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,YAAY,CAAC;oBACtC,MAAM,EAAE,GAAG,IAAI;yBACZ,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;yBACjB,WAAW,EAAE;yBACb,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;yBAC3B,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;oBACzB,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,IAAI,QAAQ,EAAE,KAAK,CAAC,CAAC;oBAC9C,SAAS;gBACX,CAAC;gBAED,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;YAED,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/renderers/markdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/renderers/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,QAAQ,CAOjD"}

package/dist/renderers/markdown.js

@@ -1,12 +0,0 @@
-/**
- * Markdown renderer — passes template output through as-is.
- */
-export function createMarkdownRenderer() {
-    return {
-        extension: '.md',
-        render(content) {
-            return content;
-        },
-    };
-}
-//# sourceMappingURL=markdown.js.map

package/dist/renderers/markdown.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../src/renderers/markdown.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,SAAS,EAAE,KAAK;QAChB,MAAM,CAAC,OAAe;YACpB,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/renderers/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/renderers/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC"}

package/dist/renderers/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/renderers/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/renderers/types.ts"],"names":[],"mappings":""}

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC7B,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE;QACL,wDAAwD;QACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,8CAA8C;QAC9C,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,iDAAiD;QACjD,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;CAMpB,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,GAAE,0BAA+B,GACvC,kCAAkC,CAOpC"}

package/dist/types.js

@@ -1,20 +0,0 @@
-/**
- * Default option values.
- */
-export const DEFAULTS = {
-    outputDir: './docs',
-    format: 'markdown',
-    enableExtractor: false,
-};
-/**
- * Resolve user options with defaults.
- */
-export function resolveOptions(options = {}) {
-    return {
-        outputDir: options.outputDir ?? DEFAULTS.outputDir,
-        format: options.format ?? DEFAULTS.format,
-        template: options.template,
-        enableExtractor: options.enableExtractor ?? DEFAULTS.enableExtractor,
-    };
-}
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,UAAmB;IAC3B,eAAe,EAAE,KAAK;CAGvB,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,cAAc,CAC5B,UAAsC,EAAE;IAExC,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,QAAQ,CAAC,SAAS;QAClD,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM;QACzC,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,QAAQ,CAAC,eAAe;KACrE,CAAC;AACJ,CAAC"}