@dogsbay/markdown-it-mdx-jsx 0.2.0-beta.132 → 0.2.0-beta.133

package/dist/index.js

@@ -101,41 +101,69 @@ export function parseJsxAttrs(str) {
  * Handles multi-line by accepting the full remaining source.
  */
 function parseTag(src, pos) {
-    if (src.charCodeAt(pos) !== 0x3c /* < */)
-        return null;
-    let i = pos + 1;
-    const len = src.length;
-    // Skip whitespace after <
-    while (i < len && /\s/.test(src[i]))
-        i++;
-    // Check for closing tag: </Tag>
-    const isClose = src[i] === "/";
-    if (isClose)
-        i++;
-    // Must start with uppercase letter (JSX convention)
-    if (i >= len || !/[A-Z]/.test(src[i]))
-        return null;
-    // Read tag name
-    const nameStart = i;
-    while (i < len && /[\w.]/.test(src[i]))
-        i++;
-    const tag = src.slice(nameStart, i);
-    if (isClose) {
-        // Closing tag: skip whitespace, expect >
+    const r = scanTag(src, pos);
+    return r && "length" in r ? r : null;
+}
+/**
+ * {@link parseTag}, or — when an opening tag's attributes run past the end of `src` — where the
+ * scan stopped, to resume on a longer `src` (`resume`). parseBlockTag appends a tag's lines one
+ * at a time; re-scanning from the start each time was quadratic: camunda's OpenAPI pages open
+ * `<RequestSchema` with 3,700 lines of attributes, 12 s for one page, 114 s for the site.
+ */
+function scanTag(src, pos, resume, 
+/** Where `src` starts in the whole tag text: a resumed scan is fed one new line at a time. */
+base = 0, 
+/** The whole tag text, for the attributes, when `src` is only its last piece. */
+whole, 
+/** Scan no further than this index: a tag that has not closed by then is not a tag. */
+maxEnd = Infinity) {
+    // Indices are into the whole text; `src` holds [base, len). Each line is scanned on its own and
+    // joined once at the end: reading a character of a string built by `+=` flattens the rope,
+    // so scanning the growing string was quadratic even when resumed.
+    const len = Math.min(base + src.length, maxEnd);
+    const at = (k) => src[k - base];
+    let i;
+    let tag;
+    let attrStart;
+    let braceDepth = 0;
+    let inQuote = null;
+    if (resume) {
+        ({ tag, attrStart, i, braceDepth, inQuote } = resume);
+    }
+    else {
+        if (src.charCodeAt(pos) !== 0x3c /* < */)
+            return null;
+        i = pos + 1;
+        // Skip whitespace after <
         while (i < len && /\s/.test(src[i]))
             i++;
-        if (i < len && src[i] === ">") {
-            return { tag, attrs: {}, selfClosing: false, isClose: true, length: i - pos + 1 };
+        // Check for closing tag: </Tag>
+        const isClose = src[i] === "/";
+        if (isClose)
+            i++;
+        // Must start with uppercase letter (JSX convention)
+        if (i >= len || !/[A-Z]/.test(src[i]))
+            return null;
+        // Read tag name
+        const nameStart = i;
+        while (i < len && /[\w.]/.test(src[i]))
+            i++;
+        tag = src.slice(nameStart, i);
+        if (isClose) {
+            // Closing tag: skip whitespace, expect >
+            while (i < len && /\s/.test(src[i]))
+                i++;
+            if (i < len && src[i] === ">") {
+                return { tag, attrs: {}, selfClosing: false, isClose: true, length: i - pos + 1 };
+            }
+            return null;
         }
-        return null;
+        // Opening tag — parse attributes until > or />
+        // Track brace depth for JSX expression attributes
+        attrStart = i;
     }
-    // Opening tag — parse attributes until > or />
-    // Track brace depth for JSX expression attributes
-    let braceDepth = 0;
-    let inQuote = null;
-    const attrStart = i;
     while (i < len) {
-        const ch = src[i];
+        const ch = at(i);
         if (inQuote) {
             if (ch === "\\") {
                 i += 2;
@@ -163,8 +191,8 @@ function parseTag(src, pos) {
         }
         // Only check for tag end when not inside braces or quotes
         if (braceDepth === 0) {
-            if (ch === "/" && i + 1 < len && src[i + 1] === ">") {
-                const attrsStr = src.slice(attrStart, i).trim();
+            if (ch === "/" && i + 1 < len && at(i + 1) === ">") {
+                const attrsStr = (whole ? whole() : src).slice(attrStart, i).trim();
                 return {
                     tag,
                     attrs: parseJsxAttrs(attrsStr),
@@ -174,7 +202,7 @@ function parseTag(src, pos) {
                 };
             }
             if (ch === ">") {
-                const attrsStr = src.slice(attrStart, i).trim();
+                const attrsStr = (whole ? whole() : src).slice(attrStart, i).trim();
                 return {
                     tag,
                     attrs: parseJsxAttrs(attrsStr),
@@ -186,7 +214,8 @@ function parseTag(src, pos) {
         }
         i++;
     }
-    return null; // Never found closing >
+    // Never found closing > — where to resume when there is more
+    return { tag, attrStart, i, braceDepth, inQuote };
 }
 // ── Block rule helpers ─────────────────────────────────────
 function getLine(state, line) {
@@ -253,6 +282,23 @@ function findCloseTag(state, startLine, endLine, tag) {
  * Concatenates lines as needed for multi-line tags.
  * Returns null if no valid tag found.
  */
+/**
+ * How much multi-line tag scanning one document may do, per parse: each line that opens a tag
+ * with no `>` scans to the end of the document, so a page of unclosed `<A x={` lines was
+ * quadratic (review 2026-10-21: 56 KB, 15 s). Real pages scan a few times their length
+ * (camunda's 3,700-line `<RequestSchema>`); past the budget a tag that has not closed is
+ * not a tag, and the line is read as text.
+ */
+const scanBudgets = new WeakMap();
+function scanBudget(state) {
+    const key = (state.env && typeof state.env === "object" ? state.env : state);
+    let b = scanBudgets.get(key);
+    if (!b || b.src !== state.src) {
+        b = { src: state.src, left: 8 * state.src.length + 100_000 };
+        scanBudgets.set(key, b);
+    }
+    return b;
+}
 function parseBlockTag(state, startLine, endLine, offset = 0) {
     const linePos = state.bMarks[startLine] + state.tShift[startLine];
     const lineEnd = state.eMarks[startLine];
@@ -267,18 +313,27 @@ function parseBlockTag(state, startLine, endLine, offset = 0) {
     const tagStart = remaining.match(/^<\/?([A-Z]\w*)/);
     if (!tagStart)
         return null;
-    // Concatenate lines until we find > or />
-    let combined = remaining;
+    // Add lines until we find > or />, resuming the scan where the last line left it
+    const budget = scanBudget(state);
+    const parts = [remaining];
+    let total = remaining.length;
+    const whole = () => parts.join("");
+    let scan = scanTag(remaining, 0);
     let currentLine = startLine + 1;
     while (currentLine < endLine) {
         // The whole line, indentation included: a multi-line attribute VALUE
         // (`<Code code={`…`} />`) is content, and trimming each line flattened
         // every code sample written that way.
-        const nextLine = state.src.slice(state.bMarks[currentLine], state.eMarks[currentLine]);
-        combined += "\n" + nextLine;
-        const parsed = parseTag(combined, 0);
-        if (parsed) {
-            return { ...parsed, endLine: currentLine };
+        const piece = "\n" + state.src.slice(state.bMarks[currentLine], state.eMarks[currentLine]);
+        budget.left -= piece.length;
+        if (budget.left < 0)
+            return null;
+        parts.push(piece);
+        // A closing tag split over lines (`</Tag\n>`) is rare and short: scanned from the start
+        scan = scan && !("length" in scan) ? scanTag(piece, 0, scan, total, whole) : scanTag(whole(), 0);
+        total += piece.length;
+        if (scan && "length" in scan) {
+            return { ...scan, endLine: currentLine };
         }
         currentLine++;
     }
@@ -421,6 +476,9 @@ function processFlowTags(state, startLine, endLine, linePos, lineText, component
 }
 // ── Inline rule ────────────────────────────────────────────
 const openInline = new WeakMap();
+/** What one inline run may still scan for tags (see `scanBudgets`): each `<` scanned to the end
+ * of the paragraph when no `>` came, quadratic in a paragraph of unclosed `<A x={` lines. */
+const inlineBudgets = new WeakMap();
 function createJsxInlineRule(options) {
     const componentSet = options.components ? new Set(options.components) : null;
     const selfClosingSet = new Set(options.selfClosing || []);
@@ -428,7 +486,14 @@ function createJsxInlineRule(options) {
         const pos = state.pos;
         if (state.src.charCodeAt(pos) !== 0x3c /* < */)
             return false;
-        const parsed = parseTag(state.src, pos);
+        let budget = inlineBudgets.get(state);
+        if (!budget)
+            inlineBudgets.set(state, (budget = { left: 8 * state.src.length + 100_000 }));
+        if (budget.left <= 0)
+            return false;
+        const scan = scanTag(state.src, pos, undefined, 0, undefined, pos + budget.left);
+        budget.left -= scan && "length" in scan ? scan.length : scan ? scan.i - pos : 1;
+        const parsed = scan && "length" in scan ? scan : null;
         if (!parsed)
             return false;
         if (componentSet && !componentSet.has(parsed.tag))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dogsbay/markdown-it-mdx-jsx",
-  "version": "0.2.0-beta.132",
+  "version": "0.2.0-beta.133",
   "description": "markdown-it plugin that tokenizes JSX-style component tags inside Markdown — used by @dogsbay/format-starlight",
   "type": "module",
   "exports": {