@fuzdev/mdz 0.1.0

package/dist/mdz_stream_parser_state.js

@@ -0,0 +1,651 @@
+/**
+ * Streaming parser state and low-level operations.
+ *
+ * Free functions take a `MdzStreamParserState` first parameter so handlers can
+ * live in separate sibling modules — JS private (`#`) fields can't cross
+ * module boundaries.
+ *
+ * @module
+ */
+import { NEWLINE, has_non_whitespace, mdz_heading_id_from_text } from './mdz_helpers.js';
+/** @nodocs */
+export const create_state = () => ({
+    buffer: '',
+    pos: 0,
+    opcodes: [],
+    next_id: 0,
+    stack: [],
+    column: 0,
+    prev_char: -1,
+    active_text_id: null,
+    accumulated_text: '',
+    accumulated_text_start: 0,
+    accumulated_text_end: 0,
+    codeblock: null,
+    list_levels: [],
+    blockquote: null,
+    in_list_item_run: false,
+    last_empty_item_end: 0,
+    base_offset: 0,
+    search_memo: null,
+    open_counts: { Bold: 0, Italic: 0, Strikethrough: 0, Link: 0 },
+    in_heading: false,
+    in_code: false,
+    in_paragraph: false,
+    pending_url: null,
+    heading_text_parts: [],
+    // matches mdz_parse: leading blank lines before any block are skipped, not
+    // preserved as paragraph content
+    skip_blank_lines: true,
+    paragraph_stack_idx: -1,
+    last_text_id: null,
+    last_text_ended_with_newline: false,
+    last_text_was_singleton_newline: false,
+});
+/** @nodocs */
+export const alloc_id = (state) => state.next_id++;
+/**
+ * Push a new container frame onto the stack. Fills the boilerplate fields
+ * (`has_children`, `has_non_whitespace_content`) so call sites only spell out
+ * what varies per container type. Keeping the object literal in one place
+ * also gives V8 a single monomorphic creation site for `StackEntry`.
+ *
+ * @nodocs
+ */
+export const push_stack_entry = (state, id, node_type, start, delimiter = '', tag_name) => {
+    state.stack.push({
+        id,
+        node_type,
+        delimiter,
+        tag_name,
+        has_children: false,
+        has_non_whitespace_content: false,
+        start,
+    });
+    if (node_type === 'Paragraph') {
+        state.paragraph_stack_idx = state.stack.length - 1;
+    }
+    else {
+        bump_open_count(state, node_type, 1);
+    }
+};
+/**
+ * Adjust the `open_counts` entry for a counted container type; no-op for
+ * uncounted types. Static-key accesses keep the property loads monomorphic —
+ * a keyed `counts[type]` access measurably regresses hot push/pop paths.
+ *
+ * @mutates `state.open_counts`
+ */
+const bump_open_count = (state, node_type, delta) => {
+    const counts = state.open_counts;
+    if (node_type === 'Bold')
+        counts.Bold += delta;
+    else if (node_type === 'Italic')
+        counts.Italic += delta;
+    else if (node_type === 'Strikethrough')
+        counts.Strikethrough += delta;
+    else if (node_type === 'Link')
+        counts.Link += delta;
+};
+/**
+ * Pop the top stack entry, keeping `open_counts` in sync. All pops of inline
+ * containers must go through this — the only direct stack removal elsewhere
+ * is `revert_failed_close`'s mid-stack splice, which adjusts the count itself.
+ *
+ * @mutates `state`
+ * @nodocs
+ */
+export const pop_stack_entry = (state) => {
+    const entry = state.stack.pop();
+    bump_open_count(state, entry.node_type, -1);
+    return entry;
+};
+/**
+ * Mark the innermost open `Paragraph` as having non-whitespace content,
+ * via the `paragraph_stack_idx` cache (O(1) instead of an O(stack) walk).
+ *
+ * No-op when no Paragraph is open — that includes the Heading case, since
+ * block boundaries are mutually exclusive (a Heading on stack means
+ * `paragraph_stack_idx === -1`).
+ */
+const mark_paragraph_non_whitespace = (state) => {
+    if (state.paragraph_stack_idx === -1)
+        return;
+    state.stack[state.paragraph_stack_idx].has_non_whitespace_content = true;
+};
+/**
+ * Global byte offset for a local buffer position.
+ *
+ * @nodocs
+ */
+export const offset = (state, pos = state.pos) => state.base_offset + pos;
+/**
+ * Seal the prior text run so `trim_trailing_newline` can no longer target it.
+ * Called when a structural opcode (open/close/revert) ends the run.
+ *
+ * @mutates `state`
+ */
+const seal_text_run = (state) => {
+    state.last_text_id = null;
+    state.last_text_ended_with_newline = false;
+    state.last_text_was_singleton_newline = false;
+};
+/**
+ * Memoized `String#indexOf` over `state.buffer` against the given memo
+ * record, taking and returning **local** buffer positions.
+ *
+ * The streaming analogue of the sync lexer's memoized `#index_of`: a failed
+ * search would otherwise rescan the remaining buffer on every candidate,
+ * making inputs dense in unclosed candidates quadratic. Unlike the sync case
+ * the buffer mutates — `feed()` appends and the parser compacts consumed
+ * bytes from the front — so the memo lives in global byte coordinates
+ * (compaction shifts local positions but global content is immutable) and a
+ * not-found result records how far it scanned (`searched_to`). After an
+ * append, only the new tail is rescanned, backed up by `needle.length - 1`
+ * bytes to catch needles straddling the old boundary.
+ *
+ * A memoized found result earlier than `from` falls through to a fresh scan,
+ * same as the sync memo — the parser's scan positions are monotonic, so each
+ * needle's missing-suffix region is still scanned at most once per append.
+ *
+ * @mutates `memo`
+ */
+const memo_index_of = (state, memo, needle, from) => {
+    const global_from = state.base_offset + from;
+    const global_end = state.base_offset + state.buffer.length;
+    if (memo.from <= global_from) {
+        if (memo.result >= global_from)
+            return memo.result - state.base_offset;
+        if (memo.result === -1) {
+            if (memo.searched_to >= global_end)
+                return -1; // nothing appended since
+            // rescan only the appended tail, overlapping the old boundary so a
+            // straddling needle isn't missed
+            const rescan_from = Math.max(global_from, memo.searched_to - (needle.length - 1));
+            const result = state.buffer.indexOf(needle, rescan_from - state.base_offset);
+            memo.from = global_from;
+            memo.result = result === -1 ? -1 : state.base_offset + result;
+            memo.searched_to = global_end;
+            return result;
+        }
+        // found result already behind `from` — fall through to a fresh scan
+    }
+    const result = state.buffer.indexOf(needle, from);
+    memo.from = global_from;
+    memo.result = result === -1 ? -1 : state.base_offset + result;
+    memo.searched_to = global_end;
+    return result;
+};
+/**
+ * Memoized buffer search for an arbitrary needle, backed by the per-needle
+ * `search_memo` map (created on first use). Used for cold-path scans with
+ * dynamic needles — the stack-delimiter searches in `code_search_limit`,
+ * where unclosed-tag delimiters absent from the rest of the input would
+ * otherwise rescan to the buffer end on every backtick candidate.
+ *
+ * @mutates `state.search_memo`
+ * @nodocs
+ */
+export const buffer_index_of = (state, needle, from) => {
+    const map = (state.search_memo ??= new Map());
+    let memo = map.get(needle);
+    if (memo === undefined) {
+        // "scanned [0, 0), found nothing" — memo_index_of handles the full scan
+        memo = { from: 0, result: -1, searched_to: 0 };
+        map.set(needle, memo);
+    }
+    return memo_index_of(state, memo, needle, from);
+};
+/**
+ * Emit an opcode into the pending batch (drained by `take_opcodes`),
+ * maintaining the `has_children`/non-whitespace bookkeeping on open frames.
+ *
+ * @nodocs
+ */
+export const emit = (state, op) => {
+    state.opcodes.push(op);
+    // mark the innermost container as having children
+    if (op.type === 'text' || op.type === 'append_text' || op.type === 'void') {
+        const top = state.stack[state.stack.length - 1];
+        if (top) {
+            top.has_children = true;
+            // propagate non-whitespace marker to the nearest Paragraph so
+            // whitespace-only paragraphs can be discarded at close
+            if (op.type === 'void' || has_non_whitespace(op.content)) {
+                mark_paragraph_non_whitespace(state);
+            }
+        }
+    }
+    else if (op.type === 'open') {
+        // opening a child container counts as content for the parent
+        const parent = state.stack[state.stack.length - 1];
+        if (parent) {
+            parent.has_children = true;
+            mark_paragraph_non_whitespace(state);
+        }
+    }
+    else if (op.type === 'wrap') {
+        // retroactive Link wrap of a text node — the resulting Link is non-whitespace
+        mark_paragraph_non_whitespace(state);
+    }
+    // track the most recent text run so `trim_trailing_newline` can target it
+    // after `take_opcodes()` has drained the queue
+    if (op.type === 'text') {
+        state.last_text_id = op.id;
+        state.last_text_ended_with_newline = op.content.endsWith('\n');
+        state.last_text_was_singleton_newline = op.content === '\n';
+    }
+    else if (op.type === 'append_text') {
+        state.last_text_id = op.id;
+        state.last_text_ended_with_newline = op.content.endsWith('\n');
+        // append_text builds on a prior text node; the underlying node can't be
+        // singleton even if this appended chunk is just '\n'
+        state.last_text_was_singleton_newline = false;
+    }
+    else if (op.type === 'open' || op.type === 'close' || op.type === 'revert') {
+        seal_text_run(state);
+    }
+    // track text content for heading ID computation
+    if (state.in_heading && state.heading_text_parts.length > 0) {
+        if (op.type === 'text' || op.type === 'append_text') {
+            state.heading_text_parts[state.heading_text_parts.length - 1] += op.content;
+        }
+        else if (op.type === 'open') {
+            // child container: push a new segment for its text content
+            state.heading_text_parts.push('');
+        }
+        else if (op.type === 'close') {
+            // normal close: pop child's text and merge into parent
+            if (state.heading_text_parts.length > 1) {
+                const child_text = state.heading_text_parts.pop();
+                state.heading_text_parts[state.heading_text_parts.length - 1] += child_text;
+            }
+        }
+        else if (op.type === 'revert') {
+            // revert: pop child's text, prepend replacement (document order), merge into parent
+            if (state.heading_text_parts.length > 1) {
+                const child_text = state.heading_text_parts.pop();
+                state.heading_text_parts[state.heading_text_parts.length - 1] +=
+                    (op.replacement_text || '') + child_text;
+            }
+        }
+    }
+};
+/**
+ * Accumulate text, tracking the source span (start of the first character, end past the last).
+ *
+ * @nodocs
+ */
+export const accumulate_text = (state, text, start_offset) => {
+    if (state.accumulated_text.length === 0) {
+        state.accumulated_text_start = start_offset;
+    }
+    state.accumulated_text += text;
+    state.accumulated_text_end = start_offset + text.length;
+};
+/**
+ * Extend the accumulated text's source span past content that was stripped
+ * from it — a list continuation line's structural indent. The sync parser
+ * attributes the stripped region to the preceding text token, so node `end`s
+ * stay source-accurate across both pipelines.
+ *
+ * @mutates `state`
+ * @nodocs
+ */
+export const extend_accumulated_end = (state, end) => {
+    state.accumulated_text_end = end;
+};
+/**
+ * Flush accumulated text as a text or append_text opcode. Opcode `end`s come
+ * from the tracked source span, which can outgrow the content length when
+ * list continuation lines strip structural indent.
+ *
+ * @nodocs
+ */
+export const flush_text = (state) => {
+    if (state.accumulated_text.length === 0)
+        return;
+    if (state.active_text_id !== null) {
+        emit(state, {
+            type: 'append_text',
+            id: state.active_text_id,
+            content: state.accumulated_text,
+            end: state.accumulated_text_end,
+        });
+    }
+    else {
+        ensure_paragraph(state);
+        const id = alloc_id(state);
+        const start = state.accumulated_text_start;
+        emit(state, {
+            type: 'text',
+            id,
+            content: state.accumulated_text,
+            text_type: 'Text',
+            start,
+            end: state.accumulated_text_end,
+        });
+        state.active_text_id = id;
+    }
+    state.accumulated_text = '';
+};
+/**
+ * Open a Paragraph frame unless a run frame is already current — an open
+ * paragraph or heading, or a list item's first inline run (which flows
+ * directly into the ListItem frame, matching the sync AST's direct-children
+ * shape).
+ *
+ * @nodocs
+ */
+export const ensure_paragraph = (state) => {
+    if (state.in_heading || state.in_paragraph || state.in_list_item_run)
+        return;
+    const id = alloc_id(state);
+    const start = offset(state);
+    emit(state, { type: 'open', id, node_type: 'Paragraph', start });
+    push_stack_entry(state, id, 'Paragraph', start);
+    state.in_paragraph = true;
+};
+/**
+ * Whether a stack frame bounds an inline run — inline pairs never cross a
+ * Paragraph, Heading, or ListItem frame (an item's first run is a
+ * paragraph-equivalent region; a List frame is never the innermost frame
+ * under inline content, so checking it is unnecessary).
+ *
+ * @nodocs
+ */
+export const is_run_boundary = (node_type) => node_type === 'Paragraph' || node_type === 'Heading' || node_type === 'ListItem';
+/**
+ * Find the innermost open container of a given type.
+ * Returns stack index, or -1 if not found.
+ * Does not cross run boundaries (Paragraph, Heading, ListItem).
+ *
+ * The "nothing open" case is O(1) via `open_counts` — without it, every
+ * candidate char in a deep-stack paragraph (unclosed optimistic tags leak
+ * one frame per line) walks to the block boundary, going quadratic.
+ *
+ * @nodocs
+ */
+export const find_open = (state, type) => {
+    const counts = state.open_counts;
+    const count = type === 'Bold'
+        ? counts.Bold
+        : type === 'Italic'
+            ? counts.Italic
+            : type === 'Strikethrough'
+                ? counts.Strikethrough
+                : counts.Link;
+    if (count === 0)
+        return -1;
+    for (let i = state.stack.length - 1; i >= 0; i--) {
+        const entry = state.stack[i];
+        if (entry.node_type === type)
+            return i;
+        if (is_run_boundary(entry.node_type))
+            return -1;
+    }
+    return -1;
+};
+/**
+ * Revert all stack entries above the given index. Every inline open is
+ * optimistic, so anything above a known frame is revertable by construction.
+ *
+ * @nodocs
+ */
+export const revert_above = (state, target_idx) => {
+    while (state.stack.length - 1 > target_idx) {
+        const entry = pop_stack_entry(state);
+        if (entry.node_type === 'Code')
+            state.in_code = false;
+        emit(state, {
+            type: 'revert',
+            id: entry.id,
+            replacement_text: entry.delimiter,
+            start: entry.start,
+        });
+    }
+    state.active_text_id = null;
+};
+/**
+ * Revert an open `Italic` whose first closer candidate failed its boundary
+ * check (italic is the only inline with closer-boundary rules). One-shot
+ * parsing greedy-rejects the opener at the first invalid closer, so once a
+ * failed candidate is seen, the optimistic open is known wrong — reverting
+ * immediately (instead of leaving the container open for a later closer)
+ * keeps chunked output identical to the one-shot parse.
+ *
+ * Unlike `revert_above`, this reverts a possibly
+ * **mid-stack** entry: containers opened above it (e.g. a Bold inside the
+ * failed Italic) stay open — the one-shot parse opens them at top level, and
+ * the consumers' revert handlers re-parent them identically (the reverted
+ * node is still its parent's last child; see `mdz_opcodes_to_nodes` and
+ * `MdzStreamState`).
+ *
+ * Bypasses `emit` for the opcode push: `emit`'s heading-segment handling
+ * assumes the reverted container is the innermost open one, which doesn't
+ * hold mid-stack — the segment merge here targets the reverted frame's own
+ * segment, keeping the segments of still-open frames above it live.
+ *
+ * @mutates `state`
+ * @nodocs
+ */
+export const revert_failed_close = (state, stack_idx) => {
+    flush_text(state);
+    const entry = state.stack[stack_idx];
+    const frames_above = state.stack.length - 1 - stack_idx;
+    state.stack.splice(stack_idx, 1);
+    bump_open_count(state, entry.node_type, -1);
+    state.opcodes.push({
+        type: 'revert',
+        id: entry.id,
+        replacement_text: entry.delimiter,
+        start: entry.start,
+    });
+    // structural opcode seals the prior text run (mirrors `emit`)
+    seal_text_run(state);
+    // heading slug bookkeeping: fold the reverted frame's segment into its
+    // parent segment, delimiter text first (document order)
+    if (state.in_heading && state.heading_text_parts.length > 1) {
+        const seg_idx = state.heading_text_parts.length - 1 - frames_above;
+        if (seg_idx >= 1) {
+            const seg = state.heading_text_parts.splice(seg_idx, 1)[0];
+            state.heading_text_parts[seg_idx - 1] += entry.delimiter + seg;
+        }
+    }
+    state.active_text_id = null;
+};
+/**
+ * Trim a trailing newline from paragraph content.
+ * Checks unflushed accumulated text first; otherwise emits a `trim_text`
+ * opcode targeting the most recent text/append_text via the tracking fields
+ * on `state` (which survive `take_opcodes()` drains). The opcode stream
+ * stays append-only — no retroactive opcode mutation.
+ *
+ * @nodocs
+ */
+export const trim_trailing_newline = (state) => {
+    if (state.accumulated_text.endsWith('\n')) {
+        state.accumulated_text = state.accumulated_text.slice(0, -1);
+        return;
+    }
+    if (state.last_text_id === null || !state.last_text_ended_with_newline)
+        return;
+    // emit trim opcode; consumer adjusts content and removes empty nodes
+    emit(state, { type: 'trim_text', id: state.last_text_id, count: 1 });
+    // if this trim empties a singleton text node, clear active_text_id so
+    // subsequent content doesn't merge into a deleted node via append_text
+    if (state.last_text_was_singleton_newline) {
+        state.active_text_id = null;
+    }
+    // after trim, the prior text no longer ends in \n — guard against re-trim
+    state.last_text_ended_with_newline = false;
+    state.last_text_was_singleton_newline = false;
+};
+/** @nodocs */
+export const close_paragraph = (state) => {
+    // find and close the paragraph on the stack
+    for (let i = state.stack.length - 1; i >= 0; i--) {
+        if (state.stack[i].node_type === 'Paragraph') {
+            // trim trailing newline from paragraph content
+            trim_trailing_newline(state);
+            revert_above(state, i);
+            const entry = pop_stack_entry(state);
+            // drop whitespace-only paragraphs to match `mdz_parse`'s output;
+            // consumers (`mdz_opcodes_to_nodes`, `MdzStreamState`) honor `discard`
+            // by removing the node and its descendants from the tree
+            const discard = !entry.has_non_whitespace_content;
+            emit(state, discard
+                ? { type: 'close', id: entry.id, end: offset(state), discard: true }
+                : { type: 'close', id: entry.id, end: offset(state) });
+            state.active_text_id = null;
+            state.in_paragraph = false;
+            state.paragraph_stack_idx = -1;
+            return;
+        }
+    }
+};
+/** @nodocs */
+export const close_heading = (state) => {
+    // find the heading frame and revert the open inlines above it (before
+    // clearing in_heading, so revert replacement text is captured in
+    // heading_text_parts)
+    let heading_idx = -1;
+    for (let i = state.stack.length - 1; i >= 0; i--) {
+        if (state.stack[i].node_type === 'Heading') {
+            heading_idx = i;
+            break;
+        }
+    }
+    if (heading_idx !== -1) {
+        revert_above(state, heading_idx);
+    }
+    // compute heading ID from accumulated text before clearing heading state
+    const heading_text = state.heading_text_parts.join('');
+    state.heading_text_parts = [];
+    state.in_heading = false;
+    if (heading_idx === -1)
+        return;
+    const heading_id = mdz_heading_id_from_text(heading_text);
+    // the heading is now the top of the stack
+    const entry = pop_stack_entry(state);
+    emit(state, { type: 'close', id: entry.id, end: offset(state), heading_id });
+    state.active_text_id = null;
+};
+/**
+ * Close a codeblock left open at EOF. Raw mode is absolute — an unclosed
+ * fence consumes to EOF as content — so this is a plain close after trimming
+ * one trailing newline, matching closed fences' content shape (which
+ * excludes the newline before the closer line) and the sync parser's
+ * unclosed-fence trim.
+ *
+ * @nodocs
+ */
+export const close_codeblock_at_eof = (state) => {
+    if (!state.codeblock)
+        return;
+    // in-item content emits line-by-line with '\n' separators and never gains
+    // a trailing newline, so only top-level bulk emission needs the trim
+    if (state.codeblock.fence_indent === 0) {
+        trim_trailing_newline(state);
+    }
+    emit(state, { type: 'close', id: state.codeblock.id, end: offset(state) });
+    state.codeblock = null;
+};
+/**
+ * Seal the innermost ListItem's first inline run: flush text and revert the
+ * optimistic inlines above the ListItem frame. The item itself stays open —
+ * block children (nested lists, paragraphs, code blocks) may follow.
+ *
+ * @nodocs
+ */
+export const seal_list_item_run = (state) => {
+    if (!state.in_list_item_run)
+        return;
+    flush_text(state);
+    for (let i = state.stack.length - 1; i >= 0; i--) {
+        if (state.stack[i].node_type === 'ListItem') {
+            revert_above(state, i);
+            break;
+        }
+    }
+    state.in_list_item_run = false;
+    state.active_text_id = null;
+};
+/**
+ * Close the current inline run inside a list, whichever frame holds it: a
+ * `Paragraph` block child closes, an item's first run seals. No-op when no
+ * run is current (post-blank, post-block-child).
+ *
+ * @nodocs
+ */
+export const close_list_run = (state) => {
+    if (state.in_paragraph) {
+        flush_text(state);
+        close_paragraph(state);
+    }
+    else {
+        seal_list_item_run(state);
+    }
+};
+/**
+ * Close the deepest open level's current item. The run must already be
+ * sealed/closed, leaving the ListItem frame on top of the stack. A childless
+ * close means an empty item — its `end` is the marker end recorded at open
+ * (the sync parser's `open.end` fallback); otherwise consumers derive the
+ * node's `end` from its children, so the offset here is cosmetic.
+ *
+ * @nodocs
+ */
+export const close_list_item = (state) => {
+    const entry = pop_stack_entry(state);
+    emit(state, {
+        type: 'close',
+        id: entry.id,
+        end: entry.has_children ? offset(state) : state.last_empty_item_end,
+    });
+    state.active_text_id = null;
+};
+/**
+ * Close the deepest open level: its current item, then its list.
+ *
+ * @nodocs
+ */
+export const close_list_level = (state) => {
+    close_list_item(state);
+    const entry = pop_stack_entry(state);
+    emit(state, { type: 'close', id: entry.id, end: offset(state) });
+    state.list_levels.pop();
+};
+/**
+ * Close every open list level — the whole stack — sealing the item's first
+ * run if current. A current `Paragraph` block child must be closed by the
+ * caller first (`close_paragraph` in `finish()`, `close_list_run` in the
+ * classifier).
+ *
+ * @nodocs
+ */
+export const close_all_list_levels = (state) => {
+    if (state.list_levels.length === 0)
+        return;
+    seal_list_item_run(state);
+    while (state.list_levels.length > 0) {
+        close_list_level(state);
+    }
+};
+/** @nodocs */
+export const handle_paragraph_break = (state) => {
+    flush_text(state);
+    // `close_paragraph` reverts everything above the paragraph frame itself.
+    // Its trailing-newline trim runs before those reverts, but the ordering is
+    // unobservable here: content at a paragraph break never ends in `\n` (the
+    // break's first newline is absorbed by `skip_blank_region`, and a lone held
+    // `\n` at buffer end never accumulates), so there's never a trim to emit.
+    close_paragraph(state);
+    // the break's newlines and blank lines are absorbed by `skip_blank_region`
+    // at the top of the process loop, which also carries the absorb across
+    // chunks — otherwise a blank run split mid-stream would leak a leading
+    // `\n` into the next paragraph's text
+    state.skip_blank_lines = true;
+    state.column = 0;
+    state.prev_char = NEWLINE;
+};

package/dist/mdz_stream_parser_text.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Plain-text run consumption for the streaming mdz parser.
+ *
+ * @module
+ */
+import { type MdzStreamParserState } from './mdz_stream_parser_state.js';
+/**
+ * Consume a delimiter at the current position as literal text — the shared
+ * tail of every "this delimiter doesn't open/close anything here" decision
+ * (failed boundary, EOF degrade, greedy-rejected closer, lone `*`/`]`).
+ *
+ * @mutates `state`
+ * @nodocs
+ */
+export declare const consume_delimiter_as_text: (state: MdzStreamParserState, delimiter: string) => void;
+/**
+ * Consume a run of plain text characters. Scans ahead to the next
+ * structurally interesting character and accumulates the whole run
+ * as a single slice, avoiding per-character string concatenation
+ * and dispatch overhead.
+ *
+ * @nodocs
+ */
+export declare const consume_text_run: (state: MdzStreamParserState) => void;
+//# sourceMappingURL=mdz_stream_parser_text.d.ts.map

package/dist/mdz_stream_parser_text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_text.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqBH,OAAO,EACN,KAAK,oBAAoB,EAIzB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,oBAAoB,EAAE,WAAW,MAAM,KAAG,IAM1F,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,oBAAoB,KAAG,IAsC9D,CAAC"}