@sigx/lynx-markdown 0.4.8 → 0.4.9

package/dist/editor/trigger/session.js

@@ -0,0 +1,162 @@
+/**
+ * Trigger sessions — the state machine behind the suggestion popup.
+ *
+ * The element exposes no keystrokes, so the session is a pure function of the
+ * editor's two event streams: document text (`bindchange`) and the collapsed
+ * caret offset (`bindselection`). On every sync we look at the **run** — the
+ * non-whitespace text between the last boundary and the caret. A run starting
+ * with a trigger (`@` / a pattern match) means an active session whose query
+ * is the rest of the run; anything else means no session. Whitespace, caret
+ * exits, blur and selection all close it for free, because they all change
+ * the run.
+ *
+ * `onQuery` may be async: results are tagged with an epoch and discarded when
+ * a newer query (or a close) supersedes them. An optional per-trigger
+ * `debounce` batches fast typing.
+ */
+/** Trigger-prefix length when `run` starts with this trigger, else `-1`. */
+function matchTrigger(spec, run) {
+    if (spec.char !== undefined) {
+        return run.startsWith(spec.char) ? spec.char.length : -1;
+    }
+    if (spec.pattern) {
+        // Reset stateful lastIndex (g/y flags) so matching is deterministic.
+        spec.pattern.lastIndex = 0;
+        const m = spec.pattern.exec(run);
+        return m && m.index === 0 ? m[0].length : -1;
+    }
+    return -1;
+}
+export function createTriggerSessionManager(opts) {
+    let text = '';
+    let caret = -1;
+    let session = null;
+    /** Bumped on every query change/close; stale async results check it. */
+    let epoch = 0;
+    let debounceTimer = null;
+    const clearTimer = () => {
+        if (debounceTimer !== null) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+    };
+    const emit = () => {
+        opts.onUpdate(session ? { ...session, items: [...session.items] } : null);
+    };
+    const close = () => {
+        if (!session)
+            return;
+        epoch++;
+        clearTimer();
+        session = null;
+        emit();
+    };
+    const runQuery = (spec) => {
+        if (!session)
+            return;
+        const myEpoch = ++epoch;
+        const query = session.query;
+        const exec = () => {
+            debounceTimer = null;
+            if (epoch !== myEpoch || !session)
+                return;
+            let result;
+            try {
+                result = spec.onQuery(query);
+            }
+            catch {
+                // A throwing onQuery behaves like a rejected async query.
+                session.items = [];
+                session.loading = false;
+                emit();
+                return;
+            }
+            if (Array.isArray(result)) {
+                session.items = result;
+                session.loading = false;
+                emit();
+                return;
+            }
+            // Guard non-thenable returns from misbehaving plugins — treat
+            // them like an empty result instead of throwing on .then.
+            if (!result || typeof result.then !== 'function') {
+                session.items = [];
+                session.loading = false;
+                emit();
+                return;
+            }
+            result.then((items) => {
+                // Discard stale resolutions: a newer query or a close won.
+                if (epoch !== myEpoch || !session)
+                    return;
+                session.items = items;
+                session.loading = false;
+                emit();
+            }, () => {
+                if (epoch !== myEpoch || !session)
+                    return;
+                session.items = [];
+                session.loading = false;
+                emit();
+            });
+        };
+        clearTimer();
+        if (spec.debounce && spec.debounce > 0) {
+            debounceTimer = setTimeout(exec, spec.debounce);
+        }
+        else {
+            exec();
+        }
+    };
+    const evaluate = () => {
+        if (caret < 0 || caret > text.length) {
+            close();
+            return;
+        }
+        // The run: non-whitespace text between the last boundary and the caret.
+        let start = caret;
+        while (start > 0 && !/\s/.test(text[start - 1]))
+            start--;
+        const run = text.slice(start, caret);
+        for (const { plugin, spec } of opts.triggers) {
+            const prefixLen = matchTrigger(spec, run);
+            if (prefixLen < 0)
+                continue;
+            const query = run.slice(prefixLen);
+            if (session && session.plugin === plugin && session.anchor === start) {
+                session.caret = caret;
+                if (session.query !== query) {
+                    session.query = query;
+                    // Clear stale results: the popup must never offer the
+                    // previous query's suggestions while the new one resolves.
+                    session.items = [];
+                    session.loading = true;
+                    emit();
+                    runQuery(spec);
+                }
+                return;
+            }
+            session = { plugin, anchor: start, query, caret, items: [], loading: true };
+            emit();
+            runQuery(spec);
+            return;
+        }
+        close();
+    };
+    return {
+        syncText: (t) => {
+            text = t ?? '';
+            evaluate();
+        },
+        syncCaret: (c) => {
+            caret = c;
+            evaluate();
+        },
+        close,
+        get session() {
+            // Snapshot — mutating the returned object must not desync internal
+            // state or bypass onUpdate (which also emits clones).
+            return session ? { ...session, items: [...session.items] } : null;
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,15 +1,28 @@
 export { MarkdownView } from './render/MarkdownView.js';
 export type { MarkdownViewProps } from './render/MarkdownView.js';
 export { defaultComponents } from './render/components.js';
-export type { MarkdownComponents, MarkdownChild, RootProps, HeadingProps, ParagraphProps, BlockquoteProps, ListProps, ListItemProps, CodeProps, ThematicBreakProps, TableProps, TableRowProps, TableCellProps, StrongProps, EmProps, DelProps, CodeSpanProps, LinkProps, AutolinkProps, ImageProps, } from './render/components.js';
+export type { MarkdownComponents, MarkdownChild, RootProps, HeadingProps, ParagraphProps, BlockquoteProps, ListProps, ListItemProps, CodeProps, ThematicBreakProps, TableProps, TableRowProps, TableCellProps, StrongProps, EmProps, DelProps, CodeSpanProps, LinkProps, AutolinkProps, ImageProps, ExtensionProps, } from './render/components.js';
 export { MarkdownEditor } from './editor/MarkdownEditor.js';
 export type { MarkdownEditorProps, MarkdownEditorController, MarkdownEditorMode, } from './editor/MarkdownEditor.js';
+export type { SelectionState } from '@sigx/lynx-richtext';
+export { EditorToolbar } from './editor/toolbar/Toolbar.js';
+export type { EditorToolbarProps, ToolbarRenderItem } from './editor/toolbar/Toolbar.js';
+export { defaultToolbarItems } from './editor/toolbar/items.js';
+export type { ToolbarItem, ToolbarContext } from './editor/toolbar/items.js';
 export { mdToDoc } from './editor/convert/mdToDoc.js';
+export type { MdToDocOptions, ExtensionSpanMapper } from './editor/convert/mdToDoc.js';
 export { docToMd } from './editor/convert/docToMd.js';
+export type { DocToMdOptions, SpanSerializer } from './editor/convert/docToMd.js';
+export type { MarkdownEditorPlugin, InlinePluginSpec, TriggerSpec, TriggerItem, TriggerSelectApi, } from './editor/plugin.js';
+export { SuggestionPopup } from './editor/trigger/SuggestionPopup.js';
+export type { SuggestionPopupProps, SuggestionRenderItem } from './editor/trigger/SuggestionPopup.js';
+export { createTriggerSessionManager } from './editor/trigger/session.js';
+export type { TriggerSession, TriggerSessionManager } from './editor/trigger/session.js';
 export { createMarkdownStream } from './stream.js';
 export type { MarkdownStream, CreateMarkdownStreamOptions } from './stream.js';
 export { createIncrementalEngine } from './parser/incremental.js';
-export type { IncrementalEngine } from './parser/incremental.js';
+export type { IncrementalEngine, IncrementalEngineOptions } from './parser/incremental.js';
 export { parseBlocks } from './parser/blocks.js';
 export { parseInline } from './parser/inline.js';
+export type { ParserInlineExtension } from './parser/extensions.js';
 export type * from './ast.js';

package/dist/index.js

@@ -6,8 +6,12 @@ export { defaultComponents } from './render/components.js';
 // True-WYSIWYG editor on the native <sigx-richtext> element
 // (requires the optional @sigx/lynx-richtext peer).
 export { MarkdownEditor } from './editor/MarkdownEditor.js';
+export { EditorToolbar } from './editor/toolbar/Toolbar.js';
+export { defaultToolbarItems } from './editor/toolbar/items.js';
 export { mdToDoc } from './editor/convert/mdToDoc.js';
 export { docToMd } from './editor/convert/docToMd.js';
+export { SuggestionPopup } from './editor/trigger/SuggestionPopup.js';
+export { createTriggerSessionManager } from './editor/trigger/session.js';
 // Streaming controller for AI token loops.
 export { createMarkdownStream } from './stream.js';
 // Parser primitives (for advanced consumers / testing).

package/dist/parser/blocks.d.ts

@@ -12,10 +12,11 @@
  * items, blockquote contents) get stable, unique keys for reconciliation.
  */
 import type { BlockNode } from '../ast.js';
+import type { ParserInlineExtension } from './extensions.js';
 /** Monotonic key generator so every block (incl. nested) gets a unique key. */
 export interface KeyGen {
     next(): string;
 }
 export declare function makeKeyGen(prefix: string): KeyGen;
 /** Parse a complete (or partial) source string into block nodes. */
-export declare function parseBlocks(src: string, keys?: KeyGen): BlockNode[];
+export declare function parseBlocks(src: string, keys?: KeyGen, extensions?: readonly ParserInlineExtension[]): BlockNode[];

package/dist/parser/blocks.js

@@ -18,11 +18,11 @@ export function makeKeyGen(prefix) {
     return { next: () => `${prefix}-${n++}` };
 }
 /** Parse a complete (or partial) source string into block nodes. */
-export function parseBlocks(src, keys = makeKeyGen('b')) {
+export function parseBlocks(src, keys = makeKeyGen('b'), extensions) {
     const lines = src.split('\n');
-    return parseLines(lines, keys);
+    return parseLines(lines, keys, extensions);
 }
-function parseLines(lines, keys) {
+function parseLines(lines, keys, extensions) {
     const blocks = [];
     let i = 0;
     while (i < lines.length) {
@@ -66,7 +66,7 @@ function parseLines(lines, keys) {
                 key: keys.next(),
                 raw: line,
                 level: heading.level,
-                children: parseInline(heading.text),
+                children: parseInline(heading.text, extensions),
             });
             i++;
             continue;
@@ -89,14 +89,14 @@ function parseLines(lines, keys) {
                 type: 'blockquote',
                 key: keys.next(),
                 raw: lines.slice(start, i).join('\n'),
-                children: parseLines(inner, keys),
+                children: parseLines(inner, keys, extensions),
             });
             continue;
         }
         // List.
         const marker = matchListMarker(line) ?? matchEmptyListMarker(line);
         if (marker) {
-            const result = parseList(lines, i, marker, keys);
+            const result = parseList(lines, i, marker, keys, extensions);
             blocks.push(result.block);
             i = result.next;
             continue;
@@ -105,7 +105,7 @@ function parseLines(lines, keys) {
         if (line.indexOf('|') !== -1 && i + 1 < lines.length) {
             const align = matchTableDelimiter(lines[i + 1]);
             if (align) {
-                const result = parseTable(lines, i, align, keys);
+                const result = parseTable(lines, i, align, keys, extensions);
                 blocks.push(result.block);
                 i = result.next;
                 continue;
@@ -122,7 +122,7 @@ function parseLines(lines, keys) {
             type: 'paragraph',
             key: keys.next(),
             raw: lines.slice(start, i).join('\n'),
-            children: parseInline(para.join('\n')),
+            children: parseInline(para.join('\n'), extensions),
         });
     }
     return blocks;
@@ -159,7 +159,7 @@ function stripIndent(line, n) {
 function sameList(a, b) {
     return a.ordered === b.ordered && a.delimiter === b.delimiter;
 }
-function parseList(lines, start, first, keys) {
+function parseList(lines, start, first, keys, extensions) {
     const items = [];
     let i = start;
     let tight = true;
@@ -217,7 +217,7 @@ function parseList(lines, start, first, keys) {
         items.push({
             key: keys.next(),
             checked,
-            children: parseLines(bodyLines, keys),
+            children: parseLines(bodyLines, keys, extensions),
         });
     }
     if (sawBlankBetween)
@@ -248,12 +248,12 @@ function extractTask(itemLines) {
 // ---------------------------------------------------------------------------
 // Tables
 // ---------------------------------------------------------------------------
-function parseTable(lines, start, align, keys) {
-    const header = splitTableRow(lines[start]).map((c) => ({ children: parseInline(c) }));
+function parseTable(lines, start, align, keys, extensions) {
+    const header = splitTableRow(lines[start]).map((c) => ({ children: parseInline(c, extensions) }));
     let i = start + 2; // skip header + delimiter
     const rows = [];
     while (i < lines.length && !isBlank(lines[i]) && lines[i].indexOf('|') !== -1 && !interrupts(lines, i)) {
-        const cells = splitTableRow(lines[i]).map((c) => ({ children: parseInline(c) }));
+        const cells = splitTableRow(lines[i]).map((c) => ({ children: parseInline(c, extensions) }));
         // Normalize cell count to the header width.
         while (cells.length < header.length)
             cells.push({ children: [] });

package/dist/parser/extensions.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Parser inline-extension contract: a plugin recognizes its own inline
+ * construct (a mention, an emoji shortcode, …) and produces an
+ * `InlineExtension` AST node, without touching this package.
+ *
+ * Extensions run inside the tokenizer at the same precedence tier as code
+ * spans and links: a successful match emits one opaque token the emphasis
+ * stack never looks into. Matching is gated by `triggerChars`, so the cost
+ * when no extension is in play is zero, and one set lookup per char otherwise.
+ */
+import type { InlineExtension } from '../ast.js';
+export interface ParserInlineExtension {
+    /** Stable extension name; also the render dispatch key (`components.extension[name]`). */
+    name: string;
+    /**
+     * Fast-path gate: the character(s) that can begin this construct. `match`
+     * is only called when the current character is in this set. Must be
+     * non-empty — an ungated extension would have to be probed at every
+     * position, which is banned for parse cost and memoization reasons.
+     */
+    triggerChars: readonly string[];
+    /**
+     * Try to match this construct anchored at `pos` (`text[pos]` is guaranteed
+     * to be one of `triggerChars`). Returns the produced node and the
+     * exclusive end index of the consumed source, or `null` when there is no
+     * match.
+     *
+     * Two contracts the parser relies on:
+     *  - **Streaming-safe**: return `null` on a partial tail (e.g. `@[lab`
+     *    while expecting `@[label](id)`) — same contract as the built-in
+     *    `scanLink`. The half-typed text degrades to literal and re-resolves
+     *    once the rest arrives.
+     *  - **Pure**: same `(text, pos)` → same result. The incremental engine
+     *    memoizes finalized blocks by reference and only re-parses the live
+     *    tail; an impure `match` breaks that invariant.
+     *
+     * The extension builds `node.raw` itself (it knows its own boundaries):
+     * `raw` must equal `text.slice(pos, end)`.
+     *
+     * The tokenizer hardens against misbehaving matches — one that throws,
+     * does not advance (`end <= pos`), or runs past the input
+     * (`end > text.length`) is treated as no match, so the text degrades to
+     * literal instead of breaking parsing.
+     */
+    match(text: string, pos: number): {
+        node: InlineExtension;
+        end: number;
+    } | null;
+}
+/** Union of all trigger chars, for the tokenizer's per-char fast path. */
+export declare function buildTriggerSet(extensions: readonly ParserInlineExtension[]): Set<string>;

package/dist/parser/extensions.js

@@ -0,0 +1,18 @@
+/**
+ * Parser inline-extension contract: a plugin recognizes its own inline
+ * construct (a mention, an emoji shortcode, …) and produces an
+ * `InlineExtension` AST node, without touching this package.
+ *
+ * Extensions run inside the tokenizer at the same precedence tier as code
+ * spans and links: a successful match emits one opaque token the emphasis
+ * stack never looks into. Matching is gated by `triggerChars`, so the cost
+ * when no extension is in play is zero, and one set lookup per char otherwise.
+ */
+/** Union of all trigger chars, for the tokenizer's per-char fast path. */
+export function buildTriggerSet(extensions) {
+    const set = new Set();
+    for (const ext of extensions)
+        for (const ch of ext.triggerChars)
+            set.add(ch);
+    return set;
+}

package/dist/parser/incremental.d.ts

@@ -17,10 +17,19 @@
  * rather than remounting.
  */
 import type { BlockNode } from '../ast.js';
+import type { ParserInlineExtension } from './extensions.js';
 export interface IncrementalEngine {
     /** Parse `src`, reusing finalized blocks from prior calls where possible. */
     parse(src: string): BlockNode[];
     /** Drop all cached state (e.g. when the source is replaced, not appended). */
     reset(): void;
 }
-export declare function createIncrementalEngine(): IncrementalEngine;
+export interface IncrementalEngineOptions {
+    /**
+     * Inline extensions threaded into every parse. Captured at construction —
+     * extensions are configuration, not data: to change the set, create a new
+     * engine. Each `match` must be pure, or finalized-block reuse breaks.
+     */
+    extensions?: readonly ParserInlineExtension[];
+}
+export declare function createIncrementalEngine(options?: IncrementalEngineOptions): IncrementalEngine;

package/dist/parser/incremental.js

@@ -18,7 +18,10 @@
  */
 import { parseBlocks, makeKeyGen } from './blocks.js';
 import { normalize } from './scanner.js';
-export function createIncrementalEngine() {
+export function createIncrementalEngine(options) {
+    // Snapshot so in-place mutation of the caller's array can't change parse
+    // behavior under cached finalized blocks (the "captured config" guarantee).
+    const extensions = options?.extensions ? [...options.extensions] : undefined;
     /** Finalized blocks, frozen and reused by reference across chunks. */
     let cached = [];
     /** Source length (in normalized chars) already folded into `cached`. */
@@ -40,7 +43,7 @@ export function createIncrementalEngine() {
         if (!norm.startsWith(stableSource))
             reset();
         const tail = norm.slice(cut);
-        const blocks = parseBlocks(tail, makeKeyGen(`p${cut}`));
+        const blocks = parseBlocks(tail, makeKeyGen(`p${cut}`), extensions);
         if (blocks.length === 0) {
             // Tail is empty / all-blank: nothing live, return finalized prefix.
             return cached.slice();

package/dist/parser/inline.d.ts

@@ -1,16 +1,26 @@
 /**
  * Inline tokenizer: a markdown text run → `InlineNode[]` (nested spans).
  *
- * Precedence (highest first): backtick code spans, backslash escapes, images,
- * links, angle/bare autolinks, then emphasis (`**`/`__` strong, `*`/`_` em,
- * `~~` del) resolved with a delimiter-run stack, then hard breaks, then text.
+ * Precedence (highest first): backslash escapes, plugin inline extensions
+ * (trigger-char gated), backtick code spans, images, links, angle/bare
+ * autolinks, then emphasis (`**`/`__` strong, `*`/`_` em, `~~` del) resolved
+ * with a delimiter-run stack, then hard breaks, then text.
  *
  * Robustness for streaming: any unmatched construct at the tail (a lone `**`,
  * a half-open `[text](`, an unterminated code span) degrades to literal text.
  * The function never throws.
  */
 import type { InlineNode } from '../ast.js';
-/** Parse an inline text run into a node array. */
-export declare function parseInline(input: string): InlineNode[];
+import { type ParserInlineExtension } from './extensions.js';
+/**
+ * Parse an inline text run into a node array.
+ *
+ * `extensions` add plugin-defined inline constructs at the same precedence
+ * tier as code spans/links (after backslash escapes; opaque to the emphasis
+ * stack). On shared trigger chars the first registered extension wins. Each
+ * extension's `match` must be pure and streaming-safe — see
+ * {@link ParserInlineExtension}.
+ */
+export declare function parseInline(input: string, extensions?: readonly ParserInlineExtension[]): InlineNode[];
 /** Flatten inline nodes to their visible text (for image alt). */
 export declare function stripFormatting(text: string): string;

package/dist/parser/inline.js

@@ -1,29 +1,43 @@
 /**
  * Inline tokenizer: a markdown text run → `InlineNode[]` (nested spans).
  *
- * Precedence (highest first): backtick code spans, backslash escapes, images,
- * links, angle/bare autolinks, then emphasis (`**`/`__` strong, `*`/`_` em,
- * `~~` del) resolved with a delimiter-run stack, then hard breaks, then text.
+ * Precedence (highest first): backslash escapes, plugin inline extensions
+ * (trigger-char gated), backtick code spans, images, links, angle/bare
+ * autolinks, then emphasis (`**`/`__` strong, `*`/`_` em, `~~` del) resolved
+ * with a delimiter-run stack, then hard breaks, then text.
  *
  * Robustness for streaming: any unmatched construct at the tail (a lone `**`,
  * a half-open `[text](`, an unterminated code span) degrades to literal text.
  * The function never throws.
  */
+import { buildTriggerSet } from './extensions.js';
 import { isEscapable, sanitizeHref, trimAutolinkTail } from './scanner.js';
 function isDelim(t) {
     return t.delim === true;
 }
 const PUNCT = /[!-/:-@[-`{-~]/;
-/** Parse an inline text run into a node array. */
-export function parseInline(input) {
-    const tokens = tokenize(input);
+/**
+ * Parse an inline text run into a node array.
+ *
+ * `extensions` add plugin-defined inline constructs at the same precedence
+ * tier as code spans/links (after backslash escapes; opaque to the emphasis
+ * stack). On shared trigger chars the first registered extension wins. Each
+ * extension's `match` must be pure and streaming-safe — see
+ * {@link ParserInlineExtension}.
+ */
+export function parseInline(input, extensions) {
+    const tokens = tokenize(input, extensions);
     resolveEmphasis(tokens, 0);
     return coalesce(tokensToNodes(tokens));
 }
 // ---------------------------------------------------------------------------
 // Tokenization
 // ---------------------------------------------------------------------------
-function tokenize(text) {
+function tokenize(text, extensions) {
+    // Normalize an empty trigger set back to null so the per-char fast path
+    // stays fully disabled when no extension can ever match.
+    const builtSet = extensions && extensions.length ? buildTriggerSet(extensions) : null;
+    const triggerSet = builtSet && builtSet.size ? builtSet : null;
     const tokens = [];
     let buf = '';
     const flush = () => {
@@ -45,7 +59,9 @@ function tokenize(text) {
                 i += 2;
                 continue;
             }
-            if (next !== undefined && isEscapable(next)) {
+            // Trigger chars are escapable too, so `\@` always suppresses an
+            // `@`-triggered extension regardless of the built-in escape set.
+            if (next !== undefined && (isEscapable(next) || (triggerSet !== null && triggerSet.has(next)))) {
                 buf += next;
                 i += 2;
                 continue;
@@ -54,6 +70,36 @@ function tokenize(text) {
             i++;
             continue;
         }
+        // Inline extension (plugin construct; opaque to the emphasis stack).
+        // After escapes (so `\@` stays literal), before every built-in scanner.
+        if (triggerSet !== null && triggerSet.has(ch)) {
+            let matched = false;
+            for (const ext of extensions) {
+                if (!ext.triggerChars.includes(ch))
+                    continue;
+                // Misbehaving extensions must not break the "never throws,
+                // never hangs" guarantee: a throwing match is treated as no
+                // match, and a non-advancing (end <= pos) or out-of-bounds
+                // (end > length) match is ignored.
+                let m = null;
+                try {
+                    m = ext.match(text, i);
+                }
+                catch {
+                    m = null;
+                }
+                if (m && m.end > i && m.end <= n) {
+                    flush();
+                    tokens.push(m.node);
+                    i = m.end;
+                    matched = true;
+                    break;
+                }
+            }
+            if (matched)
+                continue;
+            // No extension matched (or partial tail) → normal scanning.
+        }
         // Code span.
         if (ch === '`') {
             const span = scanCodeSpan(text, i);
@@ -94,7 +140,7 @@ function tokenize(text) {
                     type: 'link',
                     href: sanitizeHref(link.href),
                     ...(link.title ? { title: link.title } : {}),
-                    children: parseInline(link.label),
+                    children: parseInline(link.label, extensions),
                 });
                 i = link.end;
                 continue;

package/dist/render/MarkdownView.d.ts

@@ -23,6 +23,13 @@
  * ```
  */
 import { type Define } from '@sigx/lynx';
+import type { ParserInlineExtension } from '../parser/extensions.js';
 import { type MarkdownComponents } from './components.js';
-export type MarkdownViewProps = Define.Prop<'value', string, false> & Define.Prop<'onLink', (href: string) => void, false> & Define.Prop<'onImageTap', (src: string) => void, false> & Define.Prop<'components', Partial<MarkdownComponents>, false>;
+export type MarkdownViewProps = Define.Prop<'value', string, false> & Define.Prop<'onLink', (href: string) => void, false> & Define.Prop<'onImageTap', (src: string) => void, false> & Define.Prop<'components', Partial<MarkdownComponents>, false>
+/**
+ * Plugin inline extensions (see {@link ParserInlineExtension}). Pass a
+ * stable array (e.g. a module constant) — changing its identity resets
+ * the incremental parse state and re-parses from scratch.
+ */
+ & Define.Prop<'extensions', readonly ParserInlineExtension[], false>;
 export declare const MarkdownView: import("@sigx/runtime-core").ComponentFactory<MarkdownViewProps, void, {}>;

package/dist/render/MarkdownView.js

@@ -27,8 +27,17 @@ import { createIncrementalEngine } from '../parser/incremental.js';
 import { defaultComponents } from './components.js';
 import { renderDocument } from './engine.js';
 export const MarkdownView = component(({ props }) => {
-    const engine = createIncrementalEngine();
-    const blocks = computed(() => engine.parse(props.value ?? ''));
+    // The engine captures its extensions at construction; recreate it if the
+    // extensions prop changes identity (rare — normally a stable constant).
+    let engine = createIncrementalEngine({ extensions: props.extensions });
+    let lastExtensions = props.extensions;
+    const blocks = computed(() => {
+        if (props.extensions !== lastExtensions) {
+            lastExtensions = props.extensions;
+            engine = createIncrementalEngine({ extensions: lastExtensions });
+        }
+        return engine.parse(props.value ?? '');
+    });
     return () => {
         const ctx = {
             components: props.components

package/dist/render/components.d.ts

@@ -12,7 +12,7 @@
  * component only decides *what element to wrap children in*.
  */
 import type { JSXElement } from '@sigx/lynx';
-import type { BlockquoteBlock, CodeBlock, HeadingBlock, HeadingLevel, InlineAutolink, InlineCodeSpan, InlineDel, InlineEm, InlineImage, InlineLink, InlineStrong, ListBlock, ListItem, ParagraphBlock, TableAlign, TableBlock, ThematicBreakBlock } from '../ast.js';
+import type { BlockquoteBlock, CodeBlock, HeadingBlock, HeadingLevel, InlineAutolink, InlineCodeSpan, InlineDel, InlineEm, InlineExtension, InlineImage, InlineLink, InlineStrong, ListBlock, ListItem, ParagraphBlock, TableAlign, TableBlock, ThematicBreakBlock } from '../ast.js';
 /** A renderable child: a JSX element or a raw string (for text/`<br>`). */
 export type MarkdownChild = JSXElement | string;
 export interface RootProps {
@@ -111,6 +111,13 @@ export interface ImageProps {
     onImageTap?: (src: string) => void;
     node: InlineImage;
 }
+export interface ExtensionProps {
+    name: string;
+    attrs: Record<string, string>;
+    /** Rendered `node.children`; `[]` for leaf extensions. */
+    children: MarkdownChild[];
+    node: InlineExtension;
+}
 /**
  * Map of node type → render function. Pass a partial map to `<Markdown
  * components={…}>` to override any subset; unspecified types fall back to the
@@ -136,5 +143,10 @@ export interface MarkdownComponents {
     autolink(props: AutolinkProps): MarkdownChild;
     image(props: ImageProps): MarkdownChild;
     br(): MarkdownChild;
+    /**
+     * Renderers for plugin inline extensions, keyed by extension name. A node
+     * with no matching renderer falls back to its `raw` source as plain text.
+     */
+    extension?: Record<string, (props: ExtensionProps) => MarkdownChild>;
 }
 export declare const defaultComponents: MarkdownComponents;

package/dist/render/engine.js

@@ -141,5 +141,16 @@ function renderInlineNode(node, ctx) {
                 onImageTap: ctx.onImageTap,
                 node,
             });
+        case 'extension': {
+            const renderer = C.extension?.[node.name];
+            if (!renderer)
+                return node.raw; // no renderer registered → literal source
+            return renderer({
+                name: node.name,
+                attrs: node.attrs,
+                children: node.children ? renderInline(node.children, ctx) : [],
+                node,
+            });
+        }
     }
 }