zombie-mermaid 4.2.2 → 4.2.3

package/src/__tests__/ascii-hyperlinks.test.ts

@@ -1,364 +0,0 @@
-/**
- * Opt-in OSC 8 terminal hyperlinks in ASCII output (issue #216, piece 4).
- *
- * `renderMermaidASCII(text, { hyperlinks: true })` wraps the label of every
- * node whose `click` directive declared a safe href in an OSC 8 escape
- * pair. The sequences are zero-width, so the load-bearing property is that
- * stripping them yields exactly the non-hyperlinked output — checked here
- * per feature, and against every gallery sample in
- * __tests__/ascii-hyperlinks-samples.test.ts (which lives outside src/ so it
- * can import samples-data.ts without tripping tsconfig's rootDir).
- */
-import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
-import {
-  OSC8_CLOSE,
-  OSC8_SEQUENCE,
-  osc8Open,
-  stripOsc8,
-  joinWithLinks,
-  LinkRunTracker,
-  markBoxLabelLinks,
-  mkLinkCanvas,
-} from '../../packages/ascii-renderer/src/hyperlinks.ts'
-import {
-  colorizeLine,
-  DEFAULT_ASCII_THEME,
-} from '../../packages/ascii-renderer/src/ansi.ts'
-import { mkCanvas, write } from '../../packages/ascii-renderer/src/canvas.ts'
-import { addCoordsOverlay } from '../../packages/ascii-renderer/src/coords.ts'
-import { runRender } from '../cli/render.ts'
-import { createMockStdout, renderArgs } from './cli-test-helpers.ts'
-import type { CharRole } from '../../packages/ascii-renderer/src/types.ts'
-
-const OSC8_PREFIX = '\x1b]8;;'
-
-/** Every `open … close` span in `output`: [href, visible text]. */
-function linkSpans(output: string): [string, string][] {
-  const spans: [string, string][] = []
-  const re = /\x1b\]8;;([^\x1b]*)\x1b\\([\s\S]*?)\x1b\]8;;\x1b\\/g
-  for (const m of output.matchAll(re)) spans.push([m[1]!, m[2]!])
-  return spans
-}
-
-const LINKED_FLOW = `graph LR
-  A[Docs] --> B[Other]
-  click A "https://example.com" "Docs"`
-
-describe('renderMermaidASCII – hyperlinks option', () => {
-  it('is off by default: no OSC 8 anywhere, even with click hrefs present', () => {
-    expect(renderMermaidASCII(LINKED_FLOW)).not.toContain(OSC8_PREFIX)
-    expect(
-      renderMermaidASCII(LINKED_FLOW, { hyperlinks: false }),
-    ).not.toContain(OSC8_PREFIX)
-  })
-
-  it('wraps only the linked node label when enabled', () => {
-    const out = renderMermaidASCII(LINKED_FLOW, { hyperlinks: true })
-    expect(linkSpans(out)).toEqual([['https://example.com', 'Docs']])
-    // The unlinked node's label is present and bare.
-    expect(stripOsc8(out)).toContain('Other')
-    expect(out).toContain(`${osc8Open('https://example.com')}Docs${OSC8_CLOSE}`)
-  })
-
-  it('never changes layout: stripping the sequences gives the plain render', () => {
-    const plain = renderMermaidASCII(LINKED_FLOW)
-    const linked = renderMermaidASCII(LINKED_FLOW, { hyperlinks: true })
-    expect(linked).not.toBe(plain)
-    expect(stripOsc8(linked)).toBe(plain)
-  })
-
-  it('links a multi-word label as one span, interior space included', () => {
-    const out = renderMermaidASCII(
-      `graph TD
-  A[Web Server] --> B[DB]
-  click A "https://example.com/web"`,
-      { hyperlinks: true },
-    )
-    expect(linkSpans(out)).toEqual([['https://example.com/web', 'Web Server']])
-  })
-
-  it('links each line of a multi-line label separately', () => {
-    const out = renderMermaidASCII(
-      `graph TD
-  A["Line one<br/>Line two"] --> B[Next]
-  click A "https://example.com/multi"`,
-      { hyperlinks: true },
-    )
-    expect(linkSpans(out)).toEqual([
-      ['https://example.com/multi', 'Line one'],
-      ['https://example.com/multi', 'Line two'],
-    ])
-    expect(stripOsc8(out)).toBe(
-      renderMermaidASCII(
-        `graph TD
-  A["Line one<br/>Line two"] --> B[Next]
-  click A "https://example.com/multi"`,
-      ),
-    )
-  })
-
-  it('links only the node that declared the click when labels repeat', () => {
-    const src = `graph LR
-  A[Same] --> B[Same]
-  click B "https://example.com/b"`
-    const out = renderMermaidASCII(src, { hyperlinks: true })
-    expect(linkSpans(out)).toEqual([['https://example.com/b', 'Same']])
-    // Both labels are still rendered; exactly one of them is wrapped.
-    expect(stripOsc8(out).match(/Same/g)).toHaveLength(2)
-  })
-
-  it('links the whole label when another label is a prefix of it', () => {
-    const out = renderMermaidASCII(
-      `graph LR
-  A[Doc] --> B[Docs]
-  click B "https://example.com/docs"`,
-      { hyperlinks: true },
-    )
-    expect(linkSpans(out)).toEqual([['https://example.com/docs', 'Docs']])
-  })
-
-  it.each([
-    ['javascript:alert(1)'],
-    ['data:text/html,<script>alert(1)</script>'],
-    ['vbscript:msgbox'],
-  ])('never emits an unsafe href (%s)', (href) => {
-    const out = renderMermaidASCII(
-      `graph LR
-  A[Docs] --> B[Other]
-  click A "${href}"`,
-      { hyperlinks: true },
-    )
-    expect(out).not.toContain(OSC8_PREFIX)
-    expect(out).not.toContain(href)
-  })
-
-  it('emits nothing for a callback-only interaction', () => {
-    const out = renderMermaidASCII(
-      `graph LR
-  A[Docs] --> B[Other]
-  click A call showDetail() "A tooltip"`,
-      { hyperlinks: true },
-    )
-    expect(out).not.toContain(OSC8_PREFIX)
-    expect(out).not.toContain('showDetail')
-  })
-
-  it('accepts mailto and relative hrefs', () => {
-    const out = renderMermaidASCII(
-      `graph LR
-  A[Mail] --> B[Local]
-  click A "mailto:me@example.com"
-  click B "./guide.html"`,
-      { hyperlinks: true },
-    )
-    expect(linkSpans(out)).toEqual([
-      ['mailto:me@example.com', 'Mail'],
-      ['./guide.html', 'Local'],
-    ])
-  })
-
-  it('keeps links on their labels after the BT vertical flip', () => {
-    const src = `graph BT
-  A[Bottom] --> B[Top]
-  click B "https://example.com/top"`
-    const out = renderMermaidASCII(src, { hyperlinks: true })
-    expect(linkSpans(out)).toEqual([['https://example.com/top', 'Top']])
-    expect(stripOsc8(out)).toBe(renderMermaidASCII(src))
-  })
-
-  it('links a class name in a class diagram, but not its annotation or members', () => {
-    const src = `classDiagram
-  class Animal {
-    <<interface>>
-    +String name
-    +speak()
-  }
-  class Dog
-  Animal <|-- Dog
-  click Animal href "https://example.com/animal"`
-    const out = renderMermaidASCII(src, { hyperlinks: true })
-    expect(linkSpans(out)).toEqual([['https://example.com/animal', 'Animal']])
-    expect(stripOsc8(out)).toBe(renderMermaidASCII(src))
-  })
-
-  it("is ignored in 'html' color mode (browser mockups never get escapes)", () => {
-    const out = renderMermaidASCII(LINKED_FLOW, {
-      hyperlinks: true,
-      colorMode: 'html',
-    })
-    expect(out).not.toContain('\x1b')
-    expect(out).toContain('<span')
-  })
-
-  it('composes with ANSI colors without disturbing the SGR runs', () => {
-    const plain = renderMermaidASCII(LINKED_FLOW, { colorMode: 'truecolor' })
-    const linked = renderMermaidASCII(LINKED_FLOW, {
-      colorMode: 'truecolor',
-      hyperlinks: true,
-    })
-    expect(plain).toContain('\x1b[38;2;')
-    expect(linkSpans(linked).map(([href]) => href)).toEqual([
-      'https://example.com',
-    ])
-    expect(stripOsc8(linked)).toBe(plain)
-  })
-
-  it('does not widen the --coords ruler', () => {
-    const plain = addCoordsOverlay(renderMermaidASCII(LINKED_FLOW))
-    const linked = addCoordsOverlay(
-      renderMermaidASCII(LINKED_FLOW, { hyperlinks: true }),
-    )
-    expect(linked.split('\n')[0]).toBe(plain.split('\n')[0])
-    expect(stripOsc8(linked)).toBe(plain)
-  })
-})
-
-describe('hyperlinks – escape sequence helpers', () => {
-  it('uses the ESC \\ string terminator, not BEL', () => {
-    expect(osc8Open('https://example.com')).toBe(
-      '\x1b]8;;https://example.com\x1b\\',
-    )
-    expect(OSC8_CLOSE).toBe('\x1b]8;;\x1b\\')
-    expect(osc8Open('https://example.com')).not.toContain('\x07')
-  })
-
-  it('percent-encodes characters outside printable ASCII, leaving the rest alone', () => {
-    expect(osc8Open('https://例.jp/a b?q=1&r=%20#x')).toBe(
-      '\x1b]8;;https://%E4%BE%8B.jp/a%20b?q=1&r=%20#x\x1b\\',
-    )
-    // A surrogate pair encodes as one code point, not two lone surrogates.
-    expect(osc8Open('https://x.test/😀')).toBe(
-      '\x1b]8;;https://x.test/%F0%9F%98%80\x1b\\',
-    )
-  })
-
-  it('stripOsc8 removes ST- and BEL-terminated sequences and nothing else', () => {
-    const st = `${osc8Open('https://a.test')}A${OSC8_CLOSE} \x1b[31mB\x1b[0m`
-    expect(stripOsc8(st)).toBe('A \x1b[31mB\x1b[0m')
-    const bel = '\x1b]8;;https://a.test\x07A\x1b]8;;\x07'
-    expect(stripOsc8(bel)).toBe('A')
-    expect(OSC8_SEQUENCE.flags).toContain('g')
-  })
-
-  it('LinkRunTracker closes and reopens between adjacent different links', () => {
-    const t = new LinkRunTracker()
-    expect(t.advance(null)).toBe('')
-    expect(t.advance('https://a.test')).toBe(osc8Open('https://a.test'))
-    expect(t.advance('https://a.test')).toBe('')
-    expect(t.advance('https://b.test')).toBe(
-      OSC8_CLOSE + osc8Open('https://b.test'),
-    )
-    expect(t.advance(null)).toBe(OSC8_CLOSE)
-    expect(t.finish()).toBe('')
-    t.advance('https://c.test')
-    expect(t.finish()).toBe(OSC8_CLOSE)
-  })
-
-  it('joinWithLinks wraps runs and closes a run open at end of line', () => {
-    const chars = ['x', 'y', 'z', 'w']
-    const links = [null, 'https://a.test', 'https://a.test', 'https://b.test']
-    expect(joinWithLinks(chars, links)).toBe(
-      `x${osc8Open('https://a.test')}yz${OSC8_CLOSE}${osc8Open('https://b.test')}w${OSC8_CLOSE}`,
-    )
-    expect(joinWithLinks(chars, [null, null, null, null])).toBe('xyzw')
-  })
-
-  it('colorizeLine keeps SGR grouping intact around a link inside a color run', () => {
-    // Zero border padding: the label touches the border, so the link
-    // boundary falls inside what would otherwise be one 'border' SGR run if
-    // the label's first char were border-like. Assert the general property.
-    const chars = ['│', '-', 'x', '│']
-    const roles: (CharRole | null)[] = ['border', 'border', 'text', 'border']
-    const links = [null, 'https://a.test', 'https://a.test', null]
-    const plain = colorizeLine(chars, roles, DEFAULT_ASCII_THEME, 'truecolor')
-    const linked = colorizeLine(
-      chars,
-      roles,
-      DEFAULT_ASCII_THEME,
-      'truecolor',
-      links,
-    )
-    expect(stripOsc8(linked)).toBe(plain)
-    expect(linkSpans(stripSgr(linked))).toEqual([['https://a.test', '-x']])
-  })
-
-  it('markBoxLabelLinks marks first..last non-space cells of the requested interior rows', () => {
-    // 7 wide x 5 tall box: row 1 "ab cd", row 2 blank, row 3 "e"
-    const box = mkCanvas(6, 4)
-    for (let x = 1; x <= 5; x++) {
-      write(box, x, 0, '─')
-      write(box, x, 4, '─')
-    }
-    for (let y = 1; y <= 3; y++) {
-      write(box, 0, y, '│')
-      write(box, 6, y, '│')
-    }
-    for (const [i, ch] of ['a', 'b', ' ', 'c', 'd'].entries())
-      write(box, 1 + i, 1, ch)
-    write(box, 3, 3, 'e')
-
-    const all = mkLinkCanvas(20, 20)
-    markBoxLabelLinks(all, box, { x: 10, y: 5 }, 'https://a.test')
-    const marked = (lc: (string | null)[][]) =>
-      lc.flatMap((col, x) =>
-        col.flatMap((v, y) => (v === null ? [] : [`${x},${y}`])),
-      )
-    expect(marked(all).sort()).toEqual(
-      ['11,6', '12,6', '13,6', '14,6', '15,6', '13,8'].sort(),
-    )
-
-    const headerOnly = mkLinkCanvas(20, 20)
-    markBoxLabelLinks(headerOnly, box, { x: 0, y: 0 }, 'https://a.test', {
-      from: 3,
-      to: 3,
-    })
-    expect(marked(headerOnly)).toEqual(['3,3'])
-
-    // Out-of-range cells are clipped, not thrown on.
-    const tiny = mkLinkCanvas(1, 1)
-    expect(() =>
-      markBoxLabelLinks(tiny, box, { x: 0, y: 0 }, 'https://a.test'),
-    ).not.toThrow()
-  })
-})
-
-describe('CLI – render --ascii --hyperlinks', () => {
-  it('emits OSC 8 only when the flag is set', async () => {
-    const off = createMockStdout()
-    await runRender(renderArgs({ ascii: true }), off, LINKED_FLOW)
-    expect(off.output()).not.toContain(OSC8_PREFIX)
-
-    const on = createMockStdout()
-    await runRender(
-      renderArgs({ ascii: true, hyperlinks: true }),
-      on,
-      LINKED_FLOW,
-    )
-    expect(linkSpans(on.output())).toEqual([['https://example.com', 'Docs']])
-    expect(stripOsc8(on.output())).toBe(off.output())
-  })
-
-  it('measures --max-width on visible columns, ignoring the escapes', async () => {
-    const stderr = createMockStdout()
-    const out = createMockStdout()
-    // Wide enough that the plain render fits; the escape bytes alone would
-    // push a naive length measurement past the limit and trigger a warning.
-    const width = renderMermaidASCII(LINKED_FLOW)
-      .split('\n')
-      .reduce((m, l) => Math.max(m, l.length), 0)
-    await runRender(
-      renderArgs({ ascii: true, hyperlinks: true, maxWidth: width }),
-      out,
-      LINKED_FLOW,
-      stderr,
-    )
-    expect(stderr.output()).toBe('')
-    expect(out.output()).toContain(OSC8_PREFIX)
-  })
-})
-
-/** SGR-only strip, for asserting link spans inside colored output. */
-function stripSgr(text: string): string {
-  return text.replace(/\x1b\[[0-9;]*m/g, '')
-}

package/src/__tests__/ascii-nested-subgraph-sibling-order-444.test.ts

@@ -1,108 +0,0 @@
-/**
- * Regression test for #444 — "Flowchart: nested subgraph left-right order
- * doesn't match mermaid.js."
- *
- * Root cause: `placeReachableChildren` (src/ascii/grid.ts) placed a node's
- * children in raw edge-declaration order, so for
- *
- *   subgraph Cloud
- *     subgraph us-east [US East Region]
- *       A[Web Server] --> B[App Server]
- *     end
- *     subgraph us-west [US West Region]
- *       C[Web Server] --> D[App Server]
- *     end
- *   end
- *   E[Load Balancer] --> A
- *   E --> C
- *
- * `E`'s children were placed in the order its outgoing edges were declared
- * (`E --> A` before `E --> C`), putting `us-east` on the left and `us-west`
- * on the right. Real mermaid.js (verified against its bundled
- * flowDb.getData() — see the comment on `compareBySiblingSubgraphOrder` in
- * src/ascii/grid.ts, and the matching comment in
- * packages/svg-renderer/src/layout-engine/to-elk.ts's `mermaidToElk`) instead orders sibling
- * subgraphs in *reversed declaration order*, independent of which one a
- * shared parent's edges happen to target first — putting `us-west` (the
- * second-declared sibling) on the left and `us-east` on the right.
- *
- * The fix adds `compareBySiblingSubgraphOrder` to reorder same-level
- * children that land in different sibling subgraphs, plus a matching fix to
- * `placeReachableChildren`'s outer traversal order (visiting placed nodes in
- * cross-axis order rather than raw declaration order) so a child's
- * column/row stays aligned with its own parent once sibling order can
- * diverge from declaration order.
- */
-import { describe, it, expect } from 'vitest'
-import { parseMermaid } from '@zombie-mermaid/mermaid-parser'
-import { convertToAsciiGraph } from '../../packages/ascii-renderer/src/converter.ts'
-import { createMapping } from '../../packages/ascii-renderer/src/grid.ts'
-import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
-import type {
-  AsciiConfig,
-  AsciiGraph,
-} from '../../packages/ascii-renderer/src/types.ts'
-import { requireGridCoord } from '../../packages/ascii-renderer/src/types.ts'
-
-function layoutFlowchart(source: string): AsciiGraph {
-  const parsed = parseMermaid(source)
-  const config: AsciiConfig = {
-    useAscii: false,
-    paddingX: 5,
-    paddingY: 5,
-    boxBorderPadding: 1,
-    graphDirection: 'TD',
-  }
-  const graph = convertToAsciiGraph(parsed, config)
-  createMapping(graph)
-  return graph
-}
-
-function findNode(graph: AsciiGraph, name: string) {
-  const node = graph.nodes.find((n) => n.name === name)
-  if (!node) throw new Error(`node "${name}" not found`)
-  return node
-}
-
-describe('ASCII nested-subgraph sibling left-right order matches mermaid.js (#444)', () => {
-  const repro = `graph TD
-  subgraph Cloud
-    subgraph us-east [US East Region]
-      A[Web Server] --> B[App Server]
-    end
-    subgraph us-west [US West Region]
-      C[Web Server] --> D[App Server]
-    end
-  end
-  E[Load Balancer] --> A
-  E --> C`
-
-  it('places us-west (declared second) left of us-east (declared first)', () => {
-    const graph = layoutFlowchart(repro)
-    const a = requireGridCoord(findNode(graph, 'A')) // us-east member
-    const c = requireGridCoord(findNode(graph, 'C')) // us-west member
-    expect(c.x).toBeLessThan(a.x)
-  })
-
-  it('keeps each nested subgraph member aligned in the same column as its sibling', () => {
-    const graph = layoutFlowchart(repro)
-    const a = requireGridCoord(findNode(graph, 'A'))
-    const b = requireGridCoord(findNode(graph, 'B'))
-    const c = requireGridCoord(findNode(graph, 'C'))
-    const d = requireGridCoord(findNode(graph, 'D'))
-    expect(b.x).toBe(a.x) // A --> B stay in us-east's column
-    expect(d.x).toBe(c.x) // C --> D stay in us-west's column
-  })
-
-  it('renders "US West" before "US East" in the ASCII output', () => {
-    // The label may wrap around a routed edge line (e.g. "US East│Region"),
-    // so match on the unambiguous "US West"/"US East" prefix rather than
-    // the full two-word label.
-    const output = renderMermaidASCII(repro)
-    const westIdx = output.indexOf('US West')
-    const eastIdx = output.indexOf('US East')
-    expect(westIdx).toBeGreaterThan(-1)
-    expect(eastIdx).toBeGreaterThan(-1)
-    expect(westIdx).toBeLessThan(eastIdx)
-  })
-})

package/src/__tests__/ascii-nonmember-beside-frame-1283.test.ts

@@ -1,113 +0,0 @@
-/**
- * Regression tests for #1283 — layout of a non-member node placed beside a
- * subgraph frame (follow-up to #1252/#1278).
- *
- * `separateNonMembersFromFrames` re-places `Y` just past the frame, but left
- * its parent `W` where it was, so `W --> Y` wrapped around from W's side
- * instead of dropping straight down. A free-standing parent that only feeds
- * the moved node now moves to the same column.
- */
-import { describe, it, expect } from 'vitest'
-import { parseMermaid } from '@zombie-mermaid/mermaid-parser'
-import { convertToAsciiGraph } from '../../packages/ascii-renderer/src/converter.ts'
-import { createMapping } from '../../packages/ascii-renderer/src/grid.ts'
-import type {
-  AsciiConfig,
-  AsciiGraph,
-} from '../../packages/ascii-renderer/src/types.ts'
-
-function layout(source: string, direction: 'TD' | 'LR'): AsciiGraph {
-  const config: AsciiConfig = {
-    useAscii: false,
-    paddingX: 5,
-    paddingY: 5,
-    boxBorderPadding: 1,
-    graphDirection: direction,
-  }
-  const graph = convertToAsciiGraph(parseMermaid(source), config)
-  createMapping(graph)
-  return graph
-}
-
-function grid(graph: AsciiGraph, name: string) {
-  const gc = graph.nodes.find((n) => n.name === name)?.gridCoord
-  if (!gc) throw new Error(`node ${name} not placed`)
-  return gc
-}
-
-describe('ASCII: a non-member moved off a frame keeps its parent aligned (#1283)', () => {
-  it('keeps W directly above Y in TD', () => {
-    const graph = layout(
-      `graph TD
-subgraph Sub
-A-->B
-A-->C
-end
-X-->A
-W-->Y
-Y-->A`,
-      'TD',
-    )
-    expect(grid(graph, 'W').x).toBe(grid(graph, 'Y').x)
-    expect(grid(graph, 'W').y).toBeLessThan(grid(graph, 'Y').y)
-    const edge = graph.edges.find(
-      (e) => e.from.name === 'W' && e.to.name === 'Y',
-    )!
-    // A straight drop: every path point shares one column.
-    expect(new Set(edge.path.map((p) => p.x)).size).toBe(1)
-  })
-
-  it('keeps W level with Y in LR', () => {
-    const graph = layout(
-      `graph LR
-subgraph Sub
-A-->B
-A-->C
-end
-X-->A
-W-->Y
-Y-->A`,
-      'LR',
-    )
-    expect(grid(graph, 'W').y).toBe(grid(graph, 'Y').y)
-  })
-  const frame = `
-subgraph Sub
-A-->B
-A-->C
-end`
-
-  it('leaves a parent with two children where it is', () => {
-    const base = layout(`graph TD${frame}\nX-->A\nW-->Y\nW-->Q\nY-->A`, 'TD')
-    expect(grid(base, 'W').x).not.toBe(grid(base, 'Y').x)
-  })
-
-  it('leaves a parent that has its own incoming edge where it is', () => {
-    const g = layout(`graph TD${frame}\nX-->A\nR-->W\nW-->Y\nY-->A`, 'TD')
-    expect(g.nodes.every((n) => n.gridCoord)).toBe(true)
-  })
-
-  it('does not move anything when Y has two parents', () => {
-    const g = layout(`graph TD${frame}\nX-->A\nW-->Y\nV-->Y\nY-->A`, 'TD')
-    // Longest-path layering ranks A below Y, so Y no longer lands in the
-    // frame's span and nothing is moved: both parents stay on the root row
-    // in their own columns.
-    expect(grid(g, 'W').y).toBe(grid(g, 'V').y)
-    expect(grid(g, 'W').x).not.toBe(grid(g, 'V').x)
-    expect(grid(g, 'Y').y).toBeGreaterThan(grid(g, 'W').y)
-  })
-
-  it('leaves a parent that is itself in a subgraph alone', () => {
-    const g = layout(
-      `graph TD${frame}\nX-->A\nsubgraph Other\nW\nend\nW-->Y\nY-->A`,
-      'TD',
-    )
-    expect(g.nodes.every((n) => n.gridCoord)).toBe(true)
-  })
-
-  it('leaves a parent that is already aligned in place', () => {
-    const g = layout(`graph TD${frame}\nX-->A\nZ\nW-->Y\nY-->A`, 'TD')
-    expect(grid(g, 'W').x).toBe(grid(g, 'Y').x)
-    expect(grid(g, 'W').y).toBeLessThan(grid(g, 'Y').y)
-  })
-})