punctilio 5.0.1 → 5.0.3

package/src/quote-classifier.ts

@@ -1,4 +1,4 @@
-import { LATIN_LETTERS, SPACE_CHARS, TERMINAL_PUNCTUATION, UNICODE_SYMBOLS } from "./constants.js"
+import { FOLDED_WORD_CHARS, LATIN_LETTER_RE, SPACE_CHAR_RE, TERMINAL_PUNCTUATION, UNICODE_SYMBOLS, WORD_RE } from "./constants.js"
 import type { ProseView } from "./prose-view.js"
 
 const {
@@ -24,16 +24,11 @@ const {
   EXCLAMATION_QUESTION,
   DOUBLE_EXCLAMATION,
   INTERROBANG,
-  MULTIPLICATION,
   APPROXIMATE,
   GREATER_EQUAL,
   LESS_EQUAL,
   NOT_EQUAL,
   PLUS_MINUS,
-  SUPERSCRIPT_ST,
-  SUPERSCRIPT_ND,
-  SUPERSCRIPT_RD,
-  SUPERSCRIPT_TH,
 } = UNICODE_SYMBOLS
 
 /**
@@ -84,7 +79,7 @@ const ROLE_BY_CHAR = new Map<string, Exclude<QuoteRole, "LITERAL">>([
  *
  * The boundary-tolerance behavior of the boundary items reproduces the
  * element-boundary semantics of the pre-v5 sentinel-marked pipeline (pinned by
- * the golden corpus and the migration's differential fuzz): boundary-transparent
+ * the HTML regression corpus and the migration's differential fuzz): boundary-transparent
  * rules skip them, and rules that treat a boundary as an ordinary non-space
  * character do so.
  */
@@ -102,8 +97,6 @@ interface Item {
   anchorBind: "left" | "right"
 }
 
-const LETTER_RE = new RegExp(`[${LATIN_LETTERS}]`)
-const WORD_RE = /\w/
 const SPACE_RE = /\s/
 const DIGIT_RE = /\d/
 
@@ -115,9 +108,8 @@ const QUOTE_CANDIDATE_RE = new RegExp(
 
 const TERMINAL_SET = new Set<string>(TERMINAL_PUNCTUATION)
 
-/** The collapse pass's space alphabet (plain space, tab, NBSP, NNBSP). */
-const COLLAPSIBLE_SPACE_RE = new RegExp(`[${SPACE_CHARS}]`)
-const CLOSING_SET = new Set<string>([RIGHT_SINGLE_QUOTE, RIGHT_DOUBLE_QUOTE])
+const CLOSING_CHARS = [RIGHT_SINGLE_QUOTE, RIGHT_DOUBLE_QUOTE] as const
+const CLOSING_SET = new Set<string>(CLOSING_CHARS)
 
 /**
  * Placement alphabet for renders that collapse apostrophes into U+2019: a
@@ -126,7 +118,7 @@ const CLOSING_SET = new Set<string>([RIGHT_SINGLE_QUOTE, RIGHT_DOUBLE_QUOTE])
  * APOSTROPHE item as part of a closing run for the transform to be a fixed
  * point.
  */
-const CLOSING_OR_APOSTROPHE_SET = new Set<string>([RIGHT_SINGLE_QUOTE, RIGHT_DOUBLE_QUOTE, MODIFIER_LETTER_APOSTROPHE])
+const CLOSING_OR_APOSTROPHE_SET = new Set<string>([...CLOSING_CHARS, MODIFIER_LETTER_APOSTROPHE])
 
 /** Chars from `'` ${LSQ} ${RSQ} ${MLA}; \w handled separately. */
 const SINGLE_QUOTE_FAMILY = new Set<string>(["'", LEFT_SINGLE_QUOTE, RIGHT_SINGLE_QUOTE, MODIFIER_LETTER_APOSTROPHE])
@@ -162,12 +154,23 @@ const DOUBLE_EMPTY_AFTER_SET = new Set<string>([")", "]", "}", ".", "!", "?", ",
 /** Ending-context chars after a closing double quote (plus any \s char). */
 const DOUBLE_CLOSE_AFTER_SET = new Set<string>(["/", ")", ".", ",", ";", EM_DASH, ":", "-", "}", "!", "?", "s", ELLIPSIS, ...FOLDED_TERMINALS])
 
-function isLetterItem(items: Item[], index: number): boolean {
-  if (index < 0 || index >= items.length) return false
-  const item = items[index]
-  return !item.boundary && LETTER_RE.test(item.ch)
+/** Builds an `(items, index)` predicate: in range, non-boundary, and `test(ch)`. */
+function makeItemTester(test: (ch: string) => boolean): (items: Item[], index: number) => boolean {
+  return (items, index) => {
+    if (index < 0 || index >= items.length) return false
+    const item = items[index]
+    return !item.boundary && test(item.ch)
+  }
 }
 
+const isLetterItem = makeItemTester((ch) => LATIN_LETTER_RE.test(ch))
+const isDigitItem = makeItemTester((ch) => DIGIT_RE.test(ch))
+const isWordItem = makeItemTester((ch) => WORD_RE.test(ch) || FOLDED_WORD_CHARS.has(ch))
+const isLetterOrDigitItem = makeItemTester((ch) => LATIN_LETTER_RE.test(ch) || DIGIT_RE.test(ch) || FOLDED_WORD_CHARS.has(ch))
+/** Letter test that treats folded word glyphs as the letters they fold from
+ * (`X` → `×`, `st` → `ˢᵗ`); see {@link FOLDED_WORD_CHARS}. */
+const isLetterOrFoldedItem = makeItemTester((ch) => LATIN_LETTER_RE.test(ch) || FOLDED_WORD_CHARS.has(ch))
+
 function isCharItem(items: Item[], index: number, ch: string): boolean {
   if (index < 0 || index >= items.length) return false
   const item = items[index]
@@ -339,16 +342,6 @@ function singleCloserBefore(items: Item[], index: number): boolean {
   return !SPACE_RE.test(prev.ch) && prev.ch !== LEFT_DOUBLE_QUOTE && prev.ch !== "'" && prev.ch !== '"'
 }
 
-/**
- * Letter test that treats folded word glyphs as the letters they fold from
- * (`X` → `×`, `st` → `ˢᵗ`); see {@link FOLDED_WORD_CHARS}.
- */
-function isLetterOrFoldedItem(items: Item[], index: number): boolean {
-  if (index < 0 || index >= items.length) return false
-  const item = items[index]
-  return !item.boundary && (LETTER_RE.test(item.ch) || FOLDED_WORD_CHARS.has(item.ch))
-}
-
 /** Letter directly before (no boundary) and letter after (one boundary transparent). */
 function isContractionContext(items: Item[], index: number): boolean {
   return isLetterOrFoldedItem(items, index - 1) && isLetterOrFoldedItem(items, nextIndex(items, index, 1))
@@ -404,22 +397,6 @@ function classifyNAbbreviation(items: Item[]): void {
   }
 }
 
-/**
- * Glyphs the symbol passes fold word characters into (multiplication `x` →
- * `×`, ordinal suffixes → superscripts). Word-gated rules must accept them,
- * or a gate decided on `6x'` flips once a re-run sees `6×'`.
- */
-const FOLDED_WORD_CHARS = new Set<string>([
-  MULTIPLICATION,
-  ...SUPERSCRIPT_ST, ...SUPERSCRIPT_ND, ...SUPERSCRIPT_RD, ...SUPERSCRIPT_TH,
-])
-
-function isWordItem(items: Item[], index: number): boolean {
-  if (index < 0 || index >= items.length) return false
-  const item = items[index]
-  return !item.boundary && (WORD_RE.test(item.ch) || FOLDED_WORD_CHARS.has(item.ch))
-}
-
 /**
  * Possessive (`dog's`) → APOSTROPHE; then closing single (`'` in ending
  * context) → CLOSE_SINGLE. Returns true when any item changed.
@@ -471,18 +448,6 @@ function isDecadeElision(items: Item[], index: number): boolean {
   return !isLetterOrDigitItem(items, after)
 }
 
-function isDigitItem(items: Item[], index: number): boolean {
-  if (index < 0 || index >= items.length) return false
-  const item = items[index]
-  return !item.boundary && DIGIT_RE.test(item.ch)
-}
-
-function isLetterOrDigitItem(items: Item[], index: number): boolean {
-  if (index < 0 || index >= items.length) return false
-  const item = items[index]
-  return !item.boundary && (LETTER_RE.test(item.ch) || DIGIT_RE.test(item.ch) || FOLDED_WORD_CHARS.has(item.ch))
-}
-
 /** `nʼ ` directly after the quote — a quote leading into an already-classified 'n'. */
 function isNAbbreviationAhead(items: Item[], index: number): boolean {
   return isCharItem(items, index + 1, "n")
@@ -664,8 +629,6 @@ function doubleOpenerPrefixOk(items: Item[], index: number): boolean {
   return SPACE_RE.test(prev.ch) || DOUBLE_OPEN_BEFORE_SET.has(prev.ch)
 }
 
-const ELLIPSIS_GAP_SPACE_RE = new RegExp(`[${SPACE_CHARS}]`)
-
 /**
  * Index of the dot reachable across one inter-dot gap from the dot at
  * `dotIndex` (the ellipsis pass's gap rule: the gap is nothing, one space
@@ -680,7 +643,7 @@ function nextEllipsisDotItem(items: Item[], dotIndex: number): number {
   }
   if (j >= items.length) return -1
   if (items[j].ch === ".") return j
-  if (ELLIPSIS_GAP_SPACE_RE.test(items[j].ch) && j + 1 < items.length && !items[j + 1].boundary && items[j + 1].ch === ".") {
+  if (SPACE_CHAR_RE.test(items[j].ch) && j + 1 < items.length && !items[j + 1].boundary && items[j + 1].ch === ".") {
     return j + 1
   }
   return -1
@@ -1027,7 +990,7 @@ function prevEllipsisDotItem(order: Item[], index: number): number {
   }
   if (j < 0) return -1
   if (order[j].ch === ".") return j
-  if (ELLIPSIS_GAP_SPACE_RE.test(order[j].ch) && isCharItem(order, j - 1, ".")) return j - 1
+  if (SPACE_CHAR_RE.test(order[j].ch) && isCharItem(order, j - 1, ".")) return j - 1
   return -1
 }
 
@@ -1208,7 +1171,7 @@ function movePunctuationOutside(order: Item[], punctChar: string, closingSet: Re
       // collapse pass merges tabs and NBSPs into the closer's NNBSP padding
       // the same way.
       if (spaceBeforePaddedCloser && k < order.length && !order[k].boundary
-        && order[k].ch.length === 1 && COLLAPSIBLE_SPACE_RE.test(order[k].ch)
+        && order[k].ch.length === 1 && SPACE_CHAR_RE.test(order[k].ch)
         && isCharItem(order, k + 1, RIGHT_DOUBLE_QUOTE)) {
         k++
       }

package/src/symbols.ts

@@ -1,5 +1,5 @@
-import { cachedRegExp, LATIN_LETTERS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js"
-import { boundaryCountAt, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
+import { cachedRegExp, LATIN_LETTER_RE, LATIN_LETTERS, MAX_BOUNDARY_SEPARATORS, SPACE_CHAR_RE, UNICODE_SYMBOLS, WORD_RE } from "./constants.js"
+import { boundaryCountAt, exceedsSingleBoundary, makeProsePass, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
 import { convertPrimeMarks } from "./quote-classifier.js"
 
 export interface SymbolOptions {
@@ -36,19 +36,10 @@ const {
 
 // The boundary-tolerance positions throughout this module reproduce the
 // element-boundary semantics of the pre-v5 sentinel-marked pipeline; they are
-// pinned by the golden corpus and the migration's differential fuzz.
-
-const LATIN_LETTER_RE = new RegExp(`[${LATIN_LETTERS}]`)
-const WORD_RE = /\w/
+// pinned by the HTML regression corpus and the migration's differential fuzz.
 
 /** Convert "..." or ". . ." to "…". */
-export function ellipsis(input: string): string
-export function ellipsis(input: ProseView): void
-export function ellipsis(input: string | ProseView): string | void {
-  return overInput(input, ellipsisOverView)
-}
-
-const SPACE_CHAR_RE = new RegExp(`[${SPACE_CHARS}]`)
+export const ellipsis = makeProsePass(ellipsisOverView)
 
 function ellipsisOverView(view: ProseView): void {
   ellipsisFoldDots(view)
@@ -109,11 +100,7 @@ function ellipsisFoldDots(view: ProseView): void {
 
 
 /** Convert "5x5" to "5×5". Skips hex (0x5F). */
-export function multiplication(input: string): string
-export function multiplication(input: ProseView): void
-export function multiplication(input: string | ProseView): string | void {
-  return overInput(input, multiplicationOverView)
-}
+export const multiplication = makeProsePass(multiplicationOverView)
 
 // After a digit run, either a prime mark (10′) or a length/size unit may
 // attach before the multiplication operator. Allowing both lets dimensions
@@ -257,7 +244,7 @@ function leftSuffixUnsplit(view: ProseView, text: string, digitsEnd: number, slo
   // A prime or unit suffix begins after one optional space-or-boundary slot;
   // a second boundary in that slot (before the suffix) leaves `\d+suffix`
   // matching only the digits, detaching the operator.
-  if (slotStart > digitsEnd && boundaryCountAt(view, digitsEnd) > 1) return false
+  if (slotStart > digitsEnd && exceedsSingleBoundary(view, digitsEnd)) return false
   for (let i = digitsEnd + 1; i < slotStart; i++) {
     if (LATIN_LETTER_RE.test(text[i - 1]) && LATIN_LETTER_RE.test(text[i]) && view.hasBoundary(i)) return false
   }
@@ -371,7 +358,7 @@ function multiplicationOverView(view: ProseView): void {
     const operatorOffset = match.index + num.length
     trailingScan = match.index + match[0].length
     // One optional boundary may sit between the digits and the operator.
-    if (boundaryCountAt(view, operatorOffset) > 1) continue
+    if (exceedsSingleBoundary(view, operatorOffset)) continue
     // Leading guard and hex skip, on the boundary-free digit run ending at the
     // operator (a boundary inside the digits truncates the operand).
     const runStart = leftDigitRunStart(view, trailingText, operatorOffset, 0)
@@ -383,7 +370,7 @@ function multiplicationOverView(view: ProseView): void {
     if (op === "*") continue
     const afterOp = operatorOffset + 1
     const followChar = trailingText[afterOp]
-    if (boundaryCountAt(view, afterOp) <= 3 && followChar !== undefined && WORD_RE.test(followChar)) continue
+    if (boundaryCountAt(view, afterOp) <= MAX_BOUNDARY_SEPARATORS && followChar !== undefined && WORD_RE.test(followChar)) continue
     view.replace(operatorOffset, afterOp, MULTIPLICATION)
   }
   view.commit()
@@ -403,11 +390,7 @@ const MATH_SYMBOL_MAP: MathSymbolRule[] = [
 ]
 
 /** Convert !=, <=, >=, +/-, ~= to Unicode equivalents. */
-export function mathSymbols(input: string): string
-export function mathSymbols(input: ProseView): void
-export function mathSymbols(input: string | ProseView): string | void {
-  return overInput(input, mathSymbolsOverView)
-}
+export const mathSymbols = makeProsePass(mathSymbolsOverView)
 
 function mathSymbolsOverView(view: ProseView): void {
   for (const [left, right, forbiddenFollow, replacement] of MATH_SYMBOL_MAP) {
@@ -539,11 +522,7 @@ const LEGAL_REGISTERED_RE = "\\(r\\)"
 const LEGAL_TRADEMARK_RE = "\\(tm\\)"
 
 /** Convert (c), (r), (tm) to ©, ®, ™. */
-export function legalSymbols(input: string): string
-export function legalSymbols(input: ProseView): void
-export function legalSymbols(input: string | ProseView): string | void {
-  return overInput(input, legalSymbolsOverView)
-}
+export const legalSymbols = makeProsePass(legalSymbolsOverView)
 
 function legalSymbolsOverView(view: ProseView): void {
   // (c) → © only with positive copyright evidence (year or "copyright"
@@ -645,11 +624,7 @@ function arrowRightContextOk(view: ProseView, text: string, end: number): boolea
 }
 
 /** Convert -> and <-> to arrows. */
-export function arrows(input: string): string
-export function arrows(input: ProseView): void
-export function arrows(input: string | ProseView): string | void {
-  return overInput(input, arrowsOverView)
-}
+export const arrows = makeProsePass(arrowsOverView)
 
 function arrowsOverView(view: ProseView): void {
   // Each arrow shape is matched by a left-to-right scan so a boundary that
@@ -669,11 +644,7 @@ function arrowsOverView(view: ProseView): void {
   }
 }
 
-export function degrees(input: string): string
-export function degrees(input: ProseView): void
-export function degrees(input: string | ProseView): string | void {
-  return overInput(input, degreesOverView)
-}
+export const degrees = makeProsePass(degreesOverView)
 
 function degreesOverView(view: ProseView): void {
   // Temperature with optional space before C or F (uppercase only). One boundary
@@ -720,7 +691,7 @@ function degreeUnitFollowOk(text: string, view: ProseView, unitEnd: number): boo
   // also removes the `\b`. Consecutive boundaries pile at the same clean offset,
   // so count them there.
   const followChar = text[unitEnd]
-  if (boundaryCountAt(view, unitEnd) <= 3 && followChar !== undefined && WORD_RE.test(followChar)) return false
+  if (boundaryCountAt(view, unitEnd) <= MAX_BOUNDARY_SEPARATORS && followChar !== undefined && WORD_RE.test(followChar)) return false
   return true
 }
 
@@ -742,11 +713,7 @@ function digitSuffixBoundaryOk(match: RegExpExecArray, view: ProseView): boolean
 }
 
 /** Convert 5'10" to 5′10″ (prime marks). Call before smart quotes. */
-export function primeMarks(input: string): string
-export function primeMarks(input: ProseView): void
-export function primeMarks(input: string | ProseView): string | void {
-  return overInput(input, convertPrimeMarks)
-}
+export const primeMarks = makeProsePass(convertPrimeMarks)
 
 type FractionRule = [string, string, string]
 
@@ -771,11 +738,7 @@ const FRACTION_TUPLES: FractionRule[] = [
 const FRACTION_MAP = Object.fromEntries(FRACTION_TUPLES.map(([n, d, u]) => [`${n}/${d}`, u]))
 
 /** Convert 1/2, 1/4, etc. to ½, ¼, etc. Single-pass using alternation. */
-export function fractions(input: string): string
-export function fractions(input: ProseView): void
-export function fractions(input: string | ProseView): string | void {
-  return overInput(input, fractionsOverView)
-}
+export const fractions = makeProsePass(fractionsOverView)
 
 function fractionsOverView(view: ProseView): void {
   // Build alternation of exact valid pairs: `1/4|1/2|...`. Only exact pairs
@@ -852,11 +815,7 @@ const ORDINAL_MAP: Record<string, string> = {
 }
 
 /** Convert 1st, 2nd, 3rd, 4th to superscript ordinals. */
-export function superscriptOrdinal(input: string): string
-export function superscriptOrdinal(input: ProseView): void
-export function superscriptOrdinal(input: string | ProseView): string | void {
-  return overInput(input, superscriptOrdinalOverView)
-}
+export const superscriptOrdinal = makeProsePass(superscriptOrdinalOverView)
 
 function superscriptOrdinalOverView(view: ProseView): void {
   // Match number + ordinal suffix at word boundary, case-insensitively. One
@@ -876,11 +835,7 @@ function superscriptOrdinalOverView(view: ProseView): void {
 }
 
 // Preserves highest-priority space type (NBSP > NNBSP > regular) and leading indentation.
-export function collapseSpaces(input: string): string
-export function collapseSpaces(input: ProseView): void
-export function collapseSpaces(input: string | ProseView): string | void {
-  return overInput(input, collapseSpacesOverView)
-}
+export const collapseSpaces = makeProsePass(collapseSpacesOverView)
 
 /**
  * Collapses each run of two or more space characters to its highest-priority
@@ -922,11 +877,7 @@ const PUNCTUATION_LIGATURE_MAP: LigatureRule[] = [
 ]
 
 /** Convert ?? to ⁇, ?! to ⁈, !? to ⁉. Disabled by default (poor font support). */
-export function punctuationLigatures(input: string): string
-export function punctuationLigatures(input: ProseView): void
-export function punctuationLigatures(input: string | ProseView): string | void {
-  return overInput(input, punctuationLigaturesOverView)
-}
+export const punctuationLigatures = makeProsePass(punctuationLigaturesOverView)
 
 function punctuationLigaturesOverView(view: ProseView): void {
   for (const [first, repeated, replacement] of PUNCTUATION_LIGATURE_MAP) {

package/src/utils.ts

@@ -72,22 +72,3 @@ export function stableStringify(obj: object): string {
 export function namedGroups<G>(args: unknown[]): G {
   return args[args.length - 1] as G
 }
-
-/**
- * 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: unknown[]): { offset: number; input: string } {
-  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] as string }
-}