@fuzdev/mdz 0.1.0 → 0.2.0

package/dist/mdz_stream_parser_table.js

@@ -0,0 +1,351 @@
+/**
+ * Table handlers for the streaming mdz parser.
+ *
+ * A table is recognized at a column-0 pipe row whose next line is a valid
+ * delimiter row with a matching column count — a bounded one-line lookahead:
+ * the header row holds (`need_more`) until its delimiter line arrives, then the
+ * whole header emits at once. Body rows then stream one per line. Because a row
+ * is always fully buffered before it emits (no within-row streaming), each
+ * cell's inline content is parsed with the sync reference (`MdzTableCellParser`,
+ * one `MdzLexer`/`MdzTokenParser` shared across the row's cells) and replayed
+ * as opcodes — guaranteeing sync↔stream parity by construction.
+ *
+ * @module
+ */
+import { DEV } from 'esm-env';
+import { NEWLINE, PIPE, is_line_whitespace, mdz_split_table_row, mdz_parse_table_delimiter, } from './mdz_helpers.js';
+import { MdzTableCellParser } from './mdz.js';
+import { alloc_id, close_paragraph, emit, flush_text, offset, pop_stack_entry, push_stack_entry, } from './mdz_stream_parser_state.js';
+/**
+ * Try to open a table at a column-0 pipe row. Returns `need_more` until both
+ * the header line and its delimiter line are buffered (or, in forced mode,
+ * resolvable), `not_match` when the two lines aren't a valid header+delimiter
+ * pair, and `consumed` once the table opens (closing any open paragraph first,
+ * emitting the header row, and leaving `state.pos` at the first body line).
+ *
+ * @nodocs
+ */
+export const try_table_start = (state, forced) => {
+    const start = state.pos;
+    const header_end = state.buffer.indexOf('\n', start);
+    // a table needs a header line plus a delimiter line — without the header's
+    // newline there's no room for a delimiter (at EOF it can never be a table)
+    if (header_end === -1)
+        return forced ? 'not_match' : 'need_more';
+    const header_cells = mdz_split_table_row(state.buffer, start, header_end);
+    if (header_cells === null)
+        return 'not_match';
+    const delim_start = header_end + 1;
+    let delim_end = state.buffer.indexOf('\n', delim_start);
+    if (delim_end === -1) {
+        if (!forced)
+            return 'need_more'; // delimiter line not complete yet
+        delim_end = state.buffer.length;
+    }
+    const align = mdz_parse_table_delimiter(state.buffer, delim_start, delim_end);
+    if (align === null || align.length !== header_cells.length)
+        return 'not_match';
+    // committed — the delimiter row is structural, never emitted
+    flush_text(state);
+    close_paragraph(state);
+    const table_id = alloc_id(state);
+    const table_start = offset(state, start);
+    emit(state, { type: 'open', id: table_id, node_type: 'Table', start: table_start, align });
+    push_stack_entry(state, table_id, 'Table', table_start);
+    state.table = { id: table_id, item_indent: null };
+    emit_table_row(state, header_cells, true, start, header_end);
+    // skip past the delimiter row to the first potential body line
+    state.pos = delim_end === state.buffer.length ? delim_end : delim_end + 1;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+    return 'consumed';
+};
+/**
+ * Process the line at `state.pos` while a table is open: emit it as a body row,
+ * or close the table when it isn't a valid pipe row. Returns false (need more
+ * input) only when a pipe-row line is started but not yet complete. A non-pipe
+ * line (including a blank line) ends the table and is left for normal
+ * processing.
+ *
+ * @nodocs
+ */
+export const process_table_line = (state, forced) => {
+    const item_indent = state.table.item_indent;
+    if (item_indent !== null) {
+        return process_table_line_in_item(state, forced, item_indent);
+    }
+    if (state.pos >= state.buffer.length) {
+        // the table may continue with more rows in a later chunk
+        if (forced) {
+            close_table(state);
+            return true;
+        }
+        return false;
+    }
+    const row_start = state.pos;
+    // a body row must start with `|` at column 0; anything else ends the table
+    // (decided without waiting for the line's newline)
+    if (state.buffer.charCodeAt(row_start) !== PIPE) {
+        close_table(state);
+        return true;
+    }
+    let row_end = state.buffer.indexOf('\n', row_start);
+    if (row_end === -1) {
+        if (!forced)
+            return false; // pipe-row line not complete — hold
+        row_end = state.buffer.length;
+    }
+    const cells = mdz_split_table_row(state.buffer, row_start, row_end);
+    if (cells === null) {
+        // starts with `|` but isn't a valid row (e.g. no trailing pipe) — table ends
+        close_table(state);
+        return true;
+    }
+    emit_table_row(state, cells, false, row_start, row_end);
+    state.pos = row_end === state.buffer.length ? row_end : row_end + 1;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+    return true;
+};
+/**
+ * Process body rows of an in-item table. Unlike the top-level path this keeps
+ * `state.pos` on the newline that ends each row — a row boundary the buffer
+ * never compacts past, since it's the active cursor. So when a dedent (to the
+ * item's `marker_indent` or shallower), a blank line, or a non-pipe line ends
+ * the table, `close_table` leaves the cursor on that newline and the list's
+ * newline handler re-classifies the following line — the same control-return
+ * shape as the in-item codeblock, robust across chunk boundaries.
+ */
+const process_table_line_in_item = (state, forced, item_indent) => {
+    if (state.pos >= state.buffer.length) {
+        if (forced) {
+            close_table(state);
+            return true;
+        }
+        return false;
+    }
+    // `state.pos` sits on the newline ending the previous row (or the delimiter);
+    // the candidate next row is the line after it
+    const line_start = state.pos + 1;
+    let j = line_start;
+    while (j < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(j))) {
+        j++;
+    }
+    if (j >= state.buffer.length) {
+        if (forced) {
+            close_table(state);
+            return true;
+        }
+        return false; // indent-only / incomplete line — hold
+    }
+    if (j - line_start <= item_indent || state.buffer.charCodeAt(j) !== PIPE) {
+        // a dedent to the marker (or shallower), a blank line, or a non-pipe line
+        // ends the table; the cursor stays on the row-boundary newline so the
+        // list resumes via its newline handler
+        close_table(state);
+        return true;
+    }
+    let row_end = state.buffer.indexOf('\n', j);
+    if (row_end === -1) {
+        if (!forced)
+            return false; // pipe-row line not complete — hold
+        row_end = state.buffer.length;
+    }
+    const cells = mdz_split_table_row(state.buffer, j, row_end);
+    if (cells === null) {
+        close_table(state);
+        return true;
+    }
+    emit_table_row(state, cells, false, j, row_end);
+    state.pos = row_end; // stay on this row's terminating newline (or EOF)
+    return true;
+};
+/**
+ * Close the open table.
+ *
+ * @nodocs
+ */
+export const close_table = (state) => {
+    if (!state.table)
+        return;
+    const { item_indent } = state.table;
+    const entry = pop_stack_entry(state);
+    emit(state, { type: 'close', id: entry.id, end: offset(state) });
+    state.table = null;
+    state.active_text_id = null;
+    if (item_indent === null) {
+        // top-level: the trailing newline + any blank lines absorb at the loop top
+        state.skip_blank_lines = true;
+    }
+    // in-item: the cursor is left on a row-boundary newline (or EOF). The list's
+    // newline handler re-classifies the following line; at EOF, `finish` closes
+    // the list. No skip_blank_lines — the list owns blank-line containment.
+};
+/**
+ * Recognize a table opening as a block child of a list item: a pipe row at
+ * `header_first` (the line's indent already skipped) whose next line is a
+ * delimiter row, both indented past `marker_indent` (so both stay inside the
+ * item). Returns the parsed head, `'pending'` when the two-line lookahead isn't
+ * fully buffered, or `null` when it isn't a table.
+ *
+ * @nodocs
+ */
+export const match_table_in_item_head = (state, header_first, marker_indent, forced) => {
+    const { buffer } = state;
+    const header_end = buffer.indexOf('\n', header_first);
+    if (header_end === -1)
+        return forced ? null : 'pending'; // header needs its newline + a delimiter beneath
+    const header_cells = mdz_split_table_row(buffer, header_first, header_end);
+    if (header_cells === null)
+        return null;
+    const delim_line_start = header_end + 1;
+    let dj = delim_line_start;
+    while (dj < buffer.length && is_line_whitespace(buffer.charCodeAt(dj)))
+        dj++;
+    if (dj >= buffer.length)
+        return forced ? null : 'pending'; // delimiter line not buffered yet
+    if (dj - delim_line_start <= marker_indent)
+        return null; // delimiter dedented out of the item
+    let delim_end = buffer.indexOf('\n', dj);
+    if (delim_end === -1) {
+        if (!forced)
+            return 'pending'; // delimiter line incomplete
+        delim_end = buffer.length;
+    }
+    const align = mdz_parse_table_delimiter(buffer, dj, delim_end);
+    if (align === null || align.length !== header_cells.length)
+        return null;
+    return { header_cells, header_end, align, delim_end };
+};
+/**
+ * Open a table as a block child of a list item at `marker_indent`, given a
+ * `head` from `match_table_in_item_head`. Emits the `Table` open + header row
+ * and enters table mode (with `item_indent`), leaving `state.pos` at the first
+ * body line. The caller closes the item's run and pops to the attach level first.
+ *
+ * @nodocs
+ */
+export const open_table_in_item = (state, header_first, marker_indent, head) => {
+    const table_id = alloc_id(state);
+    const table_start = offset(state, header_first);
+    emit(state, {
+        type: 'open',
+        id: table_id,
+        node_type: 'Table',
+        start: table_start,
+        align: head.align,
+    });
+    push_stack_entry(state, table_id, 'Table', table_start);
+    state.table = { id: table_id, item_indent: marker_indent };
+    emit_table_row(state, head.header_cells, true, header_first, head.header_end);
+    // leave the cursor on the delimiter's newline (or EOF) — the in-item body-row
+    // handler reads from the line after it and hands back on this same convention
+    state.pos = head.delim_end;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+};
+/** Emit one table row: open, each cell, close. */
+const emit_table_row = (state, cells, header, row_start, row_end) => {
+    const row_id = alloc_id(state);
+    const row_off = offset(state, row_start);
+    emit(state, { type: 'open', id: row_id, node_type: 'TableRow', start: row_off, header });
+    push_stack_entry(state, row_id, 'TableRow', row_off);
+    // one lexer/parser shared across the row's cells (all index into the same
+    // buffer) rather than allocated per cell
+    const cell_parser = new MdzTableCellParser(state.buffer);
+    for (const cell of cells) {
+        emit_table_cell(state, cell_parser, cell.start, cell.end);
+    }
+    pop_stack_entry(state);
+    emit(state, { type: 'close', id: row_id, end: offset(state, row_end) });
+    state.active_text_id = null;
+};
+/**
+ * Emit one cell: open, its inline content (parsed with the sync reference over
+ * the fully-buffered span via the row's shared `cell_parser`), close.
+ */
+const emit_table_cell = (state, cell_parser, cell_start, cell_end) => {
+    const cell_id = alloc_id(state);
+    const cell_off = offset(state, cell_start);
+    emit(state, { type: 'open', id: cell_id, node_type: 'TableCell', start: cell_off });
+    push_stack_entry(state, cell_id, 'TableCell', cell_off);
+    emit_inline_nodes(state, cell_parser.parse(cell_start, cell_end));
+    pop_stack_entry(state);
+    emit(state, { type: 'close', id: cell_id, end: offset(state, cell_end) });
+    state.active_text_id = null;
+};
+/**
+ * Replay sync-parsed inline nodes as opcodes. Cell content is inline-only;
+ * positions are local to `state.buffer` and lifted to global via `offset`.
+ */
+const emit_inline_nodes = (state, nodes) => {
+    for (const node of nodes) {
+        switch (node.type) {
+            case 'Text':
+                emit(state, {
+                    type: 'text',
+                    id: alloc_id(state),
+                    content: node.content,
+                    text_type: 'Text',
+                    start: offset(state, node.start),
+                    end: offset(state, node.end),
+                });
+                break;
+            case 'Code':
+                emit(state, {
+                    type: 'text',
+                    id: alloc_id(state),
+                    content: node.content,
+                    text_type: 'Code',
+                    start: offset(state, node.start),
+                    end: offset(state, node.end),
+                });
+                break;
+            case 'Bold':
+            case 'Italic':
+            case 'Strikethrough': {
+                const id = alloc_id(state);
+                const s = offset(state, node.start);
+                emit(state, { type: 'open', id, node_type: node.type, start: s });
+                push_stack_entry(state, id, node.type, s);
+                emit_inline_nodes(state, node.children);
+                pop_stack_entry(state);
+                emit(state, { type: 'close', id, end: offset(state, node.end) });
+                break;
+            }
+            case 'Link': {
+                const id = alloc_id(state);
+                const s = offset(state, node.start);
+                emit(state, { type: 'open', id, node_type: 'Link', start: s });
+                push_stack_entry(state, id, 'Link', s);
+                emit_inline_nodes(state, node.children);
+                pop_stack_entry(state);
+                emit(state, {
+                    type: 'close',
+                    id,
+                    end: offset(state, node.end),
+                    reference: node.reference,
+                    link_type: node.link_type,
+                });
+                break;
+            }
+            case 'Element':
+            case 'Component': {
+                const id = alloc_id(state);
+                const s = offset(state, node.start);
+                emit(state, { type: 'open', id, node_type: node.type, start: s, name: node.name });
+                push_stack_entry(state, id, node.type, s, '', node.name);
+                emit_inline_nodes(state, node.children);
+                pop_stack_entry(state);
+                emit(state, { type: 'close', id, end: offset(state, node.end) });
+                break;
+            }
+            // cells are inline-only (lexed via `lex_table_cell`); a block node here
+            // would mean a sync/stream grammar drift — fail loud in dev
+            default:
+                if (DEV) {
+                    throw new Error(`mdz table cell: unexpected inline node type '${node.type}'`);
+                }
+        }
+    }
+};

package/dist/mdz_stream_state.svelte.d.ts

@@ -8,6 +8,7 @@
  * @module
  */
 import type { MdzNodeId, MdzNodeType, MdzOpcode } from './mdz_opcodes.js';
+import type { MdzTableAlign } from './mdz.js';
 /**
  * A reactive node in the stream renderer tree.
  * Fields are `$state` so Svelte re-renders only what changes.
@@ -26,6 +27,10 @@ export declare class MdzStreamNode {
     ordered?: boolean;
     start_number?: number;
     number?: number;
+    /** Per-column alignment (Table nodes). */
+    align?: Array<MdzTableAlign>;
+    /** Whether this is the header row (TableRow nodes). */
+    header?: boolean;
     constructor(id: MdzNodeId, type: MdzNodeType);
 }
 /**

package/dist/mdz_stream_state.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAExE;;;GAGG;AACH,qBAAa,aAAa;IACzB,EAAE,EAAE,SAAS,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAc;IAC7B,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAE5C,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAY;IAC9B,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,CAAY;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAY;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW;CAI5C;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;;IAC1B,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAqCxC;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IA2R9B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI;CAK5C"}
+{"version":3,"file":"mdz_stream_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AAE5C;;;GAGG;AACH,qBAAa,aAAa;IACzB,EAAE,EAAE,SAAS,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAc;IAC7B,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAE5C,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAY;IAC9B,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,CAAY;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAY;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC7B,uDAAuD;IACvD,MAAM,CAAC,EAAE,OAAO,CAAC;gBAEL,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW;CAI5C;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;;IAC1B,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAqCxC;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IA6R9B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI;CAK5C"}

package/dist/mdz_stream_state.svelte.js

@@ -27,6 +27,10 @@ export class MdzStreamNode {
     ordered;
     start_number;
     number;
+    /** Per-column alignment (Table nodes). */
+    align;
+    /** Whether this is the header row (TableRow nodes). */
+    header;
     constructor(id, type) {
         this.id = id;
         this.type = type;
@@ -96,6 +100,10 @@ export class MdzStreamState {
                     node.start_number = opcode.start_number;
                 if (opcode.number !== undefined)
                     node.number = opcode.number;
+                if (opcode.align !== undefined)
+                    node.align = opcode.align;
+                if (opcode.header !== undefined)
+                    node.header = opcode.header;
                 this.#attach(node);
                 this.#stack.push(opcode.id);
                 break;

package/dist/mdz_to_svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_to_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_to_svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,UAAU,CAAC;AAGtC;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;KAAC,CAAC,CAAC;IAEhE,yEAAyE;IACzE,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,OAAO,CAAC,EACrB,SAAS,kBAAkB,KACzB,iBA4HF,CAAC"}
+{"version":3,"file":"mdz_to_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_to_svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAC,OAAO,EAAkB,MAAM,UAAU,CAAC;AAGvD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;KAAC,CAAC,CAAC;IAEhE,yEAAyE;IACzE,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,OAAO,CAAC,EACrB,SAAS,kBAAkB,KACzB,iBA8JF,CAAC"}

package/dist/mdz_to_svelte.js

@@ -7,9 +7,9 @@
  *
  * @module
  */
-import { UnreachableError } from '@fuzdev/fuz_util/error.js';
-import { escape_svelte_text } from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
-import { escape_js_string } from '@fuzdev/fuz_util/string.js';
+import { UnreachableError } from '@fuzdev/fuz_util/error.ts';
+import { escape_svelte_text } from '@fuzdev/fuz_util/svelte_preprocess_helpers.ts';
+import { escape_js_string } from '@fuzdev/fuz_util/string.ts';
 import { mdz_resolve_relative_path, mdz_is_void_element } from './mdz_helpers.js';
 /** Derives an import's local identifier from a `.svelte` import path's basename. */
 const component_local_name = (import_path) => import_path.slice(import_path.lastIndexOf('/') + 1).replace(/\.svelte$/, '');
@@ -90,6 +90,40 @@ export const mdz_to_svelte = (nodes, options) => {
                 return `<li>${render_nodes(node.children)}</li>`;
             case 'Blockquote':
                 return `<blockquote>${render_nodes(node.children)}</blockquote>`;
+            case 'Table': {
+                const { align } = node;
+                const render_row = (row, tag) => {
+                    let cells = '';
+                    // normalize to the column count: pad short rows, ignore extra cells
+                    for (let i = 0; i < align.length; i++) {
+                        const a = align[i];
+                        const style = a ? ` style="text-align:${a}"` : '';
+                        const cell = row.children[i];
+                        cells += `<${tag}${style}>${cell ? render_nodes(cell.children) : ''}</${tag}>`;
+                    }
+                    return `<tr>${cells}</tr>`;
+                };
+                let out = '<table>';
+                const header_rows = node.children.filter((r) => r.header);
+                const body_rows = node.children.filter((r) => !r.header);
+                if (header_rows.length > 0) {
+                    out += '<thead>';
+                    for (const row of header_rows)
+                        out += render_row(row, 'th');
+                    out += '</thead>';
+                }
+                if (body_rows.length > 0) {
+                    out += '<tbody>';
+                    for (const row of body_rows)
+                        out += render_row(row, 'td');
+                    out += '</tbody>';
+                }
+                return out + '</table>';
+            }
+            case 'TableRow':
+            case 'TableCell':
+                // rendered within their `Table`; never reached through `render_nodes`
+                throw new Error(`mdz: ${node.type} must render within a Table`);
             case 'Hr':
                 return '<hr />';
             case 'Heading': {

package/dist/mdz_token_parser.d.ts

@@ -15,6 +15,22 @@ import { type MdzToken } from './mdz_lexer.js';
 export declare class MdzTokenParser {
     #private;
     constructor(tokens: Array<MdzToken>);
+    /**
+     * Rebind to a new token stream and rewind, so one parser instance can be
+     * reused across inputs — the streaming table path reuses one across a row's
+     * cells via `MdzTableCellParser`.
+     *
+     * @nodocs
+     */
+    reset(tokens: Array<MdzToken>): void;
     parse(): Array<MdzNode>;
+    /**
+     * Parse the entire token stream as a single inline run — used for table
+     * cells, whose tokens come from `MdzLexer.lex_table_cell`. Adjacent text
+     * merges as it accumulates, matching `#parse_table_cell`.
+     *
+     * @nodocs
+     */
+    parse_inline_run(): Array<MdzNode>;
 }
 //# sourceMappingURL=mdz_token_parser.d.ts.map

package/dist/mdz_token_parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_token_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_token_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,OAAO,EAYP,MAAM,UAAU,CAAC;AAQlB,OAAO,EACN,KAAK,QAAQ,EASb,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,qBAAa,cAAc;;gBAId,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IAInC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC;CAyevB"}
+{"version":3,"file":"mdz_token_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_token_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,OAAO,EAeP,MAAM,UAAU,CAAC;AAQlB,OAAO,EACN,KAAK,QAAQ,EAYb,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,qBAAa,cAAc;;gBAId,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IAInC;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,IAAI;IAKpC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC;IAIvB;;;;;;OAMG;IACH,gBAAgB,IAAI,KAAK,CAAC,OAAO,CAAC;CAikBlC"}

package/dist/mdz_token_parser.js

@@ -18,9 +18,36 @@ export class MdzTokenParser {
     constructor(tokens) {
         this.#tokens = tokens;
     }
+    /**
+     * Rebind to a new token stream and rewind, so one parser instance can be
+     * reused across inputs — the streaming table path reuses one across a row's
+     * cells via `MdzTableCellParser`.
+     *
+     * @nodocs
+     */
+    reset(tokens) {
+        this.#tokens = tokens;
+        this.#index = 0;
+    }
     parse() {
         return this.#parse_block_stream(false);
     }
+    /**
+     * Parse the entire token stream as a single inline run — used for table
+     * cells, whose tokens come from `MdzLexer.lex_table_cell`. Adjacent text
+     * merges as it accumulates, matching `#parse_table_cell`.
+     *
+     * @nodocs
+     */
+    parse_inline_run() {
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const node = this.#parse_inline();
+            if (node)
+                mdz_push_merging_text(children, node);
+        }
+        return children;
+    }
     /**
      * Parse a run of block-level tokens into nodes — the document root, or a
      * blockquote's contents (a quote's content is a mini-document, so both
@@ -80,6 +107,13 @@ export class MdzTokenParser {
                 nodes.push(this.#parse_blockquote());
                 continue;
             }
+            if (token.type === 'table_open') {
+                const flushed = this.#flush_paragraph(paragraph_children, true);
+                if (flushed)
+                    nodes.push(flushed);
+                nodes.push(this.#parse_table());
+                continue;
+            }
             if (token.type === 'paragraph_break') {
                 const flushed = this.#flush_paragraph(paragraph_children, true);
                 if (flushed)
@@ -107,6 +141,63 @@ export class MdzTokenParser {
         const end = children.length > 0 ? children[children.length - 1].end : open.end;
         return { type: 'Blockquote', children, start: open.start, end };
     }
+    #parse_table() {
+        const open = this.#tokens[this.#index];
+        this.#index++;
+        const rows = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'table_row_open') {
+                rows.push(this.#parse_table_row());
+                continue;
+            }
+            if (t.type === 'table_close') {
+                this.#index++;
+                break;
+            }
+            this.#index++; // skip anything unexpected (defensive)
+        }
+        const end = rows.length > 0 ? rows[rows.length - 1].end : open.end;
+        return { type: 'Table', align: open.align, children: rows, start: open.start, end };
+    }
+    #parse_table_row() {
+        const open = this.#tokens[this.#index];
+        const header = open.header;
+        this.#index++;
+        const cells = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'table_cell_open') {
+                cells.push(this.#parse_table_cell());
+                continue;
+            }
+            if (t.type === 'table_row_close') {
+                this.#index++;
+                return { type: 'TableRow', header, children: cells, start: open.start, end: t.end };
+            }
+            this.#index++; // skip anything unexpected (defensive)
+        }
+        const end = cells.length > 0 ? cells[cells.length - 1].end : open.end;
+        return { type: 'TableRow', header, children: cells, start: open.start, end };
+    }
+    #parse_table_cell() {
+        const open = this.#tokens[this.#index];
+        const start = open.start;
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'table_cell_close') {
+                this.#index++;
+                return { type: 'TableCell', children, start, end: t.end };
+            }
+            const node = this.#parse_inline();
+            if (node)
+                mdz_push_merging_text(children, node);
+        }
+        const end = children.length > 0 ? children[children.length - 1].end : open.end;
+        return { type: 'TableCell', children, start, end };
+    }
     #parse_heading() {
         const token = this.#tokens[this.#index];
         const start = token.start;
@@ -188,6 +279,12 @@ export class MdzTokenParser {
                 children.push(this.#parse_blockquote());
                 continue;
             }
+            if (t.type === 'table_open') {
+                flush();
+                in_paragraph = false;
+                children.push(this.#parse_table());
+                continue;
+            }
             if (t.type === 'codeblock') {
                 flush();
                 in_paragraph = false;
@@ -307,7 +404,8 @@ export class MdzTokenParser {
                 t.type === 'codeblock' ||
                 t.type === 'list_open' ||
                 t.type === 'list_item_close' ||
-                t.type === 'blockquote_open') {
+                t.type === 'blockquote_open' ||
+                t.type === 'table_open') {
                 break;
             }
             const node = this.#parse_inline();
@@ -348,7 +446,8 @@ export class MdzTokenParser {
                 t.type === 'codeblock' ||
                 t.type === 'list_open' ||
                 t.type === 'list_item_close' ||
-                t.type === 'blockquote_open') {
+                t.type === 'blockquote_open' ||
+                t.type === 'table_open') {
                 break;
             }
             const node = this.#parse_inline();

package/dist/svelte_preprocess_mdz.js

@@ -16,8 +16,8 @@
 import { parse } from 'svelte/compiler';
 import MagicString from 'magic-string';
 import { walk } from 'zimmerframe';
-import { should_exclude_path } from '@fuzdev/fuz_util/path.js';
-import { find_attribute, extract_static_string, try_extract_conditional_chain, build_static_bindings, resolve_component_names, has_identifier_in_tree, find_import_insert_position, generate_import_lines, remove_variable_declaration, remove_import_declaration, remove_import_specifier, handle_preprocess_error, } from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
+import { should_exclude_path } from '@fuzdev/fuz_util/path.ts';
+import { find_attribute, extract_static_string, try_extract_conditional_chain, build_static_bindings, resolve_component_names, has_identifier_in_tree, find_import_insert_position, generate_import_lines, remove_variable_declaration, remove_import_declaration, remove_import_specifier, handle_preprocess_error, } from '@fuzdev/fuz_util/svelte_preprocess_helpers.ts';
 import { mdz_parse } from './mdz.js';
 import { mdz_to_svelte } from './mdz_to_svelte.js';
 const PRECOMPILED_NAME = 'MdzPrecompiled';