@fro.bot/wiki-write-core 0.1.2 → 0.1.4

package/dist/code-regions.js

@@ -88,6 +88,8 @@ export function findRegionAt(regions, offset) {
 }
 function findInlineSpans(line) {
     const spans = [];
+    // Where each length of backtick run starts on this line, built when the first opener needs it.
+    let runStartsByLength;
     let index = 0;
     while (index < line.length) {
         const character = line[index];
@@ -101,30 +103,47 @@ function findInlineSpans(line) {
         }
         const openEnd = skipBackticks(line, index);
         const runLength = openEnd - index;
-        let searchFrom = openEnd;
-        let closeEnd = -1;
-        while (searchFrom < line.length) {
-            const closeStart = line.indexOf('`', searchFrom);
-            if (closeStart === -1) {
-                break;
-            }
-            const candidateEnd = skipBackticks(line, closeStart);
-            if (candidateEnd - closeStart === runLength) {
-                closeEnd = candidateEnd;
-                break;
-            }
-            searchFrom = candidateEnd;
-        }
-        if (closeEnd === -1) {
+        runStartsByLength ??= indexBacktickRuns(line);
+        // The closer is the first later run of exactly the opener's length. Openers only move forward, so each
+        // length's cursor does too, and every run is passed over at most once.
+        const closeStart = nextRunAtOrAfter(runStartsByLength.get(runLength), openEnd);
+        if (closeStart === undefined) {
             index = openEnd;
         }
         else {
+            const closeEnd = closeStart + runLength;
             spans.push({ start: index, end: closeEnd });
             index = closeEnd;
         }
     }
     return spans;
 }
+/** The start offsets of the maximal backtick runs of `line`, grouped by the length of the run. */
+function indexBacktickRuns(line) {
+    const runStartsByLength = new Map();
+    for (let start = line.indexOf('`'); start !== -1;) {
+        const end = skipBackticks(line, start);
+        const runs = runStartsByLength.get(end - start);
+        if (runs === undefined) {
+            runStartsByLength.set(end - start, { starts: [start], next: 0 });
+        }
+        else {
+            runs.starts.push(start);
+        }
+        start = line.indexOf('`', end);
+    }
+    return runStartsByLength;
+}
+/** The first run start at least `minimum`. Callers ask with increasing `minimum`, so the cursor only advances. */
+function nextRunAtOrAfter(runs, minimum) {
+    if (runs === undefined) {
+        return undefined;
+    }
+    while (runs.next < runs.starts.length && (runs.starts[runs.next] ?? minimum) < minimum) {
+        runs.next += 1;
+    }
+    return runs.starts[runs.next];
+}
 function skipBackticks(line, from) {
     let index = from;
     while (line[index] === '`') {

package/dist/corrections-survival.d.ts

@@ -30,6 +30,12 @@ export declare function normalizeFormattingText(value: string): string;
  * Masks markdown inline links `[label](url)` to spaces so exact prose matching ignores link
  * targets; wiki links `[[...]]` are left untouched (module docstring). A regex port was proven
  * non-equivalent by exhaustive differential testing (corrections-survival.test.ts), so this
- * scanner stays; its directived lines are deterministic hangs under mutation, not timing noise.
+ * stays a scanner.
+ *
+ * At each `]` that is followed by `(` and preceded by a `[`, the link runs from the last `[` to the
+ * `)` that closes that `(`, counting nested parentheses. A `(` with no closing `)` is not a link,
+ * and the scan goes on from the next character. After a link, the scan resumes past its `)` with no
+ * `[` open. The closing `)` of every `(` is found once, up front, so the scan is linear in the
+ * length of the content.
  */
 export declare function maskMarkdownLinks(content: string): string;

package/dist/corrections-survival.js

@@ -1,5 +1,6 @@
 import { normalizeCorrectionText } from "./correction-text.js";
 import { assertCorrectionsFile, getCorrectionLifecycle, } from "./corrections.js";
+import { replaceLinkLabels } from "./link-labels.js";
 import { maskNonProseContent } from "./rendering-policy.js";
 import { collectWikiPages } from "./wiki-utils.js";
 /**
@@ -94,21 +95,18 @@ export function verifyCorrectionSurvival(files, corrections, fallbackFiles = {})
  * the pre-refactor reference implementation.
  */
 export function normalizeFormattingText(value) {
-    const markdownLinkPattern = /!?(?:\[([^\]]*)\]\([^)]*\)|\[\[([^\]|]+)(?:\|([^\]]+))?\]\])/gu;
-    return (value
-        .normalize('NFKC')
-        .replaceAll(markdownLinkPattern, renderVisibleLinkText)
+    return (replaceLinkLabels(value.normalize('NFKC'), renderVisibleLinkText)
         // `\s+` below absorbs any run this leaves; a `+` here would be unobservable.
         .replaceAll(/[^\p{L}\p{N}]/gu, ' ')
         .trim()
         .replaceAll(/\s+/gu, ' ')
         .toLowerCase());
 }
-function renderVisibleLinkText(_match, markdownText, wikiTarget, wikiLabel) {
-    // markdownLinkPattern's outer alternation guarantees exactly one branch matched whenever this
-    // callback runs: the markdown branch always captures markdownText (possibly '', never
-    // undefined), and the wiki branch always captures wikiTarget (required, 1+ chars). A final
-    // '' fallback covering "neither captured" is unreachable -- asserted, not defaulted.
+function renderVisibleLinkText({ markdownText, wikiTarget, wikiLabel }) {
+    // replaceLinkLabels calls this with exactly one branch matched: the markdown branch always has
+    // markdownText (possibly '', never undefined), and the wiki branch always has wikiTarget
+    // (required, 1+ chars). A final '' fallback covering "neither captured" is unreachable --
+    // asserted, not defaulted.
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see comment above
     return (markdownText ?? wikiLabel ?? wikiTarget);
 }
@@ -116,45 +114,54 @@ function renderVisibleLinkText(_match, markdownText, wikiTarget, wikiLabel) {
  * Masks markdown inline links `[label](url)` to spaces so exact prose matching ignores link
  * targets; wiki links `[[...]]` are left untouched (module docstring). A regex port was proven
  * non-equivalent by exhaustive differential testing (corrections-survival.test.ts), so this
- * scanner stays; its directived lines are deterministic hangs under mutation, not timing noise.
+ * stays a scanner.
+ *
+ * At each `]` that is followed by `(` and preceded by a `[`, the link runs from the last `[` to the
+ * `)` that closes that `(`, counting nested parentheses. A `(` with no closing `)` is not a link,
+ * and the scan goes on from the next character. After a link, the scan resumes past its `)` with no
+ * `[` open. The closing `)` of every `(` is found once, up front, so the scan is linear in the
+ * length of the content.
  */
 export function maskMarkdownLinks(content) {
-    const masked = content.split('');
+    const characters = content.split('');
+    const closers = findClosingParentheses(characters);
+    const masked = [...characters];
     let open = -1;
-    let index = 0;
-    // Stryker disable next-line BlockStatement,EqualityOperator: BlockStatement mutation destroys mandatory loop progress (deterministic hang, not a timing artifact); EqualityOperator's >= variant hangs on empty content (0 >= 0 is true, index only grows, so it never becomes false again) and its <= variant only extends the loop to content[content.length], which is always undefined and has no side effect on open/masked/depth
-    while (index < content.length) {
-        if (content[index] === '[')
+    let resumeAt = 0;
+    for (const [index, character] of characters.entries()) {
+        if (index < resumeAt)
+            continue;
+        if (character === '[')
             open = index;
-        if (content[index] === ']' && content[index + 1] === '(' && open !== -1) {
-            let close = index + 2;
-            let depth = 1;
-            // Split from the original `close < content.length && depth > 0` combined condition so
-            // each half's mutants land on their own line; the `depth <= 0` check below is bounded by
-            // this while's own `close < content.length`, so its mutants are not a hang, just wrong
-            // output, and are killed by the differential test like any other behavior change.
-            // Stryker disable next-line BlockStatement,EqualityOperator: BlockStatement mutation destroys mandatory loop progress (deterministic hang, not a timing artifact); EqualityOperator's >= variant hangs when close starts at or past content.length (a link's `](` at the very end of the string) for the same reason as the outer loop above, and its <= variant only extends the loop to content[content.length], which is always undefined and has no side effect on open/masked/depth
-            while (close < content.length) {
-                if (depth <= 0)
-                    break;
-                if (content[close] === '(')
-                    depth += 1;
-                else if (content[close] === ')')
-                    depth -= 1;
-                // Stryker disable next-line AssignmentOperator: mutation destroys mandatory loop progress; deterministic hang, not a timing artifact
-                close += 1;
-            }
-            if (depth === 0) {
-                // Stryker disable next-line AssignmentOperator: mutation destroys mandatory loop progress; deterministic hang, not a timing artifact
-                for (let maskIndex = open; maskIndex < close; maskIndex += 1)
-                    masked[maskIndex] = ' ';
-                index = close;
+        if (character === ']' && open !== -1) {
+            // `closers` has an entry only for a `(`, so the next character is a `(` with a closer or there is no link.
+            const close = closers.get(index + 1);
+            if (close !== undefined) {
+                masked.fill(' ', open, close + 1);
+                resumeAt = close + 1;
                 open = -1;
-                continue;
             }
         }
-        // Stryker disable next-line AssignmentOperator: mutation destroys mandatory loop progress; deterministic hang, not a timing artifact
-        index += 1;
     }
     return masked.join('');
 }
+/**
+ * Maps the index of each `(` to the index of the `)` that closes it, counting nested parentheses,
+ * or to `undefined` when nothing closes it. Read from the right, each `(` takes the nearest `)`
+ * that no `(` between them has taken, which pairs the same parentheses as counting depth to the
+ * right of each `(`. A `)` with no `(` before it is left unpaired and never looked up.
+ */
+function findClosingParentheses(characters) {
+    const closers = new Map();
+    const unpaired = [];
+    for (const [reversedIndex, character] of characters.toReversed().entries()) {
+        const index = characters.length - 1 - reversedIndex;
+        if (character === ')') {
+            unpaired.push(index);
+        }
+        else if (character === '(') {
+            closers.set(index, unpaired.pop());
+        }
+    }
+    return closers;
+}

package/dist/gate-contract.js

@@ -1,4 +1,4 @@
 // Bump deliberately when an intentional consumer-visible gate contract break ships.
 export const GATE_CONTRACT_VERSION = 1;
 // Replaced with the deterministic source-tree hash by the package build.
-export const GATE_SOURCE_TREE_HASH = '28283aa25287ac6172f333c8114de4879c0c14b3c6521908bb0607bb7e55ec6e';
+export const GATE_SOURCE_TREE_HASH = 'f5e534cd9cc3438f27eee34dd45045ae986891c230ad0af86fcc35ea1e12a2f6';

package/dist/gate-contract.json

@@ -1 +1 @@
-{"version":1,"sourceTreeHash":"28283aa25287ac6172f333c8114de4879c0c14b3c6521908bb0607bb7e55ec6e"}
+{"version":1,"sourceTreeHash":"f5e534cd9cc3438f27eee34dd45045ae986891c230ad0af86fcc35ea1e12a2f6"}

package/dist/inline-links.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The inline-link scanner behind `resolveMarkdownLinks`. It is an internal module: the package does not
+ * export it, so the only way to reach it is through `markdown-links`.
+ */
+export interface InlineLink {
+    /** Offset of the opening `[` in the line. */
+    readonly index: number;
+    /** Length of the whole `[text](destination "title")` span. */
+    readonly length: number;
+    /** The destination as written: `<angle>` with its brackets, or the bare run. */
+    readonly target: string;
+}
+/** The characters `\s` matches: ASCII spaces and controls, then the Unicode space separators. */
+export declare function isWhitespaceCode(code: number): boolean;
+/** For every offset `i` up to the line length plus one: the first offset at or after `i` whose character stops a run, or the line length. */
+export declare function buildStopTable(line: string, stops: (code: number) => boolean): Int32Array;
+/**
+ * Builds a function that finds the inline links of one line, `[text](destination "title")`, left to right.
+ * `find(from)` returns the leftmost link that starts at or after `from`, or `undefined`.
+ *
+ * The grammar, over the characters of the line:
+ * - `[`, a non-empty text with no `]` or newline, then `](`;
+ * - optional whitespace, then the destination: `<` with a non-empty run of no `>` or newline and `>`, or else
+ *   a non-empty run of no `)` or whitespace; the angle form is tried first and the bare run is the fallback
+ *   when the angle form is not followed by a valid ending;
+ * - an optional title, set off by whitespace, in double quotes, in single quotes or in parentheses, each with
+ *   no newline inside and no closing delimiter before its end;
+ * - optional whitespace, then `)`. A title that is present but does not lead to `)` is dropped, and the
+ *   destination alone must then be followed by whitespace and `)`.
+ *
+ * Every run in the grammar ends at the first character that cannot continue it, so a run is read once from
+ * a table of stop offsets built right to left, and every start offset is decided in constant time. The
+ * tables are built on first use and only for a line that holds `](`.
+ */
+export declare function createInlineLinkFinder(line: string): (from: number) => InlineLink | undefined;

package/dist/inline-links.js

@@ -0,0 +1,120 @@
+/**
+ * The inline-link scanner behind `resolveMarkdownLinks`. It is an internal module: the package does not
+ * export it, so the only way to reach it is through `markdown-links`.
+ */
+/** The character codes the grammar tests for. */
+const CLOSE_BRACKET = 0x5d;
+const OPEN_PAREN = 0x28;
+const CLOSE_PAREN = 0x29;
+const LESS_THAN = 0x3c;
+const GREATER_THAN = 0x3e;
+const DOUBLE_QUOTE = 0x22;
+const SINGLE_QUOTE = 0x27;
+const NEWLINE = 0x0a;
+/** The characters `\s` matches: ASCII spaces and controls, then the Unicode space separators. */
+export function isWhitespaceCode(code) {
+    if (code <= 0x20)
+        return code === 0x20 || (code >= 0x09 && code <= 0x0d);
+    if (code < 0xa0)
+        return false;
+    return (code === 0xa0 ||
+        code === 0x1680 ||
+        (code >= 0x2000 && code <= 0x200a) ||
+        code === 0x2028 ||
+        code === 0x2029 ||
+        code === 0x202f ||
+        code === 0x205f ||
+        code === 0x3000 ||
+        code === 0xfeff);
+}
+/** For every offset `i` up to the line length plus one: the first offset at or after `i` whose character stops a run, or the line length. */
+export function buildStopTable(line, stops) {
+    const table = new Int32Array(line.length + 2).fill(line.length);
+    for (let index = line.length - 1; index >= 0; index -= 1) {
+        table[index] = stops(line.charCodeAt(index)) ? index : (table[index + 1] ?? line.length);
+    }
+    return table;
+}
+/**
+ * Builds a function that finds the inline links of one line, `[text](destination "title")`, left to right.
+ * `find(from)` returns the leftmost link that starts at or after `from`, or `undefined`.
+ *
+ * The grammar, over the characters of the line:
+ * - `[`, a non-empty text with no `]` or newline, then `](`;
+ * - optional whitespace, then the destination: `<` with a non-empty run of no `>` or newline and `>`, or else
+ *   a non-empty run of no `)` or whitespace; the angle form is tried first and the bare run is the fallback
+ *   when the angle form is not followed by a valid ending;
+ * - an optional title, set off by whitespace, in double quotes, in single quotes or in parentheses, each with
+ *   no newline inside and no closing delimiter before its end;
+ * - optional whitespace, then `)`. A title that is present but does not lead to `)` is dropped, and the
+ *   destination alone must then be followed by whitespace and `)`.
+ *
+ * Every run in the grammar ends at the first character that cannot continue it, so a run is read once from
+ * a table of stop offsets built right to left, and every start offset is decided in constant time. The
+ * tables are built on first use and only for a line that holds `](`.
+ */
+export function createInlineLinkFinder(line) {
+    if (!line.includes(']('))
+        return () => undefined;
+    const tables = new Map();
+    const stopTable = (name, stops) => {
+        let table = tables.get(name);
+        if (table === undefined) {
+            table = buildStopTable(line, stops);
+            tables.set(name, table);
+        }
+        return table;
+    };
+    const stopAt = (name, from, stops) => stopTable(name, stops)[from] ?? line.length;
+    /** Offset of the `)` that ends a link whose destination ends at `destinationEnd`, plus one; -1 when there is none. */
+    const endOfLink = (destinationEnd) => {
+        const afterSpace = stopAt('nonSpace', destinationEnd, code => !isWhitespaceCode(code));
+        if (afterSpace > destinationEnd) {
+            const opener = line.charCodeAt(afterSpace);
+            const closer = opener === OPEN_PAREN ? CLOSE_PAREN : opener;
+            if (opener === DOUBLE_QUOTE || opener === SINGLE_QUOTE || opener === OPEN_PAREN) {
+                const stop = stopAt(`title${closer}`, afterSpace + 1, code => code === closer || code === NEWLINE);
+                if (line.charCodeAt(stop) === closer) {
+                    const closeAt = stopAt('nonSpace', stop + 1, code => !isWhitespaceCode(code));
+                    if (line.charCodeAt(closeAt) === CLOSE_PAREN)
+                        return closeAt + 1;
+                }
+            }
+        }
+        return line.charCodeAt(afterSpace) === CLOSE_PAREN ? afterSpace + 1 : -1;
+    };
+    const linkAt = (start) => {
+        const textEnd = stopAt('text', start + 1, code => code === CLOSE_BRACKET || code === NEWLINE);
+        if (textEnd === start + 1 ||
+            line.charCodeAt(textEnd) !== CLOSE_BRACKET ||
+            line.charCodeAt(textEnd + 1) !== OPEN_PAREN) {
+            return undefined;
+        }
+        const destinationStart = stopAt('nonSpace', textEnd + 2, code => !isWhitespaceCode(code));
+        if (line.charCodeAt(destinationStart) === LESS_THAN) {
+            const angleClose = stopAt('angle', destinationStart + 1, code => code === GREATER_THAN || code === NEWLINE);
+            if (angleClose > destinationStart + 1 && line.charCodeAt(angleClose) === GREATER_THAN) {
+                const end = endOfLink(angleClose + 1);
+                if (end !== -1) {
+                    return { index: start, length: end - start, target: line.slice(destinationStart, angleClose + 1) };
+                }
+            }
+        }
+        const bareEnd = stopAt('bare', destinationStart, code => code === CLOSE_PAREN || isWhitespaceCode(code));
+        if (bareEnd > destinationStart) {
+            const end = endOfLink(bareEnd);
+            if (end !== -1) {
+                return { index: start, length: end - start, target: line.slice(destinationStart, bareEnd) };
+            }
+        }
+        return undefined;
+    };
+    return from => {
+        for (let start = line.indexOf('[', from); start !== -1; start = line.indexOf('[', start + 1)) {
+            const link = linkAt(start);
+            if (link !== undefined)
+                return link;
+        }
+        return undefined;
+    };
+}

package/dist/line-scanners.d.ts

@@ -0,0 +1,31 @@
+export interface IndexEntryLine {
+    /** The text between `- [[` and `]]`, not trimmed. */
+    readonly slug: string;
+    /** The whole entry line, from the dash to the end of its text. */
+    readonly line: string;
+}
+/**
+ * Finds the index entry lines `- [[slug]] — description` of an index document, left to right, as
+ * `/^- \[\[([^\]|]+)\]\]\s*—\s*(?:\S.*|[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF])$/gmu`
+ * does:
+ * - the line starts at the beginning of the text or after a line terminator, with `- [[`;
+ * - the slug is a non-empty run up to the first `]` or `|`, which may cross lines, and `]]` follows it;
+ * - whitespace (newlines included), an em dash, whitespace again;
+ * - then either a non-whitespace character and the rest of its line, or, when only whitespace remains to the end
+ *   of the text, a single non-newline whitespace character that ends its line.
+ *
+ * Each run ends at the first character that cannot continue it, so a run is read once from a table of stop
+ * offsets and each candidate line is decided in constant time. The regex rescans the rest of the text from every
+ * `- [[` line that has no `]]` after it, which is quadratic in the length of the text.
+ */
+export declare function findIndexEntryLines(index: string): IndexEntryLine[];
+/**
+ * The inside of a flow-style `related: [a, b]` line, or `undefined` when the line is not one, as
+ * `/^related:\s*\[(.*)\]\s*(?:#.*)?$/u` does. The inside runs to the last `]` before the line's first terminator
+ * that is followed only by whitespace and an optional `#` comment running to the end of the text.
+ *
+ * The regex tries every `]` from the right and rescans the tail from each, which is quadratic when the tail
+ * stops short of the end of the text (a carriage return inside a `#` comment, say). Here the tail is decided
+ * from two tables of stop offsets in constant time per `]`.
+ */
+export declare function parseRelatedFlow(line: string): string | undefined;

package/dist/line-scanners.js

@@ -0,0 +1,111 @@
+import { buildStopTable, isWhitespaceCode } from "./inline-links.js";
+const NEWLINE = 0x0a;
+const CARRIAGE_RETURN = 0x0d;
+const LINE_SEPARATOR = 0x20_28;
+const PARAGRAPH_SEPARATOR = 0x20_29;
+const EM_DASH = 0x20_14;
+const CLOSE_BRACKET = 0x5d;
+const PIPE = 0x7c;
+const HASH = 0x23;
+/** The characters a regex `^`, `$` and `.` treat as line boundaries. */
+function isLineTerminator(code) {
+    return code === NEWLINE || code === CARRIAGE_RETURN || code === LINE_SEPARATOR || code === PARAGRAPH_SEPARATOR;
+}
+/**
+ * The offset just past the last character of `text` that is a whitespace character other than a line terminator
+ * and is followed by a line terminator or the end of the text, or -1 when there is none.
+ */
+function findLastBlankEnd(text) {
+    for (let at = text.length - 1; at >= 0; at -= 1) {
+        const code = text.charCodeAt(at);
+        if (isWhitespaceCode(code) &&
+            !isLineTerminator(code) &&
+            (at + 1 === text.length || isLineTerminator(text.charCodeAt(at + 1)))) {
+            return at + 1;
+        }
+    }
+    return -1;
+}
+/**
+ * Finds the index entry lines `- [[slug]] — description` of an index document, left to right, as
+ * `/^- \[\[([^\]|]+)\]\]\s*—\s*(?:\S.*|[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF])$/gmu`
+ * does:
+ * - the line starts at the beginning of the text or after a line terminator, with `- [[`;
+ * - the slug is a non-empty run up to the first `]` or `|`, which may cross lines, and `]]` follows it;
+ * - whitespace (newlines included), an em dash, whitespace again;
+ * - then either a non-whitespace character and the rest of its line, or, when only whitespace remains to the end
+ *   of the text, a single non-newline whitespace character that ends its line.
+ *
+ * Each run ends at the first character that cannot continue it, so a run is read once from a table of stop
+ * offsets and each candidate line is decided in constant time. The regex rescans the rest of the text from every
+ * `- [[` line that has no `]]` after it, which is quadratic in the length of the text.
+ */
+export function findIndexEntryLines(index) {
+    const entries = [];
+    const opener = '- [[';
+    if (!index.includes(opener))
+        return entries;
+    const slugStop = buildStopTable(index, code => code === CLOSE_BRACKET || code === PIPE);
+    const nonSpace = buildStopTable(index, code => !isWhitespaceCode(code));
+    const lineEnd = buildStopTable(index, isLineTerminator);
+    let lastBlankEnd;
+    const trailingBlankEnd = () => (lastBlankEnd ??= findLastBlankEnd(index));
+    const entryEndAt = (slugEnd) => {
+        const dash = nonSpace[slugEnd + 2] ?? index.length;
+        if (index.charCodeAt(dash) !== EM_DASH)
+            return -1;
+        const textStart = nonSpace[dash + 1] ?? index.length;
+        if (textStart < index.length)
+            return lineEnd[textStart + 1] ?? index.length;
+        // Only whitespace follows the dash: the entry ends at the last character of the text that is a whitespace
+        // character, not a line terminator, and the last in its line. That character does not depend on the dash,
+        // so it is found once, and an entry exists when it lies after the dash.
+        return trailingBlankEnd() > dash + 1 ? trailingBlankEnd() : -1;
+    };
+    for (let start = index.indexOf(opener); start !== -1;) {
+        const atLineStart = start === 0 || isLineTerminator(index.charCodeAt(start - 1));
+        const slugEnd = slugStop[start + 4] ?? index.length;
+        if (atLineStart && slugEnd > start + 4 && index.startsWith(']]', slugEnd)) {
+            const end = entryEndAt(slugEnd);
+            if (end !== -1) {
+                entries.push({ slug: index.slice(start + 4, slugEnd), line: index.slice(start, end) });
+                start = index.indexOf(opener, end);
+                continue;
+            }
+        }
+        start = index.indexOf(opener, start + 1);
+    }
+    return entries;
+}
+/**
+ * The inside of a flow-style `related: [a, b]` line, or `undefined` when the line is not one, as
+ * `/^related:\s*\[(.*)\]\s*(?:#.*)?$/u` does. The inside runs to the last `]` before the line's first terminator
+ * that is followed only by whitespace and an optional `#` comment running to the end of the text.
+ *
+ * The regex tries every `]` from the right and rescans the tail from each, which is quadratic when the tail
+ * stops short of the end of the text (a carriage return inside a `#` comment, say). Here the tail is decided
+ * from two tables of stop offsets in constant time per `]`.
+ */
+export function parseRelatedFlow(line) {
+    const key = 'related:';
+    if (!line.startsWith(key))
+        return undefined;
+    let bracket = key.length;
+    while (bracket < line.length && isWhitespaceCode(line.charCodeAt(bracket)))
+        bracket += 1;
+    if (line.charAt(bracket) !== '[')
+        return undefined;
+    const lineEnd = buildStopTable(line, isLineTerminator);
+    const nonSpace = buildStopTable(line, code => !isWhitespaceCode(code));
+    const insideStart = bracket + 1;
+    const insideLimit = lineEnd[insideStart] ?? line.length;
+    for (let close = insideLimit - 1; close >= insideStart; close -= 1) {
+        if (line.charCodeAt(close) !== CLOSE_BRACKET)
+            continue;
+        const tail = nonSpace[close + 1] ?? line.length;
+        const tailIsComment = line.charCodeAt(tail) === HASH && (lineEnd[tail + 1] ?? line.length) === line.length;
+        if (tail === line.length || tailIsComment)
+            return line.slice(insideStart, close);
+    }
+    return undefined;
+}

package/dist/link-labels.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One link in `replaceLinkLabels`: the capture groups of a markdown link `[text](target)` or a wiki link
+ * `[[target]]` / `[[target|label]]`. The groups of the branch that did not match are `undefined`.
+ */
+export interface LinkLabelParts {
+    readonly markdownText: string | undefined;
+    readonly wikiTarget: string | undefined;
+    readonly wikiLabel: string | undefined;
+}
+/**
+ * Replaces every markdown link and wiki link in `text` with `render(parts)`, scanning left to right once, as
+ * `text.replaceAll(/!?(?:\[([^\]]*)\]\([^)]*\)|\[\[([^\]|]+)(?:\|([^\]]+))?\]\])/gu, ...)` does. A leading `!`
+ * (an image) is part of the match. The markdown form is tried before the wiki form at each `[`:
+ * - markdown: `[`, any text up to the first `]`, `](`, any run up to the first `)`, and that `)`;
+ * - wiki: `[[`, a non-empty target up to the first `]` or `|`, then either `]]` or `|`, a non-empty label up to
+ *   the first `]`, and `]]`.
+ *
+ * Every run ends at the first character that cannot continue it, so the stop offsets are read from tables built
+ * right to left and each `[` is decided in constant time. The regex form rescans the rest of the text from every
+ * unclosed `[`, which is quadratic in the length of the text.
+ */
+export declare function replaceLinkLabels(text: string, render: (parts: LinkLabelParts) => string): string;

package/dist/link-labels.js

@@ -0,0 +1,71 @@
+import { buildStopTable } from "./inline-links.js";
+const OPEN_BRACKET = '[';
+const CLOSE_BRACKET = ']';
+const OPEN_PAREN = '(';
+const CLOSE_PAREN = ')';
+const PIPE = '|';
+const BANG = '!';
+/**
+ * Replaces every markdown link and wiki link in `text` with `render(parts)`, scanning left to right once, as
+ * `text.replaceAll(/!?(?:\[([^\]]*)\]\([^)]*\)|\[\[([^\]|]+)(?:\|([^\]]+))?\]\])/gu, ...)` does. A leading `!`
+ * (an image) is part of the match. The markdown form is tried before the wiki form at each `[`:
+ * - markdown: `[`, any text up to the first `]`, `](`, any run up to the first `)`, and that `)`;
+ * - wiki: `[[`, a non-empty target up to the first `]` or `|`, then either `]]` or `|`, a non-empty label up to
+ *   the first `]`, and `]]`.
+ *
+ * Every run ends at the first character that cannot continue it, so the stop offsets are read from tables built
+ * right to left and each `[` is decided in constant time. The regex form rescans the rest of the text from every
+ * unclosed `[`, which is quadratic in the length of the text.
+ */
+export function replaceLinkLabels(text, render) {
+    if (!text.includes(OPEN_BRACKET))
+        return text;
+    const closeBracketAt = buildStopTable(text, code => code === 0x5d);
+    const closeParenAt = buildStopTable(text, code => code === 0x29);
+    const closeBracketOrPipeAt = buildStopTable(text, code => code === 0x5d || code === 0x7c);
+    const matchAt = (open) => {
+        const textEnd = closeBracketAt[open + 1] ?? text.length;
+        if (text.charAt(textEnd) === CLOSE_BRACKET && text.charAt(textEnd + 1) === OPEN_PAREN) {
+            const parenEnd = closeParenAt[textEnd + 2] ?? text.length;
+            if (text.charAt(parenEnd) === CLOSE_PAREN) {
+                return {
+                    end: parenEnd + 1,
+                    markdownText: text.slice(open + 1, textEnd),
+                    wikiTarget: undefined,
+                    wikiLabel: undefined,
+                };
+            }
+        }
+        if (text.charAt(open + 1) !== OPEN_BRACKET)
+            return undefined;
+        const targetEnd = closeBracketOrPipeAt[open + 2] ?? text.length;
+        if (targetEnd === open + 2)
+            return undefined;
+        const wikiTarget = text.slice(open + 2, targetEnd);
+        if (text.charAt(targetEnd) === PIPE) {
+            const labelEnd = closeBracketAt[targetEnd + 1] ?? text.length;
+            if (labelEnd > targetEnd + 1 && text.startsWith(']]', labelEnd)) {
+                return { end: labelEnd + 2, markdownText: undefined, wikiTarget, wikiLabel: text.slice(targetEnd + 1, labelEnd) };
+            }
+            return undefined;
+        }
+        return text.startsWith(']]', targetEnd)
+            ? { end: targetEnd + 2, markdownText: undefined, wikiTarget, wikiLabel: undefined }
+            : undefined;
+    };
+    let replaced = '';
+    let copiedTo = 0;
+    for (let open = text.indexOf(OPEN_BRACKET); open !== -1;) {
+        const match = matchAt(open);
+        if (match === undefined) {
+            open = text.indexOf(OPEN_BRACKET, open + 1);
+            continue;
+        }
+        // An image's `!` belongs to the match, unless an earlier match already took it.
+        const start = open > copiedTo && text.charAt(open - 1) === BANG ? open - 1 : open;
+        replaced += text.slice(copiedTo, start) + render(match);
+        copiedTo = match.end;
+        open = text.indexOf(OPEN_BRACKET, match.end);
+    }
+    return replaced + text.slice(copiedTo);
+}