@fuzdev/fuz_ui 0.198.1 → 0.199.0

package/dist/mdz_stream_parser_block.js

@@ -0,0 +1,458 @@
+/**
+ * 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, } from './mdz_helpers.js';
+import { accumulate_text, 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.
+ * Returns true if consumed, false if needs more input, null if definitely not a heading.
+ */
+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 (but we might not have it yet)
+    // for streaming, we'll open the heading optimistically when we see `# `
+    // if the content turns out empty, that's an edge case we can handle on close
+    // 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.
+ * Returns true if consumed, false if needs more input, null if definitely not an HR.
+ * When `forced` is true, treats buffer end as EOF (no more input coming).
+ */
+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 spaces allowed before newline/EOF
+    while (i < state.buffer.length) {
+        const c = state.buffer.charCodeAt(i);
+        if (c === NEWLINE)
+            break;
+        if (c !== SPACE)
+            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),
+    });
+    if (forced) {
+        state.pos = state.buffer.length;
+    }
+    else {
+        state.pos = i;
+        if (i < state.buffer.length && state.buffer.charCodeAt(i) === NEWLINE) {
+            state.pos++; // consume the newline
+        }
+        // skip additional newlines
+        while (state.pos < state.buffer.length && state.buffer.charCodeAt(state.pos) === NEWLINE) {
+            state.pos++;
+        }
+        if (state.pos >= state.buffer.length) {
+            state.skip_leading_newlines = true;
+        }
+    }
+    state.column = 0;
+    state.prev_char = NEWLINE;
+    return 'consumed';
+};
+/**
+ * Try to open a code block at column 0.
+ *
+ * Opens the codeblock optimistically when possible. When the current paragraph
+ * has no prior content, opens immediately on `\`\`\`lang\n` without lookahead,
+ * enabling streaming. When the paragraph has content (text before the fence on
+ * a prior line), falls back to lookahead via `find_closing_fence` to avoid
+ * splitting the paragraph on revert.
+ */
+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)
+            break;
+        if (c === SPACE)
+            break;
+        i++;
+    }
+    const lang = i > lang_start ? state.buffer.slice(lang_start, i) : null;
+    // skip trailing spaces on opening fence line
+    while (i < state.buffer.length && state.buffer.charCodeAt(i) === SPACE) {
+        i++;
+    }
+    // must find newline
+    if (i >= state.buffer.length)
+        return 'need_more';
+    if (state.buffer.charCodeAt(i) !== NEWLINE)
+        return 'not_match';
+    i++; // consume newline
+    // when the current paragraph has content, closing it would split text on
+    // revert — fall back to lookahead to avoid that
+    if (state.in_paragraph && (state.accumulated_text.length > 0 || state.active_text_id !== null)) {
+        const closing_result = find_closing_fence(state, i, backtick_count);
+        if (closing_result === 'not_found')
+            return 'need_more';
+        if (closing_result === 'invalid')
+            return 'not_match';
+    }
+    // build delimiter for potential revert (e.g. "```ts\n" or "```\n")
+    const delimiter = state.buffer.slice(start, i);
+    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, delimiter, start: cb_start };
+    state.pos = i;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+    return 'consumed';
+};
+/**
+ * Scan buffer from `start` for a valid closing fence with `backtick_count` backticks.
+ * Used as a fallback when the current paragraph has prior content (to avoid
+ * splitting the paragraph on revert). Returns 'found' if a valid closing fence
+ * exists, 'not_found' if the buffer ends before we can determine, 'invalid' if
+ * we can see the full remaining content and there's no valid closing fence.
+ */
+export const find_closing_fence = (state, start, backtick_count) => {
+    let i = start;
+    const content_start = start;
+    let at_col0 = true;
+    while (i < state.buffer.length) {
+        if (at_col0 && state.buffer.charCodeAt(i) === BACKTICK) {
+            // count backticks
+            let count = 0;
+            const fence_start = i;
+            while (i < state.buffer.length && state.buffer.charCodeAt(i) === BACKTICK) {
+                count++;
+                i++;
+            }
+            if (count === backtick_count) {
+                // skip trailing spaces
+                while (i < state.buffer.length && state.buffer.charCodeAt(i) === SPACE) {
+                    i++;
+                }
+                // must be followed by newline or EOF
+                if (i >= state.buffer.length || state.buffer.charCodeAt(i) === NEWLINE) {
+                    // check for empty content
+                    const content = state.buffer.slice(content_start, fence_start);
+                    const final_content = content.endsWith('\n') ? content.slice(0, -1) : content;
+                    if (final_content.length === 0)
+                        return 'invalid'; // empty codeblock
+                    return 'found';
+                }
+            }
+            // not a valid fence — continue scanning
+            continue;
+        }
+        if (state.buffer.charCodeAt(i) === NEWLINE) {
+            at_col0 = true;
+        }
+        else {
+            at_col0 = false;
+        }
+        i++;
+    }
+    // reached end of buffer without finding closing fence
+    return 'not_found';
+};
+/**
+ * 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.
+ */
+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 `mdz_parse`'s
+ * `#match_code_block`, 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 state.ts) handles
+ * the revert-and-wrap dance after process completes.
+ */
+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);
+                }
+                // empty codeblock — revert (matches process_codeblock behavior)
+                if (cb.text_id === null && content.length === 0) {
+                    revert_empty_codeblock(state, cb);
+                    return;
+                }
+                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 reverts the (now-unclosed) codeblock.
+    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.
+ */
+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);
+                }
+                // empty codeblock: no content was ever emitted → invalid, revert
+                if (cb.text_id === null && content.length === 0) {
+                    return revert_empty_codeblock(state, cb);
+                }
+                // 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;
+                // skip newlines after codeblock
+                while (state.pos < state.buffer.length && state.buffer.charCodeAt(state.pos) === NEWLINE) {
+                    state.pos++;
+                }
+                // if buffer ended before absorbing all trailing newlines, continue in next chunk
+                if (state.pos >= state.buffer.length) {
+                    state.skip_leading_newlines = 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
+};
+/**
+ * Check if the buffer at current position has a codeblock closing fence.
+ * 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).
+ */
+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 become a fence
+        if (!forced && i >= state.buffer.length && count < backtick_count)
+            return -2;
+        return -1;
+    }
+    // trailing spaces allowed
+    while (i < state.buffer.length && state.buffer.charCodeAt(i) === SPACE) {
+        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;
+        // exact backtick count but buffer ended (could be spaces or newline coming)
+        return -2;
+    }
+    return -1;
+};
+/**
+ * Revert an empty codeblock (closing fence found but no content was emitted).
+ * Wraps the opening fence delimiter in a new paragraph and accumulates the
+ * closing fence text for normal paragraph processing.
+ */
+export const revert_empty_codeblock = (state, cb) => {
+    const wrap_id = alloc_id(state);
+    emit(state, {
+        type: 'revert',
+        id: cb.id,
+        replacement_text: cb.delimiter,
+        start: cb.start,
+        wrap_node_type: 'Paragraph',
+        wrap_id,
+    });
+    // enter paragraph mode with the wrapper
+    push_stack_entry(state, wrap_id, 'Paragraph', cb.start);
+    state.in_paragraph = true;
+    state.active_text_id = null;
+    state.codeblock = null;
+    // accumulate the closing fence text (backticks + spaces, without trailing newline)
+    const fence_start = state.pos;
+    let fence_content_end = fence_start;
+    while (fence_content_end < state.buffer.length &&
+        state.buffer.charCodeAt(fence_content_end) === BACKTICK) {
+        fence_content_end++;
+    }
+    while (fence_content_end < state.buffer.length &&
+        state.buffer.charCodeAt(fence_content_end) === SPACE) {
+        fence_content_end++;
+    }
+    accumulate_text(state, state.buffer.slice(fence_start, fence_content_end), offset(state, fence_start));
+    // position past the closing fence content, leaving any trailing newline for normal processing
+    state.pos = fence_content_end;
+    state.column = fence_content_end - fence_start;
+    state.prev_char =
+        fence_content_end > fence_start ? state.buffer.charCodeAt(fence_content_end - 1) : NEWLINE;
+    return true;
+};

package/dist/mdz_stream_parser_inline.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Inline-formatting handlers (bold, italic, strikethrough, inline code)
+ * for the streaming mdz parser.
+ *
+ * @module
+ */
+import { type MdzStreamParserState } from './mdz_stream_parser_state.js';
+export declare const try_bold: (state: MdzStreamParserState) => boolean;
+/**
+ * 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 declare const close_bold: (state: MdzStreamParserState, stack_idx: number) => boolean;
+export declare const try_italic: (state: MdzStreamParserState, forced?: boolean) => boolean;
+export declare const try_strikethrough: (state: MdzStreamParserState) => boolean;
+export declare const check_close_word_boundary: (state: MdzStreamParserState) => boolean;
+export declare const close_single_delimiter: (state: MdzStreamParserState, stack_idx: number) => boolean;
+/**
+ * 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 declare const scan_closer_boundary: (state: MdzStreamParserState, delimiter: string) => "confirmed" | "rejected" | "pending";
+export declare const try_code: (state: MdzStreamParserState) => 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.
+ */
+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.
+ */
+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).
+ */
+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;AAGH,OAAO,EACN,KAAK,oBAAoB,EASzB,MAAM,8BAA8B,CAAC;AAItC,eAAO,MAAM,QAAQ,GAAI,OAAO,oBAAoB,KAAG,OAmBtD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,OAsB3E,CAAC;AAIF,eAAO,MAAM,UAAU,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,OA4DxE,CAAC;AAIF,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,KAAG,OAmC/D,CAAC;AAIF,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,KAAG,OAOvE,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,OAqBvF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAChC,OAAO,oBAAoB,EAC3B,WAAW,MAAM,KACf,WAAW,GAAG,UAAU,GAAG,SAe7B,CAAC;AAIF,eAAO,MAAM,QAAQ,GAAI,OAAO,oBAAoB,KAAG,OAoFtD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,oBAAoB,EAAE,MAAM,MAAM,KAAG,MAc7E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GAAI,OAAO,oBAAoB,KAAG,OAO5E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,oBAAoB,KAAG,IA2ClE,CAAC"}