punctilio 3.7.2 → 3.7.4

package/src/tests/index.test.ts

@@ -1,713 +0,0 @@
-import { transform, DEFAULT_SEPARATOR, countSeparators } from "../index.js"
-import { ellipsis } from "../symbols.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,
-  RIGHT_DOUBLE_QUOTE,
-  RIGHT_SINGLE_QUOTE,
-  EM_DASH,
-  EN_DASH,
-  ELLIPSIS,
-  MULTIPLICATION,
-  NOT_EQUAL,
-  PLUS_MINUS,
-  LESS_EQUAL,
-  GREATER_EQUAL,
-  COPYRIGHT,
-  NBSP,
-  PRIME,
-  DOUBLE_PRIME,
-  TRADEMARK,
-  REGISTERED,
-  DEGREE,
-  MINUS,
-  FRACTION_1_2,
-  SUPERSCRIPT_ST,
-} = UNICODE_SYMBOLS
-
-describe("transform", () => {
-  it("applies both quote and dash transformations", () => {
-    const input = '"Hello," she said - "it\'s pages 1-5."'
-    const expected = `${LEFT_DOUBLE_QUOTE}Hello,${RIGHT_DOUBLE_QUOTE} she said${EM_DASH}${LEFT_DOUBLE_QUOTE}it${RIGHT_SINGLE_QUOTE}s pages 1${EN_DASH}5.${RIGHT_DOUBLE_QUOTE}`
-    expect(transform(input, { nbsp: false })).toBe(expected)
-  })
-
-  it("handles complex mixed content", () => {
-    const input = 'I was born in \'99 - "the best year" - and pages 10-20 are my favorite.'
-    const expected = `I was born in ${RIGHT_SINGLE_QUOTE}99${EM_DASH}${LEFT_DOUBLE_QUOTE}the best year${RIGHT_DOUBLE_QUOTE}${EM_DASH}and pages 10${EN_DASH}20 are my favorite.`
-    expect(transform(input, { nbsp: false })).toBe(expected)
-  })
-
-  it("preserves separator character", () => {
-    const sep = DEFAULT_SEPARATOR
-    const input = `"Hello${sep}" - test`
-    expect(transform(input, { separator: sep, nbsp: false })).toBe(`${LEFT_DOUBLE_QUOTE}Hello${sep}${RIGHT_DOUBLE_QUOTE}${EM_DASH}test`)
-  })
-
-  describe("symbol transforms", () => {
-    it("applies symbol transforms by default", () => {
-      expect(transform('Wait... 5x5 != 25 (c) 2024', { nbsp: false })).toBe(`Wait${ELLIPSIS} 5${MULTIPLICATION}5 ${NOT_EQUAL} 25 ${COPYRIGHT} 2024`)
-    })
-
-    it("can disable symbol transforms", () => {
-      expect(transform('Wait... 5x5 != 25', { symbols: false, nbsp: false })).toBe('Wait... 5x5 != 25')
-    })
-  })
-
-  describe("optional transforms", () => {
-    it.each([
-      ["fractions disabled", "1/2", { nbsp: false }, "1/2"],
-      ["fractions enabled", "1/2", { fractions: true, nbsp: false }, UNICODE_SYMBOLS.FRACTION_1_2],
-      ["degrees disabled", "20 C", { nbsp: false }, "20 C"],
-      ["degrees enabled", "20 C", { degrees: true, nbsp: false }, `20 ${UNICODE_SYMBOLS.DEGREE}C`],
-      ["superscript disabled", "1st", { nbsp: false }, "1st"],
-      ["superscript enabled", "1st", { superscript: true, nbsp: false }, `1${UNICODE_SYMBOLS.SUPERSCRIPT_ST}`],
-      ["ligatures disabled", "??", { nbsp: false }, "??"],
-      ["ligatures enabled", "??", { ligatures: true, nbsp: false }, UNICODE_SYMBOLS.DOUBLE_QUESTION],
-      ["nbsp enabled (default)", "Dr. Smith", {}, `Dr.${NBSP}Smith`],
-      ["nbsp disabled", "Dr. Smith", { nbsp: false }, "Dr. Smith"],
-    ] as const)("%s: %s → %s", (_desc, input, options, expected) => {
-      expect(transform(input, options)).toBe(expected)
-    })
-  })
-
-  describe("punctuationStyle option", () => {
-    const periodOutside = `${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE}.`
-    const periodInside = `${LEFT_DOUBLE_QUOTE}Hello.${RIGHT_DOUBLE_QUOTE}`
-
-    it.each([
-      ['"Hello".', undefined, periodInside, "american (default)"],
-      ['"Hello."', "british", periodOutside, "british"],
-      ['"Hello".', "none", '"Hello".', "none (skips all quote transforms)"],
-    ] as const)("handles %s with %s style", (input, style, expected) => {
-      expect(transform(input, { ...(style ? { punctuationStyle: style } : {}), nbsp: false })).toBe(expected)
-    })
-
-    it("none skips prime marks too", () => {
-      expect(transform('5\'10"', { punctuationStyle: "none", nbsp: false })).toBe('5\'10"')
-    })
-
-    it("none skips all quote transforms while other transforms still apply", () => {
-      expect(transform('"Wait..." she said', { punctuationStyle: "none", nbsp: false })).toBe(`"Wait${ELLIPSIS}" she said`)
-    })
-  })
-
-  describe("german and french locale styles", () => {
-    it.each([
-      ['"Guten Tag"', `${UNICODE_SYMBOLS.DOUBLE_LOW_9_QUOTE}Guten Tag${LEFT_DOUBLE_QUOTE}`, { punctuationStyle: "german" as const, nbsp: false }],
-      ['"Bonjour"', `${UNICODE_SYMBOLS.LEFT_GUILLEMET}${UNICODE_SYMBOLS.NNBSP}Bonjour${UNICODE_SYMBOLS.NNBSP}${UNICODE_SYMBOLS.RIGHT_GUILLEMET}`, { punctuationStyle: "french" as const, nbsp: false }],
-      ["it's", `it${RIGHT_SINGLE_QUOTE}s`, { punctuationStyle: "german" as const, nbsp: false }],
-      ["l'homme", `l${RIGHT_SINGLE_QUOTE}homme`, { punctuationStyle: "french" as const, nbsp: false }],
-    ])('transforms "%s" with locale style', (input, expected, options) => {
-      expect(transform(input, options)).toBe(expected)
-    })
-
-    it("german style is idempotent", () => {
-      const input = '"Guten Tag"'
-      const first = transform(input, { punctuationStyle: "german", nbsp: false })
-      const second = transform(first, { punctuationStyle: "german", nbsp: false })
-      expect(second).toBe(first)
-    })
-
-    it("french style is idempotent", () => {
-      const input = '"Bonjour"'
-      const first = transform(input, { punctuationStyle: "french", nbsp: false })
-      const second = transform(first, { punctuationStyle: "french", nbsp: false })
-      expect(second).toBe(first)
-    })
-  })
-
-  describe("collapseSpaces option", () => {
-    it.each([
-      ["hello  world", "hello world", "multiple spaces"],
-      [`foo${NBSP}${NBSP}bar`, `foo${NBSP}bar`, "multiple nbsp"],
-      [`a ${NBSP}b`, `a${NBSP}b`, "mixed spaces prefer nbsp"],
-      [`a${NBSP} b`, `a${NBSP}b`, "mixed spaces prefer nbsp"],
-      ["hello\t\tworld", "hello world", "multiple tabs"],
-      ["hello\t world", "hello world", "mixed tab and space"],
-    ])("collapses %s by default", (input, expected) => {
-      expect(transform(input, { nbsp: false })).toBe(expected)
-    })
-
-    it.each([
-      ["hello  world", "hello  world", "multiple spaces"],
-      [`foo${NBSP}${NBSP}bar`, `foo${NBSP}${NBSP}bar`, "multiple nbsp"],
-      ["hello\t\tworld", "hello\t\tworld", "multiple tabs"],
-    ])("preserves %s when disabled", (input, expected) => {
-      expect(transform(input, { collapseSpaces: false, nbsp: false })).toBe(expected)
-    })
-  })
-
-  describe("nbsp option", () => {
-    it("inserts nbsp in typographically appropriate places", () => {
-      expect(transform("Dr. Smith wrote Fig. 1 on p. 42", { nbsp: true }))
-        .toBe(`Dr.${NBSP}Smith wrote Fig.${NBSP}1 on${NBSP}p.${NBSP}42`)
-    })
-
-    it("collapseSpaces cleans up after nbsp", () => {
-      expect(transform("Prof. Wilson arrived", { nbsp: true }))
-        .toBe(`Prof.${NBSP}Wilson${NBSP}arrived`)
-    })
-
-    it("is idempotent with nbsp enabled", () => {
-      const input = "Dr. Smith has 5 kg of items in § 3"
-      const first = transform(input, { nbsp: true })
-      const second = transform(first, { nbsp: true })
-      expect(second).toBe(first)
-    })
-
-    it("preserves separator count with nbsp enabled", () => {
-      const sep = DEFAULT_SEPARATOR
-      const input = `Dr.${sep} Smith has${sep} 5 kg`
-      expect(() => transform(input, { nbsp: true, separator: sep })).not.toThrow()
-    })
-  })
-
-  describe("separator preservation", () => {
-    it.each([
-      [`Wait.${DEFAULT_SEPARATOR}.${DEFAULT_SEPARATOR}. for it`, 2],
-      [`"Hello${DEFAULT_SEPARATOR}" - ${DEFAULT_SEPARATOR}she${DEFAULT_SEPARATOR} said`, 3],
-      [`.${DEFAULT_SEPARATOR}.${DEFAULT_SEPARATOR}.`, 2],
-    ])('preserves %i separators in "%s"', (input, expectedCount) => {
-      expect(() => transform(input, { separator: DEFAULT_SEPARATOR, nbsp: false })).not.toThrow()
-      expect(countSeparators(transform(input, { separator: DEFAULT_SEPARATOR, nbsp: false }), DEFAULT_SEPARATOR)).toBe(expectedCount)
-    })
-
-    it("preserves separator in ellipsis", () => {
-      const input = `.${DEFAULT_SEPARATOR}.${DEFAULT_SEPARATOR}.`
-      const result = ellipsis(input, { separator: DEFAULT_SEPARATOR })
-      expect(result.split(DEFAULT_SEPARATOR).length - 1).toBe(2)
-    })
-
-    it("preserves consecutive separators", () => {
-      const input = `a${DEFAULT_SEPARATOR}${DEFAULT_SEPARATOR}${DEFAULT_SEPARATOR}b`
-      expect(transform(input, { nbsp: false })).toBe(input)
-    })
-  })
-
-  describe("Unicode edge cases", () => {
-    it.each([
-      '"café"',
-      '"Hello 👋 world"',
-      '"日本語"',
-      '"שלום"',
-      "a\u200Bb",
-    ])('preserves content in "%s"', (input) => {
-      expect(transform(input, { nbsp: false })).toBe(transform(input, { nbsp: false })) // idempotent
-    })
-  })
-
-  // Tests derived from competitor libraries and benchmark cases
-  describe("competitor-derived comprehensive tests", () => {
-    // These tests document where punctilio excels over competitors
-    describe("punctilio advantages (benchmark cases)", () => {
-      it.each([
-        // Leading apostrophes - smartypants/tipograph fail these
-        ["'SUP", `${RIGHT_SINGLE_QUOTE}SUP`],
-        ["Rock 'n' Roll", `Rock ${RIGHT_SINGLE_QUOTE}n${RIGHT_SINGLE_QUOTE} Roll`],
-        ["I was born in '99", `I was born in ${RIGHT_SINGLE_QUOTE}99`],
-        // Em dashes from surrounded hyphens - smartquotes fails
-        ["This is a - hyphen.", `This is a${EM_DASH}hyphen.`],
-        // Number ranges - smartypants/smartquotes/typograf fail
-        ["Pages 1-5", `Pages 1${EN_DASH}5`],
-        ["2000-2020", `2000${EN_DASH}2020`],
-        // Date ranges - all competitors fail
-        ["January-March", `January${EN_DASH}March`],
-        // Minus signs - most competitors fail
-        ["-5", `${MINUS}5`],
-        ["(-5)", `(${MINUS}5)`],
-        // Prime marks - smartypants/typograf fail
-        ['5\'10"', `5${PRIME}10${DOUBLE_PRIME}`],
-        ['He is 6\'2" tall', `He is 6${PRIME}2${DOUBLE_PRIME} tall`],
-      ])('correctly transforms: "%s"', (input, expected) => {
-        expect(transform(input, { symbols: true, degrees: true, nbsp: false })).toBe(expected)
-      })
-    })
-
-    // Compound word preservation (all libraries should preserve these)
-    describe("compound word preservation", () => {
-      it.each([
-        "well-known",
-        "a browser- or OS-specific fashion",
-        "re-read",
-        "self-aware",
-        "high-quality",
-      ])('preserves compound word: "%s"', (input) => {
-        expect(transform(input, { nbsp: false })).toBe(input)
-      })
-    })
-
-    // Model name preservation (punctilio's unique strength)
-    describe("model name preservation", () => {
-      it.each([
-        "Llama-2-7B",
-        "Llama-3-8B-Instruct",
-        "GPT-4",
-        "Claude-3-Opus",
-        "Qwen1.5-1.8B",
-      ])('preserves model name: "%s"', (input) => {
-        expect(transform(input, { nbsp: false })).toBe(input)
-      })
-    })
-  })
-
-  describe("complex real-world text", () => {
-    it("handles dialogue with dashes and quotes", () => {
-      const input = '"Wait," she said -- "I don\'t think that\'s right."'
-      const expected = `${LEFT_DOUBLE_QUOTE}Wait,${RIGHT_DOUBLE_QUOTE} she said${EM_DASH}${LEFT_DOUBLE_QUOTE}I don${RIGHT_SINGLE_QUOTE}t think that${RIGHT_SINGLE_QUOTE}s right.${RIGHT_DOUBLE_QUOTE}`
-      expect(transform(input, { nbsp: false })).toEqual(expected)
-    })
-
-    it("handles technical documentation", () => {
-      const input = 'The API returns x != y when a <= b and c >= d. Error tolerance: +-5%.'
-      const expected = `The API returns x ${NOT_EQUAL} y when a ${LESS_EQUAL} b and c ${GREATER_EQUAL} d. Error tolerance: ${PLUS_MINUS}5%.`
-      expect(transform(input, { nbsp: false })).toBe(expected)
-    })
-
-
-    it("handles measurement text", () => {
-      const input = 'He is 6\'2" tall.'
-      const expected = `He is 6${PRIME}2${DOUBLE_PRIME} tall.`
-      expect(transform(input, { symbols: true, nbsp: false })).toEqual(expected)
-    })
-
-    it("handles copyright notices", () => {
-      const input = '(c) 2024 Company(tm). All rights reserved(r).'
-      const expected = `${COPYRIGHT} 2024 Company${TRADEMARK}. All rights reserved${REGISTERED}.`
-      expect(transform(input, { nbsp: false })).toEqual(expected)
-    })
-  })
-
-  describe("known limitations", () => {
-    // These document current behavior for edge cases
-    it("documents prime mark vs closing quote ambiguity", () => {
-      // When there's an open quote before a number, the quote after should close
-      // not become a prime mark
-      const input = '"Number 5"'
-      const result = transform(input, { nbsp: false })
-      // The 5" should be a closing quote, not a prime
-      expect(result).toBe(`${LEFT_DOUBLE_QUOTE}Number 5${RIGHT_DOUBLE_QUOTE}`)
-    })
-  })
-
-  describe("complex combined transformations", () => {
-    it.each([
-      [
-        '"Wait..." she said - "it\'s pages 1-5."',
-        `${LEFT_DOUBLE_QUOTE}Wait${ELLIPSIS}${RIGHT_DOUBLE_QUOTE} she said${EM_DASH}${LEFT_DOUBLE_QUOTE}it${RIGHT_SINGLE_QUOTE}s pages 1${EN_DASH}5.${RIGHT_DOUBLE_QUOTE}`,
-      ],
-      [
-        "(c) 2024 - Room is 10x12, set to 72 F",
-        `${COPYRIGHT} 2024${EM_DASH}Room is 10${MULTIPLICATION}12, set to 72 ${DEGREE}F`,
-      ],
-    ])('handles complex transform: "%s"', (input, expected) => {
-      expect(transform(input, { degrees: true, nbsp: false })).toBe(expected)
-    })
-  })
-
-  describe("empty and whitespace inputs", () => {
-    it.each([
-      ["", ""],
-      [" ", " "],
-      ["\n", "\n"],
-      ["\t", "\t"],
-      ["   ", " "],
-    ])('handles empty/whitespace: "%s"', (input, expected) => {
-      expect(transform(input, { nbsp: false })).toBe(expected)
-    })
-  })
-
-  describe("very long inputs", () => {
-    it("handles long repeated patterns", () => {
-      const input = '"Hello" '.repeat(100)
-      const expected = `${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE} `.repeat(100)
-      expect(transform(input, { nbsp: false })).toEqual(expected)
-    })
-
-    it("handles long continuous text", () => {
-      const input = "word ".repeat(1000)
-      const result = transform(input, { nbsp: false })
-      expect(result).toBe(input.trim() + " ")
-    })
-
-    it("converts ALL quote pairs in repeated pattern", () => {
-      const count = 50
-      const input = '"Hello" '.repeat(count)
-      const result = transform(input, { nbsp: false })
-      const leftCount = (result.match(new RegExp(LEFT_DOUBLE_QUOTE, "g")) || []).length
-      const rightCount = (result.match(new RegExp(RIGHT_DOUBLE_QUOTE, "g")) || []).length
-      expect(leftCount).toBe(count)
-      expect(rightCount).toBe(count)
-    })
-
-    it("converts ALL dashes in repeated pattern", () => {
-      const count = 50
-      const input = "pages 1-5 ".repeat(count)
-      const result = transform(input, { nbsp: false })
-      const enDashCount = (result.match(new RegExp(EN_DASH, "g")) || []).length
-      expect(enDashCount).toBe(count)
-    })
-
-    it("converts ALL ellipses in repeated pattern", () => {
-      const count = 50
-      const input = "Wait... ".repeat(count)
-      const result = transform(input, { nbsp: false })
-      const ellipsisCount = (result.match(new RegExp(ELLIPSIS, "g")) || []).length
-      expect(ellipsisCount).toBe(count)
-    })
-  })
-
-  describe("Unicode control characters", () => {
-    it.each([
-      ['"test\u200Bword"', `${LEFT_DOUBLE_QUOTE}test\u200Bword${RIGHT_DOUBLE_QUOTE}`],
-      ['"test\u200Fword"', `${LEFT_DOUBLE_QUOTE}test\u200Fword${RIGHT_DOUBLE_QUOTE}`],
-      ['"caf\u0065\u0301"', `${LEFT_DOUBLE_QUOTE}caf\u0065\u0301${RIGHT_DOUBLE_QUOTE}`],
-    ])('handles Unicode edge case', (input, expected) => {
-      expect(transform(input, { nbsp: false })).toBe(expected)
-    })
-  })
-
-  describe("option combinations", () => {
-    it("applies all optional transforms together", () => {
-      const input = "1st place: 1/2 at 72 F - wow!!"
-      const expected = `1${SUPERSCRIPT_ST} place: ${FRACTION_1_2} at 72 ${DEGREE}F${EM_DASH}wow!`
-      expect(transform(input, {
-        fractions: true,
-        degrees: true,
-        superscript: true,
-        ligatures: true,
-        nbsp: false,
-      })).toEqual(expected)
-    })
-
-    it("respects disabled transforms", () => {
-      const input = "1/2 at 72 F"
-      const expected = `${FRACTION_1_2} at 72 F`
-      expect(transform(input, {
-        fractions: true,
-        degrees: false,
-        nbsp: false,
-      })).toEqual(expected)
-    })
-  })
-
-  describe("separator robustness", () => {
-    const sep = DEFAULT_SEPARATOR
-
-    it.each([
-      [`${sep}"test"${sep}`, `${sep}${LEFT_DOUBLE_QUOTE}test${RIGHT_DOUBLE_QUOTE}${sep}`],
-      [`"test${sep}word"`, `${LEFT_DOUBLE_QUOTE}test${sep}word${RIGHT_DOUBLE_QUOTE}`],
-      [`${sep}${sep}"test"${sep}${sep}`, `${sep}${sep}${LEFT_DOUBLE_QUOTE}test${RIGHT_DOUBLE_QUOTE}${sep}${sep}`],
-    ])('handles separator in quotes', (input, expected) => {
-      expect(transform(input, { separator: sep, nbsp: false })).toBe(expected)
-    })
-
-    it.each([
-      [`word${sep} - ${sep}word`, `word${sep}${EM_DASH}${sep}word`],
-      [`1${sep}-${sep}5`, `1${sep}${EN_DASH}${sep}5`],
-    ])('handles separator in dashes', (input, expected) => {
-      expect(transform(input, { separator: sep, nbsp: false })).toBe(expected)
-    })
-
-    it("preserves exact separator count through transform", () => {
-      const input = `${sep}text${sep}more${sep}text${sep}`
-      const result = transform(input, { separator: sep, nbsp: false })
-      const inputCount = (input.match(new RegExp(sep, "g")) || []).length
-      const resultCount = (result.match(new RegExp(sep, "g")) || []).length
-      expect(resultCount).toBe(inputCount)
-    })
-
-    it("handles input containing separator character", () => {
-      const input = `Text with ${sep} in it`
-      expect(() => transform(input, { separator: sep, nbsp: false })).not.toThrow()
-    })
-
-    it("handles separator in fractions", () => {
-      const input = `1${sep}/2`
-      expect(transform(input, { separator: sep, fractions: true, nbsp: false })).toBe(`${sep}${FRACTION_1_2}`)
-    })
-
-    it("handles separator in degrees", () => {
-      const input = `72${sep} F`
-      expect(transform(input, { separator: sep, degrees: true, nbsp: false })).toBe(`72${sep} ${DEGREE}F`)
-    })
-  })
-
-  describe("additional idempotency", () => {
-    it.each([
-      '"Hello" - she said, "it\'s pages 1-5..."',
-      'Product(tm) 5x5 at 72 F (c) 2024',
-      "Add 1/2 cup - that's about 3/4 done",
-      '1st place winner said "congrats!!"',
-    ])('is idempotent: "%s"', (input) => {
-      const first = transform(input, { fractions: true, degrees: true, superscript: true, ligatures: true })
-      const second = transform(first, { fractions: true, degrees: true, superscript: true, ligatures: true })
-      expect(second).toBe(first)
-    })
-
-    it.each([
-      // Nested quotes with period — tests the multi-quote-jump fix
-      [`"She said, 'Hello.'"`, "british" as const],
-      [`"She said, 'Hello.'"`, "german" as const],
-      [`"She said, 'Hello.'"`, "french" as const],
-      // Leading apostrophe — tests the German RSQ normalization fix
-      [`'Twas the night before Christmas.`, "german" as const],
-    ])('is idempotent across styles: "%s" [%s]', (input, style) => {
-      const first = transform(input, { punctuationStyle: style })
-      const second = transform(first, { punctuationStyle: style })
-      expect(second).toBe(first)
-    })
-
-    it.each([
-      `${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE}`,
-      `word${EM_DASH}word`,
-      `1${EN_DASH}5`,
-      `Wait${ELLIPSIS}`,
-      `5${MULTIPLICATION}5`,
-      `20${NBSP}${DEGREE}C`,
-      `${COPYRIGHT}${NBSP}2024`,
-    ])('stable for: "%s"', (input) => {
-      expect(transform(input)).toBe(input)
-    })
-  })
-
-  describe("style combinations", () => {
-    it("applies American conventions throughout", () => {
-      const input = '"Hello." - word - "World."'
-      const expected = `${LEFT_DOUBLE_QUOTE}Hello.${RIGHT_DOUBLE_QUOTE}${EM_DASH}word${EM_DASH}${LEFT_DOUBLE_QUOTE}World.${RIGHT_DOUBLE_QUOTE}`
-      expect(transform(input, { punctuationStyle: "american", dashStyle: "american", nbsp: false })).toEqual(expected)
-    })
-
-    it("applies British conventions throughout", () => {
-      const input = '"Hello." - word - "World."'
-      const expected = `${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE}. ${EN_DASH} word ${EN_DASH} ${LEFT_DOUBLE_QUOTE}World${RIGHT_DOUBLE_QUOTE}.`
-      expect(transform(input, { punctuationStyle: "british", dashStyle: "british", nbsp: false })).toEqual(expected)
-    })
-
-    it("applies American punctuation with British dashes", () => {
-      const input = '"Hello." - word'
-      const expected = `${LEFT_DOUBLE_QUOTE}Hello.${RIGHT_DOUBLE_QUOTE} ${EN_DASH} word`
-      expect(transform(input, { punctuationStyle: "american", dashStyle: "british", nbsp: false })).toEqual(expected)
-    })
-
-    it("skips all dash transforms with dashStyle none", () => {
-      const input = '"Hello" - pages 1-5, -3'
-      const expected = `${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE} - pages 1-5, -3`
-      expect(transform(input, { dashStyle: "none", nbsp: false })).toEqual(expected)
-    })
-
-    it("skips everything with both set to none", () => {
-      const input = '"Hello" - pages 1-5'
-      expect(transform(input, { punctuationStyle: "none", dashStyle: "none", nbsp: false })).toBe(input)
-    })
-
-    it("skips quotes but applies dashes with mixed none", () => {
-      const input = '"Hello" - pages 1-5'
-      const expected = `"Hello"${EM_DASH}pages 1${EN_DASH}5`
-      expect(transform(input, { punctuationStyle: "none", dashStyle: "american", nbsp: false })).toEqual(expected)
-    })
-  })
-
-  describe("regex performance", () => {
-    it("scales linearly for pathological quote patterns", () => {
-      assertLinearScaling(transform, (n) => '"a"'.repeat(n) + "'")
-    })
-
-    it("scales linearly for pathological dash patterns", () => {
-      assertLinearScaling(transform, (n) => "1" + "-1".repeat(n))
-    })
-
-    it("scales linearly for unbalanced single quotes", () => {
-      assertLinearScaling(transform, (n) => "'".repeat(n) + "a")
-    })
-  })
-
-  describe("special regex characters in input", () => {
-    it.each([
-      ['"test [bracket]"', `${LEFT_DOUBLE_QUOTE}test [bracket]${RIGHT_DOUBLE_QUOTE}`],
-      ['"test (paren)"', `${LEFT_DOUBLE_QUOTE}test (paren)${RIGHT_DOUBLE_QUOTE}`],
-      ['"test {brace}"', `${LEFT_DOUBLE_QUOTE}test {brace}${RIGHT_DOUBLE_QUOTE}`],
-      ['"test $dollar"', `${LEFT_DOUBLE_QUOTE}test $dollar${RIGHT_DOUBLE_QUOTE}`],
-      ['"test ^caret"', `${LEFT_DOUBLE_QUOTE}test ^caret${RIGHT_DOUBLE_QUOTE}`],
-      ['"test .dot"', `${LEFT_DOUBLE_QUOTE}test .dot${RIGHT_DOUBLE_QUOTE}`],
-      ['"test |pipe"', `${LEFT_DOUBLE_QUOTE}test |pipe${RIGHT_DOUBLE_QUOTE}`],
-    ])('handles regex special chars: "%s"', (input, expected) => {
-      expect(transform(input, { nbsp: false })).toBe(expected)
-    })
-  })
-
-  describe("boundary conditions", () => {
-    it.each([
-      ['"start', `${LEFT_DOUBLE_QUOTE}start`],
-      ["'start", `${RIGHT_SINGLE_QUOTE}start`],
-      ["-5 start", `${MINUS}5 start`],
-      ["...start", `${ELLIPSIS} start`],
-      ['end"', `end${RIGHT_DOUBLE_QUOTE}`],
-      ["end'", `end${RIGHT_SINGLE_QUOTE}`],
-      ["end...", `end${ELLIPSIS}`],
-      ["5x", `5${MULTIPLICATION}`],
-    ])('handles boundary: "%s"', (input, expected) => {
-      expect(transform(input, { nbsp: false })).toBe(expected)
-    })
-  })
-
-  describe("separator validation", () => {
-    const invalidSeparators = [
-      ["🎉", "emoji (non-BMP)"],
-      ["", "empty string"],
-    ] as const
-
-    it.each(invalidSeparators)("rejects %s separator (%s)", (sep) => {
-      expect(() => transform('"Hello"', { separator: sep, nbsp: false })).toThrow(
-        /Invalid separator/
-      )
-    })
-
-    const validSeparators = ["\uE000\uE001", "\uE000", "|", "\u2603", "ab"] // Default, single PUA, pipe, snowman, multi-char
-
-    it.each(validSeparators)("accepts '%s' as separator", (sep) => {
-      expect(() => transform('"Hello"', { separator: sep, nbsp: false })).not.toThrow()
-    })
-  })
-
-  describe("regex-special separator characters", () => {
-    it.each(REGEX_SPECIAL_CHARS)("handles '%s' as separator", (sep) => {
-      expect(transform('"Hello"', { separator: sep, nbsp: false })).toEqual(
-        `${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE}`
-      )
-    })
-  })
-
-  describe("multi-character separator behavior", () => {
-    const sep = "\uE000\uE001"
-
-    it.each([
-      ["quotes with separator at boundary", `${sep}"Hello"`, `${sep}${LEFT_DOUBLE_QUOTE}Hello${RIGHT_DOUBLE_QUOTE}`],
-      ["em-dash with adjacent separators", `word${sep} - ${sep}word`, `word${sep}${EM_DASH}${sep}word`],
-      ["ellipsis with separator between dots", `a.${sep}.${sep}.`, `a\u2026${sep}${sep}`],
-      ["nbsp before last word with trailing separator", `Hello world${sep}`, `Hello${NBSP}world${sep}`],
-    ])("%s", (_desc, input, expected) => {
-      expect(transform(input, { separator: sep, nbsp: true })).toBe(expected)
-    })
-
-    it("preserves separator count through transform", () => {
-      const input = `${sep}"Hello"${sep} -- ${sep}world${sep}`
-      const result = transform(input, { separator: sep })
-      expect(countSeparators(result, sep)).toBe(countSeparators(input, sep))
-    })
-  })
-
-  describe("Unicode preservation", () => {
-    it.each([
-      ["emoji", '"Hello 👋 World"', `${LEFT_DOUBLE_QUOTE}Hello 👋 World${RIGHT_DOUBLE_QUOTE}`],
-      ["RTL text", '"שלום"', `${LEFT_DOUBLE_QUOTE}שלום${RIGHT_DOUBLE_QUOTE}`],
-      ["zero-width space", '"Hello\u200BWorld"', `${LEFT_DOUBLE_QUOTE}Hello\u200BWorld${RIGHT_DOUBLE_QUOTE}`],
-    ] as const)("preserves %s in input", (_, input, expected) => {
-      expect(transform(input, { nbsp: false })).toEqual(expected)
-    })
-  })
-
-  describe("large input handling", () => {
-    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("idempotency across punctuation styles", () => {
-    const mixedInput = `"Hello," she said -- "it's pages 1-5." Wait... 5x5 != 25. He's 5'10" tall.`
-
-    it.each([
-      ["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("treats undefined option values as absent (uses defaults)", () => {
-      const input = '"Hello," she said.'
-      const withDefault = transform(input)
-      expect(transform(input, { nbsp: undefined })).toBe(withDefault)
-    })
-
-    it("scales linearly for long non-transformable content", () => {
-      assertLinearScaling(transform, (n) => "abcdefghij ".repeat(n))
-    })
-  })
-})