punctilio 5.0.10 → 5.1.1

package/src/quote-classifier.ts

@@ -92,6 +92,17 @@ interface Item {
   end: number
   /** Set when punctuation placement relocates this item. */
   moved: boolean
+  /**
+   * Set on a CLOSE_SINGLE that has no matching opener, so punctuation
+   * placement must not move around it. Two cases qualify: a word-final quote
+   * directly after a letter, which reads as elision ("keep on truckin'") at
+   * least as plausibly as quotation — pulling the period into "truckin'."
+   * corrupts the word to "truckin.'" — and, in German, any orphan closer,
+   * because German re-derives its rendered glyph (U+2018) back to a straight
+   * quote by position on the next run, so relocating punctuation around it
+   * changes that re-derived shape and breaks the fixed point ("'06,'").
+   */
+  frozenCloser?: boolean
   /** Insertion anchor (clean-text offset and bind side) once moved. */
   anchorOffset: number
   anchorBind: "left" | "right"
@@ -126,7 +137,7 @@ const SINGLE_QUOTE_FAMILY = new Set<string>(["'", LEFT_SINGLE_QUOTE, RIGHT_SINGL
 /** Ending-context chars for single quotes (plus any \s char). The curly
  * doubles accompany the straight one: `"` curls into one of them in this same
  * pass, and an ending decision must survive the curl. */
-const SINGLE_ENDING_SET = new Set<string>([".", "!", "?", ";", ",", ")", EM_DASH, "-", "]", '"', LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, ELLIPSIS, ...FOLDED_TERMINALS])
+const SINGLE_ENDING_SET = new Set<string>([".", "!", "?", ";", ":", ",", ")", EM_DASH, "-", "]", '"', LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, ELLIPSIS, ...FOLDED_TERMINALS])
 
 /** Boundary chars before an opening single quote (plus any \s char). A
  * straight double quote belongs with the curly pair: whichever way it curls
@@ -152,7 +163,7 @@ const DOUBLE_EMPTY_BEFORE_SET = new Set<string>(["(", "[", "{"])
 const DOUBLE_EMPTY_AFTER_SET = new Set<string>([")", "]", "}", ".", "!", "?", ",", ";", ":", "/", "-", "s", EM_DASH, ELLIPSIS, ...FOLDED_TERMINALS])
 
 /** 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])
+const DOUBLE_CLOSE_AFTER_SET = new Set<string>(["/", ")", "]", ".", ",", ";", EM_DASH, ":", "-", "}", "!", "?", "s", ELLIPSIS, ...FOLDED_TERMINALS])
 
 /** Builds an `(items, index)` predicate: in range, non-boundary, and `test(ch)`. */
 function makeItemTester(test: (ch: string) => boolean): (items: Item[], index: number) => boolean {
@@ -278,8 +289,13 @@ function buildItems(view: ProseView, style: ActiveQuoteStyle): Item[] {
         mapped = '"'
       } else if (ch === RIGHT_SINGLE_QUOTE || ch === MODIFIER_LETTER_APOSTROPHE) {
         // U+02BC renders as U+2019, which the next run re-derives by position;
-        // re-derive it the same way now so both runs agree.
-        mapped = "'"
+        // re-derive it the same way now so both runs agree. Directly after a
+        // digit the mark is a separator (Swiss "5’000"), never a German quote
+        // glyph: keep the apostrophe role, which renders U+2019 unchanged.
+        // Re-deriving to a straight quote there hands correct typography to
+        // the next run's prime pass ("5'000" → "5′000") — a destroyed
+        // separator and a broken fixed point.
+        mapped = DIGIT_RE.test(text[i - 1] ?? "") ? MODIFIER_LETTER_APOSTROPHE : "'"
       }
       if (mapped !== null) {
         items.push(makeItem(false, mapped, i, i + 1))
@@ -517,9 +533,13 @@ function classifyOpeningSingles(items: Item[]): void {
 
 /**
  * Unmatched CLOSE_SINGLE after s/S → APOSTROPHE (plural possessives), via the
- * advisory open/close balance scan. Boundaries are fully transparent here.
+ * advisory open/close balance scan. An unmatched closer keeps its closer role
+ * but is flagged {@link Item.frozenCloser} so punctuation placement leaves it
+ * alone: after any other letter in every style, and after any character in
+ * German (which re-derives the rendered glyph by position on re-run).
+ * Boundaries are fully transparent here.
  */
-function classifyPluralPossessives(items: Item[]): void {
+function classifyPluralPossessives(items: Item[], style: ActiveQuoteStyle): void {
   let balance = 0
   for (let i = 0; i < items.length; i++) {
     const item = items[i]
@@ -537,6 +557,8 @@ function classifyPluralPossessives(items: Item[]): void {
     while (j >= 0 && items[j].boundary) j--
     if (j >= 0 && (items[j].ch === "s" || items[j].ch === "S")) {
       item.ch = MODIFIER_LETTER_APOSTROPHE
+    } else if (j >= 0 && (isLetterItem(items, j) || style === "german")) {
+      item.frozenCloser = true
     }
   }
 }
@@ -558,7 +580,7 @@ function classifySingles(items: Item[], style: ActiveQuoteStyle): void {
   if (style !== "german") {
     while (classifyPossessivesAndClosers(items)) { /* to fixpoint */ }
   }
-  classifyPluralPossessives(items)
+  classifyPluralPossessives(items, style)
 }
 
 // ---------------------------------------------------------------------------
@@ -674,8 +696,15 @@ function foldsToNotEqual(items: Item[], index: number): boolean {
   return !isCharItem(items, nextIndex(items, eq, 1), "=")
 }
 
-/** Opening double quote by following context. */
-function classifyOpeningDoubles(items: Item[]): void {
+/**
+ * Opening double quote by following context.
+ *
+ * French: a plain space directly before a pre-labeled closer merges into the
+ * closer's rendered NNBSP padding once spaces collapse, so a re-run reads the
+ * closer itself directly after the candidate — read it that way now (the
+ * mirror of {@link classifyClosingDoubles}'s opener-side absorption).
+ */
+function classifyOpeningDoubles(items: Item[], style: ActiveQuoteStyle): void {
   for (let i = 0; i < items.length; i++) {
     const item = items[i]
     if (item.boundary || item.ch !== '"') continue
@@ -693,8 +722,10 @@ function classifyOpeningDoubles(items: Item[]): void {
       const j = nextIndex(items, i, 1)
       if (j < items.length && !items[j].boundary) {
         const ch = items[j].ch
+        const absorbedIntoCloser = style === "french" && ch === " " && isCharItem(items, j + 1, RIGHT_DOUBLE_QUOTE)
         opens = isEllipsisDots(items, j) || foldsToNotEqual(items, j)
           || (!SPACE_RE.test(ch) && !DOUBLE_OPEN_ENDING_SET.has(ch))
+          || absorbedIntoCloser
       }
     }
     if (opens) item.ch = LEFT_DOUBLE_QUOTE
@@ -721,19 +752,37 @@ function quotedPunctuationPrefixOk(items: Item[], index: number): boolean {
  * Quoted-punctuation openers like `"?"`: an opener-prefixed straight double
  * quote with a closing straight double quote anywhere ahead (at least one
  * item between them). Decisions use the pass-start set of straight quotes.
+ *
+ * Inside an already-open double quote the same shape is that quote's closer,
+ * not a new opener: in `"un-" or "non-"` the quote after `un-` is
+ * opener-prefixed (a hyphen) with a straight quote ahead, but it closes the
+ * open `“un-`. A running depth of classified doubles — updated as this pass
+ * assigns roles, so each decision sees the ones before it — picks the reading.
  */
 function classifyQuotedPunctuationOpeners(items: Item[]): void {
   const straightIndices: number[] = []
   for (let i = 0; i < items.length; i++) {
     if (isCharItem(items, i, '"')) straightIndices.push(i)
   }
-  for (let k = 0; k < straightIndices.length; k++) {
-    const i = straightIndices[k]
-    if (!quotedPunctuationPrefixOk(items, i)) continue
-    const closer = straightIndices[k + 1]
-    if (closer !== undefined && closer >= i + 2) {
-      items[i].ch = LEFT_DOUBLE_QUOTE
+  let openDepth = 0
+  let k = 0
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i]
+    if (item.boundary) continue
+    if (k < straightIndices.length && straightIndices[k] === i) {
+      // `i` is a pass-start straight quote; after k++, `straightIndices[k]`
+      // is the nearest pass-start straight quote ahead of it.
+      k++
+      const closer = straightIndices[k]
+      if (quotedPunctuationPrefixOk(items, i) && closer !== undefined && closer >= i + 2) {
+        item.ch = openDepth > 0 ? RIGHT_DOUBLE_QUOTE : LEFT_DOUBLE_QUOTE
+      }
     }
+    // Depth over classified doubles, including the role just assigned above.
+    // A still-straight double quote below an open `“` counts as its closer:
+    // the closing rules classify it that way after this pass ends.
+    if (item.ch === LEFT_DOUBLE_QUOTE) openDepth++
+    else if ((item.ch === RIGHT_DOUBLE_QUOTE || item.ch === '"') && openDepth > 0) openDepth--
   }
 }
 
@@ -804,7 +853,7 @@ function classifySinglesBeforeClosingDoubles(items: Item[]): void {
 
 function classifyDoubles(items: Item[], style: ActiveQuoteStyle): void {
   classifyEmptyDoublePairs(items)
-  classifyOpeningDoubles(items)
+  classifyOpeningDoubles(items, style)
   classifyQuotedPunctuationOpeners(items)
   classifyBraceOpeners(items)
   classifyClosingDoubles(items, style)
@@ -826,6 +875,9 @@ function classifyDoubles(items: Item[], style: ActiveQuoteStyle): void {
  */
 function closingRunMemberAt(items: Item[], index: number, closingSet: ReadonlySet<string>): boolean {
   if (index >= items.length || items[index].boundary || !closingSet.has(items[index].ch)) return false
+  // A word-final closer with no opener behind it reads as elision; moving
+  // punctuation around it corrupts the word ("truckin'." → "truckin.'").
+  if (items[index].frozenCloser) return false
   if (items[index].ch !== MODIFIER_LETTER_APOSTROPHE) return true
   const prev = prevIndex(items, index, 1)
   return !isCharItem(items, prev, "s") && !isCharItem(items, prev, "S")
@@ -960,6 +1012,13 @@ function movePunctuationInside(order: Item[], isMovable: (items: Item[], index:
       position++
       continue
     }
+    // A space directly before the run marks an exact-string quote (`"New ",`):
+    // its content ends in whitespace on purpose, and pulling the punctuation
+    // inside would attach it to that verbatim trailing space.
+    if (beforeIndex >= 0 && !order[beforeIndex].boundary && SPACE_RE.test(order[beforeIndex].ch)) {
+      position++
+      continue
+    }
     // Moving the punctuation inside strips the run of its ending context: an
     // unresolved straight single quote earlier in the text whose closer-ahead
     // scan reads a single closer in this run would stop seeing it as a closer
@@ -1381,7 +1440,7 @@ function quotePassClosesCandidate(items: Item[], index: number, quote: string):
  * a prime only when the running quote balance is open-free; contractions are
  * skipped and trailing apostrophes consume balance without converting.
  */
-function convertPrimes(items: Item[]): void {
+function convertPrimes(items: Item[], swissSeparators: ReadonlySet<number>): void {
   const passes: [string, string][] = [
     ["'", PRIME],
     ['"', DOUBLE_PRIME],
@@ -1391,6 +1450,12 @@ function convertPrimes(items: Item[]): void {
     for (let i = 0; i < items.length; i++) {
       const item = items[i]
       if (item.boundary || item.ch !== quote) continue
+      // A Swiss/Liechtenstein digit-group separator (5'000) is an apostrophe,
+      // not a foot/minute prime; curl it and leave the quote balance untouched.
+      if (quote === "'" && swissSeparators.has(item.start)) {
+        item.ch = RIGHT_SINGLE_QUOTE
+        continue
+      }
       const digitIndex = prevIndex(items, i, 1)
       if (isDigitItem(items, digitIndex) && !isLetterItem(items, i + 1)) {
         // Prime candidate. The after-context check is boundary-blind: a
@@ -1426,12 +1491,38 @@ function convertPrimes(items: Item[]): void {
   }
 }
 
+/**
+ * Every conversion in {@link convertPrimes} keys on a digit item directly
+ * before the quote, and boundary items are zero-width, so clean text without
+ * a digit-quote pair can never change. Checking that up front skips the full
+ * per-character item build on the (overwhelmingly common) digit-free prose.
+ */
+const PRIME_CANDIDATE_RE = /\d['"]/
+
+// Swiss/Liechtenstein thousands grouping: 5'000, 1'000'000, 5'000.50. Leading
+// group of 1-3 digits, then one or more apostrophe-separated groups of exactly
+// three, not embedded in a longer digit run. Groups of exactly three rule out
+// feet-inches (5'10", 6'2"), whose inch value is one or two digits.
+const SWISS_THOUSANDS_RE = /(?<![\d'])\d{1,3}(?:'\d{3})+(?!\d)/g
+
+/** Offsets of the apostrophes that separate Swiss thousands groups in `text`. */
+function swissThousandsSeparators(text: string): ReadonlySet<number> {
+  const offsets = new Set<number>()
+  if (!text.includes("'")) return offsets
+  for (const match of text.matchAll(SWISS_THOUSANDS_RE)) {
+    for (let i = 0; i < match[0].length; i++) {
+      if (match[0][i] === "'") offsets.add(match.index + i)
+    }
+  }
+  return offsets
+}
+
 /** primeMarks engine: converts `5'10"` to `5′10″` with quote-balance guards. Commits its edits. */
 export function convertPrimeMarks(view: ProseView): void {
   const text = view.text
-  if (!text.includes("'") && !text.includes('"')) return
+  if (!PRIME_CANDIDATE_RE.test(text)) return
   const items = buildItems(view, "american")
-  convertPrimes(items)
+  convertPrimes(items, swissThousandsSeparators(text))
   for (const item of items) {
     if (!item.boundary && item.ch !== text[item.start]) {
       view.replace(item.start, item.end, item.ch)

package/src/rehype.ts

@@ -7,7 +7,7 @@ import { transformView } from "./index.js"
 import { TRANSFORM_OPTION_KEYS, type TransformOptions } from "./transform-options.js"
 import { MAX_RECURSION_DEPTH } from "./constants.js"
 import { assertKnownOptionKeys, formatErrorString } from "./utils.js"
-import { buildProseView, type ProsePass, type ProseView } from "./prose-view.js"
+import { buildProseView, type ProsePass, type ProseView, splitAtIndices } from "./prose-view.js"
 
 export type ElementPredicate = (node: Element) => boolean
 
@@ -80,53 +80,100 @@ export const REHYPE_ONLY_OPTION_KEYS: readonly string[] = ["skipTags", "skipClas
 /** Runtime list of valid `rehypePunctilio` option keys. */
 export const REHYPE_OPTION_KEYS: readonly string[] = [...TRANSFORM_OPTION_KEYS, ...REHYPE_ONLY_OPTION_KEYS]
 
-export function flattenTextNodes(
-  node: Element | ElementContent,
-  shouldSkip: ElementPredicate,
-  options?: ElementTransformOptions
-): Text[] {
-  const shouldSkipText = options?.shouldSkipText
-  // Only track ancestors when shouldSkipText needs them, to avoid the
-  // O(n²) allocation cost of copying the ancestor chain at every level.
-  const ancestors: Element[] | null = shouldSkipText ? [] : null
-  return flattenTextNodesImpl(node, shouldSkip, shouldSkipText, ancestors, 0)
+// Void/replaced inline elements that render atomic content (or a hard break)
+// and carry no transformable text. When one sits between two text nodes it is a
+// real visual separator, so the flattener records an opaque gap there.
+const OPAQUE_VOID_TAGS = new Set([
+  "img", "br", "wbr", "input", "hr", "embed",
+  "area", "source", "track", "col", "param", "keygen",
+])
+
+/** Flattened text nodes plus the opaque gaps that fell between adjacent ones. */
+export interface FlattenedProse {
+  nodes: Text[]
+  /** Indices into `nodes` (1..n-1) with removed opaque content immediately before them. */
+  opaqueBefore: Set<number>
 }
 
-function flattenTextNodesImpl(
-  node: Element | ElementContent,
-  shouldSkip: ElementPredicate,
-  shouldSkipText: TextNodeSkipPredicate | undefined,
-  ancestors: Element[] | null,
-  depth: number
-): Text[] {
+interface ProseCollector {
+  nodes: Text[]
+  opaqueBefore: Set<number>
+  shouldSkip: ElementPredicate
+  shouldSkipText: TextNodeSkipPredicate | undefined
+  ancestors: Element[] | null
+  // An opaque element was dropped since the last emitted text node; the next
+  // emitted node records an opaque gap before it.
+  pendingOpaque: boolean
+}
+
+function collectProse(node: Element | ElementContent, depth: number, c: ProseCollector): void {
   if (depth > MAX_RECURSION_DEPTH) {
-    return []
+    return
   }
 
-  if (node.type === "element" && shouldSkip(node)) {
-    return []
+  if (node.type === "element") {
+    if (c.shouldSkip(node)) {
+      // A skipped element with content is a visual separator; an empty one
+      // renders nothing and leaves its neighbors genuinely adjacent.
+      if (node.children.length > 0) c.pendingOpaque = true
+      return
+    }
+    if (OPAQUE_VOID_TAGS.has(node.tagName)) {
+      c.pendingOpaque = true
+      return
+    }
+    if (c.ancestors) c.ancestors.push(node)
+    for (const child of node.children) collectProse(child, depth + 1, c)
+    if (c.ancestors) c.ancestors.pop()
+    return
   }
 
   if (node.type === "text") {
     // Snapshot ancestors at the callback boundary — the walker mutates the
     // shared array as it recurses, so handing it out directly would let a
     // caller observe a stale view if they captured the reference.
-    if (shouldSkipText && ancestors && shouldSkipText(node, ancestors.slice())) {
-      return []
+    if (c.shouldSkipText && c.ancestors && c.shouldSkipText(node, c.ancestors.slice())) {
+      // Preserved-but-untransformed text is a separator between its neighbors.
+      c.pendingOpaque = true
+      return
     }
-    return [node]
+    if (c.pendingOpaque && c.nodes.length > 0) c.opaqueBefore.add(c.nodes.length)
+    c.pendingOpaque = false
+    c.nodes.push(node)
   }
+}
 
-  if (node.type === "element") {
-    if (ancestors) ancestors.push(node)
-    const result = node.children.flatMap((child) =>
-      flattenTextNodesImpl(child, shouldSkip, shouldSkipText, ancestors, depth + 1)
-    )
-    if (ancestors) ancestors.pop()
-    return result
+function newCollector(shouldSkip: ElementPredicate, options?: ElementTransformOptions): ProseCollector {
+  const shouldSkipText = options?.shouldSkipText
+  return {
+    nodes: [],
+    opaqueBefore: new Set(),
+    shouldSkip,
+    shouldSkipText,
+    // Only track ancestors when shouldSkipText needs them, to avoid the
+    // O(n²) allocation cost of copying the ancestor chain at every level.
+    ancestors: shouldSkipText ? [] : null,
+    pendingOpaque: false,
   }
+}
 
-  return []
+/** Flattens an element's transformable text nodes, tracking opaque gaps. */
+export function flattenProse(
+  node: Element | ElementContent,
+  shouldSkip: ElementPredicate,
+  options?: ElementTransformOptions
+): FlattenedProse {
+  const c = newCollector(shouldSkip, options)
+  collectProse(node, 0, c)
+  return { nodes: c.nodes, opaqueBefore: c.opaqueBefore }
+}
+
+export function flattenTextNodes(
+  node: Element | ElementContent,
+  shouldSkip: ElementPredicate,
+  options?: ElementTransformOptions
+): Text[] {
+  return flattenProse(node, shouldSkip, options).nodes
 }
 
 export function getTextContent(
@@ -191,9 +238,11 @@ export interface ProseViewOfOptions extends ElementTransformOptions {
 }
 
 /**
- * Builds a ProseView over the element's transformable text nodes, honoring
- * the element-level `shouldSkip` and per-text-node `shouldSkipText`
- * predicates. Returns null when the element holds no transformable text.
+ * Builds a single ProseView over the element's transformable text nodes,
+ * honoring the element-level `shouldSkip` and per-text-node `shouldSkipText`
+ * predicates. Returns null when the element holds no transformable text. This
+ * view spans opaque gaps; the transform pipeline uses {@link proseViewsOf},
+ * which splits on them so no pass rewrites across removed atomic content.
  */
 export function proseViewOf(element: Element, options: ProseViewOfOptions = {}): ProseView | null {
   /* istanbul ignore if -- defensive: elements should always have children array */
@@ -210,6 +259,22 @@ export function proseViewOf(element: Element, options: ProseViewOfOptions = {}):
   return buildProseView(textNodes)
 }
 
+/**
+ * Builds one ProseView per opaque-delimited segment of the element's text.
+ * Splitting at opaque gaps (removed skipped elements, images, and other atomic
+ * inline content) keeps their surrounding text in separate views, so a pass can
+ * never treat text as adjacent across content that visually separates it.
+ */
+export function proseViewsOf(element: Element, options: ProseViewOfOptions = {}): ProseView[] {
+  /* istanbul ignore if -- defensive: elements should always have children array */
+  if (!element?.children) {
+    return []
+  }
+  const shouldSkip = options.shouldSkip ?? (() => false)
+  const { nodes, opaqueBefore } = flattenProse(element, shouldSkip, options)
+  return splitAtIndices(nodes, opaqueBefore).map((group) => buildProseView(group))
+}
+
 /**
  * One entry in an `applyPasses` sequence: a bare pass, or a pass with its own
  * skip predicates layered on top of the base options (the per-transform
@@ -255,7 +320,7 @@ export function applyPasses(
   passes: readonly PassEntry[],
   options: ProseViewOfOptions = {},
 ): void {
-  let currentView: ProseView | null = null
+  let currentViews: ProseView[] = []
   let currentPredicates: Pick<ResolvedPassEntry, "shouldSkip" | "shouldSkipText"> | null = null
 
   for (const entry of passes) {
@@ -266,20 +331,18 @@ export function applyPasses(
       currentPredicates.shouldSkip === shouldSkip &&
       currentPredicates.shouldSkipText === shouldSkipText
     if (!samePredicates) {
-      currentView = proseViewOf(element, {
+      currentViews = proseViewsOf(element, {
         shouldSkip: mergePredicates(options.shouldSkip, shouldSkip),
         shouldSkipText: mergePredicates(options.shouldSkipText, shouldSkipText),
       })
       currentPredicates = { shouldSkip, shouldSkipText }
     }
 
-    // No transformable text under this entry's predicates; later entries may
-    // still see text (their skip sets differ), so keep going.
-    if (currentView === null) {
-      continue
+    // Each opaque-delimited segment is transformed independently; an entry with
+    // no transformable text simply has no views to run over.
+    for (const view of currentViews) {
+      pass(view)
     }
-
-    pass(currentView)
   }
 }
 
@@ -433,31 +496,47 @@ function resolveCollectOptions(options: CollectProseBlocksOptions): ResolvedColl
   }
 }
 
+// A prose unit is either a whole transformable element (an inline-only leaf) or
+// a "run" of consecutive inline siblings that sit alongside block-level
+// children. Runs let a container's loose inline text transform independently of
+// its block children instead of merging across the block boundary.
+type ProseUnit =
+  | { kind: "element"; element: Element }
+  | { kind: "run"; container: Element; children: ElementContent[] }
+
 /**
- * Collects the elements under `root` (inclusive) whose text should be
+ * Collects the leaf elements under `root` (inclusive) whose text should be
  * transformed as one prose block: transformable elements with direct text or
  * inline-only text descendants. Elements with block-level children recurse so
- * each block transforms independently.
+ * each block transforms independently. Loose inline text mixed among block
+ * children is handled by the plugin as its own run and is not represented here.
  */
 export function collectProseBlocks(root: Element, options: CollectProseBlocksOptions = {}): Element[] {
   const { shouldSkip, isTransformable } = resolveCollectOptions(options)
-  return collectProseBlocksImpl(root, shouldSkip, 0, undefined, isTransformable)
+  return collectProseUnitsImpl(root, shouldSkip, 0, undefined, isTransformable)
+    .flatMap((unit) => (unit.kind === "element" ? [unit.element] : []))
 }
 
-function collectProseBlocksImpl(
+function runHasProse(children: readonly ElementContent[], shouldSkip: ElementPredicate): boolean {
+  return children.some(
+    (child) =>
+      (child.type === "text" && child.value.trim() !== "") ||
+      (child.type === "element" && hasTextDescendant(child, shouldSkip))
+  )
+}
+
+function collectProseUnitsImpl(
   node: Element,
   shouldSkip: ElementPredicate,
   depth: number,
   alreadyTransformed: ReadonlySet<Element> | undefined,
   isTransformable: (tagName: string) => boolean
-): Element[] {
+): ProseUnit[] {
   /* istanbul ignore if -- defensive: prevents stack overflow from malicious HTML */
   if (depth > MAX_RECURSION_DEPTH) {
     return []
   }
 
-  const results: Element[] = []
-
   if (shouldSkip(node) || alreadyTransformed?.has(node)) {
     return []
   }
@@ -470,31 +549,67 @@ function collectProseBlocksImpl(
   const hasDirectText = node.children.some(
     (child) => child.type === "text" && child.value.trim() !== ""
   )
-  // Only check for block children and text descendants when there's no direct text
-  // (short-circuit avoids unnecessary tree traversal)
-  const hasBlockChildren = !hasDirectText && node.children.some(
+  const hasBlockChildren = node.children.some(
     (child) => child.type === "element" && BLOCK_ELEMENTS.has(child.tagName)
   )
-  const hasTextDescendants = !hasDirectText && !hasBlockChildren &&
-    hasTextDescendant(node, shouldSkip)
 
+  // Inline-only transformable node: a single leaf unit. `hasTextDescendant` is
+  // only walked when there's no direct text (short-circuit avoids the traversal).
   if (
     isTransformable(node.tagName) &&
-    (hasDirectText || hasTextDescendants)
+    !hasBlockChildren &&
+    (hasDirectText || hasTextDescendant(node, shouldSkip))
   ) {
-    results.push(node)
+    return [{ kind: "element", element: node }]
+  }
+
+  const units: ProseUnit[] = []
+  if (isTransformable(node.tagName) && hasBlockChildren) {
+    // Mixed content: split each maximal run of inline siblings from the block
+    // children so loose text transforms on its own, then recurse per block.
+    let run: ElementContent[] = []
+    const flushRun = () => {
+      if (runHasProse(run, shouldSkip)) units.push({ kind: "run", container: node, children: run })
+      run = []
+    }
+    for (const child of node.children) {
+      if (child.type === "element" && BLOCK_ELEMENTS.has(child.tagName)) {
+        flushRun()
+        for (const u of collectProseUnitsImpl(child, shouldSkip, depth + 1, alreadyTransformed, isTransformable)) {
+          units.push(u)
+        }
+      } else {
+        run.push(child)
+      }
+    }
+    flushRun()
   } else {
-    // Recurse into children: either the node isn't transformable, has block
-    // children that should be independent, or has no text to transform.
+    // Non-transformable, or transformable but textless: recurse into elements.
     for (const child of node.children) {
       if (child.type === "element") {
-        const childResults = collectProseBlocksImpl(child, shouldSkip, depth + 1, alreadyTransformed, isTransformable)
-        for (const r of childResults) results.push(r)
+        for (const u of collectProseUnitsImpl(child, shouldSkip, depth + 1, alreadyTransformed, isTransformable)) {
+          units.push(u)
+        }
       }
     }
   }
 
-  return results
+  return units
+}
+
+// Flatten a run's inline siblings to their text nodes (with opaque gaps),
+// seeding the ancestor chain with `container` so `shouldSkipText` sees the same
+// ancestors it would when the whole element is flattened as a leaf.
+function flattenRunProse(
+  container: Element,
+  children: readonly ElementContent[],
+  shouldSkip: ElementPredicate,
+  options: ProseViewOfOptions
+): FlattenedProse {
+  const c = newCollector(shouldSkip, options)
+  if (c.ancestors) c.ancestors.push(container)
+  for (const child of children) collectProse(child, 1, c)
+  return { nodes: c.nodes, opaqueBefore: c.opaqueBefore }
 }
 
 function markDescendants(node: Element, set: Set<Element>, depth: number = 0): void {
@@ -547,17 +662,32 @@ export function rehypePunctilio(
         return SKIP
       }
 
-      // Collect and transform elements with text content
-      const elementsToTransform = collectProseBlocksImpl(node, shouldSkip, 0, transformed, isTransformable)
-      for (const elt of elementsToTransform) {
-        if (!transformed.has(elt)) {
-          const view = proseViewOf(elt, viewOptions)
-          if (view !== null) {
-            transformView(view, transformOptions)
+      // Collect and transform every prose unit in this subtree.
+      const units = collectProseUnitsImpl(node, shouldSkip, 0, transformed, isTransformable)
+      for (const unit of units) {
+        if (unit.kind === "element") {
+          if (!transformed.has(unit.element)) {
+            for (const view of proseViewsOf(unit.element, viewOptions)) {
+              transformView(view, transformOptions)
+            }
+            transformed.add(unit.element)
+            // Mark all descendants as processed since their text was included
+            markDescendants(unit.element, transformed)
+          }
+        } else {
+          const { nodes, opaqueBefore } = flattenRunProse(unit.container, unit.children, shouldSkip, viewOptions)
+          for (const group of splitAtIndices(nodes, opaqueBefore)) {
+            transformView(buildProseView(group), transformOptions)
+          }
+          // Mark the container so a later visit doesn't re-collect its runs,
+          // and mark the run's inline-element members' subtrees.
+          transformed.add(unit.container)
+          for (const child of unit.children) {
+            if (child.type === "element") {
+              transformed.add(child)
+              markDescendants(child, transformed)
+            }
           }
-          transformed.add(elt)
-          // Mark all descendants as processed since their text was included
-          markDescendants(elt, transformed)
         }
       }
     })