comark 0.3.1 → 0.3.2

package/dist/devtools/index.d.ts

@@ -0,0 +1 @@
+export * from '../../src/devtools/index'

package/dist/devtools/index.js

@@ -0,0 +1 @@
+export * from '../../src/devtools/index.ts'

package/dist/devtools/register.d.ts

@@ -0,0 +1 @@
+export * from '../../src/devtools/register'

package/dist/devtools/register.js

@@ -0,0 +1 @@
+export * from '../../src/devtools/register.ts'

package/dist/devtools/registry.d.ts

@@ -0,0 +1 @@
+export * from '../../src/devtools/registry'

package/dist/devtools/registry.js

@@ -0,0 +1 @@
+export * from '../../src/devtools/registry.ts'

package/dist/devtools/vite.d.ts

@@ -0,0 +1 @@
+export * from '../../src/devtools/vite'

package/dist/devtools/vite.js

@@ -0,0 +1 @@
+export * from '../../src/devtools/vite.ts'

package/dist/internal/frontmatter.d.ts

@@ -7,6 +7,7 @@ import type { DumpOptions } from 'js-yaml';
 export declare function parseFrontmatter(content: string): {
     content: string;
     data: Record<string, any>;
+    frontmatterText: string;
 };
 /**
  * Render frontmatter to content

package/dist/internal/frontmatter.js

@@ -9,11 +9,12 @@ const CR = '\r';
  */
 export function parseFrontmatter(content) {
     let data = {};
+    let frontmatter = '';
     if (content.startsWith(FRONTMATTER_DELIMITER_DEFAULT)) {
         const idx = content.indexOf(LF + FRONTMATTER_DELIMITER_DEFAULT);
         if (idx !== -1) {
             const hasCarriageReturn = content[idx - 1] === CR;
-            const frontmatter = content.slice(4, idx - (hasCarriageReturn ? 1 : 0));
+            frontmatter = content.slice(4, idx - (hasCarriageReturn ? 1 : 0));
             if (frontmatter) {
                 data = parseYaml(frontmatter);
                 content = content.slice(idx + 4 + (hasCarriageReturn ? 1 : 0));
@@ -23,6 +24,7 @@ export function parseFrontmatter(content) {
     return {
         content,
         data,
+        frontmatterText: frontmatter,
     };
 }
 /**
@@ -33,7 +35,7 @@ export function parseFrontmatter(content) {
  */
 export function renderFrontmatter(data, content, yamlOptions) {
     if (!data || Object.keys(data).length === 0) {
-        return (content?.trim() || '');
+        return content?.trim() || '';
     }
     const fm = stringifyYaml(data, yamlOptions).trim();
     if (content) {

package/dist/internal/parse/auto-close/index.js

@@ -77,11 +77,22 @@ export function autoCloseMarkdown(markdown) {
                     let nameEnd = colonCount;
                     while (nameEnd < trimmed.length) {
                         const c = trimmed[nameEnd];
-                        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '$' || c === '.' || c === '-' || c === '_'))
+                        if (!((c >= 'a' && c <= 'z') ||
+                            (c >= 'A' && c <= 'Z') ||
+                            (c >= '0' && c <= '9') ||
+                            c === '$' ||
+                            c === '.' ||
+                            c === '-' ||
+                            c === '_'))
                             break;
                         nameEnd++;
                     }
-                    componentStack.push({ depth: colonCount, name: trimmed.slice(colonCount, nameEnd), indent, hasYamlProps: false });
+                    componentStack.push({
+                        depth: colonCount,
+                        name: trimmed.slice(colonCount, nameEnd),
+                        indent,
+                        hasYamlProps: false,
+                    });
                 }
                 else if (colonCount === trimmed.length && componentStack.length > 0) {
                     const top = componentStack[componentStack.length - 1];
@@ -136,14 +147,14 @@ export function autoCloseMarkdown(markdown) {
             for (let i = 0; i < propsContent.length; i++) {
                 if (propsContent[i] === '"')
                     dq++;
-                if (propsContent[i] === '\'')
+                if (propsContent[i] === "'")
                     sq++;
             }
             let braceClose = '';
             if (dq % 2 === 1)
                 braceClose += '"';
             if (sq % 2 === 1)
-                braceClose += '\'';
+                braceClose += "'";
             result += braceClose + '}';
         }
         if (componentStack.length > 0) {
@@ -299,8 +310,11 @@ function closeInlineMarkersLinear(line) {
             // Check if line starts with more than 3 asterisks (e.g., ****)
             if (!(line[3] === '*')) {
                 // Check if marker at end with no content
-                if (!(contentEnd >= 3 && line[contentEnd - 1] === '*' && line[contentEnd - 2] === '*'
-                    && line[contentEnd - 3] === '*' && (contentEnd === 3 || line[contentEnd - 4] === ' '))) {
+                if (!(contentEnd >= 3 &&
+                    line[contentEnd - 1] === '*' &&
+                    line[contentEnd - 2] === '*' &&
+                    line[contentEnd - 3] === '*' &&
+                    (contentEnd === 3 || line[contentEnd - 4] === ' '))) {
                     closingSuffix = '***';
                 }
             }
@@ -333,9 +347,9 @@ function closeInlineMarkersLinear(line) {
                         if (!allPaired) {
                             // Check if line ends with word (not just a closing marker)
                             const lastChar = line[contentEnd - 1];
-                            const endsWithWord = (lastChar >= 'a' && lastChar <= 'z')
-                                || (lastChar >= 'A' && lastChar <= 'Z')
-                                || (lastChar >= '0' && lastChar <= '9');
+                            const endsWithWord = (lastChar >= 'a' && lastChar <= 'z') ||
+                                (lastChar >= 'A' && lastChar <= 'Z') ||
+                                (lastChar >= '0' && lastChar <= '9');
                             if (!hasCompleteBoldPair || endsWithWord) {
                                 closingSuffix = '**';
                                 if (hasTrailingSpace && !endsWithMarker) {
@@ -375,8 +389,7 @@ function closeInlineMarkersLinear(line) {
                 // Check marker at end with no content
                 // Only skip if it's truly isolated (e.g., "input *")
                 // Don't skip if there are complete pairs before it (e.g., "input **bold** *")
-                const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '*'
-                    && (contentEnd === 1 || line[contentEnd - 2] === ' ');
+                const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '*' && (contentEnd === 1 || line[contentEnd - 2] === ' ');
                 if (!markerAtEnd || asteriskCount > 1) {
                     closingSuffix = '*';
                     const endsWithMarker = line[contentEnd - 1] === '*';
@@ -427,8 +440,7 @@ function closeInlineMarkersLinear(line) {
         }
         if (validItalic) {
             // Check marker at end with no content
-            const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '_'
-                && (contentEnd === 1 || line[contentEnd - 2] === ' ');
+            const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '_' && (contentEnd === 1 || line[contentEnd - 2] === ' ');
             if (!markerAtEnd) {
                 closingSuffix = '_';
                 const endsWithMarker = line[contentEnd - 1] === '_';

package/dist/internal/parse/auto-close/table.js

@@ -87,12 +87,10 @@ export function closeTables(markdown) {
     const generateSeparator = () => '| ' + Array(columnCount).fill('---').join(' | ') + ' |';
     // Check if separator exists (including incomplete ones with just :)
     const secondLine = end - start >= 1 ? lines[start + 1].trim() : '';
-    const hasSeparator = secondLine.startsWith('|')
-        && (secondLine.includes('-') || secondLine.includes(':'));
+    const hasSeparator = secondLine.startsWith('|') && (secondLine.includes('-') || secondLine.includes(':'));
     // Handle last line
     const lastLine = lines[end].trim();
-    const isSeparator = lastLine.startsWith('|')
-        && (lastLine.includes('-') || lastLine.includes(':'));
+    const isSeparator = lastLine.startsWith('|') && (lastLine.includes('-') || lastLine.includes(':'));
     if (isSeparator) {
         // Parse and complete separator cells
         const sepCells = parseCells(lastLine);
@@ -147,11 +145,16 @@ export function closeTables(markdown) {
         const refWidths = parseCellWidths(refRow);
         const cells = parseCells(lastLine);
         // Rebuild with padding
-        lines[end] = '| ' + cells.map((cell, i) => {
-            const targetWidth = refWidths[i] || cell.length + 2;
-            const padding = ' '.repeat(Math.max(0, targetWidth - cell.length - 2));
-            return cell + padding;
-        }).join(' | ') + ' |';
+        lines[end] =
+            '| ' +
+                cells
+                    .map((cell, i) => {
+                    const targetWidth = refWidths[i] || cell.length + 2;
+                    const padding = ' '.repeat(Math.max(0, targetWidth - cell.length - 2));
+                    return cell + padding;
+                })
+                    .join(' | ') +
+                ' |';
     }
     // Add separator if missing
     if (!hasSeparator) {

package/dist/internal/parse/auto-unwrap.js

@@ -28,15 +28,7 @@ export function applyAutoUnwrap(node) {
     }
     // Check if we have exactly one paragraph child (and possibly empty text nodes)
     if (nonEmptyChildren.length > 1 || typeof nonEmptyChildren[0] === 'string' || nonEmptyChildren[0][0] !== 'p') {
-        return [
-            tag,
-            props,
-            ...children.map((child) => applyAutoUnwrap(child)),
-        ];
+        return [tag, props, ...children.map((child) => applyAutoUnwrap(child))];
     }
-    return [
-        tag,
-        props,
-        ...nonEmptyChildren[0].slice(2),
-    ];
+    return [tag, props, ...nonEmptyChildren[0].slice(2)];
 }

package/dist/internal/parse/html/html_block_rule.js

@@ -20,7 +20,7 @@ export default function html_block(state, startLine, endLine, silent) {
     // if it's indented more than 3 spaces, it should be a code block
     if (state.sCount[startLine] - state.blkIndent >= 4)
         return false;
-    if (state.src.charCodeAt(pos) !== 0x3C /* < */)
+    if (state.src.charCodeAt(pos) !== 0x3c /* < */)
         return false;
     let lineText = state.src.slice(pos, max);
     let i = 0;

package/dist/internal/parse/html/html_inline_rule.js

@@ -9,22 +9,18 @@ function isLinkClose(str) {
 function isLetter(ch) {
     /* eslint no-bitwise:0 */
     const lc = ch | 0x20; // to lower case
-    return (lc >= 0x61 /* a */) && (lc <= 0x7A /* z */);
+    return lc >= 0x61 /* a */ && lc <= 0x7a; /* z */
 }
 export default function html_inline(state, silent) {
     // Check start
     const max = state.posMax;
     const pos = state.pos;
-    if (state.src.charCodeAt(pos) !== 0x3C
-        || /* < */ pos + 2 >= max) {
+    if (state.src.charCodeAt(pos) !== 0x3c || /* < */ pos + 2 >= max) {
         return false;
     }
     // Quick fail on second char
     const ch = state.src.charCodeAt(pos + 1);
-    if (ch !== 0x21
-        && /* ! */ ch !== 0x3F
-        && /* ? */ ch !== 0x2F
-        && /* / */ !isLetter(ch)) {
+    if (ch !== 0x21 && /* ! */ ch !== 0x3f && /* ? */ ch !== 0x2f && /* / */ !isLetter(ch)) {
         return false;
     }
     const match = state.src.slice(pos).match(HTML_TAG_RE);

package/dist/internal/parse/html/html_re.js

@@ -1,7 +1,7 @@
 // Regexps to match html elements
 const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
 const unquoted = '[^"\'=<>`\\x00-\\x20]+';
-const single_quoted = '\'[^\']*\'';
+const single_quoted = "'[^']*'";
 const double_quoted = '"[^"]*"';
 const attr_value = `(?:${unquoted}|${single_quoted}|${double_quoted})`;
 const attribute = `(?:\\s+${attr_name}(?:\\s*=\\s*${attr_value})?)`;

package/dist/internal/parse/html/index.js

@@ -1,7 +1,19 @@
 import { Parser } from 'htmlparser2';
 const VOID_ELEMENTS = new Set([
-    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-    'link', 'meta', 'param', 'source', 'track', 'wbr',
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
 ]);
 function attribsToComarkAttrs(attribs, isInline = false) {
     const attrs = {

package/dist/internal/parse/syntax/block-params.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse `component-name [content] {.params}` from the trailing portion of a block fence line.
+ */
+export declare function parseBlockParams(str: string): {
+    name: string;
+    content?: string;
+    props?: [string, string][];
+    remaining?: string;
+};

package/dist/internal/parse/syntax/block-params.js

@@ -0,0 +1,48 @@
+import { kebabCase } from "../../../utils/index.js";
+import { parseBracketContent } from "./brackets.js";
+import { searchProps } from "./props.js";
+const RE_BLOCK_NAME = /^[a-z$][$\w.-]*/i;
+/**
+ * Parse `component-name [content] {.params}` from the trailing portion of a block fence line.
+ */
+export function parseBlockParams(str) {
+    str = str.trim();
+    if (!str)
+        return { name: '' };
+    const name = str.match(RE_BLOCK_NAME)?.[0];
+    if (!name)
+        throw new Error(`Invalid block params: ${str}`);
+    let remaining = str.slice(name.length).trim();
+    let content;
+    let props;
+    let unparsedRemaining;
+    if (remaining.startsWith('[')) {
+        const result = parseBracketContent(remaining, 0);
+        if (result) {
+            content = result.content;
+            remaining = remaining.slice(result.endIndex).trim();
+        }
+    }
+    if (remaining.startsWith('{')) {
+        const propsResult = searchProps(remaining, 0);
+        if (propsResult) {
+            props = propsResult.props;
+            const afterProps = remaining.slice(propsResult.index).trim();
+            if (afterProps)
+                unparsedRemaining = afterProps;
+        }
+    }
+    else if (remaining) {
+        unparsedRemaining = remaining;
+    }
+    const result = {
+        name: kebabCase(name),
+    };
+    if (content !== undefined)
+        result.content = content;
+    if (props !== undefined)
+        result.props = props;
+    if (unparsedRemaining)
+        result.remaining = unparsedRemaining;
+    return result;
+}

package/dist/internal/parse/syntax/brackets.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse content within square brackets `[content]`.
+ * Returns the content (without the brackets) and the index just past the closing `]`.
+ */
+export declare function parseBracketContent(str: string, startIndex: number): {
+    content: string;
+    endIndex: number;
+} | null;

package/dist/internal/parse/syntax/brackets.js

@@ -0,0 +1,20 @@
+/**
+ * Parse content within square brackets `[content]`.
+ * Returns the content (without the brackets) and the index just past the closing `]`.
+ */
+export function parseBracketContent(str, startIndex) {
+    if (str[startIndex] !== '[')
+        return null;
+    let index = startIndex + 1;
+    while (index < str.length) {
+        if (str[index] === '\\' && index + 1 < str.length) {
+            index += 2;
+            continue;
+        }
+        if (str[index] === ']') {
+            return { content: str.slice(startIndex + 1, index), endIndex: index + 1 };
+        }
+        index += 1;
+    }
+    return null;
+}

package/dist/internal/parse/syntax/props.d.ts

@@ -0,0 +1,5 @@
+export declare function parseProps(content: string): [string, string][] | undefined;
+export declare function searchProps(content: string, index?: number): {
+    props: [string, string][];
+    index: number;
+} | undefined;

package/dist/internal/parse/syntax/props.js

@@ -0,0 +1,119 @@
+const bracketPairs = {
+    '[': ']',
+    '{': '}',
+    '(': ')',
+};
+const quotePairs = {
+    "'": "'",
+    '"': '"',
+    '`': '`',
+};
+export function parseProps(content) {
+    content = content.trim();
+    if (!content)
+        return undefined;
+    const props = searchProps(content);
+    if (!props)
+        throw new Error(`Invalid props: \`${content}\``);
+    if (props.index !== content.length)
+        throw new Error(`Invalid props: \`${content}\`, expected end \`}\` but got \`${content.slice(props.index)}\``);
+    return props.props;
+}
+export function searchProps(content, index = 0) {
+    if (content[index] !== '{')
+        throw new Error(`Invalid props, expected \`{\` but got '${content[index]}'`);
+    const props = [];
+    // Skip Vue mustache `{{ }}` syntax
+    if (content[index + 1] === '{')
+        return undefined;
+    index += 1;
+    while (index < content.length) {
+        if (content[index] === '\\') {
+            index += 2;
+        }
+        else if (content[index] === '}') {
+            index += 1;
+            break;
+        }
+        else if (content[index] === ' ') {
+            index += 1;
+        }
+        else if (content[index] === '.') {
+            index += 1;
+            props.push(['class', searchUntil(' #.}')]);
+        }
+        else if (content[index] === '#') {
+            index += 1;
+            props.push(['id', searchUntil(' #.}')]);
+        }
+        else {
+            const start = index;
+            while (index < content.length) {
+                index += 1;
+                if (' }='.includes(content[index]))
+                    break;
+            }
+            const char = content[index];
+            if (start !== index) {
+                const key = content.slice(start, index).trim();
+                if (char === '=') {
+                    index += 1;
+                    props.push([key, searchValue()]);
+                }
+                else {
+                    props.push([key, 'true']);
+                }
+            }
+        }
+    }
+    function searchUntil(str) {
+        const start = index;
+        while (index < content.length) {
+            index += 1;
+            if (content[index] === '\\')
+                index += 2;
+            if (str.includes(content[index]))
+                break;
+        }
+        return content.slice(start, index);
+    }
+    function searchValue() {
+        const start = index;
+        if (content[index] in bracketPairs) {
+            searchBracket(bracketPairs[content[index]]);
+            index += 1;
+            return content.slice(start, index);
+        }
+        else if (content[index] in quotePairs) {
+            searchString(quotePairs[content[index]]);
+            index += 1;
+            return content.slice(start, index);
+        }
+        else {
+            return searchUntil(' }');
+        }
+    }
+    function searchBracket(end) {
+        while (index < content.length) {
+            index++;
+            if (content[index] in quotePairs)
+                searchString(quotePairs[content[index]]);
+            else if (content[index] in bracketPairs)
+                searchBracket(bracketPairs[content[index]]);
+            else if (content[index] === end)
+                return;
+        }
+    }
+    function searchString(end) {
+        return searchUntil(end);
+    }
+    // Strip surrounding quotes from values
+    props.forEach((v) => {
+        if (/^(['"`]).*\1$/.test(v[1]))
+            v[1] = v[1].slice(1, -1);
+    });
+    return {
+        props,
+        index,
+    };
+}

package/dist/internal/parse/token-processor.js

@@ -38,12 +38,11 @@ export function marmdownItTokensToComarkTree(tokens, options = { startLine: 0, p
             if (options.preservePositions) {
                 for (let j = i; j < result.nextIndex; j++) {
                     if (tokens[j].map && tokens[j].map[1]) {
-                        endLine = tokens[j].map[1]
-                            + options.startLine
-                            + (tokens[j].type?.endsWith('_close') ? 1 : 0);
+                        endLine = tokens[j].map[1] + options.startLine + (tokens[j].type?.endsWith('_close') ? 1 : 0);
                     }
                 }
                 if (!result.node[1].$) {
+                    ;
                     result.node[1].$ = {};
                 }
                 ;
@@ -73,7 +72,11 @@ function processAttributes(attrsArray, options = {}) {
                 continue;
             }
             // Handle boolean attributes: {bool} -> {":bool": "true"}
-            if (handleBoolean && !key.startsWith(':') && !key.startsWith('#') && !key.startsWith('.') && (!value || value === 'true' || value === '')) {
+            if (handleBoolean &&
+                !key.startsWith(':') &&
+                !key.startsWith('#') &&
+                !key.startsWith('.') &&
+                (!value || value === 'true' || value === '')) {
                 attrs[`:${key}`] = 'true';
                 continue;
             }
@@ -140,7 +143,7 @@ function parseCodeblockInfo(info) {
                     const trimmed = part.trim();
                     if (trimmed.includes('-')) {
                         // Range like "1-3"
-                        const [start, end] = trimmed.split('-').map(s => Number.parseInt(s.trim(), 10));
+                        const [start, end] = trimmed.split('-').map((s) => Number.parseInt(s.trim(), 10));
                         if (!Number.isNaN(start) && !Number.isNaN(end)) {
                             for (let i = start; i <= end; i++) {
                                 highlights.push(i);
@@ -271,7 +274,10 @@ function processBlockToken(tokens, startIndex, insideNestedContext = false, stat
         return { node: [componentName, attrs, ...children], nextIndex: nextIndex };
     }
     if (token.type === 'math_block') {
-        return { node: ['math', { class: 'math block', content: token.content }, token.content], nextIndex: startIndex + 1 };
+        return {
+            node: ['math', { class: 'math block', content: token.content }, token.content],
+            nextIndex: startIndex + 1,
+        };
     }
     if (token.type === 'fence' || token.type === 'fenced_code_block' || token.type === 'code_block') {
         const content = token.content || '';
@@ -312,7 +318,10 @@ function processBlockToken(tokens, startIndex, insideNestedContext = false, stat
             const textContent = extractTextContent(children.nodes);
             const headingId = uniqueSlug(slugify(textContent), level, state);
             // Always attach ID to the heading element itself
-            return { node: [headingTag, { id: headingId }, ...children.nodes], nextIndex: children.nextIndex + 1 };
+            return {
+                node: [headingTag, { id: headingId }, ...children.nodes],
+                nextIndex: children.nextIndex + 1,
+            };
         }
         return { node: null, nextIndex: children.nextIndex + 1 };
     }
@@ -320,19 +329,8 @@ function processBlockToken(tokens, startIndex, insideNestedContext = false, stat
     if (token.type === 'list_item_open') {
         const attrs = processAttributes(token.attrs, { handleBoolean: false, handleJSON: false });
         const children = processBlockChildren(tokens, startIndex + 1, 'list_item_close', false, false, true, state);
-        // Unwrap paragraphs in list items
-        const unwrapped = [];
-        for (const child of children.nodes) {
-            if (Array.isArray(child) && child[0] === 'p') {
-                // Unwrap paragraph, add its children directly
-                unwrapped.push(...child.slice(2));
-            }
-            else {
-                unwrapped.push(child);
-            }
-        }
-        if (unwrapped.length > 0) {
-            return { node: ['li', attrs, ...unwrapped], nextIndex: children.nextIndex + 1 };
+        if (children.nodes.length > 0) {
+            return { node: ['li', attrs, ...children.nodes], nextIndex: children.nextIndex + 1 };
         }
         return { node: null, nextIndex: children.nextIndex + 1 };
     }
@@ -615,7 +613,7 @@ function processInlineToken(tokens, startIndex, inHeading = false) {
         return { node, nextIndex: j };
     }
     // Handle Comark inline span (e.g., [text]{attr})
-    // @comark/markdown-it creates mdc_inline_span tokens, and props appear AFTER the close token
+    // The syntax plugin emits mdc_inline_span tokens, and props appear AFTER the close token
     if (token.type === 'mdc_inline_span' && token.nesting === 1) {
         const attrs = {};
         let i = startIndex + 1;
@@ -698,11 +696,11 @@ function processInlineToken(tokens, startIndex, inHeading = false) {
         else {
             // Self-closing component (nesting === 0)
             const attrs = {};
-            // @comark/markdown-it stores attributes in a separate mdc_inline_props token
+            // The syntax plugin stores attributes in a separate mdc_inline_props token
             // that appears right after the component token
             const { attrs: componentAttrs, nextIndex: propsNextIndex } = extractAttributes(tokens, startIndex + 1, false);
             Object.assign(attrs, componentAttrs);
-            // Extract attributes from token.attrs (fallback, though @comark/markdown-it uses mdc_inline_props)
+            // Extract attributes from token.attrs (fallback, though the syntax plugin uses mdc_inline_props)
             const fallbackAttrs = processAttributes(token.attrs, { handleBoolean: false });
             Object.assign(attrs, fallbackAttrs);
             // Return the component without any text children
@@ -734,7 +732,10 @@ function processInlineToken(tokens, startIndex, inHeading = false) {
         return { node: null, nextIndex };
     }
     if (token.type === 'math_inline') {
-        return { node: ['math', { class: 'math inline', content: token.content }, token.content], nextIndex: startIndex + 1 };
+        return {
+            node: ['math', { class: 'math inline', content: token.content }, token.content],
+            nextIndex: startIndex + 1,
+        };
     }
     // Handle generic inline open/close pairs
     const tagName = INLINE_TAG_MAP[token.type];

package/dist/internal/props-validation.js

@@ -1,10 +1,5 @@
-export const unsafeTags = [
-    'object',
-];
-export const unsafeAttributes = [
-    'srcdoc',
-    'formaction',
-];
+export const unsafeTags = ['object'];
+export const unsafeAttributes = ['srcdoc', 'formaction'];
 export const unsafeLinkPrefix = [
     'javascript:',
     'data:text/html',
@@ -44,7 +39,7 @@ function validateUrl(value, mode, options) {
         return value;
     }
     // Block known-unsafe protocols — hard floor, not overrideable by options
-    if (unsafeLinkPrefix.some(prefix => url.href.toLowerCase().startsWith(prefix))) {
+    if (unsafeLinkPrefix.some((prefix) => url.href.toLowerCase().startsWith(prefix))) {
         return false;
     }
     // Block data: images when allowDataImages is false
@@ -62,7 +57,7 @@ function validateUrl(value, mode, options) {
     const allowedPrefixes = mode === 'link' ? allowedLinkPrefixes : allowedImagePrefixes;
     if (!allowedPrefixes.includes('*')) {
         const href = url.href.toLowerCase();
-        const matchesPrefix = allowedPrefixes.some(prefix => href.startsWith(prefix.toLowerCase()));
+        const matchesPrefix = allowedPrefixes.some((prefix) => href.startsWith(prefix.toLowerCase()));
         if (!matchesPrefix) {
             if (defaultOrigin) {
                 return rewriteToDefaultOrigin(urlSanitized, defaultOrigin);