115 lines
5.2 KiB
TypeScript
115 lines
5.2 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import { unescapeBlockquoteMarkers } from "./blockquote-markdown";
|
|
|
|
describe("unescapeBlockquoteMarkers", () => {
|
|
it("leaves markdown without escaped markers untouched", () => {
|
|
expect(unescapeBlockquoteMarkers("> quoted")).toBe("> quoted");
|
|
expect(unescapeBlockquoteMarkers("plain text")).toBe("plain text");
|
|
expect(unescapeBlockquoteMarkers("")).toBe("");
|
|
});
|
|
|
|
it("unescapes a single escaped blockquote line", () => {
|
|
expect(unescapeBlockquoteMarkers("\\> see")).toBe("> see");
|
|
});
|
|
|
|
it("unescapes multiple escaped blockquote lines", () => {
|
|
expect(unescapeBlockquoteMarkers("\\> line one\n\\> line two")).toBe("> line one\n> line two");
|
|
});
|
|
|
|
it("unescapes escaped blockquotes interleaved with normal text", () => {
|
|
expect(unescapeBlockquoteMarkers("hello\n\n\\> quoted\n\nbye")).toBe("hello\n\n> quoted\n\nbye");
|
|
});
|
|
|
|
it("preserves up to 3 spaces of block indent before the marker", () => {
|
|
expect(unescapeBlockquoteMarkers(" \\> indented")).toBe(" > indented");
|
|
expect(unescapeBlockquoteMarkers(" \\> three")).toBe(" > three");
|
|
});
|
|
|
|
it("does not touch an escaped marker in an indented code block (4+ spaces)", () => {
|
|
expect(unescapeBlockquoteMarkers(" \\> literal")).toBe(" \\> literal");
|
|
expect(unescapeBlockquoteMarkers("\tcode \\> x")).toBe("\tcode \\> x");
|
|
});
|
|
|
|
it("does not touch an escaped marker carrying a blockquote container prefix", () => {
|
|
// A code fence nested inside a blockquote has a `> ` prefix on each line, so
|
|
// its `\>` content must stay escaped.
|
|
expect(unescapeBlockquoteMarkers("> \\> nested")).toBe("> \\> nested");
|
|
});
|
|
|
|
it("does not touch an escaped marker inside a list item", () => {
|
|
expect(unescapeBlockquoteMarkers("- \\> item")).toBe("- \\> item");
|
|
});
|
|
|
|
it("does not touch escaped markers inside fenced code blocks", () => {
|
|
const input = "```\n\\> not a quote\n```\n\\> real quote";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("```\n\\> not a quote\n```\n> real quote");
|
|
});
|
|
|
|
it("does not touch escaped markers inside a list-nested fenced code block", () => {
|
|
const input = "- ```\n \\> literal\n ```\n\\> real quote";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("- ```\n \\> literal\n ```\n> real quote");
|
|
});
|
|
|
|
it("does not close a list-nested fence on a list-marker content line", () => {
|
|
const input = "- ```\n - ```\n \\> literal\n ```\n\\> real quote";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("- ```\n - ```\n \\> literal\n ```\n> real quote");
|
|
});
|
|
|
|
it("tracks the continuation indent of an ordered-list fence", () => {
|
|
const input = "10. ```\n \\> literal\n ```\n\\> real quote";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("10. ```\n \\> literal\n ```\n> real quote");
|
|
});
|
|
|
|
it("tracks fenced code blocks through blockquote container prefixes", () => {
|
|
const input = "> ```\n> \\> literal\n> ```\n\\> real quote";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("> ```\n> \\> literal\n> ```\n> real quote");
|
|
});
|
|
|
|
it("handles tilde fences", () => {
|
|
const input = "~~~\n\\> literal\n~~~";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("~~~\n\\> literal\n~~~");
|
|
});
|
|
|
|
it("only rewrites the leading marker, not later text", () => {
|
|
expect(unescapeBlockquoteMarkers("\\> a \\> b")).toBe("> a \\> b");
|
|
});
|
|
|
|
it("leaves a mid-line escaped marker alone", () => {
|
|
expect(unescapeBlockquoteMarkers("text \\> not a quote")).toBe("text \\> not a quote");
|
|
});
|
|
|
|
it("does not close a fence on a shorter same-char run (nested fence content stays code)", () => {
|
|
// A 3-backtick line inside a 4-backtick fence is code content, not a close,
|
|
// so the escaped marker after it must remain escaped.
|
|
const input = "````\n\\> a\n```\n\\> b\n````\n\\> real";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("````\n\\> a\n```\n\\> b\n````\n> real");
|
|
});
|
|
|
|
it("does not treat a fence-like line with trailing content as a closing fence", () => {
|
|
const input = "```\n\\> code\n``` not a close\n\\> still code\n```\n\\> real";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("```\n\\> code\n``` not a close\n\\> still code\n```\n> real");
|
|
});
|
|
|
|
it("does not close a backtick fence with a tilde fence", () => {
|
|
const input = "```\n\\> code\n~~~\n\\> still code\n```\n\\> real";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("```\n\\> code\n~~~\n\\> still code\n```\n> real");
|
|
});
|
|
|
|
it("closes on a longer run than the opening fence", () => {
|
|
const input = "```\n\\> code\n`````\n\\> real";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("```\n\\> code\n`````\n> real");
|
|
});
|
|
|
|
it("treats a backtick fence with a backtick in the info string as non-opening", () => {
|
|
// `` ```` `` with `x` after is not a valid opening fence, so following
|
|
// escaped markers are ordinary paragraph text and get recovered.
|
|
const input = "``` `x`\n\\> real";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("``` `x`\n> real");
|
|
});
|
|
|
|
it("keeps an info string on the opening fence and still protects contents", () => {
|
|
const input = "```ts\n\\> code\n```\n\\> real";
|
|
expect(unescapeBlockquoteMarkers(input)).toBe("```ts\n\\> code\n```\n> real");
|
|
});
|
|
});
|