punctilio 3.2.3 → 3.3.1

package/src/symbols.ts

@@ -293,43 +293,58 @@ export function primeMarks(text: string, options: SymbolOptions = {}): string {
   return text
 }
 
-const FRACTION_MAP: Record<string, string> = {
-  "1/4": UNICODE_SYMBOLS.FRACTION_1_4,
-  "1/2": UNICODE_SYMBOLS.FRACTION_1_2,
-  "3/4": UNICODE_SYMBOLS.FRACTION_3_4,
-  "1/3": UNICODE_SYMBOLS.FRACTION_1_3,
-  "2/3": UNICODE_SYMBOLS.FRACTION_2_3,
-  "1/5": UNICODE_SYMBOLS.FRACTION_1_5,
-  "2/5": UNICODE_SYMBOLS.FRACTION_2_5,
-  "3/5": UNICODE_SYMBOLS.FRACTION_3_5,
-  "4/5": UNICODE_SYMBOLS.FRACTION_4_5,
-  "1/6": UNICODE_SYMBOLS.FRACTION_1_6,
-  "5/6": UNICODE_SYMBOLS.FRACTION_5_6,
-  "1/8": UNICODE_SYMBOLS.FRACTION_1_8,
-  "3/8": UNICODE_SYMBOLS.FRACTION_3_8,
-  "5/8": UNICODE_SYMBOLS.FRACTION_5_8,
-  "7/8": UNICODE_SYMBOLS.FRACTION_7_8,
-}
+/**
+ * Supported Unicode fractions: [numerator, denominator, unicode character].
+ * The regex alternation and lookup map are both derived from this list.
+ */
+const FRACTION_TUPLES: [string, string, string][] = [
+  ["1", "4", UNICODE_SYMBOLS.FRACTION_1_4],
+  ["1", "2", UNICODE_SYMBOLS.FRACTION_1_2],
+  ["3", "4", UNICODE_SYMBOLS.FRACTION_3_4],
+  ["1", "3", UNICODE_SYMBOLS.FRACTION_1_3],
+  ["2", "3", UNICODE_SYMBOLS.FRACTION_2_3],
+  ["1", "5", UNICODE_SYMBOLS.FRACTION_1_5],
+  ["2", "5", UNICODE_SYMBOLS.FRACTION_2_5],
+  ["3", "5", UNICODE_SYMBOLS.FRACTION_3_5],
+  ["4", "5", UNICODE_SYMBOLS.FRACTION_4_5],
+  ["1", "6", UNICODE_SYMBOLS.FRACTION_1_6],
+  ["5", "6", UNICODE_SYMBOLS.FRACTION_5_6],
+  ["1", "8", UNICODE_SYMBOLS.FRACTION_1_8],
+  ["3", "8", UNICODE_SYMBOLS.FRACTION_3_8],
+  ["5", "8", UNICODE_SYMBOLS.FRACTION_5_8],
+  ["7", "8", UNICODE_SYMBOLS.FRACTION_7_8],
+]
 
-/** Convert 1/2, 1/4, etc. to ½, ¼, etc. */
+const FRACTION_MAP = Object.fromEntries(FRACTION_TUPLES.map(([n, d, u]) => [`${n}/${d}`, u]))
+
+/** Convert 1/2, 1/4, etc. to ½, ¼, etc. Single-pass using alternation. */
 export function fractions(text: string, options: SymbolOptions = {}): string {
   const chr = getEscapedSeparator(options)
 
-  for (const [ascii, unicode] of Object.entries(FRACTION_MAP)) {
-    // Negative lookbehind/lookahead: ensures fraction is not part of a larger number or path
-    // - (?<![/.\d]) prevents matching after slashes, dots, or digits
-    // - (?![/\d]|\.\d) prevents matching before slashes, digits, or decimal points
-    // Named captures preserve separators before and after the slash
-    const [numerator, denominator] = ascii.split("/")
-    const pattern = cachedRegExp(
-      `(?<![/\\.\\d])${numerator}(?<sepBefore>${chr}?)/(?<sepAfter>${chr}?)${denominator}(?![/\\d]|\\.\\d)`,
-      "g"
-    )
-    // Preserve separators around the fraction Unicode character
-    text = text.replace(pattern, `$<sepBefore>${unicode}$<sepAfter>`)
-  }
+  // Build alternation of exact valid pairs: `1${sep}?/${sep}?4|1${sep}?/${sep}?2|...`
+  // Only exact pairs from FRACTION_TUPLES match — no cross-product.
+  const pairAlternation = FRACTION_TUPLES.map(([n, d]) =>
+    `${n}${chr}?/${chr}?${d}`
+  ).join("|")
 
-  return text
+  // - (?<![/.\d]) prevents matching after slashes, dots, or digits
+  // - (?![/\d]|\.\d) prevents matching before slashes, digits, or decimal points
+  const pattern = cachedRegExp(
+    `(?<![/\\.\\d])(?:${pairAlternation})(?![/\\d]|\\.\\d)`,
+    "g"
+  )
+
+  const sepPattern = cachedRegExp(chr, "g")
+
+  return text.replace(pattern, (match) => {
+    // Split on separator to isolate the raw fraction and preserve markers.
+    // e.g. "1\uE000/\uE0002" → parts ["1", "/", "2"], separators ["\uE000", "\uE000"]
+    const parts = match.split(sepPattern)
+    const raw = parts.join("")
+    const separators = match.match(sepPattern) ?? []
+    // Distribute separators: first goes before the unicode char, second after
+    return `${separators[0] ?? ""}${FRACTION_MAP[raw]}${separators[1] ?? ""}`
+  })
 }
 
 const ORDINAL_MAP: Record<string, string> = {

package/src/tests/dashes.test.ts

@@ -1,5 +1,6 @@
 import { hyphenReplace, enDashNumberRange, enDashDateRange, minusReplace, numberRangeDisallowedPrefixes } from "../dashes.js"
 import { DEFAULT_SEPARATOR, UNICODE_SYMBOLS } from "../constants.js"
+import { assertLinearScaling } from "./test-helpers.js"
 
 const {
   LEFT_DOUBLE_QUOTE,
@@ -709,3 +710,13 @@ describe("hyphenReplace preserves multi-segment numbers across separators", () =
     expect(hyphenReplace(input, { separator: sep })).toBe(input)
   })
 })
+
+describe("dash stress tests", () => {
+  it("scales linearly for parenthetical dashes", () => {
+    assertLinearScaling(hyphenReplace, (n) => "word - word ".repeat(n))
+  })
+
+  it("scales linearly for number ranges", () => {
+    assertLinearScaling(hyphenReplace, (n) => "pages 1-2 ".repeat(n))
+  })
+})

package/src/tests/index.test.ts

@@ -1,6 +1,7 @@
 import { transform, DEFAULT_SEPARATOR, countSeparators } from "../index.js"
 import { ellipsis } from "../symbols.js"
-import { UNICODE_SYMBOLS, REGEX_SPECIAL_CHARS } from "../constants.js"
+import { UNICODE_SYMBOLS, REGEX_SPECIAL_CHARS, MAX_REGEX_CACHE_SIZE } from "../constants.js"
+import { assertLinearScaling, buildMixedContent } from "./test-helpers.js"
 
 const {
   LEFT_DOUBLE_QUOTE,
@@ -507,36 +508,16 @@ describe("transform", () => {
   })
 
   describe("regex performance", () => {
-    it("handles pathological quote patterns efficiently", () => {
-      const input = '"a"'.repeat(50) + "'"
-      const start = Date.now()
-      transform(input)
-      const duration = Date.now() - start
-      expect(duration).toBeLessThan(1000)
+    it("scales linearly for pathological quote patterns", () => {
+      assertLinearScaling(transform, (n) => '"a"'.repeat(n) + "'")
     })
 
-    it("handles pathological dash patterns efficiently", () => {
-      const input = "1-2-3-4-5-6-7-8-9-10-11-12-13-14-15"
-      const start = Date.now()
-      transform(input)
-      const duration = Date.now() - start
-      expect(duration).toBeLessThan(1000)
+    it("scales linearly for pathological dash patterns", () => {
+      assertLinearScaling(transform, (n) => "1" + "-1".repeat(n))
     })
 
-    it("handles 1000 unbalanced single quotes efficiently", () => {
-      const input = "'".repeat(1000) + "a"
-      const start = performance.now()
-      transform(input)
-      const duration = performance.now() - start
-      expect(duration).toBeLessThan(500)
-    })
-
-    it("handles 500 chained number patterns efficiently", () => {
-      const input = "1" + "-1".repeat(500)
-      const start = performance.now()
-      transform(input)
-      const duration = performance.now() - start
-      expect(duration).toBeLessThan(500)
+    it("scales linearly for unbalanced single quotes", () => {
+      assertLinearScaling(transform, (n) => "'".repeat(n) + "a")
     })
   })
 
@@ -626,28 +607,110 @@ describe("transform", () => {
   })
 
   describe("large input handling", () => {
-    it("handles 1MB of text", () => {
-      const input = "Hello, world! ".repeat(70000)
-      const start = performance.now()
-      transform(input)
-      expect(performance.now() - start).toBeLessThan(2000)
+    it("scales linearly on seeded mixed content", () => {
+      assertLinearScaling(transform, (n) => buildMixedContent(n * 100), 50)
+    })
+
+    it("scales linearly with all features enabled", () => {
+      const allFeatures = { fractions: true, degrees: true, superscript: true, ligatures: true }
+      assertLinearScaling((input) => transform(input, allFeatures), (n) => buildMixedContent(n * 100), 50)
     })
   })
 
-  describe("ReDoS resistance", () => {
-    const MAX_TIMEOUT_MS = 100
+  describe("idempotency across punctuation styles", () => {
+    const mixedInput = `"Hello," she said -- "it's pages 1-5." Wait... 5x5 != 25. He's 5'10" tall.`
 
     it.each([
-      ["10000 single quotes", "'".repeat(10000)],
-      ["10000 double quotes", '"'.repeat(10000)],
-      ["1000 unbalanced quotes", '"Hello '.repeat(1000)],
-      ["10000 hyphens", "-".repeat(10000)],
-      ["alternating digits/hyphens", "1-2-3-4-5-6-7-8-9-0".repeat(500)],
-      ["10000 dots", ".".repeat(10000)],
-    ] as const)("handles %s", (_, input) => {
+      ["american"],
+      ["british"],
+      ["german"],
+      ["french"],
+    ] as const)("idempotent with %s style", (style) => {
+      const opts = { punctuationStyle: style, checkIdempotency: false, nbsp: false } as const
+      const first = transform(mixedInput, opts)
+      const second = transform(first, opts)
+      expect(second).toBe(first)
+    })
+  })
+
+  describe("edge case inputs", () => {
+    it.each([
+      ["empty string", "", ""],
+      ["single space", " ", " "],
+      ["newlines only", "\n\n\n", "\n\n\n"],
+      ["tab only", "\t", "\t"],
+      ["nbsp only", NBSP, NBSP],
+    ])("handles %s", (_desc, input, expected) => {
+      expect(transform(input)).toBe(expected)
+    })
+  })
+
+  describe("separator collision", () => {
+    it("preserves default separator in plain transform", () => {
+      // transform() itself uses the separator internally but tolerates it in input
+      // The assertSeparatorAbsent check is in the rehype/remark plugins
+      const input = `text${DEFAULT_SEPARATOR}more`
+      const result = transform(input)
+      expect(countSeparators(result, DEFAULT_SEPARATOR)).toBe(1)
+    })
+
+    it("does not throw for single char of multi-char default separator", () => {
+      expect(() => transform(`text${DEFAULT_SEPARATOR[0]}more`)).not.toThrow()
+    })
+  })
+
+  describe("regex cache thrashing", () => {
+    it("produces correct results after exceeding cache capacity", () => {
+      const input = `"Hello," she said.`
+      const separatorCount = MAX_REGEX_CACHE_SIZE + 200
+      for (let i = 0; i < separatorCount; i++) {
+        const sep = String.fromCharCode(0xE100 + i)
+        const result = transform(input, { separator: sep, nbsp: false })
+        expect(result).toBe(`${LEFT_DOUBLE_QUOTE}Hello,${RIGHT_DOUBLE_QUOTE} she said.`)
+      }
+    })
+  })
+
+  describe("ReDoS resistance", () => {
+    it.each([
+      ["single quotes", (n: number) => "'".repeat(n)],
+      ["double quotes", (n: number) => '"'.repeat(n)],
+      ["unbalanced quotes", (n: number) => '"Hello '.repeat(n)],
+      ["hyphens", (n: number) => "-".repeat(n)],
+      ["alternating digits/hyphens", (n: number) => "1-2-3-4-5-6-7-8-9-0".repeat(n / 10)],
+      ["dots", (n: number) => ".".repeat(n)],
+      ["fraction-like patterns", (n: number) => "1/2 ".repeat(n)],
+      ["short words (nbsp)", (n: number) => "a b c d e f ".repeat(n)],
+      ["math symbol patterns", (n: number) => "!= ".repeat(n)],
+    ] as const)("scales linearly for %s", (_, buildInput) => {
+      assertLinearScaling(transform, buildInput)
+    })
+
+    it("scales linearly on seeded mixed content", () => {
+      assertLinearScaling(transform, (n) => buildMixedContent(n * 10))
+    })
+  })
+
+  describe("edge cases", () => {
+    it("handles empty string input", () => {
+      expect(transform("")).toBe("")
+      expect(transform("", { nbsp: false })).toBe("")
+    })
+
+    it("handles undefined option values", () => {
+      const input = '"Hello," she said.'
+      // `nbsp: undefined` overrides the default (true) via spread, so nbsp is skipped
+      const expected = transform(input, { nbsp: false })
+      expect(transform(input, { nbsp: undefined })).toBe(expected)
+    })
+
+    it("handles long string without transformable content", () => {
+      const input = "abcdefghij ".repeat(1000)
       const start = performance.now()
-      transform(input)
-      expect(performance.now() - start).toBeLessThan(MAX_TIMEOUT_MS)
+      const result = transform(input)
+      const elapsed = performance.now() - start
+      expect(result).toBe(input)
+      expect(elapsed).toBeLessThan(2000)
     })
   })
 })

package/src/tests/markdown.test.ts

@@ -1,6 +1,12 @@
+import { readFileSync } from "fs"
+import { resolve } from "path"
+import { fileURLToPath } from "url"
 import { transformMarkdown } from "../markdown.js"
+import { transform } from "../index.js"
 import { UNICODE_SYMBOLS } from "../constants.js"
 
+const __dirname = fileURLToPath(new URL(".", import.meta.url))
+
 const {
   LEFT_DOUBLE_QUOTE: LDQ,
   RIGHT_DOUBLE_QUOTE: RDQ,
@@ -75,4 +81,22 @@ describe("transformMarkdown", () => {
     })
     expect(result.trimEnd()).toEqual("See references \\[1\\]\\[4\\]\\[5\\]\\[6\\] for details.")
   })
+
+  it("README.md prose is already typographically correct", () => {
+    const readme = readFileSync(resolve(__dirname, "../../README.md"), "utf-8")
+    const lines = readme.split("\n")
+    let inCodeBlock = false
+
+    for (const line of lines) {
+      if (line.startsWith("```")) { inCodeBlock = !inCodeBlock; continue }
+      if (inCodeBlock) continue
+      // Skip non-prose: tables, badges, HTML, footnotes, headings, list items (including indented)
+      if (/^[|#>\d]|^\s*-\s|^\s*\d+\.\s|^\[[\^!]|<span/.test(line)) continue
+      if (line.trim() === "") continue
+
+      // collapseSpaces: false because Markdown uses double-space for formatting
+      const transformed = transform(line, { nbsp: false, collapseSpaces: false, checkIdempotency: false })
+      expect(transformed).toBe(line)
+    }
+  })
 })

package/src/tests/nbsp.test.ts

@@ -14,6 +14,7 @@ import {
   type NbspOptions,
 } from "../nbsp.js"
 import { UNICODE_SYMBOLS, DEFAULT_SEPARATOR } from "../constants.js"
+import { assertLinearScaling } from "./test-helpers.js"
 
 const { NBSP, COPYRIGHT, REGISTERED, TRADEMARK } = UNICODE_SYMBOLS
 const SEP = DEFAULT_SEPARATOR
@@ -252,4 +253,15 @@ describe("nbspTransform", () => {
       expect(nbspTransform("St. Anne had 5 kg")).toBe(`St.${NBSP}Anne had 5${NBSP}kg`)
     })
   })
+
+  describe("stress tests", () => {
+    it("scales linearly for short words", () => {
+      assertLinearScaling(nbspTransform, (n) => "a b c d e f ".repeat(n))
+    })
+
+    it("early-exits on text with no spaces", () => {
+      const result = nbspTransform("nospaces".repeat(1000))
+      expect(result).toBe("nospaces".repeat(1000))
+    })
+  })
 })

package/src/tests/quotes.test.ts

@@ -1,5 +1,6 @@
 import { niceQuotes, classifyApostrophes } from "../quotes.js"
 import { UNICODE_SYMBOLS, DEFAULT_SEPARATOR, TERMINAL_PUNCTUATION } from "../constants.js"
+import { assertLinearScaling } from "./test-helpers.js"
 
 const {
   LEFT_DOUBLE_QUOTE,
@@ -170,13 +171,13 @@ describe("niceQuotes", () => {
       expect(classifyApostrophes(result)).toBe(result)
     })
 
-    it("stress: 200 consecutive plural possessives", () => {
+    it("stress: 200 consecutive plural possessives scales linearly", () => {
       const words = ["dogs'", "cats'", "Bayes'", "Thomas'", "PLAYERS'"]
-      const input = Array.from({ length: 200 }, (_, i) => words[i % words.length]).join(" ")
-      const start = performance.now()
-      const result = classifyApostrophes(input)
-      expect(performance.now() - start).toBeLessThan(1000)
+      const buildInput = (n: number) => Array.from({ length: n }, (_, i) => words[i % words.length]).join(" ")
+
+      assertLinearScaling(classifyApostrophes, buildInput)
       // All should be MLA (no LSQ to pair with)
+      const result = classifyApostrophes(buildInput(200))
       expect(result).not.toContain(RIGHT_SINGLE_QUOTE)
       expect(result).not.toContain("'")
       expect(classifyApostrophes(result)).toBe(result)
@@ -701,20 +702,16 @@ describe("niceQuotes", () => {
   })
 
   describe("pathological inputs", () => {
-    it("handles 1500-char input without closing quote", () => {
+    it("scales linearly for input without closing quote", () => {
+      assertLinearScaling(classifyApostrophes, (n) => `'${"a".repeat(n)}`)
       const input = `'${"a".repeat(1500)}`
-      const start = performance.now()
-      const result = classifyApostrophes(input)
-      expect(performance.now() - start).toBeLessThan(1000)
-      expect(classifyApostrophes(result)).toBe(result)
+      expect(classifyApostrophes(classifyApostrophes(input))).toBe(classifyApostrophes(input))
     })
 
     it("handles 16 rapid apostrophes", () => {
       const input = "a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p"
       const expected = `a${MODIFIER_LETTER_APOSTROPHE}b${MODIFIER_LETTER_APOSTROPHE}c${MODIFIER_LETTER_APOSTROPHE}d${MODIFIER_LETTER_APOSTROPHE}e${MODIFIER_LETTER_APOSTROPHE}f${MODIFIER_LETTER_APOSTROPHE}g${MODIFIER_LETTER_APOSTROPHE}h${MODIFIER_LETTER_APOSTROPHE}i${MODIFIER_LETTER_APOSTROPHE}j${MODIFIER_LETTER_APOSTROPHE}k${MODIFIER_LETTER_APOSTROPHE}l${MODIFIER_LETTER_APOSTROPHE}m${MODIFIER_LETTER_APOSTROPHE}n${MODIFIER_LETTER_APOSTROPHE}o${MODIFIER_LETTER_APOSTROPHE}p`
-      const start = performance.now()
       const result = classifyApostrophes(input)
-      expect(performance.now() - start).toBeLessThan(1000)
       expect(result).toBe(expected)
       expect(classifyApostrophes(result)).toBe(result)
     })
@@ -725,4 +722,25 @@ describe("niceQuotes", () => {
     })
   })
 
+  describe("mixed-locale stress", () => {
+    it.each([
+      ["german", `Er sagte, "es ist gro\u00DFartig" und sie sagte, "h\u00F6r nicht auf"`, DOUBLE_LOW_9_QUOTE],
+      ["french", `"C'est magnifique," dit-elle. "N'arr\u00EAte pas."`, LEFT_GUILLEMET],
+      ["american", `He said, "She said, 'They said, "No."'"`, LEFT_DOUBLE_QUOTE],
+      ["british", `He said, "She said, 'They said, "No."'"`, LEFT_DOUBLE_QUOTE],
+      ["german", `Er fragte, "Hat sie 'Nein' gesagt?"`, DOUBLE_LOW_9_QUOTE],
+      ["french", `"Qui a dit 'bonjour'?" demanda-t-il.`, LEFT_GUILLEMET],
+    ] as const)("%s style produces locale-appropriate quotes and is idempotent", (style, input, expectedChar) => {
+      const opts = { punctuationStyle: style }
+      const first = niceQuotes(input, opts)
+      expect(first).toContain(expectedChar)
+      expect(niceQuotes(first, opts)).toBe(first)
+    })
+  })
+
+  describe("apostrophe regex scaling", () => {
+    it("scales linearly for repeated apostrophe patterns", () => {
+      assertLinearScaling(classifyApostrophes, (n) => "'a".repeat(n))
+    })
+  })
 })

package/src/tests/rehype.test.ts

@@ -414,14 +414,12 @@ describe("rehypePunctilio", () => {
 
     it("inserts nbsp when option enabled", async () => {
       const result = await processHtml('<p>Dr. Smith has 5 kg of items.</p>', { nbsp: true })
-      expect(result).toContain(`Dr.${NBSP}Smith`)
-      expect(result).toContain(`5${NBSP}kg`)
+      expect(result).toBe(`<p>Dr.${NBSP}Smith has 5${NBSP}kg${NBSP}of${NBSP}items.</p>`)
     })
 
     it("inserts nbsp by default", async () => {
       const result = await processHtml('<p>Dr. Smith has 5 kg of items.</p>')
-      expect(result).toContain(`Dr.${NBSP}Smith`)
-      expect(result).toContain(`5${NBSP}kg`)
+      expect(result).toBe(`<p>Dr.${NBSP}Smith has 5${NBSP}kg${NBSP}of${NBSP}items.</p>`)
     })
 
     it("does not insert nbsp when option disabled", async () => {
@@ -431,9 +429,7 @@ describe("rehypePunctilio", () => {
 
     it("works across element boundaries", async () => {
       const result = await processHtml('<p>See <em>Fig.</em> 1</p>', { nbsp: true })
-      expect(result).toContain(`Fig.`)
-      // The nbsp should appear between Fig. and 1
-      expect(result).toContain(NBSP)
+      expect(result).toBe(`<p>See <em>Fig.</em>${NBSP}1</p>`)
     })
   })
 
@@ -461,4 +457,55 @@ describe("rehypePunctilio", () => {
       )
     })
   })
+
+  describe("stress tests", () => {
+    it("handles many sibling paragraphs", async () => {
+      // 100 siblings: enough to exercise the visitor/transformed-set logic
+      // without spending seconds on HTML parsing
+      const count = 100
+      const html = '<div>' + '<p>"Hello," she said.</p>'.repeat(count) + '</div>'
+      const result = await processHtml(html, { nbsp: false })
+      const matchCount = (result.match(new RegExp(LDQ, "g")) ?? []).length
+      expect(matchCount).toBe(count)
+    })
+
+    it("handles paragraph with many inline elements", async () => {
+      const count = 100
+      const inlineElements = Array.from({ length: count }, (_, i) =>
+        `<em>"word${i}"</em>`
+      ).join(" ")
+      const html = `<p>${inlineElements}</p>`
+      const result = await processHtml(html, { nbsp: false })
+      const matchCount = (result.match(new RegExp(LDQ, "g")) ?? []).length
+      expect(matchCount).toBe(count)
+    })
+
+    it("transforms text at 100-level deep nesting", async () => {
+      let html = '"Hello"'
+      for (let i = 0; i < 100; i++) {
+        html = `<span>${html}</span>`
+      }
+      html = `<p>${html}</p>`
+      const result = await processHtml(html, { nbsp: false })
+      let expected = `${LDQ}Hello${RDQ}`
+      for (let i = 0; i < 100; i++) expected = `<span>${expected}</span>`
+      expected = `<p>${expected}</p>`
+      expect(result).toBe(expected)
+    })
+
+    it("does not crash beyond MAX_RECURSION_DEPTH", async () => {
+      let html = '"Hello"'
+      for (let i = 0; i < 1050; i++) {
+        html = `<span>${html}</span>`
+      }
+      html = `<p>${html}</p>`
+      // Should not throw — deep nesting is silently skipped
+      const result = await processHtml(html, { nbsp: false })
+      // Build expected: same structure with smart quotes applied
+      let expected = `${LDQ}Hello${RDQ}`
+      for (let i = 0; i < 1050; i++) expected = `<span>${expected}</span>`
+      expected = `<p>${expected}</p>`
+      expect(result).toBe(expected)
+    })
+  })
 })

package/src/tests/remark.test.ts

@@ -170,4 +170,31 @@ describe("remarkPunctilio", () => {
     const first = await processMarkdown('"Hello," she said -- "it\'s pages 1-5."', { nbsp: false })
     expect(await processMarkdown(first, { nbsp: false })).toEqual(first)
   })
+
+  describe("stress tests", () => {
+    it("handles many paragraphs", async () => {
+      const count = 100
+      const paragraphs = Array.from({ length: count }, () => '"Hello," she said.').join("\n\n")
+      const result = await processMarkdown(paragraphs, { nbsp: false })
+      const matchCount = (result.match(new RegExp(LDQ, "g")) ?? []).length
+      expect(matchCount).toBe(count)
+    })
+
+    it("handles paragraph with many inline elements", async () => {
+      const count = 50
+      const inlines = Array.from({ length: count }, (_, i) => `*"word${i}"*`).join(" ")
+      const result = await processMarkdown(inlines, { nbsp: false })
+      const matchCount = (result.match(new RegExp(LDQ, "g")) ?? []).length
+      expect(matchCount).toBe(count)
+    })
+
+    it("handles quotes spanning nested inline elements", async () => {
+      // Exercises text node flattening across multiple nesting levels:
+      // emphasis inside strong inside link text
+      const md = `[**"Hello,** *world"*](url)`
+      const result = await processMarkdown(md, { nbsp: false })
+      expect(result).toContain(LDQ)
+      expect(result).toContain(RDQ)
+    })
+  })
 })

package/src/tests/symbols.test.ts

@@ -13,6 +13,7 @@ import {
   symbolTransform,
 } from "../symbols.js"
 import { UNICODE_SYMBOLS, DEFAULT_SEPARATOR } from "../constants.js"
+import { assertLinearScaling } from "./test-helpers.js"
 
 describe("ellipsis", () => {
   it.each([
@@ -683,11 +684,9 @@ describe("symbolTransform", () => {
 })
 
 describe("multiplication ReDoS regression", () => {
-  it("handles 50k digits without quadratic slowdown", () => {
-    const start = performance.now()
-    multiplication("1".repeat(50_000))
-    // Before fix: ~4400ms (O(n²)). After fix: <50ms (O(n)).
-    expect(performance.now() - start).toBeLessThan(500)
+  it("scales linearly for long digit strings", () => {
+    // Before fix: quadratic (~100x for 10x input). After fix: linear.
+    assertLinearScaling(multiplication, (n) => "1".repeat(n), 5_000)
   })
 })
 
@@ -784,6 +783,8 @@ describe("fractions edge cases", () => {
     ["(1/2)", `(${UNICODE_SYMBOLS.FRACTION_1_2})`],
     ["5/7", "5/7"],
     ["11/12", "11/12"],
+    ["2/2", "2/2"],
+    ["4/3", "4/3"],
   ])('handles fraction edge: "%s"', (input, expected) => {
     expect(fractions(input)).toBe(expected)
   })
@@ -802,3 +803,21 @@ describe("chained multiplications", () => {
   })
 })
 
+describe("symbol stress tests", () => {
+  it("scales linearly for ellipsis patterns", () => {
+    assertLinearScaling(ellipsis, (n) => "wait... ".repeat(n))
+  })
+
+  it("scales linearly for fraction patterns", () => {
+    assertLinearScaling(fractions, (n) => "add 1/2 cup ".repeat(n))
+  })
+
+  it("completes 10000 consecutive single quotes in under 2 seconds", () => {
+    const input = "'".repeat(10000)
+    const start = performance.now()
+    symbolTransform(input)
+    const elapsed = performance.now() - start
+    expect(elapsed).toBeLessThan(2000)
+  })
+})
+