@agentshouse/mdruntime 0.1.0-ce131cb435f8b → 0.1.0-ce9f29a01a271

package/dist/chat/pieces.js

@@ -0,0 +1,1110 @@
+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 QUOTE_MARKER = /^ {0,3}> ?/;
+const MARKER = /^(?:[-+*]|\d{1,9}[.)])/;
+const TASK = /^\[[ \txX]\]/;
+const NOTE = /^\[\^(?:[^\\\]]|\\.){1,999}\]:/;
+const SPACES = /^[ \t]*$/;
+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: '', levels: [] },
+        urls: new Map(),
+        spans: new Map(),
+        discoveries: new Map(),
+        regions: new Map(),
+        spreads: 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,
+        levels: from.levels,
+        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: '', levels: [] } };
+        long.discoveries.set(anchor, discovery);
+    }
+    while (discovery.next !== null && discovery.next.start < stop) {
+        const from = discovery.next;
+        const { pane, cut } = cutWindow(long, from, 'discover', (end) => windowOf(long, from, end, ''));
+        const end = cut?.at ?? long.text.length;
+        discovery.found.push(...pane.defined.filter((one) => one.at < end));
+        discovery.next = cut === null ? null : nextOf(cut);
+    }
+    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 pane = windowOf(long, from, end, prefixOf(known));
+    const later = [];
+    for (const key of deferred) {
+        const native = pane.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 ? pane : 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 nextOf(cut) {
+    return { start: cut.at, path: cut.path, join: cut.join, carry: cut.carry, levels: cut.levels };
+}
+function quotesOf(levels) {
+    return levels.filter((level) => level.kind === 'quote').length;
+}
+function itemed(levels) {
+    return levels.some((level) => level.kind !== 'quote');
+}
+function stepsOf(levels) {
+    return levels.flatMap((level) => level.kind === 'quote'
+        ? ['blockquote']
+        : level.kind === 'item'
+            ? ['list', 'item']
+            : ['footnote']);
+}
+function carryOf(levels) {
+    return levels.map((level) => level.carry).join('');
+}
+function columnOn(long, index, levels) {
+    const raw = lineText(long.starts, long.text, index);
+    let at = 0;
+    for (const level of levels) {
+        if (level.line === index) {
+            at = level.column;
+            if (at < 0)
+                return -1;
+        }
+        else if (level.kind === 'quote') {
+            const marker = QUOTE_MARKER.exec(raw.slice(at));
+            if (marker === null)
+                return -1;
+            at += marker[0].length;
+        }
+        else {
+            for (let column = 0; column < level.size; column += 1) {
+                if (raw[at + column] !== ' ')
+                    return -1;
+            }
+            at += level.size;
+        }
+    }
+    return at;
+}
+function withinOf(raw, levels) {
+    let rest = raw;
+    for (const [index, level] of levels.entries()) {
+        if (level.kind === 'quote') {
+            const marker = QUOTE_MARKER.exec(rest);
+            if (marker === null)
+                return SPACES.test(rest) ? 'gone' : 'line';
+            rest = rest.slice(marker[0].length);
+            continue;
+        }
+        if (SPACES.test(rest))
+            return quotesOf(levels.slice(index)) > 0 ? 'gone' : 'blank';
+        if (!rest.startsWith(' '.repeat(level.size)))
+            return 'line';
+        rest = rest.slice(level.size);
+    }
+    return SPACES.test(rest) ? 'blank' : 'line';
+}
+function plain(facts) {
+    return (!opens(facts) &&
+        !TAG.test(facts.content) &&
+        !DELIMITER_ROW.test(facts.content) &&
+        !UNDERLINE.test(facts.content));
+}
+function spreadScan(long, line, column, size, parents) {
+    const { text, starts } = long;
+    const lines = starts.length - 1;
+    const quotes = quotesOf(parents);
+    const breaks = quotes > 0 ? long.quoteBreaks : long.breaks;
+    const kind = (index) => withinOf(lineText(starts, text, index), parents);
+    let blank = breaks[line + 1];
+    while (blank < lines && kind(blank) === 'line')
+        blank = breaks[blank + 1];
+    if (blank >= lines || kind(blank) === 'gone')
+        return false;
+    let next = blank + 1;
+    while (next < lines && kind(next) === 'blank')
+        next += 1;
+    if (next >= lines || kind(next) === 'gone')
+        return false;
+    const at = columnOn(long, next, parents);
+    if (at < 0)
+        return false;
+    const lead = /^[ \t]*/.exec(lineText(starts, text, next).slice(at))[0];
+    if (lead.includes('\t'))
+        return null;
+    if (lead.length < size)
+        return false;
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${quotes}}`);
+    if (!plain(lineFacts(lineText(starts, text, line).slice(column))))
+        return null;
+    for (let index = line + 1; index < blank; index += 1) {
+        const raw = lineText(starts, text, index);
+        const held = columnOn(long, index, parents);
+        const rest = held < 0 ? raw.replace(leads, '') : raw.slice(held);
+        const indent = /^[ \t]*/.exec(rest)[0];
+        if (indent.includes('\t'))
+            return null;
+        const inner = indent.length >= size ? lineFacts(rest.slice(size)) : lineFacts(rest);
+        if (indent.length >= size && inner.indent >= 4)
+            return null;
+        if (!plain(inner))
+            return null;
+    }
+    return true;
+}
+function spreadOf(long, line, column, size, parents) {
+    const key = long.starts[line] + column;
+    const held = long.spreads.get(key);
+    if (held !== undefined)
+        return held;
+    const spread = spreadScan(long, line, column, size, parents);
+    long.spreads.set(key, spread);
+    return spread;
+}
+function itemLevel(long, pane, item, outer) {
+    const { text, starts } = long;
+    const marker = offsetOf(item) + pane.start - pane.lead;
+    const line = lineOf(long, marker);
+    const start = starts[line];
+    const base = columnOn(long, line, outer);
+    if (base < 0 || marker < start + base || !/^ *$/.test(text.slice(start + base, marker))) {
+        return null;
+    }
+    const sign = MARKER.exec(text.slice(marker, marker + 11))?.[0];
+    if (sign === undefined)
+        return null;
+    let after = marker + sign.length;
+    while (text[after] === ' ')
+        after += 1;
+    const spaces = after - marker - sign.length;
+    if (spaces < 1 || spaces > 4 || after >= lineEnd(starts, text, line))
+        return null;
+    if (/[\t\r\n]/.test(text[after]))
+        return null;
+    const column = after - start;
+    const size = column - base;
+    const spread = item.spread === true
+        ? true
+        : spreadOf(long, line, column, size, outer);
+    if (spread === null)
+        return null;
+    long.spreads.set(start + column, spread);
+    const carry = `${' '.repeat(marker - start - base)}${sign}${' '.repeat(spaces)}`;
+    return { kind: 'item', line, column, size, carry, spread };
+}
+function noteLevel(long, pane, note, outer) {
+    const { text, starts } = long;
+    const marker = offsetOf(note) + pane.start - pane.lead;
+    const line = lineOf(long, marker);
+    const start = starts[line];
+    const base = columnOn(long, line, outer);
+    if (base < 0 || marker < start + base || !/^ *$/.test(text.slice(start + base, marker))) {
+        return null;
+    }
+    const label = NOTE.exec(text.slice(marker, marker + 1_004))?.[0];
+    if (label === undefined)
+        return null;
+    let after = marker + label.length;
+    while (text[after] === ' ')
+        after += 1;
+    if (text[after] === '\t')
+        return null;
+    const column = after - start;
+    return { kind: 'note', line, column, size: 4, carry: `${label} `, spread: false };
+}
+function quoteLevel(long, pane, quote) {
+    const { text, starts } = long;
+    const marker = offsetOf(quote) + pane.start - pane.lead;
+    const line = lineOf(long, marker);
+    const known = text[marker] === '>' && text[marker + 1] !== '\t';
+    const after = text[marker + 1] === ' ' ? marker + 2 : marker + 1;
+    return {
+        kind: 'quote',
+        line,
+        column: known ? after - starts[line] : -1,
+        size: 0,
+        carry: '> ',
+        spread: false,
+    };
+}
+function regionOf(long, line, levels) {
+    const quotes = quotesOf(levels);
+    const lined = !itemed(levels);
+    const stop = (quotes > 0 ? long.quoteBreaks : long.breaks)[line];
+    const markers = markersOf(quotes);
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${quotes}}`);
+    const name = `${levels.map((level) => (level.kind === 'quote' ? '>' : level.size)).join(' ')}:${stop}`;
+    const held = long.regions.get(name);
+    if (held !== undefined && held.from <= line + 1)
+        return held;
+    const { text, starts } = long;
+    const looks = [];
+    for (let index = line + 1; index < stop; index += 1) {
+        const raw = lineText(starts, text, index);
+        const column = lined ? (markers.exec(raw)?.[0].length ?? -1) : columnOn(long, index, levels);
+        const facts = lineFacts(column < 0 ? raw.replace(lined ? markers : leads, '') : raw.slice(column));
+        if (facts.indent <= 3 && UNDERLINE.test(facts.content))
+            looks.push(index);
+    }
+    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 = { from: line + 1, looks, last, runs };
+    long.regions.set(name, region);
+    return region;
+}
+function after(lines, line) {
+    let low = 0;
+    let high = lines.length;
+    while (low < high) {
+        const middle = (low + high) >> 1;
+        if (lines[middle] <= line)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return lines[low] ?? Infinity;
+}
+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, pane, paragraph, start, region) {
+    const { text } = long;
+    const shift = pane.start - pane.lead;
+    const flags = new Uint8Array(pane.end - start);
+    marked(paragraph, flags, shift, start, text);
+    for (let at = start; at < pane.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 spreadAlong(nodes, levels) {
+    let node = nodes.at(-1);
+    for (const level of levels) {
+        if (node === undefined || !('children' in node))
+            break;
+        if (level.kind !== 'item') {
+            node = node.children.at(-1);
+            continue;
+        }
+        const item = node.children.at(-1);
+        if (node.type !== 'list' || item?.type !== 'listItem')
+            break;
+        item.spread = level.spread;
+        node = item.children.at(-1);
+    }
+    return nodes;
+}
+function openable(long, line, cut, begun, frame) {
+    const { text, starts } = long;
+    if (!/^ *$/.test(text.slice(cut, begun)))
+        return false;
+    const content = lineText(starts, text, line).slice(cut - starts[line]);
+    const inner = frame.at(-1).kind;
+    if (inner !== 'quote' && cut !== begun)
+        return false;
+    if (inner === 'item' && TASK.test(content))
+        return false;
+    return frame.every((_, index) => {
+        const facts = lineFacts(`${carryOf(frame.slice(index))}${content}`);
+        return facts.indent > 3 || !THEMATIC.test(facts.content);
+    });
+}
+function paragraphCuts(long, pane, paragraph, levels, mode) {
+    const { text, starts } = long;
+    const quotes = quotesOf(levels);
+    const lined = !itemed(levels);
+    const markers = markersOf(quotes);
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${quotes}}`);
+    const carry = carryOf(levels);
+    const shift = pane.start - pane.lead;
+    const start = Math.max(offsetOf(paragraph) + shift, pane.start);
+    const first = lineOf(long, start);
+    const region = regionOf(long, first, levels);
+    if (after(region.looks, first) !== Infinity)
+        return [];
+    const pending = mode === 'render' ? pendingAt(long, pane, 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, pane.end - 1);
+    const lines = starts.length - 1;
+    const path = [...stepsOf(levels), 'paragraph'];
+    const reparsed = (at) => () => spreadAlong(windowOf(long, { start: pane.start, path: [], join: '', carry: pane.carry, levels: pane.levels }, at, pane.prefix).nodes, levels);
+    const cuts = [];
+    const settled = (at) => at > start && at < pending && !inside(spans, at);
+    const restOf = (index) => {
+        const raw = lineText(starts, text, index);
+        const column = lined ? -1 : columnOn(long, index, levels);
+        return column < 0 ? raw.replace(lined ? markers : leads, '') : raw.slice(column);
+    };
+    const unbroken = (index) => index >= lines || !DELIMITER_ROW.test(lineFacts(restOf(index)).content);
+    const contentOf = (index) => {
+        const raw = lineText(starts, text, index);
+        const column = lined ? -1 : columnOn(long, index, levels);
+        return starts[index] + (column < 0 ? leads.exec(raw)[0].length : column);
+    };
+    const fresh = (at) => levels.at(-1)?.kind !== 'item' || !TASK.test(text.slice(at, at + 3));
+    for (let index = first + 1; index <= last; index += 1) {
+        const line = starts[index];
+        if (line >= pending)
+            break;
+        const whole = lined && 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) || !fresh(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, levels, 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), pane.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 (!fresh(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, levels, nodes: reparsed(at) });
+        }
+    }
+    return cuts;
+}
+function cutsOf(long, pane, mode) {
+    const { nodes } = pane;
+    const shift = pane.start - pane.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 > pane.start) {
+            const taken = nodes.slice(0, index);
+            cuts.push({ at: start, path: [], join: '', carry: '', levels: [], nodes: () => taken });
+        }
+    }
+    const last = nodes.at(-1);
+    if (last === undefined)
+        return cuts;
+    const before = nodes.slice(0, -1);
+    const chain = [];
+    const levels = [];
+    const spreads = new Map();
+    const within = (parent, path, frame, header) => {
+        const held = [...chain, parent];
+        const lined = !itemed(frame);
+        const marked = markersOf(quotesOf(frame));
+        for (let index = 1; index < parent.children.length; index += 1) {
+            const begun = offsetOf(parent.children[index]) + shift;
+            const line = lineOf(long, begun);
+            let cut = long.starts[line];
+            if (lined) {
+                if (!marked.test(lineText(long.starts, long.text, line)))
+                    continue;
+            }
+            else {
+                const column = columnOn(long, line, frame);
+                if (column < 0)
+                    continue;
+                if (header === null) {
+                    cut += column;
+                    if (!openable(long, line, cut, begun, frame))
+                        continue;
+                }
+            }
+            if (cut <= pane.start)
+                continue;
+            const taken = [...before, truncated(held, index, spreads)];
+            const carry = header ?? (lined ? '' : carryOf(frame));
+            cuts.push({ at: cut, path, join: '', carry, levels: frame, nodes: () => taken });
+        }
+    };
+    const carried = (node) => offsetOf(node) < pane.lead;
+    let node = last;
+    while (node !== undefined) {
+        if (node.type === 'paragraph') {
+            cuts.push(...paragraphCuts(long, pane, node, levels, mode));
+        }
+        if (node.type === 'table' && node.children.length > 1) {
+            const begun = offsetOf(node) + shift;
+            const lined = !itemed(levels);
+            const header = begun < pane.start
+                ? pane.carry
+                : lined
+                    ? long.text.slice(at(node), at(node.children[1]))
+                    : long.text[begun] === ' '
+                        ? null
+                        : `${carryOf(levels)}${long.text.slice(begun, at(node.children[1]))}`;
+            if (header !== null)
+                within(node, [...stepsOf(levels), 'table'], levels, header);
+        }
+        if (node.type === 'list') {
+            within(node, [...stepsOf(levels), 'list'], levels, null);
+            const item = node.children.at(-1);
+            if (item === undefined)
+                break;
+            const level = carried(item)
+                ? pane.levels[levels.length]
+                : itemLevel(long, pane, item, levels);
+            if (level === undefined || level === null || level.kind !== 'item')
+                break;
+            chain.push(node);
+            levels.push(level);
+            spreads.set(item, level.spread);
+            within(item, stepsOf(levels), levels, null);
+            chain.push(item);
+            node = item.children.at(-1);
+            continue;
+        }
+        if (node.type === 'footnoteDefinition') {
+            const level = carried(node)
+                ? pane.levels[levels.length]
+                : noteLevel(long, pane, node, levels);
+            if (level === undefined || level === null || level.kind !== 'note')
+                break;
+            levels.push(level);
+            within(node, stepsOf(levels), levels, null);
+            chain.push(node);
+            node = node.children.at(-1);
+            continue;
+        }
+        if (node.type !== 'blockquote')
+            break;
+        const level = carried(node) ? pane.levels[levels.length] : quoteLevel(long, pane, node);
+        if (level === undefined || level.kind !== 'quote')
+            break;
+        levels.push(level);
+        within(node, stepsOf(levels), levels, null);
+        chain.push(node);
+        node = node.children.at(-1);
+    }
+    return cuts;
+}
+function truncated(chain, index, spreads) {
+    const [outer, ...inner] = chain;
+    const spread = spreads.get(outer);
+    const kept = spread === undefined ? {} : { spread };
+    if (inner.length === 0) {
+        return { ...outer, ...kept, children: outer.children.slice(0, index) };
+    }
+    const children = outer.children.slice(0, -1);
+    return {
+        ...outer,
+        ...kept,
+        children: [...children, truncated(inner, index, spreads)],
+    };
+}
+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, pane) {
+    const last = pane.nodes.at(-1);
+    if (last?.type !== 'code')
+        return 0;
+    const { text, starts } = long;
+    const line = lineOf(long, offsetOf(last) + pane.start - pane.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 pane = open(end);
+        if (end >= long.text.length)
+            return { pane, cut: null };
+        const cut = chosen(cutsOf(long, pane, mode), from.start + VIEW_CHARS);
+        if (cut !== null)
+            return { pane, 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, pane));
+    }
+}
+export function pieceAt(long, index) {
+    while (long.pieces.length <= index && long.next !== null) {
+        const from = long.next;
+        const { pane, cut } = cutWindow(long, from, 'render', (end) => renderWindow(long, from, end));
+        const end = cut?.at ?? long.text.length;
+        for (const one of pane.defined) {
+            if (one.at < end && !long.urls.has(one.key))
+                long.urls.set(one.key, one.url);
+        }
+        const nodes = cut === null ? pane.nodes : cut.nodes();
+        long.pieces.push({ nodes, path: from.path, join: from.join });
+        long.next = cut === null ? null : nextOf(cut);
+    }
+    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);
+}