@traq-markdown-engine/commonmark-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2020 traP
+Copyright (c) 2026 東京工業大学デジタル創作同好会traP
+
+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,43 @@
+# commonmark-plugin: CommonMark and reusable extensions
+
+CommonMark 0.31.2 と汎用 Markdown 拡張の文法・ノード契約・テキスト描画を所有します。
+
+| crate                           | 責務                                    |
+| ------------------------------- | --------------------------------------- |
+| `markdown-commonmark-contracts` | CommonMark の型付きノード               |
+| `markdown-commonmark`           | CommonMark の構文解析                   |
+| `markdown-commonmark-text`      | CommonMark AST のテキスト描画           |
+| `markdown-generic-contracts`    | 数式、表、取り消し線、mark のノード契約 |
+| `markdown-generic-syntax`       | 汎用拡張の構文解析                      |
+| `markdown-generic-text`         | 汎用拡張のテキスト描画                  |
+
+各機能は独立した crate として利用できます。契約と構文実装は同じリポジトリで管理し、ノードを読むだけの処理が構文解析へ依存する必要はありません。
+
+## 開発
+
+共通の環境準備と検証は [ルートの CONTRIBUTING](../../../CONTRIBUTING.md) に従います。CommonMark の 652 仕様例の出典とライセンスは [root fixture](../../../tests/fixtures/README.md) に記載しています。
+
+## 境界
+
+依存先は [core](../../core/README.md) です。traP / traQ の文法・preset・アプリケーション方針は知りません。
+
+traP 固有の拡張部品は [traq-plugin](../traq/README.md)、traQ 向けの構成と Wasm・TypeScript / Go bindings は [sdk](../../sdk/README.md)、HTML 描画は各パッケージの `typescript/renderer`、traQ の CSS は SDK パッケージにあります。
+
+## TypeScript / HTML rendering
+
+TypeScript の実装もこのリポジトリの責務に合わせて配置しています。
+
+| TypeScript package                        | 責務                                                                   |
+| ----------------------------------------- | ---------------------------------------------------------------------- |
+| `@traq-markdown-engine/core`              | 共通 AST 型、HTML handler・Plugin・PresetBuilder、契約検証と生成の基盤 |
+| `@traq-markdown-engine/commonmark-plugin` | CommonMark・汎用拡張の生成ノード型と HTML 描画                         |
+| `@traq-markdown-engine/traq-plugin`       | traP の生成ノード型・参照・スタンプ等の HTML 描画                      |
+| `@traq-markdown-engine/sdk`               | Wasm / Go / TypeScript 配布、traQ の描画構成・preview・CSS             |
+
+AST の共通形は core の `typescript/ast.ts` に一度だけ定義し、SDK の生成 bindings はそれを構文の union で特殊化します。構文の payload は Rust を正として生成し、commonmark-plugin と traq-plugin の `bun run generate:bindings` でそれぞれの契約 crate から再生成できます。
+
+HTML API は `/renderer` サブパスです。traQ は `@traq-markdown-engine/sdk/renderer` の `messageRenderers`、CSS は `@traq-markdown-engine/sdk/index.css` を利用します。
+
+## Go contracts
+
+The Go module is `github.com/uni-kakurenbo/traq-markdown-engine/packages/plugins/commonmark/go`. Payloads and node factories are generated from this repository's Rust contracts by `bun run generate:bindings`. The canonical tree and Wasm runtime belong to the core Go module.

package/dist/generated/commonmark.d.ts

@@ -0,0 +1,124 @@
+export type Blockquote = Record<symbol, never>;
+export type CodeBlock = {
+    fenced: boolean;
+    info: string;
+    literal: string;
+};
+export type Emphasis = Record<symbol, never>;
+export type Hardbreak = Record<symbol, never>;
+export type Heading = {
+    level: number;
+};
+export type HtmlBlock = {
+    literal: string;
+};
+export type HtmlInline = {
+    literal: string;
+};
+export type Image = {
+    destination: string;
+    title: string | null;
+    label_source: string;
+};
+export type InlineCode = {
+    literal: string;
+};
+export type Link = {
+    destination: string;
+    title: string | null;
+    form: LinkForm;
+};
+export type LinkForm = 'explicit' | 'autolink' | 'linkify';
+export type List = {
+    ordered: boolean;
+    start: number;
+    tight: boolean;
+};
+export type ListItem = {
+    marker: string;
+};
+export type Paragraph = Record<symbol, never>;
+export type Softbreak = Record<symbol, never>;
+export type Strong = Record<symbol, never>;
+export type Text = {
+    value: string;
+};
+export type ThematicBreak = {
+    marker: string;
+};
+export type NodeKind = {
+    kind: 'markdown_commonmark_contracts::nodes::Blockquote';
+    data: Blockquote;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::CodeBlock';
+    data: CodeBlock;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Emphasis';
+    data: Emphasis;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Hardbreak';
+    data: Hardbreak;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Heading';
+    data: Heading;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::HtmlBlock';
+    data: HtmlBlock;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::HtmlInline';
+    data: HtmlInline;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Image';
+    data: Image;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::InlineCode';
+    data: InlineCode;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Link';
+    data: Link;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::List';
+    data: List;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::ListItem';
+    data: ListItem;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Paragraph';
+    data: Paragraph;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Softbreak';
+    data: Softbreak;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Strong';
+    data: Strong;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::Text';
+    data: Text;
+} | {
+    kind: 'markdown_commonmark_contracts::nodes::ThematicBreak';
+    data: ThematicBreak;
+};
+export declare const names: Readonly<{
+    readonly Blockquote: 'markdown_commonmark_contracts::nodes::Blockquote';
+    readonly CodeBlock: 'markdown_commonmark_contracts::nodes::CodeBlock';
+    readonly Emphasis: 'markdown_commonmark_contracts::nodes::Emphasis';
+    readonly Hardbreak: 'markdown_commonmark_contracts::nodes::Hardbreak';
+    readonly Heading: 'markdown_commonmark_contracts::nodes::Heading';
+    readonly HtmlBlock: 'markdown_commonmark_contracts::nodes::HtmlBlock';
+    readonly HtmlInline: 'markdown_commonmark_contracts::nodes::HtmlInline';
+    readonly Image: 'markdown_commonmark_contracts::nodes::Image';
+    readonly InlineCode: 'markdown_commonmark_contracts::nodes::InlineCode';
+    readonly Link: 'markdown_commonmark_contracts::nodes::Link';
+    readonly List: 'markdown_commonmark_contracts::nodes::List';
+    readonly ListItem: 'markdown_commonmark_contracts::nodes::ListItem';
+    readonly Paragraph: 'markdown_commonmark_contracts::nodes::Paragraph';
+    readonly Softbreak: 'markdown_commonmark_contracts::nodes::Softbreak';
+    readonly Strong: 'markdown_commonmark_contracts::nodes::Strong';
+    readonly Text: 'markdown_commonmark_contracts::nodes::Text';
+    readonly ThematicBreak: 'markdown_commonmark_contracts::nodes::ThematicBreak';
+}>;
+export declare const nodes: ReadonlyMap<string, (data: unknown) => boolean>;
+export declare function isKnownNode<T extends {
+    kind: string;
+    data: unknown;
+}>(node: T): node is T & NodeKind;

package/dist/generated/commonmark.js

@@ -0,0 +1,112 @@
+// Generated from Rust node payload types. Do not edit.
+import { boolean, fields, nullable, oneOf, string } from '@traq-markdown-engine/core/validation';
+export const names = Object.freeze({
+    Blockquote: 'markdown_commonmark_contracts::nodes::Blockquote',
+    CodeBlock: 'markdown_commonmark_contracts::nodes::CodeBlock',
+    Emphasis: 'markdown_commonmark_contracts::nodes::Emphasis',
+    Hardbreak: 'markdown_commonmark_contracts::nodes::Hardbreak',
+    Heading: 'markdown_commonmark_contracts::nodes::Heading',
+    HtmlBlock: 'markdown_commonmark_contracts::nodes::HtmlBlock',
+    HtmlInline: 'markdown_commonmark_contracts::nodes::HtmlInline',
+    Image: 'markdown_commonmark_contracts::nodes::Image',
+    InlineCode: 'markdown_commonmark_contracts::nodes::InlineCode',
+    Link: 'markdown_commonmark_contracts::nodes::Link',
+    List: 'markdown_commonmark_contracts::nodes::List',
+    ListItem: 'markdown_commonmark_contracts::nodes::ListItem',
+    Paragraph: 'markdown_commonmark_contracts::nodes::Paragraph',
+    Softbreak: 'markdown_commonmark_contracts::nodes::Softbreak',
+    Strong: 'markdown_commonmark_contracts::nodes::Strong',
+    Text: 'markdown_commonmark_contracts::nodes::Text',
+    ThematicBreak: 'markdown_commonmark_contracts::nodes::ThematicBreak'
+});
+const validators = new Map([
+    [
+        'markdown_commonmark_contracts::nodes::Blockquote',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::CodeBlock',
+        value => fields(value, { fenced: boolean, info: string, literal: string }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Emphasis',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Hardbreak',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Heading',
+        value => fields(value, {
+            level: value => typeof value === 'number' &&
+                Number.isInteger(value) &&
+                value >= 0 &&
+                value <= 255
+        }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::HtmlBlock',
+        value => fields(value, { literal: string }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::HtmlInline',
+        value => fields(value, { literal: string }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Image',
+        value => fields(value, { destination: string, label_source: string, title: nullable(string) }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::InlineCode',
+        value => fields(value, { literal: string }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Link',
+        value => fields(value, {
+            destination: string,
+            form: oneOf('explicit', 'autolink', 'linkify'),
+            title: nullable(string)
+        }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::List',
+        value => fields(value, {
+            ordered: boolean,
+            start: value => typeof value === 'number' &&
+                Number.isInteger(value) &&
+                value >= 0 &&
+                value <= 4294967295,
+            tight: boolean
+        }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::ListItem',
+        value => fields(value, { marker: string }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Paragraph',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Softbreak',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Strong',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::Text',
+        value => fields(value, { value: string }, {})
+    ],
+    [
+        'markdown_commonmark_contracts::nodes::ThematicBreak',
+        value => fields(value, { marker: string }, {})
+    ]
+]);
+export const nodes = new Map(validators);
+// Check this payload only; children can still contain unknown nodes.
+export function isKnownNode(node) {
+    return validators.get(node.kind)?.(node.data) ?? false;
+}

package/dist/generated/generic.d.ts

@@ -0,0 +1,52 @@
+export type MarkData = Record<symbol, never>;
+export type BlockMathData = {
+    tex: string;
+};
+export type InlineMathData = {
+    tex: string;
+};
+export type StrikethroughData = Record<symbol, never>;
+export type CellData = {
+    alignment: Alignment | null;
+};
+export type Alignment = 'left' | 'center' | 'right';
+export type RowData = {
+    header: boolean;
+};
+export type TableData = Record<symbol, never>;
+export type NodeKind = {
+    kind: 'markdown_generic_contracts::mark::MarkData';
+    data: MarkData;
+} | {
+    kind: 'markdown_generic_contracts::math::BlockMathData';
+    data: BlockMathData;
+} | {
+    kind: 'markdown_generic_contracts::math::InlineMathData';
+    data: InlineMathData;
+} | {
+    kind: 'markdown_generic_contracts::strikethrough::StrikethroughData';
+    data: StrikethroughData;
+} | {
+    kind: 'markdown_generic_contracts::table::CellData';
+    data: CellData;
+} | {
+    kind: 'markdown_generic_contracts::table::RowData';
+    data: RowData;
+} | {
+    kind: 'markdown_generic_contracts::table::TableData';
+    data: TableData;
+};
+export declare const names: Readonly<{
+    readonly Mark: 'markdown_generic_contracts::mark::MarkData';
+    readonly BlockMath: 'markdown_generic_contracts::math::BlockMathData';
+    readonly InlineMath: 'markdown_generic_contracts::math::InlineMathData';
+    readonly Strikethrough: 'markdown_generic_contracts::strikethrough::StrikethroughData';
+    readonly Cell: 'markdown_generic_contracts::table::CellData';
+    readonly Row: 'markdown_generic_contracts::table::RowData';
+    readonly Table: 'markdown_generic_contracts::table::TableData';
+}>;
+export declare const nodes: ReadonlyMap<string, (data: unknown) => boolean>;
+export declare function isKnownNode<T extends {
+    kind: string;
+    data: unknown;
+}>(node: T): node is T & NodeKind;

package/dist/generated/generic.js

@@ -0,0 +1,46 @@
+// Generated from Rust node payload types. Do not edit.
+import { boolean, fields, nullable, oneOf, string } from '@traq-markdown-engine/core/validation';
+export const names = Object.freeze({
+    Mark: 'markdown_generic_contracts::mark::MarkData',
+    BlockMath: 'markdown_generic_contracts::math::BlockMathData',
+    InlineMath: 'markdown_generic_contracts::math::InlineMathData',
+    Strikethrough: 'markdown_generic_contracts::strikethrough::StrikethroughData',
+    Cell: 'markdown_generic_contracts::table::CellData',
+    Row: 'markdown_generic_contracts::table::RowData',
+    Table: 'markdown_generic_contracts::table::TableData'
+});
+const validators = new Map([
+    [
+        'markdown_generic_contracts::mark::MarkData',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_generic_contracts::math::BlockMathData',
+        value => fields(value, { tex: string }, {})
+    ],
+    [
+        'markdown_generic_contracts::math::InlineMathData',
+        value => fields(value, { tex: string }, {})
+    ],
+    [
+        'markdown_generic_contracts::strikethrough::StrikethroughData',
+        value => fields(value, {}, {})
+    ],
+    [
+        'markdown_generic_contracts::table::CellData',
+        value => fields(value, { alignment: nullable(oneOf('left', 'center', 'right')) }, {})
+    ],
+    [
+        'markdown_generic_contracts::table::RowData',
+        value => fields(value, { header: boolean }, {})
+    ],
+    [
+        'markdown_generic_contracts::table::TableData',
+        value => fields(value, {}, {})
+    ]
+]);
+export const nodes = new Map(validators);
+// Check this payload only; children can still contain unknown nodes.
+export function isKnownNode(node) {
+    return validators.get(node.kind)?.(node.data) ?? false;
+}

package/dist/renderer/block.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '@traq-markdown-engine/core/renderer';
+import type { Options } from './options.js';
+type BlockOptions = Pick<Options, 'highlight'>;
+export declare function registerBlockHandlers(result: Plugin, { highlight }: BlockOptions): void;
+export {};

package/dist/renderer/block.js

@@ -0,0 +1,76 @@
+import { isKnownNode, names } from '@traq-markdown-engine/commonmark-plugin/nodes';
+import { attributes, checked, escapeHtml } from '@traq-markdown-engine/core/html';
+import { decodeHTMLStrict } from 'entities';
+function tightList(node) {
+    return (!!node && isKnownNode(node) && node.kind === names.List && node.data.tight);
+}
+function codeLanguage(info) {
+    return info
+        .replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])|&(?:#[xX][0-9a-fA-F]+|#\d+|[a-zA-Z][a-zA-Z0-9]+);/g, (match, escaped) => escaped ?? decodeHTMLStrict(match))
+        .trim()
+        .split(/\s+/)[0];
+}
+export function registerBlockHandlers(result, { highlight }) {
+    result.on(names.Paragraph, checked(names.Paragraph, isKnownNode, (n, ctx) => {
+        const content = ctx.render(n.children);
+        return ctx.ancestors.at(-1)?.kind === names.ListItem &&
+            tightList(ctx.ancestors.at(-2))
+            ? content
+            : '<p>' + content + '</p>\n';
+    }));
+    result.on(names.Heading, checked(names.Heading, isKnownNode, (n, ctx) => '<h' +
+        n.data.level +
+        '>' +
+        ctx.render(n.children) +
+        '</h' +
+        n.data.level +
+        '>\n'));
+    result.on(names.Blockquote, checked(names.Blockquote, isKnownNode, (n, ctx) => '<blockquote>' +
+        (n.children?.length ? '\n' : '') +
+        ctx.render(n.children) +
+        '</blockquote>\n'));
+    result.on(names.List, checked(names.List, isKnownNode, (n, ctx) => {
+        const tag = n.data.ordered ? 'ol' : 'ul';
+        const attrs = n.data.ordered && n.data.start !== 1
+            ? attributes([['start', String(n.data.start)]])
+            : '';
+        return ('<' + tag + attrs + '>\n' + ctx.render(n.children) + '</' + tag + '>\n');
+    }));
+    result.on(names.ListItem, checked(names.ListItem, isKnownNode, (n, ctx) => {
+        const children = n.children ?? [];
+        const tight = tightList(ctx.ancestors.at(-1));
+        const content = children
+            .map((child, i) => {
+            const rendered = ctx.render([child]);
+            // A line break following a tight paragraph needs no leading whitespace.
+            const separator = tight &&
+                i > 0 &&
+                children[i - 1].kind === names.Paragraph &&
+                child.kind !== names.CodeBlock &&
+                !rendered.startsWith('<br>')
+                ? '\n'
+                : '';
+            return separator + rendered;
+        })
+            .join('');
+        return ('<li>' +
+            (children.length && !(tight && children[0].kind === names.Paragraph)
+                ? '\n'
+                : '') +
+            content +
+            '</li>\n');
+    }));
+    result.on(names.CodeBlock, checked(names.CodeBlock, isKnownNode, n => {
+        const language = n.data.fenced ? codeLanguage(n.data.info ?? '') : '';
+        const content = (n.data.fenced && highlight?.(n.data.literal, language)) ||
+            escapeHtml(n.data.literal);
+        if (content.startsWith('<pre'))
+            return content + '\n';
+        const attrs = language
+            ? attributes([['class', 'language-' + language]])
+            : '';
+        return '<pre><code' + attrs + '>' + content + '</code></pre>\n';
+    }));
+    result.on(names.ThematicBreak, checked(names.ThematicBreak, isKnownNode, () => '<hr>\n'));
+    result.on(names.HtmlBlock, checked(names.HtmlBlock, isKnownNode, n => '<p>' + escapeHtml(n.data.literal) + '</p>\n'));
+}

package/dist/renderer/extensions/index.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from '@traq-markdown-engine/core/renderer';
+export interface Options {
+    /** Return trusted HTML. KaTeX is used by default. */
+    math?(tex: string, displayMode: boolean): string;
+}
+export declare function plugin({ math }?: Options): Plugin;

package/dist/renderer/extensions/index.js

@@ -0,0 +1,44 @@
+import { isKnownNode, names } from '@traq-markdown-engine/commonmark-plugin/generic/nodes';
+import { Plugin as Declaration } from '@traq-markdown-engine/core/definitions';
+import { attributes, checked } from '@traq-markdown-engine/core/html';
+import { Plugin } from '@traq-markdown-engine/core/renderer';
+import { math as defaultMath } from './math.js';
+function table(node, ctx) {
+    const rows = (node.children ?? []).map(row => {
+        if (!isKnownNode(row) || row.kind !== names.Row)
+            throw new TypeError('Invalid table row');
+        return row;
+    });
+    const head = rows.filter(r => r.data.header), body = rows.filter(r => !r.data.header);
+    return ('<table>\n<thead>\n' +
+        head.map(node => row(node, ctx)).join('') +
+        '</thead>\n' +
+        (body.length
+            ? '<tbody>\n' + body.map(node => row(node, ctx)).join('') + '</tbody>\n'
+            : '') +
+        '</table>\n');
+}
+function row(node, ctx) {
+    const tag = node.data.header ? 'th' : 'td';
+    const cells = (node.children ?? [])
+        .map(cell => {
+        if (!isKnownNode(cell) || cell.kind !== names.Cell)
+            throw new TypeError('Invalid table cell');
+        const attrs = cell.data.alignment
+            ? attributes([['style', 'text-align:' + cell.data.alignment]])
+            : '';
+        return ('<' + tag + attrs + '>' + ctx.render(cell.children) + '</' + tag + '>\n');
+    })
+        .join('');
+    return '<tr>\n' + cells + '</tr>\n';
+}
+const declaration = Declaration.group('generic').new('presentation');
+export function plugin({ math = defaultMath } = {}) {
+    const result = new Plugin(declaration);
+    result.on(names.Mark, checked(names.Mark, isKnownNode, (n, ctx) => '<mark>' + ctx.render(n.children) + '</mark>'));
+    result.on(names.Strikethrough, checked(names.Strikethrough, isKnownNode, (n, ctx) => '<s>' + ctx.render(n.children) + '</s>'));
+    result.on(names.Table, checked(names.Table, isKnownNode, table));
+    result.on(names.InlineMath, checked(names.InlineMath, isKnownNode, node => math(node.data.tex, false)));
+    result.on(names.BlockMath, checked(names.BlockMath, isKnownNode, node => math(node.data.tex, true)));
+    return result;
+}

package/dist/renderer/extensions/math.d.ts

@@ -0,0 +1,4 @@
+export declare function math(tex: string, displayMode: boolean, options?: {
+    maxSize?: number;
+    macros?: Record<string, string>;
+}): string;

package/dist/renderer/extensions/math.js

@@ -0,0 +1,24 @@
+import { escapeHtml } from '@traq-markdown-engine/core/html';
+import katex from 'katex';
+export function math(tex, displayMode, options = {}) {
+    try {
+        const html = katex.renderToString(tex, {
+            displayMode,
+            output: 'html',
+            maxSize: 100,
+            ...options,
+            strict: code => (code === 'unicodeTextInMathMode' ? 'ignore' : 'warn')
+        });
+        return displayMode ? `<p class="katex-block is-scroll">${html}</p>\n` : html;
+    }
+    catch (error) {
+        if (!(error instanceof katex.ParseError))
+            throw error;
+        const tag = displayMode ? 'p' : 'span';
+        const classes = displayMode
+            ? 'katex-block katex-error is-scroll'
+            : 'katex-error';
+        return (`<${tag} class="${classes}" title="${escapeHtml(String(error))}">${escapeHtml(tex)}</${tag}>` +
+            (displayMode ? '\n' : ''));
+    }
+}

package/dist/renderer/highlight.d.ts

@@ -0,0 +1 @@
+export declare const createHighlightFunc: (preClass: string, withCaption?: boolean, useSubsetForAuto?: boolean) => (code: string, lang: string) => string;

package/dist/renderer/highlight.js

@@ -0,0 +1,29 @@
+import { escapeHtml } from '@traq-markdown-engine/core/html';
+import hljs from 'highlight.js';
+import defaultSubset from './languages.js';
+const noHighlightRe = /^(no-?highlight|plain|text)$/i;
+export const createHighlightFunc = (preClass, withCaption = true, useSubsetForAuto = true) => (code, lang) => {
+    let langName;
+    let citeTag = '';
+    if (withCaption) {
+        const [_langName, langCaption] = lang.split(':');
+        langName = _langName ?? '';
+        if (langCaption) {
+            citeTag = `<cite>${escapeHtml(langCaption)}</cite>`;
+        }
+    }
+    else {
+        langName = lang;
+    }
+    if (hljs.getLanguage(langName)) {
+        const result = hljs.highlight(code, { language: langName });
+        return `<pre class="${preClass}">${citeTag}<code class="lang-${result.language}">${result.value}</code></pre>`;
+    }
+    else if (noHighlightRe.test(langName)) {
+        return `<pre class="${preClass}">${citeTag}<code>${escapeHtml(code)}</code></pre>`;
+    }
+    else {
+        const result = hljs.highlightAuto(code, useSubsetForAuto ? defaultSubset : undefined);
+        return `<pre class="${preClass}">${citeTag}<code class="lang-${result.language}">${result.value}</code></pre>`;
+    }
+};

package/dist/renderer/index.d.ts

@@ -0,0 +1,10 @@
+import { names } from '@traq-markdown-engine/commonmark-plugin/nodes';
+import { Plugin } from '@traq-markdown-engine/core/renderer';
+import type { Options } from './options.js';
+export type { Options } from './options.js';
+export { names as nodes };
+export declare function plugin({ validateLink, validateImage, breaks, highlight, linkAttributes }?: Options): Plugin;
+export declare const html: Readonly<{
+    plugin: typeof plugin;
+}>;
+export declare function preset(options?: Options): import("@traq-markdown-engine/core/renderer").Preset;

package/dist/renderer/index.js

@@ -0,0 +1,24 @@
+import { names } from '@traq-markdown-engine/commonmark-plugin/nodes';
+import { Plugin as Declaration } from '@traq-markdown-engine/core/definitions';
+import { Plugin } from '@traq-markdown-engine/core/renderer';
+import { PresetBuilder } from '@traq-markdown-engine/core/renderer';
+import { registerBlockHandlers } from './block.js';
+import { registerInlineHandlers } from './inline.js';
+import { validateLink as defaultPolicy } from './policy.js';
+const declaration = Declaration.group('commonmark').new('core');
+export { names as nodes };
+export function plugin({ validateLink = defaultPolicy, validateImage = validateLink, breaks = false, highlight, linkAttributes = {} } = {}) {
+    const result = new Plugin(declaration);
+    registerInlineHandlers(result, {
+        validateLink,
+        validateImage,
+        breaks,
+        linkAttributes
+    });
+    registerBlockHandlers(result, { highlight });
+    return result;
+}
+export const html = Object.freeze({ plugin });
+export function preset(options) {
+    return new PresetBuilder().add(plugin(options)).build();
+}

package/dist/renderer/inline.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '@traq-markdown-engine/core/renderer';
+import type { Options } from './options.js';
+type InlineOptions = Required<Pick<Options, 'validateLink' | 'validateImage' | 'breaks' | 'linkAttributes'>>;
+export declare function registerInlineHandlers(result: Plugin, { validateLink, validateImage, breaks, linkAttributes }: InlineOptions): void;
+export {};

package/dist/renderer/inline.js

@@ -0,0 +1,61 @@
+import { isKnownNode, names } from '@traq-markdown-engine/commonmark-plugin/nodes';
+import { attributes, checked, escapeHtml } from '@traq-markdown-engine/core/html';
+function imageText(nodes = [], source) {
+    return nodes
+        .map(node => {
+        if (!isKnownNode(node))
+            return new TextDecoder().decode(new TextEncoder()
+                .encode(source)
+                .subarray(node.span.start, node.span.end));
+        switch (node.kind) {
+            case names.Text:
+                return node.data.value;
+            case names.HtmlInline:
+                return node.data.literal;
+            case names.Softbreak:
+            case names.Hardbreak:
+                return '\n';
+            case names.InlineCode:
+                return node.data.literal;
+            default:
+                return imageText(node.children, source);
+        }
+    })
+        .join('');
+}
+function titleAttribute(title) {
+    return title === null ? '' : attributes([['title', title]]);
+}
+export function registerInlineHandlers(result, { validateLink, validateImage, breaks, linkAttributes }) {
+    const linkAttrs = attributes(Object.entries(linkAttributes));
+    result.on(names.Text, checked(names.Text, isKnownNode, n => escapeHtml(n.data.value)));
+    result.on(names.InlineCode, checked(names.InlineCode, isKnownNode, n => '<code>' + escapeHtml(n.data.literal) + '</code>'));
+    result.on(names.Softbreak, checked(names.Softbreak, isKnownNode, () => (breaks ? '<br>\n' : '\n')));
+    result.on(names.Hardbreak, checked(names.Hardbreak, isKnownNode, () => '<br>\n'));
+    result.on(names.Emphasis, checked(names.Emphasis, isKnownNode, (n, ctx) => '<em>' + ctx.render(n.children) + '</em>'));
+    result.on(names.Strong, checked(names.Strong, isKnownNode, (n, ctx) => '<strong>' + ctx.render(n.children) + '</strong>'));
+    result.on(names.Link, checked(names.Link, isKnownNode, (n, ctx) => {
+        const content = ctx.render(n.children);
+        if (!validateLink(n.data.destination))
+            return content;
+        return ('<a' +
+            attributes([['href', n.data.destination]]) +
+            linkAttrs +
+            titleAttribute(n.data.title) +
+            '>' +
+            content +
+            '</a>');
+    }));
+    result.on(names.Image, checked(names.Image, isKnownNode, (n, ctx) => {
+        if (!validateImage(n.data.destination))
+            return ctx.fallback(n);
+        return ('<img' +
+            attributes([
+                ['src', n.data.destination],
+                ['alt', imageText(n.children, ctx.source)]
+            ]) +
+            titleAttribute(n.data.title) +
+            '>');
+    }));
+    result.on(names.HtmlInline, checked(names.HtmlInline, isKnownNode, n => escapeHtml(n.data.literal)));
+}

package/dist/renderer/languages.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/renderer/languages.js

@@ -0,0 +1,82 @@
+export default [
+    'actionscript',
+    'awk',
+    'bash',
+    'basic',
+    'bnf',
+    'csharp',
+    'h',
+    'cpp',
+    'cmake',
+    'coq',
+    'css',
+    'clojure',
+    'coffeescript',
+    'crystal',
+    'd',
+    'dart',
+    'delphi',
+    'diff',
+    'django',
+    'dockerfile',
+    'elixir',
+    'elm',
+    'fsharp',
+    'fortran',
+    'go',
+    'gradle',
+    'groovy',
+    'xml',
+    'http',
+    'haml',
+    'handlebars',
+    'haxe',
+    'ini',
+    'json',
+    'java',
+    'javascript',
+    'kotlin',
+    'tex',
+    'less',
+    'lisp',
+    'livescript',
+    'lua',
+    'makefile',
+    'markdown',
+    'mathematica',
+    'matlab',
+    'nginx',
+    'nimrod',
+    'ocaml',
+    'objectivec',
+    'glsl',
+    'graphql',
+    'php',
+    'perl',
+    'plaintext',
+    'pgsql',
+    'powershell',
+    'processing',
+    'prolog',
+    'protobuf',
+    'python',
+    'r',
+    'ruby',
+    'scss',
+    'sql',
+    'scheme',
+    'shell',
+    'stylus',
+    'swift',
+    'twig',
+    'typescript',
+    'vbnet',
+    'vbscript',
+    'verilog',
+    'vim',
+    'x86asm',
+    'xquery',
+    'yaml',
+    'wasm',
+    'zephir'
+];

package/dist/renderer/options.d.ts

@@ -0,0 +1,8 @@
+export interface Options {
+    validateLink?(destination: string): boolean;
+    validateImage?(destination: string): boolean;
+    breaks?: boolean;
+    /** Return highlighted HTML, or an empty string to use escaped code. */
+    highlight?(code: string, language: string): string;
+    linkAttributes?: Readonly<Record<string, string>>;
+}

package/dist/renderer/options.js

@@ -0,0 +1 @@
+export {};

package/dist/renderer/policy.d.ts

@@ -0,0 +1 @@
+export declare function validateLink(destination: string): boolean;

package/dist/renderer/policy.js

@@ -0,0 +1,10 @@
+// Conservative default for standalone rendering. Application adapters supply
+// their existing policy so integrating the shared parser does not change it.
+export function validateLink(destination) {
+    try {
+        return ['http:', 'https:', 'mailto:', 'ftp:'].includes(new URL(destination, 'https://markdown.invalid').protocol);
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@traq-markdown-engine/commonmark-plugin",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "commonmark Markdown contracts and HTML rendering.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uni-kakurenbo/traq-markdown-engine.git",
+    "directory": "packages/plugins/commonmark"
+  },
+  "exports": {
+    "./nodes": {
+      "types": "./dist/generated/commonmark.d.ts",
+      "import": "./dist/generated/commonmark.js"
+    },
+    "./generic/nodes": {
+      "types": "./dist/generated/generic.d.ts",
+      "import": "./dist/generated/generic.js"
+    },
+    "./renderer": {
+      "types": "./dist/renderer/index.d.ts",
+      "import": "./dist/renderer/index.js"
+    },
+    "./generic/renderer": {
+      "types": "./dist/renderer/extensions/index.d.ts",
+      "import": "./dist/renderer/extensions/index.js"
+    },
+    "./generic/math": {
+      "types": "./dist/renderer/extensions/math.d.ts",
+      "import": "./dist/renderer/extensions/math.js"
+    },
+    "./highlight": {
+      "types": "./dist/renderer/highlight.d.ts",
+      "import": "./dist/renderer/highlight.js"
+    },
+    "./policy": {
+      "types": "./dist/renderer/policy.d.ts",
+      "import": "./dist/renderer/policy.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "bun run ../../../scripts/tsc.ts -p typescript/tsconfig.build.json",
+    "generate:bindings": "bun run ../../../scripts/generate-bindings.ts commonmark-plugin",
+    "typecheck": "bun run ../../../scripts/tsc.ts -p typescript/tsconfig.json"
+  },
+  "peerDependencies": {
+    "@traq-markdown-engine/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@traq-markdown-engine/core": "workspace:*",
+    "@types/katex": "0.16.8"
+  },
+  "dependencies": {
+    "entities": "8.0.0",
+    "highlight.js": "11.12.0",
+    "katex": "0.18.5"
+  }
+}