mmi-md 1.0.0

package/.editorconfig

@@ -0,0 +1,7 @@
+[*.{html,js,jsx,mjs,cjs,ts,tsx,mts,cts,vue,css,scss,sass,less,styl}]
+charset = utf-8
+indent_size = 4
+indent_style = tab
+insert_final_newline = false
+trim_trailing_whitespace = true
+end_of_line = lf

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://json.schemastore.org/prettierrc",
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 100
+}

package/README.md

@@ -0,0 +1,2 @@
+# mmarkdown
+Markdown spécial MMI

package/lib/ast/nodes.d.ts

@@ -0,0 +1,77 @@
+export interface DocumentNode {
+    type: 'document';
+    children: BlockNode[];
+}
+export type BlockNode = HeadingNode | ParagraphNode | ListNode | BlockquoteNode | CodeBlockNode | TableNode;
+export type InlineNode = TextNode | EmphasisNode | StrongNode | UnderlineNode | StrikethroughNode | CodeInlineNode | LinkNode | ImageNode | LineBreakNode;
+export interface TextNode {
+    type: 'text';
+    content: string;
+}
+export interface EmphasisNode {
+    type: 'emphasis';
+    children: InlineNode[];
+}
+export interface StrongNode {
+    type: 'strong';
+    children: InlineNode[];
+}
+export interface UnderlineNode {
+    type: 'underline';
+    children: InlineNode[];
+}
+export interface StrikethroughNode {
+    type: 'strikethrough';
+    children: InlineNode[];
+}
+export interface CodeInlineNode {
+    type: 'code_inline';
+    content: string;
+}
+export interface LinkNode {
+    type: 'link';
+    text: string;
+    href: string;
+    external: boolean;
+}
+export interface ImageNode {
+    type: 'image';
+    alt: string;
+    src: string;
+}
+export interface LineBreakNode {
+    type: 'line_break';
+}
+export interface HeadingNode {
+    type: 'heading';
+    level: number;
+    subtitle: boolean;
+    sample: boolean;
+    children: InlineNode[];
+}
+export interface ParagraphNode {
+    type: 'paragraph';
+    children: InlineNode[];
+}
+export interface BlockquoteNode {
+    type: 'blockquote';
+    children: BlockNode[];
+}
+export interface ListNode {
+    type: 'list';
+    ordered: boolean;
+    items: ListItemNode[];
+}
+export interface ListItemNode {
+    type: 'list_item';
+    children: BlockNode[];
+}
+export interface CodeBlockNode {
+    type: 'code_block';
+    content: string;
+}
+export interface TableNode {
+    type: 'table';
+    header: InlineNode[][][];
+    rows: InlineNode[][][];
+}

package/lib/ast/nodes.js

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

package/lib/index.d.ts

@@ -0,0 +1 @@
+export declare function renderMMarkdown(source: string): string;

package/lib/index.js

@@ -0,0 +1,15 @@
+import { preprocess } from './parser/preprocess.js';
+import { BlockParser } from './parser/BlockParser.js';
+import { HTMLRenderer } from './renderer/HTMLRenderer.js';
+export function renderMMarkdown(source) {
+    const cleaned = preprocess(source);
+    const lines = cleaned.replace(/\r\n/g, '\n').split('\n');
+    const blockParser = new BlockParser();
+    const blocks = blockParser.parse(lines);
+    const doc = {
+        type: 'document',
+        children: blocks,
+    };
+    const renderer = new HTMLRenderer();
+    return renderer.render(doc);
+}

package/lib/parser/BlockParser.d.ts

@@ -0,0 +1,4 @@
+import type { BlockNode } from '../ast/nodes.js';
+export declare class BlockParser {
+    parse(lines: string[]): BlockNode[];
+}

package/lib/parser/BlockParser.js

@@ -0,0 +1,137 @@
+import { InlineParser } from './InlineParser.js';
+export class BlockParser {
+    parse(lines) {
+        const blocks = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (line.trim() === '') {
+                i++;
+                continue;
+            }
+            // Blockquote
+            if (line.trim().startsWith('>')) {
+                const quote = [];
+                while (i < lines.length && lines[i].trim().startsWith('>')) {
+                    let stripped = lines[i].replace(/^\s*>+\s?/, '');
+                    quote.push(stripped);
+                    i++;
+                }
+                blocks.push({
+                    type: 'blockquote',
+                    children: this.parse(quote),
+                });
+                continue;
+            }
+            // List (nested)
+            const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.*)/);
+            if (listMatch) {
+                const indent = listMatch[1].length;
+                const ordered = /\d+\./.test(listMatch[2]);
+                const items = [];
+                while (i < lines.length) {
+                    const m = lines[i].match(/^(\s*)([-*+]|\d+\.)\s+(.*)/);
+                    if (!m || m[1].length < indent)
+                        break;
+                    const content = m[3];
+                    const children = [
+                        {
+                            type: 'paragraph',
+                            children: InlineParser.parse(content),
+                        },
+                    ];
+                    i++;
+                    const sub = [];
+                    while (i < lines.length && lines[i].startsWith(' '.repeat(indent + 2))) {
+                        sub.push(lines[i].slice(indent + 2));
+                        i++;
+                    }
+                    children.push(...this.parse(sub));
+                    items.push({ type: 'list_item', children });
+                }
+                blocks.push({ type: 'list', ordered, items });
+                continue;
+            }
+            // Heading / Subtitle / Sample
+            const h = line.match(/^([~:]?)(#{1,6})\s+(.*)/);
+            if (h) {
+                blocks.push({
+                    type: 'heading',
+                    level: h[2].length,
+                    subtitle: h[1] === ':',
+                    sample: h[1] === '~',
+                    children: InlineParser.parse(h[3]),
+                });
+                i++;
+                continue;
+            }
+            // Code block
+            if (line.startsWith('```')) {
+                const content = [];
+                i++;
+                while (i < lines.length && !lines[i].startsWith('```')) {
+                    content.push(lines[i]);
+                    i++;
+                }
+                i++;
+                blocks.push({
+                    type: 'code_block',
+                    content: content.join('\n'),
+                });
+                continue;
+            }
+            // Table
+            if (line.includes('|')) {
+                const headerLine = line.split('|').map(c => c.trim()).filter(c => c);
+                // Check if next line is a separator
+                if (i + 1 < lines.length) {
+                    const nextLine = lines[i + 1];
+                    const isSeparator = /^\s*\|?\s*[-:\s|]+\s*\|?\s*$/.test(nextLine) &&
+                        nextLine.split('|').filter(c => c.trim()).length === headerLine.length;
+                    if (isSeparator) {
+                        const header = [headerLine.map(cell => InlineParser.parse(cell))];
+                        const rows = [];
+                        i += 2; // Skip header and separator
+                        // Collect table rows
+                        while (i < lines.length && lines[i].includes('|')) {
+                            const rowCells = lines[i].split('|').map(c => c.trim()).filter(c => c);
+                            if (rowCells.length === headerLine.length) {
+                                rows.push(rowCells.map(cell => InlineParser.parse(cell)));
+                                i++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        blocks.push({
+                            type: 'table',
+                            header,
+                            rows,
+                        });
+                        continue;
+                    }
+                }
+            }
+            // Paragraph
+            const p = [line];
+            i++;
+            while (i < lines.length && lines[i].trim() !== '') {
+                const nextLine = lines[i];
+                // Check if next line starts a new block element
+                const isBlockStart = nextLine.trim().startsWith('>') || // blockquote
+                    nextLine.match(/^(\s*)([-*+]|\d+\.)\s+/) || // list
+                    nextLine.startsWith('```') || // code block
+                    nextLine.match(/^([~:]?)(#{1,6})\s+/); // heading
+                if (isBlockStart)
+                    break;
+                p.push(nextLine);
+                i++;
+            }
+            blocks.push({
+                type: 'paragraph',
+                children: InlineParser.parse(p.join('\n')),
+            });
+        }
+        return blocks;
+    }
+}

package/lib/parser/InlineParser.d.ts

@@ -0,0 +1,5 @@
+import type { InlineNode } from '../ast/nodes.js';
+export declare class InlineParser {
+    static parse(text: string): InlineNode[];
+    private static mergeText;
+}

package/lib/parser/InlineParser.js

@@ -0,0 +1,132 @@
+export class InlineParser {
+    static parse(text) {
+        const nodes = [];
+        let i = 0;
+        while (i < text.length) {
+            // Backslash escape
+            if (text[i] === '\\' && i + 1 < text.length) {
+                const nextChar = text[i + 1];
+                // Escape special characters
+                if ('\\`*_{}[]()#+-.!~|>:'.includes(nextChar)) {
+                    nodes.push({
+                        type: 'text',
+                        content: nextChar,
+                    });
+                    i += 2;
+                    continue;
+                }
+            }
+            // Image
+            const img = text.slice(i).match(/^!\[(.*?)\]\((.*?)\)/);
+            if (img) {
+                nodes.push({
+                    type: 'image',
+                    alt: img[1],
+                    src: img[2],
+                });
+                i += img[0].length;
+                continue;
+            }
+            // Link
+            const link = text.slice(i).match(/^(:?)\[(.*?)\]\((.*?)\)/);
+            if (link) {
+                nodes.push({
+                    type: 'link',
+                    text: link[2],
+                    href: link[3],
+                    external: link[1] === ':',
+                });
+                i += link[0].length;
+                continue;
+            }
+            // Code inline
+            if (text[i] === '`') {
+                const end = text.indexOf('`', i + 1);
+                if (end !== -1) {
+                    nodes.push({
+                        type: 'code_inline',
+                        content: text.slice(i + 1, end),
+                    });
+                    i = end + 1;
+                    continue;
+                }
+            }
+            // Strong
+            if (text.startsWith('**', i)) {
+                const end = text.indexOf('**', i + 2);
+                if (end !== -1) {
+                    nodes.push({
+                        type: 'strong',
+                        children: this.parse(text.slice(i + 2, end)),
+                    });
+                    i = end + 2;
+                    continue;
+                }
+            }
+            // Underline
+            if (text.startsWith('__', i)) {
+                const end = text.indexOf('__', i + 2);
+                if (end !== -1) {
+                    nodes.push({
+                        type: 'underline',
+                        children: this.parse(text.slice(i + 2, end)),
+                    });
+                    i = end + 2;
+                    continue;
+                }
+            }
+            // Strikethrough
+            if (text.startsWith('~~', i)) {
+                const end = text.indexOf('~~', i + 2);
+                if (end !== -1) {
+                    nodes.push({
+                        type: 'strikethrough',
+                        children: this.parse(text.slice(i + 2, end)),
+                    });
+                    i = end + 2;
+                    continue;
+                }
+            }
+            // Italic
+            if (text[i] === '*' || text[i] === '_') {
+                const end = text.indexOf(text[i], i + 1);
+                if (end !== -1) {
+                    nodes.push({
+                        type: 'emphasis',
+                        children: this.parse(text.slice(i + 1, end)),
+                    });
+                    i = end + 1;
+                    continue;
+                }
+            }
+            // Line break
+            if (text[i] === '\n') {
+                nodes.push({
+                    type: 'line_break',
+                });
+                i++;
+                continue;
+            }
+            // Text
+            nodes.push({
+                type: 'text',
+                content: text[i],
+            });
+            i++;
+        }
+        return this.mergeText(nodes);
+    }
+    static mergeText(nodes) {
+        const out = [];
+        for (const n of nodes) {
+            const last = out[out.length - 1];
+            if (n.type === 'text' && last?.type === 'text') {
+                last.content += n.content;
+            }
+            else {
+                out.push(n);
+            }
+        }
+        return out;
+    }
+}

package/lib/parser/preprocess.d.ts

@@ -0,0 +1 @@
+export declare function preprocess(source: string): string;

package/lib/parser/preprocess.js

@@ -0,0 +1,3 @@
+export function preprocess(source) {
+    return source.replace(/<!--MMDMETA>[\s\S]*?<ENDMETA-->/g, '');
+}

package/lib/renderer/HTMLRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentNode } from '../ast/nodes.js';
+export declare class HTMLRenderer {
+    render(doc: DocumentNode): string;
+    private renderBlock;
+    private renderInline;
+}

package/lib/renderer/HTMLRenderer.js

@@ -0,0 +1,71 @@
+const escapeHTML = (s) => s
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+const isAllowedImage = (src) => /\.(png|jpe?g|gif)$/i.test(src);
+export class HTMLRenderer {
+    render(doc) {
+        return doc.children.map((b) => this.renderBlock(b)).join('\n');
+    }
+    renderBlock(b) {
+        switch (b.type) {
+            case 'heading':
+                if (b.sample) {
+                    return `<span class="sample-h${b.level}">${this.renderInline(b.children)}</span>`;
+                }
+                else if (b.subtitle) {
+                    return `<span class="subtitle">${this.renderInline(b.children)}</span>`;
+                }
+                else {
+                    return `<h${b.level}>${this.renderInline(b.children)}</h${b.level}>`;
+                }
+            case 'paragraph':
+                return `<p>${this.renderInline(b.children)}</p>`;
+            case 'blockquote':
+                return `<blockquote>${b.children.map((c) => this.renderBlock(c)).join('')}</blockquote>`;
+            case 'list':
+                const tag = b.ordered ? 'ol' : 'ul';
+                return `<${tag}>${b.items.map((i) => `<li>${i.children.map((c) => this.renderBlock(c)).join('')}</li>`).join('')}</${tag}>`;
+            case 'code_block':
+                return `<pre><code>${escapeHTML(b.content)}</code></pre>`;
+            case 'table':
+                return `<table>
+					<thead>${b.header.map((r) => `<tr>${r.map((c) => `<th>${this.renderInline(c)}</th>`).join('')}</tr>`).join('')}</thead>
+					<tbody>${b.rows.map((r) => `<tr>${r.map((c) => `<td>${this.renderInline(c)}</td>`).join('')}</tr>`).join('')}</tbody>
+				</table>`;
+            default:
+                return '';
+        }
+    }
+    renderInline(nodes) {
+        return nodes
+            .map((n) => {
+            switch (n.type) {
+                case 'text':
+                    return escapeHTML(n.content);
+                case 'emphasis':
+                    return `<em>${this.renderInline(n.children)}</em>`;
+                case 'strong':
+                    return `<strong>${this.renderInline(n.children)}</strong>`;
+                case 'underline':
+                    return `<u>${this.renderInline(n.children)}</u>`;
+                case 'strikethrough':
+                    return `<del>${this.renderInline(n.children)}</del>`;
+                case 'code_inline':
+                    return `<code>${escapeHTML(n.content)}</code>`;
+                case 'link':
+                    return `<a href="${escapeHTML(n.href)}"${n.external ? ' target="_blank" rel="noopener noreferrer"' : ''}>${escapeHTML(n.text)}</a>`;
+                case 'image':
+                    if (!isAllowedImage(n.src)) {
+                        return `<span class="image-error">[image non supportée]</span>`;
+                    }
+                    return `<img src="${escapeHTML(n.src)}" alt="${escapeHTML(n.alt)}" loading="lazy" />`;
+                case 'line_break':
+                    return '<br />';
+            }
+        })
+            .join('');
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "mmi-md",
+  "version": "1.0.0",
+  "description": "Markdown créé spécialement pour MMIpedia",
+  "keywords": [
+    "markdown",
+    "mmi"
+  ],
+  "homepage": "https://github.com/MMI-CODES/mmarkdown#readme",
+  "bugs": {
+    "url": "https://github.com/MMI-CODES/mmarkdown/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MMI-CODES/mmarkdown.git"
+  },
+  "license": "UNLICENSED",
+  "author": "Loan",
+  "type": "module",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src --out-dir lib --clean",
+    "start": "tsx lib/index.ts",
+    "lint": "eslint . --fix",
+    "format": "prettier --write src/"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "eslint": "^9.39.2",
+    "prettier": "^3.8.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./lib",
+
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+
+    "declaration": true,
+
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}