@fuzdev/mdz 0.1.0

package/dist/mdz_stream_parser_link.js

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

package/dist/mdz_stream_parser_list.d.ts

@@ -0,0 +1,106 @@
+/**
+ * List handlers for the streaming mdz parser — column-0 list starts and the
+ * line classifier that drives structure inside open lists.
+ *
+ * The streaming analogue of the sync lexer's `#tokenize_list`: the level
+ * stack lives in `state.list_levels`, and List/ListItem frames sit on the
+ * main stack (never reverted, like Paragraph). Every line inside an open
+ * list classifies from bounded input — leading whitespace plus a few marker
+ * chars for most lines, the whole line for empty markers and fence openers —
+ * and blank-run containment consumes one blank line at a time, holding only
+ * the structural close-vs-contain decision, never renderable content.
+ *
+ * @module
+ */
+import { type MdzStreamParserState, type TryResult } from './mdz_stream_parser_state.js';
+/**
+ * A matched list marker: `- ` (unordered) or `N. ` (ordered, 1-9 digits).
+ * `empty` markers have nothing but whitespace after the marker — valid only
+ * as mid-list empty items, never starting a list. Positions are local buffer
+ * indices.
+ *
+ * @nodocs
+ */
+export interface MdzStreamListMarker {
+    ordered: boolean;
+    /** Parsed integer for ordered markers (`007.` → 7); `0` for unordered. */
+    number: number;
+    /** Local buffer position of the marker character. */
+    start: number;
+    /** Index just past the marker chars (`-` or `N.`), before the space. */
+    marker_end: number;
+    /** Index just past the marker space — the inline run's content. */
+    content_start: number;
+    empty: boolean;
+}
+/**
+ * Match a list marker at `i` — the streaming analogue of the sync lexer's
+ * `#match_list_marker`, with `'pending'` for a marker that can't resolve
+ * until more input arrives (digits cut off at buffer end, a possible empty
+ * marker whose line hasn't ended). Returns null for anything that's
+ * definitely not a marker (`-x`, `--`, a tab after the marker, 10+ digits).
+ *
+ * @nodocs
+ */
+export declare const match_list_marker: (state: MdzStreamParserState, i: number, forced: boolean) => MdzStreamListMarker | "pending" | null;
+/**
+ * A matched fence opener line (see `match_fence_opener`).
+ *
+ * @nodocs
+ */
+export interface MdzStreamFenceOpener {
+    backtick_count: number;
+    lang: string | null;
+    /** Local position just past the opener's newline. */
+    content_start: number;
+}
+/**
+ * Match a complete fence opener line at `i`: >=3 backticks, an optional
+ * language word, only whitespace to a terminating newline. `'pending'` while
+ * the line could still become one; null when it definitely isn't — including
+ * an opener cut off at EOF without its newline (forced), which stays text,
+ * matching the sync parser's opener rule.
+ *
+ * @nodocs
+ */
+export declare const match_fence_opener: (state: MdzStreamParserState, i: number, forced: boolean) => MdzStreamFenceOpener | "pending" | null;
+/**
+ * Try to start a list at a column-0 marker line — `try_hr` has already
+ * rejected `---` when the char is `-`. Mirrors the sync lexer's
+ * `#tokenize_list` entry conditions: empty markers never start a list, the
+ * marker line must show content before the open confirms (a line-bounded
+ * hold, the heading has-content pattern), and a non-`1.` ordered marker
+ * never interrupts a current paragraph (the hard-wrap `2024.` guard).
+ *
+ * @nodocs
+ */
+export declare const try_list_start: (state: MdzStreamParserState, forced: boolean) => TryResult;
+/**
+ * Classify the line after a newline inside an open list and apply its
+ * structural effect — the streaming analogue of the sync lexer's
+ * `#tokenize_list` line loop plus `#list_run_end`'s continuation rules.
+ * Called with `pos` at the newline; returns `false` to hold until the line
+ * classifies (never in forced mode). Dispatch, in order:
+ *
+ * - blank line: the current run closes; the close-vs-contain decision waits
+ *   on the next non-blank line (one blank consumes per call, so long blank
+ *   runs make incremental progress across chunks)
+ * - marker lines: nest when deeper (subject to the ordered interrupt guard
+ *   against a current run), else snap to the nearest surviving level as a
+ *   sibling or a marker-type switch; empty markers at an exactly-matching
+ *   level form empty items
+ * - deeper fence opener lines: a code block child of the item they'd
+ *   otherwise continue (`process_codeblock_in_item` streams it)
+ * - deeper quote opener lines (a prefix with content after it): the levels
+ *   pop to the attach target and `'blockquote'` returns with `pos` at the prefix —
+ *   the main loop opens the blockquote child (the quote machinery lives
+ *   there, beside the nested-parser driving)
+ * - deeper non-marker lines: continuation of a current run (soft break,
+ *   indent stripped), else a new `Paragraph` block child
+ * - anything else: the whole list closes and the line re-dispatches at the
+ *   top level
+ *
+ * @nodocs
+ */
+export declare const process_list_line: (state: MdzStreamParserState, forced: boolean) => boolean | "blockquote";
+//# sourceMappingURL=mdz_stream_parser_list.d.ts.map

package/dist/mdz_stream_parser_list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_list.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAiBH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAad,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CACf;AAoBD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,mBAAmB,GAAG,SAAS,GAAG,IAsDpC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qDAAqD;IACrD,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,OAAO,oBAAoB,EAC3B,GAAG,MAAM,EACT,QAAQ,OAAO,KACb,oBAAoB,GAAG,SAAS,GAAG,IAuBrC,CAAC;AAgGF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,SAY7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,QAAQ,OAAO,KACb,OAAO,GAAG,YA2KZ,CAAC"}