@markitdownjs/ast 0.1.1 → 0.1.2

package/dist/__tests__/renderers.test.js

@@ -1,54 +1,54 @@
-import { describe, it, expect } from 'vitest';
-import { MarkdownRenderer } from '../markdown-renderer.js';
-import { HtmlRenderer } from '../html-renderer.js';
-import { PlainTextRenderer } from '../plaintext-renderer.js';
-import { JsonRenderer } from '../json-renderer.js';
-import { createNode } from '@markitdownjs/shared';
+import { describe, it, expect } from "vitest";
+import { MarkdownRenderer } from "../markdown-renderer.js";
+import { HtmlRenderer } from "../html-renderer.js";
+import { PlainTextRenderer } from "../plaintext-renderer.js";
+import { JsonRenderer } from "../json-renderer.js";
+import { createNode } from "@markitdownjs/shared";
 const testAst = createNode({
-    type: 'document',
+    type: "document",
     children: [
         createNode({
-            type: 'heading',
+            type: "heading",
             level: 1,
-            children: [createNode({ type: 'text', value: 'Hello World' })],
+            children: [createNode({ type: "text", value: "Hello World" })],
         }),
         createNode({
-            type: 'paragraph',
-            children: [createNode({ type: 'text', value: 'This is a test document.' })],
+            type: "paragraph",
+            children: [createNode({ type: "text", value: "This is a test document." })],
         }),
     ],
 });
-describe('MarkdownRenderer', () => {
-    it('should render AST to markdown', () => {
+describe("MarkdownRenderer", () => {
+    it("should render AST to markdown", () => {
         const renderer = new MarkdownRenderer();
         const md = renderer.render(testAst);
-        expect(md).toContain('# Hello World');
-        expect(md).toContain('This is a test document.');
+        expect(md).toContain("# Hello World");
+        expect(md).toContain("This is a test document.");
     });
 });
-describe('HtmlRenderer', () => {
-    it('should render AST to HTML', () => {
+describe("HtmlRenderer", () => {
+    it("should render AST to HTML", () => {
         const renderer = new HtmlRenderer();
         const html = renderer.render(testAst);
-        expect(html).toContain('<h1>Hello World</h1>');
-        expect(html).toContain('<p>This is a test document.</p>');
+        expect(html).toContain("<h1>Hello World</h1>");
+        expect(html).toContain("<p>This is a test document.</p>");
     });
 });
-describe('PlainTextRenderer', () => {
-    it('should render AST to plain text', () => {
+describe("PlainTextRenderer", () => {
+    it("should render AST to plain text", () => {
         const renderer = new PlainTextRenderer();
         const text = renderer.render(testAst);
-        expect(text).toContain('Hello World');
-        expect(text).toContain('This is a test document.');
-        expect(text).not.toContain('#');
+        expect(text).toContain("Hello World");
+        expect(text).toContain("This is a test document.");
+        expect(text).not.toContain("#");
     });
 });
-describe('JsonRenderer', () => {
-    it('should render AST to JSON', () => {
+describe("JsonRenderer", () => {
+    it("should render AST to JSON", () => {
         const renderer = new JsonRenderer();
         const json = renderer.render(testAst);
         const parsed = JSON.parse(json);
-        expect(parsed.type).toBe('document');
+        expect(parsed.type).toBe("document");
     });
 });
 //# sourceMappingURL=renderers.test.js.map

package/dist/ast-utils.d.ts

@@ -1,5 +1,5 @@
-import { AnyNode, DocumentNode, HeadingInfo } from '@markitdownjs/shared';
-export type { HeadingInfo } from '@markitdownjs/shared';
+import { AnyNode, DocumentNode, HeadingInfo } from "@markitdownjs/shared";
+export type { HeadingInfo } from "@markitdownjs/shared";
 export declare function extractText(node: AnyNode): string;
 export declare function extractHeadings(node: AnyNode): HeadingInfo[];
 export declare function countTokens(node: AnyNode): number;

package/dist/ast-utils.js

@@ -1,9 +1,9 @@
-import { walkAst, getNodeText, findNodesOfType, countTokens as sharedCountTokens, } from '@markitdownjs/shared';
+import { walkAst, getNodeText, findNodesOfType, countTokens as sharedCountTokens, } from "@markitdownjs/shared";
 export function extractText(node) {
     return getNodeText(node);
 }
 export function extractHeadings(node) {
-    const headings = findNodesOfType(node, 'heading');
+    const headings = findNodesOfType(node, "heading");
     return headings.map((h) => ({
         level: h.level,
         text: getNodeText(h),
@@ -16,7 +16,7 @@ export function countTokens(node) {
 export function findNodeById(node, id) {
     let found = null;
     walkAst(node, (n) => {
-        if ('id' in n && n.id === id) {
+        if ("id" in n && n.id === id) {
             found = n;
             return false;
         }
@@ -29,7 +29,7 @@ export function getDepth(node) {
     const visit = (n, depth) => {
         if (depth > maxDepth)
             maxDepth = depth;
-        if ('children' in n && Array.isArray(n.children)) {
+        if ("children" in n && Array.isArray(n.children)) {
             for (const child of n.children) {
                 visit(child, depth + 1);
             }
@@ -54,7 +54,7 @@ export function mergeDocuments(...nodes) {
         }
     }
     return {
-        type: 'document',
+        type: "document",
         children,
     };
 }

package/dist/html-renderer.d.ts

@@ -1,4 +1,4 @@
-import { AnyNode } from '@markitdownjs/shared';
+import { AnyNode } from "@markitdownjs/shared";
 export declare class HtmlRenderer {
     render(node: AnyNode): string;
     private renderTable;

package/dist/html-renderer.js

@@ -1,140 +1,140 @@
-import { getNodeText, } from '@markitdownjs/shared';
+import { getNodeText, } from "@markitdownjs/shared";
 function escapeHtml(text) {
     return text
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#39;');
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
 }
 export class HtmlRenderer {
     render(node) {
         switch (node.type) {
-            case 'document': {
+            case "document": {
                 const children = node.children ?? [];
-                return '<div>' + children.map((c) => this.render(c)).join('\n') + '</div>';
+                return "<div>" + children.map((c) => this.render(c)).join("\n") + "</div>";
             }
-            case 'heading': {
+            case "heading": {
                 const heading = node;
                 const tag = `h${heading.level}`;
-                const id = heading.id ? ` id="${heading.id}"` : '';
-                const children = heading.children.map((c) => this.render(c)).join('');
+                const id = heading.id ? ` id="${heading.id}"` : "";
+                const children = heading.children.map((c) => this.render(c)).join("");
                 return `<${tag}${id}>${children}</${tag}>`;
             }
-            case 'paragraph': {
+            case "paragraph": {
                 const paragraph = node;
-                const children = paragraph.children.map((c) => this.render(c)).join('');
+                const children = paragraph.children.map((c) => this.render(c)).join("");
                 return `<p>${children}</p>`;
             }
-            case 'text': {
+            case "text": {
                 return escapeHtml(node.value);
             }
-            case 'emphasis': {
+            case "emphasis": {
                 const emphasis = node;
-                const children = emphasis.children.map((c) => this.render(c)).join('');
+                const children = emphasis.children.map((c) => this.render(c)).join("");
                 return `<em>${children}</em>`;
             }
-            case 'strong': {
+            case "strong": {
                 const strong = node;
-                const children = strong.children.map((c) => this.render(c)).join('');
+                const children = strong.children.map((c) => this.render(c)).join("");
                 return `<strong>${children}</strong>`;
             }
-            case 'inline-code': {
+            case "inline-code": {
                 return `<code>${escapeHtml(node.value)}</code>`;
             }
-            case 'code': {
+            case "code": {
                 const code = node;
-                const lang = code.language ? ` class="language-${code.language}"` : '';
+                const lang = code.language ? ` class="language-${code.language}"` : "";
                 return `<pre><code${lang}>${escapeHtml(code.value)}</code></pre>`;
             }
-            case 'link': {
+            case "link": {
                 const link = node;
-                const children = link.children.map((c) => this.render(c)).join('');
-                const title = link.title ? ` title="${escapeHtml(link.title)}"` : '';
+                const children = link.children.map((c) => this.render(c)).join("");
+                const title = link.title ? ` title="${escapeHtml(link.title)}"` : "";
                 return `<a href="${escapeHtml(link.href)}"${title}>${children}</a>`;
             }
-            case 'image': {
+            case "image": {
                 const image = node;
-                const alt = image.alt ? ` alt="${escapeHtml(image.alt)}"` : '';
-                const title = image.title ? ` title="${escapeHtml(image.title)}"` : '';
+                const alt = image.alt ? ` alt="${escapeHtml(image.alt)}"` : "";
+                const title = image.title ? ` title="${escapeHtml(image.title)}"` : "";
                 return `<img src="${escapeHtml(image.src)}"${alt}${title} />`;
             }
-            case 'list': {
+            case "list": {
                 const list = node;
-                const tag = list.ordered ? 'ol' : 'ul';
-                const children = list.children.map((c) => this.render(c)).join('\n');
+                const tag = list.ordered ? "ol" : "ul";
+                const children = list.children.map((c) => this.render(c)).join("\n");
                 return `<${tag}>\n${children}\n</${tag}>`;
             }
-            case 'list-item': {
+            case "list-item": {
                 const listItem = node;
-                const children = listItem.children.map((c) => this.render(c)).join('');
+                const children = listItem.children.map((c) => this.render(c)).join("");
                 return `<li>${children}</li>`;
             }
-            case 'table': {
+            case "table": {
                 return this.renderTable(node);
             }
-            case 'table-row': {
+            case "table-row": {
                 const row = node;
-                const tag = row.isHeader ? 'th' : 'td';
+                const tag = row.isHeader ? "th" : "td";
                 const cells = row.children.map((c) => {
-                    const content = c.children.map((cc) => this.render(cc)).join('');
+                    const content = c.children.map((cc) => this.render(cc)).join("");
                     return `<${tag}>${content}</${tag}>`;
                 });
-                return `<tr>\n${cells.join('\n')}\n</tr>`;
+                return `<tr>\n${cells.join("\n")}\n</tr>`;
             }
-            case 'table-cell': {
+            case "table-cell": {
                 const cell = node;
-                return cell.children.map((c) => this.render(c)).join('');
+                return cell.children.map((c) => this.render(c)).join("");
             }
-            case 'blockquote': {
+            case "blockquote": {
                 const blockquote = node;
-                const children = blockquote.children.map((c) => this.render(c)).join('\n');
+                const children = blockquote.children.map((c) => this.render(c)).join("\n");
                 return `<blockquote>\n${children}\n</blockquote>`;
             }
-            case 'thematic-break':
-            case 'horizontal-rule':
-                return '<hr />';
-            case 'html': {
+            case "thematic-break":
+            case "horizontal-rule":
+                return "<hr />";
+            case "html": {
                 return node.value;
             }
-            case 'footnote': {
+            case "footnote": {
                 const footnote = node;
                 const id = footnote.identifier;
                 return `<sup><a href="#fn-${id}">${id}</a></sup>`;
             }
-            case 'page-break':
+            case "page-break":
                 return '<div class="page-break"></div>';
-            case 'section': {
+            case "section": {
                 const section = node;
-                const children = section.children.map((c) => this.render(c)).join('\n');
+                const children = section.children.map((c) => this.render(c)).join("\n");
                 return `<section>\n${children}\n</section>`;
             }
-            case 'strikethrough': {
+            case "strikethrough": {
                 const strikethrough = node;
-                const children = strikethrough.children.map((c) => this.render(c)).join('');
+                const children = strikethrough.children.map((c) => this.render(c)).join("");
                 return `<del>${children}</del>`;
             }
-            case 'math': {
+            case "math": {
                 const math = node;
                 return `<span class="math">${escapeHtml(math.value)}</span>`;
             }
-            case 'raw': {
+            case "raw": {
                 return node.value;
             }
-            case 'definition':
-            case 'quote':
-            case 'subscript':
-            case 'superscript': {
+            case "definition":
+            case "quote":
+            case "subscript":
+            case "superscript": {
                 return escapeHtml(getNodeText(node));
             }
             default:
-                return '';
+                return "";
         }
     }
     renderTable(table) {
         const rows = table.children;
         if (rows.length === 0)
-            return '';
+            return "";
         let hasHeader = false;
         const bodyRows = [];
         for (const row of rows) {
@@ -146,20 +146,20 @@ export class HtmlRenderer {
             }
         }
         const renderRow = (row) => {
-            return '<tr>\n' + row.children.map((c) => this.render(c)).join('\n') + '\n</tr>';
+            return "<tr>\n" + row.children.map((c) => this.render(c)).join("\n") + "\n</tr>";
         };
-        let html = '<table>\n';
+        let html = "<table>\n";
         if (hasHeader) {
             const headerRow = rows.find((r) => r.isHeader);
             if (headerRow) {
-                html += '<thead>\n' + renderRow(headerRow) + '\n</thead>\n';
+                html += "<thead>\n" + renderRow(headerRow) + "\n</thead>\n";
             }
         }
-        html += '<tbody>\n';
+        html += "<tbody>\n";
         for (const row of bodyRows) {
-            html += renderRow(row) + '\n';
+            html += renderRow(row) + "\n";
         }
-        html += '</tbody>\n</table>';
+        html += "</tbody>\n</table>";
         return html;
     }
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { MarkdownRenderer } from './markdown-renderer.js';
-export { HtmlRenderer } from './html-renderer.js';
-export { PlainTextRenderer } from './plaintext-renderer.js';
-export { JsonRenderer } from './json-renderer.js';
-export * from './ast-utils.js';
+export { MarkdownRenderer } from "./markdown-renderer.js";
+export { HtmlRenderer } from "./html-renderer.js";
+export { PlainTextRenderer } from "./plaintext-renderer.js";
+export { JsonRenderer } from "./json-renderer.js";
+export * from "./ast-utils.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,6 @@
-export { MarkdownRenderer } from './markdown-renderer.js';
-export { HtmlRenderer } from './html-renderer.js';
-export { PlainTextRenderer } from './plaintext-renderer.js';
-export { JsonRenderer } from './json-renderer.js';
-export * from './ast-utils.js';
+export { MarkdownRenderer } from "./markdown-renderer.js";
+export { HtmlRenderer } from "./html-renderer.js";
+export { PlainTextRenderer } from "./plaintext-renderer.js";
+export { JsonRenderer } from "./json-renderer.js";
+export * from "./ast-utils.js";
 //# sourceMappingURL=index.js.map

package/dist/json-renderer.d.ts

@@ -1,4 +1,4 @@
-import { AnyNode } from '@markitdownjs/shared';
+import { AnyNode } from "@markitdownjs/shared";
 export declare class JsonRenderer {
     render(node: AnyNode): string;
 }

package/dist/markdown-renderer.d.ts

@@ -1,4 +1,4 @@
-import { AnyNode } from '@markitdownjs/shared';
+import { AnyNode } from "@markitdownjs/shared";
 export declare class MarkdownRenderer {
     render(node: AnyNode): string;
     private renderTable;

package/dist/markdown-renderer.js

@@ -1,134 +1,134 @@
-import { getNodeText, } from '@markitdownjs/shared';
+import { getNodeText, } from "@markitdownjs/shared";
 export class MarkdownRenderer {
     render(node) {
         switch (node.type) {
-            case 'document': {
+            case "document": {
                 const children = node.children ?? [];
-                return children.map((child) => this.render(child)).join('\n\n');
+                return children.map((child) => this.render(child)).join("\n\n");
             }
-            case 'heading': {
+            case "heading": {
                 const heading = node;
-                const prefix = '#'.repeat(heading.level);
-                const children = heading.children.map((c) => this.render(c)).join('');
+                const prefix = "#".repeat(heading.level);
+                const children = heading.children.map((c) => this.render(c)).join("");
                 return `${prefix} ${children}`;
             }
-            case 'paragraph': {
+            case "paragraph": {
                 const paragraph = node;
-                return paragraph.children.map((c) => this.render(c)).join('');
+                return paragraph.children.map((c) => this.render(c)).join("");
             }
-            case 'text': {
+            case "text": {
                 return node.value;
             }
-            case 'emphasis': {
+            case "emphasis": {
                 const emphasis = node;
-                const children = emphasis.children.map((c) => this.render(c)).join('');
+                const children = emphasis.children.map((c) => this.render(c)).join("");
                 return `*${children}*`;
             }
-            case 'strong': {
+            case "strong": {
                 const strong = node;
-                const children = strong.children.map((c) => this.render(c)).join('');
+                const children = strong.children.map((c) => this.render(c)).join("");
                 return `**${children}**`;
             }
-            case 'inline-code': {
+            case "inline-code": {
                 return `\`${node.value}\``;
             }
-            case 'code': {
+            case "code": {
                 const code = node;
-                const lang = code.language ?? '';
+                const lang = code.language ?? "";
                 return `\`\`\`${lang}\n${code.value}\n\`\`\``;
             }
-            case 'link': {
+            case "link": {
                 const link = node;
-                const children = link.children.map((c) => this.render(c)).join('');
-                const title = link.title ? ` "${link.title}"` : '';
+                const children = link.children.map((c) => this.render(c)).join("");
+                const title = link.title ? ` "${link.title}"` : "";
                 return `[${children}](${link.href}${title})`;
             }
-            case 'image': {
+            case "image": {
                 const image = node;
-                const alt = image.alt ?? '';
-                const title = image.title ? ` "${image.title}"` : '';
+                const alt = image.alt ?? "";
+                const title = image.title ? ` "${image.title}"` : "";
                 return `![${alt}](${image.src}${title})`;
             }
-            case 'list': {
+            case "list": {
                 const list = node;
                 return list.children
                     .map((item, index) => {
-                    const prefix = list.ordered ? `${(list.start ?? 1) + index}. ` : '- ';
-                    const content = item.children.map((c) => this.render(c)).join('');
+                    const prefix = list.ordered ? `${(list.start ?? 1) + index}. ` : "- ";
+                    const content = item.children.map((c) => this.render(c)).join("");
                     return `${prefix}${content}`;
                 })
-                    .join('\n');
+                    .join("\n");
             }
-            case 'list-item': {
+            case "list-item": {
                 const listItem = node;
-                return listItem.children.map((c) => this.render(c)).join('');
+                return listItem.children.map((c) => this.render(c)).join("");
             }
-            case 'table': {
+            case "table": {
                 return this.renderTable(node);
             }
-            case 'table-row': {
+            case "table-row": {
                 const row = node;
-                return '| ' + row.children.map((c) => this.render(c)).join(' | ') + ' |';
+                return "| " + row.children.map((c) => this.render(c)).join(" | ") + " |";
             }
-            case 'table-cell': {
+            case "table-cell": {
                 const cell = node;
-                return cell.children.map((c) => this.render(c)).join('');
+                return cell.children.map((c) => this.render(c)).join("");
             }
-            case 'blockquote': {
+            case "blockquote": {
                 const blockquote = node;
-                const children = blockquote.children.map((c) => this.render(c)).join('\n');
+                const children = blockquote.children.map((c) => this.render(c)).join("\n");
                 return children
-                    .split('\n')
+                    .split("\n")
                     .map((line) => `> ${line}`)
-                    .join('\n');
+                    .join("\n");
             }
-            case 'thematic-break':
-            case 'horizontal-rule':
-                return '---';
-            case 'html': {
+            case "thematic-break":
+            case "horizontal-rule":
+                return "---";
+            case "html": {
                 return node.value;
             }
-            case 'footnote': {
+            case "footnote": {
                 const footnote = node;
-                const children = footnote.children.map((c) => this.render(c)).join('');
+                const children = footnote.children.map((c) => this.render(c)).join("");
                 return `[^${footnote.identifier}]: ${children}`;
             }
-            case 'page-break':
-                return '\n---\n';
-            case 'section': {
+            case "page-break":
+                return "\n---\n";
+            case "section": {
                 const section = node;
-                const children = section.children.map((c) => this.render(c)).join('\n\n');
+                const children = section.children.map((c) => this.render(c)).join("\n\n");
                 return children;
             }
-            case 'strikethrough': {
+            case "strikethrough": {
                 const strikethrough = node;
-                const children = strikethrough.children.map((c) => this.render(c)).join('');
+                const children = strikethrough.children.map((c) => this.render(c)).join("");
                 return `~~${children}~~`;
             }
-            case 'math': {
+            case "math": {
                 const math = node;
                 if (math.inline) {
                     return `$${math.value}$`;
                 }
                 return `$$\n${math.value}\n$$`;
             }
-            case 'raw': {
+            case "raw": {
                 return node.value;
             }
-            case 'definition':
-            case 'quote':
-            case 'subscript':
-            case 'superscript': {
+            case "definition":
+            case "quote":
+            case "subscript":
+            case "superscript": {
                 return getNodeText(node);
             }
             default:
-                return '';
+                return "";
         }
     }
     renderTable(table) {
         const rows = table.children;
         if (rows.length === 0)
-            return '';
+            return "";
         const columnCount = Math.max(...rows.map((r) => r.children.length));
         const widths = Array.from({ length: columnCount }, () => 0);
         for (const row of rows) {
@@ -146,16 +146,16 @@ export class MarkdownRenderer {
             const cells = [];
             for (let ci = 0; ci < columnCount; ci++) {
                 const cell = row.children[ci];
-                const text = cell ? getNodeText(cell) : '';
+                const text = cell ? getNodeText(cell) : "";
                 const width = widths[ci] ?? 0;
                 cells.push(text.padEnd(width));
             }
-            lines.push('| ' + cells.join(' | ') + ' |');
+            lines.push("| " + cells.join(" | ") + " |");
             if (row.isHeader) {
-                lines.push('| ' + widths.map((w) => '-'.repeat(w)).join(' | ') + ' |');
+                lines.push("| " + widths.map((w) => "-".repeat(w)).join(" | ") + " |");
             }
         }
-        return lines.join('\n');
+        return lines.join("\n");
     }
 }
 //# sourceMappingURL=markdown-renderer.js.map

package/dist/plaintext-renderer.d.ts

@@ -1,4 +1,4 @@
-import { AnyNode } from '@markitdownjs/shared';
+import { AnyNode } from "@markitdownjs/shared";
 export declare class PlainTextRenderer {
     render(node: AnyNode): string;
     private renderTable;

package/dist/plaintext-renderer.js

@@ -1,130 +1,130 @@
-import { getNodeText, } from '@markitdownjs/shared';
+import { getNodeText, } from "@markitdownjs/shared";
 export class PlainTextRenderer {
     render(node) {
         switch (node.type) {
-            case 'document': {
+            case "document": {
                 const children = node.children ?? [];
-                return children.map((c) => this.render(c)).join('\n\n');
+                return children.map((c) => this.render(c)).join("\n\n");
             }
-            case 'heading': {
+            case "heading": {
                 const heading = node;
-                return heading.children.map((c) => this.render(c)).join('');
+                return heading.children.map((c) => this.render(c)).join("");
             }
-            case 'paragraph': {
+            case "paragraph": {
                 const paragraph = node;
-                return paragraph.children.map((c) => this.render(c)).join('');
+                return paragraph.children.map((c) => this.render(c)).join("");
             }
-            case 'text': {
+            case "text": {
                 return node.value;
             }
-            case 'emphasis': {
+            case "emphasis": {
                 const emphasis = node;
-                return emphasis.children.map((c) => this.render(c)).join('');
+                return emphasis.children.map((c) => this.render(c)).join("");
             }
-            case 'strong': {
+            case "strong": {
                 const strong = node;
-                return strong.children.map((c) => this.render(c)).join('');
+                return strong.children.map((c) => this.render(c)).join("");
             }
-            case 'inline-code': {
+            case "inline-code": {
                 return node.value;
             }
-            case 'code': {
+            case "code": {
                 const code = node;
                 return code.value;
             }
-            case 'link': {
+            case "link": {
                 const link = node;
-                return link.children.map((c) => this.render(c)).join('');
+                return link.children.map((c) => this.render(c)).join("");
             }
-            case 'image': {
+            case "image": {
                 const image = node;
-                return image.alt ?? '';
+                return image.alt ?? "";
             }
-            case 'list': {
+            case "list": {
                 const list = node;
                 return list.children
                     .map((item, index) => {
-                    const prefix = list.ordered ? `${(list.start ?? 1) + index}. ` : '- ';
-                    const content = item.children.map((c) => this.render(c)).join('');
+                    const prefix = list.ordered ? `${(list.start ?? 1) + index}. ` : "- ";
+                    const content = item.children.map((c) => this.render(c)).join("");
                     return `${prefix}${content}`;
                 })
-                    .join('\n');
+                    .join("\n");
             }
-            case 'list-item': {
+            case "list-item": {
                 const listItem = node;
-                return listItem.children.map((c) => this.render(c)).join('');
+                return listItem.children.map((c) => this.render(c)).join("");
             }
-            case 'table': {
+            case "table": {
                 return this.renderTable(node);
             }
-            case 'table-row': {
+            case "table-row": {
                 const row = node;
-                return row.children.map((c) => this.render(c)).join('\t');
+                return row.children.map((c) => this.render(c)).join("\t");
             }
-            case 'table-cell': {
+            case "table-cell": {
                 const cell = node;
-                return cell.children.map((c) => this.render(c)).join('');
+                return cell.children.map((c) => this.render(c)).join("");
             }
-            case 'blockquote': {
+            case "blockquote": {
                 const blockquote = node;
-                const children = blockquote.children.map((c) => this.render(c)).join('\n');
+                const children = blockquote.children.map((c) => this.render(c)).join("\n");
                 return children
-                    .split('\n')
+                    .split("\n")
                     .map((line) => `> ${line}`)
-                    .join('\n');
+                    .join("\n");
             }
-            case 'thematic-break':
-            case 'horizontal-rule':
-                return '---';
-            case 'html': {
+            case "thematic-break":
+            case "horizontal-rule":
+                return "---";
+            case "html": {
                 return node.value;
             }
-            case 'footnote': {
+            case "footnote": {
                 const footnote = node;
-                const children = footnote.children.map((c) => this.render(c)).join('');
+                const children = footnote.children.map((c) => this.render(c)).join("");
                 return `[${footnote.identifier}]: ${children}`;
             }
-            case 'page-break':
-                return '\n---\n';
-            case 'section': {
+            case "page-break":
+                return "\n---\n";
+            case "section": {
                 const section = node;
-                return section.children.map((c) => this.render(c)).join('\n\n');
+                return section.children.map((c) => this.render(c)).join("\n\n");
             }
-            case 'strikethrough': {
+            case "strikethrough": {
                 const strikethrough = node;
-                return strikethrough.children.map((c) => this.render(c)).join('');
+                return strikethrough.children.map((c) => this.render(c)).join("");
             }
-            case 'math': {
+            case "math": {
                 return node.value;
             }
-            case 'raw': {
+            case "raw": {
                 return node.value;
             }
-            case 'definition':
-            case 'quote':
-            case 'subscript':
-            case 'superscript': {
+            case "definition":
+            case "quote":
+            case "subscript":
+            case "superscript": {
                 return getNodeText(node);
             }
             default:
-                return '';
+                return "";
         }
     }
     renderTable(table) {
         const rows = table.children;
         if (rows.length === 0)
-            return '';
+            return "";
         const columnCount = Math.max(...rows.map((r) => r.children.length));
         return rows
             .map((row) => {
             const cells = [];
             for (let i = 0; i < columnCount; i++) {
                 const cell = row.children[i];
-                cells.push(cell ? this.render(cell) : '');
+                cells.push(cell ? this.render(cell) : "");
             }
-            return cells.join('\t');
+            return cells.join("\t");
         })
-            .join('\n');
+            .join("\n");
     }
 }
 //# sourceMappingURL=plaintext-renderer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markitdownjs/ast",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Unified AST types and renderers for MarkItDownJS",
   "license": "MIT",
   "type": "module",
@@ -17,7 +17,7 @@
     "dist"
   ],
   "dependencies": {
-    "@markitdownjs/shared": "0.1.1"
+    "@markitdownjs/shared": "0.2.0"
   },
   "devDependencies": {
     "typescript": "^5.5.0"