const spans = parseFenceSpans(normalized);

const parts: string[] = [];

const separators: string[] = [];

const re = /\n[\t ]*\n+/g; // paragraph break: blank line(s), allowing whitespace

let lastIndex = 0;

for (const match of normalized.matchAll(re)) {

}

parts.push(normalized.slice(lastIndex, idx));

separators.push(match[0]);

lastIndex = idx + match[0].length;

}

parts.push(normalized.slice(lastIndex));

const chunks: string[] = [];

for (const part of parts) {

let currentChunk = "";

const pushParagraph = (paragraph: string, separatorBefore?: string) => {

if (!currentChunk) {

if (paragraph.length <= limit) {

currentChunk = paragraph;

return;

}

if (!splitLongParagraphs) {

chunks.push(paragraph);

return;

}

chunks.push(...chunkText(paragraph, limit));

return;

}

const candidate = `${currentChunk}${separatorBefore ?? "\n\n"}${paragraph}`;

if (candidate.length <= limit) {

currentChunk = candidate;

return;

}

chunks.push(currentChunk);

currentChunk = "";

pushParagraph(paragraph);

};

for (const [index, part] of parts.entries()) {

const paragraph = part.replace(/\s+$/g, "");

if (!paragraph.trim()) {

continue;

}

if (paragraph.length <= limit) {

chunks.push(paragraph);

} else if (!splitLongParagraphs) {

chunks.push(paragraph);

} else {

chunks.push(...chunkText(paragraph, limit));

}

pushParagraph(paragraph, separators[index - 1]);

}

if (currentChunk) {

chunks.push(currentChunk);

}

return chunks;

// If a paragraph must be split by length, defer to the markdown-aware chunker.

const paragraphChunks = chunkByParagraph(text, limit, { splitLongParagraphs: false });

const out: string[] = [];

for (const chunk of paragraphChunks) {

const nested = chunkMarkdownText(chunk, limit);

if (!nested.length && chunk) {

out.push(chunk);

} else {

out.push(...nested);

}

for (const chunk of paragraphChunks.flatMap((paragraphChunk) =>

paragraphChunk.length > limit

? splitPackedFenceParagraphChunk(paragraphChunk)

: paragraphChunk,

)) {

out.push(...chunkMarkdownText(chunk, limit));

}

return out;

}

return lines;

}

function splitPackedFenceParagraphChunk(chunk: string): string[] {

const chunks: string[] = [];

let start = 0;

for (const span of parseFenceSpans(chunk)) {

if (span.end <= start) {

continue;

}

const separator = chunk.slice(span.end).match(/^\n[\t ]*\n+/)?.[0];

if (!separator) {

continue;

}

const tail = chunk.slice(span.end + separator.length);

if (!tail.trim()) {

continue;

}

chunks.push(chunk.slice(start, span.end));

start = span.end + separator.length;

}

if (chunks.length === 0) {

return [chunk];

}

const tail = chunk.slice(start);

if (tail) {

chunks.push(tail);

}

return chunks;

}

function resolveChunkEarlyReturn(text: string, limit: number): string[] | undefined {

if (!text) {

return [];