@miliastry/quasar 1.0.0

package/src/Tests/FindNodeAtOffset.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest'
+import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
+
+/**
+ * `findNodeAtOffset` con rangos semiabiertos.
+ *
+ * Regresión concreta: en un degradado cada carácter es su propio nodo de
+ * color. Preguntar por el principio de un nodo devolvía el nodo ANTERIOR,
+ * porque con el final inclusivo ese offset pertenecía a los dos y ganaba el
+ * primero en el recorrido. En el preview, hacer clic en la `m` de «Welcome»
+ * resaltaba la `o`.
+ */
+describe('findNodeAtOffset — fronteras', () => {
+  const gradiente = '[color=#111111]W[/color][color=#222222]e[/color][color=#333333]l[/color]'
+
+  it('el principio de un nodo devuelve ESE nodo, no el anterior', () => {
+    const model = new BBCodeDocumentModel({ source: gradiente })
+    const raiz = model.redRoot!
+
+    // Los tres nodos de color, en orden.
+    const colores: typeof raiz[] = []
+    raiz.walk(n => { if (n.kind === 'color') colores.push(n) })
+    expect(colores).toHaveLength(3)
+
+    for (const nodo of colores) {
+      const encontrado = model.redRoot!.findNodeAtOffset(nodo.range.start)
+      // El nodo encontrado debe ser el propio o un descendiente suyo, nunca
+      // el vecino de la izquierda.
+      let actual = encontrado
+      let esDescendiente = false
+      while (actual) {
+        if (actual === nodo) { esDescendiente = true; break }
+        actual = actual.parent
+      }
+      expect(esDescendiente, `offset ${nodo.range.start} cayó fuera de su nodo`).toBe(true)
+    }
+  })
+
+  it('cada carácter del texto resuelve a su propio nodo de color', () => {
+    const model = new BBCodeDocumentModel({ source: gradiente })
+    // Offsets de las letras W, e, l dentro de sus etiquetas.
+    for (const letra of ['W', 'e', 'l']) {
+      const offset = gradiente.indexOf(`]${letra}[`) + 1
+      const nodo = model.redRoot!.findNodeAtOffset(offset)
+      expect(nodo, `letra ${letra}`).toBeTruthy()
+      expect(nodo!.text || nodo!.parent?.text).toBeDefined()
+      // El texto alcanzable desde el nodo debe ser esa letra.
+      let texto = ''
+      nodo!.walk(n => { if (n.kind === 'text') texto += n.text })
+      expect(texto || nodo!.text, `letra ${letra}`).toBe(letra)
+    }
+  })
+
+  it('el final del documento devuelve la raíz en vez de null', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola' })
+    const raiz = model.redRoot!
+    expect(model.redRoot!.findNodeAtOffset(raiz.range.end)).toBe(raiz)
+  })
+
+  it('un offset fuera del documento sigue siendo null', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola' })
+    expect(model.redRoot!.findNodeAtOffset(999)).toBeNull()
+    expect(model.redRoot!.findNodeAtOffset(-1)).toBeNull()
+  })
+})

package/src/Tests/Fuzzer.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest'
+import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
+import { BBCodeExporter } from '../Visitors/BBCodeExporter'
+import { ASTOptimizer } from '../Transformers/ASTOptimizer'
+import { TagRegistry } from '../Model/TagRegistry'
+import { RedNode } from '../Syntax/RedNode'
+
+// ─── 0. Deterministic PRNG ────────────────────────────────────
+//
+// This suite used bare `Math.random()`. It failed roughly 50% of runs, and
+// when it failed the payload that broke the optimizer was gone — nothing to
+// reproduce, nothing to regression-test. A fuzzer you cannot replay is not a
+// fuzzer, it is a coin flip attached to your CI.
+//
+// The seed is fixed by default and overridable, so a failure is always
+// reproducible: QUASAR_FUZZ_SEED=123456 npm test
+
+const FUZZ_SEED = Number(process.env.QUASAR_FUZZ_SEED ?? 0x5EED_1A57)
+
+/** mulberry32 — small, fast, good enough distribution for structural fuzzing. */
+function mulberry32(seed: number): () => number {
+  let a = seed >>> 0
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0
+    let t = a
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+// ─── 1. Fuzzing Generator ─────────────────────────────────────
+class BBCodeFuzzer {
+  private random: () => number
+
+  constructor(seed: number = FUZZ_SEED) {
+    this.random = mulberry32(seed)
+  }
+
+  private tags = [
+    { open: '[b]', close: '[/b]' },
+    { open: '[i]', close: '[/i]' },
+    { open: '[color=red]', close: '[/color]' },
+    { open: '[color=blue]', close: '[/color]' },
+    { open: '[size=50]', close: '[/size]' },
+    { open: '[size=20]', close: '[/size]' },
+    { open: '[url=https://osu.ppy.sh]', close: '[/url]' },
+    { open: '[notice]', close: '[/notice]' }
+  ]
+  private words = ['osu!', 'peppy', 'click', 'circles', 'to', 'the', 'beat', 'combo', 'FC', 'SS']
+  
+  private randomInt(max: number) {
+    return Math.floor(this.random() * max)
+  }
+  
+  private randomWord() {
+    return this.words[this.randomInt(this.words.length)]
+  }
+  
+  private randomSpace() {
+    const spaces = [' ', '  ', '\n', '\n\n']
+    return spaces[this.randomInt(spaces.length)]
+  }
+
+  // Generates a random AST structure as BBCode string
+  generate(depth: number = 0, length: number = 5): string {
+    if (depth > 4) return this.randomWord()
+    
+    let result = ''
+    for (let i = 0; i < length; i++) {
+      const choice = this.randomInt(10)
+      
+      if (choice < 3) {
+        // Plain text
+        result += this.randomWord() + this.randomSpace()
+      } else if (choice < 6) {
+        // Tag pair (validly nested)
+        const tag = this.tags[this.randomInt(this.tags.length)]
+        result += `${tag.open}${this.generate(depth + 1, 2)}${tag.close}`
+      } else if (choice < 8) {
+        // Empty tag
+        const tag = this.tags[this.randomInt(this.tags.length)]
+        result += `${tag.open}${tag.close}`
+      } else if (choice === 8) {
+        // Orphan opening tag
+        const tag = this.tags[this.randomInt(this.tags.length)]
+        result += tag.open
+      } else {
+        // Orphan closing tag
+        const tag = this.tags[this.randomInt(this.tags.length)]
+        result += tag.close
+      }
+    }
+    
+    return result
+  }
+}
+
+// ─── 2. Validation Helpers ────────────────────────────────────
+
+function getPlainText(node: RedNode): string {
+  if (node.kind === 'text') return node.text || ''
+  if (node.kind === 'spacing') return node.text || ''
+  if (node.kind === 'empty_line') return '\n\n'
+  return node.children.map(c => getPlainText(c)).join('')
+}
+
+// ─── 3. The Test Suite ────────────────────────────────────────
+describe('Empirical Fuzz Testing - AST Optimizer', () => {
+  const fuzzer = new BBCodeFuzzer()
+  const registry = new TagRegistry()
+  
+  // Create 100 random BBCode payloads
+  const samples = Array.from({ length: 100 }, () => fuzzer.generate(0, 10))
+  
+  // Specific pathological edge cases we know about
+  samples.push(
+    '[b][b]Redundant[/b][/b]',
+    '[color=red][b]Inverted[/b][/color]',
+    '[size=50][size=20]Overridden[/size][/size]',
+    '[b]Merge[/b] [b]Me[/b]',
+    '[b][color=red]A[/color][/b] [b][color=red]B[/color][/b]',
+    '[color=red][b]A[/b][/color] [color=red][b]B[/b][/color]',
+    '[b]Spaces   [/b]',
+    '[[[[[not a tag]',
+    '[b][/i][/b]'
+  )
+
+  it.each(samples.map((bbcode, i) => [i, bbcode]))('Fuzz Case %i', (_, source) => {
+    // 1. Parsing should not crash
+    const model = new BBCodeDocumentModel({ source, strictMode: false })
+    expect(model.redRoot).toBeDefined()
+
+    const originalText = getPlainText(model.redRoot!)
+    
+    // 2. Optimization should not crash
+    const optimizer = new ASTOptimizer()
+    optimizer.transform(model)
+    
+    // 3. Lossless Text: Optimization must NEVER delete or alter visible text/spacing
+    const optimizedText = getPlainText(model.redRoot!)
+    expect(optimizedText).toBe(originalText)
+    
+    // 4. Exporting should not crash
+    const exporter = new BBCodeExporter(registry)
+    const exported1 = exporter.export(model.redRoot!)
+    
+    // 5. Idempotence: optimizing an already optimized tree should produce no changes
+    const model2 = new BBCodeDocumentModel({ source: exported1, strictMode: false })
+    const optimizer2 = new ASTOptimizer()
+    const { transaction } = optimizer2.transform(model2)
+    
+    // An idempotent optimizer shouldn't need to mutate the tree a second time
+    // We allow 0 operations!
+    if (transaction && transaction.operations.length > 0) {
+      console.log('--- IDEMPOTENCE FAILURE ---')
+      console.log('Exported:', exported1)
+      console.log('Operations:', JSON.stringify(transaction.operations.map(o => o.kind)))
+    }
+    expect(transaction?.operations.length || 0).toBe(0)
+    
+    // 6. Round-trip stability
+    const exported2 = model2.redRoot ? exporter.export(model2.redRoot) : ''
+    expect(exported2).toBe(exported1)
+  })
+})

package/src/Tests/GreenNodePool.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Structural sharing (roadmap point 5 / S2).
+ *
+ * The interner used to be broken in a way no test could catch, because the
+ * tests only asserted that identical leaves came back as the same object —
+ * which they did. What they never checked was the thing that made it unusable:
+ * the shared node carried the FIRST occurrence's offsets, so switching it on
+ * made every position in the document lie.
+ *
+ * That failure is not expressible any more (green nodes have no positions),
+ * but the property it violated is what these tests assert: interning must be
+ * INVISIBLE. Same tree, same offsets, same output — just fewer objects.
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import { GreenNodePool, internGreenLeaf } from '../Syntax/GreenNodePool'
+import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
+import { parseBBCode } from '../BBCode/Parser'
+import { GreenNode } from '../Syntax/GreenNode'
+import { greenToRedNode } from '../BBCode/BBCodeToGreenNode'
+import { HTMLRenderer } from '../Visitors/HTMLRenderer'
+import { TagRegistry } from '../Model/TagRegistry'
+import type { RedNode } from '../Syntax/RedNode'
+
+const registry = new TagRegistry()
+const renderer = new HTMLRenderer({ registry })
+const stripIds = (h: string) => h.replace(/ data-node-id="[^"]*"/g, '')
+
+/** Structural equality that deliberately ignores object identity. */
+function sameShape(a: GreenNode, b: GreenNode): boolean {
+  if (a.kind !== b.kind || a.text !== b.text) return false
+  if (a.width !== b.width) return false
+  if (a.leadingWidth !== b.leadingWidth || a.trailingWidth !== b.trailingWidth) return false
+  if (a.children.length !== b.children.length) return false
+  for (let i = 0; i < a.children.length; i++) {
+    if (!sameShape(a.children[i] as GreenNode, b.children[i] as GreenNode)) return false
+  }
+  return true
+}
+
+function countObjects(root: GreenNode): { reachable: number; distinct: number } {
+  let reachable = 0
+  const seen = new Set<GreenNode>()
+  const stack: GreenNode[] = [root]
+  while (stack.length > 0) {
+    const n = stack.pop()!
+    reachable++
+    seen.add(n)
+    for (const c of n.children as GreenNode[]) stack.push(c)
+  }
+  return { reachable, distinct: seen.size }
+}
+
+function allRanges(root: RedNode): string[] {
+  const out: string[] = []
+  const visit = (n: RedNode): void => {
+    out.push(`${n.kind}[${n.range.start}..${n.range.end}]`)
+    for (const c of n.children) visit(c)
+  }
+  visit(root)
+  return out
+}
+
+describe('GreenNodePool — structural sharing', () => {
+  beforeEach(() => {
+    GreenNodePool.instance.clear()
+  })
+
+  it('returns the exact same object for identical leaves', () => {
+    const leaf1 = internGreenLeaf('text', 'Miliastry')
+    const leaf2 = internGreenLeaf('text', 'Miliastry')
+
+    expect(leaf1).toBe(leaf2)
+    expect(GreenNodePool.instance.stats.hits).toBe(1)
+    expect(GreenNodePool.instance.stats.misses).toBe(1)
+  })
+
+  it('creates distinct nodes for different text payloads', () => {
+    expect(internGreenLeaf('text', 'Hola')).not.toBe(internGreenLeaf('text', 'Mundo'))
+    expect(GreenNodePool.instance.stats.size).toBe(2)
+  })
+
+  it('keeps leaves of the same text but different width apart', () => {
+    // `spacing` carries no text but occupies 1 character for `\n` and 2 for
+    // `\r\n`. Keying on text alone would merge them and shorten the document.
+    const lf = internGreenLeaf('spacing', '', 1)
+    const crlf = internGreenLeaf('spacing', '', 2)
+
+    expect(lf).not.toBe(crlf)
+    expect(lf.width).toBe(1)
+    expect(crlf.width).toBe(2)
+  })
+
+  const SOURCES = [
+    '[b]x[/b][b]x[/b][b]x[/b]',
+    '[color=#e8b04b]A[/color][color=#e8b04b]B[/color][color=#e8b04b]A[/color]',
+    '[centre][b]hola[/b] mundo[/centre]\n\notro parrafo\n\n[/b]huerfano',
+    '[list][*]uno[*]dos[/list][quote]cita[/quote]',
+    'texto plano sin etiquetas',
+    '',
+  ]
+
+  for (const mode of ['leaves', 'full'] as const) {
+    describe(`mode '${mode}'`, () => {
+      for (const source of SOURCES) {
+        it(`is invisible for ${JSON.stringify(source.slice(0, 40))}`, () => {
+          const plain = parseBBCode(source)
+          const interned = parseBBCode(source, { interner: GreenNodePool.create(mode) })
+
+          // The tree must be structurally identical...
+          expect(sameShape(plain, interned)).toBe(true)
+          // ...the offsets the red tree derives must be identical...
+          expect(allRanges(greenToRedNode(interned))).toEqual(allRanges(greenToRedNode(plain)))
+          // ...and so must the rendered output.
+          expect(stripIds(renderer.render(greenToRedNode(interned))))
+            .toBe(stripIds(renderer.render(greenToRedNode(plain))))
+        })
+      }
+    })
+  }
+
+  it('actually shares objects on a repetitive document', () => {
+    const source = '[b]x[/b][b]x[/b][b]x[/b][b]x[/b]'
+
+    const plain = countObjects(parseBBCode(source))
+    const leaves = countObjects(parseBBCode(source, { interner: GreenNodePool.create('leaves') }))
+    const full = countObjects(parseBBCode(source, { interner: GreenNodePool.create('full') }))
+
+    expect(plain.distinct).toBe(plain.reachable)      // nothing shared
+    expect(leaves.distinct).toBeLessThan(plain.distinct)
+    expect(full.distinct).toBeLessThan(leaves.distinct) // internal nodes too
+  })
+
+  it('is off by default on the document model', () => {
+    // It is a memory/latency trade and this engine's budget is latency, so it
+    // must stay opt-in. See `BBCodeDocumentModelOptions.interning`.
+    const source = '[b]x[/b][b]x[/b]'
+    const plain = new BBCodeDocumentModel({ source, autoAnalyze: false })
+    const shared = new BBCodeDocumentModel({ source, autoAnalyze: false, interning: 'full' })
+
+    expect(countObjects(plain.greenRoot!).distinct).toBe(countObjects(plain.greenRoot!).reachable)
+    expect(countObjects(shared.greenRoot!).distinct)
+      .toBeLessThan(countObjects(shared.greenRoot!).reachable)
+    // Same offsets either way — that is the whole contract.
+    expect(allRanges(shared.redRoot!)).toEqual(allRanges(plain.redRoot!))
+  })
+
+  it('computes correct RedNode offsets even when green nodes are deduplicated', () => {
+    const source = 'Hola Mundo Hola'
+    const doc = new BBCodeDocumentModel({ source, interning: 'full' })
+
+    expect(doc.redRoot!.range).toEqual({ start: 0, end: source.length })
+  })
+})

package/src/Tests/Lexer.test.ts

@@ -0,0 +1,238 @@
+/**
+ * BBCodeLexer — decisions on malformed input.
+ *
+ * The lexer had no tests of its own, which is backwards: its whole job is to
+ * make a defensible decision about garbage, and an editor's buffer is garbage
+ * most of the time — half-typed tags, lone brackets, unclosed raw blocks. The
+ * happy path was covered incidentally by every other suite; the states that
+ * actually exercise it were covered by nothing.
+ *
+ * Two properties matter here beyond "it returns the right tokens":
+ *
+ *  - **Coverage.** Tokens must tile `[0..source.length)` with no gap and no
+ *    overlap. The parser builds the partition invariant (point 14) on top of
+ *    this, so a hole here becomes a hole in the tree.
+ *  - **Case folding.** Tag names are lower-cased, and the fast path skips the
+ *    allocation when there is nothing to fold. `[COLOR]` and `[color]` must
+ *    stay indistinguishable to everything downstream.
+ */
+import { describe, it, expect } from 'vitest'
+import { REFERENCE_DOCUMENT, REFERENCE_DOCUMENT_WITH_GRADIENT } from './referenceDocument'
+import { scanBBCode, type BBCodeToken } from '../Lexer/BBCodeLexer'
+
+/** Compact form of a token stream, for readable expectations. */
+const brief = (source: string): string[] =>
+  scanBBCode(source).map(t => {
+    switch (t.kind) {
+      case 'open': return `open:${t.tag}${t.attrs ? `(${t.attrs})` : ''}`
+      case 'close': return `close:${t.tag}`
+      case 'text': return `text:${JSON.stringify(t.value)}`
+      case 'newline': return `nl:${JSON.stringify(t.value)}`
+    }
+  })
+
+/** Tokens must tile the source exactly — no gaps, no overlaps, nothing dropped. */
+function coverageGap(source: string): string | null {
+  let expected = 0
+  for (const t of scanBBCode(source)) {
+    if (t.start !== expected) {
+      return `token en [${t.start}..${t.end}] pero se esperaba empezar en ${expected}`
+    }
+    expected = t.end
+  }
+  return expected === source.length
+    ? null
+    : `los tokens acaban en ${expected}, la fuente mide ${source.length}`
+}
+
+/** Every token's span must contain exactly the text it claims. */
+function textMismatch(source: string): string | null {
+  for (const t of scanBBCode(source) as BBCodeToken[]) {
+    if (t.kind === 'text' || t.kind === 'newline') {
+      const slice = source.slice(t.start, t.end)
+      if (slice !== t.value) {
+        return `[${t.start}..${t.end}] contiene ${JSON.stringify(slice)} pero el token dice ${JSON.stringify(t.value)}`
+      }
+    }
+  }
+  return null
+}
+
+describe('BBCodeLexer', () => {
+  describe('etiquetas válidas', () => {
+    it('abre y cierra', () => {
+      expect(brief('[b]x[/b]')).toEqual(['open:b', 'text:"x"', 'close:b'])
+    })
+
+    it('separa el nombre de los atributos', () => {
+      expect(brief('[color=#FF0000]x[/color]'))
+        .toEqual(['open:color(=#FF0000)', 'text:"x"', 'close:color'])
+    })
+
+    it('resuelve el `]` correcto con BBCode anidado en los atributos', () => {
+      expect(brief('[box=[b]t[/b]]c[/box]'))
+        .toEqual(['open:box(=[b]t[/b])', 'text:"c"', 'close:box'])
+    })
+
+    it('acepta `_` y `*` en el nombre', () => {
+      expect(brief('[*]')).toEqual(['open:*'])
+      expect(brief('[_custom]')).toEqual(['open:_custom'])
+    })
+  })
+
+  describe('normalización de mayúsculas', () => {
+    // El camino rápido evita `toLowerCase()` cuando no hay nada que plegar,
+    // así que hay que comprobar las dos ramas.
+    it('pliega el nombre pero NO los atributos', () => {
+      expect(brief('[COLOR=#E8B04B]x[/COLOR]'))
+        .toEqual(['open:color(=#E8B04B)', 'text:"x"', 'close:color'])
+    })
+
+    it('mayúsculas y minúsculas dan el mismo nombre', () => {
+      for (const [a, b] of [['[B]', '[b]'], ['[/B]', '[/b]'], ['[BoX=1]', '[box=1]']]) {
+        expect([a, brief(a)]).toEqual([a, brief(b).map(x => x)])
+      }
+    })
+
+    it('un nombre mixto se pliega entero', () => {
+      expect(brief('[SpOiLeRbOx]')).toEqual(['open:spoilerbox'])
+    })
+  })
+
+  describe('sintaxis inválida → texto literal', () => {
+    const cases: [string, string[]][] = [
+      ['[', ['text:"["']],
+      [']', ['text:"]"']],
+      ['[]', ['text:"["', 'text:"]"']],
+      ['[/]', ['text:"["', 'text:"/]"']],
+      ['[ ]', ['text:"["', 'text:" ]"']],
+      ['[=]', ['text:"["', 'text:"=]"']],
+      ['[/has space]', ['text:"["', 'text:"/has space]"']],
+      ['x[y', ['text:"x"', 'text:"["', 'text:"y"']],
+    ]
+    for (const [source, expected] of cases) {
+      it(JSON.stringify(source), () => {
+        expect(brief(source)).toEqual(expected)
+      })
+    }
+  })
+
+  describe('apertura y cierre NO son simétricos', () => {
+    // Esto sorprende y es deliberado, así que queda fijado aquí.
+    //
+    // En una APERTURA el nombre es la tirada inicial de caracteres válidos y
+    // todo lo demás pasa a ser atributos, por permisiva que quede la etiqueta.
+    // En un CIERRE el nombre debe llenar el hueco entero.
+    //
+    // No es inofensivo por accidente: el parser convierte las etiquetas que no
+    // conoce (`has`, `123`) en nodos `text`, así que el usuario ve lo que
+    // escribió. Por eso nadie lo había notado.
+    it('en apertura, lo que no es nombre se vuelve atributos', () => {
+      expect(brief('[has space]')).toEqual(['open:has(space)'])
+      expect(brief('[123+456]')).toEqual(['open:123(+456)'])
+    })
+
+    it('en cierre, el nombre debe llenar todo el hueco', () => {
+      expect(brief('[/has space]')).toEqual(['text:"["', 'text:"/has space]"'])
+      expect(brief('[/b x]')).toEqual(['text:"["', 'text:"/b x]"'])
+    })
+  })
+
+  describe('saltos de línea', () => {
+    it('emite \\r\\n como un solo token', () => {
+      expect(brief('a\r\nb')).toEqual(['text:"a"', 'nl:"\\r\\n"', 'text:"b"'])
+    })
+
+    it('emite \\n y \\r sueltos por separado', () => {
+      expect(brief('a\n\rb')).toEqual(['text:"a"', 'nl:"\\n"', 'nl:"\\r"', 'text:"b"'])
+    })
+  })
+
+  describe('bloques raw', () => {
+    it('el contenido de [code] es literal', () => {
+      expect(brief('[code]raw [b]x[/b][/code]'))
+        .toEqual(['open:code', 'text:"raw [b]x[/b]"', 'close:code'])
+    })
+
+    it('[c] se comporta igual', () => {
+      expect(brief('[c][i]y[/i][/c]')).toEqual(['open:c', 'text:"[i]y[/i]"', 'close:c'])
+    })
+
+    it('un [code] sin cerrar se traga el resto', () => {
+      expect(brief('[code]resto [b]x')).toEqual(['open:code', 'text:"resto [b]x"'])
+    })
+
+    it('encuentra el cierre aunque difiera en mayúsculas', () => {
+      // El source en minúsculas se calcula de forma perezosa; este es el único
+      // caso que lo necesita, y por eso importa que siga funcionando.
+      expect(brief('[code]x[/CODE]')).toEqual(['open:code', 'text:"x"', 'close:code'])
+    })
+
+    it('[code] vacío no emite token de texto', () => {
+      expect(brief('[code][/code]')).toEqual(['open:code', 'close:code'])
+    })
+  })
+
+  describe('los tokens cubren la fuente exactamente', () => {
+    // Was two untracked `.milia` files read from disk; they vanished and took
+    // seven tests with them. See `referenceDocument.ts`.
+    const fixtures = {
+      'reference document': REFERENCE_DOCUMENT,
+      'reference document with gradient': REFERENCE_DOCUMENT_WITH_GRADIENT,
+    }
+    for (const [name, source] of Object.entries(fixtures)) {
+      it(`fixture ${name}`, () => {
+        expect(coverageGap(source)).toBeNull()
+        expect(textMismatch(source)).toBeNull()
+      })
+    }
+
+    const cases = [
+      '', '[', ']', '[]', '[b]', '[/b]', '[b]x[/b]', '[[[[[[', ']]]]]]',
+      '[code]x', '[code]x[/code]', '[c]x', 'a\r\nb', '\r', '\n\n\n',
+      '[box=[b]t[/b]]c[/box]', '🎵[b]á€ñ[/b]🎵', '[has space]', '[/b x]',
+    ]
+    for (const source of cases) {
+      it(JSON.stringify(source), () => {
+        expect(coverageGap(source)).toBeNull()
+        expect(textMismatch(source)).toBeNull()
+      })
+    }
+  })
+
+  describe('fuzz con semilla', () => {
+    function mulberry32(seed: number): () => number {
+      let a = seed >>> 0
+      return () => {
+        a = (a + 0x6d2b79f5) >>> 0
+        let t = a
+        t = Math.imul(t ^ (t >>> 15), t | 1)
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+      }
+    }
+
+    const PIECES = [
+      '[b]', '[/b]', '[COLOR=#FF0000]', '[/COLOR]', '[size=50]', '[', ']', '[[',
+      ']]', '[/', '[]', '[/]', '[ ]', '[has space]', '[123+456]', '[_custom]',
+      '[*]', '[code]', '[/code]', '[c]', '[/c]', '[box=[b]t[/b]]', 'texto',
+      ' ', '\n', '\r\n', '🎵', 'á€ñ', '[b', 'b]', '[=]', '[b =x]',
+    ]
+
+    for (const seed of [1, 42, 1337, 0x5eed1a57]) {
+      it(`semilla ${seed}: 2000 documentos se cubren enteros`, () => {
+        const rnd = mulberry32(seed)
+        for (let i = 0; i < 2000; i++) {
+          const n = 1 + Math.floor(rnd() * 30)
+          let source = ''
+          for (let j = 0; j < n; j++) source += PIECES[Math.floor(rnd() * PIECES.length)]
+
+          const gap = coverageGap(source)
+          if (gap) throw new Error(`semilla ${seed} #${i}: ${gap}\n  src=${JSON.stringify(source)}`)
+          const mismatch = textMismatch(source)
+          if (mismatch) throw new Error(`semilla ${seed} #${i}: ${mismatch}\n  src=${JSON.stringify(source)}`)
+        }
+      })
+    }
+  })
+})