remend

import remend from 'remend';

// During streaming
const partialMarkdown = 'This is **bold text';
const completed = remend(partialMarkdown);
// Result: "This is **bold text**"

// With incomplete link
const partialLink = 'Check out [this link](https://exampl';
const completedLink = remend(partialLink);
// Result: "Check out [this link](streamdown:incomplete-link)"

import remend from 'remend';

const completed = remend(partialMarkdown, {
  links: false,
  katex: false,
});

import remend, { type RemendHandler } from 'remend';

const jokeHandler: RemendHandler = {
  name: 'joke',
  handle: (text) => {
    // Complete <<<JOKE>>> marks that aren't closed
    const match = text.match(/<<<JOKE>>>([^<]*)$/);
    if (match && !text.endsWith('<<</JOKE>>>')) {
      return `${text}<<</JOKE>>>`;
    }
    return text;
  },
  priority: 80, // Runs after most built-ins (0–75)
};

const result = remend(content, { handlers: [jokeHandler] });

interface RemendHandler {
  /** Unique identifier for this handler */
  name: string;
  /** Transform function: receives the current text, returns modified text */
  handle: (text: string) => string;
  /** Execution order — lower values run first. Default: 100 */
  priority?: number;
}

const preprocessHandler: RemendHandler = {
  name: 'preprocess',
  handle: (text) => {
    // Transform content before bold is completed (priority 35)
    return text.replace(/\{\{highlight\}\}/g, '**');
  },
  priority: 25, // Runs after links (20) and before boldItalic (30)
};

const postprocessHandler: RemendHandler = {
  name: 'postprocess',
  handle: (text) => text.trim(),
  priority: 150,
};

import {
  isWithinCodeBlock,
  isWithinMathBlock,
  isWithinLinkOrImageUrl,
  isWordChar,
} from 'remend';

import { isWithinCodeBlock, type RemendHandler } from 'remend';

const handler: RemendHandler = {
  name: 'custom',
  handle: (text) => {
    // Skip if the end of the text is inside a code block
    if (isWithinCodeBlock(text, text.length - 1)) {
      return text;
    }
    // Your completion logic here
    return text;
  },
};

import remend from 'remend';
import { unified } from 'unified';
import remarkParse from 'remark-parse';
import remarkRehype from 'remark-rehype';
import rehypeStringify from 'rehype-stringify';

const streamedMarkdown = 'This is **incomplete bold';

// Step 1: complete incomplete syntax
const completedMarkdown = remend(streamedMarkdown);

// Step 2: process with unified as normal
const file = await unified()
  .use(remarkParse)
  .use(remarkRehype)
  .use(rehypeStringify)
  .process(completedMarkdown);

console.log(String(file));
// <p>This is <strong>incomplete bold</strong></p>

import ReactMarkdown from 'react-markdown';
import remend from 'remend';

<ReactMarkdown
  components={{
    a: ({ href, children, ...props }) => {
      if (href === 'streamdown:incomplete-link') {
        return <>{children}</>;
      }
      return <a href={href} {...props}>{children}</a>;
    },
  }}
>
  {remend(streamingText)}
</ReactMarkdown>

<ReactMarkdown>{remend(streamingText, { linkMode: 'text-only' })}</ReactMarkdown>