@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/colorUtils.test.ts

@@ -1,112 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  isHex,
-  oklchLighten,
-  oklchDarken,
-  oklchSetChroma,
-  contrastRatio,
-  pickContrastingText,
-  deriveScale,
-  relativeLuminance,
-} from '../schemas/colorUtils.js';
-
-describe('isHex', () => {
-  it('accepts #rgb and #rrggbb', () => {
-    expect(isHex('#fff')).toBe(true);
-    expect(isHex('#123abc')).toBe(true);
-    expect(isHex('#FF0080')).toBe(true);
-  });
-  it('rejects malformed strings', () => {
-    expect(isHex('fff')).toBe(false);
-    expect(isHex('#1234')).toBe(false);
-    expect(isHex('#xyz')).toBe(false);
-    expect(isHex('rgb(0,0,0)')).toBe(false);
-  });
-});
-
-describe('oklchLighten / oklchDarken', () => {
-  it('lighten produces a lighter color (higher luminance)', () => {
-    const dark = '#101010';
-    const lighter = oklchLighten(dark, 0.2);
-    expect(relativeLuminance(lighter)).toBeGreaterThan(relativeLuminance(dark));
-  });
-
-  it('darken produces a darker color (lower luminance)', () => {
-    const light = '#e0e0e0';
-    const darker = oklchDarken(light, 0.2);
-    expect(relativeLuminance(darker)).toBeLessThan(relativeLuminance(light));
-  });
-
-  it('round-trips approximately stable for moderate adjustments', () => {
-    const seed = '#3182ce';
-    const round = oklchDarken(oklchLighten(seed, 0.1), 0.1);
-    // sRGB gamut clamping prevents perfect round-trip; expect within a small epsilon.
-    expect(round).toMatch(/^#[0-9a-f]{6}$/);
-    const lumDiff = Math.abs(relativeLuminance(seed) - relativeLuminance(round));
-    expect(lumDiff).toBeLessThan(0.05);
-  });
-
-  it('returns a hex string', () => {
-    expect(oklchLighten('#3182ce', 0.1)).toMatch(/^#[0-9a-f]{6}$/);
-    expect(oklchDarken('#3182ce', 0.1)).toMatch(/^#[0-9a-f]{6}$/);
-  });
-
-  it('falls back to input on parse failure', () => {
-    expect(oklchLighten('not-a-color', 0.1)).toBe('not-a-color');
-  });
-});
-
-describe('oklchSetChroma', () => {
-  it('reducing chroma toward 0 desaturates a color', () => {
-    const vivid = '#ff3366';
-    const muted = oklchSetChroma(vivid, 0.1);
-    // Muted version's R/G/B channels should be much closer to each other than vivid.
-    const parse = (h: string) => [
-      parseInt(h.slice(1, 3), 16),
-      parseInt(h.slice(3, 5), 16),
-      parseInt(h.slice(5, 7), 16),
-    ];
-    const [vr, vg, vb] = parse(vivid);
-    const [mr, mg, mb] = parse(muted);
-    const vSpread = Math.max(vr, vg, vb) - Math.min(vr, vg, vb);
-    const mSpread = Math.max(mr, mg, mb) - Math.min(mr, mg, mb);
-    expect(mSpread).toBeLessThan(vSpread);
-  });
-});
-
-describe('contrastRatio', () => {
-  it('white-on-black is the maximum (≈21)', () => {
-    expect(contrastRatio('#ffffff', '#000000')).toBeCloseTo(21, 0);
-  });
-  it('same-color is 1', () => {
-    expect(contrastRatio('#aabbcc', '#aabbcc')).toBeCloseTo(1, 5);
-  });
-  it('is symmetric', () => {
-    expect(contrastRatio('#222', '#ddd')).toBeCloseTo(contrastRatio('#ddd', '#222'), 5);
-  });
-});
-
-describe('pickContrastingText', () => {
-  it('returns dark text for light backgrounds', () => {
-    expect(pickContrastingText('#ffffff')).toBe('#1a202c');
-    expect(pickContrastingText('#f7fafc')).toBe('#1a202c');
-  });
-  it('returns light text for dark backgrounds', () => {
-    expect(pickContrastingText('#000000')).toBe('#f7fafc');
-    expect(pickContrastingText('#1a202c')).toBe('#f7fafc');
-  });
-  it('respects custom light/dark options', () => {
-    expect(pickContrastingText('#000000', '#fefefe', '#020202')).toBe('#fefefe');
-  });
-});
-
-describe('deriveScale', () => {
-  it('produces 5 stops with base in the middle', () => {
-    const scale = deriveScale('#3182ce', 0.15);
-    expect(scale.base).toBe('#3182ce');
-    expect(relativeLuminance(scale.lighter2)).toBeGreaterThan(relativeLuminance(scale.lighter1));
-    expect(relativeLuminance(scale.lighter1)).toBeGreaterThan(relativeLuminance(scale.base));
-    expect(relativeLuminance(scale.base)).toBeGreaterThan(relativeLuminance(scale.darker1));
-    expect(relativeLuminance(scale.darker1)).toBeGreaterThan(relativeLuminance(scale.darker2));
-  });
-});

package/src/__tests__/contentContainer.test.ts

@@ -1,325 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { MemoryContentContainer, findDocumentPath } from '../storage/ContentContainer';
-import { createMediaProviderFromContainer } from '../storage/MediaProviderFromContainer';
-import type { ContentEntry } from '../storage/ContentContainer';
-
-// ============================================
-// MemoryContentContainer
-// ============================================
-
-describe('MemoryContentContainer', () => {
-  let container: MemoryContentContainer;
-
-  beforeEach(() => {
-    container = new MemoryContentContainer();
-  });
-
-  it('readFile returns null for missing file', async () => {
-    expect(await container.readFile('missing.txt')).toBeNull();
-  });
-
-  it('writeFile and readFile round-trip', async () => {
-    const data = new TextEncoder().encode('hello world');
-    await container.writeFile('test.txt', data, 'text/plain');
-    const result = await container.readFile('test.txt');
-    expect(result).not.toBeNull();
-    expect(new TextDecoder().decode(result!)).toBe('hello world');
-  });
-
-  it('writeFile with ArrayBuffer', async () => {
-    const buf = new ArrayBuffer(4);
-    new Uint8Array(buf).set([1, 2, 3, 4]);
-    await container.writeFile('data.bin', buf);
-    const result = await container.readFile('data.bin');
-    expect(new Uint8Array(result!)).toEqual(new Uint8Array([1, 2, 3, 4]));
-  });
-
-  it('accepts ArrayBuffers created in another browser realm', async () => {
-    const iframe = document.createElement('iframe');
-    document.body.appendChild(iframe);
-    try {
-      const foreignWindow = iframe.contentWindow as unknown as {
-        ArrayBuffer: ArrayBufferConstructor;
-        Uint8Array: Uint8ArrayConstructor;
-      };
-      const data = new foreignWindow.ArrayBuffer(3);
-      new foreignWindow.Uint8Array(data).set([7, 8, 9]);
-      await container.writeFile('foreign.bin', data);
-      expect(new Uint8Array((await container.readFile('foreign.bin'))!)).toEqual(
-        new Uint8Array([7, 8, 9]),
-      );
-    } finally {
-      iframe.remove();
-    }
-  });
-
-  it('owns copies on both write and read', async () => {
-    const input = new ArrayBuffer(2);
-    new Uint8Array(input).set([1, 2]);
-    await container.writeFile('owned.bin', input);
-
-    new Uint8Array(input)[0] = 9;
-    const firstRead = (await container.readFile('owned.bin'))!;
-    expect(Array.from(new Uint8Array(firstRead))).toEqual([1, 2]);
-
-    new Uint8Array(firstRead)[1] = 9;
-    expect(Array.from(new Uint8Array((await container.readFile('owned.bin'))!))).toEqual([1, 2]);
-  });
-
-  it('writeFile overwrites existing file', async () => {
-    await container.writeFile('f.txt', new TextEncoder().encode('first'));
-    await container.writeFile('f.txt', new TextEncoder().encode('second'));
-    const result = await container.readFile('f.txt');
-    expect(new TextDecoder().decode(result!)).toBe('second');
-  });
-
-  it('removeFile deletes a file', async () => {
-    await container.writeFile('f.txt', new TextEncoder().encode('data'));
-    await container.removeFile('f.txt');
-    expect(await container.readFile('f.txt')).toBeNull();
-  });
-
-  it('removeFile is a no-op for missing file', async () => {
-    // Should not throw
-    await container.removeFile('nonexistent.txt');
-  });
-
-  it('exists returns true for existing file', async () => {
-    await container.writeFile('f.txt', new TextEncoder().encode('data'));
-    expect(await container.exists('f.txt')).toBe(true);
-  });
-
-  it('exists returns false for missing file', async () => {
-    expect(await container.exists('missing.txt')).toBe(false);
-  });
-
-  it('listFiles returns all files', async () => {
-    await container.writeFile('a.txt', new TextEncoder().encode('a'), 'text/plain');
-    await container.writeFile('b.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
-    const entries = await container.listFiles();
-    expect(entries).toHaveLength(2);
-    expect(entries.map((e) => e.path).sort()).toEqual(['a.txt', 'b.jpg']);
-  });
-
-  it('listFiles with prefix filters results', async () => {
-    await container.writeFile('index.md', new TextEncoder().encode('# Hi'));
-    await container.writeFile('images/hero.jpg', new Uint8Array([0xff]));
-    await container.writeFile('images/bg.png', new Uint8Array([0x89]));
-    await container.writeFile('audio/clip.mp3', new Uint8Array([0x49]));
-
-    const imageEntries = await container.listFiles('images/');
-    expect(imageEntries).toHaveLength(2);
-    expect(imageEntries.map((e) => e.path).sort()).toEqual(['images/bg.png', 'images/hero.jpg']);
-  });
-
-  it('listFiles reports correct size', async () => {
-    const data = new Uint8Array([1, 2, 3, 4, 5]);
-    await container.writeFile('data.bin', data);
-    const entries = await container.listFiles();
-    expect(entries[0].size).toBe(5);
-  });
-
-  it('listFiles guesses MIME type from extension', async () => {
-    await container.writeFile('photo.jpg', new Uint8Array([0xff]));
-    const entries = await container.listFiles();
-    expect(entries[0].mimeType).toBe('image/jpeg');
-  });
-
-  it('listFiles uses provided MIME type over guess', async () => {
-    await container.writeFile('data.bin', new Uint8Array([0]), 'application/custom');
-    const entries = await container.listFiles();
-    expect(entries[0].mimeType).toBe('application/custom');
-  });
-});
-
-// ============================================
-// Document discovery
-// ============================================
-
-describe('getDocumentPath', () => {
-  let container: MemoryContentContainer;
-
-  beforeEach(() => {
-    container = new MemoryContentContainer();
-  });
-
-  it('returns null for empty container', async () => {
-    expect(await container.getDocumentPath()).toBeNull();
-  });
-
-  it('finds index.md', async () => {
-    await container.writeFile('index.md', new TextEncoder().encode('# Hello'));
-    expect(await container.getDocumentPath()).toBe('index.md');
-  });
-
-  it('preserves the actual case of a priority filename', async () => {
-    await container.writeFile('Index.MD', new TextEncoder().encode('# Hello'));
-    expect(await container.getDocumentPath()).toBe('Index.MD');
-    expect(await container.readDocument()).toBe('# Hello');
-  });
-
-  it('prefers index.md over doc.md', async () => {
-    await container.writeFile('doc.md', new TextEncoder().encode('doc'));
-    await container.writeFile('index.md', new TextEncoder().encode('index'));
-    expect(await container.getDocumentPath()).toBe('index.md');
-  });
-
-  it('prefers doc.md over document.md', async () => {
-    await container.writeFile('document.md', new TextEncoder().encode('document'));
-    await container.writeFile('doc.md', new TextEncoder().encode('doc'));
-    expect(await container.getDocumentPath()).toBe('doc.md');
-  });
-
-  it('prefers document.md over arbitrary .md', async () => {
-    await container.writeFile('readme.md', new TextEncoder().encode('readme'));
-    await container.writeFile('document.md', new TextEncoder().encode('document'));
-    expect(await container.getDocumentPath()).toBe('document.md');
-  });
-
-  it('falls back to first .md at root', async () => {
-    await container.writeFile('my-story.md', new TextEncoder().encode('story'));
-    expect(await container.getDocumentPath()).toBe('my-story.md');
-  });
-
-  it('ignores .md files in subdirectories', async () => {
-    await container.writeFile('docs/notes.md', new TextEncoder().encode('notes'));
-    expect(await container.getDocumentPath()).toBeNull();
-  });
-
-  it('ignores non-md files', async () => {
-    await container.writeFile('data.json', new TextEncoder().encode('{}'));
-    await container.writeFile('hero.jpg', new Uint8Array([0xff]));
-    expect(await container.getDocumentPath()).toBeNull();
-  });
-});
-
-describe('readDocument / writeDocument', () => {
-  let container: MemoryContentContainer;
-
-  beforeEach(() => {
-    container = new MemoryContentContainer();
-  });
-
-  it('writeDocument creates index.md by default', async () => {
-    await container.writeDocument('# Hello');
-    expect(await container.getDocumentPath()).toBe('index.md');
-    expect(await container.readDocument()).toBe('# Hello');
-  });
-
-  it('writeDocument uses custom filename', async () => {
-    await container.writeDocument('# Custom', 'story.md');
-    expect(await container.getDocumentPath()).toBe('story.md');
-    expect(await container.readDocument()).toBe('# Custom');
-  });
-
-  it('readDocument returns null for empty container', async () => {
-    expect(await container.readDocument()).toBeNull();
-  });
-});
-
-// ============================================
-// findDocumentPath (standalone)
-// ============================================
-
-describe('findDocumentPath', () => {
-  it('returns null for empty list', () => {
-    expect(findDocumentPath([])).toBeNull();
-  });
-
-  it('finds index.md from entry list', () => {
-    const entries: ContentEntry[] = [
-      { path: 'images/hero.jpg', mimeType: 'image/jpeg', size: 100 },
-      { path: 'index.md', mimeType: 'text/markdown', size: 50 },
-    ];
-    expect(findDocumentPath(entries)).toBe('index.md');
-  });
-
-  it('returns the matched entry path rather than a lower-cased synthetic path', () => {
-    const entries: ContentEntry[] = [{ path: 'INDEX.md', mimeType: 'text/markdown', size: 50 }];
-    expect(findDocumentPath(entries)).toBe('INDEX.md');
-  });
-
-  it('skips subdirectory .md files', () => {
-    const entries: ContentEntry[] = [
-      { path: 'docs/guide.md', mimeType: 'text/markdown', size: 50 },
-    ];
-    expect(findDocumentPath(entries)).toBeNull();
-  });
-});
-
-// ============================================
-// createMediaProviderFromContainer
-// ============================================
-
-describe('createMediaProviderFromContainer', () => {
-  let container: MemoryContentContainer;
-  let blobCounter = 0;
-
-  beforeEach(() => {
-    container = new MemoryContentContainer();
-    blobCounter = 0;
-    // Mock URL.createObjectURL / revokeObjectURL (not available in Node)
-    vi.stubGlobal('URL', {
-      ...URL,
-      createObjectURL: () => `blob:mock-${++blobCounter}`,
-      revokeObjectURL: vi.fn(),
-    });
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('resolveUrl returns path as-is for missing file', async () => {
-    const provider = createMediaProviderFromContainer(container);
-    expect(await provider.resolveUrl('missing.jpg')).toBe('missing.jpg');
-    provider.dispose();
-  });
-
-  it('resolveUrl returns blob URL for existing file', async () => {
-    await container.writeFile('hero.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
-    const provider = createMediaProviderFromContainer(container);
-    const url = await provider.resolveUrl('hero.jpg');
-    expect(url).toMatch(/^blob:/);
-    provider.dispose();
-  });
-
-  it('resolveUrl caches blob URLs', async () => {
-    await container.writeFile('hero.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
-    const provider = createMediaProviderFromContainer(container);
-    const url1 = await provider.resolveUrl('hero.jpg');
-    const url2 = await provider.resolveUrl('hero.jpg');
-    expect(url1).toBe(url2);
-    provider.dispose();
-  });
-
-  it('listMedia excludes markdown files', async () => {
-    await container.writeFile('index.md', new TextEncoder().encode('# Doc'));
-    await container.writeFile('hero.jpg', new Uint8Array([0xff]), 'image/jpeg');
-    await container.writeFile('clip.mp4', new Uint8Array([0x00]), 'video/mp4');
-
-    const provider = createMediaProviderFromContainer(container);
-    const media = await provider.listMedia();
-    expect(media).toHaveLength(2);
-    expect(media.map((m) => m.name).sort()).toEqual(['clip.mp4', 'hero.jpg']);
-    provider.dispose();
-  });
-
-  it('addMedia writes to container and returns path', async () => {
-    const provider = createMediaProviderFromContainer(container);
-    const path = await provider.addMedia('photo.png', new Uint8Array([0x89]), 'image/png');
-    expect(path).toBe('photo.png');
-    expect(await container.exists('photo.png')).toBe(true);
-    provider.dispose();
-  });
-
-  it('removeMedia deletes from container', async () => {
-    await container.writeFile('hero.jpg', new Uint8Array([0xff]), 'image/jpeg');
-    const provider = createMediaProviderFromContainer(container);
-    // Resolve first to populate cache
-    await provider.resolveUrl('hero.jpg');
-    await provider.removeMedia('hero.jpg');
-    expect(await container.exists('hero.jpg')).toBe(false);
-    provider.dispose();
-  });
-});

package/src/__tests__/contentExtractor.test.ts

@@ -1,243 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  extractContent,
-  stripMarkdown,
-  type ExtractionResult,
-} from '../generate/contentExtractor.js';
-
-const SAMPLE_TEXT = [
-  'Mount Rainier is the largest volcano in the Cascades, standing at 14,411 feet.',
-  'In July 1899, the mountain was designated a national park.',
-  'The park sees roughly 2 million visitors each year.',
-  '"The mountain was calling me," wrote John Muir after his 1888 expedition.',
-  'Temperatures range from 20 degrees to 70 degrees depending on elevation.',
-  'The park features hiking, camping, fishing, and climbing.',
-  'Imagine standing above the clouds at sunrise!',
-  'Paradise is a popular visitor area known for its wildflower meadows.',
-  'Rainier is the most glaciated peak in the lower 48 states.',
-].join(' ');
-
-describe('extractContent', () => {
-  let result: ExtractionResult;
-
-  // Run extraction once for all tests
-  it('extracts elements from sample text', () => {
-    result = extractContent(SAMPLE_TEXT);
-    expect(result.elements.length).toBeGreaterThan(0);
-    expect(result.sourceLength).toBe(SAMPLE_TEXT.length);
-  });
-
-  it('finds stats', () => {
-    const stats = result.elements.filter((e) => e.type === 'stat');
-    expect(stats.length).toBeGreaterThan(0);
-    // Should find 14,411 feet and/or 2 million
-    const values = stats.map((s) => (s.data.type === 'stat' ? s.data.value : ''));
-    expect(
-      values.some((v) => v.includes('14,411') || v.includes('2 million') || v.includes('feet')),
-    ).toBe(true);
-  });
-
-  it('finds dates', () => {
-    const dates = result.elements.filter((e) => e.type === 'date');
-    expect(dates.length).toBeGreaterThan(0);
-  });
-
-  it('finds quotes', () => {
-    const quotes = result.elements.filter((e) => e.type === 'quote');
-    expect(quotes.length).toBeGreaterThan(0);
-    const quoteData = quotes[0].data;
-    if (quoteData.type === 'quote') {
-      expect(quoteData.quote).toContain('mountain was calling me');
-    }
-  });
-
-  it('respects minConfidence filter', () => {
-    const strict = extractContent(SAMPLE_TEXT, { minConfidence: 0.9 });
-    const loose = extractContent(SAMPLE_TEXT, { minConfidence: 0.1 });
-    expect(loose.elements.length).toBeGreaterThanOrEqual(strict.elements.length);
-  });
-
-  it('respects types filter', () => {
-    const onlyStats = extractContent(SAMPLE_TEXT, { types: ['stat'] });
-    for (const elem of onlyStats.elements) {
-      expect(elem.type).toBe('stat');
-    }
-  });
-
-  it('respects maxPerType', () => {
-    const limited = extractContent(SAMPLE_TEXT, { maxPerType: 1 });
-    const typeCounts = new Map<string, number>();
-    for (const elem of limited.elements) {
-      typeCounts.set(elem.type, (typeCounts.get(elem.type) ?? 0) + 1);
-    }
-    for (const count of typeCounts.values()) {
-      expect(count).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('deduplicates overlapping extractions', () => {
-    // Every element should have a unique source position range
-    for (let i = 0; i < result.elements.length; i++) {
-      for (let j = i + 1; j < result.elements.length; j++) {
-        const a = result.elements[i];
-        const b = result.elements[j];
-        // They shouldn't share the exact same start position
-        if (a.sourcePosition === b.sourcePosition) {
-          // If they overlap, one should have been removed by dedup
-          // (this is checking that the dedup is working at all)
-          expect(a.type).not.toBe(b.type);
-        }
-      }
-    }
-  });
-
-  it('returns correct stats counts', () => {
-    expect(result.stats.totalCount).toBe(result.elements.length);
-    expect(result.stats.statCount).toBe(result.elements.filter((e) => e.type === 'stat').length);
-  });
-
-  it('sorts elements by source position', () => {
-    for (let i = 1; i < result.elements.length; i++) {
-      expect(result.elements[i].sourcePosition).toBeGreaterThanOrEqual(
-        result.elements[i - 1].sourcePosition,
-      );
-    }
-  });
-});
-
-describe('extractContent — comparisons', () => {
-  it('detects "from X to Y" comparisons', () => {
-    const text = 'Temperatures range from 20 degrees to 70 degrees depending on altitude.';
-    const result = extractContent(text, { types: ['comparison'] });
-    expect(result.elements.length).toBeGreaterThan(0);
-    const comp = result.elements[0].data;
-    if (comp.type === 'comparison') {
-      expect(comp.left.label).toBeTruthy();
-      expect(comp.right.label).toBeTruthy();
-    }
-  });
-
-  it('does not let a comparison capture cross a sentence boundary', () => {
-    // Regression: greedy `.{2,30}` used to capture right="witness. Robertson"
-    // from the "from witness to witness." idiom bleeding into the next sentence.
-    const text =
-      'Testimony about who carried guns and how many shots were fired ' +
-      'contradicted from witness to witness. Robertson, who initially ' +
-      'testified against the others, was later named as the ringleader.';
-    const result = extractContent(text, { types: ['comparison'] });
-    for (const el of result.elements) {
-      if (el.data.type === 'comparison') {
-        expect(el.data.left.label).not.toContain('.');
-        expect(el.data.right.label).not.toContain('.');
-        expect(el.data.right.label.toLowerCase()).not.toContain('robertson');
-      }
-    }
-  });
-
-  it('rejects idiomatic "from X to X" non-comparisons', () => {
-    // "from witness to witness", "from day to day" mean "it varied", not "A vs B".
-    for (const text of [
-      'The testimony varied from witness to witness across the trial.',
-      'Conditions changed from day to day during the expedition.',
-      'The practice was handed down from generation to generation.',
-    ]) {
-      const result = extractContent(text, { types: ['comparison'] });
-      const comparisons = result.elements.filter((e) => e.data.type === 'comparison');
-      expect(comparisons.length).toBe(0);
-    }
-  });
-});
-
-describe('extractContent — impact lines', () => {
-  it('detects short punchy sentences', () => {
-    const text =
-      'Imagine standing above the clouds! Discover the hidden valley. The weather is variable.';
-    const result = extractContent(text, { types: ['impactLine'] });
-    expect(result.elements.length).toBeGreaterThan(0);
-  });
-
-  it('does not split sentences on abbreviations or initials', () => {
-    // Regression: "…at George W. Tibbetts' store…" was split at "W." into the
-    // fragment "They were met at George W" and shown as a standalone slide.
-    const text =
-      "They were met at George W. Tibbetts' store by a crowd of white and Native men " +
-      'who intimidated them into turning back.';
-    const result = extractContent(text, { types: ['impactLine', 'fact'] });
-    for (const el of result.elements) {
-      if (el.data.type === 'impactLine') {
-        expect(el.data.text).not.toMatch(/George W$/);
-      }
-      if (el.data.type === 'fact') {
-        expect(el.data.fact).not.toMatch(/George W$/);
-      }
-      // No fragment should end on a bare single-letter initial.
-      expect(el.text).not.toMatch(/\b[A-Z]$/);
-    }
-  });
-
-  it('keeps initials-heavy name lists intact as one sentence', () => {
-    const text =
-      'A jury named M. DeWitt Rumsey, Joseph Day, and David Hughes among the killers. ' +
-      'The verdict shocked the town.';
-    const result = extractContent(text, { types: ['fact', 'impactLine'] });
-    // The "M." initial must not spawn a "A jury named M" fragment.
-    for (const el of result.elements) {
-      expect(el.text).not.toMatch(/named M$/);
-    }
-  });
-});
-
-describe('extractContent — lists', () => {
-  it('detects "including X, Y, and Z" lists', () => {
-    const text = 'Activities including hiking, camping, fishing, and climbing are popular.';
-    const result = extractContent(text, { types: ['list'] });
-    expect(result.elements.length).toBeGreaterThan(0);
-    const listData = result.elements[0].data;
-    if (listData.type === 'list') {
-      expect(listData.items.length).toBeGreaterThanOrEqual(3);
-    }
-  });
-});
-
-describe('extractContent — definitions', () => {
-  it('detects "Term is a definition" patterns', () => {
-    const text =
-      'Paradise is a popular visitor area known for its wildflower meadows and scenic viewpoints.';
-    const result = extractContent(text, { types: ['definition'] });
-    expect(result.elements.length).toBeGreaterThan(0);
-    const defData = result.elements[0].data;
-    if (defData.type === 'definition') {
-      expect(defData.term).toBe('Paradise');
-    }
-  });
-});
-
-describe('stripMarkdown', () => {
-  it('removes headers', () => {
-    expect(stripMarkdown('# Hello\n## World')).toBe('Hello\nWorld');
-  });
-
-  it('removes bold and italic', () => {
-    expect(stripMarkdown('**bold** and *italic*')).toBe('bold and italic');
-  });
-
-  it('removes links, keeping text', () => {
-    expect(stripMarkdown('[Click here](https://example.com)')).toBe('Click here');
-  });
-
-  it('removes images entirely', () => {
-    expect(stripMarkdown('![alt text](image.png)')).toBe('');
-  });
-
-  it('removes code blocks', () => {
-    expect(stripMarkdown('before\n```js\ncode\n```\nafter')).toBe('before\n\nafter');
-  });
-
-  it('removes blockquote markers', () => {
-    expect(stripMarkdown('> quoted text')).toBe('quoted text');
-  });
-
-  it('collapses excess newlines', () => {
-    expect(stripMarkdown('a\n\n\n\nb')).toBe('a\n\nb');
-  });
-});