punctilio 5.4.8 → 5.4.10

package/src/nbsp.ts

@@ -1,5 +1,5 @@
 import { cachedRegExp, LATIN_LETTER_RE, LATIN_LETTERS, NBSP_CHARS, SPACE_CHAR_RE, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js"
-import { boundaryCountAt, exceedsSingleBoundary, interiorBoundariesWithin, makeProsePass, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
+import { advanceScanIndex, boundaryCountAt, exceedsSingleBoundary, interiorBoundariesWithin, makeProsePass, overInput, type ProseView, replaceAllInView } from "./prose-view.js"
 
 const {
   NBSP,
@@ -19,7 +19,8 @@ const UNICODE_UPPERCASE = "\\p{Lu}"
 // A word-forming character (any Unicode letter or number). Used for the
 // abbreviation-family word-start guard, which must span the same alphabets the
 // initial/honorific rules glue on (they key off `\p{Lu}`), so a non-Latin
-// acronym like "СССР." is guarded exactly as "NASA." is.
+// acronym like "СССР." is guarded exactly as "NASA." is, and for the last-word
+// rule's check that a word precedes the space.
 const WORD_CHAR_RE = /[\p{L}\p{N}]/u
 
 /** Only specific abbreviations are matched to avoid false positives. */
@@ -168,7 +169,10 @@ function nextWordGluesForward(text: string, start: number): boolean {
 // glued onward.
 export const nbspAfterShortWords = makeProsePass(nbspAfterShortWordsOverView)
 
-function nbspAfterShortWordsOverView(view: ProseView): void {
+// Returns the offsets of the spaces this pass turned into no-break spaces, so
+// the last-word rule can tell its own pipeline's glue from the author's.
+function nbspAfterShortWordsOverView(view: ProseView): ReadonlySet<number> {
+  const insertedGlue = new Set<number>()
   const pattern = cachedRegExp(
     `(?<=^|${SPACE}|${PUNCTUATION_OR_QUOTE}|>)(?<shortWord>[${LATIN_LETTERS}]{1,2})${SPACE}`,
     "gmu"
@@ -191,7 +195,9 @@ function nbspAfterShortWordsOverView(view: ProseView): void {
         if (nextWordGluesForward(clean, offset + match[0].length)) return null
         previousMatchEnd = offset + match[0].length
         // Edit only the space so any boundary keeps its side of the NBSP.
-        v.replace(offset + match[0].length - 1, offset + match[0].length, NBSP)
+        const spaceOffset = offset + match[0].length - 1
+        if (!NBSP_CHARS.includes(clean[spaceOffset])) insertedGlue.add(spaceOffset)
+        v.replace(spaceOffset, spaceOffset + 1, NBSP)
         return null
       },
       {
@@ -203,6 +209,7 @@ function nbspAfterShortWordsOverView(view: ProseView): void {
     )
   }
   view.commit()
+  return insertedGlue
 }
 
 export const nbspBetweenNumberAndUnit = makeProsePass(nbspBetweenNumberAndUnitOverView)
@@ -260,35 +267,14 @@ function precedingGlueNbsp(view: ProseView, spaceOffset: number): number {
   return j >= 0 && NBSP_CHARS.includes(text[j]) ? j : -1
 }
 
-/**
- * True when the word immediately before the NBSP at `nbspIndex` is a 1–2 letter
- * Latin word whose own left edge is a word boundary — an aesthetic short-word
- * glue that yields to last-word protection. Semantic glues (honorific `Dr.`,
- * abbreviation, unit `12`) carry a "."/digit/symbol right before the NBSP, so
- * the backward letter scan finds zero letters and returns false. The scan is
- * capped at three letters so it stays bounded on a long preceding word.
- */
-function isShortWordGlue(view: ProseView, nbspIndex: number): boolean {
-  const text = view.text
-  let k = nbspIndex - 1
-  let letters = 0
-  while (k >= 0 && letters <= 2 && !view.hasBoundary(k + 1) && LATIN_LETTER_RE.test(text[k])) {
-    k--
-    letters++
-  }
-  if (letters === 0 || letters > 2 || view.hasBoundary(k + 1)) return false
-  // The short word's left edge must be a real word boundary, matching
-  // nbspAfterShortWords' lookbehind — not another NBSP.
-  return !(k >= 0 && NBSP_CHARS.includes(text[k]))
-}
-
-// When the second-to-last word is already glued backwards, an aesthetic
-// short-word glue yields (reverts to a space) so the last word binds instead,
-// keeping the non-breaking run to two words; a semantic glue there blocks.
-export const nbspBeforeLastWord = makeProsePass(nbspBeforeLastWordOverView)
+// When the second-to-last word is already glued backwards, a short-word glue
+// that `nbspAfterShortWords` inserted yields (reverts to a space) so the last
+// word binds instead, keeping the non-breaking run to two words. Any other
+// glue there (a semantic glue, or a no-break space the author wrote) blocks.
+export const nbspBeforeLastWord = makeProsePass((view) => nbspBeforeLastWordOverView(view, new Set()))
 
-function nbspBeforeLastWordOverView(view: ProseView): void {
-  // The `(?<=\w|boundary)` lookbehind and the preceding-glue resolution are
+function nbspBeforeLastWordOverView(view: ProseView, insertedShortWordGlue: ReadonlySet<number>): void {
+  // The word-char-or-boundary lookbehind and the preceding-glue resolution are
   // enforced in the replacer, where boundaries are visible.
   const pattern = cachedRegExp(
     `${SPACE}(?<lastWord>(?:(?!\\s).){1,${MAX_LAST_WORD_LENGTH}})(?<ending>\\n\\n|$)`,
@@ -302,12 +288,12 @@ function nbspBeforeLastWordOverView(view: ProseView): void {
       (match, v) => {
         const start = match.index
         const end = start + match[0].length
-        // `(?<=\w|sep)`: a word char before the space, or a boundary there.
-        const precededByWord = start > 0 && /\w/.test(clean[start - 1])
+        // A word char before the space, or a boundary there.
+        const precededByWord = start > 0 && WORD_CHAR_RE.test(clean[start - 1])
         if (!precededByWord && !view.hasBoundary(start)) return null
         const glueNbsp = precedingGlueNbsp(v, start)
         if (glueNbsp >= 0) {
-          if (!isShortWordGlue(v, glueNbsp)) return null
+          if (!insertedShortWordGlue.has(glueNbsp)) return null
           // Revert the short word's glue so the last word binds in its place.
           v.replace(glueNbsp, glueNbsp + 1, " ")
         }
@@ -373,7 +359,7 @@ function nbspBeforeContext(
         !view.hasBoundary(start) &&
         WORD_CHAR_RE.test(clean[start - 1])
       ) {
-        pattern.lastIndex = start + 1
+        pattern.lastIndex = advanceScanIndex(clean, start, pattern)
         continue
       }
       // Slot between the `thing` literal and the space (offset = end - 1);
@@ -384,7 +370,7 @@ function nbspBeforeContext(
       if (!allowed) {
         // A boundary broke the (possibly longer) literal; let the scan re-anchor
         // one position later so a shorter sub-abbreviation can still match.
-        pattern.lastIndex = start + 1
+        pattern.lastIndex = advanceScanIndex(clean, start, pattern)
         continue
       }
       // Edit only the trailing space so the slot/lookahead boundaries keep their
@@ -425,7 +411,8 @@ export const nbspAfterCopyrightSymbols = makeProsePass(nbspAfterCopyrightSymbols
 
 export const nbspBetweenInitials = makeProsePass(nbspBetweenInitialsOverView)
 
-// Specific patterns first so they claim matches before generic nbspAfterShortWords.
+// Specific patterns first so they claim matches before the generic short-word
+// rule, which nbspTransform runs after them.
 const NBSP_TRANSFORMS: ((view: ProseView) => void)[] = [
   nbspAfterHonorificsOverView,
   nbspAfterReferenceAbbreviationsOverView,
@@ -433,8 +420,6 @@ const NBSP_TRANSFORMS: ((view: ProseView) => void)[] = [
   nbspAfterCopyrightSymbolsOverView,
   nbspBetweenInitialsOverView,
   nbspBetweenNumberAndUnitOverView,
-  nbspAfterShortWordsOverView,
-  nbspBeforeLastWordOverView,
 ]
 
 export function nbspTransform(input: string): string
@@ -448,5 +433,6 @@ export function nbspTransform(input: string | ProseView): string | void {
     for (const fn of NBSP_TRANSFORMS) {
       fn(view)
     }
+    nbspBeforeLastWordOverView(view, nbspAfterShortWordsOverView(view))
   })
 }

package/src/peer-dependencies.ts

@@ -0,0 +1,58 @@
+import type { HtmlOptions } from "./html.js"
+import type { MarkdownOptions } from "./markdown.js"
+
+export type SinkType = "md" | "html"
+
+/** Imports a bare package specifier; injectable so tests can simulate an uninstalled peer. */
+export type PeerImporter = (packageName: string) => Promise<unknown>
+
+export interface SinkTransformers {
+  md: (input: string, options: MarkdownOptions) => Promise<string>
+  html: (input: string, options: HtmlOptions) => Promise<string>
+}
+
+/** The optional peer dependencies each sink needs at runtime. */
+export const SINK_PEER_DEPENDENCIES: Readonly<Record<SinkType, readonly string[]>> = {
+  md: ["unified", "remark-parse", "remark-gfm", "remark-stringify"],
+  html: ["unified", "rehype-parse", "rehype-stringify"],
+}
+
+/** Thrown when an optional peer dependency needed for the requested file type is not installed. */
+export class MissingPeerDependencyError extends Error {}
+
+const MODULE_NOT_FOUND_CODES = new Set(["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"])
+
+function isMissingPackage(err: unknown, packageName: string): boolean {
+  const { code, message } = err as NodeJS.ErrnoException
+  return MODULE_NOT_FOUND_CODES.has(code ?? "") && message.includes(`'${packageName}'`)
+}
+
+const importPackage: PeerImporter = (packageName) => import(packageName)
+
+/**
+ * Lazily loads the transform for `type`, so only the peers for the file type
+ * being processed need to be installed.
+ * @throws MissingPeerDependencyError naming every absent peer and the install command.
+ */
+export async function loadSinkTransform<T extends SinkType>(
+  type: T,
+  importPeer: PeerImporter = importPackage,
+): Promise<SinkTransformers[T]> {
+  const missing: string[] = []
+  for (const packageName of SINK_PEER_DEPENDENCIES[type]) {
+    try {
+      await importPeer(packageName)
+    } catch (err) {
+      if (!isMissingPackage(err, packageName)) throw err
+      missing.push(packageName)
+    }
+  }
+  if (missing.length > 0) {
+    throw new MissingPeerDependencyError(
+      `Processing ${type === "md" ? "Markdown" : "HTML"} files requires ${missing.join(", ")}, which ` +
+      `${missing.length === 1 ? "is" : "are"} not installed. Install with: npm install ${missing.join(" ")}`,
+    )
+  }
+  if (type === "md") return (await import("./markdown.js")).transformMarkdown as SinkTransformers[T]
+  return (await import("./html.js")).transformHtml as SinkTransformers[T]
+}

package/src/prettier-plugin.ts

@@ -5,8 +5,7 @@ import type { Parser, Plugin } from "prettier"
 import type { Root } from "mdast"
 import { cosmiconfig } from "cosmiconfig"
 
-import { HTML_ONLY_OPTION_KEYS } from "./html.js"
-import { MARKDOWN_ONLY_OPTION_KEYS } from "./markdown.js"
+import { HTML_ONLY_OPTION_KEYS, MARKDOWN_ONLY_OPTION_KEYS } from "./sink-option-keys.js"
 import { remarkPunctilio, type RemarkPunctilioOptions } from "./remark.js"
 import { omitKeys } from "./utils.js"
 

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;
@@ -382,7 +393,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/symbols.ts

@@ -147,10 +147,14 @@ const DIGIT_SUFFIX = `(?:${PRIME_ALT}|${UNIT_ALT})?`
 // (1e5x3 — the `e` is a letter) and model SKUs (Surface5x3, RTX3060x2);
 // signed exponents (1e-5x3, 3.5E+10x2) are unambiguously scientific, their
 // operand is preceded by a sign, and they convert.
-const MULTIPLICATION_CHAIN = `(?<firstNum>\\d+${DIGIT_SUFFIX})(?<rest>(?:\\s*[xX*]\\s*\\d+${DIGIT_SUFFIX})+)`
-const MULTIPLICATION_SEGMENT = `(?<spaceBefore>\\s*)[xX*](?<spaceAfter>\\s*)(?<num>\\d+${DIGIT_SUFFIX})`
+//
+// Operator spacing is horizontal whitespace only: an operator across a line
+// break is a list marker (`Step 1\n* 2 cups`), not multiplication.
+const OPERATOR_SPACE = "[^\\S\\n\\v\\f\\r\\u2028\\u2029]*"
+const MULTIPLICATION_CHAIN = `(?<firstNum>\\d+${DIGIT_SUFFIX})(?<rest>(?:${OPERATOR_SPACE}[xX*]${OPERATOR_SPACE}\\d+${DIGIT_SUFFIX})+)`
+const MULTIPLICATION_SEGMENT = `(?<spaceBefore>${OPERATOR_SPACE})[xX*](?<spaceAfter>${OPERATOR_SPACE})(?<num>\\d+${DIGIT_SUFFIX})`
 
-/** A `\s*[xX*]\s*\d+suffix` segment located by absolute clean-text offsets. */
+/** An `OPERATOR_SPACE [xX*] OPERATOR_SPACE \d+suffix` segment located by absolute clean-text offsets. */
 interface ChainSegment {
   /** Absolute offset of the operator character. */
   operatorOffset: number
@@ -183,7 +187,7 @@ function chainSegments(chainStart: number, firstNum: string, rest: string): Chai
 }
 
 /**
- * Each operator's spacing slot (`\s*[xX*]\s*`) tolerates one node boundary at
+ * Each operator's spacing slot (`OPERATOR_SPACE [xX*] OPERATOR_SPACE`) tolerates one node boundary at
  * each outer edge and none inside the spacing; a second adjacent boundary at an
  * edge breaks the segment. The operator's slot is the span [slotStart, slotEnd)
  * covering its surrounding spaces and the operator itself.

package/src/transform-options.ts

@@ -35,8 +35,9 @@ export interface TransformOptions {
    *   (U+201E/U+201C double, U+201A/U+2018 single). Punctuation outside quotes.
    * - `"french"`: French style. Uses guillemets with NNBSP padding: «\u202F...\u202F»
    *   Single quotes remain as curly quotes. Punctuation outside quotes.
-   * - `"none"`: Skip all quote and punctuation transforms entirely.
-   *   Straight quotes, apostrophes, and prime marks are left unmodified.
+   * - `"none"`: Skip quote classification and prime conversion. Straight
+   *   quotes, apostrophes, and prime marks are left unmodified; a U+02BC
+   *   modifier-letter apostrophe is still normalized to U+2019.
    *
    * Default: "american"
    */
@@ -121,6 +122,14 @@ export type ResolvedTransformOptions = Required<TransformOptions>
 
 /** Validates `options` and fills in the defaults. */
 export function resolveTransformOptions(options: TransformOptions): ResolvedTransformOptions {
+  // JS callers outside the type system can pass null, a string, or an array;
+  // `Object.keys` would otherwise throw an opaque TypeError or enumerate a
+  // string's indices as unknown option names.
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError(
+      `transform options must be an object, got ${options === null ? "null" : Array.isArray(options) ? "an array" : typeof options}.`
+    )
+  }
   assertKnownOptionKeys(options, TRANSFORM_OPTION_KEYS, "transform")
 
   const punctuationStyle = options.punctuationStyle ?? "american"

package/src/utils.ts

@@ -41,6 +41,20 @@ export function assertKnownOptionKeys(
   }
 }
 
+const BYTE_ORDER_MARK = "\uFEFF"
+
+/**
+ * Runs `transform` on `input` without its leading BOM, which would otherwise
+ * be parsed as content, and restores the BOM on the result. @internal
+ */
+export async function transformPreservingBom(
+  input: string,
+  transform: (inputWithoutBom: string) => Promise<string>,
+): Promise<string> {
+  if (!input.startsWith(BYTE_ORDER_MARK)) return transform(input)
+  return BYTE_ORDER_MARK + (await transform(input.slice(BYTE_ORDER_MARK.length)))
+}
+
 /** Returns a copy of `obj` without the listed keys. @internal */
 export function omitKeys<T extends object>(obj: T, keys: readonly string[]): Partial<T> {
   const result: Record<string, unknown> = {}