livemark 0.7.1 → 0.8.0

package/target/plugins/remark-abbr.unit.js

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vite-plus/test";
+import { transformAbbrDirectives } from "./remark-abbr.js";
+function makeTextDirective(name, text, attributes) {
+    return {
+        type: "textDirective",
+        name,
+        attributes: attributes ?? {},
+        children: [{ type: "text", value: text }],
+    };
+}
+function makeTree(...children) {
+    return { type: "root", children };
+}
+describe("transformAbbrDirectives", () => {
+    function process(tree) {
+        transformAbbrDirectives(tree);
+        return tree;
+    }
+    it("should convert :abbr directive to Abbr JSX element", () => {
+        const directive = makeTextDirective("abbr", "HTML", {
+            title: "HyperText Markup Language",
+        });
+        const tree = process(makeTree({
+            type: "paragraph",
+            children: [directive],
+        }));
+        const paragraph = tree.children[0];
+        if (!paragraph || paragraph.type !== "paragraph")
+            throw new Error("Expected paragraph");
+        const node = paragraph.children[0];
+        expect(node).toMatchObject({
+            type: "mdxJsxTextElement",
+            name: "Abbr",
+            attributes: [
+                { type: "mdxJsxAttribute", name: "text", value: "HTML" },
+                {
+                    type: "mdxJsxAttribute",
+                    name: "title",
+                    value: "HyperText Markup Language",
+                },
+            ],
+            children: [],
+        });
+    });
+    it("should use empty string when title is not provided", () => {
+        const directive = makeTextDirective("abbr", "CSS");
+        const tree = process(makeTree({
+            type: "paragraph",
+            children: [directive],
+        }));
+        const paragraph = tree.children[0];
+        if (!paragraph || paragraph.type !== "paragraph")
+            throw new Error("Expected paragraph");
+        const node = paragraph.children[0];
+        expect(node).toMatchObject({
+            type: "mdxJsxTextElement",
+            name: "Abbr",
+            attributes: [
+                { type: "mdxJsxAttribute", name: "text", value: "CSS" },
+                { type: "mdxJsxAttribute", name: "title", value: "" },
+            ],
+        });
+    });
+    it("should ignore non-abbr text directives", () => {
+        const directive = makeTextDirective("other", "Text");
+        const tree = process(makeTree({
+            type: "paragraph",
+            children: [directive],
+        }));
+        const paragraph = tree.children[0];
+        if (!paragraph || paragraph.type !== "paragraph")
+            throw new Error("Expected paragraph");
+        expect(paragraph.children[0]).toMatchObject({
+            type: "textDirective",
+            name: "other",
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtYXJrLWFiYnIudW5pdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9wbHVnaW5zL3JlbWFyay1hYmJyLnVuaXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDckQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFFMUQsU0FBUyxpQkFBaUIsQ0FDeEIsSUFBWSxFQUNaLElBQVksRUFDWixVQUFtQztJQUVuQyxPQUFPO1FBQ0wsSUFBSSxFQUFFLGVBQWU7UUFDckIsSUFBSTtRQUNKLFVBQVUsRUFBRSxVQUFVLElBQUksRUFBRTtRQUM1QixRQUFRLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDO0tBQzFDLENBQUE7QUFDSCxDQUFDO0FBRUQsU0FBUyxRQUFRLENBQUMsR0FBRyxRQUEwQjtJQUM3QyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsQ0FBQTtBQUNuQyxDQUFDO0FBRUQsUUFBUSxDQUFDLHlCQUF5QixFQUFFLEdBQUcsRUFBRTtJQUN2QyxTQUFTLE9BQU8sQ0FBQyxJQUFVO1FBQ3pCLHVCQUF1QixDQUFDLElBQUksQ0FBQyxDQUFBO1FBQzdCLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUVELEVBQUUsQ0FBQyxvREFBb0QsRUFBRSxHQUFHLEVBQUU7UUFDNUQsTUFBTSxTQUFTLEdBQUcsaUJBQWlCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRTtZQUNsRCxLQUFLLEVBQUUsMkJBQTJCO1NBQ25DLENBQUMsQ0FBQTtRQUNGLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FDbEIsUUFBUSxDQUFDO1lBQ1AsSUFBSSxFQUFFLFdBQVc7WUFDakIsUUFBUSxFQUFFLENBQUMsU0FBUyxDQUFDO1NBQ3RCLENBQUMsQ0FDSCxDQUFBO1FBRUQsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNsQyxJQUFJLENBQUMsU0FBUyxJQUFJLFNBQVMsQ0FBQyxJQUFJLEtBQUssV0FBVztZQUM5QyxNQUFNLElBQUksS0FBSyxDQUFDLG9CQUFvQixDQUFDLENBQUE7UUFDdkMsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNsQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsYUFBYSxDQUFDO1lBQ3pCLElBQUksRUFBRSxtQkFBbUI7WUFDekIsSUFBSSxFQUFFLE1BQU07WUFDWixVQUFVLEVBQUU7Z0JBQ1YsRUFBRSxJQUFJLEVBQUUsaUJBQWlCLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFO2dCQUN4RDtvQkFDRSxJQUFJLEVBQUUsaUJBQWlCO29CQUN2QixJQUFJLEVBQUUsT0FBTztvQkFDYixLQUFLLEVBQUUsMkJBQTJCO2lCQUNuQzthQUNGO1lBQ0QsUUFBUSxFQUFFLEVBQUU7U0FDYixDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtJQUVGLEVBQUUsQ0FBQyxvREFBb0QsRUFBRSxHQUFHLEVBQUU7UUFDNUQsTUFBTSxTQUFTLEdBQUcsaUJBQWlCLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFBO1FBQ2xELE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FDbEIsUUFBUSxDQUFDO1lBQ1AsSUFBSSxFQUFFLFdBQVc7WUFDakIsUUFBUSxFQUFFLENBQUMsU0FBUyxDQUFDO1NBQ3RCLENBQUMsQ0FDSCxDQUFBO1FBRUQsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNsQyxJQUFJLENBQUMsU0FBUyxJQUFJLFNBQVMsQ0FBQyxJQUFJLEtBQUssV0FBVztZQUM5QyxNQUFNLElBQUksS0FBSyxDQUFDLG9CQUFvQixDQUFDLENBQUE7UUFDdkMsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNsQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsYUFBYSxDQUFDO1lBQ3pCLElBQUksRUFBRSxtQkFBbUI7WUFDekIsSUFBSSxFQUFFLE1BQU07WUFDWixVQUFVLEVBQUU7Z0JBQ1YsRUFBRSxJQUFJLEVBQUUsaUJBQWlCLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFO2dCQUN2RCxFQUFFLElBQUksRUFBRSxpQkFBaUIsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUU7YUFDdEQ7U0FDRixDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtJQUVGLEVBQUUsQ0FBQyx3Q0FBd0MsRUFBRSxHQUFHLEVBQUU7UUFDaEQsTUFBTSxTQUFTLEdBQUcsaUJBQWlCLENBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxDQUFBO1FBQ3BELE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FDbEIsUUFBUSxDQUFDO1lBQ1AsSUFBSSxFQUFFLFdBQVc7WUFDakIsUUFBUSxFQUFFLENBQUMsU0FBUyxDQUFDO1NBQ3RCLENBQUMsQ0FDSCxDQUFBO1FBRUQsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNsQyxJQUFJLENBQUMsU0FBUyxJQUFJLFNBQVMsQ0FBQyxJQUFJLEtBQUssV0FBVztZQUM5QyxNQUFNLElBQUksS0FBSyxDQUFDLG9CQUFvQixDQUFDLENBQUE7UUFDdkMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUM7WUFDMUMsSUFBSSxFQUFFLGVBQWU7WUFDckIsSUFBSSxFQUFFLE9BQU87U0FDZCxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSb290IH0gZnJvbSBcIm1kYXN0XCJcbmltcG9ydCB0eXBlIHsgVGV4dERpcmVjdGl2ZSB9IGZyb20gXCJtZGFzdC11dGlsLWRpcmVjdGl2ZVwiXG5pbXBvcnQgeyBkZXNjcmliZSwgZXhwZWN0LCBpdCB9IGZyb20gXCJ2aXRlLXBsdXMvdGVzdFwiXG5pbXBvcnQgeyB0cmFuc2Zvcm1BYmJyRGlyZWN0aXZlcyB9IGZyb20gXCIuL3JlbWFyay1hYmJyLnRzXCJcblxuZnVuY3Rpb24gbWFrZVRleHREaXJlY3RpdmUoXG4gIG5hbWU6IHN0cmluZyxcbiAgdGV4dDogc3RyaW5nLFxuICBhdHRyaWJ1dGVzPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPixcbik6IFRleHREaXJlY3RpdmUge1xuICByZXR1cm4ge1xuICAgIHR5cGU6IFwidGV4dERpcmVjdGl2ZVwiLFxuICAgIG5hbWUsXG4gICAgYXR0cmlidXRlczogYXR0cmlidXRlcyA/PyB7fSxcbiAgICBjaGlsZHJlbjogW3sgdHlwZTogXCJ0ZXh0XCIsIHZhbHVlOiB0ZXh0IH1dLFxuICB9XG59XG5cbmZ1bmN0aW9uIG1ha2VUcmVlKC4uLmNoaWxkcmVuOiBSb290W1wiY2hpbGRyZW5cIl0pOiBSb290IHtcbiAgcmV0dXJuIHsgdHlwZTogXCJyb290XCIsIGNoaWxkcmVuIH1cbn1cblxuZGVzY3JpYmUoXCJ0cmFuc2Zvcm1BYmJyRGlyZWN0aXZlc1wiLCAoKSA9PiB7XG4gIGZ1bmN0aW9uIHByb2Nlc3ModHJlZTogUm9vdCkge1xuICAgIHRyYW5zZm9ybUFiYnJEaXJlY3RpdmVzKHRyZWUpXG4gICAgcmV0dXJuIHRyZWVcbiAgfVxuXG4gIGl0KFwic2hvdWxkIGNvbnZlcnQgOmFiYnIgZGlyZWN0aXZlIHRvIEFiYnIgSlNYIGVsZW1lbnRcIiwgKCkgPT4ge1xuICAgIGNvbnN0IGRpcmVjdGl2ZSA9IG1ha2VUZXh0RGlyZWN0aXZlKFwiYWJiclwiLCBcIkhUTUxcIiwge1xuICAgICAgdGl0bGU6IFwiSHlwZXJUZXh0IE1hcmt1cCBMYW5ndWFnZVwiLFxuICAgIH0pXG4gICAgY29uc3QgdHJlZSA9IHByb2Nlc3MoXG4gICAgICBtYWtlVHJlZSh7XG4gICAgICAgIHR5cGU6IFwicGFyYWdyYXBoXCIsXG4gICAgICAgIGNoaWxkcmVuOiBbZGlyZWN0aXZlXSxcbiAgICAgIH0pLFxuICAgIClcblxuICAgIGNvbnN0IHBhcmFncmFwaCA9IHRyZWUuY2hpbGRyZW5bMF1cbiAgICBpZiAoIXBhcmFncmFwaCB8fCBwYXJhZ3JhcGgudHlwZSAhPT0gXCJwYXJhZ3JhcGhcIilcbiAgICAgIHRocm93IG5ldyBFcnJvcihcIkV4cGVjdGVkIHBhcmFncmFwaFwiKVxuICAgIGNvbnN0IG5vZGUgPSBwYXJhZ3JhcGguY2hpbGRyZW5bMF1cbiAgICBleHBlY3Qobm9kZSkudG9NYXRjaE9iamVjdCh7XG4gICAgICB0eXBlOiBcIm1keEpzeFRleHRFbGVtZW50XCIsXG4gICAgICBuYW1lOiBcIkFiYnJcIixcbiAgICAgIGF0dHJpYnV0ZXM6IFtcbiAgICAgICAgeyB0eXBlOiBcIm1keEpzeEF0dHJpYnV0ZVwiLCBuYW1lOiBcInRleHRcIiwgdmFsdWU6IFwiSFRNTFwiIH0sXG4gICAgICAgIHtcbiAgICAgICAgICB0eXBlOiBcIm1keEpzeEF0dHJpYnV0ZVwiLFxuICAgICAgICAgIG5hbWU6IFwidGl0bGVcIixcbiAgICAgICAgICB2YWx1ZTogXCJIeXBlclRleHQgTWFya3VwIExhbmd1YWdlXCIsXG4gICAgICAgIH0sXG4gICAgICBdLFxuICAgICAgY2hpbGRyZW46IFtdLFxuICAgIH0pXG4gIH0pXG5cbiAgaXQoXCJzaG91bGQgdXNlIGVtcHR5IHN0cmluZyB3aGVuIHRpdGxlIGlzIG5vdCBwcm92aWRlZFwiLCAoKSA9PiB7XG4gICAgY29uc3QgZGlyZWN0aXZlID0gbWFrZVRleHREaXJlY3RpdmUoXCJhYmJyXCIsIFwiQ1NTXCIpXG4gICAgY29uc3QgdHJlZSA9IHByb2Nlc3MoXG4gICAgICBtYWtlVHJlZSh7XG4gICAgICAgIHR5cGU6IFwicGFyYWdyYXBoXCIsXG4gICAgICAgIGNoaWxkcmVuOiBbZGlyZWN0aXZlXSxcbiAgICAgIH0pLFxuICAgIClcblxuICAgIGNvbnN0IHBhcmFncmFwaCA9IHRyZWUuY2hpbGRyZW5bMF1cbiAgICBpZiAoIXBhcmFncmFwaCB8fCBwYXJhZ3JhcGgudHlwZSAhPT0gXCJwYXJhZ3JhcGhcIilcbiAgICAgIHRocm93IG5ldyBFcnJvcihcIkV4cGVjdGVkIHBhcmFncmFwaFwiKVxuICAgIGNvbnN0IG5vZGUgPSBwYXJhZ3JhcGguY2hpbGRyZW5bMF1cbiAgICBleHBlY3Qobm9kZSkudG9NYXRjaE9iamVjdCh7XG4gICAgICB0eXBlOiBcIm1keEpzeFRleHRFbGVtZW50XCIsXG4gICAgICBuYW1lOiBcIkFiYnJcIixcbiAgICAgIGF0dHJpYnV0ZXM6IFtcbiAgICAgICAgeyB0eXBlOiBcIm1keEpzeEF0dHJpYnV0ZVwiLCBuYW1lOiBcInRleHRcIiwgdmFsdWU6IFwiQ1NTXCIgfSxcbiAgICAgICAgeyB0eXBlOiBcIm1keEpzeEF0dHJpYnV0ZVwiLCBuYW1lOiBcInRpdGxlXCIsIHZhbHVlOiBcIlwiIH0sXG4gICAgICBdLFxuICAgIH0pXG4gIH0pXG5cbiAgaXQoXCJzaG91bGQgaWdub3JlIG5vbi1hYmJyIHRleHQgZGlyZWN0aXZlc1wiLCAoKSA9PiB7XG4gICAgY29uc3QgZGlyZWN0aXZlID0gbWFrZVRleHREaXJlY3RpdmUoXCJvdGhlclwiLCBcIlRleHRcIilcbiAgICBjb25zdCB0cmVlID0gcHJvY2VzcyhcbiAgICAgIG1ha2VUcmVlKHtcbiAgICAgICAgdHlwZTogXCJwYXJhZ3JhcGhcIixcbiAgICAgICAgY2hpbGRyZW46IFtkaXJlY3RpdmVdLFxuICAgICAgfSksXG4gICAgKVxuXG4gICAgY29uc3QgcGFyYWdyYXBoID0gdHJlZS5jaGlsZHJlblswXVxuICAgIGlmICghcGFyYWdyYXBoIHx8IHBhcmFncmFwaC50eXBlICE9PSBcInBhcmFncmFwaFwiKVxuICAgICAgdGhyb3cgbmV3IEVycm9yKFwiRXhwZWN0ZWQgcGFyYWdyYXBoXCIpXG4gICAgZXhwZWN0KHBhcmFncmFwaC5jaGlsZHJlblswXSkudG9NYXRjaE9iamVjdCh7XG4gICAgICB0eXBlOiBcInRleHREaXJlY3RpdmVcIixcbiAgICAgIG5hbWU6IFwib3RoZXJcIixcbiAgICB9KVxuICB9KVxufSlcbiJdfQ==

package/target/plugins/remark-ansi.d.ts

@@ -0,0 +1,8 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+/** Convert a string containing ANSI escape sequences into HTML with inline styles */
+export declare function ansiToHtml(input: string): string;
+/** Walk a mdast tree and convert ansi code blocks into AnsiCode JSX elements */
+export declare function transformAnsiCodeBlocks(tree: Root): void;
+/** Remark plugin that converts ansi code blocks into colored HTML output */
+export declare const remarkAnsi: Plugin<[], Root>;

package/target/plugins/remark-ansi.js

@@ -0,0 +1,239 @@
+const STANDARD_COLORS = [
+    "#4f5b66", // 0 black
+    "#bf616a", // 1 red
+    "#a3be8c", // 2 green
+    "#ebcb8b", // 3 yellow
+    "#8fa1b3", // 4 blue
+    "#b48ead", // 5 magenta
+    "#96b5b4", // 6 cyan
+    "#c0c5ce", // 7 white
+];
+const BRIGHT_COLORS = [
+    "#65737e", // 8 bright black
+    "#bf616a", // 9 bright red
+    "#a3be8c", // 10 bright green
+    "#ebcb8b", // 11 bright yellow
+    "#8fa1b3", // 12 bright blue
+    "#b48ead", // 13 bright magenta
+    "#96b5b4", // 14 bright cyan
+    "#eff1f5", // 15 bright white
+];
+function color256(n) {
+    if (n < 8)
+        return STANDARD_COLORS[n];
+    if (n < 16)
+        return BRIGHT_COLORS[n - 8];
+    if (n < 232) {
+        const idx = n - 16;
+        const r = Math.floor(idx / 36);
+        const g = Math.floor((idx % 36) / 6);
+        const b = idx % 6;
+        const toHex = (v) => (v === 0 ? 0 : 55 + v * 40).toString(16).padStart(2, "0");
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    if (n < 256) {
+        const v = (8 + (n - 232) * 10).toString(16).padStart(2, "0");
+        return `#${v}${v}${v}`;
+    }
+    return undefined;
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function buildStyle(state) {
+    const parts = [];
+    if (state.fg)
+        parts.push(`color:${state.fg}`);
+    if (state.bg)
+        parts.push(`background-color:${state.bg}`);
+    if (state.bold)
+        parts.push("font-weight:bold");
+    if (state.dim)
+        parts.push("opacity:0.7");
+    if (state.italic)
+        parts.push("font-style:italic");
+    if (state.underline)
+        parts.push("text-decoration:underline");
+    if (state.strikethrough)
+        parts.push("text-decoration:line-through");
+    return parts.join(";");
+}
+function makeDefaultState() {
+    return {
+        bold: false,
+        dim: false,
+        italic: false,
+        underline: false,
+        strikethrough: false,
+        fg: undefined,
+        bg: undefined,
+    };
+}
+function applyParams(state, params) {
+    let i = 0;
+    while (i < params.length) {
+        const code = params[i];
+        switch (code) {
+            case 0: {
+                const reset = makeDefaultState();
+                state.bold = reset.bold;
+                state.dim = reset.dim;
+                state.italic = reset.italic;
+                state.underline = reset.underline;
+                state.strikethrough = reset.strikethrough;
+                state.fg = reset.fg;
+                state.bg = reset.bg;
+                break;
+            }
+            case 1:
+                state.bold = true;
+                break;
+            case 2:
+                state.dim = true;
+                break;
+            case 3:
+                state.italic = true;
+                break;
+            case 4:
+                state.underline = true;
+                break;
+            case 9:
+                state.strikethrough = true;
+                break;
+            case 22:
+                state.bold = false;
+                state.dim = false;
+                break;
+            case 23:
+                state.italic = false;
+                break;
+            case 24:
+                state.underline = false;
+                break;
+            case 29:
+                state.strikethrough = false;
+                break;
+            case 39:
+                state.fg = undefined;
+                break;
+            case 49:
+                state.bg = undefined;
+                break;
+            default:
+                if (code >= 30 && code <= 37) {
+                    state.fg = STANDARD_COLORS[code - 30];
+                }
+                else if (code >= 40 && code <= 47) {
+                    state.bg = STANDARD_COLORS[code - 40];
+                }
+                else if (code >= 90 && code <= 97) {
+                    state.fg = BRIGHT_COLORS[code - 90];
+                }
+                else if (code >= 100 && code <= 107) {
+                    state.bg = BRIGHT_COLORS[code - 100];
+                }
+                else if (code === 38 || code === 48) {
+                    const kind = params[i + 1];
+                    if (kind === 5) {
+                        const colorIdx = params[i + 2];
+                        if (colorIdx !== undefined) {
+                            const c = color256(colorIdx);
+                            if (code === 38)
+                                state.fg = c;
+                            else
+                                state.bg = c;
+                        }
+                        i += 2;
+                    }
+                    else if (kind === 2) {
+                        const r = params[i + 2] ?? 0;
+                        const g = params[i + 3] ?? 0;
+                        const b = params[i + 4] ?? 0;
+                        const toHex = (v) => v.toString(16).padStart(2, "0");
+                        const c = `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+                        if (code === 38)
+                            state.fg = c;
+                        else
+                            state.bg = c;
+                        i += 4;
+                    }
+                }
+                break;
+        }
+        i++;
+    }
+}
+/** Convert a string containing ANSI escape sequences into HTML with inline styles */
+export function ansiToHtml(input) {
+    // oxlint-disable-next-line no-control-regex -- ANSI escape sequences start with U+001B
+    const sgr = /\u001b\[([0-9;]*)m/g;
+    const state = makeDefaultState();
+    const parts = [];
+    let lastIndex = 0;
+    let match = sgr.exec(input);
+    while (match !== null) {
+        const textBefore = input.slice(lastIndex, match.index);
+        if (textBefore) {
+            const style = buildStyle(state);
+            if (style) {
+                parts.push(`<span style="${style}">${escapeHtml(textBefore)}</span>`);
+            }
+            else {
+                parts.push(escapeHtml(textBefore));
+            }
+        }
+        const rawParams = match[1];
+        const params = rawParams === ""
+            ? [0]
+            : rawParams.split(";").map(s => Number.parseInt(s, 10));
+        applyParams(state, params);
+        lastIndex = match.index + match[0].length;
+        match = sgr.exec(input);
+    }
+    const trailing = input.slice(lastIndex);
+    if (trailing) {
+        const style = buildStyle(state);
+        if (style) {
+            parts.push(`<span style="${style}">${escapeHtml(trailing)}</span>`);
+        }
+        else {
+            parts.push(escapeHtml(trailing));
+        }
+    }
+    return parts.join("");
+}
+/** Walk a mdast tree and convert ansi code blocks into AnsiCode JSX elements */
+export function transformAnsiCodeBlocks(tree) {
+    const children = tree.children;
+    for (let i = 0; i < children.length; i++) {
+        const node = children[i];
+        if (node?.type !== "code" || node.lang !== "ansi")
+            continue;
+        const html = ansiToHtml(node.value);
+        const jsxNode = {
+            type: "mdxJsxFlowElement",
+            name: "AnsiCode",
+            attributes: [
+                {
+                    type: "mdxJsxAttribute",
+                    name: "html",
+                    value: html,
+                },
+            ],
+            children: [],
+        };
+        // @ts-expect-error mdxJsxFlowElement is not in mdast types
+        children[i] = jsxNode;
+    }
+}
+/** Remark plugin that converts ansi code blocks into colored HTML output */
+export const remarkAnsi = () => {
+    return tree => {
+        transformAnsiCodeBlocks(tree);
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remark-ansi.js","sourceRoot":"","sources":["../../source/plugins/remark-ansi.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Root } from \"mdast\"\nimport type { Plugin } from \"unified\"\n\ninterface AnsiState {\n  bold: boolean\n  dim: boolean\n  italic: boolean\n  underline: boolean\n  strikethrough: boolean\n  fg: string | undefined\n  bg: string | undefined\n}\n\nconst STANDARD_COLORS: ReadonlyArray<string> = [\n  \"#4f5b66\", // 0 black\n  \"#bf616a\", // 1 red\n  \"#a3be8c\", // 2 green\n  \"#ebcb8b\", // 3 yellow\n  \"#8fa1b3\", // 4 blue\n  \"#b48ead\", // 5 magenta\n  \"#96b5b4\", // 6 cyan\n  \"#c0c5ce\", // 7 white\n]\n\nconst BRIGHT_COLORS: ReadonlyArray<string> = [\n  \"#65737e\", // 8 bright black\n  \"#bf616a\", // 9 bright red\n  \"#a3be8c\", // 10 bright green\n  \"#ebcb8b\", // 11 bright yellow\n  \"#8fa1b3\", // 12 bright blue\n  \"#b48ead\", // 13 bright magenta\n  \"#96b5b4\", // 14 bright cyan\n  \"#eff1f5\", // 15 bright white\n]\n\nfunction color256(n: number): string | undefined {\n  if (n < 8) return STANDARD_COLORS[n]\n  if (n < 16) return BRIGHT_COLORS[n - 8]\n  if (n < 232) {\n    const idx = n - 16\n    const r = Math.floor(idx / 36)\n    const g = Math.floor((idx % 36) / 6)\n    const b = idx % 6\n    const toHex = (v: number) =>\n      (v === 0 ? 0 : 55 + v * 40).toString(16).padStart(2, \"0\")\n    return `#${toHex(r)}${toHex(g)}${toHex(b)}`\n  }\n  if (n < 256) {\n    const v = (8 + (n - 232) * 10).toString(16).padStart(2, \"0\")\n    return `#${v}${v}${v}`\n  }\n  return undefined\n}\n\nfunction escapeHtml(text: string): string {\n  return text\n    .replace(/&/g, \"&amp;\")\n    .replace(/</g, \"&lt;\")\n    .replace(/>/g, \"&gt;\")\n    .replace(/\"/g, \"&quot;\")\n}\n\nfunction buildStyle(state: AnsiState): string {\n  const parts: string[] = []\n  if (state.fg) parts.push(`color:${state.fg}`)\n  if (state.bg) parts.push(`background-color:${state.bg}`)\n  if (state.bold) parts.push(\"font-weight:bold\")\n  if (state.dim) parts.push(\"opacity:0.7\")\n  if (state.italic) parts.push(\"font-style:italic\")\n  if (state.underline) parts.push(\"text-decoration:underline\")\n  if (state.strikethrough) parts.push(\"text-decoration:line-through\")\n  return parts.join(\";\")\n}\n\nfunction makeDefaultState(): AnsiState {\n  return {\n    bold: false,\n    dim: false,\n    italic: false,\n    underline: false,\n    strikethrough: false,\n    fg: undefined,\n    bg: undefined,\n  }\n}\n\nfunction applyParams(state: AnsiState, params: ReadonlyArray<number>) {\n  let i = 0\n  while (i < params.length) {\n    const code = params[i]!\n    switch (code) {\n      case 0: {\n        const reset = makeDefaultState()\n        state.bold = reset.bold\n        state.dim = reset.dim\n        state.italic = reset.italic\n        state.underline = reset.underline\n        state.strikethrough = reset.strikethrough\n        state.fg = reset.fg\n        state.bg = reset.bg\n        break\n      }\n      case 1:\n        state.bold = true\n        break\n      case 2:\n        state.dim = true\n        break\n      case 3:\n        state.italic = true\n        break\n      case 4:\n        state.underline = true\n        break\n      case 9:\n        state.strikethrough = true\n        break\n      case 22:\n        state.bold = false\n        state.dim = false\n        break\n      case 23:\n        state.italic = false\n        break\n      case 24:\n        state.underline = false\n        break\n      case 29:\n        state.strikethrough = false\n        break\n      case 39:\n        state.fg = undefined\n        break\n      case 49:\n        state.bg = undefined\n        break\n      default:\n        if (code >= 30 && code <= 37) {\n          state.fg = STANDARD_COLORS[code - 30]\n        } else if (code >= 40 && code <= 47) {\n          state.bg = STANDARD_COLORS[code - 40]\n        } else if (code >= 90 && code <= 97) {\n          state.fg = BRIGHT_COLORS[code - 90]\n        } else if (code >= 100 && code <= 107) {\n          state.bg = BRIGHT_COLORS[code - 100]\n        } else if (code === 38 || code === 48) {\n          const kind = params[i + 1]\n          if (kind === 5) {\n            const colorIdx = params[i + 2]\n            if (colorIdx !== undefined) {\n              const c = color256(colorIdx)\n              if (code === 38) state.fg = c\n              else state.bg = c\n            }\n            i += 2\n          } else if (kind === 2) {\n            const r = params[i + 2] ?? 0\n            const g = params[i + 3] ?? 0\n            const b = params[i + 4] ?? 0\n            const toHex = (v: number) => v.toString(16).padStart(2, \"0\")\n            const c = `#${toHex(r)}${toHex(g)}${toHex(b)}`\n            if (code === 38) state.fg = c\n            else state.bg = c\n            i += 4\n          }\n        }\n        break\n    }\n    i++\n  }\n}\n\n/** Convert a string containing ANSI escape sequences into HTML with inline styles */\nexport function ansiToHtml(input: string): string {\n  // oxlint-disable-next-line no-control-regex -- ANSI escape sequences start with U+001B\n  const sgr = /\\u001b\\[([0-9;]*)m/g\n  const state = makeDefaultState()\n  const parts: string[] = []\n  let lastIndex = 0\n\n  let match = sgr.exec(input)\n  while (match !== null) {\n    const textBefore = input.slice(lastIndex, match.index)\n    if (textBefore) {\n      const style = buildStyle(state)\n      if (style) {\n        parts.push(`<span style=\"${style}\">${escapeHtml(textBefore)}</span>`)\n      } else {\n        parts.push(escapeHtml(textBefore))\n      }\n    }\n\n    const rawParams = match[1]!\n    const params =\n      rawParams === \"\"\n        ? [0]\n        : rawParams.split(\";\").map(s => Number.parseInt(s, 10))\n    applyParams(state, params)\n    lastIndex = match.index + match[0].length\n    match = sgr.exec(input)\n  }\n\n  const trailing = input.slice(lastIndex)\n  if (trailing) {\n    const style = buildStyle(state)\n    if (style) {\n      parts.push(`<span style=\"${style}\">${escapeHtml(trailing)}</span>`)\n    } else {\n      parts.push(escapeHtml(trailing))\n    }\n  }\n\n  return parts.join(\"\")\n}\n\n/** Walk a mdast tree and convert ansi code blocks into AnsiCode JSX elements */\nexport function transformAnsiCodeBlocks(tree: Root) {\n  const children = tree.children\n  for (let i = 0; i < children.length; i++) {\n    const node = children[i]\n    if (node?.type !== \"code\" || node.lang !== \"ansi\") continue\n\n    const html = ansiToHtml(node.value)\n\n    const jsxNode = {\n      type: \"mdxJsxFlowElement\" as const,\n      name: \"AnsiCode\",\n      attributes: [\n        {\n          type: \"mdxJsxAttribute\" as const,\n          name: \"html\",\n          value: html,\n        },\n      ],\n      children: [],\n    }\n\n    // @ts-expect-error mdxJsxFlowElement is not in mdast types\n    children[i] = jsxNode\n  }\n}\n\n/** Remark plugin that converts ansi code blocks into colored HTML output */\nexport const remarkAnsi: Plugin<[], Root> = () => {\n  return tree => {\n    transformAnsiCodeBlocks(tree)\n  }\n}\n"]}

package/target/plugins/remark-ansi.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/target/plugins/remark-ansi.unit.js

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vite-plus/test";
+import { ansiToHtml, transformAnsiCodeBlocks } from "./remark-ansi.js";
+function makeTree(...children) {
+    return { type: "root", children };
+}
+describe("ansiToHtml", () => {
+    it("should return plain text unchanged", () => {
+        expect(ansiToHtml("hello world")).toBe("hello world");
+    });
+    it("should escape HTML characters", () => {
+        expect(ansiToHtml("<div>&</div>")).toBe("&lt;div&gt;&amp;&lt;/div&gt;");
+    });
+    it("should render standard foreground colors", () => {
+        const input = "\x1b[31mred text\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#bf616a">red text</span>');
+    });
+    it("should render bold text", () => {
+        const input = "\x1b[1mbold\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="font-weight:bold">bold</span>');
+    });
+    it("should render italic text", () => {
+        const input = "\x1b[3mitalic\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="font-style:italic">italic</span>');
+    });
+    it("should render underline text", () => {
+        const input = "\x1b[4munderline\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="text-decoration:underline">underline</span>');
+    });
+    it("should render dim text", () => {
+        const input = "\x1b[2mdim\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="opacity:0.7">dim</span>');
+    });
+    it("should render strikethrough text", () => {
+        const input = "\x1b[9mstruck\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="text-decoration:line-through">struck</span>');
+    });
+    it("should render background colors", () => {
+        const input = "\x1b[42mgreen bg\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="background-color:#a3be8c">green bg</span>');
+    });
+    it("should combine foreground and background", () => {
+        const input = "\x1b[31;42mred on green\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#bf616a;background-color:#a3be8c">red on green</span>');
+    });
+    it("should handle bright foreground colors", () => {
+        const input = "\x1b[91mbright red\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#bf616a">bright red</span>');
+    });
+    it("should handle bright background colors", () => {
+        const input = "\x1b[102mbright green bg\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="background-color:#a3be8c">bright green bg</span>');
+    });
+    it("should handle 256-color foreground", () => {
+        const input = "\x1b[38;5;196mcolor\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#ff0000">color</span>');
+    });
+    it("should handle 256-color background", () => {
+        const input = "\x1b[48;5;21mbg\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="background-color:#0000ff">bg</span>');
+    });
+    it("should handle 24-bit RGB foreground", () => {
+        const input = "\x1b[38;2;255;128;0mrgb\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#ff8000">rgb</span>');
+    });
+    it("should handle 24-bit RGB background", () => {
+        const input = "\x1b[48;2;0;128;255mbg\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="background-color:#0080ff">bg</span>');
+    });
+    it("should handle reset via empty escape", () => {
+        const input = "\x1b[31mred\x1b[mnormal";
+        expect(ansiToHtml(input)).toBe('<span style="color:#bf616a">red</span>normal');
+    });
+    it("should handle multiple segments", () => {
+        const input = "start \x1b[32mgreen\x1b[0m middle \x1b[34mblue\x1b[0m end";
+        expect(ansiToHtml(input)).toBe('start <span style="color:#a3be8c">green</span> middle <span style="color:#8fa1b3">blue</span> end');
+    });
+    it("should handle combined bold and color", () => {
+        const input = "\x1b[1;33mbold yellow\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#ebcb8b;font-weight:bold">bold yellow</span>');
+    });
+    it("should handle 256-color grayscale", () => {
+        const input = "\x1b[38;5;232mblack\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="color:#080808">black</span>');
+    });
+    it("should reset individual attributes", () => {
+        const input = "\x1b[1;3mbold italic\x1b[23mnot italic\x1b[0m";
+        expect(ansiToHtml(input)).toBe('<span style="font-weight:bold;font-style:italic">bold italic</span><span style="font-weight:bold">not italic</span>');
+    });
+});
+describe("transformAnsiCodeBlocks", () => {
+    function process(tree) {
+        transformAnsiCodeBlocks(tree);
+        return tree;
+    }
+    it("should convert ansi code block to AnsiCode JSX element", () => {
+        const tree = process(makeTree({ type: "code", lang: "ansi", value: "\x1b[31mhello\x1b[0m" }));
+        const node = tree.children[0];
+        expect(node).toMatchObject({
+            type: "mdxJsxFlowElement",
+            name: "AnsiCode",
+            attributes: [
+                {
+                    type: "mdxJsxAttribute",
+                    name: "html",
+                    value: '<span style="color:#bf616a">hello</span>',
+                },
+            ],
+        });
+    });
+    it("should ignore non-ansi code blocks", () => {
+        const tree = process(makeTree({ type: "code", lang: "javascript", value: "const x = 1" }));
+        const node = tree.children[0];
+        expect(node).toMatchObject({
+            type: "code",
+            lang: "javascript",
+        });
+    });
+    it("should handle plain text in ansi code block", () => {
+        const tree = process(makeTree({ type: "code", lang: "ansi", value: "no escapes here" }));
+        const node = tree.children[0];
+        expect(node).toMatchObject({
+            type: "mdxJsxFlowElement",
+            name: "AnsiCode",
+            attributes: [
+                {
+                    type: "mdxJsxAttribute",
+                    name: "html",
+                    value: "no escapes here",
+                },
+            ],
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remark-ansi.unit.js","sourceRoot":"","sources":["../../source/plugins/remark-ansi.unit.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Root } from \"mdast\"\nimport { describe, expect, it } from \"vite-plus/test\"\nimport { ansiToHtml, transformAnsiCodeBlocks } from \"./remark-ansi.ts\"\n\nfunction makeTree(...children: Root[\"children\"]): Root {\n  return { type: \"root\", children }\n}\n\ndescribe(\"ansiToHtml\", () => {\n  it(\"should return plain text unchanged\", () => {\n    expect(ansiToHtml(\"hello world\")).toBe(\"hello world\")\n  })\n\n  it(\"should escape HTML characters\", () => {\n    expect(ansiToHtml(\"<div>&</div>\")).toBe(\"&lt;div&gt;&amp;&lt;/div&gt;\")\n  })\n\n  it(\"should render standard foreground colors\", () => {\n    const input = \"\\x1b[31mred text\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"color:#bf616a\">red text</span>',\n    )\n  })\n\n  it(\"should render bold text\", () => {\n    const input = \"\\x1b[1mbold\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe('<span style=\"font-weight:bold\">bold</span>')\n  })\n\n  it(\"should render italic text\", () => {\n    const input = \"\\x1b[3mitalic\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"font-style:italic\">italic</span>',\n    )\n  })\n\n  it(\"should render underline text\", () => {\n    const input = \"\\x1b[4munderline\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"text-decoration:underline\">underline</span>',\n    )\n  })\n\n  it(\"should render dim text\", () => {\n    const input = \"\\x1b[2mdim\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe('<span style=\"opacity:0.7\">dim</span>')\n  })\n\n  it(\"should render strikethrough text\", () => {\n    const input = \"\\x1b[9mstruck\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"text-decoration:line-through\">struck</span>',\n    )\n  })\n\n  it(\"should render background colors\", () => {\n    const input = \"\\x1b[42mgreen bg\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"background-color:#a3be8c\">green bg</span>',\n    )\n  })\n\n  it(\"should combine foreground and background\", () => {\n    const input = \"\\x1b[31;42mred on green\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"color:#bf616a;background-color:#a3be8c\">red on green</span>',\n    )\n  })\n\n  it(\"should handle bright foreground colors\", () => {\n    const input = \"\\x1b[91mbright red\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"color:#bf616a\">bright red</span>',\n    )\n  })\n\n  it(\"should handle bright background colors\", () => {\n    const input = \"\\x1b[102mbright green bg\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"background-color:#a3be8c\">bright green bg</span>',\n    )\n  })\n\n  it(\"should handle 256-color foreground\", () => {\n    const input = \"\\x1b[38;5;196mcolor\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe('<span style=\"color:#ff0000\">color</span>')\n  })\n\n  it(\"should handle 256-color background\", () => {\n    const input = \"\\x1b[48;5;21mbg\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"background-color:#0000ff\">bg</span>',\n    )\n  })\n\n  it(\"should handle 24-bit RGB foreground\", () => {\n    const input = \"\\x1b[38;2;255;128;0mrgb\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe('<span style=\"color:#ff8000\">rgb</span>')\n  })\n\n  it(\"should handle 24-bit RGB background\", () => {\n    const input = \"\\x1b[48;2;0;128;255mbg\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"background-color:#0080ff\">bg</span>',\n    )\n  })\n\n  it(\"should handle reset via empty escape\", () => {\n    const input = \"\\x1b[31mred\\x1b[mnormal\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"color:#bf616a\">red</span>normal',\n    )\n  })\n\n  it(\"should handle multiple segments\", () => {\n    const input = \"start \\x1b[32mgreen\\x1b[0m middle \\x1b[34mblue\\x1b[0m end\"\n    expect(ansiToHtml(input)).toBe(\n      'start <span style=\"color:#a3be8c\">green</span> middle <span style=\"color:#8fa1b3\">blue</span> end',\n    )\n  })\n\n  it(\"should handle combined bold and color\", () => {\n    const input = \"\\x1b[1;33mbold yellow\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"color:#ebcb8b;font-weight:bold\">bold yellow</span>',\n    )\n  })\n\n  it(\"should handle 256-color grayscale\", () => {\n    const input = \"\\x1b[38;5;232mblack\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe('<span style=\"color:#080808\">black</span>')\n  })\n\n  it(\"should reset individual attributes\", () => {\n    const input = \"\\x1b[1;3mbold italic\\x1b[23mnot italic\\x1b[0m\"\n    expect(ansiToHtml(input)).toBe(\n      '<span style=\"font-weight:bold;font-style:italic\">bold italic</span><span style=\"font-weight:bold\">not italic</span>',\n    )\n  })\n})\n\ndescribe(\"transformAnsiCodeBlocks\", () => {\n  function process(tree: Root) {\n    transformAnsiCodeBlocks(tree)\n    return tree\n  }\n\n  it(\"should convert ansi code block to AnsiCode JSX element\", () => {\n    const tree = process(\n      makeTree({ type: \"code\", lang: \"ansi\", value: \"\\x1b[31mhello\\x1b[0m\" }),\n    )\n\n    const node = tree.children[0]\n    expect(node).toMatchObject({\n      type: \"mdxJsxFlowElement\",\n      name: \"AnsiCode\",\n      attributes: [\n        {\n          type: \"mdxJsxAttribute\",\n          name: \"html\",\n          value: '<span style=\"color:#bf616a\">hello</span>',\n        },\n      ],\n    })\n  })\n\n  it(\"should ignore non-ansi code blocks\", () => {\n    const tree = process(\n      makeTree({ type: \"code\", lang: \"javascript\", value: \"const x = 1\" }),\n    )\n\n    const node = tree.children[0]\n    expect(node).toMatchObject({\n      type: \"code\",\n      lang: \"javascript\",\n    })\n  })\n\n  it(\"should handle plain text in ansi code block\", () => {\n    const tree = process(\n      makeTree({ type: \"code\", lang: \"ansi\", value: \"no escapes here\" }),\n    )\n\n    const node = tree.children[0]\n    expect(node).toMatchObject({\n      type: \"mdxJsxFlowElement\",\n      name: \"AnsiCode\",\n      attributes: [\n        {\n          type: \"mdxJsxAttribute\",\n          name: \"html\",\n          value: \"no escapes here\",\n        },\n      ],\n    })\n  })\n})\n"]}

package/target/plugins/remark-badge.d.ts

@@ -0,0 +1,6 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+/** Walk a mdast tree and convert :badge text directives into InlineBadge JSX elements */
+export declare function transformBadgeDirectives(tree: Root): void;
+/** Remark plugin that converts :badge text directives into InlineBadge JSX elements */
+export declare const remarkBadge: Plugin<[], Root>;

package/target/plugins/remark-badge.js

@@ -0,0 +1,43 @@
+import { visit } from "unist-util-visit";
+/** Walk a mdast tree and convert :badge text directives into InlineBadge JSX elements */
+export function transformBadgeDirectives(tree) {
+    visit(tree, "textDirective", (node, index, parent) => {
+        if (node.name !== "badge" || index === undefined || !parent)
+            return;
+        const label = node.children
+            .map(c => ("value" in c ? String(c.value) : ""))
+            .join("");
+        const variant = node.attributes?.variant;
+        const jsxNode = {
+            type: "mdxJsxTextElement",
+            name: "InlineBadge",
+            attributes: [
+                {
+                    type: "mdxJsxAttribute",
+                    name: "label",
+                    value: label,
+                },
+                ...(variant
+                    ? [
+                        {
+                            type: "mdxJsxAttribute",
+                            name: "variant",
+                            value: variant,
+                        },
+                    ]
+                    : []),
+            ],
+            children: [],
+            data: { _mdxExplicitJsx: true },
+        };
+        // @ts-expect-error mdxJsxTextElement is not in mdast types
+        parent.children.splice(index, 1, jsxNode);
+    });
+}
+/** Remark plugin that converts :badge text directives into InlineBadge JSX elements */
+export const remarkBadge = () => {
+    return tree => {
+        transformBadgeDirectives(tree);
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/target/plugins/remark-badge.unit.d.ts

@@ -0,0 +1 @@
+export {};