telegram-md2html 1.0.1 → 1.0.3

package/dist/converter.d.ts

@@ -3,26 +3,12 @@ export declare class MarkdownConverter {
     private options;
     private hasCustomLinkProcessor;
     private hasCustomCodeBlockProcessor;
+    private headingSymbol;
     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

@@ -6,20 +6,15 @@ 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);
@@ -34,11 +29,22 @@ class MarkdownTokenizer {
     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
+        // Match headings (###, ##)
+        const headingMatch = remaining.match(/^(#{1,3})\s+(.+?)(?=\n|$)/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const content = headingMatch[2];
+            return {
+                type: `heading_${level}`,
+                content: content,
+                start: start,
+                end: start + headingMatch[0].length
+            };
+        }
+        // Match code block (triple backticks)
         const codeBlockMatch = remaining.match(/^```(\w+)?\n([\s\S]*?)```/);
         if (codeBlockMatch) {
             return {
@@ -99,13 +105,22 @@ class MarkdownTokenizer {
                 end: start + underlineMatch[0].length
             };
         }
-        // Match italic with asterisk
-        const italicAsteriskMatch = remaining.match(/^\*([^*\n][^*]*?)\*/);
+        // FIXED: Match italic with asterisk - require space before and after
+        const italicAsteriskMatch = remaining.match(/^\*([^*\s][^*]*?[^*\s])\*/);
         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;
             }
+            // Check if preceded by alphanumeric or underscore (prevents matching words like *italic* inside words)
+            if (start > 0 && /[a-zA-Z0-9_]/.test(text[start - 1])) {
+                return null;
+            }
+            // Check if followed by alphanumeric or underscore
+            const afterMatch = start + italicAsteriskMatch[0].length;
+            if (afterMatch < text.length && /[a-zA-Z0-9_]/.test(text[afterMatch])) {
+                return null;
+            }
             return {
                 type: 'italic',
                 content: italicAsteriskMatch[1],
@@ -113,13 +128,25 @@ class MarkdownTokenizer {
                 end: start + italicAsteriskMatch[0].length
             };
         }
-        // Match italic with underscore
-        const italicUnderscoreMatch = remaining.match(/^_([^_\n]+?)_/);
+        // FIXED: Match italic with underscore - require word boundaries and not part of username
+        const italicUnderscoreMatch = remaining.match(/^_([^_\s][^_]*?[^_\s])_/);
         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;
             }
+            // FIXED: Don't match if preceded by @ (username) or alphanumeric
+            if (start > 0) {
+                const prevChar = text[start - 1];
+                if (prevChar === '@' || /[a-zA-Z0-9]/.test(prevChar)) {
+                    return null;
+                }
+            }
+            // Don't match if followed by alphanumeric (part of word)
+            const afterMatch = start + italicUnderscoreMatch[0].length;
+            if (afterMatch < text.length && /[a-zA-Z0-9]/.test(text[afterMatch])) {
+                return null;
+            }
             return {
                 type: 'italic',
                 content: italicUnderscoreMatch[1],
@@ -141,12 +168,10 @@ class MarkdownTokenizer {
         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;
                 }
@@ -156,12 +181,10 @@ class MarkdownTokenizer {
         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;
                 }
@@ -216,84 +239,77 @@ class MarkdownConverter {
     constructor(options = {}) {
         this.hasCustomLinkProcessor = !!options.linkProcessor;
         this.hasCustomCodeBlockProcessor = !!options.codeBlockProcessor;
+        // Fixed: Add heading symbol option (default: '▎')
+        this.headingSymbol = options.headingSymbol ?? '▎';
         this.options = {
             escapeHtml: options.escapeHtml ?? true,
             autoCloseCodeBlocks: options.autoCloseCodeBlocks ?? true,
+            headingSymbol: options.headingSymbol ?? '▎',
+            headingBlank: options.headingBlank ?? false,
             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 text;
         }
         return result.trim();
     }
-    /**
-     * Recursively convert markdown, handling nested styles
-     */
     convertRecursive(text, depth = 0) {
         if (depth > 10)
-            return text; // Prevent infinite recursion
-        // Tokenize the text
+            return 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)
+            // Fixed: Handle headings
+            if (token.type === 'heading_2' || token.type === 'heading_3') {
+                token.type === 'heading_2' ? '##' : '###';
+                const processedContent = this.convertRecursive(token.content, depth + 1);
+                // Fixed: Add symbol and bold styling
+                const symbol = this.options.headingBlank ? '' : this.headingSymbol;
+                const headingText = symbol ? `${symbol} ${processedContent}` : processedContent;
+                result += `<b>${headingText}</b>`;
+                lastPos = token.end;
+                continue;
+            }
             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':
@@ -307,16 +323,14 @@ class MarkdownConverter {
             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`;
+                return `<pre><code${langAttr}>${escapedCode}</code></pre>`;
             case 'link':
                 const url = language || '';
                 if (this.hasCustomLinkProcessor) {
@@ -326,29 +340,23 @@ class MarkdownConverter {
                 const escapedText = this.options.escapeHtml ? escapeHtml(content) : content;
                 return `<a href="${escapedUrl}">${escapedText}</a>`;
             case 'quote':
-                return `\n<blockquote>${content.trim()}</blockquote>\n`;
+                return `<blockquote>${content.trim()}</blockquote>`;
             case 'expandable_quote':
-                return `\n<blockquote expandable>${content.trim()}</blockquote>\n`;
+                return `<blockquote expandable>${content.trim()}</blockquote>`;
             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}`);
             }
@@ -358,22 +366,17 @@ class MarkdownConverter {
         }
         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`;
+            return `<blockquote expandable>${processedContent.trim()}</blockquote>`;
         });
-        // 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 `<blockquote>${processedContent.trim()}</blockquote>`;
         });
         return result;
     }
@@ -385,7 +388,7 @@ class MarkdownConverter {
     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`;
+        return `<pre><code${langAttr}>${escapedCode}</code></pre>`;
     }
 }
 

package/dist/index.esm.js

@@ -2,20 +2,15 @@ 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);
@@ -30,11 +25,22 @@ class MarkdownTokenizer {
     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
+        // Match headings (###, ##)
+        const headingMatch = remaining.match(/^(#{1,3})\s+(.+?)(?=\n|$)/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const content = headingMatch[2];
+            return {
+                type: `heading_${level}`,
+                content: content,
+                start: start,
+                end: start + headingMatch[0].length
+            };
+        }
+        // Match code block (triple backticks)
         const codeBlockMatch = remaining.match(/^```(\w+)?\n([\s\S]*?)```/);
         if (codeBlockMatch) {
             return {
@@ -95,13 +101,22 @@ class MarkdownTokenizer {
                 end: start + underlineMatch[0].length
             };
         }
-        // Match italic with asterisk
-        const italicAsteriskMatch = remaining.match(/^\*([^*\n][^*]*?)\*/);
+        // FIXED: Match italic with asterisk - require space before and after
+        const italicAsteriskMatch = remaining.match(/^\*([^*\s][^*]*?[^*\s])\*/);
         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;
             }
+            // Check if preceded by alphanumeric or underscore (prevents matching words like *italic* inside words)
+            if (start > 0 && /[a-zA-Z0-9_]/.test(text[start - 1])) {
+                return null;
+            }
+            // Check if followed by alphanumeric or underscore
+            const afterMatch = start + italicAsteriskMatch[0].length;
+            if (afterMatch < text.length && /[a-zA-Z0-9_]/.test(text[afterMatch])) {
+                return null;
+            }
             return {
                 type: 'italic',
                 content: italicAsteriskMatch[1],
@@ -109,13 +124,25 @@ class MarkdownTokenizer {
                 end: start + italicAsteriskMatch[0].length
             };
         }
-        // Match italic with underscore
-        const italicUnderscoreMatch = remaining.match(/^_([^_\n]+?)_/);
+        // FIXED: Match italic with underscore - require word boundaries and not part of username
+        const italicUnderscoreMatch = remaining.match(/^_([^_\s][^_]*?[^_\s])_/);
         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;
             }
+            // FIXED: Don't match if preceded by @ (username) or alphanumeric
+            if (start > 0) {
+                const prevChar = text[start - 1];
+                if (prevChar === '@' || /[a-zA-Z0-9]/.test(prevChar)) {
+                    return null;
+                }
+            }
+            // Don't match if followed by alphanumeric (part of word)
+            const afterMatch = start + italicUnderscoreMatch[0].length;
+            if (afterMatch < text.length && /[a-zA-Z0-9]/.test(text[afterMatch])) {
+                return null;
+            }
             return {
                 type: 'italic',
                 content: italicUnderscoreMatch[1],
@@ -137,12 +164,10 @@ class MarkdownTokenizer {
         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;
                 }
@@ -152,12 +177,10 @@ class MarkdownTokenizer {
         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;
                 }
@@ -212,84 +235,77 @@ class MarkdownConverter {
     constructor(options = {}) {
         this.hasCustomLinkProcessor = !!options.linkProcessor;
         this.hasCustomCodeBlockProcessor = !!options.codeBlockProcessor;
+        // Fixed: Add heading symbol option (default: '▎')
+        this.headingSymbol = options.headingSymbol ?? '▎';
         this.options = {
             escapeHtml: options.escapeHtml ?? true,
             autoCloseCodeBlocks: options.autoCloseCodeBlocks ?? true,
+            headingSymbol: options.headingSymbol ?? '▎',
+            headingBlank: options.headingBlank ?? false,
             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 text;
         }
         return result.trim();
     }
-    /**
-     * Recursively convert markdown, handling nested styles
-     */
     convertRecursive(text, depth = 0) {
         if (depth > 10)
-            return text; // Prevent infinite recursion
-        // Tokenize the text
+            return 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)
+            // Fixed: Handle headings
+            if (token.type === 'heading_2' || token.type === 'heading_3') {
+                token.type === 'heading_2' ? '##' : '###';
+                const processedContent = this.convertRecursive(token.content, depth + 1);
+                // Fixed: Add symbol and bold styling
+                const symbol = this.options.headingBlank ? '' : this.headingSymbol;
+                const headingText = symbol ? `${symbol} ${processedContent}` : processedContent;
+                result += `<b>${headingText}</b>`;
+                lastPos = token.end;
+                continue;
+            }
             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':
@@ -303,16 +319,14 @@ class MarkdownConverter {
             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`;
+                return `<pre><code${langAttr}>${escapedCode}</code></pre>`;
             case 'link':
                 const url = language || '';
                 if (this.hasCustomLinkProcessor) {
@@ -322,29 +336,23 @@ class MarkdownConverter {
                 const escapedText = this.options.escapeHtml ? escapeHtml(content) : content;
                 return `<a href="${escapedUrl}">${escapedText}</a>`;
             case 'quote':
-                return `\n<blockquote>${content.trim()}</blockquote>\n`;
+                return `<blockquote>${content.trim()}</blockquote>`;
             case 'expandable_quote':
-                return `\n<blockquote expandable>${content.trim()}</blockquote>\n`;
+                return `<blockquote expandable>${content.trim()}</blockquote>`;
             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}`);
             }
@@ -354,22 +362,17 @@ class MarkdownConverter {
         }
         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`;
+            return `<blockquote expandable>${processedContent.trim()}</blockquote>`;
         });
-        // 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 `<blockquote>${processedContent.trim()}</blockquote>`;
         });
         return result;
     }
@@ -381,7 +384,7 @@ class MarkdownConverter {
     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`;
+        return `<pre><code${langAttr}>${escapedCode}</code></pre>`;
     }
 }