@readme/markdown 11.14.1 → 11.15.0

package/dist/index.d.ts

@@ -6,7 +6,7 @@ declare const utils: {
     getHref: typeof getHref;
     calloutIcons: {};
 };
-export { compile, exports, hast, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, isPlainText, } from './lib';
+export { compile, exports, hast, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
 export { default as Owlmoji } from './lib/owlmoji';
 export { Components, utils };
 export { tailwindCompiler } from './utils/tailwind-compiler';

package/dist/lib/index.d.ts

@@ -17,4 +17,3 @@ export { default as run } from './run';
 export { default as tags } from './tags';
 export { default as mdxishTags } from './mdxishTags';
 export { default as stripComments } from './stripComments';
-export { default as isPlainText } from './utils/isPlainText';

package/dist/main.js

@@ -11362,7 +11362,6 @@ __webpack_require__.d(__webpack_exports__, {
   exports: () => (/* reexport */ lib_exports),
   gemojiRegex: () => (/* reexport */ gemoji_regex),
   hast: () => (/* reexport */ lib_hast),
-  isPlainText: () => (/* reexport */ isPlainText),
   mdast: () => (/* reexport */ lib_mdast),
   mdastV6: () => (/* reexport */ lib_mdastV6),
   mdx: () => (/* reexport */ lib_mdx),
@@ -70621,10 +70620,13 @@ const tagAttributePattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("[^"]*"|'[^'
 const MAX_LOOKAHEAD = 30;
 /**
  * Tags that have dedicated transformers and should NOT be handled by this plugin.
- * These components have special parsing requirements that the generic component
- * block transformer cannot handle correctly.
+ * These components either have special parsing requirements that the generic component
+ * block transformer cannot handle correctly, or are inline components that we don't
+ * want to convert to mdxJsxFlowElement which is a block level element.
+ *
+ * Glossary and Anchor are inline components.
  */
-const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table']);
+const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table', 'Glossary', 'Anchor']);
 const inlineMdProcessor = unified().use(remarkParse);
 const isClosingTag = (value, tag) => value.trim() === `</${tag}>`;
 /**
@@ -94414,6 +94416,92 @@ const normalizeEmphasisAST = () => (tree) => {
 };
 /* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
 
+;// ./processor/transform/mdxish/normalize-table-separator.ts
+/**
+ * Preprocessor to normalize malformed GFM table separator syntax.
+ *
+ * Fixes the common mistake where the alignment colon is placed after the pipe
+ * instead of before the dashes:
+ *
+ * Invalid: `|: ---` or `|:---` (colon after pipe)
+ * Valid:   `| :---` (colon before dashes)
+ *
+ * Also handles right alignment:
+ * Invalid: `| ---:| ` with space before pipe
+ * Valid:   `| ---:|` (no space before closing pipe)
+ *
+ * This runs before remark-parse to ensure the table is recognized as a valid GFM table.
+ */
+/**
+ * Pattern to match a table separator row.
+ * A separator row consists of cells that contain only dashes, colons (for alignment), and spaces.
+ *
+ * Valid GFM separator formats:
+ * - `---` or `----` (no alignment, defaults to left)
+ * - `:---` (left aligned)
+ * - `---:` (right aligned)
+ * - `:---:` (center aligned)
+ *
+ * Invalid formats this fixes:
+ * - `|: ---` → `| :---` (colon wrongly placed after pipe)
+ * - `|:---` → `| :---` (colon directly after pipe, missing space)
+ * - `|::---` or `| ::---` → `| :---` (double colon typo)
+ */
+// Match a line that looks like a table separator row
+// This regex captures the whole line if it contains only pipe-separated cells with dashes/colons
+const TABLE_SEPARATOR_LINE_REGEX = /^(\|[:\s-]+)+\|?\s*$/;
+// Match malformed left-alignment: `|: ` or `|:` followed by dashes
+// Captures: group 1 = pipe, group 2 = spaces after colon, group 3 = dashes
+const MALFORMED_LEFT_ALIGN_REGEX = /\|:(\s*)(-+)/g;
+// Match malformed double colon: `|::---` or `| ::---` → `| :---`
+const MALFORMED_DOUBLE_COLON_REGEX = /\|\s*::(\s*)(-+)/g;
+// Match malformed patterns with spaces before closing colons: `| --- : |` → `| ---: |`
+const MALFORMED_RIGHT_ALIGN_SPACE_REGEX = /(-+)\s+:(\s*\|)/g;
+// Match malformed center alignment with spaces: `| : --- : |` → `| :---: |`
+const MALFORMED_CENTER_ALIGN_REGEX = /\|:(\s+)(-+)(\s+):/g;
+/**
+ * Normalizes a single table separator line.
+ */
+function normalizeTableSeparatorLine(line) {
+    // Check if this line looks like a table separator
+    if (!TABLE_SEPARATOR_LINE_REGEX.test(line)) {
+        return line;
+    }
+    let normalized = line;
+    // Fix `|::---` → `| :---` (double colon typo)
+    // Must run before single colon fix to avoid partial replacement
+    normalized = normalized.replace(MALFORMED_DOUBLE_COLON_REGEX, '| :$2');
+    // Fix `|: ---` or `|:---` → `| :---`
+    // The colon should be adjacent to the dashes, not the pipe
+    normalized = normalized.replace(MALFORMED_LEFT_ALIGN_REGEX, '| :$2');
+    // Fix `| --- : |` → `| ---: |`
+    // Remove space before right-alignment colon
+    normalized = normalized.replace(MALFORMED_RIGHT_ALIGN_SPACE_REGEX, '$1:$2');
+    // Fix `| : --- : |` → `| :---: |`
+    // Remove spaces around center-aligned dashes
+    normalized = normalized.replace(MALFORMED_CENTER_ALIGN_REGEX, '| :$2:');
+    return normalized;
+}
+/**
+ * Preprocesses markdown content to normalize malformed table separator syntax.
+ *
+ * @param content - The raw markdown content
+ * @returns The content with normalized table separators
+ */
+function normalizeTableSeparator(content) {
+    const lines = content.split('\n');
+    const normalizedLines = lines.map((line, index) => {
+        const prevLine = index > 0 ? lines[index - 1] : '';
+        const isPrevLineTableRow = prevLine.trim().startsWith('|');
+        if (isPrevLineTableRow) {
+            return normalizeTableSeparatorLine(line);
+        }
+        return line;
+    });
+    return normalizedLines.join('\n');
+}
+/* harmony default export */ const normalize_table_separator = ((/* unused pure expression or super */ null && (normalizeTableSeparator)));
+
 ;// ./processor/transform/mdxish/restore-snake-case-component-name.ts
 
 
@@ -94677,6 +94765,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [callouts, code_tabs, gemoji_, transform_embeds];
@@ -94689,9 +94778,11 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     // Preprocessing pipeline: Transform content to be parser-ready
     // Step 1: Extract legacy magic blocks
     const { replaced: contentAfterMagicBlocks, blocks } = extractMagicBlocks(mdContent);
-    // Step 2: Evaluate JSX expressions in attributes
-    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterMagicBlocks, jsxContext);
-    // Step 3: Replace snake_case component names with parser-safe placeholders
+    // Step 2: Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
+    const contentAfterTableNormalization = normalizeTableSeparator(contentAfterMagicBlocks);
+    // Step 3: Evaluate JSX expressions in attributes
+    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
+    // Step 4: Replace snake_case component names with parser-safe placeholders
     // (e.g., <Snake_case /> → <MDXishSnakeCase0 /> which will be restored after parsing)
     const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation);
     // Create string map for tailwind transformer
@@ -95295,89 +95386,6 @@ async function stripComments(doc, { mdx } = {}) {
 }
 /* harmony default export */ const lib_stripComments = (stripComments);
 
-;// ./lib/utils/isPlainText.ts
-
-/**
- * Detects if content contains HTML, magic blocks, or MDX syntax.
- *
- * We can use this in some pipelines to determine if we should have to parse content through
- * `.plain() or if it is already plain text and it should be able to detect everything that would
- * be stripped or sanitized by `.plain()`.
- *
- */
-function isPlainText(content) {
-    if (!content || typeof content !== 'string') {
-        return true;
-    }
-    // Exclude markdown code blocks and inline code to avoid false positives
-    // Match code blocks with optional language identifier: ```lang\n...\n```
-    const codeBlockRegex = /```[^\n]*\n[\s\S]*?```/g;
-    // Match inline code: `code` (but not escaped backticks)
-    const inlineCodeRegex = /`[^`\n]+`/g;
-    // Remove code blocks and inline code to avoid false positives
-    let contentWithoutCode = structuredClone(content);
-    contentWithoutCode = contentWithoutCode.replace(codeBlockRegex, '');
-    contentWithoutCode = contentWithoutCode.replace(inlineCodeRegex, '');
-    // Check for magic blocks: `[block:TYPE]...[/block]`
-    // Only check after removing code blocks to avoid detecting magic blocks in code
-    if (contentWithoutCode.match(MAGIC_BLOCK_REGEX) !== null) {
-        return false;
-    }
-    // Check for markdown links: [text](url) or [text][reference]
-    // Pattern matches inline links and reference-style links
-    // Exclude images which start with ! before the bracket
-    // Only check after removing code blocks
-    const markdownLinkPattern = /(?<!!)\[([^\]]+)\]\(([^)]+)\)|(?<!!)\[([^\]]+)\]\[([^\]]*)\]/;
-    if (markdownLinkPattern.test(contentWithoutCode)) {
-        return false;
-    }
-    // Check for JSX elements (PascalCase components) in the original content
-    // This includes code blocks since JSX code examples should be detected
-    // Pattern matches:
-    // - Self-closing: <Component /> or <Component/>
-    // - With attributes: <Component prop="value" />
-    // - With children: <Component>...</Component>
-    // Use simpler, safer patterns to avoid ReDoS from backtracking
-    // Match self-closing tags with bounded attribute length to prevent excessive backtracking
-    const jsxSelfClosingPattern = /<[A-Z][a-zA-Z0-9]*(?:\s[^>]{0,50})?\/>/;
-    if (jsxSelfClosingPattern.test(content)) {
-        return false;
-    }
-    // For components with children, use a safer pattern that limits backtracking
-    // Match opening tag with bounded attributes, then look for closing tag with same name
-    const jsxWithChildrenPattern = /<([A-Z][a-zA-Z0-9]*)(?:\s[^>]{0,50})?>[\s\S]{0,50}<\/\1>/;
-    if (jsxWithChildrenPattern.test(content)) {
-        return false;
-    }
-    // Check for MDX expressions and HTML tags in the original content
-    // HTML/JSX/MDX in code blocks should be detected (as per test requirements)
-    // But exclude inline code that contains magic block patterns to avoid false positives
-    let contentForHtmlMdx = content;
-    // Find inline code blocks and check if they contain [block: pattern
-    // Exclude these from HTML/MDX detection to avoid false positives
-    const inlineCodePattern = /`[^`\n]+`/g;
-    let inlineCodeMatch;
-    inlineCodePattern.lastIndex = 0;
-    while ((inlineCodeMatch = inlineCodePattern.exec(content)) !== null) {
-        if (inlineCodeMatch[0].includes('[block:')) {
-            contentForHtmlMdx = contentForHtmlMdx.replace(inlineCodeMatch[0], '');
-        }
-    }
-    // Match simple MDX variable expressions like {variable}, {user.name}, {getValue()}, {}
-    // Use bounded quantifier to prevent ReDoS - limit to reasonable variable name length
-    // Allow empty braces {} to be detected as well
-    const jsxExpressionPattern = /\{[^}"]{0,50}\}/;
-    if (jsxExpressionPattern.test(contentForHtmlMdx)) {
-        return false;
-    }
-    // Match HTML tags with bounded attribute length to prevent ReDoS
-    const htmlTagPattern = /<[a-z][a-z0-9]*(?:\s[^>]{0,50})?(?:\/>|>)/i;
-    if (htmlTagPattern.test(contentForHtmlMdx)) {
-        return false;
-    }
-    return true;
-}
-
 ;// ./lib/index.ts
 
 
@@ -95396,7 +95404,6 @@ function isPlainText(content) {
 
 
 
-
 ;// ./index.tsx
 
 

package/dist/main.node.js

@@ -19024,7 +19024,6 @@ __webpack_require__.d(__webpack_exports__, {
   exports: () => (/* reexport */ lib_exports),
   gemojiRegex: () => (/* reexport */ gemoji_regex),
   hast: () => (/* reexport */ lib_hast),
-  isPlainText: () => (/* reexport */ isPlainText),
   mdast: () => (/* reexport */ lib_mdast),
   mdastV6: () => (/* reexport */ lib_mdastV6),
   mdx: () => (/* reexport */ lib_mdx),
@@ -90825,10 +90824,13 @@ const tagAttributePattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("[^"]*"|'[^'
 const MAX_LOOKAHEAD = 30;
 /**
  * Tags that have dedicated transformers and should NOT be handled by this plugin.
- * These components have special parsing requirements that the generic component
- * block transformer cannot handle correctly.
+ * These components either have special parsing requirements that the generic component
+ * block transformer cannot handle correctly, or are inline components that we don't
+ * want to convert to mdxJsxFlowElement which is a block level element.
+ *
+ * Glossary and Anchor are inline components.
  */
-const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table']);
+const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table', 'Glossary', 'Anchor']);
 const inlineMdProcessor = unified().use(remarkParse);
 const isClosingTag = (value, tag) => value.trim() === `</${tag}>`;
 /**
@@ -114618,6 +114620,92 @@ const normalizeEmphasisAST = () => (tree) => {
 };
 /* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
 
+;// ./processor/transform/mdxish/normalize-table-separator.ts
+/**
+ * Preprocessor to normalize malformed GFM table separator syntax.
+ *
+ * Fixes the common mistake where the alignment colon is placed after the pipe
+ * instead of before the dashes:
+ *
+ * Invalid: `|: ---` or `|:---` (colon after pipe)
+ * Valid:   `| :---` (colon before dashes)
+ *
+ * Also handles right alignment:
+ * Invalid: `| ---:| ` with space before pipe
+ * Valid:   `| ---:|` (no space before closing pipe)
+ *
+ * This runs before remark-parse to ensure the table is recognized as a valid GFM table.
+ */
+/**
+ * Pattern to match a table separator row.
+ * A separator row consists of cells that contain only dashes, colons (for alignment), and spaces.
+ *
+ * Valid GFM separator formats:
+ * - `---` or `----` (no alignment, defaults to left)
+ * - `:---` (left aligned)
+ * - `---:` (right aligned)
+ * - `:---:` (center aligned)
+ *
+ * Invalid formats this fixes:
+ * - `|: ---` → `| :---` (colon wrongly placed after pipe)
+ * - `|:---` → `| :---` (colon directly after pipe, missing space)
+ * - `|::---` or `| ::---` → `| :---` (double colon typo)
+ */
+// Match a line that looks like a table separator row
+// This regex captures the whole line if it contains only pipe-separated cells with dashes/colons
+const TABLE_SEPARATOR_LINE_REGEX = /^(\|[:\s-]+)+\|?\s*$/;
+// Match malformed left-alignment: `|: ` or `|:` followed by dashes
+// Captures: group 1 = pipe, group 2 = spaces after colon, group 3 = dashes
+const MALFORMED_LEFT_ALIGN_REGEX = /\|:(\s*)(-+)/g;
+// Match malformed double colon: `|::---` or `| ::---` → `| :---`
+const MALFORMED_DOUBLE_COLON_REGEX = /\|\s*::(\s*)(-+)/g;
+// Match malformed patterns with spaces before closing colons: `| --- : |` → `| ---: |`
+const MALFORMED_RIGHT_ALIGN_SPACE_REGEX = /(-+)\s+:(\s*\|)/g;
+// Match malformed center alignment with spaces: `| : --- : |` → `| :---: |`
+const MALFORMED_CENTER_ALIGN_REGEX = /\|:(\s+)(-+)(\s+):/g;
+/**
+ * Normalizes a single table separator line.
+ */
+function normalizeTableSeparatorLine(line) {
+    // Check if this line looks like a table separator
+    if (!TABLE_SEPARATOR_LINE_REGEX.test(line)) {
+        return line;
+    }
+    let normalized = line;
+    // Fix `|::---` → `| :---` (double colon typo)
+    // Must run before single colon fix to avoid partial replacement
+    normalized = normalized.replace(MALFORMED_DOUBLE_COLON_REGEX, '| :$2');
+    // Fix `|: ---` or `|:---` → `| :---`
+    // The colon should be adjacent to the dashes, not the pipe
+    normalized = normalized.replace(MALFORMED_LEFT_ALIGN_REGEX, '| :$2');
+    // Fix `| --- : |` → `| ---: |`
+    // Remove space before right-alignment colon
+    normalized = normalized.replace(MALFORMED_RIGHT_ALIGN_SPACE_REGEX, '$1:$2');
+    // Fix `| : --- : |` → `| :---: |`
+    // Remove spaces around center-aligned dashes
+    normalized = normalized.replace(MALFORMED_CENTER_ALIGN_REGEX, '| :$2:');
+    return normalized;
+}
+/**
+ * Preprocesses markdown content to normalize malformed table separator syntax.
+ *
+ * @param content - The raw markdown content
+ * @returns The content with normalized table separators
+ */
+function normalizeTableSeparator(content) {
+    const lines = content.split('\n');
+    const normalizedLines = lines.map((line, index) => {
+        const prevLine = index > 0 ? lines[index - 1] : '';
+        const isPrevLineTableRow = prevLine.trim().startsWith('|');
+        if (isPrevLineTableRow) {
+            return normalizeTableSeparatorLine(line);
+        }
+        return line;
+    });
+    return normalizedLines.join('\n');
+}
+/* harmony default export */ const normalize_table_separator = ((/* unused pure expression or super */ null && (normalizeTableSeparator)));
+
 ;// ./processor/transform/mdxish/restore-snake-case-component-name.ts
 
 
@@ -114881,6 +114969,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [callouts, code_tabs, gemoji_, transform_embeds];
@@ -114893,9 +114982,11 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     // Preprocessing pipeline: Transform content to be parser-ready
     // Step 1: Extract legacy magic blocks
     const { replaced: contentAfterMagicBlocks, blocks } = extractMagicBlocks(mdContent);
-    // Step 2: Evaluate JSX expressions in attributes
-    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterMagicBlocks, jsxContext);
-    // Step 3: Replace snake_case component names with parser-safe placeholders
+    // Step 2: Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
+    const contentAfterTableNormalization = normalizeTableSeparator(contentAfterMagicBlocks);
+    // Step 3: Evaluate JSX expressions in attributes
+    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
+    // Step 4: Replace snake_case component names with parser-safe placeholders
     // (e.g., <Snake_case /> → <MDXishSnakeCase0 /> which will be restored after parsing)
     const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation);
     // Create string map for tailwind transformer
@@ -115499,89 +115590,6 @@ async function stripComments(doc, { mdx } = {}) {
 }
 /* harmony default export */ const lib_stripComments = (stripComments);
 
-;// ./lib/utils/isPlainText.ts
-
-/**
- * Detects if content contains HTML, magic blocks, or MDX syntax.
- *
- * We can use this in some pipelines to determine if we should have to parse content through
- * `.plain() or if it is already plain text and it should be able to detect everything that would
- * be stripped or sanitized by `.plain()`.
- *
- */
-function isPlainText(content) {
-    if (!content || typeof content !== 'string') {
-        return true;
-    }
-    // Exclude markdown code blocks and inline code to avoid false positives
-    // Match code blocks with optional language identifier: ```lang\n...\n```
-    const codeBlockRegex = /```[^\n]*\n[\s\S]*?```/g;
-    // Match inline code: `code` (but not escaped backticks)
-    const inlineCodeRegex = /`[^`\n]+`/g;
-    // Remove code blocks and inline code to avoid false positives
-    let contentWithoutCode = structuredClone(content);
-    contentWithoutCode = contentWithoutCode.replace(codeBlockRegex, '');
-    contentWithoutCode = contentWithoutCode.replace(inlineCodeRegex, '');
-    // Check for magic blocks: `[block:TYPE]...[/block]`
-    // Only check after removing code blocks to avoid detecting magic blocks in code
-    if (contentWithoutCode.match(MAGIC_BLOCK_REGEX) !== null) {
-        return false;
-    }
-    // Check for markdown links: [text](url) or [text][reference]
-    // Pattern matches inline links and reference-style links
-    // Exclude images which start with ! before the bracket
-    // Only check after removing code blocks
-    const markdownLinkPattern = /(?<!!)\[([^\]]+)\]\(([^)]+)\)|(?<!!)\[([^\]]+)\]\[([^\]]*)\]/;
-    if (markdownLinkPattern.test(contentWithoutCode)) {
-        return false;
-    }
-    // Check for JSX elements (PascalCase components) in the original content
-    // This includes code blocks since JSX code examples should be detected
-    // Pattern matches:
-    // - Self-closing: <Component /> or <Component/>
-    // - With attributes: <Component prop="value" />
-    // - With children: <Component>...</Component>
-    // Use simpler, safer patterns to avoid ReDoS from backtracking
-    // Match self-closing tags with bounded attribute length to prevent excessive backtracking
-    const jsxSelfClosingPattern = /<[A-Z][a-zA-Z0-9]*(?:\s[^>]{0,50})?\/>/;
-    if (jsxSelfClosingPattern.test(content)) {
-        return false;
-    }
-    // For components with children, use a safer pattern that limits backtracking
-    // Match opening tag with bounded attributes, then look for closing tag with same name
-    const jsxWithChildrenPattern = /<([A-Z][a-zA-Z0-9]*)(?:\s[^>]{0,50})?>[\s\S]{0,50}<\/\1>/;
-    if (jsxWithChildrenPattern.test(content)) {
-        return false;
-    }
-    // Check for MDX expressions and HTML tags in the original content
-    // HTML/JSX/MDX in code blocks should be detected (as per test requirements)
-    // But exclude inline code that contains magic block patterns to avoid false positives
-    let contentForHtmlMdx = content;
-    // Find inline code blocks and check if they contain [block: pattern
-    // Exclude these from HTML/MDX detection to avoid false positives
-    const inlineCodePattern = /`[^`\n]+`/g;
-    let inlineCodeMatch;
-    inlineCodePattern.lastIndex = 0;
-    while ((inlineCodeMatch = inlineCodePattern.exec(content)) !== null) {
-        if (inlineCodeMatch[0].includes('[block:')) {
-            contentForHtmlMdx = contentForHtmlMdx.replace(inlineCodeMatch[0], '');
-        }
-    }
-    // Match simple MDX variable expressions like {variable}, {user.name}, {getValue()}, {}
-    // Use bounded quantifier to prevent ReDoS - limit to reasonable variable name length
-    // Allow empty braces {} to be detected as well
-    const jsxExpressionPattern = /\{[^}"]{0,50}\}/;
-    if (jsxExpressionPattern.test(contentForHtmlMdx)) {
-        return false;
-    }
-    // Match HTML tags with bounded attribute length to prevent ReDoS
-    const htmlTagPattern = /<[a-z][a-z0-9]*(?:\s[^>]{0,50})?(?:\/>|>)/i;
-    if (htmlTagPattern.test(contentForHtmlMdx)) {
-        return false;
-    }
-    return true;
-}
-
 ;// ./lib/index.ts
 
 
@@ -115600,7 +115608,6 @@ function isPlainText(content) {
 
 
 
-
 ;// ./index.tsx