@agentshouse/mdmodel 0.1.0-alpha.17 → 0.1.0-alpha.18

package/dist/links.js

@@ -1,11 +1,49 @@
 const TAB_STOP = 4;
 const CLOSING_FENCE_INDENT = 3;
+const CODE_INDENT = 4;
 const HEADING = /^#{1,6}(?:[ \t]|$)/;
 const BREAK = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
 const SETEXT = /^(?:=+|-+)[ \t]*$/;
-const LABEL = /^\[((?:[^\\\]\n]|\\.)+)\]:[ \t]*/;
-const DESTINATION = /^(?:(<[^<>\n\r]*>)|([^\s<][^\s]*))/d;
-const TITLE = /^(?:"[^"\n]*"|'[^'\n]*'|\([^()\n]*\))[ \t]*$/;
+const BLANK = /^[ \t\v\f]*\r?$/;
+const HTML_CLOSED = [
+    [
+        /^<(?:script|pre|style)(?:[ \t\v\f>]|$)/i,
+        /<\/(?:script|pre|style)>/i
+    ],
+    [
+        /^<!--/,
+        /-->/
+    ],
+    [
+        /^<\?/,
+        /\?>/
+    ],
+    [
+        /^<![A-Z]/,
+        />/
+    ],
+    [
+        /^<!\[CDATA\[/,
+        /\]\]>/
+    ]
+];
+const HTML_BLOCK_TAG = /^<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:[ \t\v\f>]|\/>|$)/i;
+const HTML_TAG_LINE = /^(?:<[A-Za-z][A-Za-z0-9-]*(?:[ \t\v\f]+[A-Za-z_:][A-Za-z0-9_.:-]*(?:[ \t\v\f]*=[ \t\v\f]*(?:[^ \t\v\f\r\n"'=<>`]+|'[^']*'|"[^"]*"))?)*[ \t\v\f]*\/?>|<\/[A-Za-z][A-Za-z0-9-]*[ \t\v\f]*>)[ \t\v\f]*$/;
+const ORDERED = /^(\d{1,9})[.)]/;
+const LABEL_LENGTH = 999;
+const PUNCTUATION = /^[!-/:-@[-`{-~]$/;
+const INLINE_RAW = new RegExp([
+    '<[A-Za-z][A-Za-z0-9-]*(?:[ \\t\\n\\v\\f\\r]+[A-Za-z_:][A-Za-z0-9_.:-]*(?:[ \\t\\n\\v\\f\\r]*=[ \\t\\n\\v\\f\\r]*(?:[^ \\t\\n\\v\\f\\r"\'=<>`]+|\'[^\']*\'|"[^"]*"))?)*[ \\t\\n\\v\\f\\r]*\\/?>',
+    '<\\/[A-Za-z][A-Za-z0-9-]*[ \\t\\n\\v\\f\\r]*>',
+    '<!--(?!-?>)(?:-?[^-])*-->',
+    '<\\?[\\s\\S]*?\\?>',
+    '<![A-Z]+[ \\t\\n\\v\\f\\r]+[^>]*>',
+    '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>',
+    '<[A-Za-z][A-Za-z0-9+.-]{1,31}:[^\\x00-\\x20<>]*>',
+    "<[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*>"
+].join('|'), 'y');
+const DELIMITER_ROW = /^\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+const GAP = /^[ \t\v\f]+/;
 function endOfLine(text, from) {
     const nl = text.indexOf('\n', from);
     return nl === -1 ? text.length : nl;
@@ -123,159 +161,435 @@ function fenceSpan(text, line, open) {
     }
     return text.length;
 }
-function skipInlineCode(text, index) {
+function skipInlineCode(text, index, joins) {
     let ticks = 0;
     while(text[index + ticks] === '`')ticks += 1;
-    const close = text.indexOf('`'.repeat(ticks), index + ticks);
-    if (close === -1) return text.length;
-    return close + ticks;
+    let i = index + ticks;
+    while(i < text.length){
+        const ch = text[i];
+        if (ch === '`') {
+            let run = 0;
+            while(text[i + run] === '`')run += 1;
+            if (run === ticks) return i + run;
+            i += run;
+            continue;
+        }
+        if (ch === '\r' && text[i + 1] !== '\n') break;
+        if (ch === '\n' && !joins.has(i)) break;
+        i += 1;
+    }
+    return index + ticks;
 }
 function skipLinkSpace(text, start) {
     let i = start;
     while(text[i] === ' ' || text[i] === '\t')i += 1;
     return i;
 }
-function skipTitle(text, start) {
-    const open = text[start];
-    if (open !== '"' && open !== "'" && open !== '(') return start;
+function skipInlineSpace(text, start, joins) {
+    let i = skipLinkSpace(text, start);
+    if (text[i] === '\r' && text[i + 1] === '\n') i += 1;
+    if (text[i] !== '\n' || !joins.has(i)) return i;
+    return afterIndent(text, readLine(text, i + 1, endOfLine(text, i + 1)));
+}
+function closeEnd(text, start, open, joins) {
     const close = open === '(' ? ')' : open;
-    let i = start + 1;
+    let i = start;
     while(i < text.length){
         const ch = text[i];
+        if (escapes(text, i)) {
+            i += 2;
+            continue;
+        }
         if (ch === close) return i + 1;
-        if (ch === '\n' || ch === '\r') return null;
+        if (open === '(' && ch === '(') return null;
+        if (ch === '\r' && text[i + 1] !== '\n') return null;
+        if (ch === '\n' && !joins.has(i)) return null;
         i += 1;
     }
     return null;
 }
-function destination(text, start) {
-    let i = skipLinkSpace(text, start + 1);
-    let occurrence;
-    if (text[i] === '<') {
-        const close = text.indexOf('>', i + 1);
-        if (close === -1) return null;
-        occurrence = {
-            href: text.slice(i + 1, close),
-            start: i,
+function skipTitle(text, start, joins) {
+    const open = text[start];
+    if (open !== '"' && open !== "'" && open !== '(') return start;
+    return closeEnd(text, start + 1, open, joins);
+}
+function destinationAt(text, at, end) {
+    if (text[at] === '<') {
+        let close = at + 1;
+        while(close < end && text[close] !== '>'){
+            if (text[close] === '<') return null;
+            close += escapes(text, close) ? 2 : 1;
+        }
+        if (close >= end) return null;
+        return {
+            href: text.slice(at + 1, close),
+            start: at,
             end: close + 1,
             bracketed: true
         };
-        i = close + 1;
-    } else {
-        const from = i;
-        let depth = 0;
-        while(i < text.length){
-            const ch = text[i];
-            if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') break;
-            if (ch === '(') depth += 1;
-            else if (ch === ')') {
-                if (depth === 0) break;
-                depth -= 1;
-            }
-            i += 1;
+    }
+    let i = at;
+    let depth = 0;
+    while(i < end){
+        if (escapes(text, i)) {
+            i += 2;
+            continue;
         }
-        occurrence = {
-            href: text.slice(from, i),
-            start: from,
-            end: i,
-            bracketed: false
-        };
+        const ch = text[i];
+        if (ch <= ' ' || ch === '\x7f') break;
+        if (ch === '(') depth += 1;
+        else if (ch === ')') {
+            if (depth === 0) break;
+            depth -= 1;
+        }
+        i += 1;
     }
-    i = skipLinkSpace(text, i);
-    const afterTitle = skipTitle(text, i);
+    if (depth !== 0) return null;
+    return {
+        href: text.slice(at, i),
+        start: at,
+        end: i,
+        bracketed: false
+    };
+}
+function destination(text, start, joins) {
+    let i = skipInlineSpace(text, start + 1, joins);
+    const occurrence = destinationAt(text, i, endOfLine(text, i));
+    if (occurrence === null) return null;
+    i = occurrence.end;
+    const spaced = skipInlineSpace(text, i, joins);
+    if (spaced === i && text[i] !== ')') return null;
+    i = spaced;
+    const afterTitle = skipTitle(text, i, joins);
     if (afterTitle === null) return null;
-    i = skipLinkSpace(text, afterTitle);
+    i = skipInlineSpace(text, afterTitle, joins);
     if (text[i] !== ')') return null;
     return {
         occurrence,
         end: i + 1
     };
 }
-function labelEnd(text, start) {
+function cellCount(row) {
+    return row.trim().replace(/^\|/, '').replace(/(?<!\\)\|$/, '').split(/(?<!\\)\|/).length;
+}
+function headsTable(text, header, end) {
+    if (end >= text.length) return false;
+    const row = lineText(text, readLine(text, end + 1, endOfLine(text, end + 1)));
+    return row.includes('|') && DELIMITER_ROW.test(row) && cellCount(row) === cellCount(header);
+}
+function blockText(text, line) {
+    if (!line.item) return lineText(text, line);
+    const raw = text.slice(afterIndent(text, line), line.end);
+    return raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+}
+function interruptsWithHtml(head) {
+    return HTML_CLOSED.some(([open])=>open.test(head)) || HTML_BLOCK_TAG.test(head);
+}
+function markerColumn(text, line) {
+    return widthOf(text, line.inner, afterIndent(text, line));
+}
+function markerEnd(text, at, end) {
+    const after = itemMarker(text, at, end);
+    if (after === null) return null;
+    return after > at && (text[after - 1] === ' ' || text[after - 1] === '\t') ? after - 1 : after;
+}
+function itemContent(text, line) {
+    let marker = markerEnd(text, afterIndent(text, line), line.end);
+    for(;;){
+        let next = marker + 1;
+        let spaces = 0;
+        while(spaces < 3 && text[next] === ' '){
+            next += 1;
+            spaces += 1;
+        }
+        const nested = next < line.end ? markerEnd(text, next, line.end) : null;
+        if (nested === null) break;
+        marker = nested;
+    }
+    const at = skipLinkSpace(text, marker);
+    const rest = text.slice(at, line.end).trim();
+    const column = widthOf(text, line.inner, at);
+    const start = widthOf(text, line.inner, marker);
+    if (rest !== '' && column - start <= CODE_INDENT) return {
+        column,
+        code: null
+    };
+    return {
+        column: start + 1,
+        code: rest === '' ? null : marker + 1
+    };
+}
+function joinsParagraph(text, line, depth, item) {
+    if (line.depth > depth) return false;
+    const head = blockText(text, line);
+    if (head.trim() === '' || endsBlock(head) || interruptsWithHtml(head)) return false;
+    if (fenceAt(text, line) !== null) return false;
+    if (!line.item) return true;
+    if (item !== undefined && markerColumn(text, line) < item) return false;
+    if (lineText(text, line).trim() === '') return true;
+    const ordered = ORDERED.exec(head);
+    return ordered !== null && Number(ordered[1]) !== 1;
+}
+function startsParagraph(text, line) {
+    return lineText(text, line).trim() !== '' && !endsBlock(blockText(text, line));
+}
+function lineColumn(text, line) {
+    return line.item ? markerColumn(text, line) : indentWidth(text, line);
+}
+function endsTable(text, line, depth) {
+    const head = blockText(text, line);
+    return head.trim() === '' || line.depth !== depth || line.item || endsBlock(head) || interruptsWithHtml(head) || fenceAt(text, line) !== null;
+}
+function quoteInner(text, start, end, depth) {
     let i = start;
-    let depth = 1;
-    while(i < text.length && depth > 0){
+    for(let level = 0; level < depth; level += 1){
+        let spaces = 0;
+        while(spaces < 3 && i < end && text[i] === ' '){
+            i += 1;
+            spaces += 1;
+        }
+        if (text[i] !== '>') return null;
+        i += 1;
+        if (text[i] === ' ') i += 1;
+    }
+    return i;
+}
+function htmlEnd(text, line, item) {
+    const head = lineText(text, line);
+    const closed = HTML_CLOSED.find(([open])=>open.test(head));
+    if (closed === undefined && !HTML_BLOCK_TAG.test(head) && !HTML_TAG_LINE.test(head)) return null;
+    if (closed !== undefined && closed[1].test(head)) return afterLine(text, line.end);
+    let cursor = afterLine(text, line.end);
+    while(cursor < text.length){
+        const end = endOfLine(text, cursor);
+        const inner = quoteInner(text, cursor, end, line.depth);
+        if (inner === null) return cursor;
+        const at = skipLinkSpace(text, inner);
+        const body = text.slice(inner, end);
+        const blank = BLANK.test(text.slice(at, end));
+        if (item !== undefined && !blank && widthOf(text, inner, at) < item) return cursor;
+        if (closed === undefined && blank) return cursor;
+        if (closed !== undefined && closed[1].test(body)) return afterLine(text, end);
+        cursor = afterLine(text, end);
+        if (cursor === end) break;
+    }
+    return text.length;
+}
+function codeEnd(text, line, base) {
+    let stop = afterLine(text, line.end);
+    let cursor = stop;
+    while(cursor < text.length){
+        const end = endOfLine(text, cursor);
+        const current = readLine(text, cursor, end);
+        if (current.depth !== line.depth) break;
+        const blank = lineText(text, current).trim() === '' && !current.item;
+        if (!blank && (current.item || indentWidth(text, current) < base + CODE_INDENT)) break;
+        cursor = afterLine(text, end);
+        if (!blank) stop = cursor;
+        if (cursor === end) break;
+    }
+    return stop;
+}
+function structure(text) {
+    const joins = new Set();
+    const raw = [];
+    const items = [];
+    let paragraph = null;
+    let table = null;
+    let depth = 0;
+    let cursor = 0;
+    while(cursor < text.length){
+        const end = endOfLine(text, cursor);
+        const line = readLine(text, cursor, end);
+        const content = lineText(text, line);
+        const blank = content.trim() === '' && !line.item;
+        if (table !== null && endsTable(text, line, table)) table = null;
+        if (table !== null) {
+            cursor = afterLine(text, end);
+            if (cursor === end) break;
+            continue;
+        }
+        if (paragraph !== null && joinsParagraph(text, line, paragraph, items.at(-1))) {
+            if (headsTable(text, content, end)) {
+                table = line.depth;
+                paragraph = null;
+            } else joins.add(cursor - 1);
+            cursor = afterLine(text, end);
+            if (cursor === end) break;
+            continue;
+        }
+        paragraph = null;
+        if (line.depth !== depth) items.length = 0;
+        depth = line.depth;
+        if (!blank) {
+            while(items.length > 0 && items.at(-1) > lineColumn(text, line))items.pop();
+        }
+        if (line.item && !BREAK.test(blockText(text, line))) {
+            const opened = itemContent(text, line);
+            items.push(opened.column);
+            if (opened.code !== null) {
+                const stop = codeEnd(text, line, opened.column);
+                raw.push([
+                    opened.code,
+                    stop
+                ]);
+                cursor = stop;
+                continue;
+            }
+        }
+        const open = fenceAt(text, line);
+        if (open !== null) {
+            const stop = fenceSpan(text, line, open);
+            raw.push([
+                cursor,
+                stop
+            ]);
+            cursor = stop;
+            continue;
+        }
+        const base = items.at(-1) ?? 0;
+        if (!blank && !line.item && indentWidth(text, line) >= base + CODE_INDENT) {
+            const stop = codeEnd(text, line, base);
+            raw.push([
+                cursor,
+                stop
+            ]);
+            cursor = stop;
+            continue;
+        }
+        const html = htmlEnd(text, line, items.at(-1));
+        if (html !== null) {
+            raw.push([
+                cursor,
+                html
+            ]);
+            cursor = html;
+            continue;
+        }
+        if (startsParagraph(text, line)) {
+            if (headsTable(text, content, end)) table = line.depth;
+            else paragraph = line.depth;
+        }
+        cursor = afterLine(text, end);
+        if (cursor === end) break;
+    }
+    return {
+        joins,
+        raw
+    };
+}
+function escapes(text, index) {
+    return text[index] === '\\' && PUNCTUATION.test(text[index + 1] ?? '');
+}
+function referenceEnd(text, start, joins) {
+    let i = start;
+    while(i < text.length){
         const ch = text[i];
-        if (ch === '\\') {
+        if (escapes(text, i)) {
             i += 2;
             continue;
         }
-        if (ch === '[') depth += 1;
-        else if (ch === ']') depth -= 1;
-        else if (ch === '\n' || ch === '\r') return -1;
+        if (ch === ']') return i + 1;
+        if (ch === '[') return -1;
+        if (ch === '\r' && text[i + 1] !== '\n') return -1;
+        if (ch === '\n' && !joins.has(i)) return -1;
         i += 1;
     }
-    return depth === 0 ? i : -1;
-}
-function takeLink(text, index, start, found, defs) {
-    const end = labelEnd(text, index + 1);
-    if (end === -1) return index + 1;
-    const label = text.slice(index + 1, end - 1);
-    let i = end;
-    if (text[i] === '(') {
-        const dest = destination(text, i);
-        if (dest === null) return index + 1;
-        found.push({
-            start,
-            end: dest.end,
-            labelStart: index + 1,
-            labelEnd: end - 1,
-            destination: dest.occurrence
+    return -1;
+}
+function labelText(text, from, to) {
+    let label = '';
+    let cursor = from;
+    let newline = text.indexOf('\n', cursor);
+    while(newline !== -1 && newline < to){
+        label += `${text.slice(cursor, newline)}\n`;
+        cursor = afterIndent(text, readLine(text, newline + 1, endOfLine(text, newline + 1)));
+        newline = text.indexOf('\n', cursor);
+    }
+    return label + text.slice(cursor, to);
+}
+function labelKey(label) {
+    return label.replace(/[ \t\n\v\f\r]+/g, ' ').replace(/^ | $/g, '').toLowerCase().split('\u0131').map((part)=>part.toUpperCase()).join('\u0131');
+}
+function labelKeyAt(text, from, to) {
+    const label = labelText(text, from, to);
+    if (label.length > LABEL_LENGTH && [
+        ...label
+    ].length > LABEL_LENGTH) return '';
+    return labelKey(label);
+}
+function closeLink(text, opener, close, defs, joins) {
+    const end = close + 1;
+    const use = (destination, to)=>({
+            start: opener.start,
+            end: to,
+            labelStart: opener.at + 1,
+            labelEnd: close,
+            destination
         });
-        return dest.end;
+    if (text[end] === '(') {
+        const dest = destination(text, end, joins);
+        if (dest !== null) return use(dest.occurrence, dest.end);
     }
-    if (text[i] === '[') {
-        const close = labelEnd(text, i + 1);
-        if (close === -1) return index + 1;
-        const id = (text.slice(i + 1, close - 1) || label).trim().toLowerCase();
-        const defined = defs.get(id);
-        if (defined !== undefined) {
-            found.push({
-                start,
-                end: close,
-                labelStart: index + 1,
-                labelEnd: end - 1,
-                destination: defined
-            });
+    if (text[end] === '[') {
+        const second = referenceEnd(text, end + 1, joins);
+        const collapsed = second === end + 2;
+        const named = collapsed ? opener.bracketAfter ? '' : labelKeyAt(text, opener.at + 1, close) : labelKeyAt(text, end + 1, second - 1);
+        if (second !== -1 && (named !== '' || collapsed)) {
+            const defined = defs.get(named);
+            return defined === undefined ? null : use(defined, second);
         }
-        return close;
     }
-    return i;
+    if (opener.bracketAfter) return null;
+    const shortcut = defs.get(labelKeyAt(text, opener.at + 1, close));
+    return shortcut === undefined ? null : use(shortcut, end);
 }
 function definitionDestination(text, from, to) {
-    let i = from;
-    while(i < to && (text[i] === ' ' || text[i] === '\t'))i += 1;
-    const match = DESTINATION.exec(text.slice(i, to));
-    if (match === null) return null;
-    const bracketed = match[1];
-    const span = match.indices?.[1] ?? match.indices?.[2];
-    const href = bracketed === undefined ? match[2] : bracketed.slice(1, -1);
-    if (href === undefined || span === undefined) return null;
-    return {
-        href,
-        start: i + span[0],
-        end: i + span[1],
-        bracketed: bracketed !== undefined
-    };
+    const occurrence = destinationAt(text, skipLinkSpace(text, from), to);
+    return occurrence === null || occurrence.href === '' && !occurrence.bracketed ? null : occurrence;
+}
+function titleEnd(text, at, joins) {
+    const open = text[at];
+    if (open !== '"' && open !== "'" && open !== '(') return null;
+    const closed = closeEnd(text, at + 1, open, joins);
+    if (closed === null) return null;
+    const end = endOfLine(text, closed);
+    return BLANK.test(text.slice(closed, end)) ? afterLine(text, end) : null;
 }
-function definitionAt(text, line) {
-    const head = LABEL.exec(lineText(text, line));
-    if (head === null) return null;
-    const id = head[1]?.trim().toLowerCase();
-    if (id === undefined || id === '') return null;
-    const from = line.content + head[0].length;
-    let occurrence = definitionDestination(text, from, line.end);
-    let next = afterLine(text, line.end);
+function definitionAt(text, line, joins) {
+    if (text[line.content] !== '[') return null;
+    const close = referenceEnd(text, line.content + 1, joins);
+    if (close === -1 || text[close] !== ':') return null;
+    const id = labelKeyAt(text, line.content + 1, close - 1);
+    if (id === '') return null;
+    const from = close + 1;
+    let end = endOfLine(text, from);
+    let occurrence = definitionDestination(text, from, end);
     if (occurrence === null) {
-        if (text.slice(from, line.end).trim() !== '' || next >= text.length) return null;
-        const end = endOfLine(text, next);
-        occurrence = definitionDestination(text, readLine(text, next, end).content, end);
+        if (text.slice(from, end).trim() !== '' || !joins.has(end)) return null;
+        const start = end + 1;
+        end = endOfLine(text, start);
+        occurrence = definitionDestination(text, afterIndent(text, readLine(text, start, end)), end);
         if (occurrence === null) return null;
-        next = afterLine(text, end);
     }
-    if (next < text.length) {
-        const end = endOfLine(text, next);
-        if (TITLE.test(lineText(text, readLine(text, next, end)))) next = afterLine(text, end);
+    const rest = text.slice(occurrence.end, end);
+    if (!BLANK.test(rest)) {
+        const gap = GAP.exec(rest);
+        const titled = gap === null ? null : titleEnd(text, occurrence.end + gap[0].length, joins);
+        return titled === null ? null : {
+            id,
+            occurrence,
+            next: titled
+        };
+    }
+    const next = afterLine(text, end);
+    if (joins.has(end)) {
+        const titled = titleEnd(text, afterIndent(text, readLine(text, next, endOfLine(text, next))), joins);
+        if (titled !== null) return {
+            id,
+            occurrence,
+            next: titled
+        };
     }
     return {
         id,
@@ -287,34 +601,19 @@ function endsBlock(content) {
     return HEADING.test(content) || BREAK.test(content) || SETEXT.test(content);
 }
 function scanBlocks(text) {
-    const fences = [];
+    const { joins, raw } = structure(text);
     const definitions = new Map();
     const blocks = [];
-    let paragraph = false;
-    let depth = 0;
+    let fresh = 0;
     let i = 0;
     while(i < text.length){
-        const line = readLine(text, i, endOfLine(text, i));
-        if (line.depth !== depth || line.item) paragraph = false;
-        depth = line.depth;
-        const open = fenceAt(text, line);
-        if (open !== null) {
-            const stop = fenceSpan(text, line, open);
-            fences.push([
-                i,
-                stop
-            ]);
-            paragraph = false;
-            i = stop;
-            continue;
-        }
-        const content = lineText(text, line);
-        if (content.trim() === '') {
-            paragraph = false;
-            i = afterLine(text, line.end);
+        const skip = spanEndAt(raw, i);
+        if (skip !== undefined) {
+            i = skip;
             continue;
         }
-        const definition = paragraph ? null : definitionAt(text, line);
+        const line = readLine(text, i, endOfLine(text, i));
+        const definition = lineText(text, line).trim() === '' || i !== fresh && joins.has(i - 1) ? null : definitionAt(text, line, joins);
         if (definition !== null) {
             if (!definitions.has(definition.id)) definitions.set(definition.id, definition.occurrence);
             blocks.push({
@@ -323,46 +622,128 @@ function scanBlocks(text) {
                 destination: definition.occurrence
             });
             i = definition.next;
+            fresh = i;
             continue;
         }
-        paragraph = !endsBlock(content);
         i = afterLine(text, line.end);
     }
     return {
-        fences,
+        raw,
         definitions,
-        blocks
+        blocks,
+        joins
     };
 }
-function fenceEndAt(spans, index) {
+function spanEndAt(spans, index) {
     for (const [start, end] of spans){
         if (index >= start && index < end) return end;
     }
     return undefined;
 }
 export function fenceSpans(text) {
-    return scanBlocks(text).fences;
+    const fences = [];
+    let i = 0;
+    while(i < text.length){
+        const line = readLine(text, i, endOfLine(text, i));
+        const open = fenceAt(text, line);
+        if (open === null) {
+            i = afterLine(text, line.end);
+            continue;
+        }
+        const stop = fenceSpan(text, line, open);
+        fences.push([
+            i,
+            stop
+        ]);
+        i = stop;
+    }
+    return fences;
+}
+function paragraphEnd(text, from, joins) {
+    let i = from;
+    while(i < text.length){
+        if (text[i] === '\n' && !joins.has(i)) return i;
+        if (text[i] === '\r' && text[i + 1] !== '\n') return i;
+        i += 1;
+    }
+    return i;
 }
 export function linkInventory(body) {
-    const { fences, definitions, blocks } = scanBlocks(body);
+    const { raw, definitions, blocks, joins } = scanBlocks(body);
+    const skipped = [
+        ...raw,
+        ...blocks.map((block)=>[
+                block.start,
+                block.end
+            ])
+    ];
     const uses = [];
+    const openers = [];
+    let paragraph = {
+        start: 0,
+        end: -1,
+        text: ''
+    };
     let i = 0;
     while(i < body.length){
-        const fenceEnd = fenceEndAt(fences, i);
-        if (fenceEnd !== undefined) {
-            i = fenceEnd;
+        const skipEnd = spanEndAt(skipped, i);
+        if (skipEnd !== undefined) {
+            openers.length = 0;
+            i = skipEnd;
             continue;
         }
-        if (body[i] === '`') {
-            i = skipInlineCode(body, i);
+        const ch = body[i];
+        if (escapes(body, i)) {
+            i += 2;
             continue;
         }
-        if (body[i] === '!' && body[i + 1] === '[') {
-            i = takeLink(body, i + 1, i, uses, definitions);
+        if (ch === '`') {
+            i = skipInlineCode(body, i, joins);
+            continue;
+        }
+        if (ch === '<') {
+            if (i >= paragraph.end) {
+                const end = paragraphEnd(body, i, joins);
+                paragraph = {
+                    start: i,
+                    end,
+                    text: body.slice(i, end)
+                };
+            }
+            INLINE_RAW.lastIndex = i - paragraph.start;
+            const raw = INLINE_RAW.exec(paragraph.text);
+            if (raw !== null) {
+                i += raw[0].length;
+                continue;
+            }
+        }
+        if (ch === '\n' && !joins.has(i) || ch === '\r' && body[i + 1] !== '\n') openers.length = 0;
+        if (ch === '[' || ch === '!' && body[i + 1] === '[') {
+            const previous = openers.at(-1);
+            if (previous !== undefined) previous.bracketAfter = true;
+            const image = ch === '!';
+            openers.push({
+                at: image ? i + 1 : i,
+                start: i,
+                image,
+                active: true,
+                bracketAfter: false
+            });
+            i += image ? 2 : 1;
             continue;
         }
-        if (body[i] === '[') {
-            i = takeLink(body, i, i, uses, definitions);
+        if (ch === ']') {
+            const opener = openers.pop();
+            const use = opener?.active ? closeLink(body, opener, i, definitions, joins) : null;
+            if (opener === undefined || use === null) {
+                i += 1;
+                continue;
+            }
+            uses.push(use);
+            if (!opener.image) {
+                for (const earlier of openers)if (!earlier.image) earlier.active = false;
+            }
+            i = use.end;
             continue;
         }
         i += 1;