@fuzdev/mdz 0.2.0 → 0.3.0

package/dist/mdz_lexer.js

@@ -6,7 +6,8 @@
  *
  * @module
  */
-import { mdz_is_url, mdz_is_safe_reference, is_letter, is_tag_name_char, is_word_char, is_valid_path_char, mdz_trim_url_punctuation, BACKTICK, ASTERISK, UNDERSCORE, TILDE, NEWLINE, HYPHEN, HASH, SPACE, LEFT_ANGLE, RIGHT_ANGLE, SLASH, PERIOD, LEFT_BRACKET, LEFT_PAREN, RIGHT_BRACKET, A_UPPER, Z_UPPER, ZERO, ONE, NINE, HR_HYPHEN_COUNT, MIN_CODEBLOCK_BACKTICKS, MAX_HEADING_LEVEL, MAX_LIST_NUMBER_DIGITS, match_url_prefix_case_insensitive, is_at_absolute_path, is_at_relative_path, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, mdz_blockquote_strip_width, mdz_remap_segments, mdz_split_table_row, mdz_parse_table_delimiter, PIPE, BACKSLASH, } from './mdz_helpers.js';
+import { mdz_is_url, mdz_is_safe_reference, is_letter, is_tag_name_char, is_word_char, is_valid_path_char, mdz_trim_url_punctuation, BACKTICK, ASTERISK, UNDERSCORE, TILDE, NEWLINE, HYPHEN, HASH, SPACE, LEFT_ANGLE, RIGHT_ANGLE, SLASH, PERIOD, LEFT_BRACKET, LEFT_PAREN, RIGHT_BRACKET, A_UPPER, Z_UPPER, ZERO, ONE, NINE, HR_HYPHEN_COUNT, MIN_CODEBLOCK_BACKTICKS, MAX_HEADING_LEVEL, MAX_INLINE_NESTING_DEPTH, MAX_LIST_NUMBER_DIGITS, match_url_prefix_case_insensitive, is_at_absolute_path, is_at_relative_path, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, mdz_blockquote_strip_width, mdz_remap_segments, mdz_split_table_row, mdz_parse_table_delimiter, PIPE, TEXT_CLASS_BACKSLASH, TEXT_CLASS_NEWLINE, TEXT_CLASS_STOP, TEXT_CLASS_URL, TEXT_SCAN_CLASS, } from './mdz_helpers.js';
+import { mdz_debug_work } from './mdz_debug_work.js';
 //
 // Lexer
 //
@@ -39,9 +40,67 @@ export class MdzLexer {
      * and `\|` unescapes to a literal pipe.
      */
     #in_table_cell = false;
+    /**
+     * Start offsets of markdown-link opens (`[`) that definitively failed — so
+     * a re-lex from before the `[` short-circuits to literal text instead of
+     * re-attempting (and re-descending into) the same failing link. Without it,
+     * the revert-and-re-tokenize failure path is exponential on nested `[`
+     * (a ~30-byte `[`×n input hangs). A link's outcome (does a valid `](ref)`
+     * follow?) is independent of `#max_search_index`, so `start` alone keys it.
+     * The outcome is a pure function of the immutable text, so the memo is valid
+     * for the whole lex and across table-cell ranges; cleared on `rebind`.
+     */
+    #failed_link_starts = new Set();
+    /**
+     * The tag analogue of `#failed_link_starts`, keyed `${start}:${bound}`. A
+     * tag's closer search respects `#max_search_index`, so the same `start` can
+     * fail under a narrow bound yet succeed under the wider one a re-lex uses —
+     * the bound is part of the key.
+     */
+    #failed_tag = new Set();
+    /**
+     * Current link/tag nesting depth — the number of open
+     * `link_text_open`/`tag_open` containers being recursed into. Bumped around
+     * `#tokenize_markdown_link`/`#tokenize_tag`'s children loops (not by
+     * delimiters, which can't nest deeply — see `MAX_INLINE_NESTING_DEPTH`). At
+     * the cap a further `[`/`<` renders literal instead of opening, bounding
+     * recursion depth (no stack overflow) and, with the failure memos, the
+     * revert re-scan (linear, not quadratic) on adversarial nesting.
+     */
+    #inline_depth = 0;
+    /**
+     * Start offsets of `[`/`<` openers suppressed by the nesting-depth cap
+     * (`#inline_depth >= MAX_INLINE_NESTING_DEPTH`) — position-keyed like
+     * `#failed_link_starts` so a re-lex from a shallower depth short-circuits to
+     * literal text rather than re-opening the construct (which would reintroduce
+     * the quadratic the cap removes). A suppression is bound-independent, so
+     * `start` alone keys it; cleared on `rebind`.
+     */
+    #depth_capped = new Set();
     constructor(text) {
         this.#text = text;
     }
+    /**
+     * Rebind to a new text, so one lexer instance can be reused across inputs —
+     * the streaming table path reuses one across a table's rows via
+     * `MdzTableCellParser` instead of allocating a lexer (and its memo `Map`)
+     * per row. The search memos survive when the text is identical (they're
+     * valid over the immutable text — the common case for rows parsed from one
+     * buffered chunk) and clear otherwise. Per-parse cursor state is reset by
+     * `lex_table_cell` itself.
+     *
+     * @nodocs
+     */
+    rebind(text) {
+        if (this.#text === text)
+            return;
+        this.#text = text;
+        this.#search_memo.clear();
+        this.#break_memo = null;
+        this.#failed_link_starts.clear();
+        this.#failed_tag.clear();
+        this.#depth_capped.clear();
+    }
     /**
      * Memoized `String#indexOf` over the immutable text.
      *
@@ -58,6 +117,10 @@ export class MdzLexer {
             return memo.result;
         }
         const result = this.#text.indexOf(needle, from);
+        if (mdz_debug_work.enabled) {
+            // scan span: `indexOf` examined [from, result] (found) or [from, EOF)
+            mdz_debug_work.total += (result === -1 ? this.#text.length : result) - from;
+        }
         if (memo === undefined) {
             this.#search_memo.set(needle, { from, result });
         }
@@ -110,6 +173,9 @@ export class MdzLexer {
      */
     lex_table_cell(cell_start, cell_end) {
         this.#tokens = [];
+        // depth is balanced back to 0 per cell, but pin it so a future early-return
+        // between an `#inline_depth++` and its decrement can't leak into the next cell
+        this.#inline_depth = 0;
         this.#tokenize_cell_inline(cell_start, cell_end);
         return this.#tokens;
     }
@@ -1194,12 +1260,30 @@ export class MdzLexer {
     }
     #tokenize_markdown_link() {
         const start = this.#index;
+        // a link open at this offset already failed, or was suppressed by the
+        // nesting cap — emit `[` as text instead of re-descending into the same
+        // failing children (exponential on nested `[`); the short-circuit
+        // reproduces the revert's exact net effect (`[` text, cursor at start + 1)
+        if (this.#failed_link_starts.has(start) || this.#depth_capped.has(start)) {
+            this.#index = start + 1;
+            this.#emit_text('[', start);
+            return;
+        }
+        // nesting-depth cap: too deep to open — render literal and record the
+        // suppression so a shallower re-lex short-circuits here too
+        if (this.#inline_depth >= MAX_INLINE_NESTING_DEPTH) {
+            this.#depth_capped.add(start);
+            this.#index = start + 1;
+            this.#emit_text('[', start);
+            return;
+        }
         this.#index++; // consume [ (dispatch guarantees it)
         // Emit link_text_open
         this.#tokens.push({ type: 'link_text_open', start, end: this.#index });
         // Tokenize children until ] — only `]` delimits link text; a bare `)`
         // is ordinary content (matching the streaming parser, which has no `)`
         // dispatch case — the reference scan finds its own `)` after `](`)
+        this.#inline_depth++;
         while (this.#index < this.#text.length) {
             if (this.#text.charCodeAt(this.#index) === RIGHT_BRACKET)
                 break;
@@ -1207,6 +1291,7 @@ export class MdzLexer {
                 break;
             this.#tokenize_inline();
         }
+        this.#inline_depth--;
         // Check for ]
         if (this.#index >= this.#text.length || this.#text.charCodeAt(this.#index) !== RIGHT_BRACKET) {
             // Revert - remove link_text_open and all children tokens added
@@ -1263,6 +1348,13 @@ export class MdzLexer {
         });
     }
     #revert_tokens_from_link_open(start) {
+        // record the failure so a re-lex from before this `[` short-circuits.
+        // Keyed by `start` alone — unlike `#failed_tag`'s `start:bound` — because a
+        // link's outcome is bound-independent: the `]`-terminator scan (the children
+        // loop) runs to `text.length` and never consults `#max_search_index`, so a
+        // wider-bound re-lex can't move it. The bound reaches nested tags inside the
+        // link text, but re-attempting those wider never flips the link's net result.
+        this.#failed_link_starts.add(start);
         // Find and remove link_text_open and all tokens after it
         let open_idx = -1;
         for (let i = this.#tokens.length - 1; i >= 0; i--) {
@@ -1279,6 +1371,30 @@ export class MdzLexer {
     }
     #tokenize_tag() {
         const start = this.#index;
+        // short-circuit a re-attempt of a tag open that already failed at this
+        // offset+bound — re-descending into the same failing children is
+        // exponential on nested same-name tags. Keyed by
+        // `#max_search_index` (captured as `bound`) because the closer search is
+        // bound-sensitive, so a wider-bound re-lex can legitimately succeed. The
+        // key string is built only when the memo is non-empty (adversarial
+        // input); prose never allocates it. The short-circuit reproduces a
+        // revert's exact net effect (`<` text, cursor at start + 1).
+        const bound = this.#max_search_index;
+        if (this.#depth_capped.has(start) ||
+            (this.#failed_tag.size !== 0 && this.#failed_tag.has(`${start}:${bound}`))) {
+            this.#index = start + 1;
+            this.#emit_text('<', start);
+            return;
+        }
+        // nesting-depth cap: too deep to open a tag — render literal and record
+        // the suppression (position-keyed) so a shallower re-lex short-circuits
+        // here too, keeping the revert re-scan linear
+        if (this.#inline_depth >= MAX_INLINE_NESTING_DEPTH) {
+            this.#depth_capped.add(start);
+            this.#index = start + 1;
+            this.#emit_text('<', start);
+            return;
+        }
         this.#index++; // consume <
         // Tag name must start with a letter
         if (this.#index >= this.#text.length || !is_letter(this.#text.charCodeAt(this.#index))) {
@@ -1315,6 +1431,7 @@ export class MdzLexer {
         }
         // Check for >
         if (this.#index >= this.#text.length || this.#text.charCodeAt(this.#index) !== RIGHT_ANGLE) {
+            this.#failed_tag.add(`${start}:${bound}`);
             this.#index = start + 1;
             this.#emit_text('<', start);
             return;
@@ -1332,11 +1449,13 @@ export class MdzLexer {
         const search_limit = Math.min(this.#max_search_index, this.#text.length);
         const closing_tag_pos = this.#index_of(closing_tag, this.#index);
         if (closing_tag_pos === -1 || closing_tag_pos > search_limit) {
+            this.#failed_tag.add(`${start}:${bound}`);
             this.#index = start + 1;
             this.#emit_text('<', start);
             return;
         }
         if (this.#has_paragraph_break_between(this.#index, closing_tag_pos)) {
+            this.#failed_tag.add(`${start}:${bound}`);
             this.#index = start + 1;
             this.#emit_text('<', start);
             return;
@@ -1350,8 +1469,10 @@ export class MdzLexer {
         // the code span). Recomputed per iteration because a nested same-name
         // tag legitimately consumes the nearest closer (`<b>x<b>y</b></b>`).
         const saved_max = this.#max_search_index;
+        this.#inline_depth++;
         while (this.#index < this.#text.length) {
             if (this.#match(closing_tag)) {
+                this.#inline_depth--;
                 this.#max_search_index = saved_max;
                 const close_start = this.#index;
                 this.#index += closing_tag.length;
@@ -1372,11 +1493,13 @@ export class MdzLexer {
             this.#max_search_index = next_close;
             this.#tokenize_inline();
         }
+        this.#inline_depth--;
         // No valid closer left — revert: drop the open token and all consumed
         // children tokens, emit `<` as text, and re-lex from the next char
         // (the `#revert_tokens_from_link_open` pattern; the old fallthrough
         // left a dangling `tag_open` whose parser fallback discarded content)
         this.#max_search_index = saved_max;
+        this.#failed_tag.add(`${start}:${bound}`);
         this.#tokens.splice(open_token_index);
         this.#index = start + 1;
         this.#emit_text('<', start);
@@ -1400,15 +1523,30 @@ export class MdzLexer {
         // content: parts accumulate around each stripped region
         let parts = null;
         let part_start = start;
-        while (this.#index < this.#text.length) {
+        // in a table cell the trimmed cell end is a hard stop (no newline to
+        // halt on mid-line) — hoisted to the loop bound
+        const scan_end = this.#in_table_cell
+            ? Math.min(this.#max_search_index, this.#text.length)
+            : this.#text.length;
+        while (this.#index < scan_end) {
             const char_code = this.#text.charCodeAt(this.#index);
-            // in a table cell: the trimmed cell end is a hard stop (no newline to
-            // halt on mid-line), and `\|` is a literal pipe (the only mdz escape,
-            // scoped here)
-            if (this.#in_table_cell) {
-                if (this.#index >= this.#max_search_index)
-                    break;
-                if (char_code === BACKSLASH &&
+            // one table load classifies the char; zero (the common case — the
+            // char can't end or interrupt the run) skips the dispatch below.
+            // `TEXT_SCAN_CLASS` is shared with the streaming scanner
+            // (`consume_text_run` in `mdz_stream_parser_text.ts`); the two dispatch
+            // bodies intentionally differ around it — this one handles `\|` escapes
+            // and list-run strip, that one URL speculation across chunk boundaries.
+            const char_class = char_code < 128 ? TEXT_SCAN_CLASS[char_code] : 0;
+            if (char_class === 0) {
+                this.#index++;
+                continue;
+            }
+            // Stop at special characters
+            if ((char_class & TEXT_CLASS_STOP) !== 0)
+                break;
+            if ((char_class & TEXT_CLASS_BACKSLASH) !== 0) {
+                // `\|` is a literal pipe — the only mdz escape, scoped to table cells
+                if (this.#in_table_cell &&
                     this.#index + 1 < this.#max_search_index &&
                     this.#text.charCodeAt(this.#index + 1) === PIPE) {
                     (parts ??= []).push(this.#text.slice(part_start, this.#index));
@@ -1417,18 +1555,10 @@ export class MdzLexer {
                     part_start = this.#index;
                     continue;
                 }
+                this.#index++;
+                continue;
             }
-            // Stop at special characters
-            if (char_code === BACKTICK ||
-                char_code === ASTERISK ||
-                char_code === UNDERSCORE ||
-                char_code === TILDE ||
-                char_code === LEFT_BRACKET ||
-                char_code === RIGHT_BRACKET ||
-                char_code === LEFT_ANGLE) {
-                break;
-            }
-            if (char_code === NEWLINE) {
+            if ((char_class & TEXT_CLASS_NEWLINE) !== 0) {
                 if (this.#list_run_strip) {
                     if (this.#index >= this.#max_search_index)
                         break; // the run's terminator
@@ -1465,15 +1595,25 @@ export class MdzLexer {
                         break;
                     }
                 }
+                this.#index++; // single newline — ordinary text
+                continue;
+            }
+            // URL or internal path mid-text (class guard avoids probing every char)
+            if ((char_class & TEXT_CLASS_URL) !== 0) {
+                if (this.#is_at_url())
+                    break;
+            }
+            else if (char_code === SLASH) {
+                if (is_at_absolute_path(this.#text, this.#index))
+                    break;
             }
-            // Check for URL or internal path mid-text (char code guard avoids startsWith on every char)
-            if (((char_code === 104 /* h */ || char_code === 72) /* H */ && this.#is_at_url()) ||
-                (char_code === SLASH && is_at_absolute_path(this.#text, this.#index)) ||
-                (char_code === PERIOD && is_at_relative_path(this.#text, this.#index))) {
+            else if (is_at_relative_path(this.#text, this.#index)) {
                 break;
             }
             this.#index++;
         }
+        if (mdz_debug_work.enabled)
+            mdz_debug_work.total += this.#index - start;
         // Ensure we always consume at least one character
         if (this.#index === start && this.#index < this.#text.length) {
             this.#index++;

package/dist/mdz_stream_parser_inline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_inline.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_inline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EACN,KAAK,oBAAoB,EAYzB,MAAM,8BAA8B,CAAC;AA6GtC;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,WAAW,IAAI,GAAG,IAAI,EACtB,WAAW,MAAM,GAAG,eAAe,EACnC,gBAAc,KACZ,OA2BF,CAAC;AAIF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OAyCxE,CAAC;AAIF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,KAAG,OAOvE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,OAuBhF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,gBAAc,KACZ,WAAW,GAAG,UAAU,GAAG,SAmB7B,CAAC;AAIF,cAAc;AACd,eAAO,MAAM,QAAQ,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OAoFtE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,MAAM,MAAM,KAAG,MAyB7E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,GAAI,OAAO,oBAAoB,KAAG,OAO5E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,oBAAoB,KAAG,IA2ClE,CAAC"}
+{"version":3,"file":"mdz_stream_parser_inline.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_inline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EACN,KAAK,oBAAoB,EAYzB,MAAM,8BAA8B,CAAC;AA6GtC;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,WAAW,IAAI,GAAG,IAAI,EACtB,WAAW,MAAM,GAAG,eAAe,EACnC,gBAAc,KACZ,OA2BF,CAAC;AAIF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OAyCxE,CAAC;AAIF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,KAAG,OAOvE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,OAuBhF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,gBAAc,KACZ,WAAW,GAAG,UAAU,GAAG,SAmB7B,CAAC;AAIF,cAAc;AACd,eAAO,MAAM,QAAQ,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OAwFtE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,MAAM,MAAM,KAAG,MAyB7E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,GAAI,OAAO,oBAAoB,KAAG,OAO5E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,oBAAoB,KAAG,IA2ClE,CAAC"}

package/dist/mdz_stream_parser_inline.js

@@ -297,15 +297,20 @@ export const scan_closer_boundary = (state, forced = false) => {
 /** @nodocs */
 export const try_code = (state, forced = false) => {
     const start = state.pos;
-    let i = start + 1; // past opening backtick
+    const search_start = start + 1; // past opening backtick
     // compute search boundary: don't scan past open formatting delimiters
-    const search_limit = code_search_limit(state, start + 1);
-    // scan for closing backtick (must be before newline and search boundary)
-    while (i < state.buffer.length && i < search_limit) {
-        const c = state.buffer.charCodeAt(i);
-        if (c === BACKTICK) {
+    const search_limit = code_search_limit(state, search_start);
+    // find the first closing backtick or newline (memoized — a candidate that
+    // holds under open formatting re-enters here on every feed, and a raw scan
+    // would re-cover the same growing region each time, going quadratic on a
+    // single long line)
+    const close_pos = buffer_index_of(state, '`', search_start);
+    const newline_pos = buffer_index_of(state, '\n', search_start);
+    const terminator = close_pos !== -1 && (newline_pos === -1 || close_pos < newline_pos) ? close_pos : newline_pos;
+    if (terminator !== -1 && terminator < search_limit) {
+        if (terminator === close_pos) {
             // found close
-            const content = state.buffer.slice(start + 1, i);
+            const content = state.buffer.slice(search_start, terminator);
             if (content.length === 0) {
                 // empty code — treat as text
                 consume_delimiter_as_text(state, '``');
@@ -320,20 +325,17 @@ export const try_code = (state, forced = false) => {
                 content,
                 text_type: 'Code',
                 start: offset(state, start),
-                end: offset(state, i + 1),
+                end: offset(state, terminator + 1),
             });
             state.active_text_id = null;
-            state.pos = i + 1;
-            state.column += i + 1 - start;
+            state.pos = terminator + 1;
+            state.column += terminator + 1 - start;
             state.prev_char = BACKTICK;
             return true;
         }
-        if (c === NEWLINE) {
-            // inline code can't span lines — treat opening backtick as text
-            consume_delimiter_as_text(state, '`');
-            return true;
-        }
-        i++;
+        // newline before any close — inline code can't span lines
+        consume_delimiter_as_text(state, '`');
+        return true;
     }
     // hit search limit (open formatting delimiter boundary) — treat backtick as
     // text. This is the documented backtick-adjacent divergence point: when the
@@ -341,7 +343,7 @@ export const try_code = (state, forced = false) => {
     // processed), the one-shot parse rejects that italic and scans unbounded —
     // see the `MdzStreamParser` TSDoc and the parity suite's expected-divergence
     // battery
-    if (i < state.buffer.length && i >= search_limit) {
+    if (search_limit < state.buffer.length) {
         consume_delimiter_as_text(state, '`');
         return true;
     }

package/dist/mdz_stream_parser_link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_link.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_link.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAWd,MAAM,8BAA8B,CAAC;AAItC,cAAc;AACd,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,OAa3D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,gBAAgB,MAAM,EACtB,aAAa,MAAM,KACjB,IAUF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,gBAAgB,MAAM,KAAG,OAwEvF,CAAC;AAIF,cAAc;AACd,eAAO,MAAM,YAAY,GAAI,OAAO,oBAAoB,KAAG,SAyE1D,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,SA0C3D,CAAC"}
+{"version":3,"file":"mdz_stream_parser_link.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_link.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAYd,MAAM,8BAA8B,CAAC;AAMtC,cAAc;AACd,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,OAoB3D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,gBAAgB,MAAM,EACtB,aAAa,MAAM,KACjB,IAUF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,gBAAgB,MAAM,KAAG,OA4EvF,CAAC;AAIF,cAAc;AACd,eAAO,MAAM,YAAY,GAAI,OAAO,oBAAoB,KAAG,SAqF1D,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,SAiD3D,CAAC"}

package/dist/mdz_stream_parser_link.js

@@ -4,11 +4,20 @@
  *
  * @module
  */
-import { A_UPPER, LEFT_BRACKET, LEFT_PAREN, NEWLINE, RIGHT_ANGLE, RIGHT_BRACKET, RIGHT_PAREN, SLASH, SPACE, Z_UPPER, is_letter, is_tag_name_char, is_valid_path_char, mdz_is_safe_reference, mdz_is_url, } from './mdz_helpers.js';
-import { accumulate_text, alloc_id, emit, ensure_paragraph, flush_text, is_run_boundary, offset, pop_stack_entry, push_stack_entry, revert_above, } from './mdz_stream_parser_state.js';
+import { A_UPPER, LEFT_BRACKET, LEFT_PAREN, MAX_INLINE_NESTING_DEPTH, RIGHT_ANGLE, RIGHT_BRACKET, RIGHT_PAREN, SLASH, SPACE, Z_UPPER, is_letter, is_tag_name_char, is_valid_path_char, mdz_is_safe_reference, mdz_is_url, } from './mdz_helpers.js';
+import { accumulate_text, alloc_id, buffer_index_of, emit, ensure_paragraph, flush_text, is_run_boundary, offset, pop_stack_entry, push_stack_entry, revert_above, } from './mdz_stream_parser_state.js';
+import { consume_delimiter_as_text } from './mdz_stream_parser_text.js';
+import { mdz_debug_work } from './mdz_debug_work.js';
 // -- Links --
 /** @nodocs */
 export const try_link_open = (state) => {
+    // nesting-depth cap: too deep to open — render `[` literal, matching the
+    // sync lexer's `#tokenize_markdown_link` cap (keeps the two parsers agreeing
+    // on where deep `[` stops nesting)
+    if (state.open_link_tag_depth >= MAX_INLINE_NESTING_DEPTH) {
+        consume_delimiter_as_text(state, '[');
+        return true;
+    }
     flush_text(state);
     ensure_paragraph(state);
     const id = alloc_id(state);
@@ -55,63 +64,67 @@ export const try_complete_link = (state, link_stack_idx) => {
         abort_link_to_text(state, link_stack_idx, bracket_pos);
         return true;
     }
-    // found ]( — scan for )
-    let i = bracket_pos + 2; // past ](
-    while (i < state.buffer.length) {
-        const c = state.buffer.charCodeAt(i);
-        if (c === RIGHT_PAREN) {
-            const reference = state.buffer.slice(bracket_pos + 2, i);
-            // validate reference: non-empty and only valid path chars
-            if (!reference.trim()) {
-                abort_link_to_text(state, link_stack_idx, bracket_pos);
-                return true;
-            }
-            let valid = true;
-            for (let j = 0; j < reference.length; j++) {
-                if (!is_valid_path_char(reference.charCodeAt(j))) {
-                    valid = false;
-                    break;
-                }
-            }
-            if (!valid) {
-                abort_link_to_text(state, link_stack_idx, bracket_pos);
-                return true;
-            }
-            // Reject unsafe protocols (javascript:, data:, etc.) at parse time.
-            // `is_valid_path_char` permits `:` so we have to filter explicitly.
-            if (!mdz_is_safe_reference(reference)) {
-                abort_link_to_text(state, link_stack_idx, bracket_pos);
-                return true;
-            }
-            // success — close the link with reference
-            flush_text(state);
-            revert_above(state, link_stack_idx);
-            const entry = pop_stack_entry(state);
-            const link_type = mdz_is_url(reference) ? 'external' : 'internal';
-            emit(state, {
-                type: 'close',
-                id: entry.id,
-                end: offset(state, i + 1),
-                reference,
-                link_type,
-            });
-            state.active_text_id = null;
-            state.pos = i + 1;
-            state.column += i + 1 - bracket_pos;
-            state.prev_char = RIGHT_PAREN;
+    // found ]( — find the reference's terminator: `)` completes, a space or
+    // newline aborts. Memoized searches (see `buffer_index_of`) — a link whose
+    // URL arrives incrementally re-enters here on every feed with `pos` still
+    // at the `]`, and a raw scan would re-cover the growing reference each
+    // time, going quadratic on long streamed URLs.
+    const ref_start = bracket_pos + 2;
+    const close_pos = buffer_index_of(state, ')', ref_start);
+    const space_pos = buffer_index_of(state, ' ', ref_start);
+    const newline_pos = buffer_index_of(state, '\n', ref_start);
+    let invalid_pos = space_pos;
+    if (newline_pos !== -1 && (invalid_pos === -1 || newline_pos < invalid_pos)) {
+        invalid_pos = newline_pos;
+    }
+    if (close_pos === -1) {
+        // didn't find ) — need more input or invalid
+        if (invalid_pos === -1)
+            return false; // need more input
+        // found invalid char before any ) — revert
+        abort_link_to_text(state, link_stack_idx, bracket_pos);
+        return true;
+    }
+    if (invalid_pos !== -1 && invalid_pos < close_pos) {
+        // invalid character in URL (simplified check)
+        abort_link_to_text(state, link_stack_idx, bracket_pos);
+        return true;
+    }
+    const i = close_pos;
+    const reference = state.buffer.slice(ref_start, i);
+    // validate reference: non-empty and only valid path chars
+    if (!reference.trim()) {
+        abort_link_to_text(state, link_stack_idx, bracket_pos);
+        return true;
+    }
+    for (let j = 0; j < reference.length; j++) {
+        if (!is_valid_path_char(reference.charCodeAt(j))) {
+            abort_link_to_text(state, link_stack_idx, bracket_pos);
             return true;
         }
-        if (c === NEWLINE || c === SPACE) {
-            // invalid character in URL (simplified check)
-            break;
-        }
-        i++;
     }
-    // didn't find ) — need more input or invalid
-    if (i >= state.buffer.length)
-        return false; // need more input
-    // found invalid char before ) — revert
-    abort_link_to_text(state, link_stack_idx, bracket_pos);
+    // Reject unsafe protocols (javascript:, data:, etc.) at parse time.
+    // `is_valid_path_char` permits `:` so we have to filter explicitly.
+    if (!mdz_is_safe_reference(reference)) {
+        abort_link_to_text(state, link_stack_idx, bracket_pos);
+        return true;
+    }
+    // success — close the link with reference
+    flush_text(state);
+    revert_above(state, link_stack_idx);
+    const entry = pop_stack_entry(state);
+    const link_type = mdz_is_url(reference) ? 'external' : 'internal';
+    emit(state, {
+        type: 'close',
+        id: entry.id,
+        end: offset(state, i + 1),
+        reference,
+        link_type,
+    });
+    state.active_text_id = null;
+    state.pos = i + 1;
+    state.column += i + 1 - bracket_pos;
+    state.prev_char = RIGHT_PAREN;
     return true;
 };
 // -- Tags --
@@ -129,7 +142,18 @@ export const try_tag_open = (state) => {
     if (!is_letter(state.buffer.charCodeAt(i))) {
         return 'not_match';
     }
+    // nesting-depth cap: `<letter…` is a tag open, but we're too deep to nest —
+    // render `<` literal, matching the sync lexer's `#tokenize_tag` cap. Checked
+    // after the closer/hold cases above (a `</…>` closer still closes; a `<` at
+    // the buffer end still holds), so only genuine opens are suppressed.
+    if (state.open_link_tag_depth >= MAX_INLINE_NESTING_DEPTH) {
+        consume_delimiter_as_text(state, '<');
+        return 'consumed';
+    }
     // collect tag name
+    // TODO the name/whitespace scans rescan from `start` on every held retry
+    // of an unclosed tag's open tail — needs a hold watermark; a length cap would
+    // diverge from the sync parser on pathological multi-KB "tag names"
     const name_start = i;
     while (i < state.buffer.length && is_tag_name_char(state.buffer.charCodeAt(i))) {
         i++;
@@ -201,9 +225,17 @@ export const try_close_tag = (state) => {
         return 'not_match';
     const name = state.buffer.slice(name_start, i);
     i++; // past >
+    // O(1) bail when no tag of this name is open — without it, every `</name>`
+    // candidate walks the whole inline stack, which grows one frame per leaked
+    // unclosed `<Tag>` and goes quadratic on tag-dense input (the same shape
+    // `open_counts` guards for the delimiter inlines)
+    if (!state.open_tag_counts?.get(name))
+        return 'not_match';
     // find matching open tag on stack
     let found_idx = -1;
     for (let j = state.stack.length - 1; j >= 0; j--) {
+        if (mdz_debug_work.enabled)
+            mdz_debug_work.total++; // frames walked (mismatched-tags guard)
         const entry = state.stack[j];
         if ((entry.node_type === 'Element' || entry.node_type === 'Component') &&
             entry.tag_name === name) {

package/dist/mdz_stream_parser_list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_list.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAmBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAad,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CACf;AAoBD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,mBAAmB,GAAG,SAAS,GAAG,IAsDpC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,oBAAoB,GAAG,SAAS,GAAG,IAuBrC,CAAC;AAgGF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAY7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,QAAQ,OAAO,KACb,OAAO,GAAG,YA+LZ,CAAC"}
+{"version":3,"file":"mdz_stream_parser_list.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAmBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAad,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CACf;AAoBD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,mBAAmB,GAAG,SAAS,GAAG,IAsDpC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,oBAAoB,GAAG,SAAS,GAAG,IAuBrC,CAAC;AAgGF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAY7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,QAAQ,OAAO,KACb,OAAO,GAAG,YAqMZ,CAAC"}

package/dist/mdz_stream_parser_list.js

@@ -334,8 +334,16 @@ export const process_list_line = (state, forced) => {
     }
     if (marker !== null && marker.empty) {
         // empty item: only at an indent exactly matching an open level of the
-        // same marker type — anything else degrades below
-        const level_idx = state.list_levels.findIndex((l) => l.indent === indent && l.ordered === marker.ordered);
+        // same marker type — anything else degrades below (manual loop like
+        // `list_continuation_target` — no per-line closure allocation)
+        let level_idx = -1;
+        for (let li = 0; li < state.list_levels.length; li++) {
+            const l = state.list_levels[li];
+            if (l.indent === indent && l.ordered === marker.ordered) {
+                level_idx = li;
+                break;
+            }
+        }
         if (level_idx !== -1) {
             close_list_run(state);
             while (state.list_levels.length - 1 > level_idx) {