@fuzdev/mdz 0.1.0

package/dist/mdz_stream_parser_block.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Block-element handlers for the streaming mdz parser.
+ *
+ * Each `try_*` returns {@link TryResult} so the orchestrator in
+ * {@link ./mdz_stream_parser.ts} can fall through or wait for more input.
+ *
+ * @module
+ */
+import { type CodeblockState, type MdzStreamParserState, type TryResult } from './mdz_stream_parser_state.js';
+/**
+ * Try to parse a heading at column 0.
+ *
+ * @nodocs
+ */
+export declare const try_heading: (state: MdzStreamParserState) => TryResult;
+/**
+ * Try to parse a horizontal rule at column 0.
+ * When `forced` is true, treats buffer end as EOF (no more input coming).
+ *
+ * @nodocs
+ */
+export declare const try_hr: (state: MdzStreamParserState, forced?: boolean) => TryResult;
+/**
+ * Try to open a code block at column 0. A complete opener line is decisive —
+ * raw mode is absolute, so fence-ness never depends on a closer arriving:
+ * an unclosed fence consumes to EOF as content. Any open paragraph closes
+ * first (fences interrupt paragraphs, matching the sync parser). The only
+ * hold is the opener line itself; an opener cut off at EOF without its
+ * newline stays text (the orchestrator treats `need_more` as text in forced
+ * mode).
+ *
+ * @nodocs
+ */
+export declare const try_codeblock_open: (state: MdzStreamParserState) => TryResult;
+/**
+ * Emit codeblock content as `text` (first chunk) or `append_text` (subsequent
+ * chunks), updating `cb.text_id` on first emit. `content_start` is the local
+ * buffer position where the content slice began — only used to compute the
+ * global byte offset for the first `text` opcode.
+ *
+ * @nodocs
+ */
+export declare const emit_codeblock_text: (state: MdzStreamParserState, cb: CodeblockState, content: string, content_start: number) => void;
+/**
+ * Drain the remaining buffer as codeblock content at EOF, looking for a closing
+ * fence whose terminator is EOF rather than `\n`. Matches the sync lexer's
+ * `#match_fence`, which allows a fence at the end of the document.
+ *
+ * If a fence is found, the codeblock closes normally. Otherwise the remaining
+ * buffer becomes content and `close_codeblock_at_eof` (in
+ * `mdz_stream_parser_state.ts`) emits the plain close after process completes
+ * (an unclosed fence consumes to EOF — never reverted).
+ *
+ * @nodocs
+ */
+export declare const process_codeblock_forced: (state: MdzStreamParserState) => void;
+/**
+ * Process bytes while in codeblock mode.
+ * Returns true if processing should continue, false if more input needed.
+ *
+ * @nodocs
+ */
+export declare const process_codeblock: (state: MdzStreamParserState) => boolean;
+/**
+ * Process buffered lines while inside an in-item code block
+ * (`fence_indent > 0`). Operates on complete lines only — a partial line at
+ * the buffer end holds until its newline arrives (line-bounded, like the
+ * opener hold), keeping the per-line indent strip and closer probe
+ * deterministic across chunk boundaries. Content lines strip
+ * `min(fence_indent, line_indent)` and emit joined by `'\n'` separators
+ * (first line bare, later lines prefixed), so emitted content never carries
+ * the region's final newline — `close_codeblock_at_eof` therefore skips its
+ * trailing-newline trim for in-item fences.
+ *
+ * A closing fence — any indent <= the opener's, a run of >= the opener's
+ * backticks, only whitespace to the line end — closes the block with `pos`
+ * left at its terminating newline, so the list line classifier dispatches
+ * what follows (mirroring the sync lexer's loop shape). In forced mode EOF
+ * terminates closer and content lines.
+ *
+ * Returns `false` when more input is needed; never in forced mode.
+ *
+ * @nodocs
+ */
+export declare const process_codeblock_in_item: (state: MdzStreamParserState, forced: boolean) => boolean;
+/**
+ * Check if the buffer at current position has a codeblock closing fence —
+ * a run of at least `backtick_count` backticks with only whitespace to end
+ * of line. Returns the position after the fence (including trailing newline)
+ * on success, `-1` when definitely not a fence, or `-2` when more input is
+ * needed to decide.
+ *
+ * When `forced` is true, EOF after the fence counts as a valid terminator
+ * (matches `mdz_parse`'s handling of code blocks at end of input).
+ *
+ * @nodocs
+ */
+export declare const match_codeblock_close: (state: MdzStreamParserState, backtick_count: number, forced?: boolean) => number;
+//# sourceMappingURL=mdz_stream_parser_block.d.ts.map

package/dist/mdz_stream_parser_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_block.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_block.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,OAAO,EACN,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAOd,MAAM,8BAA8B,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,oBAAoB,KAAG,SAuDzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,SA4CpE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,oBAAoB,KAAG,SAgDhE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAC/B,OAAO,oBAAoB,EAC3B,IAAI,cAAc,EAClB,SAAS,MAAM,EACf,eAAe,MAAM,KACnB,IAgBF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,oBAAoB,KAAG,IA6CtE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,KAAG,OA2D/D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB,GACrC,OAAO,oBAAoB,EAC3B,QAAQ,OAAO,KACb,OAmDF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GACjC,OAAO,oBAAoB,EAC3B,gBAAgB,MAAM,EACtB,SAAQ,OAAe,KACrB,MAgCF,CAAC"}

package/dist/mdz_stream_parser_block.js

@@ -0,0 +1,437 @@
+/**
+ * Block-element handlers for the streaming mdz parser.
+ *
+ * Each `try_*` returns {@link TryResult} so the orchestrator in
+ * {@link ./mdz_stream_parser.ts} can fall through or wait for more input.
+ *
+ * @module
+ */
+import { BACKTICK, HASH, HR_HYPHEN_COUNT, HYPHEN, MAX_HEADING_LEVEL, MIN_CODEBLOCK_BACKTICKS, NEWLINE, SPACE, is_line_whitespace, } from './mdz_helpers.js';
+import { alloc_id, close_paragraph, emit, flush_text, offset, push_stack_entry, } from './mdz_stream_parser_state.js';
+/**
+ * Try to parse a heading at column 0.
+ *
+ * @nodocs
+ */
+export const try_heading = (state) => {
+    const start = state.pos;
+    let i = start;
+    // count hashes
+    let hash_count = 0;
+    while (i < state.buffer.length &&
+        state.buffer.charCodeAt(i) === HASH &&
+        hash_count <= MAX_HEADING_LEVEL) {
+        hash_count++;
+        i++;
+    }
+    if (hash_count === 0 || hash_count > MAX_HEADING_LEVEL)
+        return 'not_match';
+    // need at least one more char to check for space
+    if (i >= state.buffer.length)
+        return 'need_more';
+    // must have space after hashes
+    if (state.buffer.charCodeAt(i) !== SPACE)
+        return 'not_match';
+    i++; // consume space
+    // must have at least one non-whitespace char before the newline (mirrors
+    // the sync lexer's has-content probe) — hold until it can be decided. A
+    // line-bounded hold: the heading opens the moment its first content char
+    // arrives. In forced mode the orchestrator treats `need_more` as text.
+    let j = i;
+    while (j < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(j))) {
+        j++;
+    }
+    if (j >= state.buffer.length)
+        return 'need_more';
+    if (state.buffer.charCodeAt(j) === NEWLINE)
+        return 'not_match'; // no content — literal text
+    // close any open paragraph first
+    flush_text(state);
+    close_paragraph(state);
+    const id = alloc_id(state);
+    const heading_start = offset(state, start);
+    emit(state, {
+        type: 'open',
+        id,
+        node_type: 'Heading',
+        start: heading_start,
+        level: hash_count,
+    });
+    push_stack_entry(state, id, 'Heading', heading_start);
+    state.in_heading = true;
+    state.heading_text_parts = [''];
+    state.pos = i;
+    state.column = i - start;
+    state.prev_char = SPACE;
+    return 'consumed';
+};
+/**
+ * Try to parse a horizontal rule at column 0.
+ * When `forced` is true, treats buffer end as EOF (no more input coming).
+ *
+ * @nodocs
+ */
+export const try_hr = (state, forced = false) => {
+    const start = state.pos;
+    let i = start;
+    // must have exactly 3 hyphens
+    if (i + HR_HYPHEN_COUNT > state.buffer.length)
+        return 'need_more';
+    for (let j = 0; j < HR_HYPHEN_COUNT; j++) {
+        if (state.buffer.charCodeAt(i + j) !== HYPHEN)
+            return 'not_match';
+    }
+    i += HR_HYPHEN_COUNT;
+    // after hyphens, only line whitespace allowed before newline/EOF
+    while (i < state.buffer.length) {
+        const c = state.buffer.charCodeAt(i);
+        if (c === NEWLINE)
+            break;
+        if (!is_line_whitespace(c))
+            return 'not_match';
+        i++;
+    }
+    // if buffer ends without newline/EOF confirmation, need more input (unless forced)
+    if (i >= state.buffer.length && !forced) {
+        return 'need_more';
+    }
+    flush_text(state);
+    close_paragraph(state);
+    const id = alloc_id(state);
+    emit(state, {
+        type: 'void',
+        id,
+        node_type: 'Hr',
+        start: offset(state, start),
+        end: offset(state, i),
+    });
+    // `i` sits at the line's newline, or at the buffer end — in forced mode
+    // always the buffer end (a newline would have resolved this line during
+    // `feed`, so a forced HR is only ever the document's final line). Trailing
+    // newline and blank lines absorb at the process-loop top.
+    state.pos = i;
+    state.skip_blank_lines = true;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+    return 'consumed';
+};
+/**
+ * Try to open a code block at column 0. A complete opener line is decisive —
+ * raw mode is absolute, so fence-ness never depends on a closer arriving:
+ * an unclosed fence consumes to EOF as content. Any open paragraph closes
+ * first (fences interrupt paragraphs, matching the sync parser). The only
+ * hold is the opener line itself; an opener cut off at EOF without its
+ * newline stays text (the orchestrator treats `need_more` as text in forced
+ * mode).
+ *
+ * @nodocs
+ */
+export const try_codeblock_open = (state) => {
+    const start = state.pos;
+    let i = start;
+    // count backticks
+    let backtick_count = 0;
+    while (i < state.buffer.length && state.buffer.charCodeAt(i) === BACKTICK) {
+        backtick_count++;
+        i++;
+    }
+    if (backtick_count < MIN_CODEBLOCK_BACKTICKS) {
+        // if buffer ended mid-backtick-sequence, need more input
+        if (i >= state.buffer.length)
+            return 'need_more';
+        // definitely not enough backticks
+        return 'not_match';
+    }
+    // find end of opening fence line (need newline)
+    const lang_start = i;
+    while (i < state.buffer.length) {
+        const c = state.buffer.charCodeAt(i);
+        if (c === NEWLINE || is_line_whitespace(c))
+            break;
+        i++;
+    }
+    const lang = i > lang_start ? state.buffer.slice(lang_start, i) : null;
+    // skip trailing whitespace on opening fence line
+    while (i < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(i))) {
+        i++;
+    }
+    // must find newline
+    if (i >= state.buffer.length)
+        return 'need_more';
+    if (state.buffer.charCodeAt(i) !== NEWLINE)
+        return 'not_match';
+    i++; // consume newline
+    flush_text(state);
+    close_paragraph(state);
+    const id = alloc_id(state);
+    const cb_start = offset(state, start);
+    emit(state, { type: 'open', id, node_type: 'Codeblock', start: cb_start, lang });
+    state.codeblock = { id, backtick_count, text_id: null, fence_indent: 0, start: cb_start };
+    state.pos = i;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+    return 'consumed';
+};
+/**
+ * Emit codeblock content as `text` (first chunk) or `append_text` (subsequent
+ * chunks), updating `cb.text_id` on first emit. `content_start` is the local
+ * buffer position where the content slice began — only used to compute the
+ * global byte offset for the first `text` opcode.
+ *
+ * @nodocs
+ */
+export const emit_codeblock_text = (state, cb, content, content_start) => {
+    if (cb.text_id !== null) {
+        emit(state, { type: 'append_text', id: cb.text_id, content });
+    }
+    else {
+        const id = alloc_id(state);
+        const text_start = offset(state, content_start);
+        emit(state, {
+            type: 'text',
+            id,
+            content,
+            text_type: 'Text',
+            start: text_start,
+            end: text_start + content.length,
+        });
+        cb.text_id = id;
+    }
+};
+/**
+ * Drain the remaining buffer as codeblock content at EOF, looking for a closing
+ * fence whose terminator is EOF rather than `\n`. Matches the sync lexer's
+ * `#match_fence`, which allows a fence at the end of the document.
+ *
+ * If a fence is found, the codeblock closes normally. Otherwise the remaining
+ * buffer becomes content and `close_codeblock_at_eof` (in
+ * `mdz_stream_parser_state.ts`) emits the plain close after process completes
+ * (an unclosed fence consumes to EOF — never reverted).
+ *
+ * @nodocs
+ */
+export const process_codeblock_forced = (state) => {
+    const cb = state.codeblock;
+    const start = state.pos;
+    while (state.pos < state.buffer.length) {
+        if (state.column === 0) {
+            const fence_match = match_codeblock_close(state, cb.backtick_count, true);
+            if (fence_match !== -1) {
+                // emit content up to the closing fence (excluding trailing newline before fence)
+                let content_end = state.pos;
+                if (content_end > start && state.buffer.charCodeAt(content_end - 1) === NEWLINE) {
+                    content_end--;
+                }
+                const content = state.buffer.slice(start, content_end);
+                if (content.length > 0) {
+                    emit_codeblock_text(state, cb, content, start);
+                }
+                // the closer here is always EOF-terminated (`fence_match` is the
+                // buffer end): a newline-terminated closer resolves during `feed`,
+                // whose hold retains at most a trailing newline plus a partial
+                // fence line. So — like the non-forced path's `fence_match - 1` —
+                // the close `end` excludes any line terminator
+                emit(state, { type: 'close', id: cb.id, end: offset(state, fence_match) });
+                state.pos = fence_match;
+                state.codeblock = null;
+                return;
+            }
+        }
+        const c = state.buffer.charCodeAt(state.pos);
+        if (c === NEWLINE) {
+            state.column = 0;
+        }
+        else {
+            state.column++;
+        }
+        state.pos++;
+    }
+    // no closing fence — dump the rest as codeblock content; caller's
+    // `close_codeblock_at_eof` then closes the codeblock at EOF
+    const remaining = state.buffer.slice(start, state.pos);
+    if (remaining.length > 0) {
+        emit_codeblock_text(state, cb, remaining, start);
+    }
+};
+/**
+ * Process bytes while in codeblock mode.
+ * Returns true if processing should continue, false if more input needed.
+ *
+ * @nodocs
+ */
+export const process_codeblock = (state) => {
+    const cb = state.codeblock;
+    const start = state.pos;
+    while (state.pos < state.buffer.length) {
+        // check for closing fence at column 0
+        if (state.column === 0) {
+            const fence_match = match_codeblock_close(state, cb.backtick_count);
+            if (fence_match === -2) {
+                // need more input — hold from this position (don't consume potential fence chars)
+                break;
+            }
+            if (fence_match !== -1) {
+                // emit content up to the closing fence (excluding trailing newline before fence)
+                let content_end = state.pos;
+                if (content_end > start && state.buffer.charCodeAt(content_end - 1) === NEWLINE) {
+                    content_end--;
+                }
+                const content = state.buffer.slice(start, content_end);
+                if (content.length > 0) {
+                    emit_codeblock_text(state, cb, content, start);
+                }
+                // codeblock end = position of newline after closing fence (exclusive)
+                emit(state, { type: 'close', id: cb.id, end: offset(state, fence_match - 1) });
+                state.pos = fence_match;
+                state.codeblock = null;
+                state.column = 0;
+                state.prev_char = NEWLINE;
+                // trailing newlines and blank lines absorb at the process-loop top
+                state.skip_blank_lines = true;
+                return true;
+            }
+        }
+        // not a closing fence — advance
+        const c = state.buffer.charCodeAt(state.pos);
+        if (c === NEWLINE) {
+            state.column = 0;
+        }
+        else {
+            state.column++;
+        }
+        state.pos++;
+    }
+    // buffer exhausted or broke for potential fence — emit content so far, hold trailing data.
+    // Hold trailing \n (could be before a closing fence in next chunk), and also hold
+    // \n + backticks when we broke mid-fence-check (the \n precedes the backticks and
+    // would be stripped by fence close, so must not be emitted as content yet).
+    let emit_end = state.pos;
+    if (emit_end > start && state.buffer.charCodeAt(emit_end - 1) === NEWLINE) {
+        emit_end--;
+        state.pos = emit_end; // leave \n (+ any held backticks after it) in buffer
+    }
+    const content = state.buffer.slice(start, emit_end);
+    if (content.length > 0) {
+        emit_codeblock_text(state, cb, content, start);
+    }
+    return false; // need more input
+};
+/**
+ * Process buffered lines while inside an in-item code block
+ * (`fence_indent > 0`). Operates on complete lines only — a partial line at
+ * the buffer end holds until its newline arrives (line-bounded, like the
+ * opener hold), keeping the per-line indent strip and closer probe
+ * deterministic across chunk boundaries. Content lines strip
+ * `min(fence_indent, line_indent)` and emit joined by `'\n'` separators
+ * (first line bare, later lines prefixed), so emitted content never carries
+ * the region's final newline — `close_codeblock_at_eof` therefore skips its
+ * trailing-newline trim for in-item fences.
+ *
+ * A closing fence — any indent <= the opener's, a run of >= the opener's
+ * backticks, only whitespace to the line end — closes the block with `pos`
+ * left at its terminating newline, so the list line classifier dispatches
+ * what follows (mirroring the sync lexer's loop shape). In forced mode EOF
+ * terminates closer and content lines.
+ *
+ * Returns `false` when more input is needed; never in forced mode.
+ *
+ * @nodocs
+ */
+export const process_codeblock_in_item = (state, forced) => {
+    const cb = state.codeblock;
+    while (state.pos < state.buffer.length) {
+        const line_start = state.pos;
+        let j = line_start;
+        while (j < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(j))) {
+            j++;
+        }
+        if (j >= state.buffer.length && !forced)
+            return false; // partial line — hold
+        const line_indent = j - line_start;
+        // closer probe
+        if (line_indent <= cb.fence_indent &&
+            j < state.buffer.length &&
+            state.buffer.charCodeAt(j) === BACKTICK) {
+            let k = j;
+            let count = 0;
+            while (k < state.buffer.length && state.buffer.charCodeAt(k) === BACKTICK) {
+                count++;
+                k++;
+            }
+            if (k >= state.buffer.length && !forced)
+                return false; // run could still grow
+            if (count >= cb.backtick_count) {
+                let m = k;
+                while (m < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(m))) {
+                    m++;
+                }
+                if (m >= state.buffer.length && !forced)
+                    return false; // trailing content could disqualify
+                if (m >= state.buffer.length || state.buffer.charCodeAt(m) === NEWLINE) {
+                    emit(state, { type: 'close', id: cb.id, end: offset(state, m) });
+                    state.codeblock = null;
+                    state.pos = m; // at the closer's newline (or EOF)
+                    state.column = m - line_start;
+                    return true;
+                }
+            }
+            // not a closer — the line is content
+        }
+        // content line — emit it whole once its newline arrives (or at EOF when forced)
+        const nl = state.buffer.indexOf('\n', j);
+        if (nl === -1 && !forced)
+            return false; // hold the partial line
+        const line_end = nl === -1 ? state.buffer.length : nl;
+        const strip = line_start + Math.min(cb.fence_indent, line_indent);
+        const content = state.buffer.slice(strip, line_end);
+        emit_codeblock_text(state, cb, cb.text_id !== null ? '\n' + content : content, strip);
+        state.pos = nl === -1 ? line_end : line_end + 1;
+        state.column = 0;
+        state.prev_char = NEWLINE;
+    }
+    return true;
+};
+/**
+ * Check if the buffer at current position has a codeblock closing fence —
+ * a run of at least `backtick_count` backticks with only whitespace to end
+ * of line. Returns the position after the fence (including trailing newline)
+ * on success, `-1` when definitely not a fence, or `-2` when more input is
+ * needed to decide.
+ *
+ * When `forced` is true, EOF after the fence counts as a valid terminator
+ * (matches `mdz_parse`'s handling of code blocks at end of input).
+ *
+ * @nodocs
+ */
+export const match_codeblock_close = (state, backtick_count, forced = false) => {
+    let i = state.pos;
+    // count backticks
+    let count = 0;
+    while (i < state.buffer.length && state.buffer.charCodeAt(i) === BACKTICK) {
+        count++;
+        i++;
+    }
+    if (count < backtick_count) {
+        // buffer ended mid-backtick-sequence — could still grow into a fence
+        if (!forced && i >= state.buffer.length)
+            return -2;
+        return -1;
+    }
+    // trailing whitespace allowed
+    while (i < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(i))) {
+        i++;
+    }
+    // must be followed by newline or EOF
+    if (i < state.buffer.length && state.buffer.charCodeAt(i) === NEWLINE) {
+        return i + 1;
+    }
+    if (i >= state.buffer.length) {
+        // in forced mode, EOF terminates the fence
+        if (forced)
+            return i;
+        // enough backticks but buffer ended — the run could still grow, or
+        // whitespace/newline/disqualifying content could follow
+        return -2;
+    }
+    return -1;
+};

package/dist/mdz_stream_parser_inline.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Inline-formatting handlers (bold, italic, strikethrough, inline code)
+ * for the streaming mdz parser.
+ *
+ * @module
+ */
+import { type MdzStreamParserState } from './mdz_stream_parser_state.js';
+/**
+ * Try to open a doubled-delimiter inline (`**` bold, `~~` strikethrough) —
+ * the streaming analogue of the lexer's `#tokenize_double_delimiter`. No
+ * word-boundary checks, matching the one-shot parse: doubled delimiters are
+ * unambiguous enough to pair anywhere, and the first closer wins.
+ *
+ * @nodocs
+ */
+export declare const try_double_delimiter: (state: MdzStreamParserState, delimiter: "**" | "~~", node_type: "Bold" | "Strikethrough", forced?: boolean) => boolean;
+/**
+ * Try to open an italic span (`_`) — the streaming analogue of the lexer's
+ * `#tokenize_italic`.
+ *
+ * @nodocs
+ */
+export declare const try_italic: (state: MdzStreamParserState, forced?: boolean) => boolean;
+/**
+ * Whether the char after a closing italic candidate permits the close (only
+ * `_` has close-boundary rules — `**`/`~~` close anywhere). Word chars and
+ * `_` itself (self-opaque — `_x__` never closes on the first `_` of a run)
+ * fail the boundary.
+ *
+ * At end of buffer the boundary is treated as valid — only reachable in
+ * forced mode, where end-of-input is a true boundary; while streaming,
+ * `process_inline` holds the closer decision until the next char arrives.
+ *
+ * @nodocs
+ */
+export declare const check_close_word_boundary: (state: MdzStreamParserState) => boolean;
+/**
+ * Close an open delimiter-paired container (`Bold`, `Italic`, `Strikethrough`)
+ * at the given stack index, consuming the closing delimiter — read from the
+ * entry, so `**`/`~~` advance two chars and `_` one. The caller in
+ * `process_inline` already located the open via `find_open`, so we trust the
+ * index rather than re-walking the stack.
+ *
+ * @nodocs
+ */
+export declare const close_delimiter: (state: MdzStreamParserState, stack_idx: number) => boolean;
+/**
+ * Scan for the first potential closing `_` and check its word boundary (only
+ * italic has closer-boundary rules). 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
+ *
+ * The boundary check is self-opaque: a candidate followed by `_` itself is
+ * `'rejected'`, so underscore runs (`__init__`) degrade to literal text.
+ * While streaming, `'pending'` opens optimistically (the revert machinery
+ * corrects later); in forced mode it degrades to text.
+ *
+ * The delimiter search uses raw `indexOf` and stays amortized-linear without
+ * a memo: candidates are occurrences of the searched character itself, so a
+ * scan ends either at the next candidate (consecutive scans cover disjoint
+ * ranges) or at the end of the buffer with no candidates left to rescan it.
+ * The run-boundary probe (paragraph breaks, and list structure inside open
+ * lists) is bounded to the same window — only a boundary *before* the found
+ * delimiter matters — inheriting that amortization; an unbounded probe would
+ * rescan to EOF per candidate on single-paragraph input, going quadratic.
+ *
+ * @nodocs
+ */
+export declare const scan_closer_boundary: (state: MdzStreamParserState, forced?: boolean) => "confirmed" | "rejected" | "pending";
+/** @nodocs */
+export declare const try_code: (state: MdzStreamParserState, forced?: boolean) => boolean;
+/**
+ * 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.
+ *
+ * @nodocs
+ */
+export declare const code_search_limit: (state: MdzStreamParserState, from: number) => number;
+/**
+ * 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.
+ *
+ * @nodocs
+ */
+export declare const has_inline_formatting_on_stack: (state: MdzStreamParserState) => boolean;
+/**
+ * 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).
+ *
+ * @nodocs
+ */
+export declare const process_code_content: (state: MdzStreamParserState) => void;
+//# sourceMappingURL=mdz_stream_parser_inline.d.ts.map

package/dist/mdz_stream_parser_inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_inline.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_inline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EACN,KAAK,oBAAoB,EAYzB,MAAM,8BAA8B,CAAC;AA6GtC;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,WAAW,IAAI,GAAG,IAAI,EACtB,WAAW,MAAM,GAAG,eAAe,EACnC,gBAAc,KACZ,OA2BF,CAAC;AAIF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OAyCxE,CAAC;AAIF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,KAAG,OAOvE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,OAuBhF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,gBAAc,KACZ,WAAW,GAAG,UAAU,GAAG,SAmB7B,CAAC;AAIF,cAAc;AACd,eAAO,MAAM,QAAQ,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OAoFtE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,MAAM,MAAM,KAAG,MAyB7E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,GAAI,OAAO,oBAAoB,KAAG,OAO5E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,oBAAoB,KAAG,IA2ClE,CAAC"}