punctilio 1.4.1 → 1.7.0

package/src/tests/rehype.test.ts

@@ -64,6 +64,17 @@ describe("rehypePunctilio", () => {
     })
   })
 
+  describe("dashes across element boundaries", () => {
+    it.each([
+      ["multi-segment number preserved", "<p>1-<em>2</em>-3</p>", "<p>1-<em>2</em>-3</p>"],
+      ["model name preserved", "<p><em>GPT</em>-3</p>", "<p><em>GPT</em>-3</p>"],
+      ["simple range still converts", "<p>pages <em>1</em>-5</p>", `<p>pages <em>1</em>${EN_DASH}5</p>`],
+      ["genuine negative at element start", "<p><em>-5</em> degrees</p>", "<p><em>\u22125</em> degrees</p>"],
+    ])("%s", async (_name, html, expected) => {
+      expect(await processHtml(html)).toEqual(expected)
+    })
+  })
+
   describe("skipped elements", () => {
     it.each(["code", "pre", "script", "style", "kbd", "var", "samp"])(
       "skips %s elements",
@@ -388,6 +399,34 @@ describe("rehypePunctilio", () => {
         const tree = h("div", [h("img")]) as Element
         expect(collectTransformableElements(tree, ignoreNone)).toHaveLength(0)
       })
+
+      it("stops at max recursion depth", () => {
+        let deep: Element = h("p", "deep") as Element
+        for (let i = 0; i < 1100; i++) deep = h("div", [deep]) as Element
+        expect(collectTransformableElements(deep, ignoreNone)).toHaveLength(0)
+      })
+    })
+  })
+
+  describe("nbsp option", () => {
+    const NBSP = UNICODE_SYMBOLS.NBSP
+
+    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`)
+    })
+
+    it("does not insert nbsp when option disabled (default)", async () => {
+      const result = await processHtml('<p>Dr. Smith has 5 kg of items.</p>')
+      expect(result).not.toContain(NBSP)
+    })
+
+    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)
     })
   })
 

package/src/tests/symbols.test.ts

@@ -595,6 +595,15 @@ 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)
+  })
+})
+
 describe("multiplication edge cases", () => {
   it.each([
     ["1000000x2000000", `1000000${UNICODE_SYMBOLS.MULTIPLICATION}2000000`],

package/src/tests/utils.test.ts

@@ -59,9 +59,26 @@ describe("assertSeparatorCountPreserved", () => {
 })
 
 describe("formatErrorString", () => {
+  let originalWrite: typeof process.stderr.write
+  let stderrOutput: string[]
+
+  beforeEach(() => {
+    originalWrite = process.stderr.write
+    stderrOutput = []
+    process.stderr.write = ((chunk: string) => {
+      stderrOutput.push(chunk)
+      return true
+    }) as typeof process.stderr.write
+  })
+
+  afterEach(() => {
+    process.stderr.write = originalWrite
+  })
+
   it("returns JSON-stringified content for short strings", () => {
     const result = formatErrorString("short text", "test")
     expect(result).toBe('"short text"')
+    expect(stderrOutput).toHaveLength(0)
   })
 
   it("truncates strings over 2000 chars with label and length", () => {
@@ -77,52 +94,24 @@ describe("formatErrorString", () => {
     const longText = "a".repeat(1500) + "b".repeat(1000)
     const result = formatErrorString(longText, "mixed")
 
-    // Should contain all 1500 a's and first 500 b's (2000 total)
     const expected2000 = "a".repeat(1500) + "b".repeat(500)
     expect(result).toContain(JSON.stringify(expected2000))
     expect(result).toContain("2500 chars total")
   })
 
   it("writes full content to stderr in Node.js for long strings", () => {
-    const originalWrite = process.stderr.write
-    const written: string[] = []
-    process.stderr.write = ((chunk: string) => {
-      written.push(chunk)
-      return true
-    }) as typeof process.stderr.write
-
-    try {
-      const longText = "z".repeat(2001)
-      formatErrorString(longText, "stderr-test")
-
-      expect(written.length).toBe(1)
-      expect(written[0]).toContain("punctilio stderr-test full content")
-      expect(written[0]).toContain(longText)
-    } finally {
-      process.stderr.write = originalWrite
-    }
-  })
-
-  it("does not write to stderr for short strings", () => {
-    const originalWrite = process.stderr.write
-    const written: string[] = []
-    process.stderr.write = ((chunk: string) => {
-      written.push(chunk)
-      return true
-    }) as typeof process.stderr.write
+    const longText = "z".repeat(2001)
+    formatErrorString(longText, "stderr-test")
 
-    try {
-      formatErrorString("short", "test")
-      expect(written.length).toBe(0)
-    } finally {
-      process.stderr.write = originalWrite
-    }
+    expect(stderrOutput).toHaveLength(1)
+    expect(stderrOutput[0]).toContain("punctilio stderr-test full content")
+    expect(stderrOutput[0]).toContain(longText)
   })
 
   it("handles strings at exactly the threshold", () => {
     const exactText = "x".repeat(2000)
     const result = formatErrorString(exactText, "exact")
-    // At threshold, should return JSON-stringified (not truncated)
     expect(result).toBe(JSON.stringify(exactText))
+    expect(stderrOutput).toHaveLength(0)
   })
 })