@fuzdev/mdz 0.1.0 → 0.3.0

package/dist/mdz_lexer.d.ts

@@ -6,11 +6,12 @@
  *
  * @module
  */
+import type { MdzTableAlign } from './mdz.js';
 export interface MdzTokenBase {
     start: number;
     end: number;
 }
-export type MdzToken = MdzTokenText | MdzTokenCode | MdzTokenCodeblock | MdzTokenBoldOpen | MdzTokenBoldClose | MdzTokenItalicOpen | MdzTokenItalicClose | MdzTokenStrikethroughOpen | MdzTokenStrikethroughClose | MdzTokenLinkTextOpen | MdzTokenLinkTextClose | MdzTokenLinkRef | MdzTokenAutolink | MdzTokenHeadingStart | MdzTokenHr | MdzTokenTagOpen | MdzTokenTagSelfClose | MdzTokenTagClose | MdzTokenHeadingEnd | MdzTokenParagraphBreak | MdzTokenListOpen | MdzTokenListClose | MdzTokenListItemOpen | MdzTokenListItemClose | MdzTokenBlockquoteOpen | MdzTokenBlockquoteClose;
+export type MdzToken = MdzTokenText | MdzTokenCode | MdzTokenCodeblock | MdzTokenBoldOpen | MdzTokenBoldClose | MdzTokenItalicOpen | MdzTokenItalicClose | MdzTokenStrikethroughOpen | MdzTokenStrikethroughClose | MdzTokenLinkTextOpen | MdzTokenLinkTextClose | MdzTokenLinkRef | MdzTokenAutolink | MdzTokenHeadingStart | MdzTokenHr | MdzTokenTagOpen | MdzTokenTagSelfClose | MdzTokenTagClose | MdzTokenHeadingEnd | MdzTokenParagraphBreak | MdzTokenListOpen | MdzTokenListClose | MdzTokenListItemOpen | MdzTokenListItemClose | MdzTokenBlockquoteOpen | MdzTokenBlockquoteClose | MdzTokenTableOpen | MdzTokenTableClose | MdzTokenTableRowOpen | MdzTokenTableRowClose | MdzTokenTableCellOpen | MdzTokenTableCellClose;
 export interface MdzTokenText extends MdzTokenBase {
     type: 'text';
     content: string;
@@ -106,6 +107,28 @@ export interface MdzTokenBlockquoteOpen extends MdzTokenBase {
 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';
+}
 /**
  * Tokenizes mdz input into a flat `MdzToken` stream for `MdzTokenParser`.
  *
@@ -118,6 +141,29 @@ export interface MdzTokenBlockquoteClose extends MdzTokenBase {
 export declare class MdzLexer {
     #private;
     constructor(text: string);
+    /**
+     * 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;
     tokenize(): Array<MdzToken>;
+    /**
+     * 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>;
 }
 //# sourceMappingURL=mdz_lexer.d.ts.map

package/dist/mdz_lexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_lexer.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_lexer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mdz_lexer.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_lexer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqDH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AAO5C,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,QAAQ,GACjB,YAAY,GACZ,YAAY,GACZ,iBAAiB,GACjB,gBAAgB,GAChB,iBAAiB,GACjB,kBAAkB,GAClB,mBAAmB,GACnB,yBAAyB,GACzB,0BAA0B,GAC1B,oBAAoB,GACpB,qBAAqB,GACrB,eAAe,GACf,gBAAgB,GAChB,oBAAoB,GACpB,UAAU,GACV,eAAe,GACf,oBAAoB,GACpB,gBAAgB,GAChB,kBAAkB,GAClB,sBAAsB,GACtB,gBAAgB,GAChB,iBAAiB,GACjB,oBAAoB,GACpB,qBAAqB,GACrB,sBAAsB,GACtB,uBAAuB,GACvB,iBAAiB,GACjB,kBAAkB,GAClB,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,CAAC;AAE1B,MAAM,WAAW,YAAa,SAAQ,YAAY;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAa,SAAQ,YAAY;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACtD,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACrD,IAAI,EAAE,WAAW,CAAC;CAClB;AAED,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACtD,IAAI,EAAE,YAAY,CAAC;CACnB;AAED,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACvD,IAAI,EAAE,aAAa,CAAC;CACpB;AAED,MAAM,WAAW,mBAAoB,SAAQ,YAAY;IACxD,IAAI,EAAE,cAAc,CAAC;CACrB;AAED,MAAM,WAAW,yBAA0B,SAAQ,YAAY;IAC9D,IAAI,EAAE,oBAAoB,CAAC;CAC3B;AAED,MAAM,WAAW,0BAA2B,SAAQ,YAAY;IAC/D,IAAI,EAAE,qBAAqB,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD,IAAI,EAAE,gBAAgB,CAAC;CACvB;AAED,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IAC1D,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACpD,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC;CACnC;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACrD,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC;CACnC;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,UAAW,SAAQ,YAAY;IAC/C,IAAI,EAAE,IAAI,CAAC;CACX;AAED,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACpD,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACrD,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACvD,IAAI,EAAE,aAAa,CAAC;CACpB;AAED,MAAM,WAAW,sBAAuB,SAAQ,YAAY;IAC3D,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACrD,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACtD,IAAI,EAAE,YAAY,CAAC;CACnB;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD,IAAI,EAAE,gBAAgB,CAAC;IACvB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IAC1D,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,MAAM,WAAW,sBAAuB,SAAQ,YAAY;IAC3D,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC5D,IAAI,EAAE,kBAAkB,CAAC;CACzB;AAED,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACtD,IAAI,EAAE,YAAY,CAAC;IACnB,+EAA+E;IAC/E,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACvD,IAAI,EAAE,aAAa,CAAC;CACpB;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD,IAAI,EAAE,gBAAgB,CAAC;IACvB,wDAAwD;IACxD,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IAC1D,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IAC1D,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,MAAM,WAAW,sBAAuB,SAAQ,YAAY;IAC3D,IAAI,EAAE,kBAAkB,CAAC;CACzB;AA8BD;;;;;;;;GAQG;AACH,qBAAa,QAAQ;;gBA0DR,IAAI,EAAE,MAAM;IAIxB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAuC1B,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAAC;IA8B3B;;;;;;;;;OASG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC;CAmrDrE"}

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, } 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
 //
@@ -33,9 +34,73 @@ export class MdzLexer {
      * scanner pre-validated every line in the run as continuation).
      */
     #list_run_strip = 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 = 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.
      *
@@ -52,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 });
         }
@@ -77,6 +146,8 @@ export class MdzLexer {
                     continue;
                 if (this.#tokenize_blockquote())
                     continue;
+                if (this.#tokenize_table())
+                    continue;
             }
             // Check for paragraph break
             if (this.#is_at_paragraph_break()) {
@@ -90,6 +161,24 @@ 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, 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;
+    }
     #is_at_column_0() {
         return this.#index === 0 || this.#text.charCodeAt(this.#index - 1) === NEWLINE;
     }
@@ -350,6 +439,156 @@ export class MdzLexer {
         this.#tokens.push({ type: 'blockquote_close', start: last_line_end, end: last_line_end });
         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() {
+        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, header, row_start, row_end) {
+        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, cell_end) {
+        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, cell_end) {
+        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, marker_indent) {
+        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, marker_indent) {
+        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, marker_indent) {
+        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 --
     /**
      * Tokenize an entire list starting at a column-0 marker line, emitting
@@ -478,6 +717,22 @@ export class MdzLexer {
                     continue;
                 }
             }
+            // 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)
@@ -681,6 +936,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
         }
     }
@@ -1002,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;
@@ -1015,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
@@ -1071,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--) {
@@ -1087,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))) {
@@ -1123,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;
@@ -1140,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;
@@ -1158,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;
@@ -1180,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);
@@ -1208,19 +1523,42 @@ 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);
+            // 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) {
+            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
@@ -1251,20 +1589,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;
+            }
+            // 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_opcodes.d.ts

@@ -11,6 +11,7 @@
  *
  * @module
  */
+import type { MdzTableAlign } from './mdz.js';
 /**
  * Unique monotonic identifier for each node created by the parser.
  * IDs are never reused within a parser instance.
@@ -24,7 +25,7 @@ export type MdzNodeId = number;
  * visible yet opens an optimistic `Code` container whose content streams as
  * text children (collapsed back to `content` by consumers at `close`).
  */
-export type MdzNodeTypeContainer = 'Paragraph' | 'Bold' | 'Italic' | 'Strikethrough' | 'Link' | 'Heading' | 'List' | 'ListItem' | 'Blockquote' | 'Element' | 'Component' | 'Codeblock' | 'Code';
+export type MdzNodeTypeContainer = 'Paragraph' | 'Bold' | 'Italic' | 'Strikethrough' | 'Link' | 'Heading' | 'List' | 'ListItem' | 'Blockquote' | 'Element' | 'Component' | 'Codeblock' | 'Code' | 'Table' | 'TableRow' | 'TableCell';
 /** Node types for self-contained leaf elements. */
 export type MdzNodeTypeVoid = 'Hr';
 /** Discriminant for leaf text nodes (see `MdzNodeTypeContainer` for `Code`'s dual form). */
@@ -51,6 +52,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;
 }
 /**
  * Close a previously opened container node.