@minamorl/markdown-next 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 minamorl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# @minamorl/markdown-next
+
+A markdown parser that outputs either HTML strings or an AST you can render however you want. Built with [Parsimmon](https://github.com/jneen/parsimmon).
+
+What makes it different:
+- **AST output** for React/Vue/custom renderers (not just HTML strings)
+- **Aozora bunko ruby** syntax: `｜漢字《かんじ》`
+- **HTML passthrough**: write `<cite>` or `<ruby>` directly in your markdown
+- **Plugin system**: define custom `@[plugin:args]` blocks
+
+## Installation
+
+```bash
+npm install @minamorl/markdown-next
+```
+
+## Basic Usage
+
+The simplest way to get HTML:
+
+```typescript
+import { parse } from '@minamorl/markdown-next'
+
+parse('# Hello **world**')
+// '<h1>Hello <strong>world</strong></h1>'
+```
+
+## Getting an AST Instead
+
+If you're building a React app or need fine-grained control over rendering, use the AST output:
+
+```typescript
+import { Parser, asAST } from '@minamorl/markdown-next'
+
+const parser = new Parser({ export: asAST })
+const ast = parser.parse('# Hello **world**')
+```
+
+The AST uses a simple tuple format: `[tagName, attributes, children]`
+
+```typescript
+// Input: '# Hello **world**'
+// Output:
+[
+  ['h1', null, ['Hello ', ['strong', null, 'world']]]
+]
+```
+
+### Rendering AST in React
+
+Here's a minimal renderer:
+
+```tsx
+import { Parser, asAST, ASTNode } from '@minamorl/markdown-next'
+
+function renderNode(node: ASTNode, key: number = 0): React.ReactNode {
+  if (typeof node === 'string') return node
+  if (!Array.isArray(node)) return null
+
+  const [tag, attrs, children] = node
+
+  // Self-closing tags
+  if (tag === 'img' || tag === 'br' || tag === 'hr') {
+    return React.createElement(tag, { ...attrs, key })
+  }
+
+  // Recursively render children
+  const kids = Array.isArray(children)
+    ? children.map((child, i) => renderNode(child, i))
+    : renderNode(children, 0)
+
+  return React.createElement(tag, { ...attrs, key }, kids)
+}
+
+// Usage
+const parser = new Parser({ export: asAST })
+
+function Markdown({ content }: { content: string }) {
+  const ast = parser.parse(content)
+  return <>{ast.map((node, i) => renderNode(node, i))}</>
+}
+```
+
+## Japanese Ruby Annotations
+
+Supports [Aozora bunko](https://www.aozora.gr.jp/) ruby syntax, commonly used in Japanese publishing:
+
+```typescript
+parse('｜漢字《かんじ》')
+// '<p><ruby>漢字<rt>かんじ</rt></ruby></p>'
+
+parse('This is ｜日本語《にほんご》 text')
+// '<p>This is <ruby>日本語<rt>にほんご</rt></ruby> text</p>'
+```
+
+The `｜` (full-width pipe) marks the start of the base text, and `《》` contains the ruby reading.
+
+## HTML Passthrough
+
+Sometimes you need HTML that markdown doesn't support. Just write it:
+
+```typescript
+parse('<cite>The Art of Computer Programming</cite>')
+// '<p><cite>The Art of Computer Programming</cite></p>'
+
+parse('<ruby>東京<rt>とうきょう</rt></ruby>')
+// '<p><ruby>東京<rt>とうきょう</rt></ruby></p>'
+
+parse('<details><summary>Click me</summary>Hidden content</details>')
+// '<p><details><summary>Click me</summary>Hidden content</details></p>'
+```
+
+## Plugins
+
+Define custom syntax with plugins. Useful for embeds, custom components, or domain-specific markup.
+
+```typescript
+const parser = new Parser({
+  export: asHTML,
+  plugins: {
+    youtube: (args) => {
+      return `<iframe src="https://youtube.com/embed/${args}" frameborder="0"></iframe>`
+    },
+    note: (args, content, mapper) => {
+      return mapper('div', { class: `note note-${args || 'info'}` })(content)
+    }
+  }
+})
+
+// Inline plugin
+parser.parse('Check this video: @[youtube:dQw4w9WgXcQ]')
+
+// Block plugin with content
+parser.parse(`
+@[note:warning]
+  This is important
+`)
+```
+
+Plugin function signature:
+```typescript
+type Plugin = (
+  args: string,           // Everything after the colon
+  content: Content,       // Parsed content (for block plugins)
+  mapper: ElementMapper,  // Helper to create elements
+  join: JoinFunction      // Helper to join content
+) => string | ASTNode
+```
+
+## Supported Markdown
+
+| Syntax | Example |
+|--------|---------|
+| Headers | `# H1` through `###### H6` |
+| Alt headers | `Header\n===` or `Header\n---` |
+| Bold | `**text**` or `__text__` |
+| Italic | `*text*` or `_text_` |
+| Code | `` `inline` `` or fenced blocks |
+| Links | `[text](url)` |
+| Images | `![alt](src)` |
+| Lists | `- item` or `1. item` |
+| Nested lists | 2-space indent |
+| Blockquotes | `> text` |
+| Tables | `| a | b |` with `|---|---|` separator |
+| Ruby | `｜base《reading》` |
+| HTML | Any valid HTML tag |
+
+## API Reference
+
+### `parse(markdown: string): string`
+
+Quick function for HTML output.
+
+### `Parser<T>`
+
+```typescript
+const parser = new Parser({
+  export: asHTML,  // or asAST
+  plugins: { ... } // optional
+})
+
+parser.parse(markdown) // returns T (string for asHTML, ASTNode[] for asAST)
+```
+
+### `asHTML`
+
+Export type that produces HTML strings.
+
+### `asAST`
+
+Export type that produces an array of AST nodes.
+
+### `ASTNode`
+
+```typescript
+type ASTNode = string | [string, Record<string, string> | null, ASTNode | ASTNode[]]
+```
+
+## Why Another Markdown Parser?
+
+I needed:
+1. Ruby annotation support for Japanese text
+2. AST output for React (not just HTML strings)
+3. Extensibility without forking
+
+Most parsers give you HTML. That's fine until you need to render in React, handle custom components, or process the structure programmatically. The AST output solves this.
+
+The ruby and HTML passthrough features came from working with Japanese content where standard markdown falls short.
+
+## License
+
+MIT

package/lib/src/parser.d.ts

@@ -0,0 +1,38 @@
+import P = require("parsimmon");
+export interface ListTree {
+    type: "ul" | "ol" | "shadow";
+    children: Array<ListTree>;
+    value: string | null;
+    parent: ListTree | null;
+}
+export type Plugin<T> = (args: string, content: any, mapper: Mapper<T>, join: Function) => string;
+export type Mapper<T> = (tagName: string, attributes?: any) => (children: string | T | null) => T;
+export interface ExportType<T> {
+    mapper: Mapper<T>;
+    join: Function;
+    postprocess: (x: any) => any;
+}
+export declare class Parser<T> {
+    opts: {
+        export: ExportType<T>;
+        plugins?: {
+            [pluginName: string]: Plugin<T>;
+        };
+    };
+    liLevelBefore: number | null;
+    liLevel: number | null;
+    rootTree: ListTree;
+    currentTree: ListTree;
+    acceptables: P.Parser<T>;
+    constructor(opts: {
+        export: ExportType<T>;
+        plugins?: {
+            [pluginName: string]: Plugin<T>;
+        };
+    });
+    create(): void;
+    parse(s: string): any;
+}
+export declare const asHTML: ExportType<string>;
+export declare const asAST: ExportType<any>;
+export declare const parse: (s: string) => any;

package/lib/src/parser.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.asAST = exports.asHTML = exports.Parser = void 0;
+const P = require("parsimmon");
+class Parser {
+    constructor(opts) {
+        this.opts = opts;
+        this.liLevelBefore = null;
+        this.liLevel = null;
+        this.rootTree = {
+            value: null,
+            children: [],
+            type: "shadow",
+            parent: null
+        };
+        this.currentTree = {
+            value: null,
+            children: [],
+            type: "shadow",
+            parent: null
+        };
+        this.create();
+    }
+    create() {
+        function flags(re) {
+            var s = '' + re;
+            return s.slice(s.lastIndexOf('/') + 1);
+        }
+        function ignore(re, group = 0) {
+            const { makeSuccess, makeFailure } = P;
+            const anchored = RegExp('^(?:' + re.source + ')', flags(re));
+            const expected = '' + re;
+            return P(function (input, i) {
+                var match = anchored.exec(input.slice(i));
+                if (match) {
+                    var fullMatch = match[0];
+                    var groupMatch = match[group];
+                    if (groupMatch != null) {
+                        return makeFailure(i + fullMatch.length, groupMatch);
+                    }
+                }
+                return makeSuccess(i, expected);
+            });
+        }
+        const whitespace = P.regexp(/\s+/m);
+        const asterisk = P.string("*");
+        const sharp = P.string("#");
+        const plainStr = P.regexp(/[^`_\*\r\n]+/);
+        const codePlainStr = P.regexp(/[^`\r\n]+/);
+        const linebreak = P.string("\r\n").or(P.string("\n")).or(P.string("\r"));
+        const equal = P.string("=");
+        const minus = P.string("-");
+        const join = this.opts.export.join;
+        const mapper = this.opts.export.mapper;
+        const token = (p) => {
+            return p.skip(P.regexp(/\s*/m));
+        };
+        const h1Special = P.regexp(/^(.*)\n\=+/, 1)
+            .skip(P.alt(P.eof, P.string("\n")))
+            .map(mapper("h1"));
+        const h2Special = P.regexp(/^(.*)\n\-+/, 1)
+            .skip(P.alt(P.eof, P.string("\n")))
+            .map(mapper("h2"));
+        const h1 = token(P.seq(sharp, whitespace).then(plainStr)).map(mapper("h1"));
+        const h2 = token(P.seq(sharp.times(2), whitespace).then(plainStr)).map(mapper("h2"));
+        const h3 = token(P.seq(sharp.times(3), whitespace).then(plainStr)).map(mapper("h3"));
+        const h4 = token(P.seq(sharp.times(4), whitespace).then(plainStr)).map(mapper("h4"));
+        const h5 = token(P.seq(sharp.times(5), whitespace).then(plainStr)).map(mapper("h5"));
+        const h6 = token(P.seq(sharp.times(6), whitespace).then(plainStr)).map(mapper("h6"));
+        const strongStart = P.string("**").or(P.string("__"));
+        const strongEnd = strongStart;
+        const strong = strongStart
+            .then(plainStr)
+            .map(mapper("strong"))
+            .skip(strongEnd);
+        const emStart = P.string("*").or(P.string("_"));
+        const emEnd = emStart;
+        const em = emStart
+            .then(plainStr)
+            .map(mapper("em"))
+            .skip(emEnd);
+        const anchor = P.seqMap(P.string("["), P.regexp(/[^\]\r\n]+/), P.string("]("), P.regexp(/[^\)\r\n]+/), P.string(")"), (_1, label, _2, href, _3) => {
+            return mapper("a", { href })(label);
+        });
+        const img = P.seqMap(P.string("!["), P.regexp(/[^\]\r\n]+/), P.string("]("), P.regexp(/[^\)\r\n]+/), P.string(")"), (_1, alt, _2, src, _3) => {
+            return mapper("img", { src, alt })(null);
+        });
+        const codeStart = P.string("`");
+        const codeEnd = P.string("`");
+        const code = codeStart
+            .then(codePlainStr)
+            .map(mapper("code"))
+            .skip(codeEnd);
+        const pluginInline = P.seqMap(P.string("@["), P.regexp(/[a-zA-Z]+/), P.regexp(/:{0,1}([^\]]*)/, 1), P.string("]"), (_1, pluginName, args, _2) => {
+            return this.opts.plugins && this.opts.plugins[pluginName] ?
+                this.opts.plugins[pluginName](args, null, mapper, join) : join([_1, pluginName, args, _2]);
+        });
+        // Aozora bunko ruby format: ｜text《ruby》
+        const aozoraRuby = P.seqMap(P.string("｜"), P.regexp(/[^《]+/), P.string("《"), P.regexp(/[^》]+/), P.string("》"), (_pipe, base, _open, ruby, _close) => {
+            return mapper("ruby")(join([base, mapper("rt")(ruby)]));
+        });
+        // HTML element parser - converts <tag>content</tag> to AST format
+        const htmlSelfClosing = P.regexp(/<(br|hr)\s*\/?>/).map((match) => {
+            var _a;
+            const tag = ((_a = match.match(/<(\w+)/)) === null || _a === void 0 ? void 0 : _a[1]) || 'br';
+            return mapper(tag)(null);
+        });
+        const htmlElement = P.lazy(() => {
+            // Match opening tag with optional attributes
+            const openTag = P.regexp(/<([a-zA-Z][a-zA-Z0-9]*)((?:\s+[^>]*)?)>/, 1);
+            // Content can include nested HTML elements or text
+            const content = P.alt(htmlElement, htmlSelfClosing, P.regexp(/[^<]+/)).many();
+            return P.seqMap(openTag, P.index, content, P.regexp(/<\/([a-zA-Z][a-zA-Z0-9]*)>/, 1), (tag, _idx, children, closeTag) => {
+                if (tag.toLowerCase() !== closeTag.toLowerCase()) {
+                    // Mismatched tags - return as text
+                    return join(['<' + tag + '>', ...children, '</' + closeTag + '>']);
+                }
+                return mapper(tag)(join(children));
+            });
+        });
+        const inline = P.alt(pluginInline, aozoraRuby, anchor, img, em, strong, code, htmlElement, htmlSelfClosing, P.regexp(/[^\r\n<=-\[\]\*\`\@｜]+/), P.regexp(/./));
+        // Table cell content - supports inline elements
+        const tableCellInline = P.alt(anchor, img, em, strong, code, P.regexp(/[^\r\n\[\]\*|`]+/));
+        // Parse a single table row: |cell|cell|cell| with flexible spacing
+        const parseTableRow = (input) => {
+            // Remove leading/trailing pipes and split by pipe
+            const trimmed = input.trim();
+            if (!trimmed.startsWith('|') || !trimmed.endsWith('|')) {
+                return [];
+            }
+            // Remove first and last pipe, split by remaining pipes
+            const inner = trimmed.slice(1, -1);
+            return inner.split('|').map(cell => cell.trim());
+        };
+        // Table row regex - matches |...|
+        const tableRowLine = P.regexp(/^\|[^\r\n]+\|/, 0);
+        // Separator row pattern - matches |---|---|---| with optional alignment markers
+        const separatorRowPattern = /^\|\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|$/;
+        // Check if a row is a separator row
+        const isSeparatorRow = (row) => {
+            return separatorRowPattern.test(row.trim());
+        };
+        // Parse cell content with inline elements
+        const parseCellContent = (content) => {
+            if (!content || content.trim() === '') {
+                return '';
+            }
+            const cellParser = tableCellInline.atLeast(1).map(join);
+            const result = cellParser.parse(content.trim());
+            if (result.status) {
+                return result.value;
+            }
+            return content.trim();
+        };
+        // Table parser
+        const table = P.seqMap(tableRowLine.skip(linebreak), tableRowLine.skip(linebreak), tableRowLine.skip(linebreak.atMost(1)).atLeast(0), (headerLine, sepLine, bodyLines) => {
+            // Validate separator row
+            if (!isSeparatorRow(sepLine)) {
+                return P.makeFailure(0, 'Not a valid table separator');
+            }
+            const headerCells = parseTableRow(headerLine);
+            const bodyCells = bodyLines.map(parseTableRow);
+            if (headerCells.length === 0) {
+                return P.makeFailure(0, 'No header cells');
+            }
+            return mapper("table")(join([
+                mapper("tr")(join(headerCells.map(h => mapper("th")(parseCellContent(h))))),
+                join(bodyCells.map(row => mapper("tr")(join(row.map(cell => mapper("td")(parseCellContent(cell)))))))
+            ]));
+        });
+        const inlines = inline.atLeast(1).map(join);
+        const paragraphBegin = inlines;
+        const paragraphEnd = ignore(/```\n.*\n```/);
+        const paragraphLine = P.lazy(() => P.alt(P.seq(paragraphBegin, linebreak.skip(paragraphEnd).result(mapper("br")(null)), paragraphLine).map(join), inlines));
+        const paragraph = paragraphLine
+            .map(mapper("p"));
+        const listIndent = P.string("  ");
+        const liSingleLine = P.regexp(/[^`\r\n]*/);
+        const ulStart = P.string("- ").or(P.string("* "));
+        const olStart = P.regexp(/[0-9]+\. /);
+        let liLevel = [1];
+        let counter = 0;
+        const initializeList = () => {
+            this.rootTree = this.currentTree = {
+                value: null,
+                children: [],
+                type: "shadow",
+                parent: null
+            };
+            liLevel = [1];
+            counter = 0;
+        };
+        const listLineContent = () => {
+            return P.seqMap(listIndent.many(), P.index, ulStart.or(olStart), liSingleLine, (_1, index, start, str) => {
+                let nodeType;
+                // detect which types of content
+                liLevel.push(index.column);
+                nodeType = ((start == "* ") || (start == "- ")) ? "ul" : "ol";
+                counter += 1;
+                return { counter, nodeType, str, liLevel, index };
+            })
+                .skip(linebreak.atMost(1))
+                .chain(v => {
+                if (v.liLevel.filter(x => x % 2 !== 1).length > 0) {
+                    initializeList();
+                    return P.fail("Invalid indentation");
+                }
+                return P.succeed(v);
+            })
+                .map(v => {
+                const liLevelBefore = liLevel[v.counter - 1];
+                const liLevelCurrent = liLevel[v.counter];
+                if (liLevelBefore === liLevelCurrent) {
+                    this.currentTree.children.push({
+                        value: v.str,
+                        children: [],
+                        type: v.nodeType,
+                        parent: this.currentTree
+                    });
+                }
+                else if (liLevelBefore < liLevelCurrent) {
+                    const currentTreeIndex = this.currentTree.children.length - 1;
+                    this.currentTree = this.currentTree.children[currentTreeIndex];
+                    this.currentTree.children.push({
+                        children: [],
+                        type: v.nodeType,
+                        parent: this.currentTree,
+                        value: v.str
+                    });
+                }
+                else if (liLevelBefore > liLevelCurrent) {
+                    const unindetationStep = (liLevelBefore - liLevelCurrent) / 2;
+                    for (let i = 0; i < unindetationStep; i++) {
+                        if (this.currentTree.parent !== null) {
+                            this.currentTree = this.currentTree.parent;
+                        }
+                    }
+                    this.currentTree.children.push({
+                        type: v.nodeType,
+                        children: [],
+                        parent: this.currentTree,
+                        value: v.str
+                    });
+                }
+                const _nodeType = v.nodeType;
+                return _nodeType;
+            });
+        };
+        const lists = P.lazy(() => {
+            return listLineContent().atLeast(1).map(nodeTypes => {
+                this.rootTree.type = nodeTypes[0];
+                const result = treeToHtml(this.rootTree);
+                // initialization
+                initializeList();
+                return result;
+            });
+        });
+        const treeToHtml = (treeOrNode) => {
+            if (treeOrNode.type === "shadow") {
+                return join(treeOrNode.children.map(treeToHtml));
+            }
+            else if (treeOrNode.children.length === 0 && treeOrNode.value !== null) {
+                return mapper("li")(treeOrNode.value);
+            }
+            else if (treeOrNode.children.length !== 0 && treeOrNode.value !== null) {
+                const { children } = treeOrNode;
+                return mapper("li")(join([treeOrNode.value, mapper(treeOrNode.children[0].type)(join(children.map(treeToHtml)))]));
+            }
+            else {
+                const { children } = treeOrNode;
+                return mapper(treeOrNode.type)(join(children.map(treeToHtml)));
+            }
+        };
+        const codeBlockBegin = P.regexp(/^```/);
+        const codeBlockEnd = P.regexp(/^```/);
+        const codeBlockDefinitionStr = P.regexp(/[^`\r\n]*/);
+        const codeBlockStr = P.regexp(/[^\r\n]+/);
+        const codeBlock = P.seqMap(codeBlockBegin, codeBlockDefinitionStr, linebreak, linebreak.or(codeBlockStr.lookahead(linebreak)).many(), codeBlockEnd, (_1, definition, _2, code, _3) => {
+            if (code.length > 0) {
+                code.pop();
+            }
+            if (definition === "")
+                return mapper("pre")(mapper("code")(join(code)));
+            return mapper("pre", { "data-language": definition })(mapper("code")(join(code)));
+        });
+        const blockquoteBegin = P.string("> ");
+        // Parse blockquote content using inlines to support HTML tags and ruby
+        const blockquoteInline = P.alt(pluginInline, aozoraRuby, anchor, img, em, strong, code, htmlElement, htmlSelfClosing, P.regexp(/[^\r\n<｜\[\]\*\`\@]+/), P.regexp(/./));
+        const blockquoteContent = blockquoteInline.atLeast(1).map(join);
+        const blockquoteLine = P.lazy(() => {
+            let blockquoteLevel = 0;
+            return P.seqMap(blockquoteBegin.then(blockquoteBegin.many().map(x => blockquoteLevel = x.length)), blockquoteContent, linebreak.atMost(1), (_1, text, _2) => {
+                return { text, blockquoteLevel };
+            });
+        });
+        const createBlockquoteTree = (x) => {
+            let depth = 0;
+            let root = { text: null, children: [] };
+            let currentNode = root;
+            for (const o of x) {
+                if (o.blockquoteLevel < depth) {
+                    let node = { text: o.text, children: [], parent: currentNode.parent };
+                    for (let i = 0; i < depth - o.blockquoteLevel; i++) {
+                        if (currentNode.parent) {
+                            currentNode = currentNode.parent;
+                        }
+                    }
+                    node.parent = currentNode;
+                    currentNode.children.push(node);
+                    currentNode = node.parent;
+                    depth = o.blockquoteLevel;
+                }
+                else if (o.blockquoteLevel > depth) {
+                    let node = { text: o.text, children: [], parent: currentNode };
+                    let shadowNode = { text: null, children: [node], parent: currentNode };
+                    node.parent = shadowNode;
+                    currentNode.children.push(shadowNode);
+                    currentNode = shadowNode;
+                    depth = o.blockquoteLevel;
+                }
+                else {
+                    let node = { text: o.text, children: [], parent: currentNode };
+                    currentNode.children.push(node);
+                }
+            }
+            return root;
+        };
+        const parseBlockquoteTree = (tree, isRoot = false) => {
+            let result = [];
+            for (const [i, v] of tree.children.entries()) {
+                if (v.text !== null) {
+                    if (tree.children[i + 1] && tree.children[i + 1].text !== null) {
+                        result.push(join([v.text, mapper("br")(null)]));
+                    }
+                    else {
+                        result.push(v.text);
+                    }
+                }
+                else if (v.children.length !== 0) {
+                    result.push(parseBlockquoteTree(v));
+                }
+            }
+            const _result = mapper("blockquote")(result.reduce((a, b) => join([a, b])));
+            return _result;
+        };
+        const blockquote = P.lazy(() => {
+            return blockquoteLine.atLeast(1).map(x => {
+                return parseBlockquoteTree(createBlockquoteTree(x), true);
+            });
+        });
+        const pluginBlock = P.seqMap(P.string("@["), P.regexp(/[a-zA-Z]+/), P.regexp(/(:[^\]]*)*/), P.string("]\n"), P.seq(P.string("  ").result(""), P.regexp(/[^\r\n]+/), linebreak.atMost(1).result("\n")).map(join).atLeast(1).map(join), (_1, pluginName, args, _2, content) => {
+            return this.opts.plugins && this.opts.plugins[pluginName] ? this.opts.plugins[pluginName](args, content, mapper, join)
+                : join([_1, pluginName, args, _2, content]);
+        });
+        const block = P.alt(P.regexp(/\s+/).result(""), pluginBlock, h1Special, h2Special, h6, h5, h4, h3, h2, h1, table, codeBlock, lists, blockquote, paragraph, linebreak.result(""));
+        this.acceptables = P.alt(block).many().map(join);
+    }
+    parse(s) {
+        this.liLevelBefore = this.liLevel = null;
+        this.rootTree = this.currentTree = {
+            value: null,
+            children: [],
+            type: "shadow",
+            parent: null
+        };
+        const parsed = this.acceptables.parse(s.trim());
+        if (parsed.status === true && parsed.hasOwnProperty("value"))
+            return this.opts.export.postprocess(parsed.value);
+        console.error(s.trim());
+        console.error(parsed);
+        throw new Error("Parsing was failed.");
+    }
+}
+exports.Parser = Parser;
+function escapeHtml(text) {
+    const map = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;'
+    };
+    return text.replace(/[&<>"']/g, (m) => map[m]);
+}
+exports.asHTML = {
+    mapper: (tag, args) => children => [
+        "<" + tag,
+        args ? " " + Object.keys(args).map(x => `${x}="${escapeHtml(String(args[x]))}"`).join(" ") : "",
+        children !== null && children !== "" ? ">" + children + "</" + tag + ">" : " />"
+    ].join(""),
+    join: (x) => x.join(""),
+    postprocess: (x) => x
+};
+exports.asAST = {
+    mapper: (tag, args) => children => [
+        tag,
+        args ? args : null,
+        children
+    ],
+    join: (x) => x, // identical
+    postprocess: (obj) => {
+        return obj.filter((x) => (x !== ''));
+    }
+};
+const parse = (s) => {
+    const p = new Parser({
+        export: exports.asHTML,
+    });
+    return p.parse(s);
+};
+exports.parse = parse;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@minamorl/markdown-next",
+  "description": "Markdown parser with Aozora bunko ruby support and HTML passthrough",
+  "main": "./lib/src/parser.js",
+  "types": "./lib/src/parser.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "example": "cd examples && webpack",
+    "prepublish": "pnpm run build",
+    "test": "pnpm run build && mocha lib/test"
+  },
+  "author": "minamorl",
+  "license": "MIT",
+  "files": [
+    "lib/src/",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^20.0.0",
+    "@types/power-assert": "^1.5.12",
+    "mocha": "^11.7.5",
+    "power-assert": "^1.6.1",
+    "typescript": "^5.9.3",
+    "webpack": "^5.102.1",
+    "webpack-cli": "^6.0.1"
+  },
+  "dependencies": {
+    "@types/parsimmon": "^1.10.9",
+    "parsimmon": "^1.18.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minamorl/markdown-next.git"
+  },
+  "bugs": {
+    "url": "https://github.com/minamorl/markdown-next/issues"
+  },
+  "homepage": "https://github.com/minamorl/markdown-next#readme",
+  "version": "2.0.1"
+}