@fuzdev/mdz 0.1.0 → 0.3.0

package/src/lib/mdz_lexer.ts

@@ -38,6 +38,7 @@ import {
 	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,
@@ -47,7 +48,18 @@ import {
 	mdz_blockquote_line_has_content,
 	mdz_blockquote_strip_width,
 	mdz_remap_segments,
-} from './mdz_helpers.js';
+	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.ts';
+
+import type {MdzTableAlign} from './mdz.ts';
+import {mdz_debug_work} from './mdz_debug_work.ts';
 
 //
 // Token types
@@ -84,7 +96,13 @@ export type MdzToken =
 	| MdzTokenListItemOpen
 	| MdzTokenListItemClose
 	| MdzTokenBlockquoteOpen
-	| MdzTokenBlockquoteClose;
+	| MdzTokenBlockquoteClose
+	| MdzTokenTableOpen
+	| MdzTokenTableClose
+	| MdzTokenTableRowOpen
+	| MdzTokenTableRowClose
+	| MdzTokenTableCellOpen
+	| MdzTokenTableCellClose;
 
 export interface MdzTokenText extends MdzTokenBase {
 	type: 'text';
@@ -207,6 +225,34 @@ export interface MdzTokenBlockquoteClose extends MdzTokenBase {
 	type: 'blockquote_close';
 }
 
+export interface MdzTokenTableOpen extends MdzTokenBase {
+	type: 'table_open';
+	/** Per-column alignment from the delimiter row; length is the column count. */
+	align: Array<MdzTableAlign>;
+}
+
+export interface MdzTokenTableClose extends MdzTokenBase {
+	type: 'table_close';
+}
+
+export interface MdzTokenTableRowOpen extends MdzTokenBase {
+	type: 'table_row_open';
+	/** `true` for the header row, `false` for body rows. */
+	header: boolean;
+}
+
+export interface MdzTokenTableRowClose extends MdzTokenBase {
+	type: 'table_row_close';
+}
+
+export interface MdzTokenTableCellOpen extends MdzTokenBase {
+	type: 'table_cell_open';
+}
+
+export interface MdzTokenTableCellClose extends MdzTokenBase {
+	type: 'table_cell_close';
+}
+
 /**
  * A matched list marker: `- ` (unordered) or `N. ` (ordered, 1-9 digits).
  * `empty` markers have nothing but whitespace after the marker — valid only
@@ -258,11 +304,75 @@ export class MdzLexer {
 	 * scanner pre-validated every line in the run as continuation).
 	 */
 	#list_run_strip: boolean = false;
+	/**
+	 * Whether `#tokenize_text` is inside a table cell: `#max_search_index` is a
+	 * hard stop (the cell's trimmed end, mid-line with no newline to halt on)
+	 * and `\|` unescapes to a literal pipe.
+	 */
+	#in_table_cell: boolean = 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: Set<number> = 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: Set<string> = 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: number = 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: Set<number> = new Set();
 
 	constructor(text: string) {
 		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: string): void {
+		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.
 	 *
@@ -279,6 +389,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});
 		} else {
@@ -300,6 +414,7 @@ export class MdzLexer {
 				if (this.#tokenize_codeblock()) continue;
 				if (this.#tokenize_list()) continue;
 				if (this.#tokenize_blockquote()) continue;
+				if (this.#tokenize_table()) continue;
 			}
 
 			// Check for paragraph break
@@ -317,6 +432,25 @@ export class MdzLexer {
 		return this.#tokens;
 	}
 
+	/**
+	 * Tokenize a table cell's inline content `[cell_start, cell_end)` as a
+	 * bounded inline run, with no wrapping cell tokens (the bare form of
+	 * `#emit_table_cell`, sharing `#tokenize_cell_inline`). The streaming parser
+	 * reuses it across a row's cells via `MdzTableCellParser`: the token buffer
+	 * resets per call while the search memo — valid over the immutable bound
+	 * text — carries across cells (the same reuse the sync lexer does in place).
+	 *
+	 * @nodocs
+	 */
+	lex_table_cell(cell_start: number, cell_end: number): Array<MdzToken> {
+		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;
+	}
+
 	#is_at_column_0(): boolean {
 		return this.#index === 0 || this.#text.charCodeAt(this.#index - 1) === NEWLINE;
 	}
@@ -604,6 +738,163 @@ export class MdzLexer {
 		this.#index = last_line_end;
 	}
 
+	// -- Table tokenizers --
+
+	/**
+	 * Tokenize a table starting at a column-0 pipe row, emitting
+	 * `table_open`/`table_row_open`/`table_cell_open` … structure tokens (the
+	 * header row's cells first, then each body row's). Returns false with no
+	 * side effects when the current line isn't a table: not a `| … |` row, or
+	 * not followed by a delimiter row whose column count matches the header. The
+	 * delimiter row's colons set `align`; body rows continue until a blank line,
+	 * a non-pipe-row line, or EOF.
+	 */
+	#tokenize_table(): boolean {
+		const table_start = this.#index;
+		let header_end = this.#index_of('\n', this.#index);
+		if (header_end === -1) header_end = this.#text.length;
+		const header_cells = mdz_split_table_row(this.#text, this.#index, header_end);
+		if (header_cells === null) return false;
+		if (header_end >= this.#text.length) return false; // a header needs a delimiter row beneath it
+		const delim_start = header_end + 1;
+		let delim_end = this.#index_of('\n', delim_start);
+		if (delim_end === -1) delim_end = this.#text.length;
+		const align = mdz_parse_table_delimiter(this.#text, delim_start, delim_end);
+		if (align === null || align.length !== header_cells.length) return false;
+
+		// committed — emit the table; the delimiter row is structural (not emitted)
+		this.#tokens.push({type: 'table_open', align, start: table_start, end: header_end});
+		this.#emit_table_row(header_cells, true, table_start, header_end);
+
+		this.#index = delim_end;
+		let table_end = delim_end;
+
+		// body rows: consecutive valid pipe rows, until a blank/non-row line or EOF
+		while (this.#index < this.#text.length) {
+			const row_start = this.#index + 1; // past the newline at #index
+			let row_end = this.#index_of('\n', row_start);
+			if (row_end === -1) row_end = this.#text.length;
+			const cells = mdz_split_table_row(this.#text, row_start, row_end);
+			if (cells === null) break;
+			this.#emit_table_row(cells, false, row_start, row_end);
+			this.#index = row_end;
+			table_end = row_end;
+		}
+
+		this.#tokens.push({type: 'table_close', start: table_end, end: table_end});
+		this.#skip_blank_lines();
+		return true;
+	}
+
+	/** Emit one table row's open / cell / close tokens. */
+	#emit_table_row(
+		cells: Array<{start: number; end: number}>,
+		header: boolean,
+		row_start: number,
+		row_end: number,
+	): void {
+		this.#tokens.push({type: 'table_row_open', header, start: row_start, end: row_start});
+		for (const cell of cells) {
+			this.#emit_table_cell(cell.start, cell.end);
+		}
+		this.#tokens.push({type: 'table_row_close', start: row_end, end: row_end});
+	}
+
+	/**
+	 * Emit one cell's `table_cell_open`, inline-content tokens, and
+	 * `table_cell_close`. Inline tokenization is bounded to the cell's trimmed
+	 * span via `#max_search_index`, with `#in_table_cell` set so `#tokenize_text`
+	 * stops at that bound and unescapes `\|`.
+	 */
+	#emit_table_cell(cell_start: number, cell_end: number): void {
+		this.#tokens.push({type: 'table_cell_open', start: cell_start, end: cell_start});
+		this.#tokenize_cell_inline(cell_start, cell_end);
+		this.#tokens.push({type: 'table_cell_close', start: cell_end, end: cell_end});
+	}
+
+	/**
+	 * Tokenize a cell's trimmed inline span `[cell_start, cell_end)` into the
+	 * current token buffer, bounded by `#max_search_index` with `#in_table_cell`
+	 * set so `#tokenize_text` stops at the bound and unescapes `\|`. Shared by
+	 * `#emit_table_cell` (wrapped in cell tokens) and `lex_table_cell` (bare).
+	 */
+	#tokenize_cell_inline(cell_start: number, cell_end: number): void {
+		const saved_max = this.#max_search_index;
+		this.#max_search_index = cell_end;
+		this.#in_table_cell = true;
+		this.#index = cell_start;
+		while (this.#index < cell_end) {
+			this.#tokenize_inline();
+		}
+		this.#in_table_cell = false;
+		this.#max_search_index = saved_max;
+	}
+
+	/**
+	 * Recognize an in-item table whose header row's leading `|` is at `first`
+	 * (the line's indent already skipped): a pipe row whose next line is a
+	 * delimiter row, both indented past `marker_indent` (so both stay inside the
+	 * item). Returns the parsed header/delimiter, or null. Pure — no emission.
+	 */
+	#match_item_table_head(
+		first: number,
+		marker_indent: number,
+	): {
+		header_cells: Array<{start: number; end: number}>;
+		header_end: number;
+		align: Array<MdzTableAlign>;
+		delim_end: number;
+	} | null {
+		const header_end = this.#index_of('\n', first);
+		if (header_end === -1) return null; // a header needs a delimiter line beneath it
+		const header_cells = mdz_split_table_row(this.#text, first, header_end);
+		if (header_cells === null) return null;
+		const delim_line_start = header_end + 1;
+		let dj = delim_line_start;
+		while (dj < this.#text.length && is_line_whitespace(this.#text.charCodeAt(dj))) dj++;
+		if (dj - delim_line_start <= marker_indent) return null; // delimiter dedented out of the item
+		let delim_end = this.#index_of('\n', dj);
+		if (delim_end === -1) delim_end = this.#text.length;
+		const align = mdz_parse_table_delimiter(this.#text, dj, delim_end);
+		if (align === null || align.length !== header_cells.length) return null;
+		return {header_cells, header_end, align, delim_end};
+	}
+
+	/** Whether a table opens at `first` as a block child of an item at `marker_indent`. */
+	#is_item_table_start(first: number, marker_indent: number): boolean {
+		return this.#match_item_table_head(first, marker_indent) !== null;
+	}
+
+	/**
+	 * Tokenize an in-item table at `first` (a recognized table start). Mirrors
+	 * `#tokenize_table` but per row skips the line's indent to the `|` and ends
+	 * when a row dedents to `marker_indent` or shallower, leaving `#index` at the
+	 * table's terminating newline so the list loop classifies what follows (no
+	 * `#skip_blank_lines` — the list owns blank-line containment).
+	 */
+	#tokenize_item_table(first: number, marker_indent: number): void {
+		const head = this.#match_item_table_head(first, marker_indent)!;
+		this.#tokens.push({type: 'table_open', align: head.align, start: first, end: head.header_end});
+		this.#emit_table_row(head.header_cells, true, first, head.header_end);
+		this.#index = head.delim_end;
+		let table_end = head.delim_end;
+		while (this.#index < this.#text.length) {
+			const row_line_start = this.#index + 1; // past the newline at #index
+			let rj = row_line_start;
+			while (rj < this.#text.length && is_line_whitespace(this.#text.charCodeAt(rj))) rj++;
+			if (rj - row_line_start <= marker_indent) break; // dedent ends the table
+			if (this.#text.charCodeAt(rj) !== PIPE) break;
+			let row_end = this.#index_of('\n', rj);
+			if (row_end === -1) row_end = this.#text.length;
+			const cells = mdz_split_table_row(this.#text, rj, row_end);
+			if (cells === null) break;
+			this.#emit_table_row(cells, false, rj, row_end);
+			this.#index = row_end;
+			table_end = row_end;
+		}
+		this.#tokens.push({type: 'table_close', start: table_end, end: table_end});
+	}
+
 	// -- List tokenizers --
 
 	/**
@@ -739,6 +1030,23 @@ export class MdzLexer {
 				}
 			}
 
+			// a deeper pipe-row line whose next line is a delimiter becomes a
+			// table child of the item it would otherwise continue (the fence/quote
+			// precedent, but a two-line lookahead)
+			if (indent > 0 && this.#text.charCodeAt(first) === PIPE) {
+				const target_idx = this.#list_continuation_target(levels, indent);
+				if (target_idx !== -1) {
+					const marker_indent = levels[target_idx]!.indent;
+					if (this.#is_item_table_start(first, marker_indent)) {
+						while (levels.length - 1 > target_idx) {
+							this.#list_close(levels);
+						}
+						this.#tokenize_item_table(first, marker_indent);
+						continue;
+					}
+				}
+			}
+
 			// any other line deeper than an open item's marker opens a new
 			// `Paragraph` block child of that item (the item's inline run is never
 			// current here — a blank, block child, or dedent intervened)
@@ -947,6 +1255,9 @@ export class MdzLexer {
 			if (this.#text.charCodeAt(j) === RIGHT_ANGLE && this.#is_blockquote_opener(j)) {
 				return nl; // a quote opener line interrupts the run
 			}
+			if (this.#text.charCodeAt(j) === PIPE && this.#is_item_table_start(j, deepest_indent)) {
+				return nl; // a table opener (pipe row + delimiter) interrupts the run
+			}
 			i = line_start; // continuation — keep scanning
 		}
 	}
@@ -1301,6 +1612,23 @@ export class MdzLexer {
 
 	#tokenize_markdown_link(): void {
 		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
@@ -1309,11 +1637,13 @@ export class MdzLexer {
 		// 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;
 			if (this.#is_at_paragraph_break()) break;
 			this.#tokenize_inline();
 		}
+		this.#inline_depth--;
 
 		// Check for ]
 		if (this.#index >= this.#text.length || this.#text.charCodeAt(this.#index) !== RIGHT_BRACKET) {
@@ -1382,6 +1712,13 @@ export class MdzLexer {
 	}
 
 	#revert_tokens_from_link_open(start: number): void {
+		// 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--) {
@@ -1399,6 +1736,32 @@ export class MdzLexer {
 
 	#tokenize_tag(): void {
 		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
@@ -1445,6 +1808,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;
@@ -1463,11 +1827,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;
@@ -1483,8 +1849,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;
@@ -1507,12 +1875,14 @@ 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);
@@ -1540,23 +1910,47 @@ export class MdzLexer {
 		let parts: Array<string> | null = 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);
+			// 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_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_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));
+					parts.push('|');
+					this.#index += 2;
+					part_start = this.#index;
+					continue;
+				}
+				this.#index++;
+				continue;
 			}
 
-			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
 					// soft break: keep the newline, strip the next line's leading
@@ -1588,26 +1982,31 @@ export class MdzLexer {
 						next_char === HYPHEN ||
 						next_char === BACKTICK ||
 						next_char === ONE ||
-						next_char === RIGHT_ANGLE
+						next_char === RIGHT_ANGLE ||
+						next_char === PIPE
 					) {
 						this.#index++; // consume the newline
 						break;
 					}
 				}
+				this.#index++; // single newline — ordinary text
+				continue;
 			}
 
-			// 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))
-			) {
+			// 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;
+			} 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/src/lib/mdz_opcodes.ts

@@ -12,6 +12,8 @@
  * @module
  */
 
+import type {MdzTableAlign} from './mdz.ts';
+
 /**
  * Unique monotonic identifier for each node created by the parser.
  * IDs are never reused within a parser instance.
@@ -39,7 +41,10 @@ export type MdzNodeTypeContainer =
 	| 'Element'
 	| 'Component'
 	| 'Codeblock'
-	| 'Code';
+	| 'Code'
+	| 'Table'
+	| 'TableRow'
+	| 'TableCell';
 
 /** Node types for self-contained leaf elements. */
 export type MdzNodeTypeVoid = 'Hr';
@@ -69,6 +74,10 @@ export interface MdzOpcodeOpen {
 	start_number?: number;
 	/** Authored item number. Present when `node_type` is `'ListItem'` in an ordered list. */
 	number?: number;
+	/** Per-column alignment from the delimiter row. Present when `node_type` is `'Table'`. */
+	align?: Array<MdzTableAlign>;
+	/** Whether this is the header row (`thead`/`th`). Present when `node_type` is `'TableRow'`. */
+	header?: boolean;
 }
 
 /**