telegram-md2html 1.0.0

package/README.md

@@ -0,0 +1,306 @@
+# Telegram Markdown to HTML Converter
+
+[![npm version](https://img.shields.io/npm/v/telegram-md2html.svg)](https://www.npmjs.com/package/telegram-md2html)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
+
+A smart, efficient, and reliable library for converting Telegram-style Markdown to Telegram-compatible HTML. Perfect for Telegram bots, messaging applications, and content processing pipelines.
+
+## ✨ Features
+
+- ✅ **Complete Telegram Markdown Support** - All Telegram-specific formatting
+- ✅ **Smart Parsing** - Context-aware (ignores formatting inside code blocks)
+- ✅ **Nested Formatting** - Proper handling of nested styles
+- ✅ **HTML Safety** - Automatic escaping of HTML special characters
+- ✅ **Auto-recovery** - Automatically closes unclosed code blocks
+- ✅ **Dual Module Support** - Works with both CommonJS (`require`) and ES Modules (`import`)
+- ✅ **TypeScript Ready** - Full type definitions included
+- ✅ **Highly Customizable** - Extensible with custom processors
+- ✅ **Production Ready** - Minified builds, comprehensive tests
+- ✅ **Zero Dependencies** - Lightweight and fast
+
+## 📦 Installation
+
+```bash
+npm install telegram-md2html
+# or
+yarn add telegram-md2html
+# or
+pnpm add telegram-md2html
+```
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```javascript
+// CommonJS
+const { markdownToHtml } = require('telegram-md2html');
+
+// ES Modules
+import { markdownToHtml } from 'telegram-md2html';
+
+const markdown = '**Bold text** and *italic text* with a [link](https://example.com)';
+const html = markdownToHtml(markdown);
+
+console.log(html);
+// Output: <b>Bold text</b> and <i>italic text</i> with a <a href="https://example.com">link</a>
+```
+
+### Complex Example
+
+```javascript
+import { markdownToHtml } from 'telegram-md2html';
+
+const markdown = `
+# Welcome to Telegram Bot!
+
+**Important Features:**
+• *Italic* and __underline__ formatting
+• ~~Strikethrough~~ and ||spoiler|| text
+• \`Inline code\` and code blocks:
+\`\`\`javascript
+function greet() {
+    console.log("Hello, Telegram!");
+}
+\`\`\`
+
+> This is a regular blockquote
+**> This is an expandable blockquote
+
+[Learn more](https://core.telegram.org/bots/api#html-style)
+`;
+
+const html = markdownToHtml(markdown);
+// Send to Telegram bot...
+```
+
+## 📚 Supported Syntax
+
+| Markdown Syntax | HTML Output | Description |
+|----------------|-------------|-------------|
+| `**bold**` | `<b>bold</b>` | Bold text |
+| `*italic*` | `<i>italic</i>` | Italic text (asterisk) |
+| `_italic_` | `<i>italic</i>` | Italic text (underscore) |
+| `__underline__` | `<u>underline</u>` | Underlined text |
+| `~~strikethrough~~` | `<s>strikethrough</s>` | Strikethrough text |
+| `\|\|spoiler\|\|` | `<span class="tg-spoiler">spoiler</span>` | Spoiler text |
+| `` `code` `` | `<code>code</code>` | Inline code |
+| ```` ```language\ncode\n``` ```` | `<pre><code class="language-xxx">code</code></pre>` | Code block with syntax highlighting |
+| `[text](url)` | `<a href="url">text</a>` | Hyperlink |
+| `> quote` | `<blockquote>quote</blockquote>` | Regular blockquote |
+| `**> quote` | `<blockquote expandable>quote</blockquote>` | Expandable blockquote |
+
+## ⚙️ Advanced Usage
+
+### Custom Converter with Options
+
+```javascript
+import { createConverter } from 'telegram-md2html';
+
+// Create a custom converter with advanced options
+const converter = createConverter({
+  escapeHtml: true, // Escape HTML special characters (default: true)
+  autoCloseCodeBlocks: true, // Auto-close unclosed code blocks (default: true)
+  
+  // Custom link processor
+  linkProcessor: (url, text) => 
+    `<a href="${url}" target="_blank" rel="noopener noreferrer">🔗 ${text}</a>`,
+  
+  // Custom code block processor
+  codeBlockProcessor: (code, language) => 
+    `<div class="code-container">
+       <div class="code-header">${language || 'code'}</div>
+       <pre><code>${code}</code></pre>
+     </div>`
+});
+
+const customHtml = converter.convert('Check [this](https://example.com) out!');
+```
+
+### Disable HTML Escaping (Use with Caution)
+
+```javascript
+import { markdownToHtml } from 'telegram-md2html';
+
+// For trusted content where you want to preserve existing HTML
+const html = markdownToHtml('Mix <b>HTML</b> with **Markdown**', {
+  escapeHtml: false
+});
+// Output: Mix <b>HTML</b> with <b>Markdown</b>
+```
+
+## 🔧 API Reference
+
+### `markdownToHtml(text: string, options?: ConvertOptions): string`
+
+Main conversion function that converts Markdown to Telegram HTML.
+
+**Parameters:**
+- `text` - The Markdown text to convert
+- `options` - Optional conversion settings (see below)
+
+**Returns:** Telegram-compatible HTML string
+
+### `createConverter(options?: ConvertOptions): MarkdownConverter`
+
+Creates a reusable converter instance with custom options.
+
+### `ConvertOptions` Interface
+
+```typescript
+interface ConvertOptions {
+  /**
+   * Whether to escape HTML special characters (&, <, >, ", ')
+   * @default true
+   */
+  escapeHtml?: boolean;
+  
+  /**
+   * Whether to automatically append missing ``` to close code blocks
+   * @default true
+   */
+  autoCloseCodeBlocks?: boolean;
+  
+  /**
+   * Custom processor for links
+   * @param url - The URL
+   * @param text - The link text
+   * @returns HTML string for the link
+   */
+  linkProcessor?: (url: string, text: string) => string;
+  
+  /**
+   * Custom processor for code blocks
+   * @param code - The code content
+   * @param language - Optional language specified after ```
+   * @returns HTML string for the code block
+   */
+  codeBlockProcessor?: (code: string, language?: string) => string;
+}
+```
+
+## 💡 Real-World Examples
+
+### Telegram Bot Integration
+
+```javascript
+const { Telegraf } = require('telegraf');
+const { markdownToHtml } = require('telegram-md2html');
+
+const bot = new Telegraf(process.env.BOT_TOKEN);
+
+bot.command('format', (ctx) => {
+  const markdown = `
+**Formatting Examples:**
+
+*Bold*: **bold text**
+*Italic*: *italic text* or _italic text_
+*Code*: \`inline code\`
+*Link*: [Telegram](https://telegram.org)
+*Quote*:
+> To be or not to be
+  `;
+  
+  // Convert to Telegram HTML
+  const html = markdownToHtml(markdown);
+  
+  // Send as HTML message
+  ctx.replyWithHTML(html);
+});
+
+bot.launch();
+```
+
+### Content Processing Pipeline
+
+```javascript
+import { createConverter } from 'telegram-md2html';
+import { readFileSync, writeFileSync } from 'fs';
+
+// Process multiple files
+const converter = createConverter({
+  codeBlockProcessor: (code, language) => `
+<details>
+  <summary>${language ? `📁 ${language.toUpperCase()}` : '📄 CODE'}</summary>
+  <pre><code>${code}</code></pre>
+</details>
+  `
+});
+
+const input = readFileSync('document.md', 'utf-8');
+const output = converter.convert(input);
+writeFileSync('document.html', output);
+```
+
+## 🧪 Testing
+
+```bash
+# Run tests
+npm test
+
+# Run tests with coverage
+npm test -- --coverage
+```
+
+## 🔍 How It Works
+
+The library uses a sophisticated tokenizer that:
+1. Scans the text for Markdown patterns
+2. Intelligently ignores formatting inside code blocks and inline code
+3. Processes nested formatting correctly
+4. Applies custom processors if provided
+5. Escapes HTML characters for security
+6. Auto-closes unclosed code blocks
+
+## 📖 Common Use Cases
+
+1. **Telegram Bots** - Format bot responses with rich text
+2. **Content Management Systems** - Convert user input to safe HTML
+3. **Documentation Tools** - Generate Telegram-compatible documentation
+4. **Chat Applications** - Format messages for display
+5. **Export Tools** - Convert Markdown to Telegram HTML for export
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/soumyadeep765/telegram-md2html.git
+cd telegram-md2html
+
+# Install dependencies
+npm install
+
+# Build the library
+npm run build
+
+# Run tests
+npm test
+
+# Development mode (watch for changes)
+npm run dev
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Issue Reporting
+
+Found a bug or have a feature request? Please open an issue on the [GitHub repository](https://github.com/soumyadeep765/telegram-md2html/issues).
+
+## Acknowledgments
+
+- Telegram for their awesome Bot API and HTML formatting support
+- All contributors who help improve this library
+
+## Support
+
+For support, questions, or discussions:
+- Open an issue on GitHub
+- Check the [examples](examples/) directory
+- Refer to the [Telegram Bot API documentation](https://core.telegram.org/bots/api#html-style)
+
+---
+
+**Happy coding!** If you find this library useful, please consider giving it a ⭐ on GitHub!

package/dist/converter.d.ts

@@ -0,0 +1,29 @@
+import { ConvertOptions } from './types';
+export declare class MarkdownConverter {
+    private options;
+    private hasCustomLinkProcessor;
+    private hasCustomCodeBlockProcessor;
+    constructor(options?: ConvertOptions);
+    /**
+     * Convert markdown text to Telegram HTML
+     */
+    convert(text: string): string;
+    /**
+     * Recursively convert markdown, handling nested styles
+     */
+    private convertRecursive;
+    /**
+     * Wrap token content in HTML tags
+     */
+    private wrapToken;
+    /**
+     * Preprocess blockquotes to mark them before other parsing
+     */
+    private preprocessBlockquotes;
+    /**
+     * Process blockquote markers
+     */
+    private processBlockquoteMarkers;
+    private defaultLinkProcessor;
+    private defaultCodeBlockProcessor;
+}

package/dist/index.cjs

@@ -0,0 +1,417 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class MarkdownTokenizer {
+    constructor(text) {
+        this.text = text;
+    }
+    /**
+     * Tokenize the markdown text
+     */
+    tokenize() {
+        const tokens = [];
+        let pos = 0;
+        const text = this.text;
+        while (pos < text.length) {
+            // Skip if inside code block
+            if (this.isInsideCodeBlock(text, pos)) {
+                pos++;
+                continue;
+            }
+            // Try to match each token type (from outermost to innermost)
+            const token = this.matchToken(pos);
+            if (token) {
+                tokens.push(token);
+                pos = token.end;
+            }
+            else {
+                pos++;
+            }
+        }
+        return tokens.sort((a, b) => a.start - b.start);
+    }
+    matchToken(start) {
+        const text = this.text;
+        const remaining = text.slice(start);
+        // Skip if we're inside a quote marker
+        if (remaining.startsWith('[QUOTE]') || remaining.startsWith('[EXPANDABLE_QUOTE]')) {
+            return null;
+        }
+        // Match code block (triple backticks) - highest priority
+        const codeBlockMatch = remaining.match(/^```(\w+)?\n([\s\S]*?)```/);
+        if (codeBlockMatch) {
+            return {
+                type: 'code_block',
+                content: codeBlockMatch[2],
+                language: codeBlockMatch[1],
+                start: start,
+                end: start + codeBlockMatch[0].length
+            };
+        }
+        // Match inline code
+        const inlineCodeMatch = remaining.match(/^`([^`\n]+)`/);
+        if (inlineCodeMatch && !this.isInsideInlineCode(text, start)) {
+            return {
+                type: 'inline_code',
+                content: inlineCodeMatch[1],
+                start: start,
+                end: start + inlineCodeMatch[0].length
+            };
+        }
+        // Match spoiler
+        const spoilerMatch = remaining.match(/^\|\|([^|\n]+?)\|\|/);
+        if (spoilerMatch) {
+            return {
+                type: 'spoiler',
+                content: spoilerMatch[1],
+                start: start,
+                end: start + spoilerMatch[0].length
+            };
+        }
+        // Match strikethrough
+        const strikethroughMatch = remaining.match(/^~~([^~\n]+?)~~/);
+        if (strikethroughMatch) {
+            return {
+                type: 'strikethrough',
+                content: strikethroughMatch[1],
+                start: start,
+                end: start + strikethroughMatch[0].length
+            };
+        }
+        // Match bold
+        const boldMatch = remaining.match(/^\*\*([^*\n]+?)\*\*/);
+        if (boldMatch) {
+            return {
+                type: 'bold',
+                content: boldMatch[1],
+                start: start,
+                end: start + boldMatch[0].length
+            };
+        }
+        // Match underline
+        const underlineMatch = remaining.match(/^__([^_\n]+?)__/);
+        if (underlineMatch) {
+            return {
+                type: 'underline',
+                content: underlineMatch[1],
+                start: start,
+                end: start + underlineMatch[0].length
+            };
+        }
+        // Match italic with asterisk
+        const italicAsteriskMatch = remaining.match(/^\*([^*\n][^*]*?)\*/);
+        if (italicAsteriskMatch && italicAsteriskMatch[1].trim().length > 0) {
+            // Don't match if it's part of bold (**)
+            if (start > 0 && text[start - 1] === '*' && start < text.length - 1 && text[start + 1] === '*') {
+                return null;
+            }
+            return {
+                type: 'italic',
+                content: italicAsteriskMatch[1],
+                start: start,
+                end: start + italicAsteriskMatch[0].length
+            };
+        }
+        // Match italic with underscore
+        const italicUnderscoreMatch = remaining.match(/^_([^_\n]+?)_/);
+        if (italicUnderscoreMatch && italicUnderscoreMatch[1].trim().length > 0) {
+            // Don't match if it's part of underline (__)
+            if (start > 0 && text[start - 1] === '_' && start < text.length - 1 && text[start + 1] === '_') {
+                return null;
+            }
+            return {
+                type: 'italic',
+                content: italicUnderscoreMatch[1],
+                start: start,
+                end: start + italicUnderscoreMatch[0].length
+            };
+        }
+        // Match link
+        const linkMatch = remaining.match(/^\[([^\]]+?)\]\(([^)]+?)\)/);
+        if (linkMatch) {
+            return {
+                type: 'link',
+                content: linkMatch[1],
+                start: start,
+                end: start + linkMatch[0].length,
+                language: linkMatch[2]
+            };
+        }
+        return null;
+    }
+    isInsideCodeBlock(text, position) {
+        // Check for code blocks
+        const codeBlockRegex = /```[\s\S]*?```/g;
+        let match;
+        while ((match = codeBlockRegex.exec(text)) !== null) {
+            if (position > match.index && position < match.index + match[0].length) {
+                // But allow matching the closing ``` itself
+                if (position >= match.index + match[0].length - 3) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    isInsideInlineCode(text, position) {
+        // Check for inline code
+        const inlineCodeRegex = /`[^`\n]*`/g;
+        let match;
+        while ((match = inlineCodeRegex.exec(text)) !== null) {
+            if (position > match.index && position < match.index + match[0].length) {
+                // But allow matching the closing ` itself
+                if (position === match.index + match[0].length - 1) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+/**
+ * Escapes HTML special characters (but not double-escape)
+ */
+function escapeHtml(text) {
+    if (!text)
+        return text;
+    // Replace & first (but not if it's already an entity)
+    let result = text.replace(/&(?!#?\w+;)/g, '&amp;');
+    result = result.replace(/</g, '&lt;');
+    result = result.replace(/>/g, '&gt;');
+    result = result.replace(/"/g, '&quot;');
+    result = result.replace(/'/g, '&#39;');
+    return result;
+}
+/**
+ * Escapes Telegram HTML special characters
+ */
+function escapeTelegramHtml(text) {
+    if (!text)
+        return text;
+    // For Telegram, we only need to escape &, <, >, and "
+    let result = text.replace(/&(?!#?\w+;)/g, '&amp;');
+    result = result.replace(/</g, '&lt;');
+    result = result.replace(/>/g, '&gt;');
+    result = result.replace(/"/g, '&quot;');
+    return result;
+}
+/**
+ * Appends missing code block delimiters
+ */
+function autoCloseCodeBlocks(text) {
+    // Count triple backticks
+    const tripleBacktickCount = (text.match(/```/g) || []).length;
+    // If odd number, add closing backticks
+    if (tripleBacktickCount % 2 === 1) {
+        return text + '\n```';
+    }
+    return text;
+}
+
+class MarkdownConverter {
+    constructor(options = {}) {
+        this.hasCustomLinkProcessor = !!options.linkProcessor;
+        this.hasCustomCodeBlockProcessor = !!options.codeBlockProcessor;
+        this.options = {
+            escapeHtml: options.escapeHtml ?? true,
+            autoCloseCodeBlocks: options.autoCloseCodeBlocks ?? true,
+            linkProcessor: options.linkProcessor || this.defaultLinkProcessor.bind(this),
+            codeBlockProcessor: options.codeBlockProcessor || this.defaultCodeBlockProcessor.bind(this)
+        };
+    }
+    /**
+     * Convert markdown text to Telegram HTML
+     */
+    convert(text) {
+        // Auto-close code blocks if enabled
+        let processedText = this.options.autoCloseCodeBlocks
+            ? autoCloseCodeBlocks(text)
+            : text;
+        // First pass: convert blockquotes (they should be at line starts)
+        processedText = this.preprocessBlockquotes(processedText);
+        // Convert the text recursively
+        let result = this.convertRecursive(processedText);
+        // Process blockquote markers
+        result = this.processBlockquoteMarkers(result);
+        // Only trim if there's actual content (not just whitespace)
+        if (result.trim() === '') {
+            return text; // Return original text (spaces) if result is empty
+        }
+        return result.trim();
+    }
+    /**
+     * Recursively convert markdown, handling nested styles
+     */
+    convertRecursive(text, depth = 0) {
+        if (depth > 10)
+            return text; // Prevent infinite recursion
+        // Tokenize the text
+        const tokenizer = new MarkdownTokenizer(text);
+        const tokens = tokenizer.tokenize();
+        // If no tokens found, return the text as-is (with HTML escaping)
+        if (tokens.length === 0) {
+            return this.options.escapeHtml ? escapeTelegramHtml(text) : text;
+        }
+        let result = '';
+        let lastPos = 0;
+        for (const token of tokens) {
+            // Add text before token
+            if (token.start > lastPos) {
+                const textBefore = text.slice(lastPos, token.start);
+                result += this.options.escapeHtml ? escapeTelegramHtml(textBefore) : textBefore;
+            }
+            // Handle code blocks specially (no recursive parsing inside)
+            if (token.type === 'code_block') {
+                const codeContent = this.options.escapeHtml ? escapeHtml(token.content) : token.content;
+                result += this.wrapToken(token.type, codeContent, token.language);
+                lastPos = token.end;
+                continue;
+            }
+            // Handle inline code specially (no recursive parsing inside)
+            if (token.type === 'inline_code') {
+                const codeContent = this.options.escapeHtml ? escapeHtml(token.content) : token.content;
+                result += `<code>${codeContent}</code>`;
+                lastPos = token.end;
+                continue;
+            }
+            // Process other token content recursively
+            const tokenContent = this.convertRecursive(token.content, depth + 1);
+            // Wrap the content in appropriate HTML tags
+            result += this.wrapToken(token.type, tokenContent, token.language);
+            lastPos = token.end;
+        }
+        // Add remaining text
+        if (lastPos < text.length) {
+            const remainingText = text.slice(lastPos);
+            result += this.options.escapeHtml ? escapeTelegramHtml(remainingText) : remainingText;
+        }
+        return result;
+    }
+    /**
+     * Wrap token content in HTML tags
+     */
+    wrapToken(type, content, language) {
+        switch (type) {
+            case 'bold':
+                return `<b>${content}</b>`;
+            case 'italic':
+                return `<i>${content}</i>`;
+            case 'underline':
+                return `<u>${content}</u>`;
+            case 'strikethrough':
+                return `<s>${content}</s>`;
+            case 'spoiler':
+                return `<span class="tg-spoiler">${content}</span>`;
+            case 'inline_code':
+                // Already handled above
+                return `<code>${content}</code>`;
+            case 'code_block':
+                // Already handled above, but handle custom processor
+                if (this.hasCustomCodeBlockProcessor) {
+                    return this.options.codeBlockProcessor(content, language);
+                }
+                const escapedCode = this.options.escapeHtml ? escapeHtml(content) : content;
+                const langAttr = language ? ` class="language-${language}"` : '';
+                return `\n<pre><code${langAttr}>${escapedCode}</code></pre>\n`;
+            case 'link':
+                const url = language || '';
+                if (this.hasCustomLinkProcessor) {
+                    return this.options.linkProcessor(url, content);
+                }
+                const escapedUrl = this.options.escapeHtml ? escapeHtml(url) : url;
+                const escapedText = this.options.escapeHtml ? escapeHtml(content) : content;
+                return `<a href="${escapedUrl}">${escapedText}</a>`;
+            case 'quote':
+                return `\n<blockquote>${content.trim()}</blockquote>\n`;
+            case 'expandable_quote':
+                return `\n<blockquote expandable>${content.trim()}</blockquote>\n`;
+            default:
+                return content;
+        }
+    }
+    /**
+     * Preprocess blockquotes to mark them before other parsing
+     */
+    preprocessBlockquotes(text) {
+        const lines = text.split('\n');
+        const processedLines = [];
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            // Only treat lines starting with > at the beginning of line as blockquotes
+            if (trimmedLine.startsWith('**>')) {
+                // Expandable blockquote
+                const content = trimmedLine.substring(3).trim();
+                processedLines.push(`[EXPANDABLE_QUOTE]${content}`);
+            }
+            else if (trimmedLine.startsWith('>')) {
+                // Regular blockquote
+                const content = trimmedLine.substring(1).trim();
+                processedLines.push(`[QUOTE]${content}`);
+            }
+            else {
+                processedLines.push(line);
+            }
+        }
+        return processedLines.join('\n');
+    }
+    /**
+     * Process blockquote markers
+     */
+    processBlockquoteMarkers(text) {
+        let result = text;
+        // Replace expandable quote markers (process content recursively)
+        const expandableQuoteRegex = /\[EXPANDABLE_QUOTE\](.*?)(?=\n|$)/g;
+        result = result.replace(expandableQuoteRegex, (match, content) => {
+            const processedContent = this.convertRecursive(content);
+            return `\n<blockquote expandable>${processedContent.trim()}</blockquote>\n`;
+        });
+        // Replace regular quote markers (process content recursively)
+        const quoteRegex = /\[QUOTE\](.*?)(?=\n|$)/g;
+        result = result.replace(quoteRegex, (match, content) => {
+            const processedContent = this.convertRecursive(content);
+            return `\n<blockquote>${processedContent.trim()}</blockquote>\n`;
+        });
+        return result;
+    }
+    defaultLinkProcessor(url, text) {
+        const escapedUrl = this.options.escapeHtml ? escapeHtml(url) : url;
+        const escapedText = this.options.escapeHtml ? escapeHtml(text) : text;
+        return `<a href="${escapedUrl}">${escapedText}</a>`;
+    }
+    defaultCodeBlockProcessor(code, language) {
+        const escapedCode = this.options.escapeHtml ? escapeHtml(code) : code;
+        const langAttr = language ? ` class="language-${language}"` : '';
+        return `\n<pre><code${langAttr}>${escapedCode}</code></pre>\n`;
+    }
+}
+
+/**
+ * Convert Telegram-style Markdown to HTML
+ * @param text - Markdown text to convert
+ * @param options - Conversion options
+ * @returns Telegram-compatible HTML
+ */
+function markdownToHtml(text, options) {
+    const converter = new MarkdownConverter(options);
+    return converter.convert(text);
+}
+/**
+ * Create a converter instance with custom options
+ */
+function createConverter(options) {
+    return new MarkdownConverter(options);
+}
+var index = {
+    markdownToHtml,
+    createConverter,
+    MarkdownConverter
+};
+
+exports.MarkdownConverter = MarkdownConverter;
+exports.createConverter = createConverter;
+exports.default = index;
+exports.markdownToHtml = markdownToHtml;

package/dist/index.d.mts

@@ -0,0 +1,21 @@
+import { MarkdownConverter } from './converter.js';
+import { ConvertOptions } from './types.js';
+/**
+ * Convert Telegram-style Markdown to HTML
+ * @param text - Markdown text to convert
+ * @param options - Conversion options
+ * @returns Telegram-compatible HTML
+ */
+export declare function markdownToHtml(text: string, options?: ConvertOptions): string;
+/**
+ * Create a converter instance with custom options
+ */
+export declare function createConverter(options?: ConvertOptions): MarkdownConverter;
+export { MarkdownConverter } from './converter.js';
+export type { ConvertOptions, Token } from './types.js';
+declare const _default: {
+    markdownToHtml: typeof markdownToHtml;
+    createConverter: typeof createConverter;
+    MarkdownConverter: typeof MarkdownConverter;
+};
+export default _default;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { MarkdownConverter } from './converter.js';
+import { ConvertOptions } from './types.js';
+/**
+ * Convert Telegram-style Markdown to HTML
+ * @param text - Markdown text to convert
+ * @param options - Conversion options
+ * @returns Telegram-compatible HTML
+ */
+export declare function markdownToHtml(text: string, options?: ConvertOptions): string;
+/**
+ * Create a converter instance with custom options
+ */
+export declare function createConverter(options?: ConvertOptions): MarkdownConverter;
+export { MarkdownConverter } from './converter.js';
+export type { ConvertOptions, Token } from './types.js';
+declare const _default: {
+    markdownToHtml: typeof markdownToHtml;
+    createConverter: typeof createConverter;
+    MarkdownConverter: typeof MarkdownConverter;
+};
+export default _default;

package/dist/index.mjs

@@ -0,0 +1,410 @@
+class MarkdownTokenizer {
+    constructor(text) {
+        this.text = text;
+    }
+    /**
+     * Tokenize the markdown text
+     */
+    tokenize() {
+        const tokens = [];
+        let pos = 0;
+        const text = this.text;
+        while (pos < text.length) {
+            // Skip if inside code block
+            if (this.isInsideCodeBlock(text, pos)) {
+                pos++;
+                continue;
+            }
+            // Try to match each token type (from outermost to innermost)
+            const token = this.matchToken(pos);
+            if (token) {
+                tokens.push(token);
+                pos = token.end;
+            }
+            else {
+                pos++;
+            }
+        }
+        return tokens.sort((a, b) => a.start - b.start);
+    }
+    matchToken(start) {
+        const text = this.text;
+        const remaining = text.slice(start);
+        // Skip if we're inside a quote marker
+        if (remaining.startsWith('[QUOTE]') || remaining.startsWith('[EXPANDABLE_QUOTE]')) {
+            return null;
+        }
+        // Match code block (triple backticks) - highest priority
+        const codeBlockMatch = remaining.match(/^```(\w+)?\n([\s\S]*?)```/);
+        if (codeBlockMatch) {
+            return {
+                type: 'code_block',
+                content: codeBlockMatch[2],
+                language: codeBlockMatch[1],
+                start: start,
+                end: start + codeBlockMatch[0].length
+            };
+        }
+        // Match inline code
+        const inlineCodeMatch = remaining.match(/^`([^`\n]+)`/);
+        if (inlineCodeMatch && !this.isInsideInlineCode(text, start)) {
+            return {
+                type: 'inline_code',
+                content: inlineCodeMatch[1],
+                start: start,
+                end: start + inlineCodeMatch[0].length
+            };
+        }
+        // Match spoiler
+        const spoilerMatch = remaining.match(/^\|\|([^|\n]+?)\|\|/);
+        if (spoilerMatch) {
+            return {
+                type: 'spoiler',
+                content: spoilerMatch[1],
+                start: start,
+                end: start + spoilerMatch[0].length
+            };
+        }
+        // Match strikethrough
+        const strikethroughMatch = remaining.match(/^~~([^~\n]+?)~~/);
+        if (strikethroughMatch) {
+            return {
+                type: 'strikethrough',
+                content: strikethroughMatch[1],
+                start: start,
+                end: start + strikethroughMatch[0].length
+            };
+        }
+        // Match bold
+        const boldMatch = remaining.match(/^\*\*([^*\n]+?)\*\*/);
+        if (boldMatch) {
+            return {
+                type: 'bold',
+                content: boldMatch[1],
+                start: start,
+                end: start + boldMatch[0].length
+            };
+        }
+        // Match underline
+        const underlineMatch = remaining.match(/^__([^_\n]+?)__/);
+        if (underlineMatch) {
+            return {
+                type: 'underline',
+                content: underlineMatch[1],
+                start: start,
+                end: start + underlineMatch[0].length
+            };
+        }
+        // Match italic with asterisk
+        const italicAsteriskMatch = remaining.match(/^\*([^*\n][^*]*?)\*/);
+        if (italicAsteriskMatch && italicAsteriskMatch[1].trim().length > 0) {
+            // Don't match if it's part of bold (**)
+            if (start > 0 && text[start - 1] === '*' && start < text.length - 1 && text[start + 1] === '*') {
+                return null;
+            }
+            return {
+                type: 'italic',
+                content: italicAsteriskMatch[1],
+                start: start,
+                end: start + italicAsteriskMatch[0].length
+            };
+        }
+        // Match italic with underscore
+        const italicUnderscoreMatch = remaining.match(/^_([^_\n]+?)_/);
+        if (italicUnderscoreMatch && italicUnderscoreMatch[1].trim().length > 0) {
+            // Don't match if it's part of underline (__)
+            if (start > 0 && text[start - 1] === '_' && start < text.length - 1 && text[start + 1] === '_') {
+                return null;
+            }
+            return {
+                type: 'italic',
+                content: italicUnderscoreMatch[1],
+                start: start,
+                end: start + italicUnderscoreMatch[0].length
+            };
+        }
+        // Match link
+        const linkMatch = remaining.match(/^\[([^\]]+?)\]\(([^)]+?)\)/);
+        if (linkMatch) {
+            return {
+                type: 'link',
+                content: linkMatch[1],
+                start: start,
+                end: start + linkMatch[0].length,
+                language: linkMatch[2]
+            };
+        }
+        return null;
+    }
+    isInsideCodeBlock(text, position) {
+        // Check for code blocks
+        const codeBlockRegex = /```[\s\S]*?```/g;
+        let match;
+        while ((match = codeBlockRegex.exec(text)) !== null) {
+            if (position > match.index && position < match.index + match[0].length) {
+                // But allow matching the closing ``` itself
+                if (position >= match.index + match[0].length - 3) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    isInsideInlineCode(text, position) {
+        // Check for inline code
+        const inlineCodeRegex = /`[^`\n]*`/g;
+        let match;
+        while ((match = inlineCodeRegex.exec(text)) !== null) {
+            if (position > match.index && position < match.index + match[0].length) {
+                // But allow matching the closing ` itself
+                if (position === match.index + match[0].length - 1) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+/**
+ * Escapes HTML special characters (but not double-escape)
+ */
+function escapeHtml(text) {
+    if (!text)
+        return text;
+    // Replace & first (but not if it's already an entity)
+    let result = text.replace(/&(?!#?\w+;)/g, '&amp;');
+    result = result.replace(/</g, '&lt;');
+    result = result.replace(/>/g, '&gt;');
+    result = result.replace(/"/g, '&quot;');
+    result = result.replace(/'/g, '&#39;');
+    return result;
+}
+/**
+ * Escapes Telegram HTML special characters
+ */
+function escapeTelegramHtml(text) {
+    if (!text)
+        return text;
+    // For Telegram, we only need to escape &, <, >, and "
+    let result = text.replace(/&(?!#?\w+;)/g, '&amp;');
+    result = result.replace(/</g, '&lt;');
+    result = result.replace(/>/g, '&gt;');
+    result = result.replace(/"/g, '&quot;');
+    return result;
+}
+/**
+ * Appends missing code block delimiters
+ */
+function autoCloseCodeBlocks(text) {
+    // Count triple backticks
+    const tripleBacktickCount = (text.match(/```/g) || []).length;
+    // If odd number, add closing backticks
+    if (tripleBacktickCount % 2 === 1) {
+        return text + '\n```';
+    }
+    return text;
+}
+
+class MarkdownConverter {
+    constructor(options = {}) {
+        this.hasCustomLinkProcessor = !!options.linkProcessor;
+        this.hasCustomCodeBlockProcessor = !!options.codeBlockProcessor;
+        this.options = {
+            escapeHtml: options.escapeHtml ?? true,
+            autoCloseCodeBlocks: options.autoCloseCodeBlocks ?? true,
+            linkProcessor: options.linkProcessor || this.defaultLinkProcessor.bind(this),
+            codeBlockProcessor: options.codeBlockProcessor || this.defaultCodeBlockProcessor.bind(this)
+        };
+    }
+    /**
+     * Convert markdown text to Telegram HTML
+     */
+    convert(text) {
+        // Auto-close code blocks if enabled
+        let processedText = this.options.autoCloseCodeBlocks
+            ? autoCloseCodeBlocks(text)
+            : text;
+        // First pass: convert blockquotes (they should be at line starts)
+        processedText = this.preprocessBlockquotes(processedText);
+        // Convert the text recursively
+        let result = this.convertRecursive(processedText);
+        // Process blockquote markers
+        result = this.processBlockquoteMarkers(result);
+        // Only trim if there's actual content (not just whitespace)
+        if (result.trim() === '') {
+            return text; // Return original text (spaces) if result is empty
+        }
+        return result.trim();
+    }
+    /**
+     * Recursively convert markdown, handling nested styles
+     */
+    convertRecursive(text, depth = 0) {
+        if (depth > 10)
+            return text; // Prevent infinite recursion
+        // Tokenize the text
+        const tokenizer = new MarkdownTokenizer(text);
+        const tokens = tokenizer.tokenize();
+        // If no tokens found, return the text as-is (with HTML escaping)
+        if (tokens.length === 0) {
+            return this.options.escapeHtml ? escapeTelegramHtml(text) : text;
+        }
+        let result = '';
+        let lastPos = 0;
+        for (const token of tokens) {
+            // Add text before token
+            if (token.start > lastPos) {
+                const textBefore = text.slice(lastPos, token.start);
+                result += this.options.escapeHtml ? escapeTelegramHtml(textBefore) : textBefore;
+            }
+            // Handle code blocks specially (no recursive parsing inside)
+            if (token.type === 'code_block') {
+                const codeContent = this.options.escapeHtml ? escapeHtml(token.content) : token.content;
+                result += this.wrapToken(token.type, codeContent, token.language);
+                lastPos = token.end;
+                continue;
+            }
+            // Handle inline code specially (no recursive parsing inside)
+            if (token.type === 'inline_code') {
+                const codeContent = this.options.escapeHtml ? escapeHtml(token.content) : token.content;
+                result += `<code>${codeContent}</code>`;
+                lastPos = token.end;
+                continue;
+            }
+            // Process other token content recursively
+            const tokenContent = this.convertRecursive(token.content, depth + 1);
+            // Wrap the content in appropriate HTML tags
+            result += this.wrapToken(token.type, tokenContent, token.language);
+            lastPos = token.end;
+        }
+        // Add remaining text
+        if (lastPos < text.length) {
+            const remainingText = text.slice(lastPos);
+            result += this.options.escapeHtml ? escapeTelegramHtml(remainingText) : remainingText;
+        }
+        return result;
+    }
+    /**
+     * Wrap token content in HTML tags
+     */
+    wrapToken(type, content, language) {
+        switch (type) {
+            case 'bold':
+                return `<b>${content}</b>`;
+            case 'italic':
+                return `<i>${content}</i>`;
+            case 'underline':
+                return `<u>${content}</u>`;
+            case 'strikethrough':
+                return `<s>${content}</s>`;
+            case 'spoiler':
+                return `<span class="tg-spoiler">${content}</span>`;
+            case 'inline_code':
+                // Already handled above
+                return `<code>${content}</code>`;
+            case 'code_block':
+                // Already handled above, but handle custom processor
+                if (this.hasCustomCodeBlockProcessor) {
+                    return this.options.codeBlockProcessor(content, language);
+                }
+                const escapedCode = this.options.escapeHtml ? escapeHtml(content) : content;
+                const langAttr = language ? ` class="language-${language}"` : '';
+                return `\n<pre><code${langAttr}>${escapedCode}</code></pre>\n`;
+            case 'link':
+                const url = language || '';
+                if (this.hasCustomLinkProcessor) {
+                    return this.options.linkProcessor(url, content);
+                }
+                const escapedUrl = this.options.escapeHtml ? escapeHtml(url) : url;
+                const escapedText = this.options.escapeHtml ? escapeHtml(content) : content;
+                return `<a href="${escapedUrl}">${escapedText}</a>`;
+            case 'quote':
+                return `\n<blockquote>${content.trim()}</blockquote>\n`;
+            case 'expandable_quote':
+                return `\n<blockquote expandable>${content.trim()}</blockquote>\n`;
+            default:
+                return content;
+        }
+    }
+    /**
+     * Preprocess blockquotes to mark them before other parsing
+     */
+    preprocessBlockquotes(text) {
+        const lines = text.split('\n');
+        const processedLines = [];
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            // Only treat lines starting with > at the beginning of line as blockquotes
+            if (trimmedLine.startsWith('**>')) {
+                // Expandable blockquote
+                const content = trimmedLine.substring(3).trim();
+                processedLines.push(`[EXPANDABLE_QUOTE]${content}`);
+            }
+            else if (trimmedLine.startsWith('>')) {
+                // Regular blockquote
+                const content = trimmedLine.substring(1).trim();
+                processedLines.push(`[QUOTE]${content}`);
+            }
+            else {
+                processedLines.push(line);
+            }
+        }
+        return processedLines.join('\n');
+    }
+    /**
+     * Process blockquote markers
+     */
+    processBlockquoteMarkers(text) {
+        let result = text;
+        // Replace expandable quote markers (process content recursively)
+        const expandableQuoteRegex = /\[EXPANDABLE_QUOTE\](.*?)(?=\n|$)/g;
+        result = result.replace(expandableQuoteRegex, (match, content) => {
+            const processedContent = this.convertRecursive(content);
+            return `\n<blockquote expandable>${processedContent.trim()}</blockquote>\n`;
+        });
+        // Replace regular quote markers (process content recursively)
+        const quoteRegex = /\[QUOTE\](.*?)(?=\n|$)/g;
+        result = result.replace(quoteRegex, (match, content) => {
+            const processedContent = this.convertRecursive(content);
+            return `\n<blockquote>${processedContent.trim()}</blockquote>\n`;
+        });
+        return result;
+    }
+    defaultLinkProcessor(url, text) {
+        const escapedUrl = this.options.escapeHtml ? escapeHtml(url) : url;
+        const escapedText = this.options.escapeHtml ? escapeHtml(text) : text;
+        return `<a href="${escapedUrl}">${escapedText}</a>`;
+    }
+    defaultCodeBlockProcessor(code, language) {
+        const escapedCode = this.options.escapeHtml ? escapeHtml(code) : code;
+        const langAttr = language ? ` class="language-${language}"` : '';
+        return `\n<pre><code${langAttr}>${escapedCode}</code></pre>\n`;
+    }
+}
+
+/**
+ * Convert Telegram-style Markdown to HTML
+ * @param text - Markdown text to convert
+ * @param options - Conversion options
+ * @returns Telegram-compatible HTML
+ */
+function markdownToHtml(text, options) {
+    const converter = new MarkdownConverter(options);
+    return converter.convert(text);
+}
+/**
+ * Create a converter instance with custom options
+ */
+function createConverter(options) {
+    return new MarkdownConverter(options);
+}
+var index = {
+    markdownToHtml,
+    createConverter,
+    MarkdownConverter
+};
+
+export { MarkdownConverter, createConverter, index as default, markdownToHtml };

package/dist/tokenizer.d.ts

@@ -0,0 +1,12 @@
+import { Token } from './types';
+export declare class MarkdownTokenizer {
+    private text;
+    constructor(text: string);
+    /**
+     * Tokenize the markdown text
+     */
+    tokenize(): Token[];
+    private matchToken;
+    private isInsideCodeBlock;
+    private isInsideInlineCode;
+}

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+export interface ConvertOptions {
+    /**
+     * Whether to escape HTML special characters
+     * @default true
+     */
+    escapeHtml?: boolean;
+    /**
+     * Whether to append missing code block delimiters
+     * @default true
+     */
+    autoCloseCodeBlocks?: boolean;
+    /**
+     * Custom replacement function for links
+     */
+    linkProcessor?: (url: string, text: string) => string;
+    /**
+     * Custom replacement function for code blocks
+     */
+    codeBlockProcessor?: (code: string, language?: string) => string;
+}
+export interface Token {
+    type: string;
+    content: string;
+    start: number;
+    end: number;
+    language?: string;
+    children?: [];
+}

package/dist/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Escapes HTML special characters (but not double-escape)
+ */
+export declare function escapeHtml(text: string): string;
+/**
+ * Escapes Telegram HTML special characters
+ */
+export declare function escapeTelegramHtml(text: string): string;
+/**
+ * Checks if a position is inside a code block
+ */
+export declare function isInsideCodeBlock(text: string, position: number): boolean;
+/**
+ * Checks if a position is inside inline code
+ */
+export declare function isInsideInlineCode(text: string, position: number): boolean;
+/**
+ * Checks if a position is inside any code
+ */
+export declare function isInsideCode(text: string, position: number): boolean;
+/**
+ * Appends missing code block delimiters
+ */
+export declare function autoCloseCodeBlocks(text: string): string;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "telegram-md2html",
+  "version": "1.0.0",
+  "description": "A smart converter for Telegram-style Markdown to Telegram-compatible HTML",
+
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+
+  "scripts": {
+  "build": "rollup -c && npm run build:types",
+  "build:types": "cp dist/index.d.ts dist/index.d.mts",
+  "dev": "rollup -c -w",
+  "test": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js",
+  "test:ci": "npm test -- --coverage",
+  "prepublishOnly": "npm run build && npm run test"
+     },
+
+  "keywords": [
+    "telegram",
+    "markdown",
+    "html",
+    "converter",
+    "bot",
+    "messaging"
+  ],
+
+  "author": "Soumyadeep Das <soumyadeepdas765@gmail.com>",
+  "license": "MIT",
+
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.5",
+    "@types/jest": "^29.5.8",
+    "jest": "^29.7.0",
+    "rollup": "^4.9.0",
+    "ts-jest": "^29.1.1",
+    "tslib": "^2.6.2",
+    "typescript": "^5.3.3"
+  },
+
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}