@agentshouse/mdruntime 0.1.0-cb95ca2c884cf → 0.1.0-cb9c79aee537a

package/dist/chat/pieces.js

@@ -0,0 +1,797 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
+import { gfm } from 'micromark-extension-gfm';
+export function parseMarkdown(text) {
+    return fromMarkdown(text, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
+}
+const VIEW_CHARS = 16_384;
+const WINDOW_CHARS = 2 * VIEW_CHARS;
+const WINDOW_LINES = 2_048;
+const SPAN_CHARS = WINDOW_CHARS;
+const TRACKS = 32;
+const FENCE = /^(`{3,}|~{3,})(.*)$/;
+const CLOSING = /^(`{3,}|~{3,})[ \t]*$/;
+const RAW = [
+    [/^<(?:script|pre|style|textarea)(?:[ \t>]|$)/i, /<\/(?:script|pre|style|textarea)>/i],
+    [/^<!--/, /-->/],
+    [/^<\?/, /\?>/],
+    [/^<![A-Za-z]/, />/],
+    [/^<!\[CDATA\[/, /\]\]>/],
+];
+const TAG = /^<[A-Za-z/]/;
+const ATX = /^#{1,6}(?:[ \t]|$)/;
+const THEMATIC = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const UNDERLINE = /^(?:=+|-+)[ \t]*$/;
+const ITEM = /^(?:[-+*]|(\d{1,9})[.)])(?=[ \t]|$)/;
+const UNRESOLVED = /^\[(?:[^\\[\]]|\\.)+\]:[ \t]*$/;
+const DELIMITER_ROW = /^\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+const CANDIDATE = /^[ \t>]*(?:(?:[-+*]|\d{1,9}[.)])[ \t]+[ \t>]*)*\[/;
+const DEFINED = /\[((?:[^\\[\]]|\\[\s\S]){1,999})\]:/y;
+const LABEL = /\[((?:[^\\[\]]|\\[\s\S]){1,999})\]/g;
+const QUOTE_BREAK = /^[ \t>]*$/;
+const BLOCK_START = /[\s#>+*=_`~<|-]/;
+const ORDERED = /\d{1,9}[.)](?=[ \t\r\n]|$)/y;
+const SPACE = /\s/u;
+const PUNCTUATION = /[\p{P}\p{S}]/u;
+const ESCAPABLE = /[!-/:-@[-`{-~]/;
+const TAG_START = /[A-Za-z!?/]/;
+const LINE_ENDING = /\r\n?|\n/g;
+const START = {
+    fence: null,
+    list: null,
+    empty: false,
+    para: false,
+    table: false,
+    quote: false,
+    unresolved: false,
+};
+export function identifierOf(label) {
+    return label
+        .replace(/(?:\r\n?|\n)[ \t>]*/g, '\n')
+        .replace(/[\t\n\r ]+/g, ' ')
+        .replace(/^ | $/g, '')
+        .toLowerCase()
+        .toUpperCase()
+        .toLowerCase();
+}
+function lineOf(long, at) {
+    let low = 0;
+    let high = long.starts.length - 2;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (long.starts[middle] <= at)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+}
+function lineEnd(starts, text, index) {
+    return Math.min(starts[index + 1] - 1, text.length);
+}
+function lineText(starts, text, index) {
+    const end = lineEnd(starts, text, index);
+    return text.slice(starts[index], text[end - 1] === '\r' ? end - 1 : end);
+}
+function lineStartOf(long, at) {
+    return long.starts[lineOf(long, at)];
+}
+function lineFacts(raw) {
+    let indent = 0;
+    let index = 0;
+    while (index < raw.length && (raw[index] === ' ' || raw[index] === '\t')) {
+        indent += raw[index] === '\t' ? 4 - (indent % 4) : 1;
+        index += 1;
+    }
+    const content = raw.slice(index);
+    return { raw, indent, content, blank: content === '' };
+}
+function itemOf(line) {
+    if (line.indent > 3 || THEMATIC.test(line.content))
+        return null;
+    const marker = ITEM.exec(line.content);
+    if (marker === null)
+        return null;
+    const width = marker[0].length;
+    let columns = line.indent + width;
+    let index = width;
+    while (index < line.content.length && /[ \t]/.test(line.content[index])) {
+        columns += line.content[index] === '\t' ? 4 - (columns % 4) : 1;
+        index += 1;
+    }
+    const empty = index === line.content.length;
+    const spacing = columns - line.indent - width;
+    return {
+        indent: empty || spacing >= 5 ? line.indent + width + 1 : columns,
+        empty,
+        interrupts: !empty && (marker[1] === undefined || Number(marker[1]) === 1),
+    };
+}
+function fenceOf(line) {
+    if (line.indent > 3)
+        return null;
+    const fence = FENCE.exec(line.content);
+    if (fence === null || (fence[1][0] === '`' && fence[2].includes('`')))
+        return null;
+    return `${fence[1][0]}${fence[1].length}`;
+}
+function opens(line) {
+    if (line.indent > 3)
+        return false;
+    return (fenceOf(line) !== null ||
+        RAW.some(([start]) => start.test(line.content)) ||
+        line.content.startsWith('>') ||
+        ATX.test(line.content) ||
+        THEMATIC.test(line.content) ||
+        itemOf(line) !== null);
+}
+function fenced(track, line) {
+    const fence = track.fence;
+    if (fence === 'html')
+        return line.blank ? { ...track, fence: null } : track;
+    if (fence.startsWith('raw')) {
+        return RAW[Number(fence.slice(3))][1].test(line.raw) ? { ...track, fence: null } : track;
+    }
+    const close = line.indent <= 3 ? CLOSING.exec(line.content) : null;
+    const closes = close !== null && close[1][0] === fence[0] && close[1].length >= Number(fence.slice(1));
+    return closes ? { ...track, fence: null } : track;
+}
+function prose(track, plain, line) {
+    if (track.table)
+        return [{ ...plain, para: false }];
+    const paragraph = { ...plain, para: true, unresolved: UNRESOLVED.test(line.content) };
+    return track.quote ? [{ ...plain, para: false, quote: true }, paragraph] : [paragraph];
+}
+function topLevel(track, line) {
+    const plain = { ...track, list: null, empty: false, quote: false, unresolved: false };
+    if (line.indent >= 4)
+        return [{ ...plain, para: track.para }];
+    const fence = fenceOf(line);
+    if (fence !== null) {
+        const opened = { ...plain, fence, para: false, table: false };
+        return track.table || track.unresolved ? [opened, { ...plain, para: false }] : [opened];
+    }
+    const raw = RAW.findIndex(([start]) => start.test(line.content));
+    if (raw !== -1) {
+        const [start, end] = RAW[raw];
+        const closed = end.test(line.content.replace(start, ''));
+        const opened = { ...plain, fence: closed ? null : `raw${raw}`, para: false, table: false };
+        return track.table ? [opened, { ...plain, para: false }] : [opened];
+    }
+    if (TAG.test(line.content)) {
+        return [{ ...plain, fence: 'html', para: false, table: false }, ...prose(track, plain, line)];
+    }
+    if (line.content.startsWith('>'))
+        return [{ ...plain, para: false, table: false, quote: true }];
+    if (ATX.test(line.content) || THEMATIC.test(line.content)) {
+        return [{ ...plain, para: false, table: false }];
+    }
+    const item = itemOf(line);
+    if (item !== null) {
+        const opened = { ...plain, list: item.indent, empty: item.empty, para: false, table: false };
+        if (!item.interrupts && track.para)
+            return [{ ...plain, para: true }];
+        return track.table || (!item.interrupts && track.quote)
+            ? [opened, ...prose(track, plain, line)]
+            : [opened];
+    }
+    if (track.para && UNDERLINE.test(line.content))
+        return [{ ...plain, para: false, table: false }];
+    if (track.para && DELIMITER_ROW.test(line.content)) {
+        return [
+            { ...plain, para: false, table: true },
+            { ...plain, para: true },
+        ];
+    }
+    return prose(track, plain, line);
+}
+function advance(track, line, blankBefore) {
+    if (track.fence !== null)
+        return [fenced(track, line)];
+    if (line.blank) {
+        const blank = { ...track, para: false, table: false, quote: false, unresolved: false };
+        return track.empty
+            ? [
+                { ...blank, empty: false },
+                { ...blank, list: null, empty: false },
+            ]
+            : [blank];
+    }
+    if (track.list === null)
+        return topLevel(track, line);
+    if (line.indent >= track.list) {
+        return [{ ...track, empty: false, para: false, table: false, quote: false, unresolved: false }];
+    }
+    const closed = topLevel({ ...track, list: null, empty: false, para: false, table: false, quote: false }, line);
+    if (blankBefore || opens(line))
+        return closed;
+    return [{ ...track, empty: false, para: false, quote: false, unresolved: false }, ...closed];
+}
+function trackKey(track) {
+    return `${track.fence}|${track.list}|${track.empty}|${track.para}|${track.table}|${track.quote}|${track.unresolved}`;
+}
+function candidatesOf(text, start, raw, found) {
+    const lead = CANDIDATE.exec(raw);
+    if (lead === null)
+        return;
+    let at = start + lead[0].length - 1;
+    for (;;) {
+        DEFINED.lastIndex = at;
+        const label = DEFINED.exec(text);
+        if (label === null)
+            return;
+        const key = identifierOf(label[1]);
+        const held = found.get(key);
+        if (held === undefined)
+            found.set(key, [at]);
+        else
+            held.push(at);
+        if (!label[1].startsWith('^'))
+            return;
+        at = DEFINED.lastIndex;
+        while (text[at] === ' ' || text[at] === '\t')
+            at += 1;
+        if (text[at] !== '[')
+            return;
+    }
+}
+function breaksOf(flags) {
+    const breaks = new Int32Array(flags.length + 1);
+    breaks[flags.length] = flags.length;
+    for (let index = flags.length - 1; index >= 0; index -= 1) {
+        breaks[index] = flags[index] === 1 ? index : breaks[index + 1];
+    }
+    return breaks;
+}
+export function longOf(text) {
+    const offsets = [];
+    let at = 0;
+    while (at < text.length) {
+        offsets.push(at);
+        LINE_ENDING.lastIndex = at;
+        at = LINE_ENDING.test(text) ? LINE_ENDING.lastIndex : text.length + 1;
+    }
+    offsets.push(at);
+    const starts = Int32Array.from(offsets);
+    const count = starts.length - 1;
+    const blank = new Uint8Array(count);
+    const quoteBlank = new Uint8Array(count);
+    const anchors = [0];
+    const candidates = new Map();
+    let tracks = [START];
+    let lost = false;
+    for (let index = 0; index < count; index += 1) {
+        const line = lineFacts(lineText(starts, text, index));
+        const before = index === 0 || blank[index - 1] === 1;
+        blank[index] = line.blank ? 1 : 0;
+        quoteBlank[index] = QUOTE_BREAK.test(line.raw) ? 1 : 0;
+        if (index > 0 && !lost && !line.blank && before && line.indent <= 1) {
+            if (tracks.every((track) => track.fence === null))
+                anchors.push(starts[index]);
+        }
+        candidatesOf(text, starts[index], line.raw, candidates);
+        if (lost)
+            continue;
+        const advanced = new Map();
+        for (const track of tracks) {
+            for (const one of advance(track, line, before))
+                advanced.set(trackKey(one), one);
+        }
+        tracks = [...advanced.values()];
+        lost = tracks.length > TRACKS;
+    }
+    return {
+        text,
+        starts,
+        breaks: breaksOf(blank),
+        quoteBreaks: breaksOf(quoteBlank),
+        anchors,
+        candidates,
+        pieces: [],
+        next: { start: 0, path: [], join: '', carry: '' },
+        urls: new Map(),
+        spans: new Map(),
+        discoveries: new Map(),
+        regions: new Map(),
+    };
+}
+function offsetOf(node) {
+    return node.position.start.offset;
+}
+function endOf(node) {
+    return node.position.end.offset;
+}
+function definedIn(nodes, shift, found = []) {
+    for (const node of nodes) {
+        if (node.type === 'definition') {
+            found.push({ key: node.identifier, at: offsetOf(node) + shift, url: node.url });
+        }
+        else if (node.type === 'footnoteDefinition') {
+            found.push({ key: `^${node.identifier}`, at: offsetOf(node) + shift, url: '' });
+        }
+        if (node.type === 'blockquote' ||
+            node.type === 'list' ||
+            node.type === 'listItem' ||
+            node.type === 'footnoteDefinition') {
+            definedIn(node.children, shift, found);
+        }
+    }
+    return found;
+}
+function windowOf(long, from, end, prefix) {
+    const root = parseMarkdown(`${prefix}${from.carry}${long.text.slice(from.start, end)}`);
+    const lead = prefix.length + from.carry.length;
+    const nodes = root.children.filter((node) => offsetOf(node) >= prefix.length);
+    return {
+        start: from.start,
+        end,
+        lead,
+        prefix,
+        carry: from.carry,
+        nodes,
+        defined: definedIn(nodes, from.start - lead),
+    };
+}
+function spanned(long, anchor, stop) {
+    const key = `${anchor}:${stop}`;
+    const held = long.spans.get(key);
+    if (held !== undefined)
+        return held;
+    const found = definedIn(parseMarkdown(long.text.slice(anchor, stop)).children, anchor);
+    long.spans.set(key, found);
+    return found;
+}
+function discovered(long, anchor, stop) {
+    let discovery = long.discoveries.get(anchor);
+    if (discovery === undefined) {
+        discovery = { found: [], next: { start: anchor, path: [], join: '', carry: '' } };
+        long.discoveries.set(anchor, discovery);
+    }
+    while (discovery.next !== null && discovery.next.start < stop) {
+        const from = discovery.next;
+        const { window, cut } = cutWindow(long, from, 'discover', (end) => windowOf(long, from, end, ''));
+        const end = cut?.at ?? long.text.length;
+        discovery.found.push(...window.defined.filter((one) => one.at < end));
+        discovery.next =
+            cut === null ? null : { start: cut.at, path: cut.path, join: cut.join, carry: cut.carry };
+    }
+    return discovery.found;
+}
+function anchorBefore(long, at) {
+    let low = 0;
+    let high = long.anchors.length - 1;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (long.anchors[middle] <= at)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return long.anchors[low];
+}
+function verified(long, at, key) {
+    const line = lineOf(long, at);
+    const anchor = anchorBefore(long, long.starts[line]);
+    const stop = Math.min(long.starts[long.breaks[line]], long.text.length);
+    const found = stop - anchor <= SPAN_CHARS ? spanned(long, anchor, stop) : discovered(long, anchor, stop);
+    return found.find((one) => one.key === key && one.at === at)?.url ?? null;
+}
+function realFrom(long, key, position) {
+    for (const at of long.candidates.get(key) ?? []) {
+        if (at < position)
+            continue;
+        const url = verified(long, at, key);
+        if (url !== null)
+            return url;
+    }
+    return null;
+}
+function dummy(key) {
+    const label = key.startsWith('^') ? `^${key.slice(1)}` : key;
+    const trailing = /\\+$/.exec(label)?.[0].length ?? 0;
+    return `[${label}${trailing % 2 === 1 ? ' ' : ''}]: x`;
+}
+function prefixOf(keys) {
+    return keys.length === 0 ? '' : `${keys.map(dummy).join('\n')}\n\n***\n\n`;
+}
+function renderWindow(long, from, end) {
+    const known = [];
+    const deferred = [];
+    const seen = new Set();
+    for (const found of `${from.carry}${long.text.slice(from.start, end)}`.matchAll(LABEL)) {
+        const key = identifierOf(found[1]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (long.urls.has(key)) {
+            known.push(key);
+            continue;
+        }
+        const first = long.candidates.get(key)?.find((at) => at >= from.start);
+        if (first === undefined)
+            continue;
+        if (first < end) {
+            deferred.push(key);
+            continue;
+        }
+        const url = realFrom(long, key, end);
+        if (url === null)
+            continue;
+        long.urls.set(key, url);
+        known.push(key);
+    }
+    const window = windowOf(long, from, end, prefixOf(known));
+    const later = [];
+    for (const key of deferred) {
+        const native = window.defined.find((one) => one.key === key);
+        if (native !== undefined) {
+            long.urls.set(key, native.url);
+            continue;
+        }
+        const url = realFrom(long, key, from.start);
+        if (url === null)
+            continue;
+        long.urls.set(key, url);
+        later.push(key);
+    }
+    return later.length === 0 ? window : windowOf(long, from, end, prefixOf([...known, ...later]));
+}
+function windowEnd(long, start, size) {
+    const at = start + size;
+    if (at >= long.text.length)
+        return long.text.length;
+    const end = lineEnd(long.starts, long.text, lineOf(long, at));
+    return end - at <= VIEW_CHARS ? Math.min(end + 1, long.text.length) : at;
+}
+function regionOf(long, line, depth) {
+    const stop = (depth > 0 ? long.quoteBreaks : long.breaks)[line];
+    const markers = markersOf(depth);
+    const name = `${depth}:${stop}`;
+    const held = long.regions.get(name);
+    if (held !== undefined)
+        return held;
+    const { text, starts } = long;
+    let setext = false;
+    for (let index = line + 1; index < stop && !setext; index += 1) {
+        const raw = lineText(starts, text, index);
+        const facts = lineFacts(raw.replace(markers, ''));
+        setext = facts.indent <= 3 && UNDERLINE.test(facts.content);
+    }
+    const from = starts[line];
+    const to = Math.min(starts[stop], text.length);
+    const last = new Map();
+    for (const one of ['*', '_', '~', ']', '>'])
+        last.set(one, text.lastIndexOf(one, to - 1));
+    const runs = new Map();
+    for (let at = text.indexOf('`', from); at !== -1 && at < to;) {
+        let end = at;
+        while (text[end] === '`')
+            end += 1;
+        runs.set(end - at, at);
+        at = text.indexOf('`', end);
+    }
+    const region = { setext, last, runs };
+    long.regions.set(name, region);
+    return region;
+}
+const CODE = 1;
+const LINKED = 2;
+const EMPHASIZED = 4;
+function marked(node, flags, shift, start, text) {
+    if (!('children' in node))
+        return;
+    for (const child of node.children) {
+        const from = Math.max(offsetOf(child) + shift - start, 0);
+        const to = Math.min(endOf(child) + shift - start, flags.length);
+        const flag = child.type === 'inlineCode' || child.type === 'html'
+            ? CODE
+            : child.type === 'link'
+                ? text[offsetOf(child) + shift] === '<'
+                    ? CODE
+                    : LINKED
+                : child.type === 'image' ||
+                    child.type === 'linkReference' ||
+                    child.type === 'imageReference' ||
+                    child.type === 'footnoteReference'
+                    ? LINKED
+                    : child.type === 'emphasis' || child.type === 'strong' || child.type === 'delete'
+                        ? EMPHASIZED
+                        : 0;
+        for (let at = from; flag !== 0 && at < to; at += 1)
+            flags[at] |= flag;
+        marked(child, flags, shift, start, text);
+    }
+}
+function opener(text, from, to, paragraph) {
+    const before = from === paragraph ? ' ' : (text[from - 1] ?? ' ');
+    const after = text[to] ?? ' ';
+    const space = (one) => SPACE.test(one);
+    const mark = (one) => PUNCTUATION.test(one);
+    const left = !space(after) && (!mark(after) || space(before) || mark(before));
+    if (text[from] !== '_')
+        return left;
+    const right = !space(before) && (!mark(before) || space(after) || mark(after));
+    return left && (!right || mark(before));
+}
+function pendingAt(long, window, paragraph, start, region) {
+    const { text } = long;
+    const shift = window.start - window.lead;
+    const flags = new Uint8Array(window.end - start);
+    marked(paragraph, flags, shift, start, text);
+    for (let at = start; at < window.end; at += 1) {
+        if ((flags[at - start] & CODE) !== 0)
+            continue;
+        const one = text[at];
+        if (one === '\\' && ESCAPABLE.test(text[at + 1] ?? '')) {
+            at += 1;
+            continue;
+        }
+        if (one === '`') {
+            let end = at;
+            while (text[end] === '`')
+                end += 1;
+            if ((region.runs.get(end - at) ?? -1) > at)
+                return at;
+            at = end - 1;
+            continue;
+        }
+        if (one === '<' && TAG_START.test(text[at + 1] ?? '') && region.last.get('>') > at)
+            return at;
+        const settled = flags[at - start];
+        if (one === '[' && (settled & LINKED) === 0 && region.last.get(']') > at)
+            return at;
+        if ((one === '*' || one === '_' || one === '~') && (settled & (LINKED | EMPHASIZED)) === 0) {
+            let end = at;
+            while (text[end] === one)
+                end += 1;
+            if (opener(text, at, end, start) && region.last.get(one) >= end)
+                return at;
+            at = end - 1;
+        }
+    }
+    return Infinity;
+}
+function restartable(text, at) {
+    const first = text[at];
+    ORDERED.lastIndex = at;
+    if (first === undefined || BLOCK_START.test(first) || ORDERED.test(text))
+        return false;
+    DEFINED.lastIndex = at;
+    return first !== '[' || !DEFINED.test(text);
+}
+function inside(spans, at) {
+    return spans.some(([from, to]) => from < at && at < to);
+}
+function markersOf(depth) {
+    return new RegExp(`^(?: {0,3}> ?){${depth}}`);
+}
+function paragraphCuts(long, window, paragraph, depth, mode) {
+    const { text, starts } = long;
+    const markers = markersOf(depth);
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${depth}}`);
+    const carry = '> '.repeat(depth);
+    const shift = window.start - window.lead;
+    const start = Math.max(offsetOf(paragraph) + shift, window.start);
+    const first = lineOf(long, start);
+    const region = regionOf(long, first, depth);
+    if (region.setext)
+        return [];
+    const pending = mode === 'render' ? pendingAt(long, window, paragraph, start, region) : Infinity;
+    const spans = mode === 'render'
+        ? paragraph.children
+            .filter((child) => child.type !== 'text')
+            .map((child) => [offsetOf(child) + shift, endOf(child) + shift])
+        : [];
+    const last = lineOf(long, window.end - 1);
+    const lines = starts.length - 1;
+    const path = [...Array(depth).fill('blockquote'), 'paragraph'];
+    const reparsed = (at) => () => windowOf(long, { start: window.start, path: [], join: '', carry: window.carry }, at, window.prefix).nodes;
+    const cuts = [];
+    const settled = (at) => at > start && at < pending && !inside(spans, at);
+    const unbroken = (index) => {
+        if (index >= lines)
+            return true;
+        const next = lineText(starts, text, index);
+        return !DELIMITER_ROW.test(lineFacts(next.replace(markers, '')).content);
+    };
+    const contentOf = (index) => starts[index] + leads.exec(lineText(starts, text, index))[0].length;
+    for (let index = first + 1; index <= last; index += 1) {
+        const line = starts[index];
+        if (line >= pending)
+            break;
+        const whole = markers.test(lineText(starts, text, index));
+        const content = contentOf(index);
+        const at = whole ? line : content;
+        const previous = lineText(starts, text, index - 1);
+        if (!restartable(text, content) || /[ \t\\]$/.test(previous))
+            continue;
+        if (!settled(at) || !unbroken(index + 1))
+            continue;
+        const join = text.slice(starts[index - 1] + previous.length, line);
+        cuts.push({ at, path, join, carry: whole ? '' : carry, nodes: reparsed(at) });
+    }
+    if (cuts.length > 0)
+        return cuts;
+    for (let index = first; index <= last; index += 1) {
+        const content = contentOf(index);
+        const end = Math.min(lineEnd(starts, text, index), window.end);
+        for (let at = Math.max(content + 1, start + 1); at < end; at += 1) {
+            if (at >= pending)
+                return cuts;
+            if (!/[ \t]/.test(text[at - 1]) || !restartable(text, at) || !settled(at))
+                continue;
+            if (!unbroken(index + 1))
+                break;
+            let from = at - 1;
+            while (from > content && /[ \t]/.test(text[from - 1]))
+                from -= 1;
+            if (from === content)
+                continue;
+            cuts.push({ at, path, join: text.slice(from, at), carry, nodes: reparsed(at) });
+        }
+    }
+    return cuts;
+}
+function cutsOf(long, window, mode) {
+    const { nodes } = window;
+    const shift = window.start - window.lead;
+    const at = (node) => lineStartOf(long, offsetOf(node) + shift);
+    const cuts = [];
+    for (let index = 1; index < nodes.length; index += 1) {
+        const start = at(nodes[index]);
+        if (start > window.start) {
+            const taken = nodes.slice(0, index);
+            cuts.push({ at: start, path: [], join: '', carry: '', nodes: () => taken });
+        }
+    }
+    const last = nodes.at(-1);
+    if (last === undefined)
+        return cuts;
+    const before = nodes.slice(0, -1);
+    const chain = [];
+    const within = (parent, step, carry) => {
+        const held = [...chain, parent];
+        const path = [...Array(chain.length).fill('blockquote'), step];
+        const marked = markersOf(path.filter((one) => one === 'blockquote').length);
+        for (let index = 1; index < parent.children.length; index += 1) {
+            const start = at(parent.children[index]);
+            if (start <= window.start)
+                continue;
+            if (!marked.test(lineText(long.starts, long.text, lineOf(long, start))))
+                continue;
+            const taken = [...before, truncated(held, index)];
+            cuts.push({ at: start, path, join: '', carry, nodes: () => taken });
+        }
+    };
+    let node = last;
+    while (node !== undefined) {
+        if (node.type === 'paragraph') {
+            cuts.push(...paragraphCuts(long, window, node, chain.length, mode));
+        }
+        if (node.type === 'list')
+            within(node, 'list', '');
+        if (node.type === 'table' && node.children.length > 1) {
+            const begun = offsetOf(node) + shift < window.start;
+            const carry = begun ? window.carry : long.text.slice(at(node), at(node.children[1]));
+            within(node, 'table', carry);
+        }
+        if (node.type !== 'blockquote')
+            break;
+        within(node, 'blockquote', '');
+        chain.push(node);
+        node = node.children.at(-1);
+    }
+    return cuts;
+}
+function truncated(chain, index) {
+    const [outer, ...inner] = chain;
+    if (inner.length === 0)
+        return { ...outer, children: outer.children.slice(0, index) };
+    const children = outer.children.slice(0, -1);
+    return { ...outer, children: [...children, truncated(inner, index)] };
+}
+function chosen(cuts, target) {
+    let best = null;
+    for (const cut of cuts) {
+        if (best === null)
+            best = cut;
+        else if (cut.at >= target) {
+            if (best.at < target || cut.at < best.at)
+                best = cut;
+        }
+        else if (best.at < target && cut.at > best.at)
+            best = cut;
+    }
+    return best;
+}
+function closingOf(long, window) {
+    const last = window.nodes.at(-1);
+    if (last?.type !== 'code')
+        return 0;
+    const { text, starts } = long;
+    const line = lineOf(long, offsetOf(last) + window.start - window.lead);
+    const fence = fenceOf(lineFacts(lineText(starts, text, line)));
+    if (fence === null)
+        return 0;
+    const open = { ...START, fence };
+    for (let index = line + 1; index < starts.length - 1; index += 1) {
+        if (fenced(open, lineFacts(lineText(starts, text, index))).fence === null) {
+            return windowEnd(long, lineEnd(starts, text, index) + 1, WINDOW_CHARS);
+        }
+    }
+    return text.length;
+}
+function cutWindow(long, from, mode, open) {
+    const line = Math.min(lineOf(long, from.start) + WINDOW_LINES, long.starts.length - 1);
+    let end = windowEnd(long, from.start, Math.min(WINDOW_CHARS, long.starts[line] - from.start));
+    for (;;) {
+        const window = open(end);
+        if (end >= long.text.length)
+            return { window, cut: null };
+        const cut = chosen(cutsOf(long, window, mode), from.start + VIEW_CHARS);
+        if (cut !== null)
+            return { window, cut };
+        const grown = windowEnd(long, from.start, 2 * (end - from.start));
+        const whole = 2 * grown - from.start >= long.text.length;
+        end = Math.max(whole ? long.text.length : grown, closingOf(long, window));
+    }
+}
+export function pieceAt(long, index) {
+    while (long.pieces.length <= index && long.next !== null) {
+        const from = long.next;
+        const { window, cut } = cutWindow(long, from, 'render', (end) => renderWindow(long, from, end));
+        const end = cut?.at ?? long.text.length;
+        for (const one of window.defined) {
+            if (one.at < end && !long.urls.has(one.key))
+                long.urls.set(one.key, one.url);
+        }
+        const nodes = cut === null ? window.nodes : cut.nodes();
+        long.pieces.push({ nodes, path: from.path, join: from.join });
+        long.next =
+            cut === null ? null : { start: cut.at, path: cut.path, join: cut.join, carry: cut.carry };
+    }
+    return long.pieces[index] ?? null;
+}
+function opened(node, made) {
+    if (made.has(node))
+        return node;
+    const copy = { ...node, children: [...node.children] };
+    made.add(copy);
+    return copy;
+}
+function continued(into, more, path, join, made) {
+    const [step, ...deeper] = path;
+    const tail = (step === 'table' ? more.children.slice(1) : more.children);
+    const merged = opened(into, made);
+    const held = merged.children;
+    if (step === 'paragraph')
+        held.push({ type: 'text', value: join }, ...tail);
+    else if (deeper.length === 0)
+        held.push(...tail);
+    else {
+        const [head, ...rest] = tail;
+        held.push(continued(held.pop(), head, deeper, join, made), ...rest);
+    }
+    return merged;
+}
+export function drawn(long, count) {
+    const nodes = [];
+    const made = new Set();
+    for (let index = 0; index < count; index += 1) {
+        const piece = pieceAt(long, index);
+        if (piece === null)
+            break;
+        const [first, ...rest] = piece.nodes;
+        const last = nodes.at(-1);
+        if (piece.path.length === 0 || first === undefined || last === undefined) {
+            nodes.push(...piece.nodes);
+            continue;
+        }
+        nodes.pop();
+        nodes.push(continued(last, first, piece.path, piece.join, made), ...rest);
+    }
+    return nodes;
+}
+export function remaining(long, count) {
+    return long.pieces.length > count || (long.pieces.length === count && long.next !== null);
+}