@fuzdev/mdz 0.2.0 → 0.4.0

package/src/lib/mdz_stream_parser_link.ts

@@ -5,12 +5,12 @@
  * @module
  */
 
-import type {MdzNodeTypeContainer} from './mdz_opcodes.ts';
+import type { MdzNodeTypeContainer } from './mdz_opcodes.ts';
 import {
 	A_UPPER,
 	LEFT_BRACKET,
 	LEFT_PAREN,
-	NEWLINE,
+	MAX_INLINE_NESTING_DEPTH,
 	RIGHT_ANGLE,
 	RIGHT_BRACKET,
 	RIGHT_PAREN,
@@ -21,13 +21,14 @@ import {
 	is_tag_name_char,
 	is_valid_path_char,
 	mdz_is_safe_reference,
-	mdz_is_url,
+	mdz_is_url
 } from './mdz_helpers.ts';
 import {
 	type MdzStreamParserState,
 	type TryResult,
 	accumulate_text,
 	alloc_id,
+	buffer_index_of,
 	emit,
 	ensure_paragraph,
 	flush_text,
@@ -35,19 +36,28 @@ import {
 	offset,
 	pop_stack_entry,
 	push_stack_entry,
-	revert_above,
+	revert_above
 } from './mdz_stream_parser_state.ts';
+import { consume_delimiter_as_text } from './mdz_stream_parser_text.ts';
+import { mdz_debug_work } from './mdz_debug_work.ts';
 
 // -- Links --
 
 /** @nodocs */
 export const try_link_open = (state: MdzStreamParserState): boolean => {
+	// 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);
 	const link_start = offset(state);
-	emit(state, {type: 'open', id, node_type: 'Link', start: link_start});
+	emit(state, { type: 'open', id, node_type: 'Link', start: link_start });
 	push_stack_entry(state, id, 'Link', link_start, '[');
 	state.active_text_id = null;
 	state.pos++;
@@ -66,12 +76,12 @@ export const try_link_open = (state: MdzStreamParserState): boolean => {
 export const abort_link_to_text = (
 	state: MdzStreamParserState,
 	link_stack_idx: number,
-	bracket_pos: number,
+	bracket_pos: number
 ): void => {
 	flush_text(state);
 	revert_above(state, link_stack_idx);
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'revert', id: entry.id, replacement_text: '[', start: entry.start});
+	emit(state, { type: 'revert', id: entry.id, replacement_text: '[', start: entry.start });
 	state.active_text_id = null;
 	accumulate_text(state, ']', offset(state, bracket_pos));
 	state.pos = bracket_pos + 1;
@@ -97,65 +107,69 @@ export const try_complete_link = (state: MdzStreamParserState, link_stack_idx: n
 		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++;
+	}
+	// 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;
 	}
 
-	// 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);
+	// 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;
 };
 
@@ -176,7 +190,19 @@ export const try_tag_open = (state: MdzStreamParserState): TryResult => {
 		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++;
@@ -204,8 +230,8 @@ export const try_tag_open = (state: MdzStreamParserState): TryResult => {
 		ensure_paragraph(state);
 		const id = alloc_id(state);
 		const tag_start = offset(state, start);
-		emit(state, {type: 'open', id, node_type, start: tag_start, name});
-		emit(state, {type: 'close', id, end: offset(state, i + 2)});
+		emit(state, { type: 'open', id, node_type, start: tag_start, name });
+		emit(state, { type: 'close', id, end: offset(state, i + 2) });
 		state.active_text_id = null;
 		state.pos = i + 2;
 		state.column += i + 2 - start;
@@ -228,7 +254,7 @@ export const try_tag_open = (state: MdzStreamParserState): TryResult => {
 	const id = alloc_id(state);
 	const tag_start = offset(state, start);
 	const delimiter = state.buffer.slice(start, i); // e.g., "<Alert>"
-	emit(state, {type: 'open', id, node_type, start: tag_start, name});
+	emit(state, { type: 'open', id, node_type, start: tag_start, name });
 	push_stack_entry(state, id, node_type, tag_start, delimiter, name);
 	state.active_text_id = null;
 	state.pos = i;
@@ -255,9 +281,16 @@ export const try_close_tag = (state: MdzStreamParserState): TryResult => {
 	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') &&
@@ -274,7 +307,7 @@ export const try_close_tag = (state: MdzStreamParserState): TryResult => {
 	flush_text(state);
 	revert_above(state, found_idx);
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state, i)});
+	emit(state, { type: 'close', id: entry.id, end: offset(state, i) });
 	state.active_text_id = null;
 	state.column += i - state.pos;
 	state.pos = i;

package/src/lib/mdz_stream_parser_list.ts

@@ -27,9 +27,9 @@ import {
 	ZERO,
 	is_line_whitespace,
 	mdz_match_blockquote_prefix,
-	mdz_blockquote_line_has_content,
+	mdz_blockquote_line_has_content
 } from './mdz_helpers.ts';
-import {match_table_in_item_head, open_table_in_item} from './mdz_stream_parser_table.ts';
+import { match_table_in_item_head, open_table_in_item } from './mdz_stream_parser_table.ts';
 import {
 	type MdzStreamParserState,
 	type TryResult,
@@ -44,7 +44,7 @@ import {
 	extend_accumulated_end,
 	flush_text,
 	offset,
-	push_stack_entry,
+	push_stack_entry
 } from './mdz_stream_parser_state.ts';
 
 /**
@@ -76,7 +76,7 @@ export interface MdzStreamListMarker {
 const rest_is_blank = (
 	state: MdzStreamParserState,
 	from: number,
-	forced: boolean,
+	forced: boolean
 ): boolean | 'pending' => {
 	let i = from;
 	while (i < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(i))) {
@@ -98,9 +98,9 @@ const rest_is_blank = (
 export const match_list_marker = (
 	state: MdzStreamParserState,
 	i: number,
-	forced: boolean,
+	forced: boolean
 ): MdzStreamListMarker | 'pending' | null => {
-	const {buffer} = state;
+	const { buffer } = state;
 	const c = buffer.charCodeAt(i);
 	if (c === HYPHEN) {
 		const after = i + 1;
@@ -113,7 +113,7 @@ export const match_list_marker = (
 				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`
@@ -121,7 +121,7 @@ export const match_list_marker = (
 		const content_start = after + 1;
 		const empty = rest_is_blank(state, content_start, forced);
 		if (empty === 'pending') return 'pending';
-		return {ordered: false, number: 0, start: i, marker_end: after, content_start, empty};
+		return { ordered: false, number: 0, start: i, marker_end: after, content_start, empty };
 	}
 	if (c >= ZERO && c <= NINE) {
 		let j = i + 1;
@@ -142,7 +142,7 @@ export const match_list_marker = (
 				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`
@@ -150,7 +150,7 @@ export const match_list_marker = (
 		const content_start = after + 1;
 		const empty = rest_is_blank(state, content_start, forced);
 		if (empty === 'pending') return 'pending';
-		return {ordered: true, number, start: i, marker_end: after, content_start, empty};
+		return { ordered: true, number, start: i, marker_end: after, content_start, empty };
 	}
 	return null;
 };
@@ -179,9 +179,9 @@ export interface MdzStreamFenceOpener {
 export const match_fence_opener = (
 	state: MdzStreamParserState,
 	i: number,
-	forced: boolean,
+	forced: boolean
 ): MdzStreamFenceOpener | 'pending' | null => {
-	const {buffer} = state;
+	const { buffer } = state;
 	let j = i;
 	let count = 0;
 	while (j < buffer.length && buffer.charCodeAt(j) === BACKTICK) {
@@ -202,7 +202,7 @@ export const match_fence_opener = (
 	}
 	if (j >= buffer.length) return forced ? null : 'pending'; // the opener needs its newline
 	if (buffer.charCodeAt(j) !== NEWLINE) return null;
-	return {backtick_count: count, lang, content_start: j + 1};
+	return { backtick_count: count, lang, content_start: j + 1 };
 };
 
 /** Emit a `ListItem` open for `marker` and push its frame. */
@@ -210,9 +210,9 @@ const open_list_item = (state: MdzStreamParserState, marker: MdzStreamListMarker
 	const id = alloc_id(state);
 	const start = offset(state, marker.start);
 	if (marker.ordered) {
-		emit(state, {type: 'open', id, node_type: 'ListItem', start, number: marker.number});
+		emit(state, { type: 'open', id, node_type: 'ListItem', start, number: marker.number });
 	} else {
-		emit(state, {type: 'open', id, node_type: 'ListItem', start});
+		emit(state, { type: 'open', id, node_type: 'ListItem', start });
 	}
 	push_stack_entry(state, id, 'ListItem', start);
 	if (marker.empty) {
@@ -226,7 +226,7 @@ const open_list_item = (state: MdzStreamParserState, marker: MdzStreamListMarker
 const open_list_level = (
 	state: MdzStreamParserState,
 	indent: number,
-	marker: MdzStreamListMarker,
+	marker: MdzStreamListMarker
 ): void => {
 	const id = alloc_id(state);
 	const start = offset(state, marker.start);
@@ -237,14 +237,14 @@ const open_list_level = (
 			node_type: 'List',
 			start,
 			ordered: true,
-			start_number: marker.number,
+			start_number: marker.number
 		});
 	} else {
-		emit(state, {type: 'open', id, node_type: 'List', start, ordered: false});
+		emit(state, { type: 'open', id, node_type: 'List', start, ordered: false });
 	}
 	push_stack_entry(state, id, 'List', start);
 	open_list_item(state, marker);
-	state.list_levels.push({indent, ordered: marker.ordered});
+	state.list_levels.push({ indent, ordered: marker.ordered });
 };
 
 /**
@@ -256,7 +256,7 @@ const open_list_level = (
 const begin_item_run = (
 	state: MdzStreamParserState,
 	marker: MdzStreamListMarker,
-	line_start: number,
+	line_start: number
 ): void => {
 	let i = marker.content_start;
 	while (i < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(i))) {
@@ -289,7 +289,7 @@ const list_continuation_target = (state: MdzStreamParserState, indent: number):
 const continue_run = (
 	state: MdzStreamParserState,
 	nl_pos: number,
-	content_pos: number,
+	content_pos: number
 ): boolean => {
 	accumulate_text(state, '\n', offset(state, nl_pos));
 	extend_accumulated_end(state, offset(state, content_pos));
@@ -352,9 +352,9 @@ export const try_list_start = (state: MdzStreamParserState, forced: boolean): Tr
  */
 export const process_list_line = (
 	state: MdzStreamParserState,
-	forced: boolean,
+	forced: boolean
 ): boolean | 'blockquote' => {
-	const {buffer} = state;
+	const { buffer } = state;
 	const nl_pos = state.pos;
 	const line_start = nl_pos + 1;
 	let j = line_start;
@@ -418,10 +418,16 @@ export const process_list_line = (
 
 	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) {
@@ -456,13 +462,19 @@ export const process_list_line = (
 				}
 				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;