@fuzdev/mdz 0.2.0 → 0.4.0

package/dist/mdz_opcodes_to_nodes.js

@@ -44,7 +44,7 @@ export const mdz_opcodes_to_nodes = (opcodes) => {
                     start_number: op.start_number,
                     number: op.number,
                     align: op.align,
-                    header: op.header,
+                    header: op.header
                 });
                 break;
             }
@@ -180,7 +180,7 @@ export const mdz_opcodes_to_nodes = (opcodes) => {
                         type: 'Text',
                         content: trimmed_content,
                         start: text_node.end,
-                        end: text_node.end + trimmed_content.length,
+                        end: text_node.end + trimmed_content.length
                     };
                     text_nodes.set(op.trim_id, trimmed_node);
                 }
@@ -191,7 +191,7 @@ export const mdz_opcodes_to_nodes = (opcodes) => {
                     children: [text_node],
                     link_type: op.link_type,
                     start: op.start,
-                    end: op.end,
+                    end: op.end
                 };
                 // replace text node with [Link, trimmed?] in the buffer
                 if (trimmed_node) {
@@ -250,7 +250,12 @@ const insert_replacement = (children, stack, reverted_idx, at, op) => {
         }
     }
     // 3. standalone Text node
-    const node = { type: 'Text', content: text, start: op.start, end: op.start + text.length };
+    const node = {
+        type: 'Text',
+        content: text,
+        start: op.start,
+        end: op.start + text.length
+    };
     if (at >= children.length) {
         children.push(node);
     }
@@ -284,7 +289,7 @@ const build_node = (frame, frame_children) => {
                 type: 'Paragraph',
                 children,
                 start: children[0].start,
-                end: children[children.length - 1].end,
+                end: children[children.length - 1].end
             };
         }
         case 'Heading': {
@@ -296,7 +301,7 @@ const build_node = (frame, frame_children) => {
                 id,
                 children,
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         }
         case 'Bold':
@@ -304,21 +309,21 @@ const build_node = (frame, frame_children) => {
                 type: 'Bold',
                 children: mdz_merge_adjacent_text(frame_children),
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         case 'Italic':
             return {
                 type: 'Italic',
                 children: mdz_merge_adjacent_text(frame_children),
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         case 'Strikethrough':
             return {
                 type: 'Strikethrough',
                 children: mdz_merge_adjacent_text(frame_children),
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         case 'Link':
             return {
@@ -327,7 +332,7 @@ const build_node = (frame, frame_children) => {
                 children: mdz_merge_adjacent_text(frame_children),
                 link_type: frame.link_type ?? 'internal',
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         case 'List': {
             // items are the only possible children; `end` derives from the last
@@ -341,7 +346,7 @@ const build_node = (frame, frame_children) => {
                     start_number: frame.start_number ?? 1,
                     children,
                     start: frame.start,
-                    end,
+                    end
                 };
             }
             return { type: 'List', ordered: false, children, start: frame.start, end };
@@ -375,7 +380,7 @@ const build_node = (frame, frame_children) => {
                 header: frame.header ?? false,
                 children,
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         }
         case 'TableCell':
@@ -383,7 +388,7 @@ const build_node = (frame, frame_children) => {
                 type: 'TableCell',
                 children: mdz_merge_adjacent_text(frame_children),
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         case 'Code': {
             // optimistic inline code container — concatenate children text into leaf MdzNodeCode
@@ -396,7 +401,7 @@ const build_node = (frame, frame_children) => {
                 type: 'Code',
                 content,
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         }
         case 'Codeblock': {
@@ -411,7 +416,7 @@ const build_node = (frame, frame_children) => {
                 lang: frame.lang ?? null,
                 content,
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         }
         case 'Element':
@@ -420,7 +425,7 @@ const build_node = (frame, frame_children) => {
                 name: frame.name ?? '',
                 children: mdz_merge_adjacent_text(frame_children),
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         case 'Component':
             return {
@@ -428,7 +433,7 @@ const build_node = (frame, frame_children) => {
                 name: frame.name ?? '',
                 children: mdz_merge_adjacent_text(frame_children),
                 start: frame.start,
-                end: frame.end,
+                end: frame.end
             };
         default:
             return null;

package/dist/mdz_stream_parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAiFhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,eAAe;;IAG3B;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,YAAY,IAAI,KAAK,CAAC,SAAS,CAAC;CAKhC"}
+{"version":3,"file":"mdz_stream_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAiFlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,eAAe;;IAG3B;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,YAAY,IAAI,KAAK,CAAC,SAAS,CAAC;CAKhC"}

package/dist/mdz_stream_parser.js

@@ -34,14 +34,14 @@
  *
  * @module
  */
-import { BACKTICK, ASTERISK, UNDERSCORE, TILDE, NEWLINE, HYPHEN, HASH, PIPE, LEFT_ANGLE, RIGHT_ANGLE, SLASH, LEFT_BRACKET, RIGHT_BRACKET, H_LOWER, H_UPPER, PERIOD, SPACE, ZERO, NINE, is_word_char, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, mdz_blockquote_strip_width, mdz_remap_segments, } from './mdz_helpers.js';
-import { accumulate_text, alloc_id, close_all_list_levels, close_codeblock_at_eof, close_heading, close_paragraph, create_state, emit, find_open, flush_text, handle_paragraph_break, offset, pop_stack_entry, push_stack_entry, revert_failed_close, } from './mdz_stream_parser_state.js';
-import { process_codeblock, process_codeblock_forced, process_codeblock_in_item, try_codeblock_open, try_heading, try_hr, } from './mdz_stream_parser_block.js';
+import { BACKTICK, ASTERISK, UNDERSCORE, TILDE, NEWLINE, HYPHEN, HASH, PIPE, LEFT_ANGLE, RIGHT_ANGLE, SLASH, LEFT_BRACKET, RIGHT_BRACKET, H_LOWER, H_UPPER, PERIOD, SPACE, ZERO, NINE, is_word_char, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, mdz_blockquote_strip_width, mdz_remap_segments } from './mdz_helpers.js';
+import { accumulate_text, alloc_id, close_all_list_levels, close_codeblock_at_eof, close_heading, close_paragraph, create_state, emit, find_open, flush_text, handle_paragraph_break, offset, pop_stack_entry, push_stack_entry, revert_failed_close } from './mdz_stream_parser_state.js';
+import { process_codeblock, process_codeblock_forced, process_codeblock_in_item, try_codeblock_open, try_heading, try_hr } from './mdz_stream_parser_block.js';
 import { process_list_line, try_list_start } from './mdz_stream_parser_list.js';
 import { close_table, process_table_line, try_table_start } from './mdz_stream_parser_table.js';
-import { check_close_word_boundary, close_delimiter, process_code_content, try_code, try_double_delimiter, try_italic, } from './mdz_stream_parser_inline.js';
-import { try_close_tag, try_complete_link, try_link_open, try_tag_open, } from './mdz_stream_parser_link.js';
-import { complete_pending_url, process_url_content, start_speculative_url, try_auto_path_absolute, try_auto_path_relative, try_auto_url_forced, } from './mdz_stream_parser_url.js';
+import { check_close_word_boundary, close_delimiter, process_code_content, try_code, try_double_delimiter, try_italic } from './mdz_stream_parser_inline.js';
+import { try_close_tag, try_complete_link, try_link_open, try_tag_open } from './mdz_stream_parser_link.js';
+import { complete_pending_url, process_url_content, start_speculative_url, try_auto_path_absolute, try_auto_path_relative, try_auto_url_forced } from './mdz_stream_parser_url.js';
 import { consume_delimiter_as_text, consume_text_run } from './mdz_stream_parser_text.js';
 /**
  * Streaming opcode parser for mdz content.
@@ -207,7 +207,7 @@ const open_blockquote = (state, item_indent) => {
         segments: [{ inner_start: 0, source_start: offset(state, strip) }],
         inner_len: 0,
         text_inner_ends: new Map(),
-        item_indent,
+        item_indent
     };
     state.pos = strip;
     state.prev_char = SPACE;
@@ -361,7 +361,7 @@ const process_blockquote = (state, forced) => {
             const strip = first + mdz_blockquote_strip_width(buffer, first);
             blockquote.segments.push({
                 inner_start: blockquote.inner_len,
-                source_start: offset(state, strip),
+                source_start: offset(state, strip)
             });
             state.pos = strip;
             state.column = strip - line_start;

package/dist/mdz_stream_parser_block.js

@@ -6,8 +6,8 @@
  *
  * @module
  */
-import { BACKTICK, HASH, HR_HYPHEN_COUNT, HYPHEN, MAX_HEADING_LEVEL, MIN_CODEBLOCK_BACKTICKS, NEWLINE, SPACE, is_line_whitespace, } from './mdz_helpers.js';
-import { alloc_id, close_paragraph, emit, flush_text, offset, push_stack_entry, } from './mdz_stream_parser_state.js';
+import { BACKTICK, HASH, HR_HYPHEN_COUNT, HYPHEN, MAX_HEADING_LEVEL, MIN_CODEBLOCK_BACKTICKS, NEWLINE, SPACE, is_line_whitespace } from './mdz_helpers.js';
+import { alloc_id, close_paragraph, emit, flush_text, offset, push_stack_entry } from './mdz_stream_parser_state.js';
 /**
  * Try to parse a heading at column 0.
  *
@@ -55,7 +55,7 @@ export const try_heading = (state) => {
         id,
         node_type: 'Heading',
         start: heading_start,
-        level: hash_count,
+        level: hash_count
     });
     push_stack_entry(state, id, 'Heading', heading_start);
     state.in_heading = true;
@@ -103,7 +103,7 @@ export const try_hr = (state, forced = false) => {
         id,
         node_type: 'Hr',
         start: offset(state, start),
-        end: offset(state, i),
+        end: offset(state, i)
     });
     // `i` sits at the line's newline, or at the buffer end — in forced mode
     // always the buffer end (a newline would have resolved this line during
@@ -193,7 +193,7 @@ export const emit_codeblock_text = (state, cb, content, content_start) => {
             content,
             text_type: 'Text',
             start: text_start,
-            end: text_start + content.length,
+            end: text_start + content.length
         });
         cb.text_id = id;
     }

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

@@ -4,8 +4,8 @@
  *
  * @module
  */
-import { BACKTICK, NEWLINE, RIGHT_ANGLE, UNDERSCORE, is_line_whitespace, is_word_char, mdz_blockquote_line_has_content, mdz_match_blockquote_prefix, } 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 { BACKTICK, NEWLINE, RIGHT_ANGLE, UNDERSCORE, is_line_whitespace, is_word_char, mdz_blockquote_line_has_content, mdz_match_blockquote_prefix } 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 { match_fence_opener, match_list_marker } from './mdz_stream_parser_list.js';
 import { consume_delimiter_as_text } from './mdz_stream_parser_text.js';
 /**
@@ -236,7 +236,7 @@ export const close_delimiter = (state, stack_idx) => {
             type: 'revert',
             id: entry.id,
             replacement_text: delimiter,
-            start: entry.start,
+            start: entry.start
         });
         accumulate_text(state, delimiter, offset(state));
     }
@@ -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,YA2MZ,CAAC"}

package/dist/mdz_stream_parser_list.js

@@ -12,9 +12,9 @@
  *
  * @module
  */
-import { BACKTICK, HYPHEN, MAX_LIST_NUMBER_DIGITS, MIN_CODEBLOCK_BACKTICKS, NEWLINE, NINE, PERIOD, PIPE, RIGHT_ANGLE, SPACE, ZERO, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, } from './mdz_helpers.js';
+import { BACKTICK, HYPHEN, MAX_LIST_NUMBER_DIGITS, MIN_CODEBLOCK_BACKTICKS, NEWLINE, NINE, PERIOD, PIPE, RIGHT_ANGLE, SPACE, ZERO, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content } from './mdz_helpers.js';
 import { match_table_in_item_head, open_table_in_item } from './mdz_stream_parser_table.js';
-import { accumulate_text, alloc_id, close_all_list_levels, close_list_item, close_list_level, close_list_run, close_paragraph, emit, extend_accumulated_end, flush_text, offset, push_stack_entry, } from './mdz_stream_parser_state.js';
+import { accumulate_text, alloc_id, close_all_list_levels, close_list_item, close_list_level, close_list_run, close_paragraph, emit, extend_accumulated_end, flush_text, offset, push_stack_entry } from './mdz_stream_parser_state.js';
 /**
  * Whether only line whitespace remains between `from` and the line's end —
  * `'pending'` when the buffer ends inside the run while streaming (the line
@@ -53,7 +53,7 @@ export const match_list_marker = (state, i, forced) => {
                 start: i,
                 marker_end: after,
                 content_start: after,
-                empty: true,
+                empty: true
             };
         }
         // in bounds: `blank === false` means the scan found a char at or past `after`
@@ -88,7 +88,7 @@ export const match_list_marker = (state, i, forced) => {
                 start: i,
                 marker_end: after,
                 content_start: after,
-                empty: true,
+                empty: true
             };
         }
         // in bounds: `blank === false` means the scan found a char at or past `after`
@@ -168,7 +168,7 @@ const open_list_level = (state, indent, marker) => {
             node_type: 'List',
             start,
             ordered: true,
-            start_number: marker.number,
+            start_number: marker.number
         });
     }
     else {
@@ -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) {
@@ -370,13 +378,19 @@ export const process_list_line = (state, forced) => {
                 }
                 const id = alloc_id(state);
                 const cb_start = offset(state, j);
-                emit(state, { type: 'open', id, node_type: 'Codeblock', start: cb_start, lang: fence.lang });
+                emit(state, {
+                    type: 'open',
+                    id,
+                    node_type: 'Codeblock',
+                    start: cb_start,
+                    lang: fence.lang
+                });
                 state.codeblock = {
                     id,
                     backtick_count: fence.backtick_count,
                     text_id: null,
                     fence_indent: indent,
-                    start: cb_start,
+                    start: cb_start
                 };
                 state.active_text_id = null;
                 state.pos = fence.content_start;