…
`
    instead of bare ``.
  - The `_pre_stash` regex at static/ui.js:1914 matched only literal ``
    with NO attributes (`[\\s\\S]*?<\\/pre>`).
  - `` doesn't match → falls through to the
    paragraph wrap pass which replaces `\\n` with `
`.
  - By the time Prism runs and the CSS rule applies, the `\\n` characters
    that the rule was meant to preserve are already gone.

Same bug affects:
  - `lang === 'yaml'` (issue #1463 / #1618 — the canonical case)
  - `lang === 'json'` (same code path at static/ui.js:1621)
  - `lang === 'diff'` / `lang === 'patch'` (``,
    same shape, same regex miss — emits at static/ui.js:1619)

Fix: relax the `_pre_stash` regex to accept any attribute on ``:
    `[\\s\\S]*?<\\/pre>`  →  `]*>[\\s\\S]*?<\\/pre>`

These tests pin both the source-level invariant (regex shape) and the
end-to-end behavior via a node-driver that exercises the actual
static/ui.js renderMd() function.
"""

import shutil
import subprocess
from pathlib import Path

import pytest


REPO_ROOT = Path(__file__).parent.parent.resolve()
UI_JS_PATH = REPO_ROOT / "static" / "ui.js"
NODE = shutil.which("node")


# ─────────────────────────────────────────────────────────────────────────
# § A — Source-string invariants (run without node, fast)
# ─────────────────────────────────────────────────────────────────────────


def test_pre_stash_regex_matches_pre_with_attributes():
    """static/ui.js _pre_stash regex must match  with ANY attributes.

    The narrow shape `[\\s\\S]*?<\\/pre>` (literal  with no
    attributes) misses every  emitted by the JSON/YAML
    tree-viewer pass and the diff/patch coloring pass — those blocks fall
    through to paragraph wrap, which converts \\n to 
.
    """
    src = UI_JS_PATH.read_text(encoding="utf-8")

    # The fix introduces `]*>` (any attributes) in the _pre_stash regex.
    # The exact regex line is documented in static/ui.js:1914.
    assert "]*>[\\s\\S]*?<\\/pre>" in src, (
        "_pre_stash regex must use ]*> to match  with any attributes "
        "(#1463/#1618). The narrow shape [\\s\\S]*?<\\/pre> misses every "
        " from the JSON/YAML tree-viewer (PR #484) "
        "and  from diff/patch — newlines inside those "
        "blocks fall through to paragraph wrap and become 
 tags."
    )

    # Defense against accidental regression: the literal-only shape must NOT
    # be present anywhere in the _pre_stash region of the file.
    pre_stash_idx = src.find("const _pre_stash=[]")
    assert pre_stash_idx > 0, "_pre_stash declaration not found"
    pre_stash_line = src[pre_stash_idx:pre_stash_idx + 1500]
    assert "[\\s\\S]*?<\\/pre>" not in pre_stash_line, (
        "_pre_stash regex must not contain the literal--only shape — "
        "use ]*> to match attributes."
    )


def test_pre_stash_still_captures_pre_header_and_optional_div():
    """The fix must keep the rest of the _pre_stash regex intact —
    specifically the optional  prefix and the
    mermaid-block / katex-block alternation."""
    src = UI_JS_PATH.read_text(encoding="utf-8")

    pre_stash_idx = src.find("const _pre_stash=[]")
    pre_stash_block = src[pre_stash_idx:pre_stash_idx + 1500]

    assert '([\\s\\S]*?<\\/div>)?]*>' in pre_stash_block, (
        "Optional  prefix must still precede the "
        "]*> match"
    )
    assert ' $({ innerHTML: '', textContent: '' }) }; const esc = s => String(s ?? '').replace(/[&<>"']/g, c => ( {'&':'&','<':'<','>':'>','"':'"',"'":'''}[c])); const _IMAGE_EXTS=/\.(png|jpg|jpeg|gif|webp|bmp|ico|avif)$/i; const _SVG_EXTS=/\.svg$/i; const _AUDIO_EXTS=/\.(mp3|ogg|wav|m4a|aac|flac|wma|opus|webm)$/i; const _VIDEO_EXTS=/\.(mp4|webm|mkv|mov|avi|ogv|m4v)$/i; function extractFunc(name) { const re = new RegExp('function\\s+' + name + '\\s*\\('); const start = src.search(re); if (start < 0) throw new Error(name + ' not found'); let i = src.indexOf('{', start); let depth = 1; i++; while (depth > 0 && i < src.length) { if (src[i] === '{') depth++; else if (src[i] === '}') depth--; i++; } return src.slice(start, i); } eval(extractFunc('_matchBacktickFenceLine')); eval(extractFunc('_isBacktickFenceClose')); eval(extractFunc('renderMd')); let buf = ''; process.stdin.on('data', c => { buf += c; }); process.stdin.on('end', () => { process.stdout.write(renderMd(buf)); }); """ @pytest.fixture(scope="module") def driver_path(tmp_path_factory): p = tmp_path_factory.mktemp("issue1618_driver") / "driver.js" p.write_text(_DRIVER_SRC, encoding="utf-8") return str(p) def _render(driver_path, markdown: str) -> str: """Run renderMd against the actual ui.js and return the rendered HTML.""" result = subprocess.run( [NODE, driver_path, str(UI_JS_PATH)], input=markdown, capture_output=True, text=True, timeout=10, ) if result.returncode != 0: raise RuntimeError(f"node driver failed: {result.stderr}") return result.stdout def _extract_pre_inner(html: str) -> str: """Extract the content of the first ... block.""" import re m = re.search(r"]*>([\s\S]*?)$ ", html)
    if not m:
        return ""
    return m.group(1)


# ── The core regression: YAML newlines must survive ────────────────────


@pytestmark_node
def test_yaml_block_preserves_newlines(driver_path):
    """YAML code blocks must render multi-line, not flatten to a single line.

    This is the exact symptom Zixim reported on #1618: a YAML block renders
    with all newlines collapsed to spaces. The fix is the relaxed _pre_stash
    regex; without it, the block falls through to paragraph wrap and \\n
    becomes 
 inside , which Prism then can't recover from.
    """
    md = "```yaml\nfoo:\n  bar: 1\n  baz:\n    - 2\n    - 3\n```"
    out = _render(driver_path, md)

    # The block must end up wrapped in code-tree-wrap (PR #484's shape)
    assert "code-tree-wrap" in out, (
        "YAML blocks should still route through the tree-viewer wrapper"
    )

    # Inner ... must contain literal \n characters (preserved
    # newlines), NOT 
 tags.
    pre_inner = _extract_pre_inner(out)
    assert pre_inner, f"No  block found in rendered output: {out!r}"
    assert "\n" in pre_inner, (
        f"YAML  block lost its newlines (#1463/#1618).  "
        f" inner content: {pre_inner!r}.  "
        f"Likely cause: _pre_stash regex doesn't match , "
        f"so the block falls through to the paragraph wrap pass which converts \\n to 
."
    )
    assert "
" not in pre_inner, (
        f"YAML  block contains 
 tags — newlines were converted by paragraph "
        f"wrap.  This means the _pre_stash regex did not capture the block.  "
        f" inner content: {pre_inner!r}"
    )


@pytestmark_node
def test_json_block_preserves_newlines(driver_path):
    """JSON code blocks have the same shape as YAML (PR #484) and must also
    preserve newlines."""
    md = '```json\n{\n  "a": 1,\n  "b": [2, 3]\n}\n```'
    out = _render(driver_path, md)

    assert "code-tree-wrap" in out
    pre_inner = _extract_pre_inner(out)
    assert pre_inner
    assert "\n" in pre_inner, (
        f"JSON  block lost newlines.  Inner: {pre_inner!r}"
    )
    assert "
" not in pre_inner


@pytestmark_node
def test_diff_block_preserves_newlines(driver_path):
    """Diff/patch blocks emit  (static/ui.js:1619).
    Same regex-miss shape as YAML/JSON. Newlines must survive."""
    md = "```diff\n-removed line\n+added line\n unchanged\n```"
    out = _render(driver_path, md)

    assert "diff-block" in out
    pre_inner = _extract_pre_inner(out)
    assert pre_inner
    assert "\n" in pre_inner, (
        f"Diff  block lost newlines.  Inner: {pre_inner!r}"
    )
    assert "
" not in pre_inner


@pytestmark_node
def test_yml_alias_already_worked_still_works(driver_path):
    """Sanity check: ` ```yml ` (the Prism alias) renders bare  and
    was never affected by the bug. This must continue to work after the
    regex relaxation."""
    md = "```yml\nfoo:\n  bar: 1\n```"
    out = _render(driver_path, md)
    pre_inner = _extract_pre_inner(out)
    assert "\n" in pre_inner
    assert "
" not in pre_inner


@pytestmark_node
def test_bash_block_unaffected_baseline(driver_path):
    """Sanity: bash blocks emit bare  and were never affected by the bug.
    They must continue to render correctly post-fix."""
    md = "```bash\necho one\necho two\n```"
    out = _render(driver_path, md)
    pre_inner = _extract_pre_inner(out)
    assert "\n" in pre_inner
    assert "
" not in pre_inner


# ── End-to-end Zixim-scenario reproducer ───────────────────────────────


@pytestmark_node
def test_yaml_block_renders_multiline_html_shape(driver_path):
    """The specific shape Zixim reported: 5-line YAML block must produce
    exactly 5 newline-separated logical lines in the  inner content.

    Pre-fix this collapsed to a single space-joined string. Post-fix the
    line count should equal the original input line count.
    """
    md = "```yaml\nname: hermes\nport: 8787\nfeatures:\n  - chat\n  - tasks\n```"
    out = _render(driver_path, md)

    pre_inner = _extract_pre_inner(out)
    # Split on \n to count rendered lines. Empty trailing line tolerated.
    rendered_lines = [l for l in pre_inner.split("\n") if l.strip()]

    assert len(rendered_lines) == 5, (
        f"YAML block should preserve 5 lines, got {len(rendered_lines)}: {rendered_lines}.  "
        f"Full  inner content: {pre_inner!r}"
    )


# ── Mermaid/katex blocks unaffected ────────────────────────────────────


@pytestmark_node
def test_mermaid_block_unaffected_by_regex_relaxation(driver_path):
    """Mermaid blocks come through a different alternation in the same regex
    (` $(no). assert "mermaid-block" in out # The mermaid div should not be wrapped in ... . assert " " not in out or out.find(" ") > out.find("mermaid-block"), ( "Mermaid block should bypass paragraph wrap" )$