@fuzdev/mdz 0.1.0

package/dist/mdz_stream_parser_state.d.ts

@@ -0,0 +1,476 @@
+/**
+ * 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 type { MdzNodeTypeContainer, MdzNodeId, MdzOpcode } from './mdz_opcodes.js';
+/**
+ * Tri-state result for `try_*` parser handlers.
+ * - `'consumed'`: input matched and the parser advanced
+ * - `'need_more'`: input is potentially valid but more bytes are required to decide
+ * - `'not_match'`: input definitely doesn't match — caller falls through to the next handler
+ *
+ * @nodocs
+ */
+export type TryResult = 'consumed' | 'need_more' | 'not_match';
+/** @nodocs */
+export interface StackEntry {
+    id: MdzNodeId;
+    node_type: MdzNodeTypeContainer;
+    /**
+     * The opening delimiter text, used as `replacement_text` on revert.
+     * Empty for the block frames (`Paragraph`, `Heading`), which are never
+     * reverted — every inline open is optimistic (speculative, reverted if not
+     * closed), so the revert loops don't need a per-entry flag.
+     */
+    delimiter: string;
+    /** Tag name for Element/Component entries, `undefined` for all others. */
+    tag_name: string | undefined;
+    /** Whether any child content has been emitted inside this container. */
+    has_children: boolean;
+    /**
+     * Whether any non-whitespace text or non-text child has been emitted
+     * inside this container. Only tracked for `Paragraph` entries to detect
+     * whitespace-only paragraphs that should be dropped at close.
+     */
+    has_non_whitespace_content: boolean;
+    /** Global byte offset of the opening delimiter. */
+    start: number;
+}
+/**
+ * Memo entry for `buffer_index_of`, in **global** byte coordinates (see
+ * `MdzStreamParserState.base_offset`). Global coordinates make the memo
+ * immune to front-compaction: content at a global offset never changes once
+ * fed, so a found result stays valid forever and a not-found result stays
+ * valid for the byte range it scanned (`searched_to`).
+ *
+ * @nodocs
+ */
+export interface BufferSearchMemo {
+    /** Global byte offset the memoized scan started from. */
+    from: number;
+    /** Global byte offset of the found occurrence, or `-1` when not found. */
+    result: number;
+    /** Global byte offset of the buffer end when the scan ran — the extent a `-1` result covers. */
+    searched_to: number;
+}
+/** @nodocs */
+export interface CodeblockState {
+    id: MdzNodeId;
+    backtick_count: number;
+    text_id: MdzNodeId | null;
+    /**
+     * The opener line's indent — 0 for top-level fences, the marker-relative
+     * line indent for in-item fences. Closers match at any indent <= this,
+     * and content lines strip `min(fence_indent, line_indent)`.
+     */
+    fence_indent: number;
+    /** Global byte offset of the opening fence. */
+    start: number;
+}
+/**
+ * An open list level — the column of its markers, mirroring the sync lexer's stack.
+ *
+ * @nodocs
+ */
+export interface MdzListLevel {
+    indent: number;
+    ordered: boolean;
+}
+/**
+ * An open blockquote — the streaming analogue of the sync lexer's quote
+ * sub-lex. A quote's content is a mini-document behind the per-line prefix,
+ * so the quote owns a **nested parser state**: the outer parser strips one
+ * prefix level per line and feeds the remainder (including each line's
+ * terminating newline) to `inner`, whose opcodes pass through with positions
+ * remapped to source offsets. Nesting recurses — `inner` opens its own quote
+ * for deeper prefixes — so the outer parser tracks at most one quote
+ * directly. The id counter is shared (`inner.next_id` seeds from the outer's
+ * and syncs back at close), so pass-through opcodes need no id remapping.
+ *
+ * @nodocs
+ */
+export interface MdzBlockquoteState {
+    /** The Blockquote frame's node id. */
+    id: MdzNodeId;
+    /** The nested parser state for the quote's content document. */
+    inner: MdzStreamParserState;
+    /**
+     * Affine segments mapping inner-document offsets to global source
+     * offsets — one per quote line; the line's content and terminating
+     * newline are contiguous in both coordinate spaces.
+     */
+    segments: Array<{
+        inner_start: number;
+        source_start: number;
+    }>;
+    /** Total bytes fed to the inner document so far. */
+    inner_len: number;
+    /**
+     * Inner-coordinate end of each live text node, tracked so forwarded
+     * `append_text` opcodes can carry explicit remapped `end`s — an implied
+     * extend-by-content-length is wrong across the prefix gap at line
+     * boundaries.
+     */
+    text_inner_ends: Map<MdzNodeId, number>;
+    /** The attach item's marker indent for in-item quotes; -1 at top level. */
+    item_indent: number;
+}
+/**
+ * Counts of open inline containers by type, letting `find_open` answer the
+ * common "nothing open" case in O(1) instead of walking a stack that can grow
+ * arbitrarily deep with unclosed optimistic tags (tag-dense single-paragraph
+ * input leaks one `<Tag>` frame per line). Only the types `find_open` is
+ * queried with are counted. The counts are run-scoped for free: every run
+ * frame below the current one sealed by reverting its inlines (decrementing
+ * their counts), so all counted entries sit above the innermost run boundary
+ * (Paragraph, Heading, or ListItem).
+ *
+ * @nodocs
+ */
+export interface OpenInlineCounts {
+    Bold: number;
+    Italic: number;
+    Strikethrough: number;
+    Link: number;
+}
+/**
+ * Pending auto-link URL/path state for text-first rendering.
+ * When set, URL chars flow as visible text. On terminator, a `wrap` opcode
+ * retroactively wraps the text node in a Link.
+ *
+ * For URLs, `confirmed` starts false during speculative prefix matching
+ * (chars stream as text while we verify `https://` or `http://`).
+ * For paths, `confirmed` starts true (prefix already validated by hold).
+ *
+ * @nodocs
+ */
+export interface PendingUrl {
+    url_text: string;
+    start: number;
+    link_type: 'external' | 'internal';
+    /** Whether the URL/path prefix has been fully confirmed. */
+    confirmed: boolean;
+    /** Prefix match tracking — only used when `!confirmed`. */
+    viable_https: boolean;
+    viable_http: boolean;
+}
+/**
+ * Mutable state for the streaming parser. One instance per `MdzStreamParser`.
+ * Handlers in sibling modules take this as their first parameter — the streaming
+ * parser uses free functions, not class methods, so state crosses module
+ * boundaries.
+ *
+ * @nodocs
+ */
+export interface MdzStreamParserState {
+    buffer: string;
+    pos: number;
+    opcodes: Array<MdzOpcode>;
+    next_id: MdzNodeId;
+    stack: Array<StackEntry>;
+    column: number;
+    prev_char: number;
+    active_text_id: MdzNodeId | null;
+    accumulated_text: string;
+    accumulated_text_start: number;
+    /**
+     * Global byte offset just past the accumulated text's source span. Equals
+     * `accumulated_text_start + accumulated_text.length` except when list
+     * continuation lines strip structural indent — content is then shorter
+     * than its source span, and flushes carry this so consumers keep
+     * source-accurate node `end`s.
+     */
+    accumulated_text_end: number;
+    codeblock: CodeblockState | null;
+    /**
+     * Open list levels, deepest last — the streaming analogue of the sync
+     * lexer's level stack in `#tokenize_list`. Non-empty exactly while
+     * List/ListItem frames are on `stack`; newlines then route to the list
+     * line classifier instead of the top-level paragraph-break scan.
+     */
+    list_levels: Array<MdzListLevel>;
+    /**
+     * The open blockquote, or null. While set, all input routes through the
+     * quote (prefix stripping + nested-parser feeding) — see `MdzBlockquoteState`.
+     */
+    blockquote: MdzBlockquoteState | null;
+    /**
+     * Whether the innermost open ListItem's first inline run is current.
+     * Content then flows directly into the ListItem frame — the sync AST
+     * keeps an item's first run as direct children — so `ensure_paragraph`
+     * is suppressed. Cleared when the run ends (blank line, dedent, block
+     * child); later runs in the item open `Paragraph` block children.
+     */
+    in_list_item_run: boolean;
+    /**
+     * Source end (just past the marker chars) of the most recently opened
+     * empty list item — the close opcode's `end` when an item closes
+     * childless, mirroring the sync parser's `open.end` fallback. One slot
+     * suffices: only empty items can close childless, and at most one can be
+     * open untouched (anything emitted after it opened becomes its child;
+     * a sibling closes it before the next empty item opens).
+     */
+    last_empty_item_end: number;
+    /** Global byte offset of the start of `buffer`. */
+    base_offset: number;
+    /**
+     * Per-needle search memo for `buffer_index_of`, keyed by needle.
+     * Created lazily — only `code_search_limit`'s cold path uses it, and the
+     * per-parser `Map` allocation is measurable on tiny inputs.
+     */
+    search_memo: Map<string, BufferSearchMemo> | null;
+    /** Open-container counts for `find_open`'s O(1) "nothing open" early exit. */
+    open_counts: OpenInlineCounts;
+    /** Whether we're inside a heading (newline ends it). */
+    in_heading: boolean;
+    /** Whether we're inside an optimistic inline Code container. */
+    in_code: boolean;
+    /** Cached flag: whether a Paragraph is open on the stack. */
+    in_paragraph: boolean;
+    pending_url: PendingUrl | null;
+    /**
+     * Stack of text segments for heading ID computation.
+     * Each open container inside a heading pushes a new segment.
+     * On close: pop and append to parent (children's text is part of heading).
+     * On revert: pop, prepend replacement_text, append to parent
+     * (document order: delimiter text comes before children's text).
+     */
+    heading_text_parts: Array<string>;
+    /**
+     * When true, absorb the blank region (newlines and whitespace-only lines)
+     * at the current position before normal processing. Set after block-element
+     * closes (codeblock, heading, HR) and paragraph breaks; stays set across
+     * chunks until a content line arrives — needed for char-by-char streaming
+     * where post-block blanks arrive in later chunks. Consumed by
+     * `skip_blank_region` in `mdz_stream_parser.ts`.
+     */
+    skip_blank_lines: boolean;
+    /**
+     * Stack index of the innermost open `Paragraph`, or `-1` when none.
+     * Lets `mark_paragraph_non_whitespace` skip the stack walk that runs on
+     * every non-whitespace emit. Updated only on Paragraph push/pop (block
+     * boundaries — only one of `Paragraph`/`Heading` can be on the stack
+     * at a time, so the cache is stable across inline pushes/pops).
+     */
+    paragraph_stack_idx: number;
+    /**
+     * Id of the most-recent `text`/`append_text` emission, used by
+     * `trim_trailing_newline` to target the right opcode after `take_opcodes()`
+     * has drained the queue. `null` after a structural emit (open/close/revert)
+     * sealed the prior text run.
+     */
+    last_text_id: MdzNodeId | null;
+    /** Whether the most recent text emission's content ended in `'\n'`. */
+    last_text_ended_with_newline: boolean;
+    /**
+     * Whether the most recent text emission was a `text` opcode (not
+     * `append_text`) with content exactly `'\n'` — trimming the trailing \n
+     * would leave the text node empty, so `active_text_id` must be cleared
+     * to keep subsequent content from merging into a deleted node.
+     */
+    last_text_was_singleton_newline: boolean;
+}
+/** @nodocs */
+export declare const create_state: () => MdzStreamParserState;
+/** @nodocs */
+export declare const alloc_id: (state: MdzStreamParserState) => MdzNodeId;
+/**
+ * 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 declare const push_stack_entry: (state: MdzStreamParserState, id: MdzNodeId, node_type: MdzNodeTypeContainer, start: number, delimiter?: string, tag_name?: string) => void;
+/**
+ * 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 declare const pop_stack_entry: (state: MdzStreamParserState) => StackEntry;
+/**
+ * Global byte offset for a local buffer position.
+ *
+ * @nodocs
+ */
+export declare const offset: (state: MdzStreamParserState, pos?: number) => number;
+/**
+ * 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 declare const buffer_index_of: (state: MdzStreamParserState, needle: string, from: number) => number;
+/**
+ * Emit an opcode into the pending batch (drained by `take_opcodes`),
+ * maintaining the `has_children`/non-whitespace bookkeeping on open frames.
+ *
+ * @nodocs
+ */
+export declare const emit: (state: MdzStreamParserState, op: MdzOpcode) => void;
+/**
+ * Accumulate text, tracking the source span (start of the first character, end past the last).
+ *
+ * @nodocs
+ */
+export declare const accumulate_text: (state: MdzStreamParserState, text: string, start_offset: number) => void;
+/**
+ * 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 declare const extend_accumulated_end: (state: MdzStreamParserState, end: number) => void;
+/**
+ * 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 declare const flush_text: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const ensure_paragraph: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const is_run_boundary: (node_type: MdzNodeTypeContainer) => boolean;
+/**
+ * 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 declare const find_open: (state: MdzStreamParserState, type: keyof OpenInlineCounts) => number;
+/**
+ * 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 declare const revert_above: (state: MdzStreamParserState, target_idx: number) => void;
+/**
+ * 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 declare const revert_failed_close: (state: MdzStreamParserState, stack_idx: number) => void;
+/**
+ * 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 declare const trim_trailing_newline: (state: MdzStreamParserState) => void;
+/** @nodocs */
+export declare const close_paragraph: (state: MdzStreamParserState) => void;
+/** @nodocs */
+export declare const close_heading: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const close_codeblock_at_eof: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const seal_list_item_run: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const close_list_run: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const close_list_item: (state: MdzStreamParserState) => void;
+/**
+ * Close the deepest open level: its current item, then its list.
+ *
+ * @nodocs
+ */
+export declare const close_list_level: (state: MdzStreamParserState) => void;
+/**
+ * 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 declare const close_all_list_levels: (state: MdzStreamParserState) => void;
+/** @nodocs */
+export declare const handle_paragraph_break: (state: MdzStreamParserState) => void;
+//# sourceMappingURL=mdz_stream_parser_state.d.ts.map

package/dist/mdz_stream_parser_state.d.ts.map

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