punctilio 5.0.10 → 5.1.1

package/src/remark.ts

@@ -6,7 +6,7 @@ import { visitParents } from "unist-util-visit-parents"
 import { transformView } from "./index.js"
 import { TRANSFORM_OPTION_KEYS, type TransformOptions } from "./transform-options.js"
 import { MAX_RECURSION_DEPTH } from "./constants.js"
-import { buildProseView } from "./prose-view.js"
+import { buildProseView, splitAtIndices } from "./prose-view.js"
 import { assertKnownOptionKeys } from "./utils.js"
 
 /**
@@ -20,30 +20,48 @@ const PHRASING_CONTAINERS = new Set(["paragraph", "heading", "tableCell"])
 
 const SKIP_TYPES = new Set(["inlineCode", "html"])
 
-function flattenTextNodes(
-  node: PhrasingContent,
-  depth: number = 0
-): Text[] {
+// Leaf phrasing nodes that render atomic content and carry no transformable
+// text. Between two text nodes, one is a real visual separator, so the
+// flattener records an opaque gap there (mirroring skipped `inlineCode`/`html`).
+const OPAQUE_LEAF_TYPES = new Set([
+  "image", "imageReference", "break", "footnoteReference", "inlineMath",
+])
+
+interface ProseCollector {
+  nodes: Text[]
+  opaqueBefore: Set<number>
+  // An opaque node was dropped since the last emitted text node; the next
+  // emitted node records an opaque gap before it.
+  pendingOpaque: boolean
+}
+
+function collectProse(node: PhrasingContent, depth: number, c: ProseCollector): void {
   /* istanbul ignore if -- defensive: prevents stack overflow from malicious nesting */
   if (depth > MAX_RECURSION_DEPTH) {
-    return []
+    return
   }
 
-  if (SKIP_TYPES.has(node.type)) {
-    return []
+  if (SKIP_TYPES.has(node.type) || OPAQUE_LEAF_TYPES.has(node.type)) {
+    c.pendingOpaque = true
+    return
   }
 
   if (node.type === "text") {
-    return [node]
+    if (c.pendingOpaque && c.nodes.length > 0) c.opaqueBefore.add(c.nodes.length)
+    c.pendingOpaque = false
+    c.nodes.push(node)
+    return
   }
 
   if ("children" in node) {
-    return (node.children as PhrasingContent[]).flatMap((child) =>
-      flattenTextNodes(child, depth + 1)
-    )
+    for (const child of node.children as PhrasingContent[]) collectProse(child, depth + 1, c)
   }
+}
 
-  return []
+function flattenProse(children: readonly PhrasingContent[]): { nodes: Text[]; opaqueBefore: Set<number> } {
+  const c: ProseCollector = { nodes: [], opaqueBefore: new Set(), pendingOpaque: false }
+  for (const child of children) collectProse(child, 0, c)
+  return { nodes: c.nodes, opaqueBefore: c.opaqueBefore }
 }
 
 export function remarkPunctilio(
@@ -75,15 +93,13 @@ export function remarkPunctilio(
         return
       }
 
-      const textNodes = (node.children as PhrasingContent[]).flatMap((child) =>
-        flattenTextNodes(child)
-      )
+      const { nodes, opaqueBefore } = flattenProse(node.children as PhrasingContent[])
 
-      if (textNodes.length === 0) {
-        return
+      // Split at opaque gaps (inline code, images, breaks) so no pass rewrites
+      // text as adjacent across content that visually separates it.
+      for (const group of splitAtIndices(nodes, opaqueBefore)) {
+        transformView(buildProseView(group), pluginOptions)
       }
-
-      transformView(buildProseView(textNodes), pluginOptions)
     })
   }
 }

package/src/symbols.ts

@@ -1,5 +1,5 @@
 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 { boundaryCountAt, exceedsSingleBoundary, firstInteriorBoundary, interiorBoundariesWithin, makeProsePass, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
 import { convertPrimeMarks } from "./quote-classifier.js"
 
 export interface SymbolOptions {
@@ -102,6 +102,20 @@ function ellipsisFoldDots(view: ProseView): void {
 /** Convert "5x5" to "5×5". Skips hex (0x5F). */
 export const multiplication = makeProsePass(multiplicationOverView)
 
+// A curly single-quote glyph directly after a trailing multiplier means the
+// quotes pass (which runs earlier in the pipeline) already read the `x` as a
+// letter — a word-final elision keyed on the letter. Were this pass to rewrite
+// that `x` to `×`, a re-run would re-read the quote as a closing quote after a
+// symbol and relocate a trailing comma/period, so the transform would never
+// reach a fixed point. Leave such an `x` alone. A straight `'` is not blocked:
+// it only reaches this pass on a standalone `multiplication()` call, where no
+// later quote pass can flip its classification.
+const CURLY_APOSTROPHE_FOLLOWERS = new Set<string>([
+  UNICODE_SYMBOLS.RIGHT_SINGLE_QUOTE,
+  UNICODE_SYMBOLS.LEFT_SINGLE_QUOTE,
+  UNICODE_SYMBOLS.MODIFIER_LETTER_APOSTROPHE,
+])
+
 // After a digit run, either a prime mark (10′) or a length/size unit may
 // attach before the multiplication operator. Allowing both lets dimensions
 // like "5m × 5m", "210mm × 297mm", or "1920px × 1080px" convert, matching
@@ -173,9 +187,7 @@ function chainSegments(chainStart: number, firstNum: string, rest: string): Chai
  */
 function operatorSlotClean(view: ProseView, slotStart: number, slotEnd: number): boolean {
   // No boundary strictly inside the spacing-plus-operator slot.
-  for (const boundary of view.boundaries) {
-    if (boundary > slotStart && boundary < slotEnd) return false
-  }
+  if (firstInteriorBoundary(view, slotStart, slotEnd) >= 0) return false
   // At most one boundary hugging each outer edge (duplicates at an offset come
   // from empty nodes and each counts as one boundary).
   return boundaryCountAt(view, slotStart) <= 1 && boundaryCountAt(view, slotEnd) <= 1
@@ -266,6 +278,24 @@ function runHasInteriorBoundary(view: ProseView, operandStart: number, operandEn
   return false
 }
 
+const ASCII_DIGIT_RE = /\d/
+
+/**
+ * Next offset at which a sticky `\d`-anchored pattern could match after a miss
+ * at `scan`. A miss at a digit rules out every start in the rest of its run:
+ * from a later start the pattern's leading `\d+` reaches a strict subset of
+ * the split positions the failed attempt already backtracked through. So the
+ * scan jumps past the current digit run (if any), then past non-digits to the
+ * next digit. Advancing one character at a time here instead re-reads the run
+ * at every offset — O(n²) on a long digit run, a denial-of-service vector.
+ */
+function nextDigitAnchorAfterMiss(text: string, scan: number): number {
+  let next = scan
+  while (next < text.length && ASCII_DIGIT_RE.test(text[next])) next++
+  while (next < text.length && !ASCII_DIGIT_RE.test(text[next])) next++
+  return next
+}
+
 function multiplicationOverView(view: ProseView): void {
   // The chain is matched with a sticky regex driven by a manual left-to-right
   // scan. Sticky anchoring keeps the nested `\d+(…\d+)+` quantifier ReDoS-safe
@@ -279,7 +309,7 @@ function multiplicationOverView(view: ProseView): void {
   while (scan < chainText.length) {
     chainPattern.lastIndex = scan
     const match = chainPattern.exec(chainText)
-    if (match === null) { scan++; continue }
+    if (match === null) { scan = nextDigitAnchorAfterMiss(chainText, scan); continue }
     const { firstNum, rest } = match.groups as { firstNum: string; rest: string }
     const text = chainText
     const chainStart = match.index
@@ -352,7 +382,7 @@ function multiplicationOverView(view: ProseView): void {
   while (trailingScan < trailingText.length) {
     trailingPattern.lastIndex = trailingScan
     const match = trailingPattern.exec(trailingText)
-    if (match === null) { trailingScan++; continue }
+    if (match === null) { trailingScan = nextDigitAnchorAfterMiss(trailingText, trailingScan); continue }
     const num = match.groups!.num
     const op = match.groups!.op
     const operatorOffset = match.index + num.length
@@ -368,8 +398,13 @@ function multiplicationOverView(view: ProseView): void {
     // trailing `\b`; otherwise reject when a word character follows the operator
     // through at most three boundaries.
     if (op === "*") continue
+    // An uppercase `X` directly attached to the digits is a model/SKU suffix
+    // (Ryzen 9 5900X), not a multiplier — prose multipliers write a lowercase
+    // x ("by 4x."). Chains ("16X16") convert above regardless of case.
+    if (op === "X") continue
     const afterOp = operatorOffset + 1
     const followChar = trailingText[afterOp]
+    if (followChar !== undefined && CURLY_APOSTROPHE_FOLLOWERS.has(followChar)) continue
     if (boundaryCountAt(view, afterOp) <= MAX_BOUNDARY_SEPARATORS && followChar !== undefined && WORD_RE.test(followChar)) continue
     view.replace(operatorOffset, afterOp, MULTIPLICATION)
   }
@@ -435,9 +470,7 @@ function mathLookaheadBlocks(text: string, view: ProseView, end: number, forbidd
  */
 function mathOperatorAllowBoundary(match: RegExpExecArray, view: ProseView): boolean {
   const junction = match.index + match[0].length - 1
-  for (const boundary of view.boundaries) {
-    if (boundary > match.index && boundary < match.index + match[0].length && boundary !== junction) return false
-  }
+  if (!interiorBoundariesWithin(view, match.index, match.index + match[0].length, [junction])) return false
   return boundaryCountAt(view, junction) <= 1
 }
 
@@ -634,6 +667,9 @@ function arrowsOverView(view: ProseView): void {
     const text = view.text
     let i = 0
     while (i < text.length) {
+      // Every arrow shape starts with `-` or `<`; skip other offsets before
+      // the comparatively expensive left-context/boundary check.
+      if (text[i] !== "-" && text[i] !== "<") { i++; continue }
       if (!arrowLeftContextOk(view, text, i)) { i++; continue }
       const end = matcher(view, text, i)
       if (end < 0 || !arrowRightContextOk(view, text, end)) { i++; continue }
@@ -644,6 +680,20 @@ function arrowsOverView(view: ProseView): void {
   }
 }
 
+/**
+ * A temperature's digit run starts a word: a letter directly before the run
+ * makes it an identifier ("W3C", "HTML5C"), and a `%` makes it a URL-encoded
+ * octet ("%2C"). Mirrors {@link chainGuardOk}'s boundary handling — a node
+ * boundary at the run start shadows the prior character and the guard passes.
+ */
+function degreeLeadingGuardOk(text: string, view: ProseView, digitIndex: number): boolean {
+  let start = digitIndex
+  while (start > 0 && /\d/.test(text[start - 1]) && !view.hasBoundary(start)) start--
+  if (view.hasBoundary(start)) return true
+  const prior = text[start - 1]
+  return prior === undefined || (!LATIN_LETTER_RE.test(prior) && prior !== "%")
+}
+
 export const degrees = makeProsePass(degreesOverView)
 
 function degreesOverView(view: ProseView): void {
@@ -657,6 +707,7 @@ function degreesOverView(view: ProseView): void {
   const text = view.text
   replaceAllInView(view, pattern, (match, v) => {
     const unitEnd = match.index + match[0].length
+    if (!degreeLeadingGuardOk(text, v, match.index)) return null
     if (!degreeUnitFollowOk(text, v, unitEnd)) return null
     const { unit } = match.groups!
     // Replace everything after the leading digit (the optional space and the
@@ -704,11 +755,9 @@ function degreeUnitFollowOk(text: string, view: ProseView, unitEnd: number): boo
 function digitSuffixBoundaryOk(match: RegExpExecArray, view: ProseView): boolean {
   const digitEnd = match.index + 1
   const matchEnd = match.index + match[0].length
-  for (const boundary of view.boundaries) {
-    // Reject any interior boundary that is not the single tolerated slot after
-    // the leading digit.
-    if (boundary > match.index && boundary < matchEnd && boundary !== digitEnd) return false
-  }
+  // Reject any interior boundary that is not the single tolerated slot after
+  // the leading digit.
+  if (!interiorBoundariesWithin(view, match.index, matchEnd, [digitEnd])) return false
   return boundaryCountAt(view, digitEnd) <= 1
 }
 
@@ -757,10 +806,8 @@ function fractionsOverView(view: ProseView): void {
     if (!fractionLookaheadOk(text, v, end)) return null
     // Distribute interior boundaries: the first lands before the unicode char,
     // any remaining after it.
-    let firstBoundary = end
-    for (const boundary of v.boundaries) {
-      if (boundary > start && boundary < end) { firstBoundary = boundary; break }
-    }
+    const interior = firstInteriorBoundary(v, start, end)
+    const firstBoundary = interior >= 0 ? interior : end
     if (firstBoundary > start) v.replace(start, firstBoundary, "")
     v.replace(firstBoundary, end, FRACTION_MAP[match[0]])
     return null

package/src/utils.ts

@@ -67,8 +67,3 @@ export function stableStringify(obj: object): string {
     .map(([k, v]) => [k, Array.isArray(v) ? [...v].sort() : v])
   return JSON.stringify(entries)
 }
-
-/** Extracts named groups from a `.replace()` callback's arguments. @internal */
-export function namedGroups<G>(args: unknown[]): G {
-  return args[args.length - 1] as G
-}