quasar-ui-danx 0.4.95 → 0.5.0

package/src/composables/useTranscodeLoader.ts

@@ -0,0 +1,68 @@
+import { onMounted, Ref, ref, watch } from "vue";
+import { danxOptions } from "../config";
+import { UploadedFile } from "../types";
+
+export interface UseTranscodeLoaderOptions {
+	file: Ref<UploadedFile | null | undefined>;
+}
+
+export interface UseTranscodeLoaderReturn {
+	isLoading: Ref<boolean>;
+	loadTranscodes: () => Promise<void>;
+}
+
+/**
+ * Composable for loading transcodes for a file
+ * Automatically loads transcodes on mount and when the file changes
+ */
+export function useTranscodeLoader(options: UseTranscodeLoaderOptions): UseTranscodeLoaderReturn {
+	const { file } = options;
+	const isLoading = ref(false);
+
+	function shouldLoadTranscodes(): boolean {
+		if (!file.value?.id) return false;
+		if (isLoading.value) return false;
+		if (!danxOptions.value.fileUpload?.refreshFile) return false;
+
+		// Only load if transcodes is explicitly null, undefined, or an empty array
+		const transcodes = file.value.transcodes;
+		return transcodes === null || transcodes === undefined || (Array.isArray(transcodes) && transcodes.length === 0);
+	}
+
+	async function loadTranscodes() {
+		if (!shouldLoadTranscodes()) return;
+
+		isLoading.value = true;
+
+		try {
+			const refreshFile = danxOptions.value.fileUpload?.refreshFile;
+			if (refreshFile && file.value?.id) {
+				const refreshedFile = await refreshFile(file.value.id);
+
+				// Update the file object with the loaded transcodes
+				if (refreshedFile.transcodes && file.value) {
+					file.value.transcodes = refreshedFile.transcodes;
+				}
+			}
+		} catch (error) {
+			console.error("Failed to load transcodes:", error);
+		} finally {
+			isLoading.value = false;
+		}
+	}
+
+	// Load transcodes when component mounts
+	onMounted(() => {
+		loadTranscodes();
+	});
+
+	// Watch for file changes and reload transcodes if needed
+	watch(() => file.value?.id, () => {
+		loadTranscodes();
+	});
+
+	return {
+		isLoading,
+		loadTranscodes
+	};
+}

package/src/helpers/formats/highlightSyntax.ts

@@ -0,0 +1,327 @@
+/**
+ * Lightweight syntax highlighting for JSON and YAML
+ * Returns HTML string with syntax highlighting spans
+ */
+
+export type HighlightFormat = "json" | "yaml" | "text" | "markdown";
+
+export interface HighlightOptions {
+	format: HighlightFormat;
+}
+
+/**
+ * Escape HTML entities to prevent XSS
+ */
+function escapeHtml(text: string): string {
+	return text
+		.replace(/&/g, "&")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&#039;");
+}
+
+/**
+ * Highlight JSON syntax by tokenizing first, then applying highlights
+ * This prevents issues with regex replacing content inside already-matched strings
+ */
+export function highlightJSON(code: string): string {
+	if (!code) return "";
+
+	const result: string[] = [];
+	let i = 0;
+
+	while (i < code.length) {
+		const char = code[i];
+
+		// String (starts with ")
+		if (char === '"') {
+			const startIndex = i;
+			i++; // skip opening quote
+
+			// Find the closing quote, handling escape sequences
+			while (i < code.length) {
+				if (code[i] === '\\' && i + 1 < code.length) {
+					i += 2; // skip escaped character
+				} else if (code[i] === '"') {
+					i++; // include closing quote
+					break;
+				} else {
+					i++;
+				}
+			}
+
+			const str = code.slice(startIndex, i);
+			const escapedStr = escapeHtml(str);
+
+			// Check if this is a key (followed by colon)
+			const afterString = code.slice(i).match(/^(\s*):/);
+			if (afterString) {
+				result.push(`<span class="syntax-key">${escapedStr}</span>`);
+				// Add the whitespace and colon
+				result.push(`<span class="syntax-punctuation">${escapeHtml(afterString[1])}:</span>`);
+				i += afterString[0].length;
+			} else {
+				// It's a string value
+				result.push(`<span class="syntax-string">${escapedStr}</span>`);
+			}
+			continue;
+		}
+
+		// Number (starts with digit or minus followed by digit)
+		if (/[-\d]/.test(char)) {
+			const numMatch = code.slice(i).match(/^-?\d+(\.\d+)?([eE][+-]?\d+)?/);
+			if (numMatch) {
+				result.push(`<span class="syntax-number">${escapeHtml(numMatch[0])}</span>`);
+				i += numMatch[0].length;
+				continue;
+			}
+		}
+
+		// Boolean true
+		if (code.slice(i, i + 4) === 'true') {
+			result.push(`<span class="syntax-boolean">true</span>`);
+			i += 4;
+			continue;
+		}
+
+		// Boolean false
+		if (code.slice(i, i + 5) === 'false') {
+			result.push(`<span class="syntax-boolean">false</span>`);
+			i += 5;
+			continue;
+		}
+
+		// Null
+		if (code.slice(i, i + 4) === 'null') {
+			result.push(`<span class="syntax-null">null</span>`);
+			i += 4;
+			continue;
+		}
+
+		// Punctuation
+		if (/[{}\[\],:]/.test(char)) {
+			result.push(`<span class="syntax-punctuation">${escapeHtml(char)}</span>`);
+			i++;
+			continue;
+		}
+
+		// Whitespace and other characters
+		result.push(escapeHtml(char));
+		i++;
+	}
+
+	return result.join('');
+}
+
+/**
+ * Highlight a YAML value based on its type
+ */
+function highlightYAMLValue(value: string): string {
+	if (!value) return value;
+
+	// Quoted string (complete)
+	if (/^(&quot;.*&quot;|&#039;.*&#039;)$/.test(value) || /^["'].*["']$/.test(value)) {
+		return `<span class="syntax-string">${value}</span>`;
+	}
+	// Number (strict format: integers, decimals, scientific notation)
+	if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(value)) {
+		return `<span class="syntax-number">${value}</span>`;
+	}
+	// Boolean
+	if (/^(true|false)$/i.test(value)) {
+		return `<span class="syntax-boolean">${value}</span>`;
+	}
+	// Null
+	if (/^(null|~)$/i.test(value)) {
+		return `<span class="syntax-null">${value}</span>`;
+	}
+	// Block scalar indicators - don't wrap, handle continuation separately
+	if (/^[|>][-+]?\d*$/.test(value)) {
+		return `<span class="syntax-punctuation">${value}</span>`;
+	}
+	// Unquoted string
+	return `<span class="syntax-string">${value}</span>`;
+}
+
+/**
+ * Check if a line is a continuation of a multi-line string
+ * (indented content following a block scalar or inside a quoted string)
+ */
+function getIndentLevel(line: string): number {
+	const match = line.match(/^(\s*)/);
+	return match ? match[1].length : 0;
+}
+
+/**
+ * Highlight YAML syntax with multi-line string support
+ */
+export function highlightYAML(code: string): string {
+	if (!code) return "";
+
+	const lines = code.split("\n");
+	const highlightedLines: string[] = [];
+
+	// State tracking for multi-line constructs
+	let inBlockScalar = false;
+	let blockScalarIndent = 0;
+	let inQuotedString = false;
+	let quoteChar = "";
+	let inUnquotedMultiline = false;
+	let unquotedMultilineKeyIndent = 0;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const escaped = escapeHtml(line);
+		const currentIndent = getIndentLevel(line);
+		const trimmedLine = line.trim();
+
+		// Handle block scalar continuation (| or > style)
+		if (inBlockScalar) {
+			// Block scalar ends when we hit a line with less or equal indentation (and content)
+			if (trimmedLine && currentIndent <= blockScalarIndent) {
+				inBlockScalar = false;
+				// Fall through to normal processing
+			} else {
+				// This is a continuation line - highlight as string
+				highlightedLines.push(`<span class="syntax-string">${escaped}</span>`);
+				continue;
+			}
+		}
+
+		// Handle quoted string continuation
+		if (inQuotedString) {
+			// Check if this line closes the quote
+			const escapedQuote = quoteChar === '"' ? '&quot;' : '&#039;';
+
+			// Count unescaped quotes in this line
+			let closed = false;
+			let searchLine = escaped;
+			while (searchLine.includes(escapedQuote)) {
+				const idx = searchLine.indexOf(escapedQuote);
+				// Check if preceded by backslash (escaped)
+				if (idx > 0 && searchLine[idx - 1] === '\\') {
+					searchLine = searchLine.slice(idx + escapedQuote.length);
+					continue;
+				}
+				closed = true;
+				break;
+			}
+
+			if (closed) {
+				// Find position of closing quote
+				const closeIdx = escaped.indexOf(escapedQuote);
+				const beforeClose = escaped.slice(0, closeIdx + escapedQuote.length);
+				const afterClose = escaped.slice(closeIdx + escapedQuote.length);
+
+				highlightedLines.push(`<span class="syntax-string">${beforeClose}</span>${afterClose}`);
+				inQuotedString = false;
+			} else {
+				// Still in quoted string
+				highlightedLines.push(`<span class="syntax-string">${escaped}</span>`);
+			}
+			continue;
+		}
+
+		// Handle unquoted multi-line string continuation
+		if (inUnquotedMultiline) {
+			// Unquoted multiline ends when we hit a line with <= indentation to the key
+			// or when the line contains a colon (new key-value pair)
+			if (trimmedLine && currentIndent <= unquotedMultilineKeyIndent) {
+				inUnquotedMultiline = false;
+				// Fall through to normal processing
+			} else if (trimmedLine) {
+				// This is a continuation line - highlight as string
+				highlightedLines.push(`<span class="syntax-string">${escaped}</span>`);
+				continue;
+			} else {
+				// Empty line within multiline - keep it
+				highlightedLines.push(escaped);
+				continue;
+			}
+		}
+
+		// Comments
+		if (/^\s*#/.test(line)) {
+			highlightedLines.push(`<span class="syntax-punctuation">${escaped}</span>`);
+			continue;
+		}
+
+		// Key-value pairs
+		const keyValueMatch = escaped.match(/^(\s*)([^:]+?)(:)(\s*)(.*)$/);
+		if (keyValueMatch) {
+			const [, indent, key, colon, space, value] = keyValueMatch;
+
+			// Check for block scalar start
+			if (/^[|>][-+]?\d*$/.test(value.trim())) {
+				inBlockScalar = true;
+				blockScalarIndent = currentIndent;
+				const highlightedValue = `<span class="syntax-punctuation">${value}</span>`;
+				highlightedLines.push(`${indent}<span class="syntax-key">${key}</span><span class="syntax-punctuation">${colon}</span>${space}${highlightedValue}`);
+				continue;
+			}
+
+			// Check for start of multi-line quoted string
+			const startsWithQuote = /^(&quot;|&#039;|"|')/.test(value);
+			const endsWithQuote = /(&quot;|&#039;|"|')$/.test(value);
+
+			if (startsWithQuote && !endsWithQuote && value.length > 1) {
+				// Multi-line quoted string starts here
+				inQuotedString = true;
+				quoteChar = value.startsWith('&quot;') || value.startsWith('"') ? '"' : "'";
+				highlightedLines.push(`${indent}<span class="syntax-key">${key}</span><span class="syntax-punctuation">${colon}</span>${space}<span class="syntax-string">${value}</span>`);
+				continue;
+			}
+
+			// Check for start of unquoted multi-line string
+			// If value is an unquoted string and next line is more indented, it's a multiline
+			if (value && !startsWithQuote && i + 1 < lines.length) {
+				const nextLine = lines[i + 1];
+				const nextIndent = getIndentLevel(nextLine);
+				const nextTrimmed = nextLine.trim();
+				// Next line must be more indented than current key and not be a new key-value or array item
+				if (nextTrimmed && nextIndent > currentIndent && !nextTrimmed.includes(':') && !nextTrimmed.startsWith('-')) {
+					inUnquotedMultiline = true;
+					unquotedMultilineKeyIndent = currentIndent;
+					highlightedLines.push(`${indent}<span class="syntax-key">${key}</span><span class="syntax-punctuation">${colon}</span>${space}<span class="syntax-string">${value}</span>`);
+					continue;
+				}
+			}
+
+			// Normal single-line value
+			const highlightedValue = highlightYAMLValue(value);
+			highlightedLines.push(`${indent}<span class="syntax-key">${key}</span><span class="syntax-punctuation">${colon}</span>${space}${highlightedValue}`);
+			continue;
+		}
+
+		// Array items (lines starting with -)
+		const arrayMatch = escaped.match(/^(\s*)(-)(\s*)(.*)$/);
+		if (arrayMatch) {
+			const [, indent, dash, space, value] = arrayMatch;
+			const highlightedValue = value ? highlightYAMLValue(value) : "";
+			highlightedLines.push(`${indent}<span class="syntax-punctuation">${dash}</span>${space}${highlightedValue}`);
+			continue;
+		}
+
+		highlightedLines.push(escaped);
+	}
+
+	return highlightedLines.join("\n");
+}
+
+/**
+ * Highlight code based on format
+ */
+export function highlightSyntax(code: string, options: HighlightOptions): string {
+	if (!code) return "";
+
+	switch (options.format) {
+		case "json":
+			return highlightJSON(code);
+		case "yaml":
+			return highlightYAML(code);
+		case "text":
+		default:
+			return escapeHtml(code);
+	}
+}

package/src/helpers/formats/index.ts

@@ -1,4 +1,6 @@
 export * from "./datetime";
+export * from "./highlightSyntax";
 export * from "./numbers";
-export * from "./strings";
 export * from "./parsers";
+export * from "./markdown";
+export * from "./strings";

package/src/helpers/formats/markdown/escapeHtml.ts

@@ -0,0 +1,15 @@
+/**
+ * HTML entity escaping for XSS prevention
+ */
+
+/**
+ * Escape HTML entities to prevent XSS
+ */
+export function escapeHtml(text: string): string {
+	return text
+		.replace(/&/g, "&")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&#039;");
+}

package/src/helpers/formats/markdown/escapeSequences.ts

@@ -0,0 +1,60 @@
+/**
+ * Markdown escape sequence handling
+ * Maps backslash-escaped characters to Unicode placeholders and back
+ * Using Private Use Area characters (U+E000-U+F8FF) to avoid conflicts
+ */
+
+/**
+ * Escape sequences mapping - character to Unicode placeholder
+ */
+export const ESCAPE_MAP: Record<string, string> = {
+	"\\*": "\uE000",
+	"\\_": "\uE001",
+	"\\~": "\uE002",
+	"\\`": "\uE003",
+	"\\[": "\uE004",
+	"\\]": "\uE005",
+	"\\#": "\uE006",
+	"\\&gt;": "\uE007", // Escaped > becomes &gt; after HTML escaping
+	"\\-": "\uE008",
+	"\\+": "\uE009",
+	"\\.": "\uE00A",
+	"\\!": "\uE00B",
+	"\\=": "\uE00C",
+	"\\^": "\uE00D"
+};
+
+/**
+ * Reverse mapping - placeholder back to literal character
+ * Generated from ESCAPE_MAP for DRY compliance
+ */
+export const UNESCAPE_MAP: Record<string, string> = Object.fromEntries(
+	Object.entries(ESCAPE_MAP).map(([escaped, placeholder]) => {
+		// Extract the literal character from the escape sequence
+		// "\\*" -> "*", "\\&gt;" -> "&gt;" (special case for HTML-escaped >)
+		const literal = escaped.startsWith("\\&") ? escaped.slice(1) : escaped.slice(1);
+		return [placeholder, literal];
+	})
+);
+
+/**
+ * Apply escape sequences - convert backslash-escaped characters to placeholders
+ */
+export function applyEscapes(text: string): string {
+	let result = text;
+	for (const [pattern, placeholder] of Object.entries(ESCAPE_MAP)) {
+		result = result.split(pattern).join(placeholder);
+	}
+	return result;
+}
+
+/**
+ * Revert escape sequences - convert placeholders back to literal characters
+ */
+export function revertEscapes(text: string): string {
+	let result = text;
+	for (const [placeholder, literal] of Object.entries(UNESCAPE_MAP)) {
+		result = result.split(placeholder).join(literal);
+	}
+	return result;
+}

package/src/helpers/formats/markdown/index.ts

@@ -0,0 +1,85 @@
+/**
+ * Lightweight markdown to HTML renderer
+ * Zero external dependencies, XSS-safe by default
+ *
+ * Supports:
+ * - Headings (# through ###### and setext-style with === or ---)
+ * - Paragraphs (double newlines)
+ * - Code blocks (```language ... ``` and indented with 4 spaces or tab)
+ * - Blockquotes (> text)
+ * - Unordered lists (-, *, +)
+ * - Ordered lists (1., 2., etc.)
+ * - Task lists (- [ ] unchecked, - [x] checked)
+ * - Definition lists (Term followed by : Definition)
+ * - Tables (| col | col | with alignment support)
+ * - Horizontal rules (---, ***, ___)
+ * - Bold (**text** or __text__)
+ * - Italic (*text* or _text_)
+ * - Bold+Italic (***text***)
+ * - Inline code (`code`)
+ * - Links [text](url)
+ * - Reference-style links ([text][ref], [text][], [ref] with [ref]: url definitions)
+ * - Images ![alt](url)
+ * - Escape sequences (\* \_ \~ etc.)
+ * - Hard line breaks (two trailing spaces)
+ * - Autolinks (<https://...> and <email@...>)
+ * - Strikethrough (~~text~~)
+ * - Highlight (==text==)
+ * - Superscript (X^2^)
+ * - Subscript (H~2~O)
+ * - Footnotes ([^id] with [^id]: content definitions)
+ */
+
+// Re-export types
+export type {
+	MarkdownRenderOptions,
+	LinkReference,
+	FootnoteDefinition,
+	ListItem,
+	BlockToken,
+	TableAlignment,
+	ParseResult
+} from "./types";
+
+// Re-export state management
+export { getFootnotes, resetParserState } from "./state";
+
+// Re-export parsers
+export { parseInline } from "./parseInline";
+export { tokenizeBlocks } from "./tokenize";
+
+// Re-export renderers
+export { renderTokens } from "./render";
+
+// Import for main function
+import type { MarkdownRenderOptions } from "./types";
+import { getFootnotes, resetParserState } from "./state";
+import { tokenizeBlocks } from "./tokenize";
+import { renderTokens } from "./render";
+import { renderFootnotesSection } from "./render/renderFootnotes";
+
+/**
+ * Convert markdown text to HTML
+ */
+export function renderMarkdown(markdown: string, options?: MarkdownRenderOptions): string {
+	if (!markdown) return "";
+
+	const sanitize = options?.sanitize ?? true;
+	const preserveState = options?.preserveState ?? false;
+
+	// Reset state for fresh document parse (unless preserving for nested rendering)
+	if (!preserveState) {
+		resetParserState();
+	}
+
+	const tokens = tokenizeBlocks(markdown);
+	let html = renderTokens(tokens, sanitize);
+
+	// Append footnotes section if any exist (only for top-level rendering)
+	const footnotes = getFootnotes();
+	if (!preserveState && Object.keys(footnotes).length > 0) {
+		html += renderFootnotesSection(footnotes, sanitize);
+	}
+
+	return html;
+}

package/src/helpers/formats/markdown/parseInline.ts

@@ -0,0 +1,124 @@
+/**
+ * Inline markdown element parser
+ * Handles: bold, italic, strikethrough, highlight, superscript, subscript,
+ * links, images, reference-style links, footnotes, autolinks, code
+ */
+
+import { escapeHtml } from "./escapeHtml";
+import { applyEscapes, revertEscapes } from "./escapeSequences";
+import { getLinkRefs, getFootnotes } from "./state";
+
+/**
+ * Parse inline markdown elements within text
+ * Order matters: more specific patterns first
+ */
+export function parseInline(text: string, sanitize: boolean = true): string {
+	if (!text) return "";
+
+	const currentLinkRefs = getLinkRefs();
+	const currentFootnotes = getFootnotes();
+
+	// Escape HTML if sanitizing (before applying markdown)
+	let result = sanitize ? escapeHtml(text) : text;
+
+	// 1. ESCAPE SEQUENCES - Pre-process backslash escapes to placeholders
+	// Must be first so escaped characters aren't treated as markdown
+	result = applyEscapes(result);
+
+	// 2. HARD LINE BREAKS - Two trailing spaces + newline becomes <br />
+	result = result.replace(/ {2,}\n/g, "<br />\n");
+
+	// 3. AUTOLINKS - Must be before regular link parsing
+	// URL autolinks: <https://example.com>
+	result = result.replace(/&lt;(https?:\/\/[^&]+)&gt;/g, '<a href="$1">$1</a>');
+	// Email autolinks: <user@example.com>
+	result = result.replace(/&lt;([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})&gt;/g, '<a href="mailto:$1">$1</a>');
+
+	// 4. FOOTNOTE REFERENCES: [^id]
+	// Must be before regular link/image parsing to avoid conflicts
+	result = result.replace(/\[\^([^\]]+)\]/g, (match, fnId) => {
+		const fn = currentFootnotes[fnId];
+		if (fn) {
+			return `<sup class="footnote-ref"><a href="#fn-${fnId}" id="fnref-${fnId}">[${fn.index}]</a></sup>`;
+		}
+		return match; // Keep original if footnote not defined
+	});
+
+	// 5. IMAGES: ![alt](url) - must be before links
+	result = result.replace(
+		/!\[([^\]]*)\]\(([^)]+)\)/g,
+		'<img src="$2" alt="$1" />'
+	);
+
+	// 6. INLINE LINKS: [text](url)
+	result = result.replace(
+		/\[([^\]]+)\]\(([^)]+)\)/g,
+		'<a href="$2">$1</a>'
+	);
+
+	// 7. REFERENCE-STYLE LINKS - Process after regular links
+	// Full reference: [text][ref-id]
+	result = result.replace(/\[([^\]]+)\]\[([^\]]+)\]/g, (match, text, refId) => {
+		const ref = currentLinkRefs[refId.toLowerCase()];
+		if (ref) {
+			const title = ref.title ? ` title="${escapeHtml(ref.title)}"` : "";
+			return `<a href="${ref.url}"${title}>${text}</a>`;
+		}
+		return match; // Keep original if ref not found
+	});
+
+	// Collapsed reference: [text][]
+	result = result.replace(/\[([^\]]+)\]\[\]/g, (match, text) => {
+		const ref = currentLinkRefs[text.toLowerCase()];
+		if (ref) {
+			const title = ref.title ? ` title="${escapeHtml(ref.title)}"` : "";
+			return `<a href="${ref.url}"${title}>${text}</a>`;
+		}
+		return match;
+	});
+
+	// Shortcut reference: [ref] alone (must not match [text](url) or [text][ref])
+	// Only match [word] not followed by ( or [
+	result = result.replace(/\[([^\]]+)\](?!\(|\[)/g, (match, text) => {
+		const ref = currentLinkRefs[text.toLowerCase()];
+		if (ref) {
+			const title = ref.title ? ` title="${escapeHtml(ref.title)}"` : "";
+			return `<a href="${ref.url}"${title}>${text}</a>`;
+		}
+		return match;
+	});
+
+	// 8. INLINE CODE: `code`
+	result = result.replace(/`([^`]+)`/g, "<code>$1</code>");
+
+	// 9. STRIKETHROUGH: ~~text~~ - Must be before subscript (single tilde)
+	result = result.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+
+	// 10. HIGHLIGHT: ==text==
+	result = result.replace(/==([^=]+)==/g, "<mark>$1</mark>");
+
+	// 11. SUPERSCRIPT: X^2^ - Must be before subscript
+	result = result.replace(/\^([^\^]+)\^/g, "<sup>$1</sup>");
+
+	// 12. SUBSCRIPT: H~2~O - Single tilde, use negative lookbehind/lookahead to avoid ~~
+	result = result.replace(/(?<!~)~([^~]+)~(?!~)/g, "<sub>$1</sub>");
+
+	// 13. BOLD + ITALIC: ***text*** or ___text___
+	result = result.replace(/\*\*\*([^*]+)\*\*\*/g, "<strong><em>$1</em></strong>");
+	result = result.replace(/___([^_]+)___/g, "<strong><em>$1</em></strong>");
+
+	// 14. BOLD: **text** or __text__
+	result = result.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+	result = result.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+
+	// 15. ITALIC: *text* or _text_ (but not inside words for underscores)
+	// For asterisks, match any single asterisk pairs
+	result = result.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+	// For underscores, only match at word boundaries
+	result = result.replace(/(^|[^a-zA-Z0-9])_([^_]+)_([^a-zA-Z0-9]|$)/g, "$1<em>$2</em>$3");
+
+	// LAST: Restore escaped characters from placeholders to literals
+	result = revertEscapes(result);
+
+	return result;
+}