@fuzdev/mdz 0.1.0 → 0.2.0

package/dist/mdz_lexer.js

@@ -6,7 +6,7 @@
  *
  * @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_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, BACKSLASH, } from './mdz_helpers.js';
 //
 // Lexer
 //
@@ -33,6 +33,12 @@ 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;
     constructor(text) {
         this.#text = text;
     }
@@ -77,6 +83,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 +98,21 @@ 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 = [];
+        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 +373,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 +651,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 +870,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
         }
     }
@@ -1210,6 +1402,22 @@ export class MdzLexer {
         let part_start = start;
         while (this.#index < this.#text.length) {
             const char_code = this.#text.charCodeAt(this.#index);
+            // in a table cell: the trimmed cell end is a hard stop (no newline to
+            // halt on mid-line), and `\|` is a literal pipe (the only mdz escape,
+            // scoped here)
+            if (this.#in_table_cell) {
+                if (this.#index >= this.#max_search_index)
+                    break;
+                if (char_code === BACKSLASH &&
+                    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;
+                }
+            }
             // Stop at special characters
             if (char_code === BACKTICK ||
                 char_code === ASTERISK ||
@@ -1251,7 +1459,8 @@ 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;
                     }

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.

package/dist/mdz_opcodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_opcodes.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_opcodes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mdz_opcodes.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_opcodes.ts"],"names":[],"mappings":"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"}

package/dist/mdz_opcodes_to_nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_opcodes_to_nodes.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_opcodes_to_nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EACX,OAAO,EAMP,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAC,SAAS,EAAY,MAAM,kBAAkB,CAAC;AAuB3D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,KAAK,CAAC,SAAS,CAAC,KAAG,KAAK,CAAC,OAAO,CA8L7E,CAAC"}
+{"version":3,"file":"mdz_opcodes_to_nodes.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_opcodes_to_nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EACX,OAAO,EASP,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAC,SAAS,EAAY,MAAM,kBAAkB,CAAC;AAyB3D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,KAAK,CAAC,SAAS,CAAC,KAAG,KAAK,CAAC,OAAO,CAgM7E,CAAC"}

package/dist/mdz_opcodes_to_nodes.js

@@ -43,6 +43,8 @@ export const mdz_opcodes_to_nodes = (opcodes) => {
                     ordered: op.ordered,
                     start_number: op.start_number,
                     number: op.number,
+                    align: op.align,
+                    header: op.header,
                 });
                 break;
             }
@@ -359,6 +361,30 @@ const build_node = (frame, frame_children) => {
             const end = frame_children.length > 0 ? frame_children[frame_children.length - 1].end : frame.end;
             return { type: 'Blockquote', children: frame_children, start: frame.start, end };
         }
+        case 'Table': {
+            // rows are the only children — `end` derives from the last, matching
+            // the sync token parser
+            const children = frame_children;
+            const end = children.length > 0 ? children[children.length - 1].end : frame.end;
+            return { type: 'Table', align: frame.align ?? [], children, start: frame.start, end };
+        }
+        case 'TableRow': {
+            const children = frame_children;
+            return {
+                type: 'TableRow',
+                header: frame.header ?? false,
+                children,
+                start: frame.start,
+                end: frame.end,
+            };
+        }
+        case 'TableCell':
+            return {
+                type: 'TableCell',
+                children: mdz_merge_adjacent_text(frame_children),
+                start: frame.start,
+                end: frame.end,
+            };
         case 'Code': {
             // optimistic inline code container — concatenate children text into leaf MdzNodeCode
             let content = '';

package/dist/mdz_stream_parser.d.ts.map

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

package/dist/mdz_stream_parser.js

@@ -34,10 +34,11 @@
  *
  * @module
  */
-import { BACKTICK, ASTERISK, UNDERSCORE, TILDE, NEWLINE, HYPHEN, HASH, LEFT_ANGLE, RIGHT_ANGLE, SLASH, LEFT_BRACKET, RIGHT_BRACKET, H_LOWER, H_UPPER, PERIOD, SPACE, ZERO, NINE, is_word_char, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, mdz_blockquote_strip_width, mdz_remap_segments, } from './mdz_helpers.js';
+import { BACKTICK, ASTERISK, UNDERSCORE, TILDE, NEWLINE, HYPHEN, HASH, PIPE, LEFT_ANGLE, RIGHT_ANGLE, SLASH, LEFT_BRACKET, RIGHT_BRACKET, H_LOWER, H_UPPER, PERIOD, SPACE, ZERO, NINE, is_word_char, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, mdz_blockquote_strip_width, mdz_remap_segments, } from './mdz_helpers.js';
 import { accumulate_text, alloc_id, close_all_list_levels, close_codeblock_at_eof, close_heading, close_paragraph, create_state, emit, find_open, flush_text, handle_paragraph_break, offset, pop_stack_entry, push_stack_entry, revert_failed_close, } from './mdz_stream_parser_state.js';
 import { process_codeblock, process_codeblock_forced, process_codeblock_in_item, try_codeblock_open, try_heading, try_hr, } from './mdz_stream_parser_block.js';
 import { process_list_line, try_list_start } from './mdz_stream_parser_list.js';
+import { close_table, process_table_line, try_table_start } from './mdz_stream_parser_table.js';
 import { check_close_word_boundary, close_delimiter, process_code_content, try_code, try_double_delimiter, try_italic, } from './mdz_stream_parser_inline.js';
 import { try_close_tag, try_complete_link, try_link_open, try_tag_open, } from './mdz_stream_parser_link.js';
 import { complete_pending_url, process_url_content, start_speculative_url, try_auto_path_absolute, try_auto_path_relative, try_auto_url_forced, } from './mdz_stream_parser_url.js';
@@ -146,6 +147,11 @@ const finish_state = (state) => {
     if (state.buffer.length > 0) {
         process_loop(state, true);
     }
+    // close an open top-level table — forced processing ends it at the last
+    // row, but an already-drained buffer (everything consumed) needs this net
+    if (state.table) {
+        close_table(state);
+    }
     // close an open blockquote — finishes its nested inner document (an
     // unclosed fence inside ends at the quote's EOF, which is this) and
     // cascades recursively through deeper quotes
@@ -477,6 +483,12 @@ const process_loop = (state, forced) => {
             process_url_content(state, forced);
             continue;
         }
+        // open table — each line is a body row or ends the table
+        if (state.table) {
+            if (!process_table_line(state, forced))
+                return; // need more input
+            continue;
+        }
         const char_code = state.buffer.charCodeAt(state.pos);
         // newline handling
         if (char_code === NEWLINE) {
@@ -567,6 +579,13 @@ const process_loop = (state, forced) => {
                 if (!forced && r === 'need_more')
                     return;
             }
+            else if (char_code === PIPE) {
+                const r = try_table_start(state, forced);
+                if (r === 'consumed')
+                    continue;
+                if (!forced && r === 'need_more')
+                    return;
+            }
         }
         // inline processing
         if (!process_inline(state, forced))

package/dist/mdz_stream_parser_list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_list.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAiBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAad,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CACf;AAoBD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,mBAAmB,GAAG,SAAS,GAAG,IAsDpC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,oBAAoB,GAAG,SAAS,GAAG,IAuBrC,CAAC;AAgGF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAY7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,QAAQ,OAAO,KACb,OAAO,GAAG,YA2KZ,CAAC"}
+{"version":3,"file":"mdz_stream_parser_list.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAmBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAad,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CACf;AAoBD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,mBAAmB,GAAG,SAAS,GAAG,IAsDpC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,oBAAoB,GAAG,SAAS,GAAG,IAuBrC,CAAC;AAgGF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAY7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,QAAQ,OAAO,KACb,OAAO,GAAG,YA+LZ,CAAC"}

package/dist/mdz_stream_parser_list.js

@@ -12,7 +12,8 @@
  *
  * @module
  */
-import { BACKTICK, HYPHEN, MAX_LIST_NUMBER_DIGITS, MIN_CODEBLOCK_BACKTICKS, NEWLINE, NINE, PERIOD, RIGHT_ANGLE, SPACE, ZERO, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, } from './mdz_helpers.js';
+import { BACKTICK, HYPHEN, MAX_LIST_NUMBER_DIGITS, MIN_CODEBLOCK_BACKTICKS, NEWLINE, NINE, PERIOD, PIPE, RIGHT_ANGLE, SPACE, ZERO, is_line_whitespace, mdz_match_blockquote_prefix, mdz_blockquote_line_has_content, } from './mdz_helpers.js';
+import { match_table_in_item_head, open_table_in_item } from './mdz_stream_parser_table.js';
 import { accumulate_text, alloc_id, close_all_list_levels, close_list_item, close_list_level, close_list_run, close_paragraph, emit, extend_accumulated_end, flush_text, offset, push_stack_entry, } from './mdz_stream_parser_state.js';
 /**
  * Whether only line whitespace remains between `from` and the line's end —
@@ -410,6 +411,26 @@ export const process_list_line = (state, forced) => {
             }
         }
     }
+    // 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,
+    // a two-line lookahead held until the delimiter line arrives)
+    if (indent > 0 && buffer.charCodeAt(j) === PIPE) {
+        const target_idx = list_continuation_target(state, indent);
+        if (target_idx !== -1) {
+            const marker_indent = state.list_levels[target_idx].indent;
+            const head = match_table_in_item_head(state, j, marker_indent, forced);
+            if (head === 'pending')
+                return false;
+            if (head !== null) {
+                close_list_run(state);
+                while (state.list_levels.length - 1 > target_idx) {
+                    close_list_level(state);
+                }
+                open_table_in_item(state, j, marker_indent, head);
+                return true;
+            }
+        }
+    }
     if (run_current && indent > deepest.indent) {
         // continuation line: soft break, structural indent stripped
         return continue_run(state, nl_pos, j);

package/dist/mdz_stream_parser_state.d.ts

@@ -199,6 +199,18 @@ export interface MdzStreamParserState {
      * quote (prefix stripping + nested-parser feeding) — see `MdzBlockquoteState`.
      */
     blockquote: MdzBlockquoteState | null;
+    /**
+     * The open table, or null. While set, each line is consumed as a body row
+     * (or ends the table) by `process_table_line`. Holds the `Table` frame's id
+     * so the table can be closed when a non-row line or EOF ends it. `item_indent`
+     * is `null` for a top-level table (column-0 rows) or the enclosing list item's
+     * marker indent for a table nested as a block child (rows skip the indent and
+     * a dedent to that indent ends the table, returning control to the list).
+     */
+    table: {
+        id: MdzNodeId;
+        item_indent: number | null;
+    } | null;
     /**
      * Whether the innermost open ListItem's first inline run is current.
      * Content then flows directly into the ListItem frame — the sync AST

package/dist/mdz_stream_parser_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_stream_parser_state.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mdz_stream_parser_state.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_state.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,oBAAoB,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAGjF;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAE/D,cAAc;AACd,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,SAAS,CAAC;IACd,SAAS,EAAE,oBAAoB,CAAC;IAChC;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,wEAAwE;IACxE,YAAY,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,0BAA0B,EAAE,OAAO,CAAC;IACpC,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAChC,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,gGAAgG;IAChG,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,cAAc;AACd,MAAM,WAAW,cAAc;IAC9B,EAAE,EAAE,SAAS,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IAClC,sCAAsC;IACtC,EAAE,EAAE,SAAS,CAAC;IACd,gEAAgE;IAChE,KAAK,EAAE,oBAAoB,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,EAAE,KAAK,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC7D,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,eAAe,EAAE,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACxC,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,UAAU;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC;IACnC,4DAA4D;IAC5D,SAAS,EAAE,OAAO,CAAC;IACnB,2DAA2D;IAC3D,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,OAAO,EAAE,SAAS,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,cAAc,GAAG,IAAI,CAAC;IACjC;;;;;OAKG;IACH,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IACjC;;;OAGG;IACH,UAAU,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACtC;;;;;;;OAOG;IACH,KAAK,EAAE;QAAC,EAAE,EAAE,SAAS,CAAC;QAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GAAG,IAAI,CAAC;IAC1D;;;;;;OAMG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,IAAI,CAAC;IAClD,8EAA8E;IAC9E,WAAW,EAAE,gBAAgB,CAAC;IAC9B,wDAAwD;IACxD,UAAU,EAAE,OAAO,CAAC;IACpB,gEAAgE;IAChE,OAAO,EAAE,OAAO,CAAC;IACjB,6DAA6D;IAC7D,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B;;;;;;OAMG;IACH,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAClC;;;;;;;OAOG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,YAAY,EAAE,SAAS,GAAG,IAAI,CAAC;IAC/B,uEAAuE;IACvE,4BAA4B,EAAE,OAAO,CAAC;IACtC;;;;;OAKG;IACH,+BAA+B,EAAE,OAAO,CAAC;CACzC;AAED,cAAc;AACd,eAAO,MAAM,YAAY,QAAO,oBAiC9B,CAAC;AAEH,cAAc;AACd,eAAO,MAAM,QAAQ,GAAI,OAAO,oBAAoB,KAAG,SAA4B,CAAC;AAEpF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAC5B,OAAO,oBAAoB,EAC3B,IAAI,SAAS,EACb,WAAW,oBAAoB,EAC/B,OAAO,MAAM,EACb,YAAW,MAAW,EACtB,WAAW,MAAM,KACf,IAeF,CAAC;AAqBF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,KAAG,UAI7D,CAAC;AAeF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,oBAAoB,EAAE,MAAK,MAAkB,KAAG,MACtD,CAAC;AAgEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAC3B,OAAO,oBAAoB,EAC3B,QAAQ,MAAM,EACd,MAAM,MAAM,KACV,MASF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,oBAAoB,EAAE,IAAI,SAAS,KAAG,IA6DjE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC3B,OAAO,oBAAoB,EAC3B,MAAM,MAAM,EACZ,cAAc,MAAM,KAClB,IAMF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAAI,OAAO,oBAAoB,EAAE,KAAK,MAAM,KAAG,IAEjF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,oBAAoB,KAAG,IAwBxD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,oBAAoB,KAAG,IAO9D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,WAAW,oBAAoB,KAAG,OACe,CAAC;AAElF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,oBAAoB,EAAE,MAAM,MAAM,gBAAgB,KAAG,MAiBrF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,oBAAoB,EAAE,YAAY,MAAM,KAAG,IAY9E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,IAwBpF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,oBAAoB,KAAG,IAgBnE,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,KAAG,IAwB7D,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,IAwB3D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAAI,OAAO,oBAAoB,KAAG,IASpE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,oBAAoB,KAAG,IAWhE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,KAAG,IAO5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,KAAG,IAQ7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,oBAAoB,KAAG,IAK9D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,oBAAoB,KAAG,IAMnE,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,sBAAsB,GAAI,OAAO,oBAAoB,KAAG,IAepE,CAAC"}

package/dist/mdz_stream_parser_state.js

@@ -24,6 +24,7 @@ export const create_state = () => ({
     codeblock: null,
     list_levels: [],
     blockquote: null,
+    table: null,
     in_list_item_run: false,
     last_empty_item_end: 0,
     base_offset: 0,

package/dist/mdz_stream_parser_table.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 { type MdzTableAlign } from './mdz.js';
+import { type MdzStreamParserState, type TryResult } 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 declare const try_table_start: (state: MdzStreamParserState, forced: boolean) => TryResult;
+/**
+ * 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 declare const process_table_line: (state: MdzStreamParserState, forced: boolean) => boolean;
+/**
+ * Close the open table.
+ *
+ * @nodocs
+ */
+export declare const close_table: (state: MdzStreamParserState) => void;
+/** A recognized in-item table head: the header row's cells + the delimiter alignment. */
+export interface TableInItemHead {
+    header_cells: Array<{
+        start: number;
+        end: number;
+    }>;
+    header_end: number;
+    align: Array<MdzTableAlign>;
+    delim_end: number;
+}
+/**
+ * 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 declare const match_table_in_item_head: (state: MdzStreamParserState, header_first: number, marker_indent: number, forced: boolean) => TableInItemHead | "pending" | null;
+/**
+ * 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 declare const open_table_in_item: (state: MdzStreamParserState, header_first: number, marker_indent: number, head: TableInItemHead) => void;
+//# sourceMappingURL=mdz_stream_parser_table.d.ts.map

package/dist/mdz_stream_parser_table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_table.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAWH,OAAO,EAAmC,KAAK,aAAa,EAAC,MAAM,UAAU,CAAC;AAC9E,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAQd,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAqC9E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,OAyCjF,CAAC;AA2DF;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,oBAAoB,KAAG,IAczD,CAAC;AAEF,yFAAyF;AACzF,MAAM,WAAW,eAAe;IAC/B,YAAY,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GACpC,OAAO,oBAAoB,EAC3B,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,QAAQ,OAAO,KACb,eAAe,GAAG,SAAS,GAAG,IAmBhC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,MAAM,eAAe,KACnB,IAkBF,CAAC"}