@agentshouse/mdmodel 0.1.0-alpha.8 → 0.1.0-c04c0d681d2d4

package/dist/links.js

@@ -1,11 +1,34 @@
 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;
@@ -16,16 +39,21 @@ function afterLine(text, end) {
 function itemMarker(text, index, end) {
     let i = index;
     const bullet = text[i];
-    if (bullet === '-' || bullet === '*' || bullet === '+') i += 1;
+    if (bullet === '-' || bullet === '*' || bullet === '+')
+        i += 1;
     else {
         let digits = 0;
-        while(digits < 9 && i + digits < end && text[i + digits] >= '0' && text[i + digits] <= '9')digits += 1;
+        while (digits < 9 && i + digits < end && text[i + digits] >= '0' && text[i + digits] <= '9')
+            digits += 1;
         const delimiter = text[i + digits];
-        if (digits === 0 || delimiter !== '.' && delimiter !== ')') return null;
+        if (digits === 0 || (delimiter !== '.' && delimiter !== ')'))
+            return null;
         i += digits + 1;
     }
-    if (i >= end) return i;
-    if (text[i] !== ' ' && text[i] !== '\t') return null;
+    if (i >= end)
+        return i;
+    if (text[i] !== ' ' && text[i] !== '\t')
+        return null;
     return i + 1;
 }
 function readLine(text, start, end) {
@@ -33,41 +61,38 @@ function readLine(text, start, end) {
     let depth = 0;
     let item = false;
     let inner = start;
-    for(;;){
+    for (;;) {
         let spaces = 0;
-        while(spaces < 3 && i < end && text[i] === ' '){
+        while (spaces < 3 && i < end && text[i] === ' ') {
             i += 1;
             spaces += 1;
         }
         if (i < end && text[i] === '>') {
             depth += 1;
             i += 1;
-            if (i < end && text[i] === ' ') i += 1;
+            if (i < end && text[i] === ' ')
+                i += 1;
             inner = i;
             continue;
         }
         const after = i < end ? itemMarker(text, i, end) : null;
-        if (after === null) break;
+        if (after === null)
+            break;
         item = true;
         i = after;
     }
-    return {
-        start,
-        end,
-        content: i,
-        depth,
-        item,
-        inner
-    };
+    return { start, end, content: i, depth, item, inner };
 }
 function widthOf(text, from, to) {
     let width = 0;
-    for(let i = from; i < to; i += 1)width += text[i] === '\t' ? TAB_STOP - width % TAB_STOP : 1;
+    for (let i = from; i < to; i += 1)
+        width += text[i] === '\t' ? TAB_STOP - (width % TAB_STOP) : 1;
     return width;
 }
 function afterIndent(text, line) {
     let i = line.inner;
-    while(i < line.end && (text[i] === ' ' || text[i] === '\t'))i += 1;
+    while (i < line.end && (text[i] === ' ' || text[i] === '\t'))
+        i += 1;
     return i;
 }
 function indentWidth(text, line) {
@@ -79,302 +104,685 @@ function lineText(text, line) {
 }
 function fenceRun(text, at, end) {
     const char = text[at];
-    if (char !== '`' && char !== '~') return null;
+    if (char !== '`' && char !== '~')
+        return null;
     let length = 0;
-    while(at + length < end && text[at + length] === char)length += 1;
-    return length < 3 ? null : {
-        char,
-        length
-    };
+    while (at + length < end && text[at + length] === char)
+        length += 1;
+    return length < 3 ? null : { char, length };
 }
 function fenceAt(text, line) {
     const run = fenceRun(text, line.content, line.end);
-    if (run === null) return null;
+    if (run === null)
+        return null;
     return {
         char: run.char,
         length: run.length,
         depth: line.depth,
         column: line.item ? widthOf(text, line.inner, line.content) : 0,
-        item: line.item
+        item: line.item,
     };
 }
 function closesFence(text, line, open) {
-    if (line.depth !== open.depth || line.item) return false;
+    if (line.depth !== open.depth || line.item)
+        return false;
     const indent = indentWidth(text, line);
-    if (indent < open.column || indent > open.column + CLOSING_FENCE_INDENT) return false;
+    if (indent < open.column || indent > open.column + CLOSING_FENCE_INDENT)
+        return false;
     const at = afterIndent(text, line);
     const run = fenceRun(text, at, line.end);
-    if (run === null || run.char !== open.char || run.length < open.length) return false;
+    if (run === null || run.char !== open.char || run.length < open.length)
+        return false;
     return text.slice(at + run.length, line.end).trim() === '';
 }
 function leavesContainer(text, line, open) {
-    if (line.depth < open.depth) return true;
-    if (!open.item || lineText(text, line).trim() === '') return false;
+    if (line.depth < open.depth)
+        return true;
+    if (!open.item || lineText(text, line).trim() === '')
+        return false;
     return indentWidth(text, line) < open.column;
 }
 function fenceSpan(text, line, open) {
     let cursor = afterLine(text, line.end);
-    while(cursor < text.length){
+    while (cursor < text.length) {
         const end = endOfLine(text, cursor);
         const next = readLine(text, cursor, end);
-        if (leavesContainer(text, next, open)) return cursor;
-        if (closesFence(text, next, open)) return afterLine(text, end);
+        if (leavesContainer(text, next, open))
+            return cursor;
+        if (closesFence(text, next, open))
+            return afterLine(text, end);
         cursor = afterLine(text, end);
     }
     return text.length;
 }
-function skipInlineCode(text, index) {
+function skipInlineCode(text, index, joins, unclosed) {
     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;
+    while (text[index + ticks] === '`')
+        ticks += 1;
+    if (index < unclosed.stop && (unclosed.runs.get(ticks) ?? -1) <= index)
+        return index + ticks;
+    const runs = new Map();
+    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;
+            runs.set(run, i);
+            i += run;
+            continue;
+        }
+        if (ch === '\r' && text[i + 1] !== '\n')
+            break;
+        if (ch === '\n' && !joins.has(i))
+            break;
+        i += 1;
+    }
+    unclosed.stop = i;
+    unclosed.runs = runs;
+    return index + ticks;
 }
 function skipLinkSpace(text, start) {
     let i = start;
-    while(text[i] === ' ' || text[i] === '\t')i += 1;
+    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;
-    while(i < text.length){
+    let i = start;
+    while (i < text.length) {
         const ch = text[i];
-        if (ch === close) return i + 1;
-        if (ch === '\n' || ch === '\r') return null;
+        if (escapes(text, i)) {
+            i += 2;
+            continue;
+        }
+        if (ch === close)
+            return i + 1;
+        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,
-            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;
-            }
+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 };
+    }
+    let i = at;
+    let depth = 0;
+    while (i < end) {
+        if (escapes(text, i)) {
+            i += 2;
+            continue;
+        }
+        const ch = text[i];
+        if (ch <= ' ' || ch === '\x7f')
+            break;
+        if (ch === '(')
+            depth += 1;
+        else if (ch === ')') {
+            if (depth === 0)
+                break;
+            depth -= 1;
+        }
+        i += 1;
+    }
+    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 = skipInlineSpace(text, afterTitle, joins);
+    if (text[i] !== ')')
+        return null;
+    return { occurrence, end: i + 1 };
+}
+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;
+    for (let level = 0; level < depth; level += 1) {
+        let spaces = 0;
+        while (spaces < 3 && i < end && text[i] === ' ') {
             i += 1;
+            spaces += 1;
         }
-        occurrence = {
-            href: text.slice(from, i),
-            start: from,
-            end: i,
-            bracketed: false
-        };
+        if (text[i] !== '>')
+            return null;
+        i += 1;
+        if (text[i] === ' ')
+            i += 1;
     }
-    i = skipLinkSpace(text, i);
-    const afterTitle = skipTitle(text, i);
-    if (afterTitle === null) return null;
-    i = skipLinkSpace(text, afterTitle);
-    if (text[i] !== ')') return null;
-    return {
-        occurrence,
-        end: 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 };
+}
+export function escapes(text, index) {
+    return text[index] === '\\' && PUNCTUATION.test(text[index + 1] ?? '');
 }
-function labelEnd(text, start) {
+function referenceEnd(text, start, joins) {
     let i = start;
-    let depth = 1;
-    while(i < text.length && depth > 0){
+    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 dest.end;
+    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);
     }
-    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
-            });
+    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,
+    });
+    if (text[end] === '(') {
+        const dest = destination(text, end, joins);
+        if (dest !== null)
+            return use(dest.occurrence, dest.end);
+    }
+    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 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 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, 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 (occurrence === null) return null;
-        next = afterLine(text, 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;
     }
-    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 };
     }
-    return {
-        id,
-        occurrence,
-        next
-    };
+    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, occurrence, next };
 }
 function endsBlock(content) {
     return HEADING.test(content) || BREAK.test(content) || SETEXT.test(content);
 }
 function scanBlocks(text) {
-    const fences = [];
+    const { joins, raw } = structure(text);
+    const rawEnd = spanCursor(raw);
     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);
+    while (i < text.length) {
+        const skip = rawEnd(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({
-                start: line.start,
-                end: definition.next,
-                destination: definition.occurrence
-            });
+            if (!definitions.has(definition.id))
+                definitions.set(definition.id, definition.occurrence);
+            blocks.push({ start: line.start, end: definition.next, destination: definition.occurrence });
             i = definition.next;
+            fresh = i;
             continue;
         }
-        paragraph = !endsBlock(content);
         i = afterLine(text, line.end);
     }
-    return {
-        fences,
-        definitions,
-        blocks
+    return { raw, definitions, blocks, joins };
+}
+export function spanCursor(spans) {
+    let next = 0;
+    return (index) => {
+        while (next < spans.length && spans[next][1] <= index)
+            next += 1;
+        const span = spans[next];
+        return span !== undefined && span[0] <= index ? span[1] : undefined;
     };
 }
-function fenceEndAt(spans, index) {
-    for (const [start, end] of spans){
-        if (index >= start && index < end) return end;
+export function fenceSpans(text) {
+    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 undefined;
+    return i;
 }
 export function linkInventory(body) {
-    const { fences, definitions, blocks } = scanBlocks(body);
+    const { raw, definitions, blocks, joins } = scanBlocks(body);
+    const rawEnd = spanCursor(raw);
+    const blockEnd = spanCursor(blocks.map((block) => [block.start, block.end]));
     const uses = [];
+    const openers = [];
+    const unclosed = { stop: 0, runs: new Map() };
+    let paragraph = { start: 0, end: -1, text: '' };
     let i = 0;
-    while(i < body.length){
-        const fenceEnd = fenceEndAt(fences, i);
-        if (fenceEnd !== undefined) {
-            i = fenceEnd;
+    while (i < body.length) {
+        const skipEnd = rawEnd(i) ?? blockEnd(i);
+        if (skipEnd !== undefined) {
+            openers.length = 0;
+            i = skipEnd;
+            continue;
+        }
+        const ch = body[i];
+        if (escapes(body, i)) {
+            i += 2;
             continue;
         }
-        if (body[i] === '`') {
-            i = skipInlineCode(body, i);
+        if (ch === '`') {
+            i = skipInlineCode(body, i, joins, unclosed);
             continue;
         }
-        if (body[i] === '!' && body[i + 1] === '[') {
-            i = takeLink(body, i + 1, i, uses, definitions);
+        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;
     }
-    return {
-        uses,
-        blocks
-    };
+    return { uses, blocks };
 }
-export function hrefOccurrences(body) {
+export function destinations(inventory) {
     const byStart = new Map();
-    for (const use of linkInventory(body).uses)byStart.set(use.destination.start, use.destination);
-    return [
-        ...byStart.values()
-    ].sort((left, right)=>left.start - right.start);
+    for (const use of inventory.uses)
+        byStart.set(use.destination.start, use.destination);
+    return [...byStart.values()].sort((left, right) => left.start - right.start);
+}
+export function hrefOccurrences(body) {
+    return destinations(linkInventory(body));
 }
-
-//# sourceMappingURL=links.js.map