@geml/geml 1.7.8 → 1.8.2

package/dist/inline.js

@@ -72,41 +72,57 @@ function classifyDest(dest) {
         return { doc: d };
     return {};
 }
+function pairsOf(s) {
+    const br = new Int32Array(s.length).fill(-1);
+    const pa = new Int32Array(s.length).fill(-1);
+    const bs = [], ps = [];
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === "[")
+            bs.push(i);
+        else if (c === "]") {
+            const j = bs.pop();
+            if (j !== undefined)
+                br[j] = i;
+        }
+        else if (c === "(")
+            ps.push(i);
+        else if (c === ")") {
+            const j = ps.pop();
+            if (j !== undefined)
+                pa[j] = i;
+        }
+    }
+    return { br, pa, off: 0 };
+}
+// A link label is a bracket-balanced span, so the map restricted to it IS the
+// map of the substring — the maps are built ONCE for the whole inline and read
+// through an offset by every nesting level, rather than rebuilt per level (which
+// at the 100-deep cap would have multiplied a 1 MB line's map memory by 100).
+// A partner falling outside the window means "unbalanced here", which is what
+// the substring-local scan reported.
+function pairEnd(m, p, s, i) {
+    const j = m[p.off + i];
+    if (j === undefined || j < 0)
+        return -1;
+    const end = j - p.off;
+    return end < s.length ? end : -1;
+}
 // Read a balanced `(...)` starting at s[i]==='('. Returns content and index
 // just past the closing ')', or null if unbalanced.
-function readParen(s, i) {
+function readParen(s, i, p) {
     if (s[i] !== "(")
         return null;
-    let depth = 0;
-    for (let j = i; j < s.length; j++) {
-        const c = s[j];
-        if (c === "(")
-            depth++;
-        else if (c === ")") {
-            depth--;
-            if (depth === 0)
-                return { content: s.slice(i + 1, j), end: j + 1 };
-        }
-    }
-    return null;
+    const j = pairEnd(p.pa, p, s, i);
+    return j < 0 ? null : { content: s.slice(i + 1, j), end: j + 1 };
 }
 // Read a balanced `[...]` starting at s[i]==='['. Returns content and index
 // just past the closing ']', or null if unbalanced.
-function readBracket(s, i) {
+function readBracket(s, i, p) {
     if (s[i] !== "[")
         return null;
-    let depth = 0;
-    for (let j = i; j < s.length; j++) {
-        const c = s[j];
-        if (c === "[")
-            depth++;
-        else if (c === "]") {
-            depth--;
-            if (depth === 0)
-                return { content: s.slice(i + 1, j), end: j + 1 };
-        }
-    }
-    return null;
+    const j = pairEnd(p.br, p, s, i);
+    return j < 0 ? null : { content: s.slice(i + 1, j), end: j + 1 };
 }
 // Optional `{…}` attribute object immediately following a construct.
 function readAttrs(s, i) {
@@ -120,13 +136,18 @@ function readAttrs(s, i) {
 // Phase A: pull out high-priority atoms (escapes, code, math, media, links,
 // auto-refs, footnotes, hard breaks). Everything else is left as text runs for
 // phase B (emphasis). Children of links are fully re-parsed.
-function scanAtoms(s, line, sink, depth = 0) {
+function scanAtoms(s, line, sink, depth, p) {
     const out = [];
     let buf = "";
     const flush = () => { if (buf) {
         out.push(buf);
         buf = "";
     } };
+    // Emit `node` as the atom occupying source span [start, end).
+    const atom = (node, start, end) => {
+        flush();
+        out.push({ node, first: s[start], last: s[end - 1] });
+    };
     let i = 0;
     while (i < s.length) {
         const c = s[i];
@@ -134,16 +155,15 @@ function scanAtoms(s, line, sink, depth = 0) {
         if (c === "\\") {
             const next = s[i + 1];
             if (next === undefined || next === "\n") { // line-final backslash
-                flush();
-                out.push({ type: "break" });
-                i += next === undefined ? 1 : 2;
+                const end = i + (next === undefined ? 1 : 2);
+                atom({ type: "break" }, i, end);
+                i = end;
                 continue;
             }
             if (/[!-/:-@[-`{-~]/.test(next)) {
                 // ASCII punctuation -> literal, emitted as its own text atom so phase B
                 // (emphasis) cannot mistake an escaped `*`/`~` for a delimiter (§5.3(1)).
-                flush();
-                out.push({ type: "text", value: next });
+                atom({ type: "text", value: next }, i, i + 2);
                 i += 2;
                 continue;
             }
@@ -159,8 +179,7 @@ function scanAtoms(s, line, sink, depth = 0) {
             const fence = "`".repeat(n);
             const close = s.indexOf(fence, i + n);
             if (close >= 0) {
-                flush();
-                out.push({ type: "code", value: s.slice(i + n, close) });
+                atom({ type: "code", value: s.slice(i + n, close) }, i, close + n);
                 i = close + n;
                 continue;
             }
@@ -172,8 +191,7 @@ function scanAtoms(s, line, sink, depth = 0) {
         if (c === "$") {
             const close = s.indexOf("$", i + 1);
             if (close > i + 1) {
-                flush();
-                out.push({ type: "math", value: s.slice(i + 1, close) });
+                atom({ type: "math", value: s.slice(i + 1, close) }, i, close + 1);
                 i = close + 1;
                 continue;
             }
@@ -187,15 +205,14 @@ function scanAtoms(s, line, sink, depth = 0) {
         // `![[#x]](y)` would be claimed whole — the parenthesis run has to stay
         // literal text, which is what this ordering pins.
         if (c === "!" && s[i + 1] === "[" && s[i + 2] === "[") {
-            const inner = readBracket(s, i + 2); // the inner [...] after `![`
+            const inner = readBracket(s, i + 2, p); // the inner [...] after `![`
             if (inner && s[inner.end] === "]") {
                 const { doc, anchor } = classifyDest(inner.content.trim());
                 if (anchor) {
-                    flush();
                     const node = { type: "project", anchor };
                     if (doc)
                         node.doc = doc;
-                    out.push(node);
+                    atom(node, i, inner.end + 1);
                     // Validated by the same §8 resolver as any reference; the target's TYPE
                     // is checked separately, since only inline content can be projected.
                     sink.refs.push({ kind: doc ? "cross" : "autoref", doc, anchor, line });
@@ -206,8 +223,8 @@ function scanAtoms(s, line, sink, depth = 0) {
             }
         }
         if (c === "!" && s[i + 1] === "[") {
-            const label = readBracket(s, i + 1);
-            const paren = label ? readParen(s, label.end) : null;
+            const label = readBracket(s, i + 1, p);
+            const paren = label ? readParen(s, label.end, p) : null;
             if (label && paren) {
                 const a = readAttrs(s, paren.end);
                 const attrObj = a ? a.attrs : { classes: [], attrs: {} };
@@ -232,24 +249,22 @@ function scanAtoms(s, line, sink, depth = 0) {
                     if (inf)
                         node.as = inf;
                 }
-                flush();
-                out.push(node);
+                atom(node, i, a ? a.end : paren.end);
                 i = a ? a.end : paren.end;
                 continue;
             }
         }
         // §5.3(2): auto-reference [[#id]].
         if (c === "[" && s[i + 1] === "[") {
-            const inner = readBracket(s, i + 1); // inner [...] after the first [
+            const inner = readBracket(s, i + 1, p); // inner [...] after the first [
             if (inner && s[inner.end] === "]") {
                 const target = inner.content.trim();
                 const { doc, anchor } = classifyDest(target);
                 if (anchor) {
-                    flush();
                     const node = { type: "autoref", anchor };
                     if (doc)
                         node.doc = doc;
-                    out.push(node);
+                    atom(node, i, inner.end + 1);
                     sink.refs.push({ kind: doc ? "cross" : "autoref", doc, anchor, line });
                     i = inner.end + 1;
                     continue;
@@ -258,11 +273,10 @@ function scanAtoms(s, line, sink, depth = 0) {
         }
         // §5.3(2): footnote reference [^id].
         if (c === "[" && s[i + 1] === "^") {
-            const br = readBracket(s, i);
+            const br = readBracket(s, i, p);
             if (br && br.content.startsWith("^")) {
                 const ref = br.content.slice(1).trim();
-                flush();
-                out.push({ type: "footnote", ref });
+                atom({ type: "footnote", ref }, i, br.end);
                 sink.refs.push({ kind: "footnote", anchor: ref, line });
                 i = br.end;
                 continue;
@@ -270,15 +284,17 @@ function scanAtoms(s, line, sink, depth = 0) {
         }
         // §5.3(2): link [text](dest){…}.
         if (c === "[") {
-            const label = readBracket(s, i);
-            const paren = label ? readParen(s, label.end) : null;
+            const label = readBracket(s, i, p);
+            const paren = label ? readParen(s, label.end, p) : null;
             if (label && paren) {
                 const a = readAttrs(s, paren.end);
                 const attrObj = a ? a.attrs : { classes: [], attrs: {} };
                 const dest = classifyDest(paren.content);
                 const node = {
                     type: "link",
-                    children: parseInline(label.content, line, sink, depth + 1),
+                    // The label window starts one character past this `[`, so the shared
+                    // maps are read at that offset instead of being rebuilt for it.
+                    children: parseInline(label.content, line, sink, depth + 1, { br: p.br, pa: p.pa, off: p.off + i + 1 }),
                     attrs: attrObj.attrs,
                 };
                 if (dest.href)
@@ -290,8 +306,7 @@ function scanAtoms(s, line, sink, depth = 0) {
                 if (dest.anchor || dest.doc) {
                     sink.refs.push({ kind: dest.doc ? "cross" : "internal", doc: dest.doc, anchor: dest.anchor, line });
                 }
-                flush();
-                out.push(node);
+                atom(node, i, a ? a.end : paren.end);
                 i = a ? a.end : paren.end;
                 continue;
             }
@@ -302,19 +317,23 @@ function scanAtoms(s, line, sink, depth = 0) {
     flush();
     return out;
 }
-// Phase B: emphasis / strong / strikethrough on a plain text run (§5.3).
+// Phase B: emphasis / strong / strikethrough over the whole inline sequence
+// (§5.3, GEP-0007).
 //
-// A maximal run of `*` is an emphasis delimiter (one `*` -> emphasis, two ->
-// strong, longer runs pair greedily); a maximal run of two or more `~` is a
-// strikethrough delimiter (a lone `~` is literal). Whether a run may *open*
-// and/or *close* is fixed by flanking: it must hug a non-space character, and on
-// the side facing a punctuation character it must also have whitespace or
-// punctuation on the far side (the CommonMark left/right-flanking rule). Runs are
-// then paired by a single left-to-right stack scan with the rule of three, so
-// nested and adjacent delimiters resolve to exactly one tree — no leftmost-regex
-// guesswork. Delimiters pair only *within* one text run: they never reach across
-// a code span, inline math, a link or image (atoms from phase A), or a block
-// boundary. Any delimiter left unpaired is literal text.
+// A maximal run of `*` in literal text is an emphasis delimiter (one `*` ->
+// emphasis, two -> strong, longer runs pair greedily); a maximal run of two or
+// more `~` is a strikethrough delimiter (a lone `~` is literal). Whether a run
+// may *open* and/or *close* is fixed by flanking: it must hug a non-space
+// character, and on the side facing a punctuation character it must also have
+// whitespace or punctuation on the far side (the CommonMark left/right-flanking
+// rule). Runs are then paired by a single left-to-right stack scan with the
+// rule of three, so nested and adjacent delimiters resolve to exactly one tree
+// — no leftmost-regex guesswork. Delimiters pair across phase-A atoms — a pair
+// may wrap a code span, math, a link or image — but the atoms themselves are
+// opaque: characters inside one are never delimiters, and at an atom boundary
+// the flanking test reads the atom's edge source characters (AtomPart). A
+// delimiter run never pairs across a block boundary, and any run left unpaired
+// is literal text.
 // Unicode punctuation, not just ASCII (§5.3). With an ASCII-only test, `“` and
 // `，` count as ordinary letters, and a run hugged by CJK punctuation on the
 // outside and ASCII punctuation on the inside stops flanking: `“*(foo)*”` loses
@@ -328,45 +347,68 @@ function flank(before, after) {
     const bWS = isWS(before), aWS = isWS(after), bP = isPunct(before), aP = isPunct(after);
     return { open: !aWS && (!aP || bWS || bP), close: !bWS && (!bP || aWS || aP) };
 }
-// Split a text run into a doubly-linked list of text and delimiter-run nodes.
-function tokenizeRuns(s) {
+// Split the mixed phase-A sequence into a doubly-linked list of text,
+// delimiter-run, and atom nodes. A delimiter run at the edge of a text part
+// flanks against the neighboring part's edge character — an atom's recorded
+// source edge, or the adjacent char of a neighboring text part — and against
+// nothing (whitespace) at the ends of the sequence.
+function tokenizeRuns(parts) {
     let head = null, tail = null;
     const push = (node) => { node.prev = tail; if (tail)
         tail.next = node;
     else
         head = node; tail = node; };
-    let i = 0;
-    while (i < s.length) {
-        const c = s[i];
-        if (c === "*" || c === "~") {
-            let j = i;
-            while (s[j] === c)
-                j++;
-            const n = j - i;
-            if (c === "~" && n < 2)
-                push({ t: "text", v: "~", prev: null, next: null });
+    // …and thread every delimiter onto the delimiter-only chain as it is pushed.
+    let dhead = null, dtail = null, dn = 0;
+    const pushDelim = (d) => {
+        d.idx = dn++;
+        d.dprev = dtail;
+        if (dtail)
+            dtail.dnext = d;
+        else
+            dhead = d;
+        dtail = d;
+        push(d);
+    };
+    for (let k = 0; k < parts.length; k++) {
+        const part = parts[k];
+        if (typeof part !== "string") {
+            push({ t: "atom", node: part.node, prev: null, next: null });
+            continue;
+        }
+        const s = part;
+        // A text part's neighbors are always atoms (or the sequence edge):
+        // scanAtoms flushes buffered text exactly when it emits an atom, so two
+        // text parts are never adjacent.
+        const before0 = k > 0 ? parts[k - 1].last : undefined;
+        const after0 = k + 1 < parts.length ? parts[k + 1].first : undefined;
+        let i = 0;
+        while (i < s.length) {
+            const c = s[i];
+            if (c === "*" || c === "~") {
+                let j = i;
+                while (s[j] === c)
+                    j++;
+                const n = j - i;
+                if (c === "~" && n < 2)
+                    push({ t: "text", v: "~", prev: null, next: null });
+                else {
+                    const f = flank(i > 0 ? s[i - 1] : before0, j < s.length ? s[j] : after0);
+                    pushDelim({ t: "delim", ch: c, n, open: f.open, close: f.close, idx: 0, dprev: null, dnext: null, prev: null, next: null });
+                }
+                i = j;
+            }
             else {
-                const f = flank(i > 0 ? s[i - 1] : undefined, j < s.length ? s[j] : undefined);
-                push({ t: "delim", ch: c, n, open: f.open, close: f.close, prev: null, next: null });
+                let j = i;
+                while (j < s.length && s[j] !== "*" && s[j] !== "~")
+                    j++;
+                push({ t: "text", v: s.slice(i, j), prev: null, next: null });
+                i = j;
             }
-            i = j;
-        }
-        else {
-            let j = i;
-            while (j < s.length && s[j] !== "*" && s[j] !== "~")
-                j++;
-            push({ t: "text", v: s.slice(i, j), prev: null, next: null });
-            i = j;
         }
     }
-    return head;
+    return { head, first: dhead };
 }
-const nextDelim = (n) => { for (; n; n = n.next)
-    if (n.t === "delim")
-        return n; return null; };
-const prevDelim = (n) => { for (; n; n = n.prev)
-    if (n.t === "delim")
-        return n; return null; };
 // Rule of three: when either side can also play the other role, a combined
 // length that is a multiple of three is only allowed if both lengths are.
 function rule3(o, c) {
@@ -374,6 +416,18 @@ function rule3(o, c) {
         return (o.n + c.n) % 3 !== 0 || (o.n % 3 === 0 && c.n % 3 === 0);
     return true;
 }
+// Drop a delimiter from the delimiter-only chain. Called for a spent delimiter
+// and for every delimiter that a new wrap swallows: the chain must hold exactly
+// the delimiters still pairable AT THIS LEVEL, or an opener search would reach
+// inside a finished span and splice its own list.
+function unlinkDelim(d) {
+    if (d.dprev)
+        d.dprev.dnext = d.dnext;
+    if (d.dnext)
+        d.dnext.dprev = d.dprev;
+    d.dprev = null;
+    d.dnext = null;
+}
 function unlink(node, head) {
     if (node.prev)
         node.prev.next = node.next;
@@ -381,38 +435,58 @@ function unlink(node, head) {
         head = node.next;
     if (node.next)
         node.next.prev = node.prev;
+    if (node.t === "delim")
+        unlinkDelim(node);
     return head;
 }
 // The CommonMark emphasis algorithm over the delimiter list: scan closers left
 // to right, pair each with the nearest eligible opener, wrap the span, and bound
 // future searches with `bottom` so the scan stays linear and deterministic.
-function processEmphasis(head) {
+function processEmphasis(head, first) {
+    // The cut-off is a delimiter POSITION, not a node: the delimiter it names can
+    // be consumed and unlinked later on, and a stale node reference would then
+    // never be reached — the search would run to the head of the list every time,
+    // which is the O(n^2) blowup this map exists to prevent. -1 means "no bound
+    // yet" (the whole prefix is searchable), matching an unset entry.
     const bottom = new Map();
-    let closer = nextDelim(head);
+    let closer = first;
     while (closer) {
-        if (closer.t !== "delim" || !closer.close) {
-            closer = nextDelim(closer.next);
+        // A `~` run pairs TWO characters at a time, so one leftover character is no
+        // longer a delimiter — exactly as a lone `~` was never one (tokenizeRuns).
+        // Skipping it here is what keeps `n` from going negative: pairing a spent run
+        // again drove `n` past 0, and since the loop only advances on `n === 0` the
+        // same closer was re-paired forever, allocating a wrap each time (a hang on
+        // `~~~a~~~`) or reaching finalize with n = -1 (`"~".repeat(-1)` threw a
+        // RangeError on `~~~~a~~~`).
+        if (!closer.close || (closer.ch === "~" && closer.n < 2)) {
+            closer = closer.dnext;
             continue;
         }
         const ch = closer.ch;
         const key = `${ch}${closer.open ? 1 : 0}${closer.n % 3}`;
-        const stop = bottom.has(key) ? bottom.get(key) : null;
-        let opener = prevDelim(closer.prev);
+        const stop = bottom.get(key) ?? -1;
+        let opener = closer.dprev;
         let found = null;
-        while (opener && opener !== stop) {
-            if (opener.t === "delim" && opener.open && opener.ch === ch && rule3(opener, closer)) {
+        while (opener && opener.idx > stop) {
+            // …and the same for the opener side: a `~` run down to one character can
+            // no longer open, so `use = 2` never takes more than a side has left.
+            if (opener.open && opener.ch === ch && (ch !== "~" || opener.n >= 2) && rule3(opener, closer)) {
                 found = opener;
                 break;
             }
-            opener = prevDelim(opener.prev);
+            opener = opener.dprev;
         }
         if (found) {
             const use = ch === "~" ? 2 : (found.n >= 2 && closer.n >= 2 ? 2 : 1);
             const kind = ch === "~" ? "strike" : use === 2 ? "strong" : "emph";
-            // Gather and detach the nodes strictly between opener and closer.
+            // Gather and detach the nodes strictly between opener and closer. Any
+            // delimiter among them is now inside the new span — unpaired and literal —
+            // so it leaves the delimiter chain with them.
             let kidsHead = null, kidsTail = null;
             for (let p = found.next; p && p !== closer;) {
                 const q = p.next;
+                if (p.t === "delim")
+                    unlinkDelim(p);
                 p.prev = kidsTail;
                 p.next = null;
                 if (kidsTail)
@@ -430,21 +504,25 @@ function processEmphasis(head) {
             if (found.n === 0)
                 head = unlink(found, head);
             if (closer.n === 0) {
-                const after = closer.next;
+                const after = closer.dnext;
                 head = unlink(closer, head);
-                closer = nextDelim(after);
+                closer = after;
             }
             // else: keep the same closer (it still has delimiter characters left).
         }
         else {
-            bottom.set(key, closer.prev);
-            closer = nextDelim(closer.next);
+            // Nothing before this closer can open for this key, so no later closer
+            // with the same key need look past the delimiter just before it either.
+            bottom.set(key, closer.dprev ? closer.dprev.idx : -1);
+            closer = closer.dnext;
         }
     }
     return head;
 }
 // Linked list of (possibly nested) nodes -> Inline[]; unpaired delimiters and
-// empty text vanish into literal text, with adjacent text runs merged.
+// empty text vanish into literal text, with adjacent text runs merged. An
+// escaped-punctuation atom is a text Inline, so it folds into its neighbors —
+// the emitted sequence is canonical with no adjacent text nodes at any level.
 function finalize(head) {
     const out = [];
     const pushText = (v) => {
@@ -459,29 +537,25 @@ function finalize(head) {
             pushText(n.v);
         else if (n.t === "delim")
             pushText(n.ch.repeat(n.n));
+        else if (n.t === "atom") {
+            if (n.node.type === "text")
+                pushText(n.node.value);
+            else
+                out.push(n.node);
+        }
         else
             out.push({ type: n.kind, children: finalize(n.kids) });
     }
     return out;
 }
-function emphasize(text) {
-    const head = tokenizeRuns(text);
-    return head ? finalize(processEmphasis(head)) : [];
-}
-// Coalesce adjacent literal text nodes (e.g. an escaped `*` atom sitting between
-// two text runs) so the inline sequence is canonical.
-function mergeText(ns) {
-    const out = [];
-    for (const n of ns) {
-        const last = out[out.length - 1];
-        if (n.type === "text" && last && last.type === "text")
-            last.value += n.value;
-        else
-            out.push(n);
-    }
-    return out;
+function emphasize(parts) {
+    const { head, first } = tokenizeRuns(parts);
+    return head ? finalize(processEmphasis(head, first)) : [];
 }
-export function parseInline(s, line, sink, depth = 0) {
+// `pairs` is internal: the bracket/paren partner maps of the WHOLE inline, with
+// the offset of this call's window into them. Only the recursive link-label call
+// supplies it; every external caller omits it and gets the maps built here.
+export function parseInline(s, line, sink, depth = 0, pairs) {
     if (depth > MAX_INLINE_NESTING) {
         // Pathological nesting (thousands of nested link labels) would overflow the
         // call stack (R2-7). Degrade the over-deep content to text — emphasis only,
@@ -489,15 +563,7 @@ export function parseInline(s, line, sink, depth = 0) {
         const diags = sink.diags;
         if (Array.isArray(diags) && !diags.some((d) => d.code === "inline-nesting-too-deep"))
             diags.push({ severity: "error", code: "inline-nesting-too-deep", message: `inline nesting too deep (max ${MAX_INLINE_NESTING})`, line });
-        return mergeText(emphasize(s));
-    }
-    const atoms = scanAtoms(s, line, sink, depth);
-    const out = [];
-    for (const a of atoms) {
-        if (typeof a === "string")
-            out.push(...emphasize(a));
-        else
-            out.push(a);
+        return emphasize([s]);
     }
-    return mergeText(out);
+    return emphasize(scanAtoms(s, line, sink, depth, pairs ?? pairsOf(s)));
 }