punctilio 5.0.2 → 5.0.3

package/dist/utils.js

@@ -59,22 +59,4 @@ export function stableStringify(obj) {
 export function namedGroups(args) {
     return args[args.length - 1];
 }
-/**
- * Extracts the match offset and input string from a `.replace()` callback's
- * arguments, independent of capture-group count. The trailing arguments are
- * `..., offset, input[, namedGroups]`: the input is the last string (the
- * named-groups object, when present, follows it) and the offset is the
- * number immediately before the input. @internal
- */
-export function replaceCallbackContext(args) {
-    let inputIndex = args.length - 1;
-    while (inputIndex >= 0 && typeof args[inputIndex] !== "string") {
-        inputIndex--;
-    }
-    const offset = args[inputIndex - 1];
-    if (inputIndex < 1 || typeof offset !== "number") {
-        throw new Error("Could not locate offset and input in replace-callback arguments.");
-    }
-    return { offset, input: args[inputIndex] };
-}
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "punctilio",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "Smart typography transformations: curly quotes, em-dashes, en-dashes, and more",
   "type": "module",
   "sideEffects": false,
@@ -164,6 +164,7 @@
     "lint": "eslint src scripts",
     "typecheck:scripts": "tsc --noEmit -p tsconfig.scripts.json",
     "benchmark": "pnpm run build && node benchmark.mjs",
-    "mutation": "STRYKER_RUN=1 stryker run"
+    "mutation": "STRYKER_RUN=1 stryker run",
+    "mutation:changed": "node scripts/mutate-changed.mjs"
   }
 }

package/src/constants.ts

@@ -111,6 +111,38 @@ export const SPACE_CHARS = ` \t${UNICODE_SYMBOLS.NBSP}${UNICODE_SYMBOLS.NNBSP}`
 /** Non-breaking space chars only (NBSP, NNBSP) for regex `[...]`. */
 export const NBSP_CHARS = `${UNICODE_SYMBOLS.NBSP}${UNICODE_SYMBOLS.NNBSP}`
 
+/** Latin letters (incl. European accents) as a compiled regex; see {@link LATIN_LETTERS}. */
+export const LATIN_LETTER_RE = new RegExp(`[${LATIN_LETTERS}]`, "u")
+
+/** Single `\w` word-character matcher shared across passes. */
+export const WORD_RE = /\w/
+
+/** Matches a single {@link SPACE_CHARS} character (space, tab, NBSP, NNBSP). */
+export const SPACE_CHAR_RE = new RegExp(`[${SPACE_CHARS}]`)
+
+/**
+ * Glyphs the symbol passes fold word characters into (multiplication `x` →
+ * `×`, ordinal suffixes → superscripts). Rules that run before those passes
+ * must treat a folded glyph like the word character it folds from, or a gate
+ * decided on `6x3` flips once a re-run sees `6×3`.
+ */
+export const FOLDED_WORD_CHARS = new Set<string>([
+  UNICODE_SYMBOLS.MULTIPLICATION,
+  ...UNICODE_SYMBOLS.SUPERSCRIPT_ST, ...UNICODE_SYMBOLS.SUPERSCRIPT_ND,
+  ...UNICODE_SYMBOLS.SUPERSCRIPT_RD, ...UNICODE_SYMBOLS.SUPERSCRIPT_TH,
+])
+
+/** `\w` extended with {@link FOLDED_WORD_CHARS} for fold-stable `\b` checks. */
+export function isWordLike(ch: string | undefined): boolean {
+  return ch !== undefined && (WORD_RE.test(ch) || FOLDED_WORD_CHARS.has(ch))
+}
+
+/**
+ * Maximum stacked node boundaries tolerated within a single match before a
+ * pass treats the span as crossing a real gap rather than an editing seam.
+ */
+export const MAX_BOUNDARY_SEPARATORS = 3
+
 /** Max AST recursion depth; guards against stack overflow from deep nesting. */
 export const MAX_RECURSION_DEPTH = 1000
 

package/src/dashes.ts

@@ -1,5 +1,5 @@
-import { cachedRegExp, LATIN_LETTERS, NBSP_CHARS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js"
-import { boundaryCountAt, overInput, type ProseView, replaceAllInView, type ReplaceAllOptions } from "./prose-view.js"
+import { cachedRegExp, FOLDED_WORD_CHARS, isWordLike, LATIN_LETTER_RE, LATIN_LETTERS, MAX_BOUNDARY_SEPARATORS, NBSP_CHARS, SPACE_CHAR_RE, UNICODE_SYMBOLS } from "./constants.js"
+import { boundaryCountAt, exceedsSingleBoundary, makeProsePass, overInput, type ProseView, replaceAllInView, type ReplaceAllOptions } from "./prose-view.js"
 import { namedGroups } from "./utils.js"
 
 export const DASH_STYLES = ["american", "british", "none"] as const
@@ -13,7 +13,6 @@ export interface DashOptions {
 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".
@@ -34,26 +33,6 @@ const months: readonly string[] = [
 
 const monthPattern = months.join("|")
 
-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<string>([
-  MULTIPLICATION,
-  ...SUPERSCRIPT_ST, ...SUPERSCRIPT_ND, ...SUPERSCRIPT_RD, ...SUPERSCRIPT_TH,
-])
-
-/** `\w` extended with {@link FOLDED_WORD_CHARS} for fold-stable `\b` checks. */
-function isWordChar(ch: string | undefined): boolean {
-  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
@@ -101,7 +80,7 @@ function pass(
 //
 // 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
+// pinned by the HTML regression 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
@@ -142,9 +121,6 @@ function interiorBoundariesAllowed(
   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
@@ -155,7 +131,7 @@ const MAX_BOUNDARY_SEPARATORS = 3
 function wordBoundaryStartOk(view: ProseView, matchStart: number): boolean {
   if (matchStart === 0) return true
   const nb = boundaryCountAt(view, matchStart)
-  const prevWord = isWordChar(view.text[matchStart - 1])
+  const prevWord = isWordLike(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.
@@ -172,7 +148,7 @@ function wordBoundaryEndOk(view: ProseView, pos: number): boolean {
   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])
+  const leftWord = isWordLike(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 ×`.
@@ -180,7 +156,7 @@ function wordBoundaryEndOk(view: ProseView, pos: number): boolean {
     return false
   }
   const nb = boundaryCountAt(view, pos)
-  const nextCleanWord = isWordChar(text[pos])
+  const nextCleanWord = isWordLike(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`
@@ -195,14 +171,10 @@ function wordBoundaryEndOk(view: ProseView, pos: number): boolean {
 const CURRENCY_RE = /[$€£¥₹]/
 
 /** Convert number ranges to en-dash (e.g., "1-5" → "1–5"). */
-export function enDashNumberRange(input: string): string
-export function enDashNumberRange(input: ProseView): void
-export function enDashNumberRange(input: string | ProseView): string | void {
-  return overInput(input, (view) => {
-    convertPositiveRanges(view)
-    convertNegativeRanges(view)
-  })
-}
+export const enDashNumberRange = makeProsePass((view) => {
+  convertPositiveRanges(view)
+  convertNegativeRanges(view)
+})
 
 /**
  * The positive-range shape is `phoneAreaCode? \b (?:p\.?|[currency])?\d[\d.,]*
@@ -276,13 +248,13 @@ function matchRangeBody(view: ProseView, startStart: number): number | null {
   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
+  if (exceedsSingleBoundary(view, startSpanEnd)) 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
+  if (exceedsSingleBoundary(view, dashEnd)) 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.
@@ -431,7 +403,7 @@ function matchNegativeRangeAt(view: ProseView, i: number): number | 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 (exceedsSingleBoundary(view, startEnd)) return null
   if (text[startEnd] !== "-") return null
 
   // `-{1,3}?` then optional `(?<neg>-)`: a 1..3 hyphen run with no interior
@@ -442,7 +414,7 @@ function matchNegativeRangeAt(view: ProseView, i: number): number | null {
   const hasNeg = dashRunLen >= 2
   const negEnd = dashRunEnd
   // The `end` head slot tolerates one boundary.
-  if (boundaryCountAt(view, negEnd) > 1) return null
+  if (exceedsSingleBoundary(view, negEnd)) return null
 
   const end = readNegEndRun(view, negEnd)
   if (end === null) return null
@@ -487,11 +459,11 @@ function followingCandidates(view: ProseView, endSpanEnd: number, allowMinus: bo
   const candidates = [endSpanEnd]
   let pos = endSpanEnd
   for (;;) {
-    if (boundaryCountAt(view, pos) > 1) break
+    if (exceedsSingleBoundary(view, pos)) break
     const dashCh = view.text[pos]
     if (dashCh !== "-" && !(allowMinus && dashCh === MINUS)) break
     const digitStart = pos + 1
-    if (boundaryCountAt(view, digitStart) > 1) break
+    if (exceedsSingleBoundary(view, digitStart)) break
     if (!/\d/.test(view.text[digitStart] ?? "")) break
     let end = digitStart + 1
     while (/\d/.test(view.text[end] ?? "") && !view.hasBoundary(end)) end++
@@ -521,7 +493,7 @@ function suffixWbeEnd(view: ProseView, pos: number, allowAmPm: boolean): number
   // 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
+  if (exceedsSingleBoundary(view, pos)) return null
   const text = view.text
   // `[AaPp][Mm]` is contiguous — a boundary between the two letters breaks the
   // suffix.
@@ -536,8 +508,6 @@ function suffixWbeEnd(view: ProseView, pos: number, allowAmPm: boolean): number
 
 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
@@ -706,15 +676,11 @@ function enDashDateRangeOverView(view: ProseView, dashStyle: DashStyle): void {
 // ---------------------------------------------------------------------------
 
 /** Convert hyphens to minus signs in numeric contexts (e.g., "-5" → "−5"). */
-export function minusReplace(input: string): string
-export function minusReplace(input: ProseView): void
-export function minusReplace(input: string | ProseView): string | void {
-  return overInput(input, (view) => {
-    minusSubtractionOfNegative(view)
-    minusSpacedSubtraction(view)
-    minusDirectNegative(view)
-  })
-}
+export const minusReplace = makeProsePass((view) => {
+  minusSubtractionOfNegative(view)
+  minusSpacedSubtraction(view)
+  minusDirectNegative(view)
+})
 
 /** Pattern 1a/1b: spaced math subtraction after a digit (`5 - 3`, `5 - -3`). */
 function minusSubtractionOfNegative(view: ProseView): void {
@@ -764,13 +730,13 @@ const NUM_BODY_RE = /^\d*\.?\d+/
 function minusSubtractionPrefixOk(match: RegExpExecArray, view: ProseView, prefixLen: number): boolean {
   // 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
+  if (exceedsSingleBoundary(view, match.index)) 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
+  if (exceedsSingleBoundary(view, numStart)) 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
@@ -1047,8 +1013,8 @@ function spacedArrowAhead(view: ProseView, runEnd: number): boolean {
     // 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
+    if (exceedsSingleBoundary(view, runEnd)) return false // first slot
+    if (exceedsSingleBoundary(view, h)) 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 `–≥`.
@@ -1185,8 +1151,8 @@ function convertUnspacedEmDashes(view: ProseView, rendered: string): void {
     (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
+      if (exceedsSingleBoundary(v, match.index)) return null
+      if (exceedsSingleBoundary(v, match.index + match[0].length)) return null
       v.replace(match.index, match.index + match[0].length, rendered)
       return null
     },
@@ -1250,7 +1216,7 @@ function preserveLineLeadingEmDashSpace(view: ProseView): void {
     (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
+      if (exceedsSingleBoundary(v, match.index)) return null
       const groups = namedGroups<{ after: string }>(matchArgs(match))
       return `${EM_DASH} ${groups.after}`
     },
@@ -1292,14 +1258,10 @@ const { WORD_JOINER } = UNICODE_SYMBOLS
  * `nbspTransform` (U+00A0 breaks `Fig. 1` searches). Apply only in rendered
  * HTML; do not write into Markdown source.
  */
-export function dashWordJoiner(input: string): string
-export function dashWordJoiner(input: ProseView): void
-export function dashWordJoiner(input: string | ProseView): string | void {
-  return overInput(input, (view) => {
-    const re = cachedRegExp(`(?<=[^\\s${WORD_JOINER}])[${EM_DASH}${EN_DASH}]`, "gu")
-    replaceAllInView(view, re, (match) => `${WORD_JOINER}${match[0]}`)
-  })
-}
+export const dashWordJoiner = makeProsePass((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: RegExpExecArray): unknown[] {

package/src/nbsp.ts

@@ -1,5 +1,5 @@
-import { cachedRegExp, LATIN_LETTERS, NBSP_CHARS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js"
-import { boundaryCountAt, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
+import { cachedRegExp, LATIN_LETTER_RE, LATIN_LETTERS, NBSP_CHARS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js"
+import { boundaryCountAt, exceedsSingleBoundary, makeProsePass, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
 
 const {
   NBSP,
@@ -95,8 +95,8 @@ const COPYRIGHT_SYMBOLS = `[${COPYRIGHT}${REGISTERED}${TRADEMARK}]`
 
 
 // The boundary-tolerance positions in 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.
+// semantics of the pre-v5 sentinel-marked pipeline; they are pinned by the HTML
+// regression corpus and the migration's differential fuzz.
 
 /**
  * A tolerated slot admits exactly ONE node boundary at that position; two
@@ -110,18 +110,14 @@ function boundariesOnlyAtSlots(view: ProseView, start: number, end: number, slot
     if (!slots.includes(boundary)) return false
   }
   for (const slot of slots) {
-    if (boundaryCountAt(view, slot) > 1) return false
+    if (exceedsSingleBoundary(view, slot)) return false
   }
   return true
 }
 
 // Skips when preceded by NBSP or back-to-back with the previous match,
 // preventing 3+ words from binding into a single line-break atom.
-export function nbspAfterShortWords(input: string): string
-export function nbspAfterShortWords(input: ProseView): void
-export function nbspAfterShortWords(input: string | ProseView): string | void {
-  return overInput(input, nbspAfterShortWordsOverView)
-}
+export const nbspAfterShortWords = makeProsePass(nbspAfterShortWordsOverView)
 
 function nbspAfterShortWordsOverView(view: ProseView): void {
   const pattern = cachedRegExp(
@@ -157,11 +153,7 @@ function nbspAfterShortWordsOverView(view: ProseView): void {
   view.commit()
 }
 
-export function nbspBetweenNumberAndUnit(input: string): string
-export function nbspBetweenNumberAndUnit(input: ProseView): void
-export function nbspBetweenNumberAndUnit(input: string | ProseView): string | void {
-  return overInput(input, nbspBetweenNumberAndUnitOverView)
-}
+export const nbspBetweenNumberAndUnit = makeProsePass(nbspBetweenNumberAndUnitOverView)
 
 function nbspBetweenNumberAndUnitOverView(view: ProseView): void {
   const pattern = cachedRegExp(
@@ -198,8 +190,6 @@ const MAX_LAST_WORD_LENGTH = 10
 // Bounded so the lookbehind stays ReDoS-safe.
 const MAX_MIDDLE_WORD_LENGTH = 15
 
-const LATIN_LETTER_RE = cachedRegExp(`[${LATIN_LETTERS}]`, "u")
-
 /**
  * The cascade lookbehind `(?<![NBSP][LATIN]{1,15})` over clean text: blocks
  * when an NBSP/NNBSP is followed by 1..15 Latin letters ending at the space. A
@@ -219,11 +209,7 @@ function cascadeBlocksLastWord(view: ProseView, spaceOffset: number): boolean {
 }
 
 // Skips when the second-to-last word is already glued backwards via NBSP.
-export function nbspBeforeLastWord(input: string): string
-export function nbspBeforeLastWord(input: ProseView): void
-export function nbspBeforeLastWord(input: string | ProseView): string | void {
-  return overInput(input, nbspBeforeLastWordOverView)
-}
+export const nbspBeforeLastWord = makeProsePass(nbspBeforeLastWordOverView)
 
 function nbspBeforeLastWordOverView(view: ProseView): void {
   // The `(?<=\w|boundary)` lookbehind and the `[NBSP][LATIN]{1,15}` cascade
@@ -248,7 +234,7 @@ function nbspBeforeLastWordOverView(view: ProseView): void {
         // `\n\n`/end-of-text; two adjacent boundaries block the match. The
         // end-of-text slot sits at the match end (never an interior boundary),
         // so the cap is checked here rather than only in allowBoundaries.
-        if (boundaryCountAt(v, end - match.groups!.ending.length) > 1) return null
+        if (exceedsSingleBoundary(v, end - match.groups!.ending.length)) return null
         // Edit only the leading space so the lastWord/ending (and any boundary
         // before \n\n) keep their positions.
         v.replace(start, start + 1, NBSP)
@@ -332,35 +318,15 @@ function nbspBetweenInitialsOverView(view: ProseView): void {
   nbspBeforeContext(view, `${UNICODE_UPPERCASE}\\.`, UNICODE_UPPERCASE, "gu", "initial")
 }
 
-export function nbspAfterReferenceAbbreviations(input: string): string
-export function nbspAfterReferenceAbbreviations(input: ProseView): void
-export function nbspAfterReferenceAbbreviations(input: string | ProseView): string | void {
-  return overInput(input, nbspAfterReferenceAbbreviationsOverView)
-}
+export const nbspAfterReferenceAbbreviations = makeProsePass(nbspAfterReferenceAbbreviationsOverView)
 
-export function nbspAfterSectionSymbols(input: string): string
-export function nbspAfterSectionSymbols(input: ProseView): void
-export function nbspAfterSectionSymbols(input: string | ProseView): string | void {
-  return overInput(input, nbspAfterSectionSymbolsOverView)
-}
+export const nbspAfterSectionSymbols = makeProsePass(nbspAfterSectionSymbolsOverView)
 
-export function nbspAfterHonorifics(input: string): string
-export function nbspAfterHonorifics(input: ProseView): void
-export function nbspAfterHonorifics(input: string | ProseView): string | void {
-  return overInput(input, nbspAfterHonorificsOverView)
-}
+export const nbspAfterHonorifics = makeProsePass(nbspAfterHonorificsOverView)
 
-export function nbspAfterCopyrightSymbols(input: string): string
-export function nbspAfterCopyrightSymbols(input: ProseView): void
-export function nbspAfterCopyrightSymbols(input: string | ProseView): string | void {
-  return overInput(input, nbspAfterCopyrightSymbolsOverView)
-}
+export const nbspAfterCopyrightSymbols = makeProsePass(nbspAfterCopyrightSymbolsOverView)
 
-export function nbspBetweenInitials(input: string): string
-export function nbspBetweenInitials(input: ProseView): void
-export function nbspBetweenInitials(input: string | ProseView): string | void {
-  return overInput(input, nbspBetweenInitialsOverView)
-}
+export const nbspBetweenInitials = makeProsePass(nbspBetweenInitialsOverView)
 
 // Specific patterns first so they claim matches before generic nbspAfterShortWords.
 const NBSP_TRANSFORMS: ((view: ProseView) => void)[] = [

package/src/prose-view.ts

@@ -244,6 +244,15 @@ export function boundaryCountAt(view: ProseView, offset: number): number {
   return count
 }
 
+/**
+ * True when more than one node boundary is stacked at `offset` — i.e. the
+ * position exceeds the single-boundary tolerance the passes allow in an
+ * editing slot.
+ */
+export function exceedsSingleBoundary(view: ProseView, offset: number): boolean {
+  return boundaryCountAt(view, offset) > 1
+}
+
 export function replaceAllInView(
   view: ProseView,
   regex: RegExp,
@@ -518,3 +527,18 @@ export function overInput(input: string | ProseView, run: (view: ProseView) => v
   run(input)
   input.commit()
 }
+
+/**
+ * Wraps a view runner as a dual-input {@link ProsePass}: the returned function
+ * transforms a string and returns it, or edits a ProseView in place. Collapses
+ * the string/ProseView overload triple that every zero-option public pass would
+ * otherwise repeat.
+ */
+export function makeProsePass(run: (view: ProseView) => void): ProsePass {
+  function pass(input: string): string
+  function pass(input: ProseView): void
+  function pass(input: string | ProseView): string | void {
+    return overInput(input, run)
+  }
+  return pass
+}