@glossarist/concept-browser 0.7.34 → 0.7.37

package/src/__tests__/citation-display.test.ts

@@ -5,12 +5,19 @@ import { createPinia, setActivePinia } from 'pinia';
 import CitationDisplay from '../components/CitationDisplay.vue';
 import { getFactory, resetFactory } from '../adapters/factory';
 import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
+
+function createTestResolver() {
+  const uriRouter = new UriRouter();
+  const resolver = new ReferenceResolver(uriRouter);
+  return { uriRouter, resolver };
+}
 
 // Minimal Citation type matching the glossarist Citation interface
 function makeCitation(source: string, referenceFrom: string, type = 'clause') {
   return {
     ref: { source },
-    locality: { type, referenceFrom },
+    locality: { type, reference_from: referenceFrom },
   };
 }
 
@@ -21,8 +28,8 @@ describe('CitationDisplay — source reference linking', () => {
     resetFactory();
     const factory = getFactory();
     // Register dataset patterns
-    factory.resolver.registerDataset('vim-2012', ['urn:oiml:pub:v:2:2012*']);
-    factory.resolver.registerDataset('viml-2022', ['urn:oiml:pub:v:1:2022*']);
+    factory.uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    factory.uriRouter.registerDataset('viml-2022', '', '', ['urn:oiml:pub:v:1:2022*']);
     // Register source refs
     factory.resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
     factory.resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
@@ -141,3 +148,158 @@ describe('CitationDisplay — source reference linking', () => {
     expect(wrapper.html()).not.toContain('citation-preview');
   });
 });
+
+describe('CitationDisplay — classification-based rendering', () => {
+  let router: any;
+
+  beforeEach(async () => {
+    resetFactory();
+    const factory = getFactory();
+    factory.uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    factory.uriRouter.registerDataset('viml-2022', '', '', ['urn:oiml:pub:v:1:2022*']);
+    factory.resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+    router = createRouter({
+      history: createMemoryHistory(),
+      routes: [
+        { path: '/', component: { template: '<div/>' } },
+        { name: 'concept', path: '/dataset/:registerId/concept/:conceptId', component: { template: '<div/>' } },
+      ],
+    });
+    await router.push('/');
+    setActivePinia(createPinia());
+  });
+
+  function mountCitation(citation: any, registerId?: string) {
+    return mount(CitationDisplay, {
+      props: { citation, registerId },
+      global: { plugins: [router] },
+    });
+  }
+
+  it('classifies resolved citation as internal-citation with button', () => {
+    const wrapper = mountCitation(makeCitation('OIML V2-200:2012', '2.2'), 'viml-2022');
+    expect(wrapper.find('button.concept-link').exists()).toBe(true);
+  });
+
+  it('classifies citation with link as self-contained-citation with anchor', () => {
+    const citation = {
+      ref: { source: 'ISO 9000:2015' },
+      locality: { type: 'clause', reference_from: '3.1' },
+      link: 'https://iso.org/standard/62085.html',
+    };
+    const wrapper = mountCitation(citation);
+    // Should have an anchor link for the source text
+    const links = wrapper.findAll('a.concept-link');
+    expect(links.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('classifies known source without resolution as external-citation', () => {
+    const citation = {
+      ref: { source: 'Some Standard', id: '4.2.1' },
+      locality: null,
+    };
+    const wrapper = mountCitation(citation);
+    // No button, no anchor link for the source — just plain text
+    expect(wrapper.find('button.concept-link').exists()).toBe(false);
+    expect(wrapper.text()).toContain('Some Standard');
+  });
+
+  it('classifies citation without ref source as unresolved-citation', () => {
+    const wrapper = mountCitation({ ref: null, locality: null });
+    expect(wrapper.find('button').exists()).toBe(false);
+    expect(wrapper.find('a.concept-link').exists()).toBe(false);
+  });
+});
+
+describe('ReferenceResolver — resolveCite', () => {
+  let resolver: ReferenceResolver;
+  let uriRouter: UriRouter;
+
+  beforeEach(() => {
+    ({ uriRouter, resolver } = createTestResolver());
+    uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    uriRouter.registerDataset('viml-2022', '', '', ['urn:oiml:pub:v:1:2022*']);
+    resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+  });
+
+  it('resolves cite with matching source to internal-citation', () => {
+    const result = resolver.resolveCite({
+      ref: { source: 'OIML V2-200:2012' },
+      locality: { type: 'clause', reference_from: '2.2' },
+    }, 'viml-2022');
+
+    expect(result.classification).toBe('internal-citation');
+    expect(result.resolved).toEqual({ registerId: 'vim-2012', conceptId: '2.2' });
+  });
+
+  it('classifies cite with link but no resolution as self-contained-citation', () => {
+    const result = resolver.resolveCite({
+      ref: { source: 'ISO 9000:2015' },
+      locality: null,
+      link: 'https://iso.org/standard/62085.html',
+    });
+
+    expect(result.classification).toBe('self-contained-citation');
+    expect(result.resolved).toBeNull();
+  });
+
+  it('classifies cite with known ref but no resolution as external-citation', () => {
+    const result = resolver.resolveCite({
+      ref: { source: 'Unknown Standard', id: '3.1' },
+      locality: null,
+    });
+
+    expect(result.classification).toBe('external-citation');
+    expect(result.resolved).toBeNull();
+  });
+
+  it('classifies cite without ref as unresolved-citation', () => {
+    const result = resolver.resolveCite(null);
+    expect(result.classification).toBe('unresolved-citation');
+  });
+
+  it('classifies cite with null citation ref as unresolved-citation', () => {
+    const result = resolver.resolveCite({
+      ref: null,
+      locality: null,
+    });
+    expect(result.classification).toBe('unresolved-citation');
+  });
+});
+
+describe('ReferenceResolver — classifyCitation via resolveCite', () => {
+  let resolver: ReferenceResolver;
+  let uriRouter: UriRouter;
+
+  beforeEach(() => {
+    ({ uriRouter, resolver } = createTestResolver());
+    uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+  });
+
+  it('returns internal-citation for resolvable citation', () => {
+    expect(resolver.resolveCite(
+      { ref: { source: 'VIM' }, locality: { reference_from: '2.2' } },
+      'other-ds',
+    ).classification).toBe('internal-citation');
+  });
+
+  it('returns self-contained-citation for citation with link', () => {
+    expect(resolver.resolveCite(
+      { ref: { source: 'Unknown' }, locality: null, link: 'https://example.com' },
+    ).classification).toBe('self-contained-citation');
+  });
+
+  it('returns external-citation for known source without resolution', () => {
+    expect(resolver.resolveCite(
+      { ref: { source: 'Some Standard' }, locality: null },
+    ).classification).toBe('external-citation');
+  });
+
+  it('returns unresolved-citation for citation without ref source', () => {
+    expect(resolver.resolveCite(
+      { ref: null, locality: null },
+    ).classification).toBe('unresolved-citation');
+  });
+});

package/src/__tests__/cite-ref.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect } from 'vitest';
+import { parseMention } from 'glossarist';
+
+describe('parseMention — cite-ref detection', () => {
+  it('parses cite:key form', () => {
+    const result = parseMention('cite:iso-10303-2');
+    expect(result.kind).toBe('cite-ref');
+    expect(result.key).toBe('iso-10303-2');
+    expect(result.label).toBeNull();
+  });
+
+  it('parses cite:key,label form', () => {
+    const result = parseMention('cite:vim-term,entity data type');
+    expect(result.kind).toBe('cite-ref');
+    expect(result.key).toBe('vim-term');
+    expect(result.label).toBe('entity data type');
+  });
+
+  it('parses cite:key with quoted label', () => {
+    const result = parseMention('cite:foo,"quoted, label"');
+    expect(result.kind).toBe('cite-ref');
+    expect(result.key).toBe('foo');
+    expect(result.label).toBe('quoted, label');
+  });
+
+  it('parses bare numeric id as numeric', () => {
+    const result = parseMention('3.1.1');
+    expect(result.kind).toBe('numeric');
+    expect(result.id).toBe('3.1.1');
+  });
+
+  it('parses dashed numeric id as numeric', () => {
+    const result = parseMention('103-01-02');
+    expect(result.kind).toBe('numeric');
+    expect(result.id).toBe('103-01-02');
+  });
+
+  it('classifies URN mentions as urn-ref (glossarist >= 0.3.7)', () => {
+    const result = parseMention('urn:iso:std:iso:10303:-2:ed-1:en:term:foo,bar');
+    expect(result.kind).toBe('urn-ref');
+    expect(result.uri).toBe('urn:iso:std:iso:10303:-2:ed-1:en:term:foo');
+    expect(result.label).toBe('bar');
+  });
+
+  it('classifies IEV-style mentions as designation (glossarist >= 0.3.7)', () => {
+    const result = parseMention('term, IEV:103-01-02');
+    expect(result.kind).toBe('designation');
+    expect(result.id).toBe('term');
+    expect(result.label).toBe('IEV:103-01-02');
+  });
+});
+
+describe('extractInlineRefs — cite-ref integration', () => {
+  // Test the build-time extractInlineRefs function indirectly by
+  // verifying parseMention handles the forms the build script uses.
+  it('cite:key with trailing comma and empty label', () => {
+    const result = parseMention('cite:foo,');
+    expect(result.kind).toBe('cite-ref');
+    expect(result.key).toBe('foo');
+  });
+
+  it('cite:key without comma has no label', () => {
+    const result = parseMention('cite:bar');
+    expect(result.kind).toBe('cite-ref');
+    expect(result.key).toBe('bar');
+    expect(result.label).toBeNull();
+  });
+});
+
+describe('ReferenceResolver — resolveCite integration', () => {
+  it('resolves cite-ref citation with source match to internal', async () => {
+    const { ReferenceResolver } = await import('../adapters/ReferenceResolver');
+    const { UriRouter } = await import('../adapters/UriRouter');
+    const uriRouter = new UriRouter();
+    const resolver = new ReferenceResolver(uriRouter);
+    uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+    const citation = {
+      ref: { source: 'VIM' },
+      locality: { type: 'definition', reference_from: '2.2' },
+    };
+
+    const result = resolver.resolveCite(citation);
+    expect(result.classification).toBe('internal-citation');
+    expect(result.resolved).toEqual({ registerId: 'vim-2012', conceptId: '2.2' });
+  });
+
+  it('classifies citation with link but no resolution as self-contained', async () => {
+    const { ReferenceResolver } = await import('../adapters/ReferenceResolver');
+    const { UriRouter } = await import('../adapters/UriRouter');
+    const resolver = new ReferenceResolver(new UriRouter());
+
+    const citation = {
+      ref: { source: 'Unknown' },
+      locality: null,
+      link: 'https://example.com',
+    };
+
+    const result = resolver.resolveCite(citation);
+    expect(result.classification).toBe('self-contained-citation');
+  });
+
+  it('classifies citation without ref source as unresolved', async () => {
+    const { ReferenceResolver } = await import('../adapters/ReferenceResolver');
+    const { UriRouter } = await import('../adapters/UriRouter');
+    const resolver = new ReferenceResolver(new UriRouter());
+
+    const result = resolver.resolveCite({ ref: null, locality: null });
+    expect(result.classification).toBe('unresolved-citation');
+  });
+});

package/src/__tests__/concept-detail-interaction.test.ts

@@ -242,11 +242,7 @@ describe('ConceptDetail interactions', () => {
     // Register the URI pattern via factory so it resolves as internal
     const { getFactory } = await import('../adapters/factory');
     const factory = getFactory();
-    factory.router.registerDataset('test', '/data/test', {
-      ...makeManifest(),
-      uriBase: 'https://glossarist.org',
-    });
-    factory.resolver.registerDataset('test', ['https://glossarist.org/test/concept/*']);
+    factory.uriRouter.registerDataset('test', '', '', ['https://glossarist.org/test/concept/*']);
 
     const wrapper = mountDetail(json);
     await switchToDefinition(wrapper);

package/src/__tests__/{math.test.ts → content-renderer.test.ts}

@@ -1,33 +1,33 @@
 import { describe, it, expect } from 'vitest';
-import { renderMath, cleanContent } from '../utils/math';
+import { renderContent, cleanContent } from '../utils/content-renderer';
 
-describe('renderMath', () => {
+describe('renderContent', () => {
   it('passes through plain text unchanged', () => {
-    expect(renderMath('hello world')).toBe('hello world');
+    expect(renderContent('hello world')).toBe('hello world');
   });
 
   it('passes through pre-rendered MathML unchanged', () => {
     const preRendered = 'value <span class="math-inline"><math><mi>x</mi></math></span> here';
-    expect(renderMath(preRendered)).toBe(preRendered);
+    expect(renderContent(preRendered)).toBe(preRendered);
   });
 
   it('still converts italic in mixed pre-rendered MathML content', () => {
     const preRendered = '<span class="math-inline"><math><mi>x</mi></math></span> and *italic*';
-    expect(renderMath(preRendered)).toBe(
+    expect(renderContent(preRendered)).toBe(
       '<span class="math-inline"><math><mi>x</mi></math></span> and <em>italic</em>',
     );
   });
 
   it('converts *text* to <em> (italic) for non-pre-rendered content', () => {
-    expect(renderMath('some *italic* text')).toBe('some <em>italic</em> text');
+    expect(renderContent('some *italic* text')).toBe('some <em>italic</em> text');
   });
 
   it('converts ~text~ to <sub> (subscript)', () => {
-    expect(renderMath('H~2~O')).toBe('H<sub>2</sub>O');
+    expect(renderContent('H~2~O')).toBe('H<sub>2</sub>O');
   });
 
   it('converts bullet lines to <ul><li>', () => {
-    const result = renderMath('* first item\n\n* second item');
+    const result = renderContent('* first item\n\n* second item');
     expect(result).toContain('<ul class="concept-list">');
     expect(result).toContain('<li>first item</li>');
     expect(result).toContain('<li>second item</li>');
@@ -35,7 +35,7 @@ describe('renderMath', () => {
 
   it('converts AsciiDoc pipe-delimited tables to <table>', () => {
     const input = 'Intro text\n\n|===\n| a | b | c\n| d | e | f\n|===';
-    const result = renderMath(input);
+    const result = renderContent(input);
     expect(result).toContain('<table class="concept-table">');
     expect(result).toContain('<thead><tr><th>a</th><th>b</th><th>c</th></tr></thead>');
     expect(result).toContain('<tbody><tr><td>d</td><td>e</td><td>f</td></tr></tbody>');
@@ -44,7 +44,7 @@ describe('renderMath', () => {
 
   it('resolves URN inline refs via xrefResolver', () => {
     const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
-    const result = renderMath(
+    const result = renderContent(
       'a {{urn:iso:std:iso:14812:3.1.1.1,entity}} reference',
       resolver,
     );
@@ -53,7 +53,7 @@ describe('renderMath', () => {
 
   it('resolves single-braced URN inline refs', () => {
     const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
-    const result = renderMath(
+    const result = renderContent(
       'a {urn:iso:std:iso:14812:3.1.1.1,entity} reference',
       resolver,
     );
@@ -61,18 +61,18 @@ describe('renderMath', () => {
   });
 
   it('shows term without resolver', () => {
-    const result = renderMath('a {{urn:iso:std:iso:14812:3.1.1.1,entity}} ref');
+    const result = renderContent('a {{urn:iso:std:iso:14812:3.1.1.1,entity}} ref');
     expect(result).toBe('a entity ref');
   });
 
   it('uses display text from three-part URN refs', () => {
-    const result = renderMath('a {{urn:iso:std:iso:14812:3.1.1.6,person,Person}} ref');
+    const result = renderContent('a {{urn:iso:std:iso:14812:3.1.1.6,person,Person}} ref');
     expect(result).toBe('a Person ref');
   });
 
   it('resolves three-part URN refs with display text via xrefResolver', () => {
     const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
-    const result = renderMath(
+    const result = renderContent(
       '{{urn:iso:std:iso:14812:3.1.1.6,person,Person}}, object, event',
       resolver,
     );
@@ -81,38 +81,40 @@ describe('renderMath', () => {
 
   it('resolves single-braced three-part URN refs', () => {
     const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
-    const result = renderMath(
+    const result = renderContent(
       '{urn:iso:std:iso:14812:3.5.3.4,user,users} are people',
       resolver,
     );
     expect(result).toBe('[users→urn:iso:std:iso:14812:3.5.3.4] are people');
   });
 
-  it('strips remaining {{...}} to just the term', () => {
-    const result = renderMath('see {{some term, unknown ref}}');
-    expect(result).toBe('see some term');
+  it('displays render term (second part) for unresolved two-arg mentions', () => {
+    const result = renderContent('see {{some term, unknown ref}}');
+    // Per spec: {{identifier,render term}} — identifier first, render term last
+    // Without a resolver, the render term is what should display
+    expect(result).toBe('see unknown ref');
   });
 
   it('resolves cross-refs even in pre-rendered content', () => {
     const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
     const preRendered = '<span class="math-inline"><math><mi>x</mi></math></span> and {{urn:iso:std:iso:14812:3.1.1.1,entity}}';
-    expect(renderMath(preRendered, resolver)).toBe(
+    expect(renderContent(preRendered, resolver)).toBe(
       '<span class="math-inline"><math><mi>x</mi></math></span> and [entity→urn:iso:std:iso:14812:3.1.1.1]',
     );
   });
 
   it('handles empty input', () => {
-    expect(renderMath('')).toBe('');
+    expect(renderContent('')).toBe('');
   });
 
   it('handles null-ish input', () => {
-    expect(renderMath(null as any)).toBe('');
-    expect(renderMath(undefined as any)).toBe('');
+    expect(renderContent(null as any)).toBe('');
+    expect(renderContent(undefined as any)).toBe('');
   });
 
   // stem:[...] placeholder tests
   it('outputs math-pending placeholder for stem:[expr]', () => {
-    const result = renderMath('value stem:[x^2] here');
+    const result = renderContent('value stem:[x^2] here');
     expect(result).toContain('class="math-pending"');
     expect(result).toContain('data-expr="x^2"');
     expect(result).toContain('data-format="asciimath"');
@@ -120,20 +122,20 @@ describe('renderMath', () => {
   });
 
   it('outputs math-pending with math-bold for *stem:[expr]', () => {
-    const result = renderMath('*stem:[alpha]');
+    const result = renderContent('*stem:[alpha]');
     expect(result).toContain('class="math-pending math-bold"');
     expect(result).toContain('data-expr="alpha"');
   });
 
   it('outputs math-pending placeholder for latexmath:[expr]', () => {
-    const result = renderMath('equation latexmath:[\\frac{a}{b}] end');
+    const result = renderContent('equation latexmath:[\\frac{a}{b}] end');
     expect(result).toContain('class="math-pending"');
     expect(result).toContain('data-expr="\\frac{a}{b}"');
     expect(result).toContain('data-format="latex"');
   });
 
   it('handles multiple stem: expressions in one string', () => {
-    const result = renderMath('stem:[m] out of stem:[n] redundancy');
+    const result = renderContent('stem:[m] out of stem:[n] redundancy');
     const matches = result.match(/class="math-pending"/g);
     expect(matches).toHaveLength(2);
     expect(result).toContain('data-expr="m"');
@@ -141,20 +143,58 @@ describe('renderMath', () => {
   });
 
   it('handles nested brackets in stem:', () => {
-    const result = renderMath('stem:[a_[i]]');
+    const result = renderContent('stem:[a_[i]]');
     expect(result).toContain('data-expr="a_[i]"');
   });
 
   it('handles stem: in designation text', () => {
-    const result = renderMath('stem:[n]-ary digit');
+    const result = renderContent('stem:[n]-ary digit');
     expect(result).toContain('data-expr="n"');
     expect(result).toContain('-ary digit');
   });
 
   it('escapes special HTML in stem: expressions', () => {
-    const result = renderMath('stem:[a<b]');
+    const result = renderContent('stem:[a<b]');
     expect(result).toContain('data-expr="a&lt;b"');
   });
+
+  // Bold
+  it('converts **text** to <strong>', () => {
+    expect(renderContent('some **bold** text')).toBe('some <strong>bold</strong> text');
+  });
+
+  it('distinguishes **bold** from *italic*', () => {
+    expect(renderContent('**bold** and *italic*')).toBe('<strong>bold</strong> and <em>italic</em>');
+  });
+
+  // cite:key rendering
+  it('renders {{cite:key}} as bib-ref span', () => {
+    const result = renderContent('see {{cite:iso-10303-2}} for details');
+    expect(result).toBe('see <span class="bib-ref">iso-10303-2</span> for details');
+  });
+
+  it('renders {{cite:key,label}} using label', () => {
+    const result = renderContent('see {{cite:vim-2.2,entity data type}} for details');
+    expect(result).toBe('see <span class="bib-ref">entity data type</span> for details');
+  });
+
+  it('invokes citeResolver for cite:key mentions', () => {
+    const resolver = (key: string, label: string | null) => `[CITE:${key}:${label}]`;
+    const result = renderContent('{{cite:foo,bar}}', { citeResolver: resolver });
+    expect(result).toBe('[CITE:foo:bar]');
+  });
+
+  it('invokes citeResolver for cite:key without label', () => {
+    const resolver = (key: string, label: string | null) => `[CITE:${key}]`;
+    const result = renderContent('{{cite:foo}}', { citeResolver: resolver });
+    expect(result).toBe('[CITE:foo]');
+  });
+
+  it('escapes HTML in cite:key fallback rendering', () => {
+    const result = renderContent('{{cite:foo<b>}}');
+    expect(result).toContain('foo&lt;b&gt;');
+    expect(result).not.toContain('<b>');
+  });
 });
 
 describe('cleanContent', () => {
@@ -167,6 +207,18 @@ describe('cleanContent', () => {
     expect(cleanContent('some *italic* text')).toBe('some italic text');
   });
 
+  it('strips **text** to plain text', () => {
+    expect(cleanContent('some **bold** text')).toBe('some bold text');
+  });
+
+  it('strips {{cite:key}} completely', () => {
+    expect(cleanContent('see {{cite:foo}} here')).toBe('see  here');
+  });
+
+  it('strips {{cite:key,label}} to label', () => {
+    expect(cleanContent('see {{cite:foo,entity data type}} here')).toBe('see entity data type here');
+  });
+
   it('converts ~text~ to _text', () => {
     expect(cleanContent('H~2~O')).toBe('H_2O');
   });
@@ -207,3 +259,35 @@ describe('cleanContent', () => {
     expect(cleanContent('value stem:[m] out of stem:[n]')).toBe('value m out of n');
   });
 });
+
+describe('renderContent — cite-ref edge cases', () => {
+  it('renders cite with special characters in key', () => {
+    const result = renderContent('{{cite:iso-10303-2-ed1}}');
+    expect(result).toBe('<span class="bib-ref">iso-10303-2-ed1</span>');
+  });
+
+  it('renders cite with numeric-only key', () => {
+    const result = renderContent('{{cite:42}}');
+    expect(result).toBe('<span class="bib-ref">42</span>');
+  });
+
+  it('falls back to key when no label in citeResolver', () => {
+    const result = renderContent('{{cite:foo-bar}}');
+    expect(result).toBe('<span class="bib-ref">foo-bar</span>');
+  });
+});
+
+describe('cleanContent — cite-ref edge cases', () => {
+  it('strips cite:key with special characters', () => {
+    expect(cleanContent('see {{cite:iso-10303-2-ed1}}')).toBe('see ');
+  });
+
+  it('preserves label with comma in cite:key,label', () => {
+    expect(cleanContent('see {{cite:foo,entity data type}}')).toBe('see entity data type');
+  });
+
+  it('handles multiple cite refs in sequence', () => {
+    expect(cleanContent('{{cite:a}} and {{cite:b,Label B}}'))
+      .toBe(' and Label B');
+  });
+});

package/src/__tests__/escape.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { escapeHtml, escapeAttr } from '../utils/escape';
+
+describe('escapeHtml', () => {
+  it('escapes ampersands', () => {
+    expect(escapeHtml('a & b')).toBe('a & b');
+  });
+
+  it('escapes less-than', () => {
+    expect(escapeHtml('a < b')).toBe('a &lt; b');
+  });
+
+  it('escapes greater-than', () => {
+    expect(escapeHtml('a > b')).toBe('a &gt; b');
+  });
+
+  it('escapes all three special characters', () => {
+    expect(escapeHtml('<script>alert("xss")</script>')).toBe(
+      '&lt;script&gt;alert("xss")&lt;/script&gt;',
+    );
+  });
+
+  it('returns empty string for empty input', () => {
+    expect(escapeHtml('')).toBe('');
+  });
+
+  it('leaves plain text unchanged', () => {
+    expect(escapeHtml('hello world')).toBe('hello world');
+  });
+
+  it('escapes multiple ampersands', () => {
+    expect(escapeHtml('a&b&c')).toBe('a&amp;b&amp;c');
+  });
+
+  it('handles already-escaped content (double-escaping)', () => {
+    // escapeHtml does not detect already-escaped entities — by design
+    expect(escapeHtml('&amp;')).toBe('&amp;amp;');
+  });
+
+  it('handles unicode text', () => {
+    expect(escapeHtml('日本語 < 한국어')).toBe('日本語 &lt; 한국어');
+  });
+
+  it('handles long strings', () => {
+    const input = 'x'.repeat(10000) + '<' + 'y'.repeat(10000);
+    const result = escapeHtml(input);
+    expect(result).toContain('&lt;');
+    expect(result.length).toBe(input.length + 3); // '<' → '&lt;' adds 3 chars
+  });
+});
+
+describe('escapeAttr', () => {
+  it('escapes double quotes', () => {
+    expect(escapeAttr('a "b" c')).toBe('a &quot;b&quot; c');
+  });
+
+  it('escapes HTML entities and quotes', () => {
+    expect(escapeAttr('<a href="x">')).toBe('&lt;a href=&quot;x&quot;&gt;');
+  });
+
+  it('returns empty string for empty input', () => {
+    expect(escapeAttr('')).toBe('');
+  });
+
+  it('leaves plain text unchanged', () => {
+    expect(escapeAttr('hello')).toBe('hello');
+  });
+
+  it('handles single quotes (passed through)', () => {
+    expect(escapeAttr("it's")).toBe("it's");
+  });
+
+  it('handles combined special characters', () => {
+    expect(escapeAttr('a&b<c"d')).toBe('a&amp;b&lt;c&quot;d');
+  });
+});