punctilio 5.0.10 → 5.1.1

package/src/dashes.ts

@@ -1,6 +1,5 @@
 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"
+import { boundaryCountAt, exceedsSingleBoundary, firstInteriorBoundary, lastBoundaryBefore, makeProsePass, overInput, type ProseView, replaceAllInView, type ReplaceAllOptions } from "./prose-view.js"
 
 export const DASH_STYLES = ["american", "british", "none"] as const
 export type DashStyle = (typeof DASH_STYLES)[number]
@@ -28,7 +27,7 @@ const months: readonly string[] = [
   "July", "August", "September", "October", "November", "December",
   // Abbreviated "May" omitted — the full name is already 3 letters
   "Jan", "Feb", "Mar", "Apr", "Jun",
-  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+  "Jul", "Aug", "Sept", "Sep", "Oct", "Nov", "Dec",
 ]
 
 const monthPattern = months.join("|")
@@ -191,12 +190,46 @@ function convertPositiveRanges(view: ProseView): void {
   const text = view.text
   let i = 0
   while (i < text.length) {
+    // A structural match can only begin at a digit, `p`, or `(` (the area-code
+    // and start-run readers reject every other first character), so other
+    // offsets skip the match attempt entirely.
+    if (!RANGE_START_CHAR_RE.test(text[i])) { i++; continue }
     const span = matchPositiveRangeAt(view, i)
-    i = span === null ? i + 1 : Math.max(span, i + 1)
+    i = span === null ? failedRangeStartSkip(view, i) : Math.max(span, i + 1)
   }
   view.commit()
 }
 
+const RANGE_START_CHAR_RE = /[\dp(]/
+
+/**
+ * Advance past a failed candidate at `i`. Advancing one character at a time
+ * re-reads the digit run at every offset — O(n²) on inputs like "1.1.1.…" or
+ * "111…1-x", a denial-of-service vector — so the scan jumps wherever a
+ * failure at `i` provably rules out interior starts:
+ *
+ * - A start-dependent failure (`\b`, not-after-dash — checked first in
+ *   matchRangeBody, before any run read) says nothing about interior starts;
+ *   advance one character. The gate order makes each such attempt cheap.
+ * - Otherwise the failure came after the gates, and everything there depends
+ *   only on the run end, not the run start: every interior digit start reads
+ *   to the same boundary-free run end and fails the same wall, `.`/`,` cannot
+ *   start a run, and no dash-at-run-end fallback (dash extent, boundary
+ *   counts, end run, tail resolution) sees a different picture. The single
+ *   escape is the phone-area-code reading, which restarts a fresh match past
+ *   a dash at the run end and therefore only exists at `runEnd - 3` — so
+ *   jump straight there (or to the run end when no dash follows).
+ */
+function failedRangeStartSkip(view: ProseView, i: number): number {
+  const text = view.text
+  if (!/\d/.test(text[i])) return i + 1
+  if (!wordBoundaryStartOk(view, i) || !notAfterDashOk(view, i)) return i + 1
+  let runEnd = i + 1
+  while (/[\d.,]/.test(text[runEnd] ?? "") && !view.hasBoundary(runEnd)) runEnd++
+  if (text[runEnd] !== "-") return runEnd
+  return Math.max(i + 1, runEnd - 3)
+}
+
 /**
  * Attempts the `phoneAreaCode? \b rangeStart -{1,3} rangeEnd following* suffix?
  * \b` structural match beginning at clean offset `i`, converting the dash when
@@ -243,6 +276,12 @@ function readPhoneAreaCode(view: ProseView, i: number): number | null {
  */
 function matchRangeBody(view: ProseView, startStart: number): number | null {
   const text = view.text
+  // Start-dependent gates first: they need no run read, and their position in
+  // the conjunction lets the scanner classify a failure — everything after
+  // them depends only on where the boundary-free start run ends, not on where
+  // it begins (see failedRangeStartSkip).
+  if (!wordBoundaryStartOk(view, startStart)) return null
+  if (!notAfterDashOk(view, startStart)) return null
   // rangeStart = `(?:p\.?|[currency])?\d[\d.,]*`, anchored at a `\b`.
   const start = readStartRun(view, startStart)
   if (start === null) return null
@@ -258,15 +297,20 @@ function matchRangeBody(view: ProseView, startStart: number): number | null {
 
   // `readStartRun` already stops at the first interior boundary, so the start
   // span is boundary-free and its clean digits are the whole run.
+  //
+  // INVARIANT (load-bearing for failedRangeStartSkip): past the gates above,
+  // `startDigits` is the ONLY value derived from where the run begins, and it
+  // feeds only the conversion decision, never the null/non-null return. The
+  // skip's jump is sound precisely because every interior start shares this
+  // function's post-gate outcome; threading the start position into the
+  // end/tail logic would silently break it.
   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--) {
+  // structural match commits at the longest end whose tail completes. The
+  // mandatory `\d` caps the backtrack at one digit.
+  for (let len = end.length; len >= 1; len--) {
     const endPos = end.firstDigitStart + len
     const tail = resolvePositiveTail(view, endPos)
     if (tail === null) continue
@@ -313,8 +357,6 @@ interface EndRun {
   firstDigitStart: number
   /** Length of the `[\d.,]` run from `firstDigitStart`, boundary-truncated. */
   length: number
-  /** Minimum end length: 1 digit (`\d` is required). */
-  minLen: number
 }
 
 /** The `[currency]?\d[\d.,]*` end run starting at `pos`, boundary-truncated. */
@@ -330,7 +372,7 @@ function readEndRun(view: ProseView, pos: number): EndRun | null {
   const firstDigitStart = i
   i++
   while (/[\d.,]/.test(text[i] ?? "") && !view.hasBoundary(i)) i++
-  return { firstDigitStart, length: i - firstDigitStart, minLen: 1 }
+  return { firstDigitStart, length: i - firstDigitStart }
 }
 
 interface ResolvedTail {
@@ -608,6 +650,22 @@ export function enDashDateRange(input: string | ProseView, options: DashOptions
   return overInput(input, (view) => enDashDateRangeOverView(view, options.dashStyle ?? "american"))
 }
 
+interface DateRangeGroups {
+  startMonth: string
+  startYear?: string
+  preSpace: string
+  postSpace: string
+  endMonth: string
+  endYear?: string
+}
+
+/** Clean offsets of the `[preSpace]-[postSpace]` span inside a date-range match. */
+function dateRangeDashSpan(match: RegExpExecArray): { dashStart: number; dashEnd: number } {
+  const groups = match.groups as unknown as DateRangeGroups
+  const dashStart = match.index + groups.startMonth.length + (groups.startYear?.length ?? 0)
+  return { dashStart, dashEnd: dashStart + groups.preSpace.length + 1 + groups.postSpace.length }
+}
+
 function enDashDateRangeOverView(view: ProseView, dashStyle: DashStyle): void {
   if (dashStyle === "none") return
   const [pre, post] = dashStyle === "british" ? [" ", " "] : ["", ""]
@@ -630,37 +688,17 @@ function enDashDateRangeOverView(view: ProseView, dashStyle: DashStyle): void {
       // 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<{
-        startMonth: string
-        startYear?: string
-        preSpace: string
-        postSpace: string
-        endMonth: string
-        endYear?: string
-      }>(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}`)
+      const { dashStart, dashEnd } = dateRangeDashSpan(match)
+      v.replace(dashStart, dashEnd, `${pre}${EN_DASH}${post}`)
       return null
     },
     {
       allowBoundaries: (match, v) => {
-        const groups = namedGroups<{
-          startMonth: string
-          startYear?: string
-          preSpace: string
-          postSpace: string
-          endMonth: string
-          endYear?: string
-        }>(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 { dashStart, dashEnd } = dateRangeDashSpan(match)
         const tolerated = new Map<number, number>()
         tolerated.set(dashStart, 1)
         tolerated.set(dashEnd, 1)
@@ -732,19 +770,14 @@ function minusSubtractionPrefixOk(match: RegExpExecArray, view: ProseView, prefi
   // leading digit and the space; it tolerates at most one boundary.
   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
-  }
+  if (firstInteriorBoundary(view, match.index, numStart) >= 0) return false
   // The slot before `num` tolerates at most one boundary at the num head.
   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
-  let truncatedEnd = numEnd
-  for (const b of view.boundaries) {
-    if (b > numStart && b < numEnd) { truncatedEnd = b; break }
-    if (b >= numEnd) break
-  }
+  const interior = firstInteriorBoundary(view, numStart, numEnd)
+  const truncatedEnd = interior >= 0 ? interior : numEnd
   return NUM_BODY_RE.test(view.text.slice(numStart, truncatedEnd))
 }
 
@@ -783,11 +816,8 @@ function minusDirectNegative(view: ProseView): void {
       // ("-{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
-      }
+      const interior = firstInteriorBoundary(v, start, numEnd)
+      const numTruncEnd = interior >= 0 ? interior : numEnd
       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
@@ -864,7 +894,7 @@ function convertSpacedDashes(view: ProseView, rendered: string): void {
     cachedRegExp(pattern, "g"),
     (match, v) => {
       const text = v.text
-      const groups = namedGroups<{ dashStart: string }>(matchArgs(match))
+      const groups = match.groups as { dashStart: string }
       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
@@ -873,10 +903,10 @@ function convertSpacedDashes(view: ProseView, rendered: string): void {
       // 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
-      }
+      // The greatest boundary strictly left of the dash restarts the match just
+      // after it (binary search, not a per-match scan of every boundary).
+      const boundaryBeforeDash = lastBoundaryBefore(view, firstDash)
+      if (boundaryBeforeDash > matchStart) matchStart = boundaryBeforeDash
       /* 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
@@ -1217,7 +1247,7 @@ function preserveLineLeadingEmDashSpace(view: ProseView): void {
       // One boundary is tolerated between the line start and the em-dash; two or
       // more exceed that slot and block the match.
       if (exceedsSingleBoundary(v, match.index)) return null
-      const groups = namedGroups<{ after: string }>(matchArgs(match))
+      const groups = match.groups as { after: string }
       return `${EM_DASH} ${groups.after}`
     },
   )
@@ -1246,8 +1276,10 @@ 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
+ * first glyph on a wrapped line. The em dash (U+2014) is Unicode line-break
+ * class B2, which permits a break on either side; the en dash (U+2013) is
+ * class BA (break after). The word joiner glues either dash to the preceding
+ * word so it cannot start a wrapped line. 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.
@@ -1262,8 +1294,3 @@ 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[] {
-  return [...match, match.index, match.input, match.groups]
-}

package/src/nbsp.ts

@@ -1,5 +1,5 @@
 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"
+import { boundaryCountAt, exceedsSingleBoundary, interiorBoundariesWithin, makeProsePass, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
 
 const {
   NBSP,
@@ -105,10 +105,7 @@ const COPYRIGHT_SYMBOLS = `[${COPYRIGHT}${REGISTERED}${TRADEMARK}]`
  * allowed slot offsets.
  */
 function boundariesOnlyAtSlots(view: ProseView, start: number, end: number, slots: number[]): boolean {
-  for (const boundary of view.boundaries) {
-    if (boundary <= start || boundary >= end) continue
-    if (!slots.includes(boundary)) return false
-  }
+  if (!interiorBoundariesWithin(view, start, end, slots)) return false
   for (const slot of slots) {
     if (exceedsSingleBoundary(view, slot)) return false
   }

package/src/prose-view.ts

@@ -67,19 +67,8 @@ class ProseViewImpl implements ProseView {
 
   hasBoundary(offset: number): boolean {
     const boundaries = this.cachedBoundaries
-    let low = 0
-    let high = boundaries.length - 1
-    while (low <= high) {
-      const mid = (low + high) >>> 1
-      const value = boundaries[mid]
-      if (value === offset) return true
-      if (value < offset) {
-        low = mid + 1
-      } else {
-        high = mid - 1
-      }
-    }
-    return false
+    const first = lowerBound(boundaries, offset)
+    return first < boundaries.length && boundaries[first] === offset
   }
 
   replace(start: number, end: number, text: string, opts?: { bind?: "left" | "right" }): void {
@@ -217,6 +206,28 @@ export function buildProseView(nodes: ProseNode[]): ProseView {
   return new ProseViewImpl(nodes)
 }
 
+/**
+ * Partitions `items` into contiguous groups, breaking before every index in
+ * `breakBefore` (indices 1..n-1). With no break indices the whole list is one
+ * group; an empty list yields no groups. Used to isolate opaque-delimited
+ * segments so a pass never sees text as adjacent across removed content.
+ */
+export function splitAtIndices<T>(items: readonly T[], breakBefore: ReadonlySet<number>): T[][] {
+  if (breakBefore.size === 0) {
+    return items.length > 0 ? [items.slice()] : []
+  }
+  const groups: T[][] = []
+  let start = 0
+  for (let i = 1; i < items.length; i++) {
+    if (breakBefore.has(i)) {
+      groups.push(items.slice(start, i))
+      start = i
+    }
+  }
+  groups.push(items.slice(start))
+  return groups
+}
+
 export interface ReplaceAllOptions {
   /** Opt-in: allow a match that contains an interior node boundary. Default: such matches are skipped. */
   allowBoundaries?: (match: RegExpExecArray, view: ProseView) => boolean
@@ -224,22 +235,68 @@ export interface ReplaceAllOptions {
   bind?: "left" | "right"
 }
 
+/**
+ * Index of the first element in sorted `values` that is >= `target`. The
+ * boundary helpers below run per candidate offset in the pass scanners, so a
+ * linear scan here would make inline-element-heavy views O(text × nodes).
+ */
+function lowerBound(values: readonly number[], target: number): number {
+  let low = 0
+  let high = values.length
+  while (low < high) {
+    const mid = (low + high) >>> 1
+    if (values[mid] < target) low = mid + 1
+    else high = mid
+  }
+  return low
+}
+
 /** True iff some interior boundary falls strictly inside the match span. */
 function matchContainsBoundary(match: RegExpExecArray, view: ProseView): boolean {
-  const matchStart = match.index
-  const matchEnd = match.index + match[0].length
-  for (const boundary of view.boundaries) {
-    if (boundary > matchStart && boundary < matchEnd) return true
+  return firstInteriorBoundary(view, match.index, match.index + match[0].length) >= 0
+}
+
+/** Smallest node boundary strictly inside (start, end), or -1 when none. */
+export function firstInteriorBoundary(view: ProseView, start: number, end: number): number {
+  const boundaries = view.boundaries
+  const first = lowerBound(boundaries, start + 1)
+  return first < boundaries.length && boundaries[first] < end ? boundaries[first] : -1
+}
+
+/** Largest node boundary strictly less than `offset`, or -1 when none. O(log n). */
+export function lastBoundaryBefore(view: ProseView, offset: number): number {
+  const boundaries = view.boundaries
+  const first = lowerBound(boundaries, offset)
+  return first > 0 ? boundaries[first - 1] : -1
+}
+
+/**
+ * True when every node boundary strictly inside (start, end) is one of
+ * `allowedSlots`. Seeks to the span with binary search, so it scans only the
+ * boundaries in range rather than the whole array on every call — the linear
+ * alternative is O(matches × nodes) on inline-element-heavy views.
+ */
+export function interiorBoundariesWithin(
+  view: ProseView,
+  start: number,
+  end: number,
+  allowedSlots: readonly number[],
+): boolean {
+  const boundaries = view.boundaries
+  for (let i = lowerBound(boundaries, start + 1); i < boundaries.length && boundaries[i] < end; i++) {
+    if (!allowedSlots.includes(boundaries[i])) return false
   }
-  return false
+  return true
 }
 
 /** Count of node boundaries that fall at exactly `offset` (empty nodes stack). */
 export function boundaryCountAt(view: ProseView, offset: number): number {
+  const boundaries = view.boundaries
+  let i = lowerBound(boundaries, offset)
   let count = 0
-  for (const boundary of view.boundaries) {
-    if (boundary === offset) count++
-    else if (boundary > offset) break
+  while (i < boundaries.length && boundaries[i] === offset) {
+    count++
+    i++
   }
   return count
 }