punctilio 5.4.9 → 5.5.0

package/src/prose-view.ts

@@ -35,6 +35,17 @@ function splitsSurrogatePair(text: string, offset: number): boolean {
   return high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff;
 }
 
+/**
+ * The scan index one position past `index`: one code point for a unicode-mode
+ * (u/v) regex, else one code unit. Resuming a unicode-mode regex inside a
+ * surrogate pair makes `exec` back up to the pair's start and re-match there
+ * forever.
+ */
+export function advanceScanIndex(text: string, index: number, regex: RegExp): number {
+  const unicodeMode = regex.unicode || regex.flags.includes("v");
+  return index + (unicodeMode && splitsSurrogatePair(text, index + 1) ? 2 : 1);
+}
+
 class ProseViewImpl implements ProseView {
   private readonly nodes: ProseNode[];
   private cachedText: string;
@@ -262,6 +273,93 @@ export function splitAtIndices<T>(
   return groups;
 }
 
+/**
+ * Stand-in for removed opaque inline content (a skipped element, an image,
+ * inline code) inside a spanning view. U+FFFC OBJECT REPLACEMENT CHARACTER is
+ * Unicode's placeholder for an embedded object: it is neither space, word
+ * character, nor punctuation, so a pass needing adjacent text never matches
+ * across it (`5<code>c</code>x 3` stays put), while the quote classifier still
+ * sees real content between a quote and its partner (`"<kbd>q</kbd>"` pairs).
+ */
+export const OPAQUE_PLACEHOLDER = "\uFFFC";
+
+/**
+ * Single-quote edge stand-ins. The classifier reads end of text as an ending
+ * context after a closing single quote and as an opening context before an
+ * opening one, but reads {@link OPAQUE_PLACEHOLDER} as neither, so `'hi'` or
+ * `boys'` directly before a gap, or `'hi'` directly after one, would lose the
+ * role the segment edge gives it. A `)` after the quote and a `(` before it
+ * restore those contexts without blocking a pair across the gap
+ * (`'<code>x</code>'` still pairs). They are added only beside a single quote:
+ * double quotes read the placeholder correctly, and `)` would block a double
+ * opener.
+ */
+const SEGMENT_END_STAND_IN = ")";
+const SEGMENT_START_STAND_IN = "(";
+
+/** Straight, curly, modifier-letter and low-9 single-quote characters. */
+const SINGLE_QUOTE_CHARS: ReadonlySet<string> = new Set([
+  "'",
+  "\u2018",
+  "\u2019",
+  "\u02BC",
+  "\u201A",
+]);
+
+/** Gap stand-in for the text between `before` and `after`. */
+function gapPlaceholder(before: string, after: string): string {
+  const afterQuote = SINGLE_QUOTE_CHARS.has(before.slice(-1));
+  const beforeQuote = SINGLE_QUOTE_CHARS.has(after.slice(0, 1));
+  return (
+    (afterQuote ? SEGMENT_END_STAND_IN : "") +
+    OPAQUE_PLACEHOLDER +
+    (beforeQuote ? SEGMENT_START_STAND_IN : "")
+  );
+}
+
+/**
+ * Runs `run` over `nodes` as one view with a placeholder node (see
+ * {@link OPAQUE_PLACEHOLDER}) at each opaque gap (`breakBefore`, as for
+ * {@link splitAtIndices}), so context-sensitive passes such as quote pairing
+ * read across the gap. The view is committed after `run`. If any edit lands in
+ * a placeholder (one that spans, replaces, or is inserted into the gap), the
+ * nodes are restored and `run` goes over each opaque-delimited segment on its
+ * own instead, so no edit ever lands in or through a gap.
+ */
+export function runAcrossOpaqueGaps(
+  nodes: readonly ProseNode[],
+  breakBefore: ReadonlySet<number>,
+  run: (view: ProseView) => void,
+): void {
+  if (nodes.length === 0) return;
+  const originalValues = nodes.map((node) => node.value);
+  const placeholders: { node: ProseNode; value: string }[] = [];
+  const spanning: ProseNode[] = [];
+  nodes.forEach((node, index) => {
+    if (breakBefore.has(index)) {
+      const value = gapPlaceholder(nodes[index - 1].value, node.value);
+      const placeholder = { value };
+      placeholders.push({ node: placeholder, value });
+      spanning.push(placeholder);
+    }
+    spanning.push(node);
+  });
+
+  const spanningView = buildProseView(spanning);
+  run(spanningView);
+  spanningView.commit();
+  if (placeholders.every(({ node, value }) => node.value === value)) return;
+
+  nodes.forEach((node, index) => {
+    node.value = originalValues[index];
+  });
+  for (const group of splitAtIndices(nodes, breakBefore)) {
+    const segmentView = buildProseView(group);
+    run(segmentView);
+    segmentView.commit();
+  }
+}
+
 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;
@@ -382,7 +480,7 @@ export function replaceAllInView(
   let match: RegExpExecArray | null;
   while ((match = regex.exec(text)) !== null) {
     if (match[0].length === 0) {
-      regex.lastIndex += 1;
+      regex.lastIndex = advanceScanIndex(text, regex.lastIndex, regex);
     }
 
     if (matchContainsBoundary(match, view) && !allowBoundaries?.(match, view)) {

package/src/quote-classifier.ts

@@ -1,4 +1,4 @@
-import { FOLDED_WORD_CHARS, LATIN_LETTER_RE, SPACE_CHAR_RE, TERMINAL_PUNCTUATION, UNICODE_SYMBOLS, WORD_RE } from "./constants.js"
+import { CLOSING_BRACKETS, FOLDED_WORD_CHARS, LATIN_LETTER_RE, OPENING_BRACKETS, SPACE_CHAR_RE, TERMINAL_PUNCTUATION, UNICODE_SYMBOLS, WORD_RE } from "./constants.js"
 import type { ProseView } from "./prose-view.js"
 
 const {
@@ -14,6 +14,8 @@ const {
   SINGLE_LOW_9_QUOTE,
   LEFT_GUILLEMET,
   RIGHT_GUILLEMET,
+  INVERTED_EXCLAMATION,
+  INVERTED_QUESTION,
   NBSP,
   NNBSP,
   PRIME,
@@ -103,6 +105,12 @@ interface Item {
    * changes that re-derived shape and breaks the fixed point ("'06,'").
    */
   frozenCloser?: boolean
+  /**
+   * Set on a German item whose curly source glyph was re-derived to a straight
+   * candidate by position. If classification assigns it no role, it renders as
+   * this glyph: the style never downgrades curly text to straight.
+   */
+  curlySource?: string
   /** Insertion anchor (clean-text offset and bind side) once moved. */
   anchorOffset: number
   anchorBind: "left" | "right"
@@ -143,10 +151,11 @@ const SINGLE_ENDING_SET = new Set<string>([".", "!", "?", ";", ":", ",", ")", EM
  * straight double quote belongs with the curly pair: whichever way it curls
  * lands in this set, so deciding as if it already had keeps re-runs (which
  * see the curled glyph) consistent. */
-const SINGLE_OPEN_BEFORE_SET = new Set<string>([LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, '"', EM_DASH, "-", "("])
+const SINGLE_OPEN_BEFORE_SET = new Set<string>([LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, '"', EM_DASH, "-", "(", "/", "[", "{", INVERTED_QUESTION, INVERTED_EXCLAMATION])
 
-/** Boundary chars before an opening double quote (plus any \s char). */
-const DOUBLE_OPEN_BEFORE_SET = new Set<string>(["(", "/", "[", "{", "-", EM_DASH])
+/** Boundary chars before an opening double quote (plus any \s char). A
+ * single opener qualifies: a double quoted directly inside a single. */
+const DOUBLE_OPEN_BEFORE_SET = new Set<string>(["(", "/", "[", "{", "-", EM_DASH, LEFT_SINGLE_QUOTE, INVERTED_QUESTION, INVERTED_EXCLAMATION])
 
 /** Ending-context chars that block the opener rule's arm 2 (plus any \s char).
  * ELLIPSIS is deliberately absent: the rule's `...` arm opens, so `…` must too. */
@@ -160,10 +169,10 @@ const DOUBLE_EMPTY_BEFORE_SET = new Set<string>(["(", "[", "{"])
  * rule rejects falls through to opener/closer rules whose after-contexts are
  * the closer set, and the two routes must accept the same shapes or a re-run
  * (which sees the rendered opener, not the whitespace) classifies anew. */
-const DOUBLE_EMPTY_AFTER_SET = new Set<string>([")", "]", "}", ".", "!", "?", ",", ";", ":", "/", "-", "s", EM_DASH, ELLIPSIS, ...FOLDED_TERMINALS])
+const DOUBLE_EMPTY_AFTER_SET = new Set<string>([")", "]", "}", ".", "!", "?", ",", ";", ":", "/", "-", "s", EM_DASH, ELLIPSIS, RIGHT_SINGLE_QUOTE, ...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, RIGHT_SINGLE_QUOTE, ...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 {
@@ -298,7 +307,9 @@ function buildItems(view: ProseView, style: ActiveQuoteStyle): Item[] {
         mapped = DIGIT_RE.test(text[i - 1] ?? "") ? MODIFIER_LETTER_APOSTROPHE : "'"
       }
       if (mapped !== null) {
-        items.push(makeItem(false, mapped, i, i + 1))
+        const item = makeItem(false, mapped, i, i + 1)
+        if (mapped === '"' || mapped === "'") item.curlySource = ch
+        items.push(item)
         i++
         continue
       }
@@ -346,16 +357,19 @@ function possessiveAfter(items: Item[], index: number): boolean {
 /**
  * `(?<=[^\s“'"])` — the closing/possessive lookbehind. A boundary directly
  * before the quote satisfies it (a boundary is an ordinary non-space char).
- * A straight double quote is excluded along with `“`: it may curl into an
- * opener later in this same pass, which puts the candidate in exactly the
- * nested-opener position the `“` exclusion covers, and deciding against it
- * now keeps re-runs (which see the curled glyph) consistent.
+ * A straight double quote in opener position is excluded along with `“`: it
+ * curls into an opener later in this same pass, which puts the candidate in
+ * exactly the nested-opener position the `“` exclusion covers, and deciding
+ * against it now keeps re-runs (which see the curled glyph) consistent. A
+ * straight double quote outside opener position curls into a closer (`”`,
+ * which passes), so it passes too (`'"Hello"'`).
  */
 function singleCloserBefore(items: Item[], index: number): boolean {
   if (index === 0) return false
   const prev = items[index - 1]
   if (prev.boundary) return true
-  return !SPACE_RE.test(prev.ch) && prev.ch !== LEFT_DOUBLE_QUOTE && prev.ch !== "'" && prev.ch !== '"'
+  if (prev.ch === '"') return !doubleOpenerPrefixOk(items, index - 1)
+  return !SPACE_RE.test(prev.ch) && prev.ch !== LEFT_DOUBLE_QUOTE && prev.ch !== "'"
 }
 
 /** Letter directly before (no boundary) and letter after (one boundary transparent). */
@@ -588,7 +602,7 @@ function classifySingles(items: Item[], style: ActiveQuoteStyle): void {
 // ---------------------------------------------------------------------------
 
 /** Empty (`""`) and whitespace-only (`" "`) double-quote pairs (no boundaries allowed anywhere in or around the match). */
-function classifyEmptyDoublePairs(items: Item[]): void {
+function classifyEmptyDoublePairs(items: Item[], style: ActiveQuoteStyle): void {
   const beforeOk = (index: number): boolean => {
     if (index < 0) return true
     const item = items[index]
@@ -597,7 +611,7 @@ function classifyEmptyDoublePairs(items: Item[]): void {
   const afterOk = (index: number): boolean => {
     if (index >= items.length) return true
     const item = items[index]
-    return !item.boundary && (SPACE_RE.test(item.ch) || DOUBLE_EMPTY_AFTER_SET.has(item.ch))
+    return !item.boundary && (SPACE_RE.test(item.ch) || DOUBLE_EMPTY_AFTER_SET.has(item.ch) || apostropheEndsDouble(item.ch, style))
   }
   for (let i = 0; i < items.length - 1; i++) {
     if (!isCharItem(items, i, '"') || !isCharItem(items, i + 1, '"')) continue
@@ -839,6 +853,16 @@ function isDoubleCloseAfterChar(ch: string): boolean {
   return SPACE_RE.test(ch) || DOUBLE_CLOSE_AFTER_SET.has(ch)
 }
 
+/**
+ * An apostrophe directly after a double quote ends it, as the closing single
+ * quote it renders as does. German is the exception: it re-derives the
+ * rendered apostrophe (U+2019) by position, so a re-run can read it as a
+ * closing single quote that the first pass, which saw an apostrophe, did not.
+ */
+function apostropheEndsDouble(ch: string, style: ActiveQuoteStyle): boolean {
+  return ch === MODIFIER_LETTER_APOSTROPHE && style !== "german"
+}
+
 /**
  * Closing double quote by ending context: a non-space/non-paren character (or
  * a boundary) before it, and an ending character, a boundary, or end of input
@@ -861,7 +885,7 @@ function classifyClosingDoubles(items: Item[], style: ActiveQuoteStyle): void {
     }
     const next = items[i + 1]
     if (foldsToNotEqual(items, i + 1)) continue
-    if (next === undefined || next.boundary || isDoubleCloseAfterChar(next.ch)) {
+    if (next === undefined || next.boundary || isDoubleCloseAfterChar(next.ch) || apostropheEndsDouble(next.ch, style)) {
       item.ch = RIGHT_DOUBLE_QUOTE
     }
   }
@@ -889,8 +913,31 @@ function classifySinglesBeforeClosingDoubles(items: Item[]): void {
   }
 }
 
+/**
+ * German reads its rendered glyphs by depth: a U+201C below an open „ closes
+ * it. A curly orphan that kept its source glyph (see {@link Item.curlySource})
+ * below a quote opened in this same pass is therefore that quote's closer on
+ * the next run; label it one now so both runs agree. Singles need no
+ * counterpart: a single opener is only recognized when a closer follows it
+ * with no straight single in between, and an orphan U+2018 is one.
+ */
+function closeCurlyOrphansBelowOpeners(items: Item[]): void {
+  let depth = 0
+  for (const item of items) {
+    if (item.boundary) continue
+    if (item.ch === LEFT_DOUBLE_QUOTE) {
+      depth++
+    } else if (item.ch === RIGHT_DOUBLE_QUOTE) {
+      if (depth > 0) depth--
+    } else if (item.ch === '"' && item.curlySource === LEFT_DOUBLE_QUOTE && depth > 0) {
+      item.ch = RIGHT_DOUBLE_QUOTE
+      depth--
+    }
+  }
+}
+
 function classifyDoubles(items: Item[], style: ActiveQuoteStyle): void {
-  classifyEmptyDoublePairs(items)
+  classifyEmptyDoublePairs(items, style)
   classifyOpeningDoubles(items, style)
   classifyQuotedPunctuationOpeners(items)
   classifyBraceOpeners(items)
@@ -987,11 +1034,11 @@ function applyRelocations(order: Item[], moves: Relocation[]): Item[] {
   return result
 }
 
-const OPEN_BRACKETS = new Set<string>(["(", "[", "{"])
-const CLOSE_BRACKETS = new Set<string>([")", "]", "}"])
+const OPEN_BRACKETS = new Set<string>(OPENING_BRACKETS)
+const CLOSE_BRACKETS = new Set<string>(CLOSING_BRACKETS)
 
 /**
- * Unmatched open brackets (`(`, `[`, `{`) strictly before each item — a
+ * Unmatched open brackets (see {@link OPENING_BRACKETS}) strictly before each item — a
  * position is inside a bracket pair when its entry is > 0. Brackets never move
  * during placement, so the depths hold across the fixpoint's rounds. Boundary
  * items are transparent; a closer with no opener above it floors the depth at 0.
@@ -1463,6 +1510,7 @@ function queueRenderEdits(view: ProseView, items: Item[], table: Record<QuoteRol
       }
       continue
     }
+    if (role === undefined && item.curlySource !== undefined) continue
     // Fast path for ordinary characters; pre-labeled items may have changed
     // `ch` without gaining a role (German orphan closers) and must still diff.
     if (role === undefined && item.ch === text[item.start] && item.end - item.start === 1) continue
@@ -1492,6 +1540,7 @@ export function classifyAndRenderQuotes(
   const items = buildItems(view, style)
   classifySingles(items, style)
   classifyDoubles(items, style)
+  if (style === "german") closeCurlyOrphansBelowOpeners(items)
   const placed = applyPunctuationPlacement(items, style, apostrophe)
   // Placement can slide a closer past punctuation until it sits directly after
   // an s/S (british/french move the closer left, out of "dogs.'" → "dogs'."),

package/src/rehype.ts

@@ -21,6 +21,7 @@ import {
   buildProseView,
   type ProsePass,
   type ProseView,
+  runAcrossOpaqueGaps,
   splitAtIndices,
 } from "./prose-view.js";
 
@@ -45,10 +46,12 @@ export interface ElementTransformOptions {
 export interface RehypePunctilioOptions
   extends TransformOptions, ElementTransformOptions {
   /**
-   * HTML tag names to skip when applying transformations.
-   * Content inside these elements won't have formatting improvements applied.
+   * Additional HTML tag names to skip when applying transformations, on top of
+   * the always-skipped defaults ("code", "pre", "script", "style", "kbd",
+   * "var", "samp", "template", "math", "svg", "iframe"). Content inside these
+   * elements won't have formatting improvements applied.
    *
-   * Default: ["code", "pre", "script", "style", "kbd", "var", "samp", "template", "math", "svg"]
+   * Default: []
    */
   skipTags?: string[];
 
@@ -73,7 +76,8 @@ export interface RehypePunctilioOptions
   transformAllElements?: boolean;
 }
 
-const DEFAULT_SKIP_TAGS = [
+/** Tag names whose content is always left untransformed; user `skipTags` extend this list. */
+export const DEFAULT_SKIP_TAGS: readonly string[] = [
   "code",
   "pre",
   "script",
@@ -84,6 +88,7 @@ const DEFAULT_SKIP_TAGS = [
   "template",
   "math",
   "svg",
+  "iframe",
 ];
 
 // Form elements whose text content is a literal control value, not prose.
@@ -99,7 +104,7 @@ const FORM_VALUE_TAGS = ["textarea", "input"];
 // Skipped in BOTH modes — the allowlist default does not reach it as its own
 // unit, but a transformable ancestor would otherwise pull its text into a
 // shared view and transform it.
-const RAW_TEXT_FORM_TAG = "textarea";
+export const RAW_TEXT_FORM_TAG = "textarea";
 
 // `<select>` is not prose itself, but its `<option>` children are (and are
 // transformed under the default allowlist). Under `transformAllElements` we
@@ -311,9 +316,10 @@ export interface ProseViewOfOptions extends ElementTransformOptions {
 /**
  * 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.
+ * predicates. Returns null when the element holds no transformable text. The
+ * view spans opaque gaps with only a boundary at each; the transform pipeline
+ * instead runs {@link runAcrossOpaqueGaps}, which holds each gap with a
+ * placeholder, and {@link proseViewsOf} gives one view per gap-free segment.
  */
 export function proseViewOf(
   element: Element,
@@ -588,8 +594,8 @@ function hasTextDescendant(
 
 export interface CollectProseBlocksOptions {
   /**
-   * HTML tag names to skip. Default: the plugin's default skip list
-   * ("code", "pre", "script", ...).
+   * HTML tag names to skip in addition to the plugin's default skip list
+   * ("code", "pre", "script", ...). Default: []
    */
   skipTags?: string[];
   /** CSS class names whose elements (and their subtrees) are skipped. Default: [] */
@@ -600,6 +606,16 @@ export interface CollectProseBlocksOptions {
   transformAllElements?: boolean;
 }
 
+// An `<option>` with no `value` attribute submits its text as the value, so
+// the text is a literal control value, not prose. HAST marks an absent
+// property as either `undefined` or `null`.
+function isValueOption(node: Element): boolean {
+  return (
+    node.tagName === "option" &&
+    (node.properties?.value === undefined || node.properties.value === null)
+  );
+}
+
 /** Skip predicate and transformable-tag test resolved from the options. */
 interface ResolvedCollectOptions {
   shouldSkip: ElementPredicate;
@@ -610,7 +626,7 @@ function resolveCollectOptions(
   options: CollectProseBlocksOptions,
 ): ResolvedCollectOptions {
   const {
-    skipTags = DEFAULT_SKIP_TAGS,
+    skipTags = [],
     skipClasses = [],
     shouldSkip,
     transformAllElements = false,
@@ -620,11 +636,11 @@ function resolveCollectOptions(
   // flattens its literal value; inverted mode additionally hard-skips the whole
   // form-value set (void `input`, which is opaque otherwise) on top of the user
   // skip-list.
-  const skipTagSet = new Set(
-    transformAllElements
-      ? [...skipTags, ...FORM_VALUE_TAGS]
-      : [...skipTags, RAW_TEXT_FORM_TAG],
-  );
+  const skipTagSet = new Set([
+    ...DEFAULT_SKIP_TAGS,
+    ...skipTags,
+    ...(transformAllElements ? FORM_VALUE_TAGS : [RAW_TEXT_FORM_TAG]),
+  ]);
   const skipClassSet = new Set(skipClasses);
 
   const hasSkipClass = (node: Element): boolean => {
@@ -641,6 +657,7 @@ function resolveCollectOptions(
   return {
     shouldSkip: (node) =>
       skipTagSet.has(node.tagName) ||
+      isValueOption(node) ||
       hasSkipClass(node) ||
       (shouldSkip?.(node) ?? false),
     // Inverted mode transforms every non-skipped element except non-prose
@@ -837,6 +854,17 @@ function runViewOf(
   return nodes.length === 0 ? null : buildProseView(nodes);
 }
 
+// Runs the full pipeline over flattened prose as one view, with each opaque gap
+// held by a placeholder so quotes pair across it (see `runAcrossOpaqueGaps`).
+function transformProse(
+  { nodes, opaqueBefore }: FlattenedProse,
+  transformOptions: TransformOptions,
+): void {
+  runAcrossOpaqueGaps(nodes, opaqueBefore, (view) =>
+    transformView(view, transformOptions),
+  );
+}
+
 function markDescendants(
   node: Element,
   set: Set<Element>,
@@ -874,14 +902,10 @@ function transformRootProse(
   let run: ElementContent[] = [];
   const flushRun = () => {
     if (runHasProse(run, shouldSkip)) {
-      const { nodes, opaqueBefore } = flattenRootRunProse(
-        run,
-        shouldSkip,
-        viewOptions,
+      transformProse(
+        flattenRootRunProse(run, shouldSkip, viewOptions),
+        transformOptions,
       );
-      for (const group of splitAtIndices(nodes, opaqueBefore)) {
-        transformView(buildProseView(group), transformOptions);
-      }
       for (const child of run) {
         if (child.type === "element") {
           transformed.add(child);
@@ -892,7 +916,8 @@ function transformRootProse(
     run = [];
   };
 
-  // Only bare text and inline prose elements merge into a run. Block elements
+  // Only bare text and inline elements merge into a run: prose elements, plus
+  // opaque ones (`<kbd>`, `<img>`) that quotes must pair across. Block elements
   // and non-transformable structural wrappers (`<html>`/`<head>`/`<body>` under
   // a full-document parse, or a non-allowlisted element in default mode) are
   // boundaries left to the element visitor, so their subtrees keep the same
@@ -904,7 +929,9 @@ function transformRootProse(
       child.type === "comment" ||
       (child.type === "element" &&
         !BLOCK_ELEMENTS.has(child.tagName) &&
-        isTransformable(child.tagName));
+        (isTransformable(child.tagName) ||
+          OPAQUE_VOID_TAGS.has(child.tagName) ||
+          shouldSkip(child)));
     if (isRunMember) {
       run.push(child);
     } else {
@@ -974,23 +1001,24 @@ export function rehypePunctilio(
       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);
-            }
+            transformProse(
+              flattenProse(unit.element, shouldSkip, viewOptions),
+              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,
+          transformProse(
+            flattenRunProse(
+              unit.container,
+              unit.children,
+              shouldSkip,
+              viewOptions,
+            ),
+            transformOptions,
           );
-          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);