punctilio 4.3.0 → 5.0.0

package/dist/symbols.js

@@ -1,180 +1,668 @@
-import { cachedRegExp, DEFAULT_SEPARATOR, getEscapedSeparator, LATIN_LETTERS, SPACE_CHARS, UNICODE_SYMBOLS, wordBoundaryEnd } from "./constants.js";
+import { cachedRegExp, LATIN_LETTERS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js";
+import { boundaryCountAt, overInput, replaceAllInView } from "./prose-view.js";
 import { convertPrimeMarks } from "./quote-classifier.js";
-import { namedGroups } from "./utils.js";
 const { ELLIPSIS, MULTIPLICATION, NOT_EQUAL, PLUS_MINUS, COPYRIGHT, REGISTERED, TRADEMARK, DEGREE, ARROW_RIGHT, ARROW_LEFT, ARROW_LEFT_RIGHT, APPROXIMATE, LESS_EQUAL, GREATER_EQUAL, NBSP, PRIME, DOUBLE_PRIME, SUPERSCRIPT_ST, SUPERSCRIPT_ND, SUPERSCRIPT_RD, SUPERSCRIPT_TH, DOUBLE_QUESTION, QUESTION_EXCLAMATION, EXCLAMATION_QUESTION, } = UNICODE_SYMBOLS;
-/** Convert "..." or ". . ." to "…". */
-export function ellipsis(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    // Convert consecutive or spaced dots: ... or . . . → …
-    // Each gap allows EITHER a space (same-text-node spaced dots) OR a separator
-    // (cross-boundary contiguous dots), but never both — a space adjacent to a
-    // separator means the dots straddle a text-node boundary and shouldn't fold
-    // into one ellipsis.
-    const pattern = cachedRegExp(`\\.(?:[${SPACE_CHARS}]|(?<sep1>${chr}))?\\.(?:[${SPACE_CHARS}]?|(?<sep2>${chr})?)\\.`, "g");
-    text = text.replace(pattern, (...args) => {
-        const { sep1, sep2 } = namedGroups(args);
-        return ELLIPSIS + (sep1 ?? "") + (sep2 ?? "");
+// The boundary-tolerance positions throughout this module reproduce the
+// element-boundary semantics of the pre-v5 sentinel-marked pipeline; they are
+// pinned by the golden corpus and the migration's differential fuzz.
+const LATIN_LETTER_RE = new RegExp(`[${LATIN_LETTERS}]`);
+const WORD_RE = /\w/;
+export function ellipsis(input) {
+    return overInput(input, ellipsisOverView);
+}
+const SPACE_CHAR_RE = new RegExp(`[${SPACE_CHARS}]`);
+function ellipsisOverView(view) {
+    ellipsisFoldDots(view);
+    view.commit();
+    // A space is inserted only when a letter or digit directly follows the
+    // ellipsis. A node boundary between the ellipsis and the letter is a non-letter
+    // for the `(?=[A-Za-z…\d])` lookahead, so it blocks the space; re-check the
+    // boundary at the lookahead position.
+    const trailing = cachedRegExp(`${ELLIPSIS}(?=[${LATIN_LETTERS}\\d])`, "gu");
+    replaceAllInView(view, trailing, (match, v) => {
+        if (v.hasBoundary(match.index + match[0].length))
+            return null;
+        return `${ELLIPSIS} `;
     });
-    text = text.replace(cachedRegExp(`${ELLIPSIS}(?=[${LATIN_LETTERS}\\d])`, "gu"), `${ELLIPSIS} `);
-    return text;
-}
-/** Convert "5x5" to "5×5". Skips hex (0x5F). */
-export function multiplication(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    // After a digit run, either a prime mark (10′) or a length/size unit may
-    // attach before the multiplication operator. Allowing both lets dimensions
-    // like "5m × 5m", "210mm × 297mm", or "1920px × 1080px" convert, matching
-    // Chicago §9.17's preference for × in dimension notation.
-    //
-    // Only length/size units that plausibly appear in two-dimensional
-    // dimensions are listed — mass/time/electrical units (kg, min, V, …) don't
-    // participate in "N × N" constructions and excluding them avoids false
-    // matches on words ending in those letters.
-    const dimensionUnits = "rem|vh|vw|km|cm|mm|nm|pm|mi|ft|yd|in|px|pt|em|m";
-    // Word-boundary lookahead: the unit must be followed by whitespace, a
-    // separator marker, the multiplication operator, end-of-string, or
-    // sentence punctuation — never another letter (which would mean the
-    // "unit" is actually a word prefix like "mold").
-    const unitBoundary = `(?=\\s|${chr}|[xX*.,;!?)}]|$)`;
-    const unitAlt = `(?:\\s|${chr})?(?:${dimensionUnits})${unitBoundary}`;
-    const primeAlt = `${chr}?[${PRIME}${DOUBLE_PRIME}]`;
-    const digitSuffix = `(?:${primeAlt}|${unitAlt})?`;
-    // Match entire multiplication chains in one pass: "5 x 5 x 5" or "5x5x5"
-    // Pattern matches: digit(s), then one or more (operator, digit(s)) groups
-    // The (?<!\d[eE]) lookbehind prevents matching inside ambiguous unsigned
-    // scientific notation (1e5x3 — could also be a model SKU). Signed exponents
-    // (1e-5x3, 3.5E+10x2) are unambiguously scientific so the multiplication
-    // is converted. The Latin-letter lookbehind blocks model-name identifiers
-    // (Surface5x3, RTX3060x2).
-    const chainPattern = cachedRegExp(`(?<!\\d[eE])(?<![${LATIN_LETTERS}\\d])(?<firstNum>\\d+${digitSuffix})(?<rest>(?:${chr}?\\s*[xX*]\\s*${chr}?\\d+${digitSuffix})+)`, "g");
-    text = text.replace(chainPattern, (...args) => {
-        const { firstNum, rest } = namedGroups(args);
-        // Skip hexadecimal: 0x... or 0X...
-        if (firstNum === "0" && /^x/i.test(rest))
-            return args[0];
-        // Replace each "operator + next digit group" segment in lockstep.
-        // Consuming the digit-suffix as part of each segment keeps the inner
-        // replace from misreading the `x` inside a trailing unit like `px` as
-        // another operator.
-        // Sticky flag (`y`) anchors each segment at the previous one's end.
-        // `rest` always starts with a chain segment from the outer match, so
-        // the engine never tries multiple start positions across whitespace.
-        const converted = rest.replace(cachedRegExp(`(?<pre>${chr}?)(?<spaceBefore>\\s*)[xX*](?<spaceAfter>\\s*)(?<post>${chr}?)(?<num>\\d+${digitSuffix})`, "gy"), (...innerArgs) => {
-            const groups = namedGroups(innerArgs);
-            const space = groups.spaceBefore || groups.spaceAfter ? " " : "";
-            return `${groups.pre}${space}${MULTIPLICATION}${space}${groups.post}${groups.num}`;
+    view.commit();
+}
+/**
+ * Offset of the dot following one inter-dot gap that begins at `afterDot`, or
+ * -1 when no dot is reachable. The gap is one of: nothing, one space character,
+ * or one node boundary — never two and never a space-plus-boundary mix. A dot
+ * is reachable only when no unconsumed boundary shadows it (the `\.` cannot
+ * cross a boundary).
+ */
+function ellipsisNextDot(view, text, afterDot) {
+    const boundariesHere = boundaryCountAt(view, afterDot);
+    if (text[afterDot] === ".") {
+        // Empty gap (no boundary) or a single-boundary gap consuming exactly one.
+        return boundariesHere <= 1 ? afterDot : -1;
+    }
+    // Space gap: one space character with no boundary, then a non-shadowed dot.
+    if (boundariesHere === 0 && text[afterDot] !== undefined && SPACE_CHAR_RE.test(text[afterDot])) {
+        const dot = afterDot + 1;
+        if (text[dot] === "." && boundaryCountAt(view, dot) === 0)
+            return dot;
+    }
+    return -1;
+}
+/**
+ * Fold `...`, `. . .`, and the cross-boundary variants into `…`, scanning
+ * left-to-right so a blocked leftmost triple still lets the next valid triple
+ * fold. Each fold replaces the whole `. gap . gap .` span with `…`; consumed
+ * interior boundaries collapse to just after the ellipsis.
+ */
+function ellipsisFoldDots(view) {
+    const text = view.text;
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== ".") {
+            i++;
+            continue;
+        }
+        const secondDot = ellipsisNextDot(view, text, i + 1);
+        if (secondDot < 0) {
+            i++;
+            continue;
+        }
+        const thirdDot = ellipsisNextDot(view, text, secondDot + 1);
+        if (thirdDot < 0) {
+            i++;
+            continue;
+        }
+        view.replace(i, thirdDot + 1, ELLIPSIS);
+        i = thirdDot + 1;
+    }
+}
+export function multiplication(input) {
+    return overInput(input, multiplicationOverView);
+}
+// After a digit run, either a prime mark (10′) or a length/size unit may
+// attach before the multiplication operator. Allowing both lets dimensions
+// like "5m × 5m", "210mm × 297mm", or "1920px × 1080px" convert, matching
+// Chicago §9.17's preference for × in dimension notation.
+//
+// Only length/size units that plausibly appear in two-dimensional dimensions
+// are listed — mass/time/electrical units (kg, min, V, …) don't participate in
+// "N × N" constructions and excluding them avoids false matches on words
+// ending in those letters.
+const DIMENSION_UNITS = "rem|vh|vw|km|cm|mm|nm|pm|mi|ft|yd|in|px|pt|em|m";
+// Word-boundary lookahead: the unit must be followed by whitespace, the
+// multiplication operator, end-of-string, or sentence punctuation — never
+// another letter (which would mean the "unit" is actually a word prefix like
+// "mold"). A node boundary directly after the unit also satisfies this position
+// and is permitted by allowBoundaries, so it is dropped from the literal
+// lookahead.
+const UNIT_BOUNDARY = `(?=\\s|[xX*.,;!?)}]|$)`;
+const UNIT_ALT = `\\s?(?:${DIMENSION_UNITS})${UNIT_BOUNDARY}`;
+const PRIME_ALT = `[${PRIME}${DOUBLE_PRIME}]`;
+const DIGIT_SUFFIX = `(?:${PRIME_ALT}|${UNIT_ALT})?`;
+// Match entire multiplication chains in one pass: "5 x 5 x 5" or "5x5x5".
+// Pattern matches: digit(s), then one or more (operator, digit(s)) groups.
+// The (?<!\d[eE]) lookbehind prevents matching inside ambiguous unsigned
+// scientific notation (1e5x3 — could also be a model SKU). Signed exponents
+// (1e-5x3, 3.5E+10x2) are unambiguously scientific so the multiplication is
+// converted. The Latin-letter lookbehind blocks model-name identifiers
+// (Surface5x3, RTX3060x2).
+const MULTIPLICATION_CHAIN = `(?<firstNum>\\d+${DIGIT_SUFFIX})(?<rest>(?:\\s*[xX*]\\s*\\d+${DIGIT_SUFFIX})+)`;
+const MULTIPLICATION_SEGMENT = `(?<spaceBefore>\\s*)[xX*](?<spaceAfter>\\s*)(?<num>\\d+${DIGIT_SUFFIX})`;
+/** Locate each operator segment of `rest` (absolute offsets via `chainStart`). */
+function chainSegments(chainStart, firstNum, rest) {
+    const segments = [];
+    const segmentRe = cachedRegExp(MULTIPLICATION_SEGMENT, "gy");
+    segmentRe.lastIndex = 0;
+    let m;
+    while ((m = segmentRe.exec(rest)) !== null) {
+        const groups = m.groups;
+        const operatorAbs = chainStart + firstNum.length + m.index + groups.spaceBefore.length;
+        segments.push({
+            operatorOffset: operatorAbs,
+            operandStart: operatorAbs + 1 + groups.spaceAfter.length,
+            operandEnd: chainStart + firstNum.length + m.index + m[0].length,
+            spaceBefore: groups.spaceBefore,
+            spaceAfter: groups.spaceAfter,
         });
-        return `${firstNum}${converted}`;
-    });
-    // Trailing multiplier: 5x (followed by word boundary - space, punctuation, etc.)
-    const wbe = wordBoundaryEnd(chr);
-    const trailingPattern = cachedRegExp(`(?<!\\d[eE])(?<![${LATIN_LETTERS}\\d])(?<num>\\d+${chr}?)[xX*]${wbe}`, "g");
-    text = text.replace(trailingPattern, (match, num) => {
-        // Skip if this looks like start of hexadecimal
-        if (num === "0")
-            return match;
-        return `${num}${MULTIPLICATION}`;
-    });
-    return text;
+    }
+    return segments;
+}
+/**
+ * Each operator's spacing slot (`\s*[xX*]\s*`) tolerates one node boundary at
+ * each outer edge and none inside the spacing; a second adjacent boundary at an
+ * edge breaks the segment. The operator's slot is the span [slotStart, slotEnd)
+ * covering its surrounding spaces and the operator itself.
+ */
+function operatorSlotClean(view, slotStart, slotEnd) {
+    // No boundary strictly inside the spacing-plus-operator slot.
+    for (const boundary of view.boundaries) {
+        if (boundary > slotStart && boundary < slotEnd)
+            return false;
+    }
+    // At most one boundary hugging each outer edge (duplicates at an offset come
+    // from empty nodes and each counts as one boundary).
+    return boundaryCountAt(view, slotStart) <= 1 && boundaryCountAt(view, slotEnd) <= 1;
+}
+/**
+ * The chain's leading lookbehinds at `operandStart`
+ * (`(?<!\d[eE])(?<![A-Za-z…\d])`); the Latin-letter arm already rejects any
+ * operand preceded by `e`/`E`, so the scientific-notation arm adds nothing for
+ * the operand's immediate left character and is folded in here. A node boundary
+ * right before the operand shadows the clean character (a boundary is not a
+ * letter or digit), satisfying the lookbehind.
+ */
+function chainGuardOk(view, operandStart) {
+    if (view.hasBoundary(operandStart))
+        return true;
+    const prior = view.text[operandStart - 1];
+    return prior === undefined || !(LATIN_LETTER_RE.test(prior) || /\d/.test(prior));
+}
+/**
+ * The hex skip `firstNum === "0" && /^x/i.test(rest)`: a `0` operand directly
+ * followed (no boundary) by `x`/`X` skips the whole matched chain without
+ * re-anchoring.
+ */
+function chainHexBlocked(view, operandStart, operandText) {
+    if (operandText !== "0")
+        return false;
+    const after = operandStart + operandText.length;
+    // Hex requires `x`/`X` directly after the `0` (a unit between them is not hex).
+    // `after` always indexes the operator/unit reached by the match, so it is in
+    // bounds.
+    return !view.hasBoundary(after) && /x/i.test(view.text[after]);
+}
+/**
+ * Start offset of the maximal boundary-free digit run ending at `digitsEnd`
+ * (exclusive), not crossing below `lowerBound`. A node boundary inside a digit
+ * run truncates the operand an operator actually sees; that truncated run drives
+ * the hex and guard checks.
+ */
+function leftDigitRunStart(view, text, digitsEnd, lowerBound) {
+    let start = digitsEnd;
+    // A boundary at `digitsEnd` sits between the last digit and the operator and
+    // does not split the run; only boundaries strictly inside the digits do.
+    while (start > lowerBound && /\d/.test(text[start - 1]) && (start === digitsEnd || !view.hasBoundary(start)))
+        start--;
+    return start;
+}
+/**
+ * End offset of the digit run of the left operand whose operator spacing slot
+ * begins at `slotStart`: walk back over the operand's optional suffix (a prime,
+ * or a unit's letters, possibly with one space) to the last digit.
+ */
+function leftDigitsEnd(text, slotStart) {
+    let i = slotStart;
+    while (i > 0 && !/\d/.test(text[i - 1]))
+        i--;
+    return i;
+}
+/**
+ * True iff the operand's unit suffix between `digitsEnd` and `slotStart` is not
+ * split by a node boundary. One boundary is tolerated before the unit, but the
+ * unit's letters must be contiguous, so a boundary between two unit letters
+ * detaches the operator from the operand.
+ */
+function leftSuffixUnsplit(view, text, digitsEnd, slotStart) {
+    // A prime or unit suffix begins after one optional space-or-boundary slot;
+    // a second boundary in that slot (before the suffix) leaves `\d+suffix`
+    // matching only the digits, detaching the operator.
+    if (slotStart > digitsEnd && boundaryCountAt(view, digitsEnd) > 1)
+        return false;
+    for (let i = digitsEnd + 1; i < slotStart; i++) {
+        if (LATIN_LETTER_RE.test(text[i - 1]) && LATIN_LETTER_RE.test(text[i]) && view.hasBoundary(i))
+            return false;
+    }
+    return true;
+}
+/**
+ * True iff a node boundary falls strictly inside the leading digit run of the
+ * operand starting at `operandStart` (`\d+` cannot cross a boundary, so such a
+ * boundary truncates the operand and ends the chain there).
+ */
+function runHasInteriorBoundary(view, operandStart, operandEnd) {
+    const text = view.text;
+    let i = operandStart + 1;
+    while (i < operandEnd && /\d/.test(text[i])) {
+        if (view.hasBoundary(i))
+            return true;
+        i++;
+    }
+    return false;
+}
+function multiplicationOverView(view) {
+    // The chain is matched with a sticky regex driven by a manual left-to-right
+    // scan. Sticky anchoring keeps the nested `\d+(…\d+)+` quantifier ReDoS-safe
+    // without leading lookbehinds; dropping those lookbehinds lets a chain anchor
+    // on an operand whose preceding letter/digit is shadowed by a node boundary.
+    // Boundary-aware guard/hex/operand checks below make the per-operand
+    // decisions.
+    const chainPattern = cachedRegExp(MULTIPLICATION_CHAIN, "y");
+    const chainText = view.text;
+    let scan = 0;
+    while (scan < chainText.length) {
+        chainPattern.lastIndex = scan;
+        const match = chainPattern.exec(chainText);
+        if (match === null) {
+            scan++;
+            continue;
+        }
+        const { firstNum, rest } = match.groups;
+        const text = chainText;
+        const chainStart = match.index;
+        const segments = chainSegments(chainStart, firstNum, rest);
+        // Edit each operator's spacing slot in place, leaving the digit operands
+        // (and any node boundaries inside them) untouched so boundary positions are
+        // preserved.
+        //
+        // The chain matches contiguously, then the hex skip is applied. Two
+        // outcomes propagate differently:
+        //   - Leading-guard failure does not anchor here, so the match is re-tried
+        //     at the next operand: keep retrying each operator until one anchors.
+        //   - Hex skip and a successful anchor consume the matched chain, so no
+        //     operator inside it converts or re-anchors until a STRUCTURAL break (a
+        //     boundary inside an operator's spacing slot or splitting an operand's
+        //     digit run) lets the chain re-match at a later operand.
+        let chainActive = false;
+        let anchored = false;
+        segments.forEach((segment, index) => {
+            const slotStart = segment.operatorOffset - segment.spaceBefore.length;
+            const slotEnd = segment.operatorOffset + 1 + segment.spaceAfter.length;
+            const digitsEnd = leftDigitsEnd(text, slotStart);
+            // The left operand's unit suffix must be a contiguous match: a boundary
+            // splitting the unit's letters breaks `\d+suffix`, detaching the operator
+            // from any operand (its left side is no longer `\d+unit`).
+            const slotClean = operatorSlotClean(view, slotStart, slotEnd) && leftSuffixUnsplit(view, text, digitsEnd, slotStart);
+            if (!anchored) {
+                const lowerBound = index === 0 ? chainStart : segments[index - 1].operandStart;
+                const runStart = leftDigitRunStart(view, text, digitsEnd, lowerBound);
+                const operand = text.slice(runStart, digitsEnd);
+                if (!chainGuardOk(view, runStart)) {
+                    // Did not anchor here; re-try at the next operand.
+                    chainActive = false;
+                }
+                else {
+                    anchored = true;
+                    chainActive = !chainHexBlocked(view, runStart, operand);
+                }
+            }
+            if (!slotClean) {
+                // Structural break: the matched chain ends; the next operand re-anchors.
+                chainActive = false;
+                anchored = false;
+                return;
+            }
+            if (chainActive) {
+                const space = segment.spaceBefore || segment.spaceAfter ? " " : "";
+                view.replace(slotStart, slotEnd, `${space}${MULTIPLICATION}${space}`);
+            }
+            // A boundary inside this operand's digit run truncates it (`\d+` stops
+            // there): a structural break, so the next operand re-anchors.
+            if (runHasInteriorBoundary(view, segment.operandStart, segment.operandEnd)) {
+                chainActive = false;
+                anchored = false;
+            }
+        });
+        scan = chainStart + match[0].length;
+    }
+    view.commit();
+    // Trailing multiplier: 5x (followed by a word boundary). The rule is
+    // `(?<!\d[eE])(?<![A-Za-z…\d])\d+ [xX*] \b(?!\w)` with one tolerated boundary
+    // before the operator. The leading guard, the slot before the operator, the
+    // hex skip, and the trailing word boundary each consult boundaries at their
+    // position. `*` never trails because it is not a word character, so the
+    // closing `\b` cannot anchor on it.
+    const trailingPattern = cachedRegExp(`(?<num>\\d+)(?<op>[xX*])`, "y");
+    const trailingText = view.text;
+    let trailingScan = 0;
+    while (trailingScan < trailingText.length) {
+        trailingPattern.lastIndex = trailingScan;
+        const match = trailingPattern.exec(trailingText);
+        if (match === null) {
+            trailingScan++;
+            continue;
+        }
+        const num = match.groups.num;
+        const op = match.groups.op;
+        const operatorOffset = match.index + num.length;
+        trailingScan = match.index + match[0].length;
+        // One optional boundary may sit between the digits and the operator.
+        if (boundaryCountAt(view, operatorOffset) > 1)
+            continue;
+        // Leading guard and hex skip, on the boundary-free digit run ending at the
+        // operator (a boundary inside the digits truncates the operand).
+        const runStart = leftDigitRunStart(view, trailingText, operatorOffset, 0);
+        const operand = trailingText.slice(runStart, operatorOffset);
+        if (!chainGuardOk(view, runStart) || chainHexBlocked(view, runStart, operand))
+            continue;
+        // Trailing word boundary: `*` is not a word character so it never anchors a
+        // trailing `\b`; otherwise reject when a word character follows the operator
+        // through at most three boundaries.
+        if (op === "*")
+            continue;
+        const afterOp = operatorOffset + 1;
+        const followChar = trailingText[afterOp];
+        if (boundaryCountAt(view, afterOp) <= 3 && followChar !== undefined && WORD_RE.test(followChar))
+            continue;
+        view.replace(operatorOffset, afterOp, MULTIPLICATION);
+    }
+    view.commit();
 }
 const MATH_SYMBOL_MAP = [
-    ["!", "=", (chr) => `(?!${chr}?=)`, NOT_EQUAL],
-    ["\\+/", "-", () => "", PLUS_MINUS],
-    ["\\+", "-", () => "", PLUS_MINUS],
-    ["<", "=", (chr) => `(?!${chr}?=)`, LESS_EQUAL],
-    [">", "=", (chr) => `(?!${chr}?=)`, GREATER_EQUAL],
-    ["~", "=", () => "", APPROXIMATE],
-    ["=", "~", () => "", APPROXIMATE],
+    ["!", "=", "=", NOT_EQUAL],
+    ["\\+/", "-", "", PLUS_MINUS],
+    ["\\+", "-", "", PLUS_MINUS],
+    ["<", "=", "=", LESS_EQUAL],
+    [">", "=", "=", GREATER_EQUAL],
+    ["~", "=", "", APPROXIMATE],
+    ["=", "~", "", APPROXIMATE],
 ];
-/** Convert !=, <=, >=, +/-, ~= to Unicode equivalents. */
-export function mathSymbols(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    for (const [left, right, lookahead, replacement] of MATH_SYMBOL_MAP) {
-        // Capture an optional separator between left and right so a cross-boundary
-        // match (e.g., `!<SEP>=`) re-emits the separator alongside the replacement
-        // and preserves the text-node-count invariant in transformTextNodes.
-        const pattern = cachedRegExp(`${left}(?<sep>${chr})?${right}${lookahead(chr)}`, "g");
-        text = text.replace(pattern, (...args) => {
-            const { sep } = namedGroups(args);
-            return `${replacement}${sep ?? ""}`;
+export function mathSymbols(input) {
+    return overInput(input, mathSymbolsOverView);
+}
+function mathSymbolsOverView(view) {
+    for (const [left, right, forbiddenFollow, replacement] of MATH_SYMBOL_MAP) {
+        // Re-read after each rule's commit: prior rules mutate the clean text.
+        const text = view.text;
+        // One boundary is tolerated at the left/right junction (e.g. `!<boundary>=`).
+        // Position editing keeps the surrounding fragments (and so the boundary)
+        // intact; allowBoundaries permits that one boundary. The negative lookahead
+        // `(?!=)` is checked manually because it tolerates one boundary before the
+        // forbidden `=`: with two or more boundaries the `=` is out of reach, so the
+        // match is not blocked.
+        const pattern = cachedRegExp(`${left}${right}`, "g");
+        replaceAllInView(view, pattern, (match, v) => {
+            if (forbiddenFollow && mathLookaheadBlocks(text, v, match.index + match[0].length, forbiddenFollow)) {
+                return null;
+            }
+            return replacement;
+        }, {
+            allowBoundaries: (m, v) => mathOperatorAllowBoundary(m, v),
         });
+        view.commit();
+    }
+}
+/**
+ * The `(?!=)` guard: the match is blocked when the forbidden character follows
+ * through at most one boundary. Two or more boundaries put the character out of
+ * reach (one boundary tolerated), so the match proceeds. `≈` blocks where `=`
+ * does: a later rule in this same pass folds `=~` to `≈`, consuming the `=`
+ * this guard keys on (`!==~` must stay blocked once it reads `!=≈`).
+ */
+function mathLookaheadBlocks(text, view, end, forbidden) {
+    const next = text[end];
+    const matches = next === forbidden || (forbidden === "=" && next === APPROXIMATE);
+    return matches && boundaryCountAt(view, end) <= 1;
+}
+/**
+ * Only the junction between the `left` operator string and the single-character
+ * `right` tolerates one interior boundary (the `right` char ends the match). A
+ * boundary inside a multi-character `left` like `+/` breaks the operator.
+ */
+function mathOperatorAllowBoundary(match, view) {
+    const junction = match.index + match[0].length - 1;
+    for (const boundary of view.boundaries) {
+        if (boundary > match.index && boundary < match.index + match[0].length && boundary !== junction)
+            return false;
     }
-    return text;
+    return boundaryCountAt(view, junction) <= 1;
 }
 // 25 chars: fits "copyright " or a 4-digit year with padding, without making slicing expensive.
 const LEGAL_SYMBOL_CONTEXT_WINDOW = 25;
+// Window cost charged per node boundary: an element edge stands in for two
+// characters of context, so boundary-dense markup exposes less of it.
+const BOUNDARY_CONTEXT_COST = 2;
+// Vulgar fraction glyphs (½, ¾, …). A fraction folds from `n/m`, which the path
+// heuristic below reads as a path context — so the glyph must read the same way,
+// or `1/2(tm)` (blocked) would convert once fractions strips the slash to `½(tm)`.
+const FRACTION_GLYPH_RE = new RegExp(`[${Object.entries(UNICODE_SYMBOLS)
+    .filter(([key]) => key.startsWith("FRACTION_"))
+    .map(([, glyph]) => glyph)
+    .join("")}]`);
 const isPathContext = (before) => {
     const parts = before.split(/\s+/);
     const trailing = parts[parts.length - 1];
+    if (FRACTION_GLYPH_RE.test(trailing))
+        return true;
     const slashIdx = trailing.indexOf("/");
     return slashIdx >= 0 && slashIdx < trailing.length - 1;
 };
-function contextAwareLegalReplace(text, pattern, replacement, shouldConvert, separator) {
-    return text.replace(pattern, (match, offset, str) => {
-        const before = str
-            .slice(Math.max(0, offset - LEGAL_SYMBOL_CONTEXT_WINDOW), offset)
-            .replaceAll(separator, "");
-        const after = str
-            .slice(offset + match.length, offset + match.length + LEGAL_SYMBOL_CONTEXT_WINDOW)
-            .replaceAll(separator, "");
-        return shouldConvert(before, after) ? replacement : match;
+function contextAwareLegalReplace(view, pattern, replacement, shouldConvert) {
+    const text = view.text;
+    replaceAllInView(view, pattern, (match, v) => {
+        const offset = match.index;
+        const before = legalContextBefore(text, v, offset);
+        const after = legalContextAfter(text, v, offset + match[0].length);
+        return shouldConvert(before, after) ? replacement : null;
+    }, {
+        // The `(c)`/`(r)`/`(tm)` token itself never spans a boundary (no interior
+        // slot), so a match containing an interior boundary is skipped, exactly as
+        // the default behavior.
+        allowBoundaries: undefined,
     });
 }
-const LEGAL_COPYRIGHT_RE = /\(c\)/gi;
-const LEGAL_REGISTERED_RE = /\(r\)/gi;
-const LEGAL_TRADEMARK_RE = /\(tm\)/gi;
-/** Convert (c), (r), (tm) to ©, ®, ™. */
-export function legalSymbols(text, options = {}) {
-    const separator = options.separator ?? DEFAULT_SEPARATOR;
-    // (c) → © only with positive copyright evidence (year or "copyright" keyword)
-    // and not in a path context (e.g., example.com/path(c))
-    text = contextAwareLegalReplace(text, LEGAL_COPYRIGHT_RE, COPYRIGHT, (before, after) => !isPathContext(before) && (/^\s*(?:19|20)\d{2}\b/.test(after) || /\bcopyright\s*$/i.test(before)), separator);
-    // (r) → ® unless in enumeration "(q), (r)", legal citation "(r)(1)", or path context
-    text = contextAwareLegalReplace(text, LEGAL_REGISTERED_RE, REGISTERED, (before, after) => !/\([a-z]\)[,;]\s*$/i.test(before) && !/^\(\d/.test(after) && !isPathContext(before), separator);
-    // (tm) → ™ unless in a path context
-    text = contextAwareLegalReplace(text, LEGAL_TRADEMARK_RE, TRADEMARK, (before) => !isPathContext(before), separator);
-    return text;
-}
-// Leading `<` on bidi anchors the dash-run group for linear time.
-const ARROW_RULES = [
-    [(sep) => `<${sep}?-+(?:${sep}-+)*${sep}?>`, ARROW_LEFT_RIGHT],
-    [(sep) => `-+${sep}?>`, ARROW_RIGHT],
-    [(sep) => `<${sep}?-+`, ARROW_LEFT],
+/**
+ * Context preceding `offset`, spanning the 25-character window. Each node
+ * boundary costs {@link BOUNDARY_CONTEXT_COST} characters of the window, so a
+ * region dense with boundaries exposes fewer characters of context.
+ */
+function legalContextBefore(text, view, offset) {
+    let cost = 0;
+    let i = offset;
+    while (i > 0) {
+        // Cost of stepping back over this clean char plus the boundaries hugging it.
+        cost += boundaryCountAt(view, i) * BOUNDARY_CONTEXT_COST + 1;
+        if (cost > LEGAL_SYMBOL_CONTEXT_WINDOW)
+            break;
+        i--;
+    }
+    return text.slice(i, offset);
+}
+/** Mirror of {@link legalContextBefore} for the text following `end`. */
+function legalContextAfter(text, view, end) {
+    let cost = 0;
+    let i = end;
+    while (i < text.length) {
+        cost += boundaryCountAt(view, i) * BOUNDARY_CONTEXT_COST + 1;
+        if (cost > LEGAL_SYMBOL_CONTEXT_WINDOW)
+            break;
+        i++;
+    }
+    return text.slice(end, i);
+}
+const LEGAL_COPYRIGHT_RE = "\\(c\\)";
+const LEGAL_REGISTERED_RE = "\\(r\\)";
+const LEGAL_TRADEMARK_RE = "\\(tm\\)";
+export function legalSymbols(input) {
+    return overInput(input, legalSymbolsOverView);
+}
+function legalSymbolsOverView(view) {
+    // (c) → © only with positive copyright evidence (year or "copyright"
+    // keyword) and not in a path context (e.g. example.com/path(c)).
+    contextAwareLegalReplace(view, cachedRegExp(LEGAL_COPYRIGHT_RE, "gi"), COPYRIGHT, (before, after) => !isPathContext(before) && (/^\s*(?:19|20)\d{2}\b/.test(after) || /\bcopyright\s*$/i.test(before)));
+    view.commit();
+    // (r) → ® unless in enumeration "(q), (r)", legal citation "(r)(1)", or path context.
+    contextAwareLegalReplace(view, cachedRegExp(LEGAL_REGISTERED_RE, "gi"), REGISTERED, (before, after) => !/\([a-z]\)[,;]\s*$/i.test(before) && !/^\(\d/.test(after) && !isPathContext(before));
+    view.commit();
+    // (tm) → ™ unless in a path context.
+    contextAwareLegalReplace(view, cachedRegExp(LEGAL_TRADEMARK_RE, "gi"), TRADEMARK, (before) => !isPathContext(before));
+    view.commit();
+}
+const SPACE_OR_TAB_RE = /\s/;
+/**
+ * One boundary is tolerated after `<`, between dash runs, and before `>`, and a
+ * boundary cannot split a dash run (`-+`). Each helper walks the clean text and
+ * consults boundaries at exactly those positions, tolerating at most one
+ * boundary per slot.
+ */
+const ARROW_MATCHERS = [
+    [matchLeftRightArrow, ARROW_LEFT_RIGHT],
+    [matchRightArrow, ARROW_RIGHT],
+    [matchLeftArrow, ARROW_LEFT],
 ];
-/** Convert -> and <-> to arrows. */
-export function arrows(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    const sepPattern = cachedRegExp(chr, "g");
-    // Boundary on the left is a capturing group rather than a lookbehind so
-    // the alternation stays out of the assertion (recheck-safe); the captured
-    // boundary char is re-emitted before the replacement.
-    const startBoundary = `(^|\\s|${chr})`;
-    const endBoundary = `(?=\\s|${chr}|$)`;
-    for (const [buildArrow, replacement] of ARROW_RULES) {
-        const pattern = cachedRegExp(`${startBoundary}${buildArrow(chr)}${endBoundary}`, "g");
-        // Re-emit every separator the arrow body consumed; dropping any would
-        // break the text-node-count invariant in transformTextNodes.
-        text = text.replace(pattern, (match, boundary) => {
-            const arrowPart = match.slice(boundary.length);
-            const seps = arrowPart.match(sepPattern) ?? [];
-            return `${boundary}${replacement}${seps.join("")}`;
-        });
+/** Length of a `-+` dash run at `pos` (no boundary may split it); 0 if none. */
+function dashRunLength(view, text, pos) {
+    let i = pos;
+    while (text[i] === "-" && (i === pos || boundaryCountAt(view, i) === 0))
+        i++;
+    return i - pos;
+}
+/** Skip at most one boundary slot at `pos`; returns the offset after it. -1 on a double boundary. */
+function arrowSepSlot(view, pos) {
+    const count = boundaryCountAt(view, pos);
+    return count <= 1 ? pos : -1;
+}
+/** `-+${sep}?>`: a dash run, an optional boundary, then `>`. */
+function matchRightArrow(view, text, start) {
+    const run = dashRunLength(view, text, start);
+    if (run === 0)
+        return -1;
+    const beforeGt = start + run;
+    if (arrowSepSlot(view, beforeGt) < 0)
+        return -1;
+    return text[beforeGt] === ">" ? beforeGt + 1 : -1;
+}
+/** `<${sep}?-+`: `<`, an optional boundary, then a dash run. */
+function matchLeftArrow(view, text, start) {
+    if (text[start] !== "<")
+        return -1;
+    const afterLt = start + 1;
+    if (arrowSepSlot(view, afterLt) < 0)
+        return -1;
+    const run = dashRunLength(view, text, afterLt);
+    return run === 0 ? -1 : afterLt + run;
+}
+/** `<${sep}?-+(?:${sep}-+)*${sep}?>`: bidirectional arrow with dash runs. */
+function matchLeftRightArrow(view, text, start) {
+    if (text[start] !== "<")
+        return -1;
+    let i = start + 1;
+    if (arrowSepSlot(view, i) < 0)
+        return -1;
+    let run = dashRunLength(view, text, i);
+    if (run === 0)
+        return -1;
+    i += run;
+    // Additional `${sep}-+` runs: each separated by exactly one boundary.
+    while (boundaryCountAt(view, i) === 1) {
+        run = dashRunLength(view, text, i);
+        if (run === 0)
+            break;
+        i += run;
+    }
+    if (arrowSepSlot(view, i) < 0)
+        return -1;
+    return text[i] === ">" ? i + 1 : -1;
+}
+/** Left context `(^|\s|${chr})`: start of text, a space, or a node boundary. */
+function arrowLeftContextOk(view, text, start) {
+    if (start === 0 || view.hasBoundary(start))
+        return true;
+    return SPACE_OR_TAB_RE.test(text[start - 1]);
+}
+/** Right context `(?=\s|${chr}|$)`: end of text, a space, or a node boundary. */
+function arrowRightContextOk(view, text, end) {
+    if (end >= text.length || view.hasBoundary(end))
+        return true;
+    return SPACE_OR_TAB_RE.test(text[end]);
+}
+export function arrows(input) {
+    return overInput(input, arrowsOverView);
+}
+function arrowsOverView(view) {
+    // Each arrow shape is matched by a left-to-right scan so a boundary that
+    // splits a dash run still lets the valid suffix match. The whole shape span is
+    // replaced with the arrow; consumed boundaries collapse to just after it.
+    for (const [matcher, replacement] of ARROW_MATCHERS) {
+        const text = view.text;
+        let i = 0;
+        while (i < text.length) {
+            if (!arrowLeftContextOk(view, text, i)) {
+                i++;
+                continue;
+            }
+            const end = matcher(view, text, i);
+            if (end < 0 || !arrowRightContextOk(view, text, end)) {
+                i++;
+                continue;
+            }
+            view.replace(i, end, replacement);
+            i = end;
+        }
+        view.commit();
+    }
+}
+export function degrees(input) {
+    return overInput(input, degreesOverView);
+}
+function degreesOverView(view) {
+    // Temperature with optional space before C or F (uppercase only). One boundary
+    // is tolerated between the digit and the unit, and the unit is followed by
+    // `(?!-[A-Za-z…]|[+#])` (reject "C-compiler", "C++", "F#") plus a word
+    // boundary. Those trailing assertions are checked manually so a node boundary
+    // right after the unit shadows the compound character, and the word-boundary
+    // arm sees through up to three boundaries.
+    const pattern = cachedRegExp(`\\d ?(?<unit>[CF])`, "g");
+    const text = view.text;
+    replaceAllInView(view, pattern, (match, v) => {
+        const unitEnd = match.index + match[0].length;
+        if (!degreeUnitFollowOk(text, v, unitEnd))
+            return null;
+        const { unit } = match.groups;
+        // Replace everything after the leading digit (the optional space and the
+        // unit) with ` °C`/` °F`, leaving the digit and any boundary right after it
+        // in place so the boundary keeps its position.
+        v.replace(match.index + 1, unitEnd, ` ${DEGREE}${unit}`);
+        return null;
+    }, {
+        allowBoundaries: (match, v) => digitSuffixBoundaryOk(match, v),
+    });
+    view.commit();
+}
+/**
+ * The `(?!-[A-Za-z…]|[+#])` compound guard plus `\b(?!${chr}{0,3}\w)` word
+ * boundary that follow the unit. A node boundary directly after the unit
+ * shadows a `+`/`#`/`-`, satisfying the compound guard; the word boundary
+ * blocks only when a word character follows the unit through at most three
+ * boundaries.
+ */
+function degreeUnitFollowOk(text, view, unitEnd) {
+    const boundaryAfterUnit = view.hasBoundary(unitEnd);
+    // Compound guard: `+`/`#` directly after the unit (no boundary shadowing it),
+    // or `-` directly followed by a Latin letter (boundary-aware).
+    if (!boundaryAfterUnit) {
+        const next = text[unitEnd];
+        if (next === "+" || next === "#")
+            return false;
+        if (next === "-" && !view.hasBoundary(unitEnd + 1) && LATIN_LETTER_RE.test(text[unitEnd + 1] ?? ""))
+            return false;
     }
-    return text;
-}
-export function degrees(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    // Temperature with optional space before C or F (uppercase only)
-    // Handles separator between digit and unit
-    // Uses marker-aware boundary to avoid false matches like "20C\uE000elsius"
-    const wbe = wordBoundaryEnd(chr);
-    // Reject C/F followed by hyphen+letter ("C-compiler"), +/# ("C++", "F#")
-    const notCompound = `(?!-[${LATIN_LETTERS}]|[+#])`;
-    return text.replace(cachedRegExp(`(?<num>\\d${chr}?) ?(?<unit>[CF])${notCompound}${wbe}`, "g"), (_, num, unit) => `${num} ${DEGREE}${unit}`);
-}
-/** Convert 5'10" to 5′10″ (prime marks). Call before smart quotes. */
-export function primeMarks(text, options = {}) {
-    return convertPrimeMarks(text, options.separator ?? DEFAULT_SEPARATOR);
+    // Word boundary: reject when a word character follows the unit across up to
+    // three boundaries; with no boundary a word character directly after the unit
+    // also removes the `\b`. Consecutive boundaries pile at the same clean offset,
+    // so count them there.
+    const followChar = text[unitEnd];
+    if (boundaryCountAt(view, unitEnd) <= 3 && followChar !== undefined && WORD_RE.test(followChar))
+        return false;
+    return true;
+}
+/**
+ * Tolerate at most one boundary directly after the leading digit (the single
+ * slot between `\d` and the rest); a second adjacent boundary breaks the slot.
+ * The digit is the first match character, so the only legal interior-boundary
+ * offset is match.index + 1.
+ */
+function digitSuffixBoundaryOk(match, view) {
+    const digitEnd = match.index + 1;
+    const matchEnd = match.index + match[0].length;
+    for (const boundary of view.boundaries) {
+        // Reject any interior boundary that is not the single tolerated slot after
+        // the leading digit.
+        if (boundary > match.index && boundary < matchEnd && boundary !== digitEnd)
+            return false;
+    }
+    return boundaryCountAt(view, digitEnd) <= 1;
+}
+export function primeMarks(input) {
+    return overInput(input, convertPrimeMarks);
 }
 const FRACTION_TUPLES = [
     ["1", "4", UNICODE_SYMBOLS.FRACTION_1_4],
@@ -194,25 +682,82 @@ const FRACTION_TUPLES = [
     ["7", "8", UNICODE_SYMBOLS.FRACTION_7_8],
 ];
 const FRACTION_MAP = Object.fromEntries(FRACTION_TUPLES.map(([n, d, u]) => [`${n}/${d}`, u]));
-/** Convert 1/2, 1/4, etc. to ½, ¼, etc. Single-pass using alternation. */
-export function fractions(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    // Build alternation of exact valid pairs: `1${sep}?/${sep}?4|1${sep}?/${sep}?2|...`
-    // Only exact pairs from FRACTION_TUPLES match — no cross-product.
-    const pairAlternation = FRACTION_TUPLES.map(([n, d]) => `${n}${chr}?/${chr}?${d}`).join("|");
-    // - (?<![/.\d]) prevents matching after slashes, dots, or digits
-    // - (?![/\d]|\.\d) prevents matching before slashes, digits, or decimal points
-    const pattern = cachedRegExp(`(?<![/\\.\\d])(?:${pairAlternation})(?![/\\d]|\\.\\d)`, "g");
-    const sepPattern = cachedRegExp(chr, "g");
-    return text.replace(pattern, (match) => {
-        // Split on separator to isolate the raw fraction and preserve markers.
-        // e.g. "1\uE000/\uE0002" → parts ["1", "/", "2"], separators ["\uE000", "\uE000"]
-        const parts = match.split(sepPattern);
-        const raw = parts.join("");
-        const separators = match.match(sepPattern) ?? [];
-        // Distribute separators: first goes before the unicode char, second after
-        return `${separators[0] ?? ""}${FRACTION_MAP[raw]}${separators[1] ?? ""}`;
+export function fractions(input) {
+    return overInput(input, fractionsOverView);
+}
+function fractionsOverView(view) {
+    // Build alternation of exact valid pairs: `1/4|1/2|...`. Only exact pairs
+    // from FRACTION_TUPLES match — no cross-product. One boundary is tolerated on
+    // each side of the slash, and the pair is surrounded by the lookarounds
+    // `(?<![/.\d])` and `(?![/\d]|\.\d)`. The lookarounds are checked manually so
+    // a node boundary at the numerator's left edge or the denominator's right edge
+    // satisfies them (a boundary is none of those characters).
+    const pairAlternation = FRACTION_TUPLES.map(([n, d]) => `${n}/${d}`).join("|");
+    const pattern = cachedRegExp(`(?:${pairAlternation})`, "g");
+    const text = view.text;
+    replaceAllInView(view, pattern, (match, v) => {
+        const start = match.index;
+        const end = start + match[0].length;
+        if (!fractionLookbehindOk(text, v, start))
+            return null;
+        if (!fractionLookaheadOk(text, v, end))
+            return null;
+        // Distribute interior boundaries: the first lands before the unicode char,
+        // any remaining after it.
+        let firstBoundary = end;
+        for (const boundary of v.boundaries) {
+            if (boundary > start && boundary < end) {
+                firstBoundary = boundary;
+                break;
+            }
+        }
+        if (firstBoundary > start)
+            v.replace(start, firstBoundary, "");
+        v.replace(firstBoundary, end, FRACTION_MAP[match[0]]);
+        return null;
+    }, {
+        allowBoundaries: (match, v) => fractionSlotBoundaryOk(match, v),
     });
+    view.commit();
+}
+/**
+ * `(?<![/.\d])` at the numerator's left edge. A node boundary immediately
+ * before the numerator shadows the clean character (a boundary is not `/`, `.`,
+ * or a digit), so the lookbehind passes.
+ */
+function fractionLookbehindOk(text, view, start) {
+    if (start === 0 || view.hasBoundary(start))
+        return true;
+    return !/[/.\d]/.test(text[start - 1]);
+}
+/**
+ * `(?![/\d]|\.\d)` at the denominator's right edge. A node boundary immediately
+ * after the denominator shadows the clean characters, satisfying the lookahead.
+ */
+function fractionLookaheadOk(text, view, end) {
+    if (view.hasBoundary(end))
+        return true;
+    const next = text[end];
+    if (next === undefined)
+        return true;
+    if (/[/\d]/.test(next))
+        return false;
+    // `\.\d`: a dot directly followed by a digit (a node boundary between them
+    // breaks the pair, so re-test for the boundary).
+    if (next === "." && !view.hasBoundary(end + 1) && /\d/.test(text[end + 1] ?? ""))
+        return false;
+    return true;
+}
+/**
+ * A fraction tolerates one boundary on each side of the slash (two slots). The
+ * numerator and denominator are single digits, so the match spans exactly
+ * `digit/digit` and the only interior-boundary offsets are right before the
+ * slash (match.index + 1) and right after it (match.index + 2); each accepts at
+ * most one boundary.
+ */
+function fractionSlotBoundaryOk(match, view) {
+    const slashOffset = match.index + 1;
+    return boundaryCountAt(view, slashOffset) <= 1 && boundaryCountAt(view, slashOffset + 1) <= 1;
 }
 const ORDINAL_MAP = {
     st: SUPERSCRIPT_ST,
@@ -220,61 +765,108 @@ const ORDINAL_MAP = {
     rd: SUPERSCRIPT_RD,
     th: SUPERSCRIPT_TH,
 };
-/** Convert 1st, 2nd, 3rd, 4th to superscript ordinals. */
-export function superscriptOrdinal(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    // Match number + optional separator + ordinal suffix at word boundary
-    // Use case-insensitive matching for the suffix
-    // Uses marker-aware boundary to avoid false matches like "1st\uE000ly"
-    const wbe = wordBoundaryEnd(chr);
-    const pattern = cachedRegExp(`(?<num>\\d${chr}?)(?<suffix>st|nd|rd|th)${wbe}`, "gi");
-    return text.replace(pattern, (_match, num, suffix) => {
-        const superscriptSuffix = ORDINAL_MAP[suffix.toLowerCase()];
-        return num + superscriptSuffix;
-    });
+export function superscriptOrdinal(input) {
+    return overInput(input, superscriptOrdinalOverView);
 }
-// Preserves highest-priority space type (NBSP > NNBSP > regular) and leading indentation.
-export function collapseSpaces(text) {
-    return text.replace(cachedRegExp(`(?<=[^\\n${SPACE_CHARS}])[${SPACE_CHARS}]{2,}`, "g"), (match) => {
-        if (match.includes(NBSP))
-            return NBSP;
-        if (match.includes(UNICODE_SYMBOLS.NNBSP))
-            return UNICODE_SYMBOLS.NNBSP;
-        return " ";
+function superscriptOrdinalOverView(view) {
+    // Match number + ordinal suffix at word boundary, case-insensitively. One
+    // boundary is tolerated between the digit and the suffix, with a word boundary
+    // after the suffix. Only the suffix is replaced, leaving the digit and any
+    // boundary between them untouched so the boundary keeps its position.
+    const pattern = cachedRegExp(`(?<num>\\d)(?<suffix>st|nd|rd|th)\\b(?![${LATIN_LETTERS}\\d])`, "gi");
+    replaceAllInView(view, pattern, (match, v) => {
+        const { num, suffix } = match.groups;
+        const suffixStart = match.index + num.length;
+        v.replace(suffixStart, match.index + match[0].length, ORDINAL_MAP[suffix.toLowerCase()]);
+        return null;
+    }, {
+        allowBoundaries: (match, v) => digitSuffixBoundaryOk(match, v),
     });
+    view.commit();
+}
+export function collapseSpaces(input) {
+    return overInput(input, collapseSpacesOverView);
+}
+/**
+ * Collapses each run of two or more space characters to its highest-priority
+ * space. A run never crosses a node boundary, and the anchor requiring a
+ * non-newline, non-space character before the run is satisfied by a boundary
+ * (so a run opening a node still collapses); runs at line or text start are
+ * preserved so indented blocks survive.
+ */
+function collapseSpacesOverView(view) {
+    const text = view.text;
+    let i = 0;
+    while (i < text.length) {
+        if (!SPACE_CHAR_RE.test(text[i])) {
+            i++;
+            continue;
+        }
+        let end = i + 1;
+        while (end < text.length && SPACE_CHAR_RE.test(text[end]) && !view.hasBoundary(end))
+            end++;
+        const anchored = view.hasBoundary(i) || (i > 0 && text[i - 1] !== "\n" && !SPACE_CHAR_RE.test(text[i - 1]));
+        if (anchored && end - i >= 2) {
+            const run = text.slice(i, end);
+            const kept = run.includes(NBSP) ? NBSP : run.includes(UNICODE_SYMBOLS.NNBSP) ? UNICODE_SYMBOLS.NNBSP : " ";
+            view.replace(i, end, kept);
+        }
+        i = end;
+    }
+    view.commit();
 }
 // Order matters: mixed punctuation first, then repeated.
 const PUNCTUATION_LIGATURE_MAP = [
-    ["\\?", "!", QUESTION_EXCLAMATION], // ?!+ → ⁈
-    ["!", "\\?", EXCLAMATION_QUESTION], // !?+ → ⁉
-    ["\\?", "\\?", DOUBLE_QUESTION], // ??+ → ⁇
+    ["?", "!", QUESTION_EXCLAMATION], // ?!+ → ⁈
+    ["!", "?", EXCLAMATION_QUESTION], // !?+ → ⁉
+    ["?", "?", DOUBLE_QUESTION], // ??+ → ⁇
     ["!", "!", "!"], // !!+ → ! (normalize)
 ];
-/** Convert ?? to ⁇, ?! to ⁈, !? to ⁉. Disabled by default (poor font support). */
-export function punctuationLigatures(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    const sepPattern = cachedRegExp(chr, "g");
+export function punctuationLigatures(input) {
+    return overInput(input, punctuationLigaturesOverView);
+}
+function punctuationLigaturesOverView(view) {
     for (const [first, repeated, replacement] of PUNCTUATION_LIGATURE_MAP) {
-        const pattern = cachedRegExp(`${first}(?:${chr}?${repeated})+`, "g");
-        // Re-emit every separator that fell inside the match. The repeat group
-        // can swallow more than one (e.g. across 3+ split text nodes), and
-        // dropping any of them breaks transformTextNodes's text-node-count
-        // invariant.
-        text = text.replace(pattern, (match) => {
-            const seps = match.match(sepPattern) ?? [];
-            return replacement + seps.join("");
-        });
-    }
-    return text;
-}
-export function symbolTransform(text, options = {}) {
-    text = ellipsis(text, options);
-    text = multiplication(text, options);
-    text = mathSymbols(text, options);
-    text = legalSymbols(text, options);
-    if (options.includeArrows !== false) {
-        text = arrows(text, options);
+        // The rule is `first (repeated)+`: the leading char, then one or more
+        // repeated chars each preceded by at most one boundary (a second adjacent
+        // boundary breaks the run). A left-to-right scan replaces the whole run with
+        // the ligature; consumed boundaries collapse to just after it, and a broken
+        // run re-anchors at the next leading char.
+        const text = view.text;
+        let i = 0;
+        while (i < text.length) {
+            if (text[i] !== first) {
+                i++;
+                continue;
+            }
+            let end = i + 1;
+            let consumed = 0;
+            for (;;) {
+                const afterSep = arrowSepSlot(view, end);
+                if (afterSep < 0 || text[afterSep] !== repeated)
+                    break;
+                end = afterSep + 1;
+                consumed++;
+            }
+            if (consumed === 0) {
+                i++;
+                continue;
+            }
+            view.replace(i, end, replacement);
+            i = end;
+        }
+        view.commit();
     }
-    return text;
+}
+export function symbolTransform(input, options = {}) {
+    return overInput(input, (view) => {
+        ellipsisOverView(view);
+        multiplicationOverView(view);
+        mathSymbolsOverView(view);
+        legalSymbolsOverView(view);
+        if (options.includeArrows !== false) {
+            arrowsOverView(view);
+        }
+    });
 }
 //# sourceMappingURL=symbols.js.map