@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal/input.js

@@ -0,0 +1,197 @@
+const ESC = 0x1b;
+const PASTE_START = Buffer.from("\u001b[200~");
+const PASTE_END = Buffer.from("\u001b[201~");
+export function createInputParser(options = {}) {
+    const escTimeoutMs = options.escTimeoutMs ?? 50;
+    let pending = Buffer.alloc(0);
+    let paste = false;
+    let timer;
+    let escapeReady = false;
+    const clearEscapeTimer = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = undefined;
+        escapeReady = false;
+    };
+    const armEscapeTimer = () => {
+        if (timer !== undefined)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (options.onEvent !== undefined && pending.length > 0 && pending.every((byte) => byte === ESC)) {
+                const count = pending.length;
+                pending = Buffer.alloc(0);
+                for (let index = 0; index < count; index++)
+                    options.onEvent(key("escape"));
+            }
+            else {
+                escapeReady = true;
+            }
+        }, escTimeoutMs);
+    };
+    const parse = () => {
+        const events = [];
+        while (pending.length > 0) {
+            if (paste) {
+                const end = pending.indexOf(PASTE_END);
+                if (end < 0)
+                    break;
+                events.push({ type: "paste", text: pending.subarray(0, end).toString("utf8") });
+                pending = pending.subarray(end + PASTE_END.length);
+                paste = false;
+                continue;
+            }
+            if (pending[0] === ESC) {
+                if (pending.every((byte) => byte === ESC)) {
+                    if (escapeReady) {
+                        const count = pending.length;
+                        pending = Buffer.alloc(0);
+                        escapeReady = false;
+                        for (let index = 0; index < count; index++)
+                            events.push(key("escape"));
+                    }
+                    else {
+                        armEscapeTimer();
+                    }
+                    break;
+                }
+                clearEscapeTimer();
+                if (pending.subarray(0, PASTE_START.length).equals(PASTE_START)) {
+                    pending = pending.subarray(PASTE_START.length);
+                    paste = true;
+                    continue;
+                }
+                const altCsi = pending[1] === ESC && pending[2] === 0x5b;
+                if (pending[1] === 0x5b || altCsi) {
+                    const offset = altCsi ? 1 : 0;
+                    const final = findCsiFinal(pending.subarray(offset));
+                    if (final < 0)
+                        break;
+                    const sequence = pending.subarray(offset, offset + final + 1).toString("ascii");
+                    pending = pending.subarray(offset + final + 1);
+                    const event = parseCsi(sequence);
+                    if (event !== undefined)
+                        events.push(altCsi && event.type === "key" ? { ...event, alt: true } : event);
+                    continue;
+                }
+                if (pending[1] === 0x4f) {
+                    if (pending.length < 3)
+                        break;
+                    const name = navigationName(String.fromCharCode(pending[2]));
+                    pending = pending.subarray(3);
+                    if (name !== undefined)
+                        events.push(key(name));
+                    continue;
+                }
+                if (pending[1] === 0x03) {
+                    pending = pending.subarray(1);
+                    events.push(key("escape"));
+                    continue;
+                }
+                if (pending[1] < 0x20 || pending[1] === 0x7f) {
+                    events.push({ ...control(pending[1]), alt: true });
+                    pending = pending.subarray(2);
+                    continue;
+                }
+                const decoded = decodeFirstCharacter(pending.subarray(1));
+                if (decoded === undefined)
+                    break;
+                pending = pending.subarray(1 + decoded.bytes);
+                events.push(character(decoded.ch, true));
+                continue;
+            }
+            const byte = pending[0];
+            if (byte < 0x20 || byte === 0x7f) {
+                pending = pending.subarray(1);
+                events.push(control(byte));
+                continue;
+            }
+            const decoded = decodeFirstCharacter(pending);
+            if (decoded === undefined)
+                break;
+            pending = pending.subarray(decoded.bytes);
+            events.push(character(decoded.ch, false));
+        }
+        return events;
+    };
+    return {
+        feed(chunk) {
+            if (chunk.length > 0) {
+                if (pending.length > 0 && pending.every((byte) => byte === ESC))
+                    clearEscapeTimer();
+                pending = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, chunk]);
+            }
+            return parse();
+        },
+        flush() {
+            return parse();
+        },
+        destroy() {
+            clearEscapeTimer();
+            pending = Buffer.alloc(0);
+        }
+    };
+}
+function findCsiFinal(input) {
+    for (let index = 2; index < input.length; index += 1) {
+        const byte = input[index];
+        if (byte >= 0x40 && byte <= 0x7e)
+            return index;
+    }
+    return -1;
+}
+function parseCsi(sequence) {
+    if (sequence.startsWith("\u001b[<") && (sequence.endsWith("M") || sequence.endsWith("m"))) {
+        const fields = sequence.slice(3, -1).split(";");
+        if ((fields[0] === "64" || fields[0] === "65") && fields.length === 3) {
+            return {
+                type: "wheel",
+                direction: fields[0] === "64" ? "up" : "down",
+                x: Number(fields[1]) - 1,
+                y: Number(fields[2]) - 1
+            };
+        }
+    }
+    const final = sequence.at(-1);
+    const name = navigationName(final) ?? ({ "1": "home", "3": "delete", "4": "end", "5": "pageup", "6": "pagedown", "7": "home", "8": "end" }[sequence.slice(2, -1)]);
+    if (name === undefined)
+        return undefined;
+    const parameters = sequence.slice(2, -1).split(";");
+    const modifier = parameters.length > 1 ? Number(parameters.at(-1)) : 1;
+    return key(name, {
+        shift: modifier === 2 || modifier === 4 || modifier === 6 || modifier === 8,
+        alt: modifier === 3 || modifier === 4 || modifier === 7 || modifier === 8,
+        ctrl: modifier === 5 || modifier === 6 || modifier === 7 || modifier === 8
+    });
+}
+function navigationName(final) {
+    return { A: "up", B: "down", C: "right", D: "left", H: "home", F: "end" }[final];
+}
+function control(byte) {
+    if (byte === 0x0d || byte === 0x0a)
+        return key("enter");
+    if (byte === 0x09)
+        return key("tab");
+    if (byte === 0x7f || byte === 0x08)
+        return key("backspace");
+    if (byte === 0x20)
+        return character(" ", false);
+    if (byte >= 1 && byte <= 26)
+        return key(String.fromCharCode(96 + byte), { ctrl: true });
+    return key(`control-${byte}`);
+}
+function character(ch, alt) {
+    return { type: "key", name: ch, ch, ctrl: false, alt, shift: ch.toLocaleUpperCase() === ch && ch.toLocaleLowerCase() !== ch };
+}
+function key(name, flags = {}) {
+    return { type: "key", name, ctrl: flags.ctrl ?? false, alt: flags.alt ?? false, shift: flags.shift ?? false };
+}
+function decodeFirstCharacter(input) {
+    if (input.length === 0)
+        return undefined;
+    const first = input[0];
+    const bytes = first < 0x80 ? 1 : first < 0xe0 ? 2 : first < 0xf0 ? 3 : 4;
+    if (input.length < bytes)
+        return undefined;
+    return { ch: input.subarray(0, bytes).toString("utf8"), bytes };
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal/output.d.ts

@@ -0,0 +1,10 @@
+export interface FrameWriter {
+    open(): void;
+    close(): void;
+    writeFrame(ansi: string): void;
+}
+export declare function createFrameWriter(stream: {
+    write(value: string): boolean;
+}, options?: {
+    mouse?: boolean;
+}): FrameWriter;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal/output.js

@@ -0,0 +1,44 @@
+const OPEN = "\u001b[?1049h\u001b[?25l\u001b[?2004h";
+const OPEN_MOUSE = "\u001b[?1000h\u001b[?1006h";
+const CLOSE_MOUSE = "\u001b[?1006l\u001b[?1000l";
+const CLOSE = "\u001b[?2004l\u001b[?25h\u001b[?1049l";
+export function createFrameWriter(stream, options = {}) {
+    let opened = false;
+    const interrupt = () => terminateWith("SIGINT");
+    const terminate = () => terminateWith("SIGTERM");
+    const fatal = (error) => {
+        close();
+        throw error;
+    };
+    function terminateWith(signal) {
+        close();
+        process.kill(process.pid, signal);
+    }
+    function open() {
+        if (opened)
+            return;
+        opened = true;
+        stream.write(`${OPEN}${options.mouse === false ? CLOSE_MOUSE : OPEN_MOUSE}\u001b[?7l`);
+        process.once("SIGINT", interrupt);
+        process.once("SIGTERM", terminate);
+        process.once("uncaughtException", fatal);
+    }
+    function close() {
+        if (!opened)
+            return;
+        opened = false;
+        process.removeListener("SIGINT", interrupt);
+        process.removeListener("SIGTERM", terminate);
+        process.removeListener("uncaughtException", fatal);
+        stream.write(`\u001b[0m\u001b[?7h${options.mouse === false ? "" : CLOSE_MOUSE}${CLOSE}`);
+    }
+    return {
+        open,
+        close,
+        writeFrame(ansi) {
+            if (!opened || ansi.length === 0)
+                return;
+            stream.write(`\u001b[?2026h${ansi}\u001b[?2026l`);
+        }
+    };
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/index.d.ts

@@ -3,6 +3,8 @@ import { type RenderOptions } from "./renderer.js";
 export type { CodeToken, CodeTokenKind, MdNode } from "./ast.js";
 export { renderHtml } from "./html-renderer.js";
 export type { HtmlRenderOptions } from "./html-renderer.js";
+export { renderPlaintext, renderMarkdownPlaintext } from "./plaintext-renderer.js";
+export type { PlaintextRenderOptions } from "./plaintext-renderer.js";
 export { parse } from "./parser.js";
 export { render } from "./renderer.js";
 export type { RenderOptions } from "./renderer.js";

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/index.js

@@ -2,6 +2,7 @@ import { parse } from "./parser.js";
 import { renderHtml } from "./html-renderer.js";
 import { render } from "./renderer.js";
 export { renderHtml } from "./html-renderer.js";
+export { renderPlaintext, renderMarkdownPlaintext } from "./plaintext-renderer.js";
 export { parse } from "./parser.js";
 export { render } from "./renderer.js";
 export function renderMarkdown(markdown, options) {

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/parser/frontmatter.js

@@ -1,4 +1,5 @@
 import { FrontmatterParseError, parseFrontmatter } from "@poe-code/frontmatter";
+const utf8Encoder = new TextEncoder();
 export function extractFrontmatter(markdown) {
     let parsed;
     try {
@@ -19,7 +20,7 @@ export function extractFrontmatter(markdown) {
         body: parsed.body
     }, {
         start: 0,
-        end: Buffer.byteLength(markdown.slice(0, markdown.length - parsed.body.length), "utf8")
+        end: utf8Encoder.encode(markdown.slice(0, markdown.length - parsed.body.length)).byteLength
     });
 }
 function withRange(result, range) {

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/parser/inline.js

@@ -519,10 +519,10 @@ function parseInlineCode(input, start, offsets) {
     return null;
 }
 function normalizeInlineCodeValue(value) {
+    value = value.replace(/\r\n?|\n/g, " ");
     if (value.length >= 2 &&
         value.startsWith(" ") &&
         value.endsWith(" ") &&
-        (value[1] === "`" || value[value.length - 2] === "`") &&
         value.trim().length > 0) {
         return value.slice(1, -1);
     }
@@ -618,6 +618,10 @@ function parseLinkDestination(input, openParenIndex) {
     let depth = 1;
     let quote = null;
     let index = openParenIndex + 1;
+    while (isAsciiWhitespace(input[index]))
+        index += 1;
+    const destinationStart = index;
+    let angleDestination = false;
     while (index < input.length) {
         const char = input[index];
         if (quote !== null) {
@@ -635,6 +639,19 @@ function parseLinkDestination(input, openParenIndex) {
             index += 2;
             continue;
         }
+        if (index === destinationStart && char === "<") {
+            angleDestination = true;
+            index += 1;
+            continue;
+        }
+        if (angleDestination) {
+            if (char === "\n" || char === "\r" || char === "<")
+                return null;
+            if (char === ">")
+                angleDestination = false;
+            index += 1;
+            continue;
+        }
         if (char === '"' || char === "'") {
             quote = char;
             index += 1;
@@ -662,26 +679,24 @@ function parseLinkDestination(input, openParenIndex) {
 }
 function parseLinkDestinationContent(content) {
     const trimmedEnd = trimAsciiWhitespaceEndIndex(content);
-    if (trimmedEnd === 0) {
-        return { url: "" };
-    }
+    let url = trimAsciiWhitespace(content.slice(0, trimmedEnd));
+    let title;
     const quote = content[trimmedEnd - 1];
     if (quote === '"' || quote === "'") {
         const titleStart = findTrailingQuotedSegmentStart(content, trimmedEnd, quote);
         if (titleStart !== -1) {
             let separatorStart = titleStart;
-            while (separatorStart > 0 && isAsciiWhitespace(content[separatorStart - 1])) {
+            while (separatorStart > 0 && isAsciiWhitespace(content[separatorStart - 1]))
                 separatorStart -= 1;
-            }
             if (separatorStart < titleStart) {
-                return {
-                    url: decodeEscapes(trimAsciiWhitespace(content.slice(0, separatorStart))),
-                    title: decodeEscapes(content.slice(titleStart + 1, trimmedEnd - 1))
-                };
+                url = trimAsciiWhitespace(content.slice(0, separatorStart));
+                title = decodeEscapes(content.slice(titleStart + 1, trimmedEnd - 1));
             }
         }
     }
-    return { url: decodeEscapes(trimAsciiWhitespace(content.slice(0, trimmedEnd))) };
+    if (url.startsWith("<") && url.endsWith(">"))
+        url = url.slice(1, -1);
+    return { url: decodeEscapes(url), ...(title === undefined ? {} : { title }) };
 }
 function findTrailingQuotedSegmentStart(content, end, quote) {
     let index = end - 2;
@@ -853,9 +868,12 @@ function parseInlineHtmlTag(input, start, offsets) {
             return null;
         }
         if (input[index] === ">") {
+            const tagEnd = index + 1;
+            const closingTagEnd = findClosingInlineHtmlTagEnd(input, tagEnd, tagName);
+            const nodeEnd = closingTagEnd ?? tagEnd;
             return {
-                node: withRange({ type: "html", value: input.slice(start, index + 1) }, offsets === undefined ? { start, end: index + 1 } : createRange(offsets, start, index + 1)),
-                end: index + 1
+                node: withRange({ type: "html", value: input.slice(start, nodeEnd) }, offsets === undefined ? { start, end: nodeEnd } : createRange(offsets, start, nodeEnd)),
+                end: nodeEnd
             };
         }
         if (input[index] === "/") {
@@ -907,6 +925,39 @@ function parseInlineHtmlTag(input, start, offsets) {
     }
     return null;
 }
+function findClosingInlineHtmlTagEnd(input, start, tagName) {
+    let index = start;
+    while (index < input.length) {
+        if (input[index] !== "<") {
+            index += 1;
+            continue;
+        }
+        const closingEnd = readClosingInlineHtmlTagEnd(input, index, tagName);
+        if (closingEnd !== undefined) {
+            return closingEnd;
+        }
+        index += 1;
+    }
+    return undefined;
+}
+function readClosingInlineHtmlTagEnd(input, start, tagName) {
+    let index = start + 1;
+    if (index >= input.length || input[index] !== "/") {
+        return undefined;
+    }
+    index += 1;
+    for (const expectedChar of tagName) {
+        if (index >= input.length || input[index]?.toLowerCase() !== expectedChar) {
+            return undefined;
+        }
+        index += 1;
+    }
+    index = skipHtmlWhitespace(input, index);
+    if (index >= input.length || input[index] !== ">") {
+        return undefined;
+    }
+    return index + 1;
+}
 function decodeEscapes(value) {
     let result = "";
     let index = 0;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/parser.js

@@ -1,4 +1,5 @@
 import { parseBlockDocument } from "./parser/block.js";
+const utf8Encoder = new TextEncoder();
 export function parse(markdown) {
     const { frontmatter, frontmatterRange, children } = parseBlockDocument(markdown);
     const ast = withRange({
@@ -8,7 +9,7 @@ export function parse(markdown) {
             : [createFrontmatterNode(frontmatter, frontmatterRange), ...children]
     }, {
         start: 0,
-        end: Buffer.byteLength(markdown, "utf8")
+        end: utf8Encoder.encode(markdown).byteLength
     });
     return {
         ...(frontmatter === undefined ? {} : { frontmatter }),

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/plaintext-renderer.d.ts

@@ -0,0 +1,11 @@
+import type { MdNode } from "./ast.js";
+export interface PlaintextRenderOptions {
+    announceHeadings?: boolean;
+    announceCode?: boolean;
+    announceAlerts?: boolean;
+    showLinks?: boolean;
+    expandLinks?: boolean;
+    includeFrontmatter?: boolean;
+}
+export declare function renderPlaintext(ast: MdNode, options?: PlaintextRenderOptions): string;
+export declare function renderMarkdownPlaintext(markdown: string, options?: PlaintextRenderOptions): string;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/plaintext-renderer.js

@@ -0,0 +1,228 @@
+import { stripAnsi } from "../internal/strip-ansi.js";
+import { parse } from "./parser.js";
+function renderInline(node, ctx) {
+    switch (node.type) {
+        case "text":
+            return stripAnsi(node.value);
+        case "emphasis":
+        case "strong":
+            return renderChildren(node.children, ctx);
+        case "strikethrough":
+            return "";
+        case "inlineCode":
+            return stripAnsi(node.value);
+        case "break":
+            return " ";
+        case "html":
+            return "";
+        case "link": {
+            const childText = renderChildren(node.children, ctx) || node.url;
+            if (ctx.expandLinks) {
+                return `${childText} ${stripAnsi(node.url)}`;
+            }
+            if (ctx.showLinks) {
+                return `${childText} (link)`;
+            }
+            return childText;
+        }
+        case "image":
+            return stripAnsi(node.alt);
+        case "footnoteReference": {
+            if (!ctx.footnoteOrder.includes(node.label)) {
+                ctx.footnoteOrder.push(node.label);
+            }
+            const index = ctx.footnoteOrder.indexOf(node.label) + 1;
+            return `[${index}]`;
+        }
+        default:
+            return "";
+    }
+}
+function renderChildren(nodes, ctx) {
+    return nodes.map((node) => renderInline(node, ctx)).join("");
+}
+function renderBlock(node, ctx) {
+    switch (node.type) {
+        case "root": {
+            collectFootnoteDefinitions(node.children, ctx);
+            const text = trimBlockSeparators(renderBlockChildren(node.children, ctx));
+            const footnotes = renderReferencedFootnotes(ctx);
+            return footnotes.length === 0 ? text : trimBlockSeparators(`${text}\n\n${footnotes}`);
+        }
+        case "paragraph":
+            return `${renderChildren(node.children, ctx)}\n\n`;
+        case "thematicBreak":
+            return "";
+        case "heading": {
+            const prefix = ctx.announceHeadings && node.depth === 1
+                ? "Section: "
+                : ctx.announceHeadings && node.depth === 2
+                    ? "Subsection: "
+                    : ctx.announceHeadings
+                        ? "Topic: "
+                        : "";
+            return `${prefix}${renderChildren(node.children, ctx).trim()}\n\n`;
+        }
+        case "blockquote":
+            return `Quote: ${renderBlockChildren(node.children, ctx).trim()}\n\n`;
+        case "alert": {
+            const prefix = ctx.announceAlerts ? `${node.kind}: ` : "";
+            return `${prefix}${renderBlockChildren(node.children, ctx).trim()}\n\n`;
+        }
+        case "list": {
+            const items = node.children
+                .filter((child) => child.type === "listItem")
+                .map((child, index) => {
+                const text = renderBlock(child, ctx).trim();
+                return node.ordered ? `${getOrderedListPrefix(index)}${text}` : text;
+            });
+            return `${items.join(node.ordered ? " " : getUnorderedListSeparator(items.length))}\n\n`;
+        }
+        case "listItem": {
+            const text = renderBlockChildren(node.children, ctx).trim();
+            if (node.checked === true) {
+                return `done: ${text}`;
+            }
+            if (node.checked === false) {
+                return `to do: ${text}`;
+            }
+            return text;
+        }
+        case "table": {
+            const [headerRow, ...bodyRows] = node.children.filter((child) => child.type === "tableRow");
+            if (!headerRow) {
+                return "\n\n";
+            }
+            const headers = headerRow.children.map((cell) => cell.type === "tableCell" ? renderChildren(cell.children, ctx).trim() : "");
+            const sentences = bodyRows.flatMap((row) => row.children.flatMap((cell, index) => {
+                if (cell.type !== "tableCell") {
+                    return [];
+                }
+                const header = headers[index]?.trim() ?? "";
+                const value = renderChildren(cell.children, ctx).trim();
+                return value === "" ? [] : `${header} is ${value}.`;
+            }));
+            return `${sentences.join(" ")}\n\n`;
+        }
+        case "tableRow":
+        case "tableCell":
+            return "";
+        case "code": {
+            const prefix = ctx.announceCode ? "Code: " : "";
+            const value = node.value.length === 0 && ctx.announceCode ? "Code:" : `${prefix}${node.value}`;
+            return `${value}\n\n`;
+        }
+        case "frontmatter": {
+            if (!ctx.includeFrontmatter) {
+                return "";
+            }
+            return `${Object.entries(node.data)
+                .map(([key, value]) => `${key}: ${String(value)}.`)
+                .join(" ")}\n\n`;
+        }
+        case "footnoteDefinition":
+            return "";
+        default:
+            return "";
+    }
+}
+function renderBlockChildren(nodes, ctx) {
+    return nodes
+        .map((node) => (isBlockNode(node) ? renderBlock(node, ctx) : renderInline(node, ctx)))
+        .join("");
+}
+function isBlockNode(node) {
+    switch (node.type) {
+        case "root":
+        case "paragraph":
+        case "thematicBreak":
+        case "heading":
+        case "blockquote":
+        case "alert":
+        case "list":
+        case "listItem":
+        case "table":
+        case "tableRow":
+        case "tableCell":
+        case "code":
+        case "frontmatter":
+        case "footnoteDefinition":
+            return true;
+        default:
+            return false;
+    }
+}
+function collectFootnoteDefinitions(nodes, ctx) {
+    for (const node of nodes) {
+        if (node.type === "footnoteDefinition") {
+            ctx.footnoteDefinitions.set(node.label, renderBlockChildren(node.children, createFootnoteDefinitionContext(ctx)).trim());
+            continue;
+        }
+        if ("children" in node) {
+            collectFootnoteDefinitions(node.children, ctx);
+        }
+    }
+}
+function createFootnoteDefinitionContext(ctx) {
+    return {
+        announceHeadings: ctx.announceHeadings,
+        announceCode: ctx.announceCode,
+        announceAlerts: ctx.announceAlerts,
+        showLinks: ctx.showLinks,
+        expandLinks: ctx.expandLinks,
+        includeFrontmatter: ctx.includeFrontmatter,
+        footnoteDefinitions: new Map(),
+        footnoteOrder: []
+    };
+}
+function renderReferencedFootnotes(ctx) {
+    return ctx.footnoteOrder
+        .map((label, index) => {
+        const definitionText = ctx.footnoteDefinitions.get(label);
+        return definitionText === undefined ? "" : `Note ${index + 1}: ${definitionText}.`;
+    })
+        .filter((value) => value.length > 0)
+        .join(" ");
+}
+function getOrderedListPrefix(index) {
+    switch (index) {
+        case 0:
+            return "First, ";
+        case 1:
+            return "Second, ";
+        case 2:
+            return "Third, ";
+        default:
+            return "Next, ";
+    }
+}
+function getUnorderedListSeparator(itemCount) {
+    return itemCount <= 3 ? ", " : "; ";
+}
+function trimBlockSeparators(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && value[start] === "\n") {
+        start += 1;
+    }
+    while (end > start && value[end - 1] === "\n") {
+        end -= 1;
+    }
+    return value.slice(start, end);
+}
+export function renderPlaintext(ast, options) {
+    return renderBlock(ast, {
+        announceHeadings: options?.announceHeadings ?? true,
+        announceCode: options?.announceCode ?? true,
+        announceAlerts: options?.announceAlerts ?? true,
+        showLinks: options?.showLinks ?? false,
+        expandLinks: options?.expandLinks ?? false,
+        includeFrontmatter: options?.includeFrontmatter ?? false,
+        footnoteDefinitions: new Map(),
+        footnoteOrder: []
+    });
+}
+export function renderMarkdownPlaintext(markdown, options) {
+    const { ast } = parse(markdown);
+    return renderPlaintext(ast, options);
+}