@fuzdev/fuz_ui 0.198.0 → 0.199.0

package/dist/mdz_stream_parser_inline.js

@@ -0,0 +1,378 @@
+/**
+ * Inline-formatting handlers (bold, italic, strikethrough, inline code)
+ * for the streaming mdz parser.
+ *
+ * @module
+ */
+import { ASTERISK, BACKTICK, NEWLINE, TILDE, UNDERSCORE, is_word_char } from './mdz_helpers.js';
+import { accumulate_text, alloc_id, emit, ensure_paragraph, flush_text, offset, push_stack_entry, revert_above, } from './mdz_stream_parser_state.js';
+// -- Bold --
+export const try_bold = (state) => {
+    // we know we're at ** and there's no open Bold
+    if (state.pos + 1 >= state.buffer.length)
+        return false; // need more input
+    // need at least one char after ** to avoid empty bold
+    if (state.pos + 2 >= state.buffer.length)
+        return false;
+    flush_text(state);
+    ensure_paragraph(state);
+    const id = alloc_id(state);
+    const bold_start = offset(state);
+    emit(state, { type: 'open', id, node_type: 'Bold', start: bold_start });
+    push_stack_entry(state, id, 'Bold', bold_start, true, '**');
+    state.active_text_id = null;
+    state.pos += 2;
+    state.column += 2;
+    state.prev_char = ASTERISK;
+    return true;
+};
+/**
+ * Close a `Bold` container at the given stack index. The caller in
+ * `process_inline` already located the open via `find_open`, so we trust the
+ * index rather than re-walking the stack.
+ */
+export const close_bold = (state, stack_idx) => {
+    flush_text(state);
+    // revert anything between the bold and the top of the stack
+    revert_above(state, stack_idx);
+    const entry = state.stack.pop();
+    // check for empty container — revert to literal text instead of closing
+    if (!entry.has_children) {
+        emit(state, {
+            type: 'revert',
+            id: entry.id,
+            replacement_text: entry.delimiter,
+            start: entry.start,
+        });
+        accumulate_text(state, '**', offset(state));
+    }
+    else {
+        emit(state, { type: 'close', id: entry.id, end: offset(state) + 2 });
+    }
+    state.active_text_id = null;
+    state.pos += 2;
+    state.column += 2;
+    state.prev_char = ASTERISK;
+    return true;
+};
+// -- Italic --
+export const try_italic = (state, forced = false) => {
+    // check opening word boundary
+    if (state.prev_char !== -1 && is_word_char(state.prev_char)) {
+        // not at word boundary — emit as text
+        ensure_paragraph(state);
+        accumulate_text(state, '_', offset(state));
+        state.prev_char = UNDERSCORE;
+        state.column++;
+        state.pos++;
+        return true;
+    }
+    // need at least one char after _
+    if (state.pos + 1 >= state.buffer.length) {
+        if (forced) {
+            // at EOF with only _ left — treat as text
+            ensure_paragraph(state);
+            accumulate_text(state, '_', offset(state));
+            state.prev_char = UNDERSCORE;
+            state.column++;
+            state.pos++;
+            return true;
+        }
+        return false;
+    }
+    // Italic is non-optimistic: require confirmed closer in the buffer.
+    // This avoids flashing italic on common `_` usage (snake_case, identifiers).
+    // When the closer isn't visible yet (`pending`), we treat `_` as text rather
+    // than holding — holding would block all subsequent content from being
+    // parsed in normal mode, and at EOF the parser can't distinguish "still
+    // streaming" from "really done."
+    //
+    // Consequence: italic cannot span chunk boundaries when the closing `_`
+    // arrives in a later chunk. The one-shot path (the correctness gate) is
+    // always correct because the full buffer is visible. See the
+    // `deliberate-divergence` block in `mdz_parser_parity.test.ts` for an
+    // asserted gap.
+    const closer = scan_closer_boundary(state, '_');
+    if (closer !== 'confirmed') {
+        ensure_paragraph(state);
+        accumulate_text(state, '_', offset(state));
+        state.prev_char = UNDERSCORE;
+        state.column++;
+        state.pos++;
+        return true;
+    }
+    flush_text(state);
+    ensure_paragraph(state);
+    const id = alloc_id(state);
+    const italic_start = offset(state);
+    emit(state, { type: 'open', id, node_type: 'Italic', start: italic_start });
+    push_stack_entry(state, id, 'Italic', italic_start, true, '_');
+    state.active_text_id = null;
+    state.pos++;
+    state.column++;
+    state.prev_char = UNDERSCORE;
+    return true;
+};
+// -- Strikethrough --
+export const try_strikethrough = (state) => {
+    // check opening word boundary
+    if (state.prev_char !== -1 && is_word_char(state.prev_char)) {
+        ensure_paragraph(state);
+        accumulate_text(state, '~', offset(state));
+        state.prev_char = TILDE;
+        state.column++;
+        state.pos++;
+        return true;
+    }
+    if (state.pos + 1 >= state.buffer.length)
+        return false;
+    // strikethrough is optimistic: 'pending' proceeds, only 'rejected' aborts
+    if (scan_closer_boundary(state, '~') === 'rejected') {
+        ensure_paragraph(state);
+        accumulate_text(state, '~', offset(state));
+        state.prev_char = TILDE;
+        state.column++;
+        state.pos++;
+        return true;
+    }
+    flush_text(state);
+    ensure_paragraph(state);
+    const id = alloc_id(state);
+    const strike_start = offset(state);
+    emit(state, { type: 'open', id, node_type: 'Strikethrough', start: strike_start });
+    push_stack_entry(state, id, 'Strikethrough', strike_start, true, '~');
+    state.active_text_id = null;
+    state.pos++;
+    state.column++;
+    state.prev_char = TILDE;
+    return true;
+};
+// -- Single delimiter close (italic/strikethrough) --
+export const check_close_word_boundary = (state) => {
+    const next_pos = state.pos + 1;
+    if (next_pos < state.buffer.length) {
+        return !is_word_char(state.buffer.charCodeAt(next_pos));
+    }
+    // at end of buffer — we'll treat as boundary for now (finish() handles unclosed)
+    return true;
+};
+export const close_single_delimiter = (state, stack_idx) => {
+    flush_text(state);
+    revert_above(state, stack_idx);
+    const entry = state.stack.pop();
+    // check for empty container — revert to literal text instead of closing
+    if (!entry.has_children) {
+        emit(state, {
+            type: 'revert',
+            id: entry.id,
+            replacement_text: entry.delimiter,
+            start: entry.start,
+        });
+        accumulate_text(state, entry.delimiter, offset(state));
+    }
+    else {
+        emit(state, { type: 'close', id: entry.id, end: offset(state) + 1 });
+    }
+    state.active_text_id = null;
+    state.pos++;
+    state.column++;
+    state.prev_char = state.buffer.charCodeAt(state.pos - 1);
+    return true;
+};
+/**
+ * Scan for the first potential closing delimiter and check its word boundary.
+ * Returns a tri-state:
+ * - `'confirmed'`: closer found in buffer with valid word boundary
+ * - `'rejected'`: closer found but with invalid word boundary (greedy first-match fails)
+ * - `'pending'`: no closer in buffer yet, or can't determine boundary
+ *
+ * Optimistic constructs (strikethrough) treat `'pending'` as proceed.
+ * Non-optimistic constructs (italic) treat `'pending'` as text.
+ *
+ * Uses native `indexOf` instead of a manual char loop for faster scanning.
+ */
+export const scan_closer_boundary = (state, delimiter) => {
+    const search_start = state.pos + 1;
+    const delim_pos = state.buffer.indexOf(delimiter, search_start);
+    if (delim_pos === -1)
+        return 'pending'; // no closer in buffer
+    // check for paragraph break before the delimiter
+    const para_pos = state.buffer.indexOf('\n\n', search_start);
+    if (para_pos !== -1 && para_pos < delim_pos)
+        return 'pending'; // paragraph break first
+    // check word boundary after the closer
+    const after_pos = delim_pos + 1;
+    if (after_pos < state.buffer.length) {
+        return is_word_char(state.buffer.charCodeAt(after_pos)) ? 'rejected' : 'confirmed';
+    }
+    // closer at end of buffer — treat as confirmed, consistent with
+    // check_close_word_boundary which also assumes boundary at buffer end
+    return 'confirmed';
+};
+// -- Inline code --
+export const try_code = (state) => {
+    const start = state.pos;
+    let i = start + 1; // past opening backtick
+    // compute search boundary: don't scan past open formatting delimiters
+    const search_limit = code_search_limit(state, start + 1);
+    // scan for closing backtick (must be before newline and search boundary)
+    while (i < state.buffer.length && i < search_limit) {
+        const c = state.buffer.charCodeAt(i);
+        if (c === BACKTICK) {
+            // found close
+            const content = state.buffer.slice(start + 1, i);
+            if (content.length === 0) {
+                // empty code — treat as text
+                ensure_paragraph(state);
+                accumulate_text(state, '``', offset(state, start));
+                state.pos = i + 1;
+                state.column += 2;
+                state.prev_char = BACKTICK;
+                return true;
+            }
+            flush_text(state);
+            ensure_paragraph(state);
+            const id = alloc_id(state);
+            emit(state, {
+                type: 'text',
+                id,
+                content,
+                text_type: 'Code',
+                start: offset(state, start),
+                end: offset(state, i + 1),
+            });
+            state.active_text_id = null;
+            state.pos = i + 1;
+            state.column += i + 1 - start;
+            state.prev_char = BACKTICK;
+            return true;
+        }
+        if (c === NEWLINE) {
+            // inline code can't span lines — treat opening backtick as text
+            ensure_paragraph(state);
+            accumulate_text(state, '`', offset(state, start));
+            state.pos = start + 1;
+            state.column++;
+            state.prev_char = BACKTICK;
+            return true;
+        }
+        i++;
+    }
+    // hit search limit (open formatting delimiter boundary) — treat backtick as text
+    if (i < state.buffer.length && i >= search_limit) {
+        ensure_paragraph(state);
+        accumulate_text(state, '`', offset(state, start));
+        state.pos = start + 1;
+        state.column++;
+        state.prev_char = BACKTICK;
+        return true;
+    }
+    // buffer ended without close or newline.
+    // If formatting is on the stack, hold — the formatting delimiter might appear
+    // in the next chunk between the backtick and its closer, and going optimistic
+    // would make the code span consume the formatting closer as raw text.
+    if (has_inline_formatting_on_stack(state)) {
+        return false; // hold for more input
+    }
+    // no formatting on stack — open Code optimistically.
+    // Content streams via text/append_text inside the container.
+    // Closes on matching backtick, reverts on newline.
+    flush_text(state);
+    ensure_paragraph(state);
+    const id = alloc_id(state);
+    const code_start = offset(state, start);
+    emit(state, { type: 'open', id, node_type: 'Code', start: code_start });
+    push_stack_entry(state, id, 'Code', code_start, true, '`');
+    state.in_code = true;
+    state.active_text_id = null;
+    state.pos = start + 1; // past opening backtick
+    state.column++;
+    state.prev_char = BACKTICK;
+    return true;
+};
+/**
+ * Compute search limit for inline code scanning.
+ * Finds the closest closing delimiter for any open formatting on the stack.
+ * This prevents backtick scanning from crossing bold/italic/etc boundaries.
+ */
+export const code_search_limit = (state, from) => {
+    let limit = state.buffer.length;
+    for (let s = state.stack.length - 1; s >= 0; s--) {
+        const entry = state.stack[s];
+        if (entry.node_type === 'Paragraph' || entry.node_type === 'Heading')
+            break;
+        // find the closing delimiter in the buffer
+        const delimiter = entry.delimiter;
+        if (!delimiter)
+            continue;
+        const idx = state.buffer.indexOf(delimiter, from);
+        if (idx !== -1 && idx < limit) {
+            limit = idx;
+        }
+    }
+    return limit;
+};
+/**
+ * Check if any inline formatting container (Bold, Italic, Strikethrough, Link)
+ * is on the stack above the current block boundary.
+ * Used to decide whether backtick can go optimistic — when formatting is open,
+ * the code span might cross the formatting boundary, so we hold instead.
+ */
+export const has_inline_formatting_on_stack = (state) => {
+    for (let s = state.stack.length - 1; s >= 0; s--) {
+        const entry = state.stack[s];
+        if (entry.node_type === 'Paragraph' || entry.node_type === 'Heading')
+            return false;
+        if (entry.delimiter)
+            return true;
+    }
+    return false;
+};
+/**
+ * Process content inside an optimistic inline Code container.
+ * Scans raw text (no inline formatting) until closing backtick or newline.
+ * Backtick closes (or reverts if empty). Newline reverts (code can't span lines).
+ */
+export const process_code_content = (state) => {
+    const char_code = state.buffer.charCodeAt(state.pos);
+    if (char_code === BACKTICK) {
+        flush_text(state);
+        const entry = state.stack.pop();
+        if (!entry.has_children) {
+            // empty code `` — revert opener, accumulate closer as text
+            emit(state, { type: 'revert', id: entry.id, replacement_text: '`', start: entry.start });
+            accumulate_text(state, '`', offset(state));
+        }
+        else {
+            emit(state, { type: 'close', id: entry.id, end: offset(state) + 1 });
+        }
+        state.in_code = false;
+        state.active_text_id = null;
+        state.pos++;
+        state.column++;
+        state.prev_char = BACKTICK;
+        return;
+    }
+    if (char_code === NEWLINE) {
+        // code spans can't cross lines — revert
+        flush_text(state);
+        const entry = state.stack.pop();
+        emit(state, { type: 'revert', id: entry.id, replacement_text: '`', start: entry.start });
+        state.in_code = false;
+        state.active_text_id = null;
+        // don't consume newline — outer loop handles it
+        return;
+    }
+    // scan raw text until backtick or newline (paragraph already ensured at code open)
+    const start = state.pos;
+    state.pos++;
+    while (state.pos < state.buffer.length) {
+        const c = state.buffer.charCodeAt(state.pos);
+        if (c === BACKTICK || c === NEWLINE)
+            break;
+        state.pos++;
+    }
+    accumulate_text(state, state.buffer.slice(start, state.pos), offset(state, start));
+    state.prev_char = state.buffer.charCodeAt(state.pos - 1);
+    state.column += state.pos - start;
+};

package/dist/mdz_stream_parser_link.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Markdown link `[text](url)` handlers and HTML-style tag handlers
+ * (`<tag>`, `<Tag />`, `</tag>`) for the streaming mdz parser.
+ *
+ * @module
+ */
+import { type MdzStreamParserState, type TryResult } from './mdz_stream_parser_state.js';
+export declare const try_link_open: (state: MdzStreamParserState) => boolean;
+/**
+ * Revert an optimistic Link container to its literal `[` and consume the
+ * `]` at `bracket_pos` as text. Used whenever a `]` doesn't form a valid
+ * `[text](url)` — missing `(`, empty url, invalid url char, etc.
+ */
+export declare const abort_link_to_text: (state: MdzStreamParserState, link_stack_idx: number, bracket_pos: number) => void;
+/**
+ * Try to complete a link after seeing `]`.
+ * Returns false if more input is needed (leaves pos at `]`).
+ */
+export declare const try_complete_link: (state: MdzStreamParserState, link_stack_idx: number) => boolean;
+export declare const try_tag_open: (state: MdzStreamParserState) => TryResult;
+export declare const try_close_tag: (state: MdzStreamParserState) => TryResult;
+//# sourceMappingURL=mdz_stream_parser_link.d.ts.map

package/dist/mdz_stream_parser_link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_link.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_link.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EASd,MAAM,8BAA8B,CAAC;AAItC,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,OAa3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,gBAAgB,MAAM,EACtB,aAAa,MAAM,KACjB,IAUF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,gBAAgB,MAAM,KAAG,OAwEvF,CAAC;AAIF,eAAO,MAAM,YAAY,GAAI,OAAO,oBAAoB,KAAG,SAsE1D,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,SA0C3D,CAAC"}

package/dist/mdz_stream_parser_link.js

@@ -0,0 +1,215 @@
+/**
+ * Markdown link `[text](url)` handlers and HTML-style tag handlers
+ * (`<tag>`, `<Tag />`, `</tag>`) for the streaming mdz parser.
+ *
+ * @module
+ */
+import { A_UPPER, LEFT_BRACKET, LEFT_PAREN, NEWLINE, RIGHT_ANGLE, RIGHT_BRACKET, RIGHT_PAREN, SLASH, SPACE, Z_UPPER, is_letter, is_tag_name_char, is_valid_path_char, mdz_is_safe_reference, mdz_is_url, } from './mdz_helpers.js';
+import { accumulate_text, alloc_id, emit, ensure_paragraph, flush_text, offset, push_stack_entry, revert_above, } from './mdz_stream_parser_state.js';
+// -- Links --
+export const try_link_open = (state) => {
+    flush_text(state);
+    ensure_paragraph(state);
+    const id = alloc_id(state);
+    const link_start = offset(state);
+    emit(state, { type: 'open', id, node_type: 'Link', start: link_start });
+    push_stack_entry(state, id, 'Link', link_start, true, '[');
+    state.active_text_id = null;
+    state.pos++;
+    state.column++;
+    state.prev_char = LEFT_BRACKET;
+    return true;
+};
+/**
+ * Revert an optimistic Link container to its literal `[` and consume the
+ * `]` at `bracket_pos` as text. Used whenever a `]` doesn't form a valid
+ * `[text](url)` — missing `(`, empty url, invalid url char, etc.
+ */
+export const abort_link_to_text = (state, link_stack_idx, bracket_pos) => {
+    flush_text(state);
+    revert_above(state, link_stack_idx);
+    const entry = state.stack.pop();
+    emit(state, { type: 'revert', id: entry.id, replacement_text: '[', start: entry.start });
+    state.active_text_id = null;
+    accumulate_text(state, ']', offset(state, bracket_pos));
+    state.pos = bracket_pos + 1;
+    state.column++;
+    state.prev_char = RIGHT_BRACKET;
+};
+/**
+ * Try to complete a link after seeing `]`.
+ * Returns false if more input is needed (leaves pos at `]`).
+ */
+export const try_complete_link = (state, link_stack_idx) => {
+    const bracket_pos = state.pos;
+    // need at least one char after ]
+    if (bracket_pos + 1 >= state.buffer.length)
+        return false;
+    const after_bracket = state.buffer.charCodeAt(bracket_pos + 1);
+    if (after_bracket !== LEFT_PAREN) {
+        abort_link_to_text(state, link_stack_idx, bracket_pos);
+        return true;
+    }
+    // found ]( — scan for )
+    let i = bracket_pos + 2; // past ](
+    while (i < state.buffer.length) {
+        const c = state.buffer.charCodeAt(i);
+        if (c === RIGHT_PAREN) {
+            const reference = state.buffer.slice(bracket_pos + 2, i);
+            // validate reference: non-empty and only valid path chars
+            if (!reference.trim()) {
+                abort_link_to_text(state, link_stack_idx, bracket_pos);
+                return true;
+            }
+            let valid = true;
+            for (let j = 0; j < reference.length; j++) {
+                if (!is_valid_path_char(reference.charCodeAt(j))) {
+                    valid = false;
+                    break;
+                }
+            }
+            if (!valid) {
+                abort_link_to_text(state, link_stack_idx, bracket_pos);
+                return true;
+            }
+            // Reject unsafe protocols (javascript:, data:, etc.) at parse time.
+            // `is_valid_path_char` permits `:` so we have to filter explicitly.
+            if (!mdz_is_safe_reference(reference)) {
+                abort_link_to_text(state, link_stack_idx, bracket_pos);
+                return true;
+            }
+            // success — close the link with reference
+            flush_text(state);
+            revert_above(state, link_stack_idx);
+            const entry = state.stack.pop();
+            const link_type = mdz_is_url(reference) ? 'external' : 'internal';
+            emit(state, {
+                type: 'close',
+                id: entry.id,
+                end: offset(state, i + 1),
+                reference,
+                link_type,
+            });
+            state.active_text_id = null;
+            state.pos = i + 1;
+            state.column += i + 1 - bracket_pos;
+            state.prev_char = RIGHT_PAREN;
+            return true;
+        }
+        if (c === NEWLINE || c === SPACE) {
+            // invalid character in URL (simplified check)
+            break;
+        }
+        i++;
+    }
+    // didn't find ) — need more input or invalid
+    if (i >= state.buffer.length)
+        return false; // need more input
+    // found invalid char before ) — revert
+    abort_link_to_text(state, link_stack_idx, bracket_pos);
+    return true;
+};
+// -- Tags --
+export const try_tag_open = (state) => {
+    const start = state.pos;
+    let i = start + 1; // past <
+    // tag name must start with letter
+    if (i >= state.buffer.length)
+        return 'not_match'; // treat as text via fallthrough
+    if (!is_letter(state.buffer.charCodeAt(i))) {
+        return 'not_match';
+    }
+    // collect tag name
+    const name_start = i;
+    while (i < state.buffer.length && is_tag_name_char(state.buffer.charCodeAt(i))) {
+        i++;
+    }
+    if (i >= state.buffer.length)
+        return 'need_more';
+    const name = state.buffer.slice(name_start, i);
+    // skip whitespace
+    while (i < state.buffer.length && state.buffer.charCodeAt(i) === SPACE) {
+        i++;
+    }
+    if (i >= state.buffer.length)
+        return 'need_more';
+    // check for self-closing />
+    if (state.buffer.charCodeAt(i) === SLASH &&
+        i + 1 < state.buffer.length &&
+        state.buffer.charCodeAt(i + 1) === RIGHT_ANGLE) {
+        const first_char = name.charCodeAt(0);
+        const is_component = first_char >= A_UPPER && first_char <= Z_UPPER;
+        const node_type = is_component ? 'Component' : 'Element';
+        flush_text(state);
+        ensure_paragraph(state);
+        const id = alloc_id(state);
+        const tag_start = offset(state, start);
+        emit(state, { type: 'open', id, node_type, start: tag_start, name });
+        emit(state, { type: 'close', id, end: offset(state, i + 2) });
+        state.active_text_id = null;
+        state.pos = i + 2;
+        state.column += i + 2 - start;
+        state.prev_char = RIGHT_ANGLE;
+        return 'consumed';
+    }
+    // check for >
+    if (state.buffer.charCodeAt(i) !== RIGHT_ANGLE) {
+        return 'not_match';
+    }
+    i++; // past >
+    const first_char = name.charCodeAt(0);
+    const is_component = first_char >= A_UPPER && first_char <= Z_UPPER;
+    const node_type = is_component ? 'Component' : 'Element';
+    flush_text(state);
+    ensure_paragraph(state);
+    const id = alloc_id(state);
+    const tag_start = offset(state, start);
+    const delimiter = state.buffer.slice(start, i); // e.g., "<Alert>"
+    emit(state, { type: 'open', id, node_type, start: tag_start, name });
+    push_stack_entry(state, id, node_type, tag_start, true, delimiter, name);
+    state.active_text_id = null;
+    state.pos = i;
+    state.column += i - start;
+    state.prev_char = RIGHT_ANGLE;
+    return 'consumed';
+};
+export const try_close_tag = (state) => {
+    // we're at </
+    let i = state.pos + 2; // past </
+    if (i >= state.buffer.length)
+        return 'need_more';
+    // collect tag name
+    const name_start = i;
+    while (i < state.buffer.length && is_tag_name_char(state.buffer.charCodeAt(i))) {
+        i++;
+    }
+    if (i >= state.buffer.length)
+        return 'need_more';
+    if (state.buffer.charCodeAt(i) !== RIGHT_ANGLE)
+        return 'not_match';
+    const name = state.buffer.slice(name_start, i);
+    i++; // past >
+    // find matching open tag on stack
+    let found_idx = -1;
+    for (let j = state.stack.length - 1; j >= 0; j--) {
+        const entry = state.stack[j];
+        if ((entry.node_type === 'Element' || entry.node_type === 'Component') &&
+            entry.tag_name === name) {
+            found_idx = j;
+            break;
+        }
+        if (entry.node_type === 'Paragraph' || entry.node_type === 'Heading')
+            break;
+    }
+    if (found_idx === -1)
+        return 'not_match';
+    flush_text(state);
+    revert_above(state, found_idx);
+    const entry = state.stack.pop();
+    emit(state, { type: 'close', id: entry.id, end: offset(state, i) });
+    state.active_text_id = null;
+    state.column += i - state.pos;
+    state.pos = i;
+    state.prev_char = RIGHT_ANGLE;
+    return 'consumed';
+};