punctilio 4.3.0 → 5.0.0

package/dist/dashes.js

@@ -1,13 +1,8 @@
-import { cachedRegExp, DEFAULT_SEPARATOR, getEscapedSeparator, LATIN_LETTERS, UNICODE_SYMBOLS, wordBoundaryEnd, wordBoundaryStart } from "./constants.js";
+import { cachedRegExp, LATIN_LETTERS, NBSP_CHARS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js";
+import { boundaryCountAt, overInput, replaceAllInView } from "./prose-view.js";
 import { namedGroups } from "./utils.js";
 export const DASH_STYLES = ["american", "british", "none"];
-const { EN_DASH, EM_DASH, MINUS, MULTIPLICATION, PLUS_MINUS, SUPERSCRIPT_ST, SUPERSCRIPT_ND, SUPERSCRIPT_RD, SUPERSCRIPT_TH, LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, LEFT_SINGLE_QUOTE, RIGHT_SINGLE_QUOTE } = UNICODE_SYMBOLS;
-// Characters a later pass produces from a trailing *word* character: the symbol
-// pass turns "x" into "×", and the superscript pass turns the ordinal letters
-// "st"/"nd"/"rd"/"th" into superscripts. Before conversion those word chars block
-// a range via the trailing word boundary ("1-55x5", "5--1st"); rejecting their
-// non-word replacements keeps a second pass from en-dashing the same range.
-const SYMBOL_PASS_TRAILING = `${MULTIPLICATION}${SUPERSCRIPT_ST}${SUPERSCRIPT_ND}${SUPERSCRIPT_RD}${SUPERSCRIPT_TH}`;
+const { EN_DASH, EM_DASH, MINUS, MULTIPLICATION, PLUS_MINUS, LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, LEFT_SINGLE_QUOTE, RIGHT_SINGLE_QUOTE, SUPERSCRIPT_ST, SUPERSCRIPT_ND, SUPERSCRIPT_RD, SUPERSCRIPT_TH, } = UNICODE_SYMBOLS;
 // Prevents false-positive ranges in model names like "Llama-2-7B".
 export const numberRangeDisallowedPrefixes = ["-", EN_DASH, EM_DASH, MINUS];
 // Non-ASCII dashes escaped to \uXXXX for safe embedding in [...] classes.
@@ -22,187 +17,1186 @@ const months = [
     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 ];
 const monthPattern = months.join("|");
-/** Convert number ranges to en-dash (e.g., "1-5" → "1–5"). */
-export function enDashNumberRange(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    const wb = wordBoundaryStart(chr);
-    const wbe = wordBoundaryEnd(chr);
-    // Common currency symbols for price ranges
-    const currencies = "$€£¥₹";
-    // Build positive range pattern from readable components
-    const phoneAreaCode = `(?<precedingAreaCode>\\d{3}-|\\(\\d{3}\\) ?)?`; // 555- or (555)
-    // Lookbehind prevents matching after dashes, so Llama-2-7B and +44-20 don't en-dash.
-    // `${MULTIPLICATION}${PLUS_MINUS}` keep ranges stable across the symbol pass, which
-    // runs after this one: a range start preceded by `x` (a Latin letter) or `+`/`-` is
-    // already rejected here, and the symbol pass rewrites "5x10" → "5×10" and "+/-1" →
-    // "±1". Rejecting `×` and `±` too means a second pass over those outputs doesn't
-    // suddenly en-dash a tail the first pass left alone (e.g. "5x10-20" → "5×10-20").
-    const notAfterDash = `(?<![${DISALLOWED_PREFIX_CLASS_FRAGMENT}${LATIN_LETTERS}${MULTIPLICATION}${PLUS_MINUS}.+])`;
-    const rangeStart = `(?<start>(?:p\\.?|[${currencies}])?\\d[\\d.,]*${chr}?)`; // p.10, $100, 1,000
-    const rangeEnd = `(?<end>${chr}?[${currencies}]?\\d[\\d.,]*)`; // 20, $200, 2,000
-    const moreSegments = `(?<following>(?:${chr}?[-${MINUS}]${chr}?\\d+)*)`; // -4567 in phone numbers
-    const unitSuffix = `(?<suffix>${chr}?(?:[AaPp][Mm]|[xKBTM]))?`; // am/pm, K/M/B
-    // Positive ranges: 1-5, 5--10, $100-$200, €5-€10, p.10-15
-    const positiveRangePattern = [
-        phoneAreaCode, wb, notAfterDash, rangeStart, "-{1,3}", rangeEnd, moreSegments, unitSuffix, wbe
-    ].join("");
-    text = text.replace(cachedRegExp(positiveRangePattern, "g"), (...args) => {
-        const groups = namedGroups(args);
-        if (groups.following)
-            return args[0];
-        // A range whose end abuts a symbol-pass replacement (× or a superscript
-        // ordinal) is an operand, not a range (e.g. "1-55×5", "5--1ˢᵗ"). This
-        // mirrors `notAfterDash` on the trailing side; done in the callback rather
-        // than as a regex lookahead to keep the composed pattern ReDoS-safe.
-        const matchEnd = args.at(-3) + args[0].length;
-        if (cachedRegExp(`^${chr}?[${SYMBOL_PASS_TRAILING}]`, "").test(args.at(-2).slice(matchEnd))) {
-            return args[0];
-        }
-        const startNum = groups.start.replace(cachedRegExp(chr, "g"), "");
-        const endNum = groups.end.replace(cachedRegExp(chr, "g"), "");
-        if (/^(?:19|20)\d{2}$/.test(startNum) && /^(?:0[1-9]|1[0-2])$/.test(endNum))
-            return args[0];
-        // Skip 3+4 digit phone-shaped patterns (555-1234, or the second half of
-        // 555-123-4567). Thousands-grouped endings (1,234 / 1.234) keep their
-        // internal separator and so fail /^\d{4}$/, falling through to convert
-        // as ranges. Space/NNBSP/thin-space grouping isn't captured by the outer
-        // range regex, so those variants currently aren't affected here.
-        if (/^\d{3}$/.test(startNum) && /^\d{4}$/.test(endNum))
-            return args[0];
-        // Skip US toll-free prefix pattern: 1-800, 1-888, 1-877, etc. Only the
-        // seven real toll-free codes (800, 888, 877, 866, 855, 844, 833) are
-        // blocked, so genuine ranges like 1-850 or 1-810 still en-dash.
-        if (/^1$/.test(startNum) && /^8(?:00|88|77|66|55|44|33)$/.test(endNum))
-            return args[0];
-        return `${groups.precedingAreaCode ?? ""}${groups.start}${EN_DASH}${groups.end}${groups.suffix ?? ""}`;
-    });
-    // Negative ranges: −5-5 → −5–5, −5--2 → −5–−2
-    // Separate regex because MINUS isn't a word char, so \b in ${wb} would match after it
-    text = text.replace(cachedRegExp(`(?<![${LATIN_LETTERS}])(?<start>${MINUS}\\d[\\d.,]*${chr}?)-{1,3}?(?<neg>-)?(?<end>${chr}?\\d[\\d.,]*)(?<following>(?:${chr}?-${chr}?\\d+)*)(?<suffix>${chr}?[xKBTM])?${wbe}`, "g"), (...args) => {
-        const groups = namedGroups(args);
-        if (groups.following)
-            return args[0];
-        return `${groups.start}${EN_DASH}${groups.neg ? MINUS : ""}${groups.end}${groups.suffix ?? ""}`;
+const WORD_CHAR_RE = /\w/;
+const LATIN_LETTER_RE = new RegExp(`[${LATIN_LETTERS}]`);
+/**
+ * Glyphs the symbol passes fold word characters into (multiplication `x` →
+ * `×`, ordinal suffixes → superscripts). The dash rules run before those
+ * passes, so their word-character tests must treat a folded glyph like the
+ * word character it folds from — otherwise a range blocked at `6x3` converts
+ * once a re-run sees `6×3`.
+ */
+const FOLDED_WORD_CHARS = new Set([
+    MULTIPLICATION,
+    ...SUPERSCRIPT_ST, ...SUPERSCRIPT_ND, ...SUPERSCRIPT_RD, ...SUPERSCRIPT_TH,
+]);
+/** `\w` extended with {@link FOLDED_WORD_CHARS} for fold-stable `\b` checks. */
+function isWordChar(ch) {
+    return ch !== undefined && (WORD_CHAR_RE.test(ch) || FOLDED_WORD_CHARS.has(ch));
+}
+/**
+ * Glyphs the math-symbol pass folds two-character operators into (`=~` → `≈`,
+ * `!=` → `≠`, ...). The fold tolerates one node boundary at its junction, so
+ * it can consume the character that sat between a boundary and a dash.
+ */
+const FOLDED_MATH_OPERATORS = new Set([
+    UNICODE_SYMBOLS.APPROXIMATE,
+    UNICODE_SYMBOLS.GREATER_EQUAL,
+    UNICODE_SYMBOLS.LESS_EQUAL,
+    UNICODE_SYMBOLS.NOT_EQUAL,
+    UNICODE_SYMBOLS.PLUS_MINUS,
+]);
+/**
+ * Glyphs the symbol passes fold from a source ending in a dash char (`<-` →
+ * `←`, `+-` → `±`). Where a trailing hyphen blocks a dash rule, its folded
+ * glyph must keep blocking, or the rule fires only on the re-run.
+ */
+const FOLDED_FROM_TRAILING_DASH = new Set([
+    UNICODE_SYMBOLS.ARROW_LEFT,
+    UNICODE_SYMBOLS.PLUS_MINUS,
+]);
+/** Mirror of {@link FOLDED_FROM_TRAILING_DASH} for sources starting with a
+ * dash char (`->` → `→`). */
+const FOLDED_FROM_LEADING_DASH = new Set([UNICODE_SYMBOLS.ARROW_RIGHT]);
+/**
+ * Runs one boundary-gated regex pass over the view and commits it immediately.
+ * Committing after every pass sequences the passes so a later pass sees the
+ * earlier edits and never queues an overlapping edit.
+ */
+function pass(view, regex, replacer, options) {
+    replaceAllInView(view, regex, replacer, options);
+    view.commit();
+}
+// ---------------------------------------------------------------------------
+// Boundary-tolerance helpers over a ProseView
+//
+// 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. Over a
+// clean ProseView, `replaceAllInView` skips any match with an interior boundary
+// unless `allowBoundaries` opts in. Each pass below builds an `allowBoundaries`
+// callback that admits a match only when every interior boundary sits at a
+// tolerated slot offset.
+// ---------------------------------------------------------------------------
+/** Interior boundary offsets of a match, strictly inside (matchStart, matchEnd). */
+function interiorBoundaryOffsets(match, view) {
+    const start = match.index;
+    const end = match.index + match[0].length;
+    const offsets = [];
+    for (const boundary of view.boundaries) {
+        if (boundary > start && boundary < end)
+            offsets.push(boundary);
+        else if (boundary >= end)
+            break;
+    }
+    return offsets;
+}
+/**
+ * True iff every interior boundary of the match lands on a tolerated offset,
+ * with no offset carrying more boundaries than its budget. A tolerated slot
+ * admits exactly one boundary; two stacked boundaries (an empty fragment)
+ * exceed the single-boundary budget and block the match.
+ */
+function interiorBoundariesAllowed(match, view, tolerated) {
+    const counts = new Map();
+    for (const offset of interiorBoundaryOffsets(match, view)) {
+        counts.set(offset, (counts.get(offset) ?? 0) + 1);
+    }
+    for (const [offset, count] of counts) {
+        const budget = tolerated.get(offset);
+        if (budget === undefined || count > budget)
+            return false;
+    }
+    return true;
+}
+/** Separators tolerated by the word-boundary helpers (mirrors constants.ts). */
+const MAX_BOUNDARY_SEPARATORS = 3;
+/**
+ * Reproduces `wordBoundaryStart` = `(?<!\w${sep}{0,3})\b` at the marked position
+ * `matchStart` (the start char is a word char — a digit). The `\b` requires a
+ * non-word char to its left (a separator counts as non-word); the negative
+ * lookbehind additionally blocks when a word char sits within
+ * {@link MAX_BOUNDARY_SEPARATORS} stacked boundaries to the left.
+ */
+function wordBoundaryStartOk(view, matchStart) {
+    if (matchStart === 0)
+        return true;
+    const nb = boundaryCountAt(view, matchStart);
+    const prevWord = isWordChar(view.text[matchStart - 1]);
+    if (nb === 0)
+        return !prevWord; // `\b` needs a non-word char immediately left
+    // A separator sits left (non-word) so `\b` holds; the lookbehind blocks only
+    // when a word char is within ≤MAX boundaries.
+    return !prevWord || nb > MAX_BOUNDARY_SEPARATORS;
+}
+/**
+ * Reproduces `wordBoundaryEnd` = `\b(?!${sep}{0,3}\w)` at the marked position
+ * `pos`. The `\b` requires a word/non-word transition (a separator counts as
+ * non-word); the negative lookahead blocks when a word char sits within
+ * {@link MAX_BOUNDARY_SEPARATORS} stacked boundaries to the right.
+ */
+function wordBoundaryEndOk(view, pos) {
+    const text = view.text;
+    // `wordBoundaryEndOk` is only ever called at the end of a digit, letter, or
+    // suffix run, so `pos` is always ≥ 1 and `text[pos - 1]` is a real char.
+    const leftWord = isWordChar(text[pos - 1]);
+    // A multiplication sign one space to the right blocks like the word char
+    // it folds from: the multiplication pass renders `5X 8` as `5 × 8`, and a
+    // range blocked at `3-5X` must stay blocked at `3-5 ×`.
+    if (text[pos] !== undefined && SPACE_CHAR_RE.test(text[pos]) && text[pos + 1] === MULTIPLICATION) {
+        return false;
+    }
+    const nb = boundaryCountAt(view, pos);
+    const nextCleanWord = isWordChar(text[pos]);
+    // The marked char right after pos is a separator when nb > 0 (non-word).
+    const rightWord = nb > 0 ? false : nextCleanWord;
+    if (leftWord === rightWord)
+        return false; // no `\b`
+    // `(?!${sep}{0,3}\w)`: a word char within ≤3 boundaries to the right blocks.
+    return !(nb <= MAX_BOUNDARY_SEPARATORS && nextCleanWord);
+}
+// ---------------------------------------------------------------------------
+// Number ranges
+// ---------------------------------------------------------------------------
+const CURRENCY_RE = /[$€£¥₹]/;
+export function enDashNumberRange(input) {
+    return overInput(input, (view) => {
+        convertPositiveRanges(view);
+        convertNegativeRanges(view);
     });
-    return text;
 }
-/** Convert month ranges to en-dash (e.g., "January-March" → "January–March"). */
-export function enDashDateRange(text, options = {}) {
-    const dashStyle = options.dashStyle ?? "american";
+/**
+ * The positive-range shape is `phoneAreaCode? \b (?:p\.?|[currency])?\d[\d.,]*
+ * -{1,3} [currency]?\d[\d.,]* (?:[-−]\d+)* (?:[AaPp][Mm]|[xKBTMCF])? \b`, scanned
+ * left to right. The consume/advance behaviour determines which sub-ranges a
+ * later pass sees. The scan below realizes it: at each offset it attempts the
+ * structural match (boundary-aware), consuming its span on success (whether or
+ * not the dash converts) and advancing one character otherwise. So a multi-segment
+ * number whose head fails to form a structural match (e.g. boundary-broken
+ * "2024-01-15") still exposes a later sub-range ("01-15"), while a structurally
+ * matching but non-converting number hides its inner dashes.
+ */
+function convertPositiveRanges(view) {
+    const text = view.text;
+    let i = 0;
+    while (i < text.length) {
+        const span = matchPositiveRangeAt(view, i);
+        i = span === null ? i + 1 : Math.max(span, i + 1);
+    }
+    view.commit();
+}
+/**
+ * Attempts the `phoneAreaCode? \b rangeStart -{1,3} rangeEnd following* suffix?
+ * \b` structural match beginning at clean offset `i`, converting the dash when
+ * the gates pass. Returns the consumed end offset on a structural match (so the
+ * scan skips it), or null when no structural match begins at `i`.
+ */
+function matchPositiveRangeAt(view, i) {
+    // Optional phoneAreaCode (`\d{3}-` or `(\d{3}) `); when it ends in a dash that
+    // dash can instead be the range dash, so both interpretations are tried.
+    // `rangeStart` carries no leading slot, so a boundary right where it would
+    // begin (just past the area code) invalidates the area-code reading: fall back
+    // to treating the area-code digits as the range start.
+    const areaCode = readPhoneAreaCode(view, i);
+    const startStarts = areaCode === null || view.hasBoundary(i + areaCode) ? [i] : [i + areaCode, i];
+    for (const startStart of startStarts) {
+        const span = matchRangeBody(view, startStart);
+        if (span !== null)
+            return span;
+    }
+    return null;
+}
+const THREE_DIGITS_RE = /^\d\d\d/;
+const THREE_DIGITS_IN_PARENS_RE = /^\(\d\d\d\)/;
+/** `phoneAreaCode` = `\d{3}-|\(\d{3}\) ?` at `i`; returns its length or null. */
+function readPhoneAreaCode(view, i) {
+    const text = view.text;
+    // `\d{3}-` with no boundary inside the digits or before the dash.
+    if (THREE_DIGITS_RE.test(text.slice(i, i + 3)) && text[i + 3] === "-"
+        && !view.hasBoundary(i + 1) && !view.hasBoundary(i + 2) && !view.hasBoundary(i + 3)) {
+        return 4;
+    }
+    // `(\d{3})` with an optional trailing space.
+    if (THREE_DIGITS_IN_PARENS_RE.test(text.slice(i, i + 5))) {
+        return text[i + 5] === " " ? 6 : 5;
+    }
+    return null;
+}
+/**
+ * Matches `\b rangeStart -{1,3} rangeEnd following* suffix? \b` boundary-aware,
+ * beginning the start at `startStart`. Converts the dash on a converting match.
+ * Returns the consumed end offset (structural span end) or null.
+ */
+function matchRangeBody(view, startStart) {
+    const text = view.text;
+    // rangeStart = `(?:p\.?|[currency])?\d[\d.,]*`, anchored at a `\b`.
+    const start = readStartRun(view, startStart);
+    if (start === null)
+        return null;
+    const startSpanEnd = startStart + start.length;
+    // One slot between start and the dash tolerates a single boundary there.
+    if (boundaryCountAt(view, startSpanEnd) > 1)
+        return null;
+    // Dash run of 1..3 hyphens that never spans an interior boundary (a boundary
+    // between two hyphens truncates the run).
+    if (text[startSpanEnd] !== "-")
+        return null;
+    let dashEnd = startSpanEnd + 1;
+    while (text[dashEnd] === "-" && dashEnd - startSpanEnd < 3 && !view.hasBoundary(dashEnd))
+        dashEnd++;
+    if (boundaryCountAt(view, dashEnd) > 1)
+        return null;
+    // `readStartRun` already stops at the first interior boundary, so the start
+    // span is boundary-free and its clean digits are the whole run.
+    const startDigits = text.slice(startStart, startSpanEnd);
+    if (!wordBoundaryStartOk(view, startStart))
+        return null;
+    if (!notAfterDashOk(view, startStart))
+        return null;
+    const end = readEndRun(view, dashEnd);
+    if (end === null)
+        return null;
+    // The greedy end `[\d.,]*` and greedy `following*` backtrack together; the
+    // structural match commits at the longest end whose tail completes.
+    for (let len = end.length; len >= end.minLen; len--) {
+        const endPos = end.firstDigitStart + len;
+        const tail = resolvePositiveTail(view, endPos);
+        if (tail === null)
+            continue;
+        const endStr = text.slice(dashEnd, endPos);
+        if (tail.followingEmpty && rangeNumbersConvert(startDigits, endStr)) {
+            view.replace(startSpanEnd, dashEnd, EN_DASH);
+        }
+        return tail.consumedEnd;
+    }
+    return null;
+}
+/**
+ * The `(?:p\.?|[currency])?\d[\d.,]*` start run, boundary-truncated. The `wb`
+ * (`(?<!\w)\b`) anchors the start at a word boundary, so the currency
+ * alternative is unreachable: a leading currency symbol is non-word, and the only
+ * `\b` sits after it, at the digit — so the currency is never part of `start`
+ * (e.g. "$100-2000" reads start "100", which the 3+4 phone gate then blocks). The
+ * `p`/`p.` prefix is a word char, so it can begin the run at a word boundary.
+ */
+function readStartRun(view, pos) {
+    const text = view.text;
+    let i = pos;
+    if (text[i] === "p") {
+        // `p\.?\d` is contiguous (no interior slot), so a boundary between `p`, an
+        // optional `.`, and the first digit breaks the prefix.
+        if (view.hasBoundary(i + 1))
+            return null;
+        i++;
+        if (text[i] === ".") {
+            if (view.hasBoundary(i + 1))
+                return null;
+            i++;
+        }
+    }
+    // `\d` is required after the optional `p\.?` prefix. The prefix chars are
+    // never digits, so a missing digit here means no start run begins.
+    if (!/\d/.test(text[i] ?? ""))
+        return null;
+    i++;
+    while (/[\d.,]/.test(text[i] ?? "") && !view.hasBoundary(i))
+        i++;
+    return { length: i - pos };
+}
+/** The `[currency]?\d[\d.,]*` end run starting at `pos`, boundary-truncated. */
+function readEndRun(view, pos) {
+    const text = view.text;
+    let i = pos;
+    if (CURRENCY_RE.test(text[i] ?? "")) {
+        // No slot between the currency symbol and the digit.
+        if (view.hasBoundary(i + 1))
+            return null;
+        i++;
+    }
+    if (!/\d/.test(text[i] ?? ""))
+        return null;
+    const firstDigitStart = i;
+    i++;
+    while (/[\d.,]/.test(text[i] ?? "") && !view.hasBoundary(i))
+        i++;
+    return { firstDigitStart, length: i - firstDigitStart, minLen: 1 };
+}
+/**
+ * Resolves the tail at `endPos`: finds the longest `following` whose
+ * `suffix? wbe` completes (the greedy choice). `followingEmpty` reports whether
+ * that following is empty (the convert condition); `consumedEnd` is the tail's
+ * end including any suffix (for the scan's consume/advance). Returns null when
+ * no following completes.
+ */
+function resolvePositiveTail(view, endPos) {
+    const candidates = followingCandidates(view, endPos, true);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const suffixEnd = suffixWbeEnd(view, candidates[i], true);
+        if (suffixEnd !== null) {
+            return { followingEmpty: i === 0, consumedEnd: suffixEnd };
+        }
+    }
+    return null;
+}
+/**
+ * Negative ranges: −5-5 → −5–5, −5--2 → −5–−2. A separate hand scan (not a regex)
+ * because the end run (`\d[\d.,]*`, with one tolerated boundary at its head)
+ * must truncate at node boundaries before its tail is resolved: a regex would
+ * fuse boundary-split digits into one run (e.g. "8{b}{b}{b}{b}{b}0" reads as
+ * "80") and mis-place or miss the conversion. The scan mirrors `matchRangeBody`:
+ * at each MINUS-led start it resolves the longest end whose `following* suffix?
+ * wbe` tail completes, converting only when that tail leaves `following` empty.
+ */
+function convertNegativeRanges(view) {
+    const text = view.text;
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] === MINUS) {
+            const span = matchNegativeRangeAt(view, i);
+            if (span !== null) {
+                i = Math.max(span, i + 1);
+                continue;
+            }
+        }
+        i++;
+    }
+    view.commit();
+}
+/**
+ * Attempts `(?<![LAT]) ${MINUS}\d[\d.,]* -{1,3} -? end following* suffix? wbe`
+ * beginning the MINUS at clean offset `i`. Converts the dash run when the gates
+ * pass. Returns the consumed structural end offset, or null when no match begins.
+ */
+function matchNegativeRangeAt(view, i) {
+    const text = view.text;
+    // `(?<![LAT])`: a Latin letter directly before the MINUS (no intervening
+    // boundary, which would hide it) blocks the match.
+    if (boundaryCountAt(view, i) === 0) {
+        const before = text[i - 1];
+        if (before !== undefined && LATIN_LETTER_RE.test(before))
+            return null;
+    }
+    // start = `${MINUS}\d[\d.,]*`: the digits after MINUS must not cross a
+    // boundary (the `start` body has no interior slot before its trailing one).
+    if (!/\d/.test(text[i + 1] ?? ""))
+        return null;
+    let startEnd = i + 1;
+    while (/[\d.,]/.test(text[startEnd] ?? "") && !view.hasBoundary(startEnd))
+        startEnd++;
+    // One slot between start and the dash tolerates a single boundary there.
+    if (boundaryCountAt(view, startEnd) > 1)
+        return null;
+    if (text[startEnd] !== "-")
+        return null;
+    // `-{1,3}?` then optional `(?<neg>-)`: a 1..3 hyphen run with no interior
+    // boundary, the last of which becomes `neg` when two or more hyphens are present.
+    let dashRunEnd = startEnd + 1;
+    while (text[dashRunEnd] === "-" && dashRunEnd - startEnd < 3 && !view.hasBoundary(dashRunEnd))
+        dashRunEnd++;
+    const dashRunLen = dashRunEnd - startEnd;
+    const hasNeg = dashRunLen >= 2;
+    const negEnd = dashRunEnd;
+    // The `end` head slot tolerates one boundary.
+    if (boundaryCountAt(view, negEnd) > 1)
+        return null;
+    const end = readNegEndRun(view, negEnd);
+    if (end === null)
+        return null;
+    // The greedy end and `following*` backtrack together; commit at the longest end
+    // whose tail completes, converting only when that tail's `following` is empty.
+    for (let len = end.length; len >= 1; len--) {
+        const endPos = end.firstDigitStart + len;
+        const candidates = followingCandidates(view, endPos, false);
+        for (let c = candidates.length - 1; c >= 0; c--) {
+            const suffixEnd = suffixWbeEnd(view, candidates[c], false);
+            if (suffixEnd === null)
+                continue;
+            if (c === 0) {
+                view.replace(startEnd, negEnd, `${EN_DASH}${hasNeg ? MINUS : ""}`);
+            }
+            return suffixEnd;
+        }
+    }
+    return null;
+}
+/** The negative `end` body `\d[\d.,]*` starting at `pos`, boundary-truncated. */
+function readNegEndRun(view, pos) {
+    const text = view.text;
+    if (!/\d/.test(text[pos] ?? ""))
+        return null;
+    let i = pos + 1;
+    while (/[\d.,]/.test(text[i] ?? "") && !view.hasBoundary(i))
+        i++;
+    return { firstDigitStart: pos, length: i - pos };
+}
+/**
+ * Boundary-aware `following` end positions, shortest (empty) first, walking
+ * segments `[-(−)]\d+`. Each segment tolerates one boundary on each side of its
+ * dash, and each `\d+` stops at a boundary. `allowMinus` admits a MINUS as a
+ * segment's dash (positive ranges).
+ */
+function followingCandidates(view, endSpanEnd, allowMinus) {
+    const candidates = [endSpanEnd];
+    let pos = endSpanEnd;
+    for (;;) {
+        if (boundaryCountAt(view, pos) > 1)
+            break;
+        const dashCh = view.text[pos];
+        if (dashCh !== "-" && !(allowMinus && dashCh === MINUS))
+            break;
+        const digitStart = pos + 1;
+        if (boundaryCountAt(view, digitStart) > 1)
+            break;
+        if (!/\d/.test(view.text[digitStart] ?? ""))
+            break;
+        let end = digitStart + 1;
+        while (/\d/.test(view.text[end] ?? "") && !view.hasBoundary(end))
+            end++;
+        pos = end;
+        candidates.push(pos);
+    }
+    return candidates;
+}
+/**
+ * Single-letter range suffixes: the multipliers `x`/`K`/`B`/`T`/`M` and the
+ * temperature units `C`/`F`. The degree pass rewrites `5C` to `5 °C` — a
+ * space a re-run's word boundary sees through — so the range must already
+ * convert with the unit attached. `X` and `×` are deliberately absent: an
+ * unconverted `1-10X` folds to `1-10×`, which the word-boundary check (which
+ * treats `×` as the word char it folds from) keeps blocking on re-runs.
+ */
+const RANGE_SUFFIX_RE = /[xKBTMCF]/;
+/**
+ * The `(?:[AaPp][Mm]|[xKBTMCF])?${wbe}` suffix at `pos`, with one tolerated
+ * boundary before the suffix. Returns the end offset after the optional suffix
+ * when the tail completes (wbe passes), or null when it does not.
+ */
+function suffixWbeEnd(view, pos, allowAmPm) {
+    if (wordBoundaryEndOk(view, pos))
+        return pos;
+    // An optional suffix: one tolerated boundary then am/pm or one of
+    // {@link RANGE_SUFFIX_RE}'s letters, followed by wbe. The suffix letters sit
+    // at the clean `pos`.
+    if (boundaryCountAt(view, pos) > 1)
+        return null;
+    const text = view.text;
+    // `[AaPp][Mm]` is contiguous — a boundary between the two letters breaks the
+    // suffix.
+    if (allowAmPm && /[ap]/i.test(text[pos] ?? "") && /m/i.test(text[pos + 1] ?? "") && !view.hasBoundary(pos + 1)) {
+        return wordBoundaryEndOk(view, pos + 2) ? pos + 2 : null;
+    }
+    if (RANGE_SUFFIX_RE.test(text[pos] ?? "")) {
+        return wordBoundaryEndOk(view, pos + 1) ? pos + 1 : null;
+    }
+    return null;
+}
+const NOT_AFTER_DASH_RE = new RegExp(`[${DISALLOWED_PREFIX_CLASS_FRAGMENT}${LATIN_LETTERS}${MULTIPLICATION}${PLUS_MINUS}.+]`);
+const SPACE_CHAR_RE = new RegExp(`[${SPACE_CHARS}]`);
+/**
+ * Offset of the dot reachable backwards across one inter-dot gap ending at the
+ * dot at `dotIndex` (the mirror of the ellipsis pass's forward gap rule: the
+ * gap is nothing, one space character, or one node boundary). -1 when none.
+ */
+function ellipsisPrevDot(view, dotIndex) {
+    const text = view.text;
+    if (text[dotIndex - 1] === ".") {
+        // Empty gap: at most one boundary between the two dots.
+        return boundaryCountAt(view, dotIndex) <= 1 ? dotIndex - 1 : -1;
+    }
+    // Space gap: one space character with no boundary on either side of it.
+    if (boundaryCountAt(view, dotIndex) === 0 && dotIndex >= 2 && SPACE_CHAR_RE.test(text[dotIndex - 1])
+        && text[dotIndex - 2] === "." && boundaryCountAt(view, dotIndex - 1) === 0) {
+        return dotIndex - 2;
+    }
+    return -1;
+}
+/** True iff the dot at `dotIndex` can close a `...`/`. . .` triple. */
+function endsFoldableEllipsisDots(view, dotIndex) {
+    const second = ellipsisPrevDot(view, dotIndex);
+    return second >= 0 && ellipsisPrevDot(view, second) >= 0;
+}
+/**
+ * `notAfterDash` is a single-char negative lookbehind. A node boundary
+ * immediately before the start hides the clean char (a boundary is not the
+ * dash/letter), so the guard only fires when a disallowed clean char sits
+ * directly before the start with no intervening boundary.
+ *
+ * A `.` that closes a dot triple does not block: the ellipsis pass (which
+ * runs after the dash rules) folds the triple to `…` and pads a following
+ * digit with a space, so a re-run would see a plain space here and convert —
+ * converting now reaches that fixed point in one pass. A line-leading em dash
+ * does not block for the same reason: the em-dash spacing normalizer pads it
+ * before a digit (`^—5` → `— 5`), mirroring that rule's one tolerated
+ * boundary at line start.
+ */
+function notAfterDashOk(view, startOffset) {
+    if (startOffset === 0)
+        return true;
+    if (boundaryCountAt(view, startOffset) > 0)
+        return true;
+    const prev = view.text[startOffset - 1];
+    // A multiplication sign one space slot further left blocks like the `x` it
+    // folds from: the multiplication pass renders `5x8` as `5 × 8`, so a range
+    // blocked at `x8-6` must stay blocked at `× 8-6`.
+    if (prev !== undefined && SPACE_CHAR_RE.test(prev) && view.text[startOffset - 2] === MULTIPLICATION) {
+        return false;
+    }
+    if (prev === undefined || !NOT_AFTER_DASH_RE.test(prev))
+        return true;
+    if (prev === "." && endsFoldableEllipsisDots(view, startOffset - 1))
+        return true;
+    const dashIndex = startOffset - 1;
+    if (prev === EM_DASH && boundaryCountAt(view, dashIndex) <= 1
+        && (dashIndex === 0 || view.text[dashIndex - 1] === "\n" || emDashBehindLeadingSpaces(view, dashIndex))) {
+        return true;
+    }
+    // An en dash behind leading spaces converts the same way: the spaced-dash
+    // rule renders it as a line-leading em dash, which the normalizer then pads.
+    return prev === EN_DASH && boundaryCountAt(view, dashIndex) <= 1
+        && emDashBehindLeadingSpaces(view, dashIndex);
+}
+/**
+ * True iff only plain spaces sit between text start and the em dash at
+ * `emIndex`. The spaced-dash rule collapses that run, leaving the em dash
+ * line-leading, which the spacing normalizer then pads before a digit — the
+ * same state the `\n` arm of {@link notAfterDashOk} accepts.
+ */
+function emDashBehindLeadingSpaces(view, emIndex) {
+    let j = emIndex;
+    while (j > 0 && view.text[j - 1] === " ")
+        j--;
+    return j < emIndex && j === 0;
+}
+/** Range-number gates: reject year-month, phone-shaped, and toll-free pairs. */
+function rangeNumbersConvert(startNum, endNum) {
+    if (/^(?:19|20)\d{2}$/.test(startNum) && /^(?:0[1-9]|1[0-2])$/.test(endNum))
+        return false;
+    // Skip 3+4 digit phone-shaped patterns (555-1234, or the second half of
+    // 555-123-4567). Thousands-grouped endings (1,234 / 1.234) keep their
+    // internal separator and so fail /^\d{4}$/, falling through to convert as
+    // ranges.
+    if (/^\d{3}$/.test(startNum) && /^\d{4}$/.test(endNum))
+        return false;
+    // Skip US toll-free prefix pattern: 1-800, 1-888, 1-877, etc. Only the seven
+    // real toll-free codes (800, 888, 877, 866, 855, 844, 833) are blocked, so
+    // genuine ranges like 1-850 or 1-810 still en-dash.
+    if (/^1$/.test(startNum) && /^8(?:00|88|77|66|55|44|33)$/.test(endNum))
+        return false;
+    return true;
+}
+export function enDashDateRange(input, options = {}) {
+    return overInput(input, (view) => enDashDateRangeOverView(view, options.dashStyle ?? "american"));
+}
+function enDashDateRangeOverView(view, dashStyle) {
     if (dashStyle === "none")
-        return text;
-    const chr = getEscapedSeparator(options);
-    const wb = wordBoundaryStart(chr);
-    const wbe = wordBoundaryEnd(chr);
-    // Atomic-optional year groups (lookahead + backref). The capture inside
-    // the lookahead is locked in once matched, so the year group commits
-    // without backtracking.
-    const startYear = `(?=(?<startYear>${chr}? \\d{4})?)\\k<startYear>`;
-    const endYear = `(?=(?<endYear> \\d{4})?)\\k<endYear>`;
-    return text.replace(cachedRegExp(`${wb}(?<startMonth>${monthPattern})${startYear}(?<preSep>${chr}?)(?<preSpace> ?)-(?<postSpace> ?)(?<postSep>${chr}?)(?<endMonth>${monthPattern})${endYear}${wbe}`, "g"), (...args) => {
-        const groups = namedGroups(args);
-        const [pre, post] = dashStyle === "british" ? [" ", " "] : ["", ""];
-        return `${groups.startMonth}${groups.startYear || ""}${groups.preSep}${pre}${EN_DASH}${post}${groups.postSep}${groups.endMonth}${groups.endYear || ""}`;
+        return;
+    const [pre, post] = dashStyle === "british" ? [" ", " "] : ["", ""];
+    // Atomic-optional year groups (lookahead + backref). The capture inside the
+    // lookahead is locked in once matched, so the year group commits without
+    // backtracking. The year space also matches NBSP/NNBSP: the nbsp pass (which
+    // runs after the dash rules) glues "March 2025" with an NBSP, and the year
+    // must still capture on a re-run so the trailing-boundary gate sees the same
+    // end position.
+    const startYear = `(?=(?<startYear>[ ${NBSP_CHARS}]\\d{4})?)\\k<startYear>`;
+    const endYear = `(?=(?<endYear>[ ${NBSP_CHARS}]\\d{4})?)\\k<endYear>`;
+    const pattern = `\\b(?<startMonth>${monthPattern})${startYear}(?<preSpace> ?)-(?<postSpace> ?)(?<endMonth>${monthPattern})${endYear}\\b`;
+    pass(view, cachedRegExp(pattern, "g"), (match, v) => {
+        // The pattern's trailing `\b` sees a folded glyph (`×`, a superscript
+        // ordinal) as a non-word char, but the source character it folds from is
+        // a word char that blocks the match ("March 2025x3"); re-check the end
+        // boundary fold-stably.
+        if (!wordBoundaryEndOk(v, match.index + match[0].length))
+            return null;
+        const groups = namedGroups(matchArgs(match));
+        // Replace `[preSpace]-[postSpace]` (the dash and its spaces) with the
+        // styled en-dash, leaving the months and any boundaries around them.
+        const startLen = groups.startMonth.length + (groups.startYear?.length ?? 0);
+        const dashSpan = groups.preSpace.length + 1 + groups.postSpace.length;
+        const dashStart = match.index + startLen;
+        v.replace(dashStart, dashStart + dashSpan, `${pre}${EN_DASH}${post}`);
+        return null;
+    }, {
+        allowBoundaries: (match, v) => {
+            const groups = namedGroups(matchArgs(match));
+            const startLen = groups.startMonth.length + (groups.startYear?.length ?? 0);
+            // One boundary is tolerated after the start year and one before the end
+            // month, bracketing the dash and spaces.
+            const dashStart = match.index + startLen;
+            const dashEnd = dashStart + groups.preSpace.length + 1 + groups.postSpace.length;
+            const tolerated = new Map();
+            tolerated.set(dashStart, 1);
+            tolerated.set(dashEnd, 1);
+            if (!interiorBoundariesAllowed(match, v, tolerated))
+                return false;
+            return wordBoundaryStartOk(v, match.index) && wordBoundaryEndOk(v, match.index + match[0].length);
+        },
     });
 }
-/** Convert hyphens to minus signs in numeric contexts (e.g., "-5" → "−5"). */
-export function minusReplace(text, options = {}) {
-    const chr = getEscapedSeparator(options);
-    // Pattern 1a: Subtraction of negative number (e.g., "5 - -3" → "5 − −3")
-    // Must come before Pattern 1b so the negative hyphen is consumed first
-    text = text.replace(cachedRegExp(`(?<=\\d${chr}?) - -(?<num>${chr}?\\d*\\.?\\d+)`, "g"), ` ${MINUS} ${MINUS}$<num>`);
-    // Pattern 1b: Spaced math subtraction (e.g., "5 - 3" → "5 − 3")
-    // Only when preceded by a digit - this distinguishes "5 - 3" from "Safari) - 9"
-    text = text.replace(cachedRegExp(`(?<=\\d${chr}?) - (?<num>${chr}?\\d*\\.?\\d+)`, "g"), ` ${MINUS} $<num>`);
-    // Pattern 2: Direct negative numbers (e.g., "-5" → "−5", "(-3)" → "(−3)")
-    // Match after: start of line, whitespace, (, or quotes (straight or curly)
-    // No space allowed between hyphen and digit
-    text = text.replace(cachedRegExp(`(?<before>^|[\\s\\("'${LEFT_DOUBLE_QUOTE}${RIGHT_DOUBLE_QUOTE}${LEFT_SINGLE_QUOTE}${RIGHT_SINGLE_QUOTE}])-(?<num>\\d*\\.?\\d+)`, "gm"), `$<before>${MINUS}$<num>`);
-    // Pattern 2b: Direct negative numbers after separator boundary (e.g., <em>-5</em>)
-    // Only when no word character precedes the separator — prevents both
-    // "2{SEP}-3" in "1-2-3" and "GPT{SEP}-3" from being misidentified as negative 3
-    text = text.replace(cachedRegExp(`(?<![\\d.,${LATIN_LETTERS}])(?<before>${chr})-(?<num>\\d*\\.?\\d+)`, "gm"), `$<before>${MINUS}$<num>`);
-    return text;
-}
-function convertParentheticalDashes(text, sep, style) {
+export function minusReplace(input) {
+    return overInput(input, (view) => {
+        minusSubtractionOfNegative(view);
+        minusSpacedSubtraction(view);
+        minusDirectNegative(view);
+    });
+}
+/** Pattern 1a/1b: spaced math subtraction after a digit (`5 - 3`, `5 - -3`). */
+function minusSubtractionOfNegative(view) {
+    // "5 - -3" → "5 − −3"; the negative hyphen is consumed first. The slot before
+    // `num` tolerates one boundary there (the `- -` prefix has 4 chars).
+    pass(view, cachedRegExp(`(?<=\\d) - -(?<num>\\d*\\.?\\d+)`, "g"), (match, v) => {
+        // Replace only the ` - -` prefix; `num` (which may carry interior
+        // boundaries that truncate it) stays untouched.
+        if (!minusSubtractionPrefixOk(match, v, 4))
+            return null;
+        v.replace(match.index, match.index + 4, ` ${MINUS} ${MINUS}`);
+        return null;
+    }, { allowBoundaries: () => true });
+}
+function minusSpacedSubtraction(view) {
+    // "5 - 3" → "5 − 3"; only after a digit ("5 - 3" not "Safari) - 9").
+    pass(view, cachedRegExp(`(?<=\\d) - (?<num>\\d*\\.?\\d+)`, "g"), (match, v) => {
+        if (!minusSubtractionPrefixOk(match, v, 3))
+            return null;
+        v.replace(match.index, match.index + 3, ` ${MINUS} `);
+        return null;
+    }, { allowBoundaries: () => true });
+}
+const NUM_BODY_RE = /^\d*\.?\d+/;
+/**
+ * The subtraction patterns tolerate one boundary after the leading digit (at
+ * the match start) and one before `num`. The `-` prefix span ([match.index,
+ * match.index + prefixLen)) must stay boundary-free; one boundary may sit at
+ * `num`'s head. The `num` body (`\d*\.?\d+`) carries no interior slot, so it
+ * stops at the first interior boundary: a boundary that truncates `num` to a
+ * still-valid number (e.g. "12" in "5 - 12{b}5") leaves the match standing, but
+ * one that strips the mandatory `\d+` (e.g. "." in "5 - .{b}5") breaks it. The
+ * targeted edit only rewrites the ` - ` prefix, so a converting match must keep
+ * `num` satisfiable.
+ */
+function minusSubtractionPrefixOk(match, view, prefixLen) {
+    // The slot in the lookbehind (`(?<=\d)`) sits at the match start between the
+    // leading digit and the space; it tolerates at most one boundary.
+    if (boundaryCountAt(view, match.index) > 1)
+        return false;
+    const numStart = match.index + prefixLen;
+    for (const b of view.boundaries) {
+        if (b > match.index && b < numStart)
+            return false;
+    }
+    // The slot before `num` tolerates at most one boundary at the num head.
+    if (boundaryCountAt(view, numStart) > 1)
+        return false;
+    // `num` stops at the first interior boundary; the clean run up to it must
+    // still satisfy `\d*\.?\d+` (the mandatory trailing `\d+`).
+    const numEnd = match.index + match[0].length;
+    let truncatedEnd = numEnd;
+    for (const b of view.boundaries) {
+        if (b > numStart && b < numEnd) {
+            truncatedEnd = b;
+            break;
+        }
+        if (b >= numEnd)
+            break;
+    }
+    return NUM_BODY_RE.test(view.text.slice(numStart, truncatedEnd));
+}
+const MINUS_BEFORE_CLASS_RE = new RegExp(`[\\s("'${LEFT_DOUBLE_QUOTE}${RIGHT_DOUBLE_QUOTE}${LEFT_SINGLE_QUOTE}${RIGHT_SINGLE_QUOTE}]`);
+// The folded word glyphs block like the word chars they fold from ("1x|-0"
+// and "1×|-0" must agree), the folded math operators block like the operator
+// chars they fold from (the `!=` → `≠` fold consumes the `=` that blocked
+// Pattern 2 in "!=-1"), and the folded terminals — plus the bare `!` the
+// `!!` normalization leaves — block like the `!`/`?`/`.` runs they fold from
+// ("?|!-0" folds to "⁈|-0" with the hyphen stranded boundary-adjacent).
+const FOLDED_WORD_CLASS_FRAGMENT = [...FOLDED_WORD_CHARS].join("");
+const FOLDED_MATH_CLASS_FRAGMENT = [...FOLDED_MATH_OPERATORS].join("");
+const FOLDED_TERMINAL_CLASS_FRAGMENT = [
+    UNICODE_SYMBOLS.ELLIPSIS, UNICODE_SYMBOLS.DOUBLE_QUESTION, UNICODE_SYMBOLS.QUESTION_EXCLAMATION,
+    UNICODE_SYMBOLS.EXCLAMATION_QUESTION, UNICODE_SYMBOLS.DOUBLE_EXCLAMATION, UNICODE_SYMBOLS.INTERROBANG, "!",
+].join("");
+const NUM_BEFORE_2B_BLOCK_RE = new RegExp(`[\\d.,${LATIN_LETTERS}${FOLDED_WORD_CLASS_FRAGMENT}${FOLDED_MATH_CLASS_FRAGMENT}${FOLDED_TERMINAL_CLASS_FRAGMENT}]`);
+/**
+ * Direct negative numbers, in two cases: Pattern 2 converts `-\d` after line
+ * start, whitespace, `(`, or a quote; Pattern 2b converts a boundary-led hyphen
+ * `-\d` when no digit/`.`/`,`/Latin precedes the boundary — which prevents
+ * `1{b}-2` and `GPT{b}-3` from reading as negatives. Pattern 2 fires when the
+ * clean char before the hyphen qualifies and no boundary intrudes; Pattern 2b
+ * fires when a boundary leads the hyphen.
+ */
+function minusDirectNegative(view) {
+    pass(view, cachedRegExp(`-(?<num>\\d*\\.?\\d+)`, "gm"), (match, v) => {
+        const start = match.index;
+        // `num` (`\d*\.?\d+`) carries no interior slot, so it stops at the first
+        // interior boundary; the clean run up to it must still satisfy
+        // `\d*\.?\d+`. A boundary right after the hyphen (head) leaves no digits
+        // ("-{b}5"), and one that strips the mandatory `\d+` ("-.{b}1") breaks the
+        // match, but one past a valid number ("-5{b}5") leaves it intact.
+        const numEnd = start + match[0].length;
+        let numTruncEnd = numEnd;
+        for (const b of v.boundaries) {
+            if (b > start && b < numEnd) {
+                numTruncEnd = b;
+                break;
+            }
+            if (b >= numEnd)
+                break;
+        }
+        if (!NUM_BODY_RE.test(v.text.slice(start + 1, numTruncEnd)))
+            return null;
+        // A boundary directly before the hyphen routes to Pattern 2b; otherwise
+        // Pattern 2 examines the clean preceding char. (The two never overlap: a
+        // hyphen has either a boundary or a clean char immediately before it.)
+        const nb = boundaryCountAt(v, start);
+        if (nb > 0) {
+            // Pattern 2b: the char before the boundary run must not be a digit,
+            // `.`, `,`, or Latin letter. With ≥2 stacked boundaries that char is
+            // another boundary (admitted); with one, it is the clean char left.
+            if (nb < 2) {
+                const before = v.text[start - 1];
+                if (before !== undefined && NUM_BEFORE_2B_BLOCK_RE.test(before))
+                    return null;
+            }
+        }
+        else {
+            // Pattern 2: line start, whitespace, `(`, or a quote immediately left.
+            const before = v.text[start - 1];
+            const atLineStart = before === undefined || before === "\n";
+            if (!atLineStart && !MINUS_BEFORE_CLASS_RE.test(before))
+                return null;
+        }
+        v.replace(start, start + 1, MINUS);
+        return null;
+    }, { allowBoundaries: () => true });
+}
+// ---------------------------------------------------------------------------
+// Parenthetical dashes
+// ---------------------------------------------------------------------------
+function convertParentheticalDashes(view, style) {
     const localizedDash = style === "british" ? EN_DASH : EM_DASH;
     const maybeSpace = style === "british" ? " " : "";
-    const escapedSep = getEscapedSeparator({ separator: sep });
-    // Convert spaced dashes: "word - word" or "word — word"
-    // When a separator follows the dash, preserve trailing spaces (they belong to the next text segment).
-    // A single plain hyphen directly before a word character (through optional separators) is a
-    // suspended/hanging hyphen ("Yes-men and -women"), not a parenthetical dash — skip it.
-    // Em/en dashes and multiple hyphens can have zero trailing spaces.
-    // `sepAfter` and `trailing` share one optional unit so a whitespace run
-    // can only be assigned to it as a whole, keeping the match unambiguous.
-    const spacedDashPattern = cachedRegExp(`(?<=[^\\s]|^)(?<sepBefore>${escapedSep}?)[ ]+(?:[${EN_DASH}${EM_DASH}][-${EN_DASH}${EM_DASH}]*|-{2,}|-(?!${escapedSep}*[${LATIN_LETTERS}\\d]))(?!${escapedSep}?-*${escapedSep}?>)[ ]*(?:(?<sepAfter>${escapedSep})(?<trailing>[ ]*))?(?=\\S|$)`, "g");
-    text = text.replace(spacedDashPattern, (_match, sepBefore, sepAfter, trailing) => {
-        // sepAfter and trailing are undefined when the optional group didn't match.
-        sepAfter = sepAfter ?? "";
-        trailing = trailing ?? "";
-        // Trailing space after a separator belongs to the next text node — keep it
-        // regardless of style. Without a separator, the trailing space is part of
-        // the current node's whitespace around the dash and gets consumed.
-        const keepTrailing = sepAfter ? trailing : "";
-        return `${sepBefore}${maybeSpace}${localizedDash}${maybeSpace}${sepAfter}${keepTrailing}`;
-    });
-    // Convert dashes at text node boundaries: separator alone precedes dash (e.g., "word{sep}– rest")
-    // Requires space after the dash to avoid matching number ranges like "1{sep}-{sep}5"
-    text = text.replace(cachedRegExp(`(?<=[^\\s])(?<sepBefore>${escapedSep})[${EN_DASH}${EM_DASH}-]+[ ]+(?<sepAfter>${escapedSep}?)`, "g"), `$<sepBefore>${maybeSpace}${localizedDash}${maybeSpace}$<sepAfter>`);
-    // Convert multiple dashes: "word--word" or "word---word" or "quote"--"quote"
-    // Upper bound of 50 prevents ReDoS on pathological runs of dashes.
-    const quoteChars = `"'${LEFT_DOUBLE_QUOTE}${RIGHT_DOUBLE_QUOTE}${LEFT_SINGLE_QUOTE}${RIGHT_SINGLE_QUOTE}`;
-    text = text.replace(cachedRegExp(`(?<=[${LATIN_LETTERS}\\d${quoteChars}])(?<sepBefore>${escapedSep}?)[${EN_DASH}${EM_DASH}-]{2,50}(?<sepAfter>${escapedSep}?)(?=[${LATIN_LETTERS}${quoteChars} ])`, "g"), `$<sepBefore>${maybeSpace}${localizedDash}${maybeSpace}$<sepAfter>`);
-    // Convert dashes at start of line
-    text = text.replace(cachedRegExp(`^(?<leadingSep>${escapedSep})?[-]+ `, "gm"), `$<leadingSep>${localizedDash} `);
-    // British: convert unspaced em-dashes to spaced en-dashes (word—word → word – word)
-    if (style === "british") {
-        text = text.replace(cachedRegExp(`(?<=[${LATIN_LETTERS}.!?'"])(?<sepBefore>${escapedSep}?)${EM_DASH}(?<sepAfter>${escapedSep}?)(?=[${LATIN_LETTERS}])`, "g"), `$<sepBefore>${maybeSpace}${localizedDash}${maybeSpace}$<sepAfter>`);
+    const rendered = `${maybeSpace}${localizedDash}${maybeSpace}`;
+    convertSpacedDashes(view, rendered);
+    convertBoundaryLedDashes(view, rendered);
+    convertMultipleDashes(view, rendered);
+    convertLeadingLineDashes(view, localizedDash);
+    if (style === "british")
+        convertUnspacedEmDashes(view, rendered);
+}
+const QUOTE_CHARS = `"'${LEFT_DOUBLE_QUOTE}${RIGHT_DOUBLE_QUOTE}${LEFT_SINGLE_QUOTE}${RIGHT_SINGLE_QUOTE}`;
+const DASH_RUN_CHARS = new Set(["-", EN_DASH, EM_DASH]);
+function isDashChar(ch) {
+    return ch !== undefined && DASH_RUN_CHARS.has(ch);
+}
+/**
+ * Spaced dashes: "word - word" / "word — word". A single plain hyphen directly
+ * before a word char (the suspended/hanging hyphen, "Yes-men and -women") is
+ * skipped. The arrow guard rejects shapes like "- >" so `foo -> bar` stays.
+ *
+ * The dash core (`[${EN}${EM}][-${EN}${EM}]*|-{2,}|-(?![LAT\d])`) never spans a
+ * boundary, so a node boundary inside the dash run truncates the run — the
+ * boundary becomes the trailing slot and any dashes past it are left untouched.
+ * The replacer realizes this by truncating the run at the first interior
+ * boundary and re-validating the dash core on the truncated form.
+ */
+function convertSpacedDashes(view, rendered) {
+    // The `(?<=[^\s]|^)` lookbehind is validated in the replacer instead, since a
+    // boundary (non-space) also satisfies it, letting a match begin even when the
+    // clean char to the left is whitespace. The cheap `(?<![ ])` anchor keeps each
+    // `[ ]+` run starting at its leftmost space, avoiding quadratic backtracking.
+    const pattern = `(?<![ ])[ ]+(?<dashStart>[-${EN_DASH}${EM_DASH}])`;
+    // The full shape consumes the trailing `[ ]*`, advancing past it; this pattern
+    // does not, so a later match could begin inside a previous match's consumed
+    // trailing spaces. Track the last consumed offset and skip.
+    let consumedThrough = -1;
+    pass(view, cachedRegExp(pattern, "g"), (match, v) => {
+        const text = v.text;
+        const groups = namedGroups(matchArgs(match));
+        const firstDash = match.index + match[0].length - groups.dashStart.length;
+        // The greedy `[ ]+` starts at the leftmost position whose `(?<=[^\s]|^)`
+        // holds: line/text start, a non-whitespace clean char, or a boundary. A
+        // boundary inside the leading spaces restarts the match just after it (the
+        // spaces before it stay with the previous node). The previous match's
+        // consumed span is also a floor: leading spaces it already consumed are not
+        // re-used.
+        let matchStart = Math.max(match.index, consumedThrough);
+        for (const b of view.boundaries) {
+            if (b > matchStart && b <= firstDash - 1)
+                matchStart = b;
+            else if (b > firstDash)
+                break;
+        }
+        /* istanbul ignore if -- defensive: the previous match's trailing `(?=\S|$)`
+           stops at this dash, so `consumedThrough` never reaches past `firstDash`. */
+        if (matchStart >= firstDash + 1)
+            return null;
+        // Validate the lookbehind at matchStart: start of text/line, a boundary
+        // immediately left, or a non-whitespace clean char.
+        const leftOk = matchStart === 0
+            || view.hasBoundary(matchStart)
+            || (text[matchStart - 1] !== undefined && !/\s/.test(text[matchStart - 1]));
+        if (!leftOk)
+            return null;
+        // A dash char left of the leading spaces (boundaries are zero-width, so
+        // this reads through them) marks this run as the tail of an
+        // already-spaced dash ("x – -"): the overlap consumption above leaves
+        // it on the pass that converts the head, and the head's edits can
+        // rewrite the linking context so the consumption never re-links; block
+        // the tail deterministically. Glyphs folded from a trailing dash (`←`,
+        // `±`) block like the hyphen that sat in this slot before the fold.
+        const charBeforeSpaces = text[matchStart - 1];
+        if (matchStart > 0
+            && (isDashChar(charBeforeSpaces) || FOLDED_FROM_TRAILING_DASH.has(charBeforeSpaces)))
+            return null;
+        // The leading spaces between matchStart and the dash must be at least one
+        // (`[ ]+` is one-or-more) — a boundary directly before the dash leaves
+        // none, which is the boundary-led pattern's job, not this one.
+        if (matchStart === firstDash)
+            return null;
+        // A boundary between the leading spaces and the dash breaks `[ ]+dashCore`
+        // (no slot there); neither spaced nor boundary-led matches, so skip.
+        if (view.hasBoundary(firstDash))
+            return null;
+        // Maximal dash run from firstDash that does not cross a boundary (the core
+        // never spans a boundary).
+        let fullRunEnd = firstDash + 1;
+        while (isDashChar(text[fullRunEnd]) && !v.hasBoundary(fullRunEnd))
+            fullRunEnd++;
+        // The dashCore (`-{2,}` greedy, then single `-`) backtracks past the arrow
+        // guard AND the trailing `[ ]*(?=\S|$)`, so try run ends longest-first and
+        // take the first one whose whole tail validates.
+        const chosen = chooseSpacedDashRun(v, firstDash, fullRunEnd);
+        if (chosen === null)
+            return null;
+        consumedThrough = chosen.consumedEnd;
+        v.replace(matchStart, chosen.editEnd, rendered);
+        return null;
+    }, { allowBoundaries: () => true });
+}
+/**
+ * Picks the dashCore from the maximal dash run [firstDash, fullRunEnd). Tries
+ * `[EN EM][-EN EM]*`, then `-{2,}` (greedy), then a single `-`, backtracking past
+ * the arrow guard and the trailing `[ ]*(?=\S|$)`. Returns the chosen run end and
+ * the trailing-spaces end (`scan`) to replace, or null when no branch validates.
+ */
+function chooseSpacedDashRun(view, firstDash, fullRunEnd) {
+    const text = view.text;
+    const first = text[firstDash];
+    if (first === EN_DASH || first === EM_DASH) {
+        // `[EN EM][-EN EM]*`: the leading EN/EM is mandatory, the `[-EN EM]*` tail is
+        // greedy but backtracks past the arrow guard — e.g. "–-{sep}{sep}>" gives the
+        // `-` back so the run is just "–" (not an arrow) and converts.
+        for (let end = fullRunEnd; end > firstDash; end--) {
+            if (spacedArrowAhead(view, end))
+                continue;
+            const trailing = spacedTrailingEnd(view, end);
+            if (trailing !== null)
+                return trailing;
+        }
+        return null;
     }
-    return text;
+    // The `-{2,}` and single-`-` branches match hyphens only, so a leading-hyphen
+    // run stops at the first EN/EM dash (e.g. "-–" is a single `-` core, not a
+    // two-dash run that would swallow the EN dash).
+    let hyphenRunEnd = firstDash;
+    while (text[hyphenRunEnd] === "-" && hyphenRunEnd < fullRunEnd)
+        hyphenRunEnd++;
+    // All hyphens. Try `-{2,}` lengths longest-first, then a single `-`.
+    for (let end = hyphenRunEnd; end > firstDash; end--) {
+        if (end - firstDash === 1) {
+            // Single `-(?!${sep}*[LAT\d])`: the next clean char must not be a letter or
+            // digit (the suspended-hyphen guard).
+            const next = text[end];
+            if (next !== undefined && /[a-z\d]/i.test(next))
+                return null;
+        }
+        if (spacedArrowAhead(view, end))
+            continue;
+        const trailing = spacedTrailingEnd(view, end);
+        if (trailing !== null)
+            return trailing;
+    }
+    return null;
+}
+/**
+ * The trailing `[ ]*(?:[ ]*)?(?=\S|$)` with one tolerated boundary. The leading
+ * `[ ]*` (before any boundary) is deleted; spaces after a boundary are kept
+ * (they belong to the next node) but still consumed. The lookahead then requires
+ * a non-space char, a boundary, or end of text. Returns the edit/consumed
+ * offsets, or null on failure.
+ */
+function spacedTrailingEnd(view, runEnd) {
+    const text = view.text;
+    let editEnd = runEnd;
+    while (text[editEnd] === " " && !view.hasBoundary(editEnd))
+        editEnd++;
+    // The trailing optional group is greedy: try consuming a single boundary and
+    // its kept trailing spaces first, then fall back to no boundary. `(?=\S|$)` is
+    // satisfied by a boundary (non-space), a non-space clean char, or end of text.
+    if (boundaryCountAt(view, editEnd) === 1) {
+        let consumedEnd = editEnd;
+        while (text[consumedEnd] === " " && (consumedEnd === editEnd || !view.hasBoundary(consumedEnd)))
+            consumedEnd++;
+        if (lookaheadNonSpace(view, consumedEnd))
+            return { editEnd, consumedEnd };
+    }
+    if (lookaheadNonSpace(view, editEnd))
+        return { editEnd, consumedEnd: editEnd };
+    return null;
+}
+/** `(?=\S|$)`: end of text, a node boundary, or a non-space clean char. */
+function lookaheadNonSpace(view, pos) {
+    return pos === view.text.length || view.hasBoundary(pos) || !/\s/.test(view.text[pos]);
+}
+/**
+ * The `(?!-*>)` arrow guard, boundary-aware. Two slots bracket the `-*` hyphen
+ * run: one boundary may sit before the run and one after. With no hyphens both
+ * slots collapse to the run-end offset (up to two boundaries there); a boundary
+ * inside the hyphen run, or more than the two slots allow, hides the `>` (so the
+ * dash is not an arrow and converts).
+ */
+function spacedArrowAhead(view, runEnd) {
+    const text = view.text;
+    let h = runEnd;
+    while (text[h] === "-") {
+        if (h > runEnd && view.hasBoundary(h))
+            return false; // boundary inside -*
+        h++;
+    }
+    if (h === runEnd) {
+        // No hyphens: both slots fall at this offset (≤2 boundaries total).
+        if (boundaryCountAt(view, runEnd) > 2)
+            return false;
+    }
+    else {
+        if (boundaryCountAt(view, runEnd) > 1)
+            return false; // first slot
+        if (boundaryCountAt(view, h) > 1)
+            return false; // second slot
+    }
+    // `≥` guards like the `>=` it folds from: the math pass folds the `>` this
+    // guard keys on, and a dash blocked before `–>=` must stay blocked at `–≥`.
+    return text[h] === ">" || text[h] === UNICODE_SYMBOLS.GREATER_EQUAL;
+}
+/**
+ * Dashes where a boundary alone precedes the dash run: "word{b}– rest". The
+ * shape `(?<=[^\s])[dash]+[ ]+` with a leading boundary requires a boundary
+ * immediately before the dash run, a non-space char before that boundary, and
+ * at least one trailing space. Because the leading boundary is required, this
+ * only fires where a node boundary opens a dash run, so the pass scans
+ * boundaries rather than the clean text. The "non-space before the boundary" is
+ * satisfied by a real non-space clean char (single boundary) or by another
+ * stacked boundary (two or more boundaries — a boundary is itself non-space).
+ */
+function convertBoundaryLedDashes(view, rendered) {
+    const text = view.text;
+    const edits = [];
+    let lastProcessedEnd = -1;
+    let prevOffset = -1;
+    let stackedHere = 0;
+    for (const b of view.boundaries) {
+        stackedHere = b === prevOffset ? stackedHere + 1 : 1;
+        prevOffset = b;
+        if (b < lastProcessedEnd)
+            continue;
+        if (!isDashChar(text[b]))
+            continue;
+        // Non-space before the boundary: ≥2 stacked boundaries, or a non-space
+        // clean char immediately left. A folded math operator there marks the
+        // fold-stranded configuration: the math pass consumes one character
+        // across this junction (`=` + `~—` folds to `≈` + `—`), so the character
+        // that blocked this rule on the source text is gone, and converting now
+        // would diverge from that blocked first pass.
+        if (stackedHere < 2) {
+            const before = text[b - 1];
+            if (before === undefined || /\s/.test(before) || FOLDED_MATH_OPERATORS.has(before))
+                continue;
+        }
+        // Dash run from the boundary, not crossing a further boundary.
+        let runEnd = b + 1;
+        while (isDashChar(text[runEnd]) && !view.hasBoundary(runEnd))
+            runEnd++;
+        // Required trailing space run; stop at a boundary.
+        let spaceEnd = runEnd;
+        while (text[spaceEnd] === " " && !view.hasBoundary(spaceEnd))
+            spaceEnd++;
+        if (spaceEnd === runEnd)
+            continue; // no trailing space
+        // A dash (or a glyph folded from a dash-led source) after the spaces
+        // blocks when the rendered form ends in a dash: consuming the spaces
+        // would fuse the rendered dash with it into a run the next pass
+        // collapses (see the same guard in the multiple-dash rule). A boundary
+        // at the junction prevents the fusion, so only a same-node follower
+        // blocks.
+        const afterSpaces = text[spaceEnd];
+        if (afterSpaces !== undefined && !view.hasBoundary(spaceEnd)
+            && isDashChar(rendered[rendered.length - 1])
+            && (isDashChar(afterSpaces) || FOLDED_FROM_LEADING_DASH.has(afterSpaces)))
+            continue;
+        edits.push([b, spaceEnd]);
+        lastProcessedEnd = spaceEnd;
+    }
+    for (const [from, to] of edits)
+        view.replace(from, to, rendered);
+    view.commit();
+}
+/**
+ * Multiple dashes: "word--word", "word---word", `"quote"--"quote"`. The shape
+ * `(?<=[LAT\d quote])[dash]{2,50}(?=[LAT quote space])` tolerates one boundary
+ * on each side of the run, but its `[dash]{2,50}` never spans a boundary. A
+ * boundary inside the run truncates it (and the 2..50 count must still hold for
+ * the truncated run); two stacked boundaries on either edge exceed the single
+ * slot and block the match.
+ */
+function convertMultipleDashes(view, rendered) {
+    const before = `[${LATIN_LETTERS}\\d${QUOTE_CHARS}]`;
+    const after = `[${LATIN_LETTERS}${QUOTE_CHARS} ]`;
+    // Upper bound of 50 prevents ReDoS on pathological runs of dashes.
+    const pattern = `(?<=${before})[${EN_DASH}${EM_DASH}-]{2,50}(?=${after})`;
+    const afterRe = new RegExp(after);
+    pass(view, cachedRegExp(pattern, "g"), (match, v) => {
+        const text = v.text;
+        const start = match.index;
+        // Two stacked boundaries before the run exceed the leading slot's budget.
+        if (boundaryCountAt(v, start) >= 2)
+            return null;
+        // Truncate the run at the first interior boundary (the class stops there).
+        let runEnd = start + 1;
+        while (isDashChar(text[runEnd]) && !v.hasBoundary(runEnd))
+            runEnd++;
+        if (runEnd - start < 2 || runEnd - start > 50)
+            return null;
+        // The trailing slot tolerates one boundary; the trailing lookahead then
+        // checks the clean char after the run is [LAT quote space].
+        if (boundaryCountAt(v, runEnd) >= 2)
+            return null;
+        const next = text[runEnd];
+        if (next === undefined || !afterRe.test(next))
+            return null;
+        // Consume the trailing space run (not crossing a boundary): the rendered
+        // dash carries its own spacing, and a re-run's spaced-dash rule would
+        // otherwise collapse the leftover spaces into it. When the rendered
+        // form ends in a dash (the unspaced American em dash), a dash (or a
+        // glyph folded from a dash-led source) after the spaces keeps them:
+        // consuming would fuse the rendered dash with it into a fresh run, and
+        // the spaced-dash rule's dash-tail guard already holds the leftover
+        // spaces still.
+        let editEnd = runEnd;
+        while (text[editEnd] === " " && !v.hasBoundary(editEnd))
+            editEnd++;
+        // A boundary at the junction prevents the fusion (dash runs never span
+        // boundaries), so only a same-node follower blocks.
+        const afterSpaces = text[editEnd];
+        if (editEnd > runEnd && afterSpaces !== undefined && !v.hasBoundary(editEnd)
+            && isDashChar(rendered[rendered.length - 1])
+            && (isDashChar(afterSpaces) || FOLDED_FROM_LEADING_DASH.has(afterSpaces))) {
+            editEnd = runEnd;
+        }
+        v.replace(start, editEnd, rendered);
+        return null;
+    }, { allowBoundaries: () => true });
+}
+/**
+ * Dashes at start of line: "^- " → styled dash. One boundary is tolerated at
+ * line start (before the dashes); it sits at the match start, never interior.
+ * The dash run has no interior slot, so a boundary inside the run blocks the
+ * match — the default interior-boundary rejection, which is what we want here.
+ */
+function convertLeadingLineDashes(view, localizedDash) {
+    pass(view, cachedRegExp(`^-+ `, "gm"), () => `${localizedDash} `);
+}
+/** British: unspaced em-dashes between letters become spaced en-dashes. */
+function convertUnspacedEmDashes(view, rendered) {
+    const pattern = `(?<=[${LATIN_LETTERS}.!?'"])${EM_DASH}(?=[${LATIN_LETTERS}])`;
+    pass(view, cachedRegExp(pattern, "g"), (match, v) => {
+        // One boundary is tolerated on each side of the em-dash; two or more
+        // exceed the slot and block the match.
+        if (boundaryCountAt(v, match.index) > 1)
+            return null;
+        if (boundaryCountAt(v, match.index + match[0].length) > 1)
+            return null;
+        v.replace(match.index, match.index + match[0].length, rendered);
+        return null;
+    });
 }
+// ---------------------------------------------------------------------------
+// Em-dash spacing normalization (american)
+// ---------------------------------------------------------------------------
 // TODO: Handle interrupted-then-resumed speech within quotes, where Chicago
 // allows a space after the dash: "Don't inter— Hey! Who threw that?"
-function normalizeEmDashSpacing(text, sep) {
-    const escapedSep = getEscapedSeparator({ separator: sep });
-    // Remove all spaces around em-dashes. The `\S|^` / `\S|$` boundary
-    // anchors restrict the match to dashes adjacent to non-whitespace.
-    text = text.replace(cachedRegExp(`(?<=\\S|^)(?<before>${escapedSep}?)[ ]*${EM_DASH}[ ]*(?<after>${escapedSep}?)(?=\\S|$)`, "g"), `$<before>${EM_DASH}$<after>`);
-    // Preserve space after em-dash at start of line (e.g., attribution)
-    text = text.replace(cachedRegExp(`^(?<sep>${escapedSep}?)${EM_DASH}(?<after>[A-Z0-9])`, "gm"), `$<sep>${EM_DASH} $<after>`);
-    return text;
-}
-export function hyphenReplace(text, options = {}) {
-    const sep = options.separator ?? DEFAULT_SEPARATOR;
+function normalizeEmDashSpacing(view) {
+    removeSpacesAroundEmDash(view);
+    preserveLineLeadingEmDashSpace(view);
+}
+/**
+ * Remove spaces directly around an em-dash that has non-whitespace on both
+ * sides. Only the spaces immediately adjacent to the dash are consumed; a
+ * boundary between a space and the dash keeps that space (space consumption
+ * cannot reach across a boundary). The walk therefore stops space consumption
+ * at node boundaries, and the `\S|^` / `\S|$` anchors treat a boundary (a
+ * non-space) as satisfying the anchor.
+ */
+function removeSpacesAroundEmDash(view) {
+    pass(view, cachedRegExp(EM_DASH, "g"), (match, v) => {
+        const d = match.index;
+        const text = v.text;
+        // Leading spaces, stopping at a boundary or non-space.
+        let left = d;
+        while (left > 0 && text[left - 1] === " " && !v.hasBoundary(left))
+            left--;
+        // Trailing spaces, stopping at a boundary or non-space.
+        let right = d + 1;
+        while (right < text.length && text[right] === " " && !v.hasBoundary(right))
+            right++;
+        const leftAnchored = left === 0 || v.hasBoundary(left) || !/\s/.test(text[left - 1]);
+        const rightAnchored = right === text.length || v.hasBoundary(right) || !/\s/.test(text[right]);
+        if (!leftAnchored || !rightAnchored)
+            return null;
+        // Drop the adjacent space runs; the em-dash and any edge boundaries
+        // stay. A side whose anchor is another dash keeps its spaces: deleting
+        // them would fuse the dashes into a run the multiple-dash rule then
+        // collapses on the next pass. Glyphs folded from a dash-edged source
+        // (`±`, `←`, `→`) anchor like the dash they fold from.
+        const leftAnchor = text[left - 1];
+        const rightAnchor = text[right];
+        if (left < d && !isDashChar(leftAnchor) && !FOLDED_FROM_TRAILING_DASH.has(leftAnchor))
+            v.replace(left, d, "");
+        if (right > d + 1 && !isDashChar(rightAnchor) && !FOLDED_FROM_LEADING_DASH.has(rightAnchor))
+            v.replace(d + 1, right, "");
+        return null;
+    });
+}
+/** Preserve a space after a line-leading em-dash before an uppercase/digit. */
+function preserveLineLeadingEmDashSpace(view) {
+    pass(view, cachedRegExp(`^${EM_DASH}(?<after>[A-Z0-9])`, "gm"), (match, v) => {
+        // One boundary is tolerated between the line start and the em-dash; two or
+        // more exceed that slot and block the match.
+        if (boundaryCountAt(v, match.index) > 1)
+            return null;
+        const groups = namedGroups(matchArgs(match));
+        return `${EM_DASH} ${groups.after}`;
+    });
+}
+export function hyphenReplace(input, options = {}) {
     const style = options.dashStyle ?? "american";
-    if (style === "none")
-        return text;
-    text = minusReplace(text, options);
-    text = enDashDateRange(text, options);
-    text = enDashNumberRange(text, options);
-    text = convertParentheticalDashes(text, sep, style);
-    if (style === "american")
-        text = normalizeEmDashSpacing(text, sep);
-    return text;
+    return overInput(input, (view) => {
+        if (style === "none")
+            return;
+        minusReplace(view);
+        enDashDateRangeOverView(view, style);
+        enDashNumberRange(view);
+        convertParentheticalDashes(view, style);
+        if (style === "american")
+            normalizeEmDashSpacing(view);
+    });
 }
 const { WORD_JOINER } = UNICODE_SYMBOLS;
-/**
- * Insert a word joiner (U+2060) immediately before each unspaced em or en
- * dash that has preceding content, preventing the dash from appearing as the
- * first glyph on a wrapped line. Both dashes share Unicode line-break class
- * B2, which permits a break before them. Does not insert before line-leading
- * dashes (preceded by whitespace or start-of-string) or dashes already glued
- * with a word joiner — including British-style spaced en dashes ("word – word"),
- * which are already protected by the surrounding spaces.
- *
- * **Trade-off:** the inserted U+2060 is invisible but present in the DOM, so
- * browser Ctrl+F / find-in-page will not match a query like `plan—result`
- * against the rendered `plan⁠—result`. This is the same trade-off made by
- * `nbspTransform` (U+00A0 breaks `Fig. 1` searches). Apply only in rendered
- * HTML; do not write into Markdown source.
- */
-export function dashWordJoiner(text) {
-    const re = cachedRegExp(`(?<=[^\\s${WORD_JOINER}])[${EM_DASH}${EN_DASH}]`, "gu");
-    return text.replace(re, `${WORD_JOINER}$&`);
+export function dashWordJoiner(input) {
+    return overInput(input, (view) => {
+        const re = cachedRegExp(`(?<=[^\\s${WORD_JOINER}])[${EM_DASH}${EN_DASH}]`, "gu");
+        replaceAllInView(view, re, (match) => `${WORD_JOINER}${match[0]}`);
+    });
+}
+/** Reconstructs `.replace()`-style callback args from a RegExpExecArray. */
+function matchArgs(match) {
+    return [...match, match.index, match.input, match.groups];
 }
 //# sourceMappingURL=dashes.js.map