zombie-mermaid 2.2.1 → 2.2.3

package/src/__tests__/sequence-activation-fix.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for the sequence diagram activation/deactivation auto-fix
+ * (packages/mermaid-parser/src/sequence/activation-fix.ts). Operates on raw
+ * Mermaid source text (unlike checkActivationBalance, which takes an
+ * already-parsed diagram), since the fix needs to append to the original
+ * source rather than just report against the parsed model.
+ *
+ * Covers: an already-balanced diagram (no-op), a single dangling
+ * activation (auto-fixed), multiple dangling activations across actors, an
+ * unmatched deactivation (deliberately NOT auto-fixed — see module header),
+ * and a mix of both issue types together.
+ */
+import { describe, it, expect } from 'vitest'
+import { fixActivationBalance } from '@zombie-mermaid/mermaid-parser'
+
+describe('fixActivationBalance', () => {
+  it('returns the diagram unchanged when already balanced', () => {
+    const source = 'sequenceDiagram\n  A->>+B: hello\n  B-->>-A: world'
+    const result = fixActivationBalance(source)
+    expect(result.ok).toBe(true)
+    expect(result.fixedDiagram).toBe(source)
+    expect(result.fixesApplied).toEqual([])
+    expect(result.remainingIssues).toEqual([])
+  })
+
+  it('appends a deactivate statement for a single dangling activation', () => {
+    const source = 'sequenceDiagram\n  activate A\n  A->>B: hello'
+    const result = fixActivationBalance(source)
+    expect(result.ok).toBe(true)
+    expect(result.originalDiagram).toBe(source)
+    expect(result.fixedDiagram).toBe(`${source}\n  deactivate A`)
+    expect(result.fixesApplied).toEqual([
+      expect.stringContaining('Appended "deactivate A"'),
+    ])
+    expect(result.remainingIssues).toEqual([])
+  })
+
+  it('makes the fixed diagram re-check as balanced', () => {
+    const source = 'sequenceDiagram\n  activate A\n  A->>B: hello'
+    const { fixedDiagram } = fixActivationBalance(source)
+    const reChecked = fixActivationBalance(fixedDiagram)
+    expect(reChecked.ok).toBe(true)
+    expect(reChecked.fixesApplied).toEqual([])
+  })
+
+  it('closes multiple dangling activations for different actors', () => {
+    const source = 'sequenceDiagram\n  activate A\n  activate B\n  A->>B: hello'
+    const result = fixActivationBalance(source)
+    expect(result.ok).toBe(true)
+    expect(result.fixesApplied).toHaveLength(2)
+    expect(result.fixedDiagram).toContain('  deactivate A')
+    expect(result.fixedDiagram).toContain('  deactivate B')
+  })
+
+  it('does not fix an unmatched deactivation and reports it back', () => {
+    const source = 'sequenceDiagram\n  A->>B: hello\n  deactivate A'
+    const result = fixActivationBalance(source)
+    expect(result.ok).toBe(false)
+    expect(result.fixedDiagram).toBe(source)
+    expect(result.fixesApplied).toEqual([])
+    expect(result.remainingIssues).toEqual([
+      expect.objectContaining({
+        code: 'UNMATCHED_DEACTIVATION',
+        actorId: 'A',
+      }),
+    ])
+  })
+
+  it('fixes the dangling half of a mixed-issue diagram, leaving the unmatched half reported', () => {
+    const source =
+      'sequenceDiagram\n  activate A\n  A->>B: hello\n  deactivate B'
+    const result = fixActivationBalance(source)
+    expect(result.ok).toBe(false)
+    expect(result.fixesApplied).toEqual([
+      expect.stringContaining('Appended "deactivate A"'),
+    ])
+    expect(result.fixedDiagram).toContain('  deactivate A')
+    expect(result.remainingIssues).toEqual([
+      expect.objectContaining({
+        code: 'UNMATCHED_DEACTIVATION',
+        actorId: 'B',
+      }),
+    ])
+  })
+
+  it('throws a clear error for a non-sequence diagram', () => {
+    expect(() => fixActivationBalance('graph LR\n  A --> B')).toThrow(
+      /only supports sequence diagrams/,
+    )
+  })
+})

package/src/__tests__/sequence-layout.test.ts

@@ -6,16 +6,13 @@
  * to inspect Y coordinates, rather than checking SVG output.
  */
 import { describe, it, expect } from 'vitest'
-import { parseSequenceDiagram } from '../sequence/parser.ts'
-import { layoutSequenceDiagram } from '../sequence/layout.ts'
+import { parseSequenceDiagram } from '@zombie-mermaid/mermaid-parser'
+import { layoutSequenceDiagram } from '@zombie-mermaid/svg-renderer'
+import { splitStatements } from '@zombie-mermaid/core'
 
 /** Helper: parse and layout a sequence diagram from source lines */
 function layout(source: string) {
-  const lines = source
-    .split('\n')
-    .map((l) => l.trim())
-    .filter((l) => l.length > 0 && !l.startsWith('%%'))
-  return layoutSequenceDiagram(parseSequenceDiagram(lines))
+  return layoutSequenceDiagram(parseSequenceDiagram(splitStatements(source)))
 }
 
 describe('sequence layout – block spacing', () => {

package/src/__tests__/sequence-parser-syntax-errors.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Syntactic error-detection tests for the sequence diagram parser
+ * (issue #762).
+ *
+ * The 8 pre-existing `throw` sites in `parseSequenceDiagram` all guard
+ * *semantic* rules mirrored from mermaid.js (duplicate actor ids, box
+ * nesting, create/destroy message mismatch — see
+ * sequence-parser.test.ts/sequence-activation-check.test.ts for those). No
+ * *syntactic* error was ever raised: a malformed arrow like `->>>` silently
+ * absorbed the extra character into the actor name instead of being
+ * rejected (verified: `Alice->>>Bob: Hello` created an actor literally
+ * named `">Bob"`), an unmatched `end` was silently ignored, and an
+ * `alt`/`loop`/`box` left open at EOF was silently accepted as if closed.
+ * These tests assert the parser now throws an actionable error instead,
+ * while confirming valid syntax — including short arrows, activation
+ * shorthand, and actor names that legitimately start with "x" — is
+ * unaffected.
+ */
+import { describe, it, expect } from 'vitest'
+import { parseSequenceDiagram } from '@zombie-mermaid/mermaid-parser'
+import { splitStatements } from '@zombie-mermaid/core'
+
+function parse(text: string) {
+  return parseSequenceDiagram(splitStatements(text))
+}
+
+describe('parseSequenceDiagram – malformed arrows', () => {
+  it('throws on an extra ">" past the longest known long-arrow token', () => {
+    // The issue's own verified repro: silently created an actor named
+    // `">Bob"` before this pass.
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice->>>Bob: Hello`),
+    ).toThrow(/Malformed sequence-diagram arrow.*"->>>"/)
+  })
+
+  it('throws on an extra ")" past a short open-arrow token', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice-))Bob: Hello`),
+    ).toThrow(/Malformed sequence-diagram arrow.*"-\)\)"/)
+  })
+
+  it('throws on an extra ")" past a short dashed-open-arrow token', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice--))Bob: Hello`),
+    ).toThrow(/Malformed sequence-diagram arrow/)
+  })
+
+  it('mentions the known-good arrow set in the message', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice->>>Bob: Hello`),
+    ).toThrow(/->, -->, ->>, -->>, -x, --x, -\), --\)/)
+  })
+
+  it('reports the 1-based line number', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        participant Alice
+        Alice->>>Bob: Hello`),
+    ).toThrow(/^Line 3:/)
+  })
+})
+
+describe('parseSequenceDiagram – unmatched "end"', () => {
+  it('throws on an "end" with no open block or box', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice->>Bob: Hi
+        end`),
+    ).toThrow(/"end" does not match any open block/)
+  })
+})
+
+describe('parseSequenceDiagram – unclosed blocks/boxes at EOF', () => {
+  it('throws when a loop is never closed', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        loop Every 5s
+        Alice->>Bob: Hi`),
+    ).toThrow(/unclosed "loop" block/)
+  })
+
+  it('throws when an alt is never closed', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        alt Happy path
+        Alice->>Bob: Hi`),
+    ).toThrow(/unclosed "alt" block/)
+  })
+
+  it('throws when a box is never closed', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        box Group1
+        participant Alice
+        Alice->>Alice: Hi`),
+    ).toThrow(/unclosed "box Group1"/)
+  })
+
+  it('reports the line the block opened on', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice->>Bob: Hi
+        loop Every 5s
+        Bob->>Alice: Pong`),
+    ).toThrow(/^Line 3:/)
+  })
+})
+
+describe('parseSequenceDiagram – valid syntax is unaffected', () => {
+  it('still parses correct long arrows without throwing', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice->>Bob: Hi
+        Bob-->>Alice: Hi back`),
+    ).not.toThrow()
+  })
+
+  it('still parses activation shorthand (+/-) without throwing', () => {
+    const d = parse(`sequenceDiagram
+      Alice->>+Bob: Hi
+      Bob-->>-Alice: Hi back`)
+    expect(d.messages[0]!.activate).toBe(true)
+    expect(d.messages[1]!.deactivate).toBe(true)
+  })
+
+  it('still parses short open/cross arrows without throwing', () => {
+    const d = parse(`sequenceDiagram
+      Alice-)Bob: fire and forget
+      Bob--xAlice: lost message`)
+    expect(d.messages).toHaveLength(2)
+  })
+
+  it('still parses bidirectional arrows without throwing', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        Alice<<->>Bob: sync
+        Alice<<-->>Bob: async sync`),
+    ).not.toThrow()
+  })
+
+  it('does not throw for an actor name that legitimately starts with "x" after a -x arrow', () => {
+    const d = parse(`sequenceDiagram
+      Alice-xXavier: lost`)
+    expect(d.actors.map((a) => a.id)).toContain('Xavier')
+  })
+
+  it('still parses a properly closed loop/alt/box without throwing', () => {
+    expect(() =>
+      parse(`sequenceDiagram
+        box Group1
+        participant Alice
+        participant Bob
+        end
+        loop Every 5s
+          alt Happy path
+            Alice->>Bob: Hi
+          else Sad path
+            Alice-xBob: nope
+          end
+        end`),
+    ).not.toThrow()
+  })
+
+  it('still closes an "end" that matches a block nested inside a box', () => {
+    const d = parse(`sequenceDiagram
+      box Group1
+      participant Alice
+      loop Every 5s
+        Alice->>Alice: ping
+      end
+      end`)
+    expect(d.blocks).toHaveLength(1)
+    expect(d.boxes).toHaveLength(1)
+  })
+})

package/src/__tests__/sequence-parser.test.ts

@@ -9,15 +9,12 @@ import {
   parseSequenceDiagram,
   isBlockType,
   toBlockType,
-} from '../sequence/parser.ts'
+} from '@zombie-mermaid/mermaid-parser'
+import { splitStatements } from '@zombie-mermaid/core'
 
 /** Helper to parse — preprocesses text the same way index.ts does */
 function parse(text: string) {
-  const lines = text
-    .split('\n')
-    .map((l) => l.trim())
-    .filter((l) => l.length > 0 && !l.startsWith('%%'))
-  return parseSequenceDiagram(lines)
+  return parseSequenceDiagram(splitStatements(text))
 }
 
 // ============================================================================

package/src/__tests__/statements.test.ts

@@ -15,13 +15,18 @@ import { describe, it, expect } from 'vitest'
 import { splitStatements, detectDiagramType } from '@zombie-mermaid/core'
 import { renderMermaidASCII, renderMermaidSVG } from '../index.ts'
 
+/** Project a `splitStatements` result down to just the text, for assertions
+ * that don't care about position (see the dedicated `line` tests below for
+ * position coverage). */
+const texts = (source: string) => splitStatements(source).map((s) => s.text)
+
 describe('splitStatements (issue #181)', () => {
   it('splits on newlines', () => {
-    expect(splitStatements('graph TD\nA-->B')).toEqual(['graph TD', 'A-->B'])
+    expect(texts('graph TD\nA-->B')).toEqual(['graph TD', 'A-->B'])
   })
 
   it('splits on semicolons', () => {
-    expect(splitStatements('graph TD;A-->B;B-->C')).toEqual([
+    expect(texts('graph TD;A-->B;B-->C')).toEqual([
       'graph TD',
       'A-->B',
       'B-->C',
@@ -29,59 +34,53 @@ describe('splitStatements (issue #181)', () => {
   })
 
   it('drops empty statements from trailing or repeated separators', () => {
-    expect(splitStatements('graph TD;A-->B;')).toEqual(['graph TD', 'A-->B'])
-    expect(splitStatements('graph TD;;;A-->B')).toEqual(['graph TD', 'A-->B'])
-    expect(splitStatements('graph TD\n\n\nA-->B')).toEqual([
-      'graph TD',
-      'A-->B',
-    ])
+    expect(texts('graph TD;A-->B;')).toEqual(['graph TD', 'A-->B'])
+    expect(texts('graph TD;;;A-->B')).toEqual(['graph TD', 'A-->B'])
+    expect(texts('graph TD\n\n\nA-->B')).toEqual(['graph TD', 'A-->B'])
   })
 
   it('trims whitespace around each statement', () => {
-    expect(splitStatements('  graph TD  ;  A-->B  ')).toEqual([
-      'graph TD',
-      'A-->B',
-    ])
+    expect(texts('  graph TD  ;  A-->B  ')).toEqual(['graph TD', 'A-->B'])
   })
 
   describe('does not split a semicolon that is not a separator', () => {
     it('inside a double-quoted label', () => {
-      expect(splitStatements('graph TD\nA["a; b"]-->B')).toEqual([
+      expect(texts('graph TD\nA["a; b"]-->B')).toEqual([
         'graph TD',
         'A["a; b"]-->B',
       ])
     })
 
     it('inside a single-quoted label', () => {
-      expect(splitStatements("graph TD\nA['x; y']-->B")).toEqual([
+      expect(texts("graph TD\nA['x; y']-->B")).toEqual([
         'graph TD',
         "A['x; y']-->B",
       ])
     })
 
     it('terminating a named character reference', () => {
-      expect(splitStatements('graph TD\nA[&]-->B')).toEqual([
+      expect(texts('graph TD\nA[&]-->B')).toEqual([
         'graph TD',
         'A[&]-->B',
       ])
     })
 
     it('terminating a numeric character reference', () => {
-      expect(splitStatements('graph TD\nA[#]-->B')).toEqual([
+      expect(texts('graph TD\nA[#]-->B')).toEqual([
         'graph TD',
         'A[#]-->B',
       ])
     })
 
     it('terminating a hex character reference', () => {
-      expect(splitStatements('graph TD\nA[😀]-->B')).toEqual([
+      expect(texts('graph TD\nA[😀]-->B')).toEqual([
         'graph TD',
         'A[😀]-->B',
       ])
     })
 
     it('but still splits a real separator on the same line as an entity', () => {
-      expect(splitStatements('graph TD;A[&]-->B;B-->C')).toEqual([
+      expect(texts('graph TD;A[&]-->B;B-->C')).toEqual([
         'graph TD',
         'A[&]-->B',
         'B-->C',
@@ -90,26 +89,20 @@ describe('splitStatements (issue #181)', () => {
 
     it('and treats a lone ampersand as an ordinary character', () => {
       // `A & B` is flowchart's parallel-link syntax, not an entity.
-      expect(splitStatements('graph TD;A-->B & C')).toEqual([
-        'graph TD',
-        'A-->B & C',
-      ])
+      expect(texts('graph TD;A-->B & C')).toEqual(['graph TD', 'A-->B & C'])
     })
   })
 
   describe('comments', () => {
     it('drops whole-line comments without splitting their semicolons', () => {
-      expect(splitStatements('graph TD\n%% note; not code\nA-->B')).toEqual([
+      expect(texts('graph TD\n%% note; not code\nA-->B')).toEqual([
         'graph TD',
         'A-->B',
       ])
     })
 
     it('drops a comment that only begins after a semicolon', () => {
-      expect(splitStatements('graph TD\nA-->B; %% note')).toEqual([
-        'graph TD',
-        'A-->B',
-      ])
+      expect(texts('graph TD\nA-->B; %% note')).toEqual(['graph TD', 'A-->B'])
     })
 
     it('lets the comment swallow the rest of the line', () => {
@@ -118,14 +111,14 @@ describe('splitStatements (issue #181)', () => {
        * resurrect what follows. Splitting first and then discarding fragments
        * that merely begin with `%%` left `C-->D` parsing as code.
        */
-      expect(splitStatements('graph TD\nA-->B; %% note; C-->D')).toEqual([
+      expect(texts('graph TD\nA-->B; %% note; C-->D')).toEqual([
         'graph TD',
         'A-->B',
       ])
     })
 
     it('treats %% inside a quoted label as text, not a comment', () => {
-      expect(splitStatements('graph TD\nA["100%% done"]-->B')).toEqual([
+      expect(texts('graph TD\nA["100%% done"]-->B')).toEqual([
         'graph TD',
         'A["100%% done"]-->B',
       ])
@@ -144,14 +137,11 @@ describe('splitStatements (issue #181)', () => {
       ['A[heart #9829; x]-->B', 'a symbol reference'],
       ['A[say #quot;hi#quot;]-->B', 'a named reference'],
     ])('keeps %s intact (%s)', (statement) => {
-      expect(splitStatements(`graph TD\n  ${statement}`)).toEqual([
-        'graph TD',
-        statement,
-      ])
+      expect(texts(`graph TD\n  ${statement}`)).toEqual(['graph TD', statement])
     })
 
     it('still splits a real separator on the same line as one', () => {
-      expect(splitStatements('graph TD;A[#59;]-->B;B-->C')).toEqual([
+      expect(texts('graph TD;A[#59;]-->B;B-->C')).toEqual([
         'graph TD',
         'A[#59;]-->B',
         'B-->C',
@@ -159,7 +149,7 @@ describe('splitStatements (issue #181)', () => {
     })
 
     it('leaves a bare # that is not a reference alone', () => {
-      expect(splitStatements('graph TD;A[C# lang]-->B')).toEqual([
+      expect(texts('graph TD;A[C# lang]-->B')).toEqual([
         'graph TD',
         'A[C# lang]-->B',
       ])
@@ -167,6 +157,34 @@ describe('splitStatements (issue #181)', () => {
   })
 })
 
+describe('splitStatements — line numbers (issue #760)', () => {
+  it('reports the 1-based physical source line for each newline-separated statement', () => {
+    const stmts = splitStatements('graph TD\nA-->B\nB-->C')
+    expect(stmts.map((s) => s.line)).toEqual([1, 2, 3])
+  })
+
+  it('carries forward the original line number across dropped blank lines', () => {
+    const stmts = splitStatements('graph TD\n\n\nA-->B')
+    expect(stmts.map((s) => ({ text: s.text, line: s.line }))).toEqual([
+      { text: 'graph TD', line: 1 },
+      { text: 'A-->B', line: 4 },
+    ])
+  })
+
+  it('carries forward the original line number across a dropped comment line', () => {
+    const stmts = splitStatements('graph TD\n%% a comment\nA-->B')
+    expect(stmts.map((s) => ({ text: s.text, line: s.line }))).toEqual([
+      { text: 'graph TD', line: 1 },
+      { text: 'A-->B', line: 3 },
+    ])
+  })
+
+  it('gives every semicolon-separated statement on one physical line the same line number', () => {
+    const stmts = splitStatements('graph TD\nA-->B;B-->C;C-->D')
+    expect(stmts.map((s) => s.line)).toEqual([1, 2, 2, 2])
+  })
+})
+
 describe('semicolon-separated diagrams render their bodies (issue #181)', () => {
   const cases = [
     {

package/src/__tests__/testdata/ascii/subgraph_direction_override.txt

@@ -16,27 +16,27 @@ B --> Y
     |
     |
     |
-+---|---+
-|LR Grou|
-|   |   |
-|   v   |
-| +---+ |
-| |   | |
-| | A | |
-| |   | |
-| +-+-+ |
-|   |   |
-|   |   |
-|   |   |
-|   |   |
-|   v   |
-| +---+ |
-| |   | |
-| | B | |
-| |   | |
-| +-+-+ |
-|   |   |
-+---|---+
++---|----+
+|LR Group|
+|   |    |
+|   v    |
+| +---+  |
+| |   |  |
+| | A |  |
+| |   |  |
+| +-+-+  |
+|   |    |
+|   |    |
+|   |    |
+|   |    |
+|   v    |
+| +---+  |
+| |   |  |
+| | B |  |
+| |   |  |
+| +-+-+  |
+|   |    |
++---|----+
     |
     |
     v

package/src/__tests__/theme-palette-contrast.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Guards the "legible, readable contrast" acceptance criterion the #684
+ * theme-selector restoration's 16 per-theme verification sub-issues
+ * (#691-706) each individually ask for, systematically across every
+ * built-in theme at once rather than eyeballing 16 screenshots one at a
+ * time — see docs/decisions/theme-selector-shared-state.md and this
+ * repo's CLAUDE.md's "favor tooling over manual scanning" convention.
+ *
+ * Computes the actual WCAG 2.x contrast ratio (relative luminance, per
+ * https://www.w3.org/TR/WCAG21/#dfn-relative-luminance) between each
+ * theme's `bg`/`fg` pair — not a hand-picked pass/fail per theme, so a
+ * future THEMES addition with a genuinely illegible pair fails this test
+ * automatically instead of only being caught by a human noticing a
+ * screenshot looks wrong.
+ */
+import { describe, it, expect } from 'vitest'
+import { THEMES } from '@zombie-mermaid/core'
+
+/**
+ * The threshold every theme must clear. WCAG AA's own thresholds are 4.5:1
+ * for normal text and 3:1 for large/bold text; diagram node labels here
+ * are typically medium, semi-bold text, closer to the "large text"
+ * category than dense body copy. 4.0 sits between the two -- strict enough
+ * to catch a genuinely illegible pair, loose enough not to fail
+ * `solarized-light` (4.13:1), whose muted bg/fg pair matches Ethan
+ * Schoonover's actual published Solarized values rather than being a
+ * mistake in this repo's THEMES data -- #684's own non-goals rule out
+ * changing THEMES' colors to "fix" a curated editor-theme's real values.
+ */
+const MIN_CONTRAST_RATIO = 4.0
+
+function hexToRgb(hex: string): [number, number, number] {
+  const clean = hex.replace('#', '')
+  return [
+    parseInt(clean.slice(0, 2), 16),
+    parseInt(clean.slice(2, 4), 16),
+    parseInt(clean.slice(4, 6), 16),
+  ]
+}
+
+/** sRGB channel -> linear-light value, the WCAG relative-luminance step. */
+function linearize(channel: number): number {
+  const c = channel / 255
+  return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4
+}
+
+function relativeLuminance(hex: string): number {
+  const [r, g, b] = hexToRgb(hex)
+  return 0.2126 * linearize(r) + 0.7152 * linearize(g) + 0.0722 * linearize(b)
+}
+
+/** WCAG contrast ratio between two colors, always >= 1 (order-independent). */
+function contrastRatio(hexA: string, hexB: string): number {
+  const lumA = relativeLuminance(hexA)
+  const lumB = relativeLuminance(hexB)
+  const lighter = Math.max(lumA, lumB)
+  const darker = Math.min(lumA, lumB)
+  return (lighter + 0.05) / (darker + 0.05)
+}
+
+describe('every built-in theme has a legible bg/fg contrast ratio', () => {
+  for (const [themeKey, colors] of Object.entries(THEMES)) {
+    it(`${themeKey}: bg/fg contrast is at least ${MIN_CONTRAST_RATIO}:1`, () => {
+      const ratio = contrastRatio(colors.bg, colors.fg)
+      expect(ratio).toBeGreaterThanOrEqual(MIN_CONTRAST_RATIO)
+    })
+  }
+})
+
+describe('contrastRatio() itself', () => {
+  it('returns 1 for identical colors', () => {
+    expect(contrastRatio('#808080', '#808080')).toBeCloseTo(1, 5)
+  })
+
+  it('returns 21 for pure black vs pure white (the WCAG maximum)', () => {
+    expect(contrastRatio('#000000', '#FFFFFF')).toBeCloseTo(21, 1)
+  })
+
+  it('is symmetric regardless of argument order', () => {
+    const a = contrastRatio('#1a1b26', '#a9b1d6')
+    const b = contrastRatio('#a9b1d6', '#1a1b26')
+    expect(a).toBeCloseTo(b, 10)
+  })
+})