emdp 1.0.0

package/dist/parser/gfm/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GFM parser entry point that exposes the CommonMark superset with GFM extensions.
+ */
+import type { DocumentNode, ParseOptions, RenderOptions } from '../types.js';
+import { GFMBlockParser } from './block-parser.js';
+import { GFMInlineParser } from './inline-parser.js';
+import { GFMHtmlRenderer } from './renderer.js';
+export { GFMBlockParser } from './block-parser.js';
+export { GFMInlineParser } from './inline-parser.js';
+export { GFMHtmlRenderer } from './renderer.js';
+export declare class GFMParser {
+    private blockParser;
+    private inlineParser;
+    private options;
+    constructor(options?: ParseOptions);
+    parse(input: string): DocumentNode;
+    private processInlines;
+}
+export declare function parse(input: string, options?: ParseOptions): DocumentNode;
+export declare function render(document: DocumentNode, options?: RenderOptions): string;
+export declare function gfm(input: string, options?: ParseOptions & RenderOptions): string;
+declare const _default: {
+    parse: typeof parse;
+    render: typeof render;
+    gfm: typeof gfm;
+    GFMParser: typeof GFMParser;
+    GFMBlockParser: typeof GFMBlockParser;
+    GFMInlineParser: typeof GFMInlineParser;
+    GFMHtmlRenderer: typeof GFMHtmlRenderer;
+};
+export default _default;

package/dist/parser/gfm/index.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * GFM parser entry point that exposes the CommonMark superset with GFM extensions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GFMParser = exports.GFMHtmlRenderer = exports.GFMInlineParser = exports.GFMBlockParser = void 0;
+exports.parse = parse;
+exports.render = render;
+exports.gfm = gfm;
+const block_parser_js_1 = require("./block-parser.js");
+const inline_parser_js_1 = require("./inline-parser.js");
+const renderer_js_1 = require("./renderer.js");
+var block_parser_js_2 = require("./block-parser.js");
+Object.defineProperty(exports, "GFMBlockParser", { enumerable: true, get: function () { return block_parser_js_2.GFMBlockParser; } });
+var inline_parser_js_2 = require("./inline-parser.js");
+Object.defineProperty(exports, "GFMInlineParser", { enumerable: true, get: function () { return inline_parser_js_2.GFMInlineParser; } });
+var renderer_js_2 = require("./renderer.js");
+Object.defineProperty(exports, "GFMHtmlRenderer", { enumerable: true, get: function () { return renderer_js_2.GFMHtmlRenderer; } });
+const DEFAULT_GFM_EXTENSIONS = new Set([
+    'table',
+    'strikethrough',
+    'tasklist',
+    'autolink',
+    'tagfilter',
+    'footnotes',
+]);
+function normalizeExtensions(extensions) {
+    if (extensions === undefined) {
+        return new Set(DEFAULT_GFM_EXTENSIONS);
+    }
+    return new Set(extensions.map(ext => ext.trim()).filter(Boolean));
+}
+class GFMParser {
+    blockParser;
+    inlineParser;
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        const extensions = normalizeExtensions(options.extensions);
+        this.blockParser = new block_parser_js_1.GFMBlockParser(extensions);
+        this.inlineParser = new inline_parser_js_1.GFMInlineParser(extensions);
+    }
+    parse(input) {
+        const { document, linkReferences, footnoteDefinitions } = this.blockParser.parse(input);
+        this.inlineParser.setLinkReferences(linkReferences);
+        this.inlineParser.setFootnoteDefinitions(footnoteDefinitions);
+        this.processInlines(document, linkReferences, footnoteDefinitions);
+        document.footnoteDefinitions = footnoteDefinitions;
+        return document;
+    }
+    processInlines(document, linkReferences, footnoteDefinitions) {
+        const processBlock = (block) => {
+            if (block.type === 'paragraph') {
+                const para = block;
+                const rawContent = para.rawContent;
+                if (rawContent) {
+                    para.children = this.inlineParser.parse(rawContent);
+                    delete para.rawContent;
+                }
+            }
+            else if (block.type === 'heading') {
+                const heading = block;
+                const rawContent = heading.rawContent;
+                if (rawContent) {
+                    heading.children = this.inlineParser.parse(rawContent);
+                    delete heading.rawContent;
+                }
+            }
+            else if (block.type === 'blockquote') {
+                block.children.forEach(processBlock);
+            }
+            else if (block.type === 'list') {
+                block.children.forEach(item => {
+                    item.children.forEach(processBlock);
+                });
+            }
+            else if (block.type === 'list_item') {
+                block.children.forEach(processBlock);
+            }
+            else if (block.type === 'table') {
+                const table = block;
+                for (const row of table.children) {
+                    for (const cell of row.children) {
+                        const rawContent = cell.rawContent;
+                        if (rawContent !== undefined) {
+                            cell.children = this.inlineParser.parse(rawContent);
+                            delete cell.rawContent;
+                        }
+                    }
+                }
+            }
+        };
+        document.children.forEach(processBlock);
+        footnoteDefinitions.forEach(def => {
+            def.blocks.forEach(processBlock);
+        });
+    }
+}
+exports.GFMParser = GFMParser;
+function parse(input, options) {
+    const parser = new GFMParser(options);
+    return parser.parse(input);
+}
+function render(document, options) {
+    const renderer = new renderer_js_1.GFMHtmlRenderer(options);
+    return renderer.render(document);
+}
+function gfm(input, options) {
+    const extensions = normalizeExtensions(options?.extensions);
+    const document = parse(input, { ...options, extensions: Array.from(extensions) });
+    const renderOptions = {
+        ...options,
+        tagfilter: options?.tagfilter ?? extensions.has('tagfilter'),
+    };
+    return render(document, renderOptions);
+}
+exports.default = {
+    parse,
+    render,
+    gfm,
+    GFMParser,
+    GFMBlockParser: block_parser_js_1.GFMBlockParser,
+    GFMInlineParser: inline_parser_js_1.GFMInlineParser,
+    GFMHtmlRenderer: renderer_js_1.GFMHtmlRenderer,
+};

package/dist/parser/gfm/inline-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GFM inline parser that extends CommonMark with strikethrough and extended autolinks.
+ */
+import type { InlineNode, LinkReferenceDefinition, FootnoteDefinition } from '../types.js';
+export declare class GFMInlineParser {
+    private linkReferences;
+    private footnoteDefinitions;
+    private enableAutolink;
+    private enableStrikethrough;
+    private enableFootnotes;
+    private enableTagfilter;
+    constructor(extensions?: Set<string>);
+    setLinkReferences(refs: Map<string, LinkReferenceDefinition>): void;
+    setFootnoteDefinitions(defs: Map<string, FootnoteDefinition>): void;
+    parse(text: string): InlineNode[];
+    private extractTextFromNodes;
+    private normalizeLabelForMatching;
+    private processEmphasisAndStrikethrough;
+    private processStrikethrough;
+    private processEmphasis;
+    private flattenNestedEmphasis;
+    private computeDelimiterRun;
+    private getFirstChar;
+    private getLastChar;
+}