buninu 0.6.0 → 0.7.0

package/apps/jsmdcui/src/highlight/go-regexp.js

@@ -0,0 +1,83 @@
+// Adapt Go regexp syntax without changing the upstream syntax definitions.
+// Scoped JS modifiers preserve flag changes across alternatives, but not out
+// of their enclosing group. They add no capturing groups. Modifiers are only
+// emitted where flags differ from those in effect, so flag-free patterns
+// do not depend on engine support for them.
+export function convertGoRegexp(pattern) {
+  const source = String(pattern);
+  if (!/\(\?[ims-]|\[\^?\]|\(\?P<|\[:[a-z]+:\]/.test(source)) return source;
+  let i = 0;
+  function expression(inherited, active, nested = false, depth = 0) {
+    // Bound syntax-rule recursion, not the length of text being highlighted.
+    if (depth > 256) throw new RangeError('Go regexp nesting exceeds 256 groups');
+    const flags = new Set(inherited);
+    let output = '', wrapped = false;
+    function open() {
+      const on = 'ims'.split('').filter(f => flags.has(f) && !active.has(f)).join('');
+      const off = 'ims'.split('').filter(f => !flags.has(f) && active.has(f)).join('');
+      if (!on && !off) return;
+      output += `(?${on}${off ? '-' + off : ''}:`;
+      wrapped = true;
+    }
+    function close() { if (wrapped) output += ')'; wrapped = false; }
+    while (i < source.length) {
+      const ch = source[i];
+      if (ch === ')' && nested) { i++; close(); return output; }
+      if (ch === '|') { close(); output += '|'; i++; continue; }
+      const directive = ch === '(' && source.slice(i).match(/^\(\?([ims]*)(?:-([ims]+))?\)/);
+      if (directive && (directive[1] || directive[2])) {
+        close();
+        for (const f of directive[1]) flags.add(f);
+        for (const f of directive[2] || '') flags.delete(f);
+        i += directive[0].length;
+        continue;
+      }
+      if (!wrapped) open();
+      if (ch === '\\') { output += source.slice(i, i + 2); i += 2; continue; }
+      if (ch === '[') {
+        output += source[i++];
+        if (source[i] === '^') output += source[i++];
+        // Go permits a literal ] as the first member of a character class.
+        if (source[i] === ']') { output += '\\]'; i++; }
+        while (i < source.length) {
+          const posix = source.slice(i).match(/^\[:([a-z]+):\]/);
+          if (posix && POSIX_CLASSES[posix[1]] !== undefined) {
+            output += POSIX_CLASSES[posix[1]]; i += posix[0].length; continue;
+          }
+          const c = source[i++]; output += c;
+          if (c === '\\' && i < source.length) output += source[i++];
+          else if (c === ']') break;
+        }
+        continue;
+      }
+      if (ch === '(') {
+        const scoped = source.slice(i).match(/^\(\?([ims]*)(?:-([ims]+))?:/);
+        const childFlags = new Set(flags);
+        if (scoped) {
+          for (const f of scoped[1]) childFlags.add(f);
+          for (const f of scoped[2] || '') childFlags.delete(f);
+          output += '(?:'; i += scoped[0].length;
+        } else {
+          const prefix = source.slice(i).match(/^\(\?(?:[:=!]|<[=!]|<[^>]+>|P<[^>]+>)/);
+          output += prefix ? prefix[0].replace('(?P<', '(?<') : '(';
+          i += prefix ? prefix[0].length : 1;
+        }
+        output += expression(childFlags, flags, true, depth + 1) + ')';
+        continue;
+      }
+      output += ch; i++;
+    }
+    close();
+    return output;
+  }
+  return expression(new Set(), new Set());
+}
+
+// Class contents, not nested [...] expressions: e.g. [[:alnum:]._-].
+const POSIX_CLASSES = {
+  alnum: 'A-Za-z0-9', alpha: 'A-Za-z', ascii: '\\x00-\\x7F',
+  blank: ' \\t', cntrl: '\\x00-\\x1F\\x7F', digit: '0-9',
+  graph: '!-~', lower: 'a-z', print: ' -~',
+  punct: '!-/:-@\\[-`{-~', space: '\\t\\n\\v\\f\\r ',
+  upper: 'A-Z', word: 'A-Za-z0-9_', xdigit: 'A-Fa-f0-9',
+};

package/apps/jsmdcui/src/highlight/highlighter.js

@@ -8,9 +8,7 @@ export class Highlighter {
   highlightLine(line, state = null, progress = null) {
     const text = String(line);
     const changes = new Map([[0, state?.group ?? "default"]]);
-    const nextState = state
-      ? scanRegion(changes, text, 0, state, this.rules, progress)
-      : scanTop(changes, text, 0, this.rules, progress);
+    const nextState = scanLine(changes, text, state, this.rules, progress);
     return {
       changes: normalizeChanges(changes, text.length),
       state: nextState,
@@ -29,16 +27,18 @@ export class Highlighter {
   }
 }
 
-export function resolveRules(rules, definitions, seen) {
+export function resolveRules(rules, definitions, seen, ancestors = new Set()) {
+  if (ancestors.has(rules) || ancestors.size >= 128) return [];
+  const path = new Set(ancestors); path.add(rules);
   const out = [];
   for (const rule of rules) {
     if (rule.type === "include") {
       if (seen.has(rule.include)) continue;
       seen.add(rule.include);
       const def = definitions.find((candidate) => candidate.filetype === rule.include);
-      if (def) out.push(...resolveRules(def.rules, definitions, seen));
+      if (def) out.push(...resolveRules(def.rules, definitions, seen, path));
     } else if (rule.type === "region") {
-      out.push({ ...rule, rules: resolveRules(rule.rules ?? [], definitions, new Set(seen)) });
+      out.push({ ...rule, rules: resolveRules(rule.rules ?? [], definitions, new Set(seen), path) });
     } else {
       out.push(rule);
     }
@@ -53,67 +53,67 @@ export function flattenRules(rules, definitions, seen) {
   });
 }
 
-function scanTop(changes, line, pos, rules, progress = null) {
-  let cursor = pos;
+// Iterative state machine: adjacent tokens on a minified line must not consume
+// call-stack depth. A state repeated at an unchanged position steps forward.
+function scanLine(changes, line, region, rootRules, progress) {
+  let cursor = 0, previous = -1;
+  const visited = new Set();
+  const parents = new Set();
+  for (let r = region; r; r = r.parent) {
+    if (parents.has(r) || parents.size >= 128) { region = null; changes.set(0, "default"); break; }
+    parents.add(r);
+  }
   while (cursor <= line.length) {
-    progress?.(cursor);
-    const regionStart = findFirstRegion(rules, line, cursor, progress);
-    if (!regionStart) {
-      applyPatterns(changes, line, cursor, line.length, rules, "default", progress);
-      changes.set(line.length, "default");
-      progress?.(line.length);
+    if (cursor !== previous) { visited.clear(); previous = cursor; }
+    if (visited.has(region)) {
+      // A zero-width child can end and reopen forever at the same position.
+      // Skip one character in the current region, like a zero-width match.
+      cursor = advanceIndex(line, cursor);
+      continue;
+    }
+    if (visited.size >= 256) {
+      // Fresh object states from malformed externally supplied trees.
+      // Discard this line's unfinished region; do not poison subsequent lines.
+      changes.set(cursor, "default"); changes.set(line.length, "default");
       return null;
     }
-
-    applyPatterns(changes, line, cursor, regionStart.start, rules, "default", progress);
-    changes.set(regionStart.start, regionStart.region.limitGroup ?? "default");
-    changes.set(regionStart.end, regionStart.region.group);
-    progress?.(regionStart.end);
-
-    const state = scanRegion(changes, line, regionStart.end, regionStart.region, rules, progress);
-    if (state) return state;
-    return null;
-  }
-  return null;
-}
-
-function scanRegion(changes, line, pos, region, rootRules, progress = null) {
-  let cursor = pos;
-  const rules = region.rules ?? [];
-  while (cursor <= line.length) {
+    visited.add(region);
     progress?.(cursor);
-    const end = findMatch(region.end, line, cursor, region.skip, progress);
+    const rules = region?.rules ?? rootRules;
+    const end = region ? findMatch(region.end, line, cursor, region.skip, progress) : null;
     const nested = findFirstRegion(rules, line, cursor, progress);
-
     if (end && (!nested || end.start <= nested.start)) {
       applyPatterns(changes, line, cursor, end.start, rules, region.group, progress);
       changes.set(end.start, region.limitGroup ?? region.group);
       changes.set(end.end, parentGroup(region));
       progress?.(end.end);
-      if (region.parent) return scanRegion(changes, line, end.end, region.parent, rootRules, progress);
-      return scanTop(changes, line, Math.max(end.end, end.start + 1), rootRules, progress);
+      const parent = region.parent ?? null;
+      cursor = parent ? end.end : Math.max(end.end, advanceIndex(line, end.start));
+      region = parent;
+      continue;
     }
-
     if (nested) {
-      applyPatterns(changes, line, cursor, nested.start, rules, region.group, progress);
-      changes.set(nested.start, nested.region.limitGroup ?? region.group);
-      const child = { ...nested.region, parent: region };
-      changes.set(nested.end, child.group);
+      applyPatterns(changes, line, cursor, nested.start, rules, region?.group ?? "default", progress);
+      changes.set(nested.start, nested.region.limitGroup ?? nested.region.group);
+      region = region ? { ...nested.region, parent: region } : nested.region;
+      changes.set(nested.end, region.group);
       progress?.(nested.end);
-      const state = scanRegion(changes, line, nested.end, child, rootRules, progress);
-      if (state) return state;
-      cursor = Math.max(nested.end + 1, nextChangeAfter(changes, nested.end));
+      cursor = nested.end;
       continue;
     }
-
-    applyPatterns(changes, line, cursor, line.length, rules, region.group, progress);
-    changes.set(line.length, region.group);
+    applyPatterns(changes, line, cursor, line.length, rules, region?.group ?? "default", progress);
+    changes.set(line.length, region?.group ?? "default");
     progress?.(line.length);
     return region;
   }
   return region;
 }
 
+// AdvanceStringIndex for Unicode regexps, including isolated surrogate units.
+function advanceIndex(text, index) {
+  return index + (text.codePointAt(index) > 0xFFFF ? 2 : 1);
+}
+
 function applyPatterns(changes, line, start, end, rules, fallbackGroup, progress = null) {
   if (end < start) return;
   const length = end - start;
@@ -161,18 +161,12 @@ function findMatch(regex, line, pos, skip, progress = null) {
   const global = globalize(regex);
   global.lastIndex = pos;
   let match;
-  if (!progress) {
-    match = global.exec(masked);
-    if (!match) return null;
-    const start = match.index ?? 0;
-    return { start, end: start + match[0].length };
-  }
   while ((match = global.exec(masked)) !== null) {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     progress?.(start);
     if (start >= pos) return { start, end };
-    if (match[0].length === 0) global.lastIndex++;
+    global.lastIndex = Math.max(global.lastIndex, advanceIndex(masked, start));
   }
   progress?.(line.length);
   return null;
@@ -189,7 +183,7 @@ function findAllMatches(regex, line, start, end, progress = null) {
       if (matchStart >= end) break;
       const matchEnd = matchStart + match[0].length;
       if (match[0].length === 0) {
-        global.lastIndex++;
+        global.lastIndex = advanceIndex(line, matchStart);
         continue;
       }
       if (matchEnd > start) out.push({ start: Math.max(matchStart, start), end: Math.min(matchEnd, end) });
@@ -202,7 +196,7 @@ function findAllMatches(regex, line, start, end, progress = null) {
     if (matchStart >= end) break;
     progress?.(matchStart);
     if (match[0].length === 0) {
-      global.lastIndex++;
+      global.lastIndex = advanceIndex(line, matchStart);
       continue;
     }
     if (matchEnd <= start || matchStart >= end) continue;
@@ -229,13 +223,6 @@ function parentGroup(region) {
   return region.parent?.group ?? "default";
 }
 
-function nextChangeAfter(changes, index) {
-  for (const key of [...changes.keys()].sort((a, b) => a - b)) {
-    if (key > index) return key;
-  }
-  return index + 1;
-}
-
 function globalize(regex) {
   const flags = new Set(regex.flags.split(""));
   flags.add("g");

package/apps/jsmdcui/src/highlight/parser.js

@@ -1,4 +1,5 @@
 import { basename } from "node:path";
+import { convertGoRegexp } from "./go-regexp.js";
 
 export class SyntaxHeader {
   constructor({ filetype = "", filename = "", header = "", signature = "" } = {}) {
@@ -195,15 +196,17 @@ function parseRule(rule) {
 
 function compileRegex(pattern) {
   if (!pattern) return null;
-  const translated = translateGoRegexp(pattern);
   try {
-    return new RegExp(translated, "u");
-  } catch {
+    // Conversion may reject an excessively nested rule. Keep that failure
+    // local to this regexp rather than dropping the entire syntax definition.
+    const translated = convertGoRegexp(translateGoRegexp(pattern));
     try {
-      return new RegExp(translated);
+      return new RegExp(translated, "u");
     } catch {
-      return null;
+      return new RegExp(translated);
     }
+  } catch {
+    return null;
   }
 }
 

package/apps/jsmdcui/tests/go-regexp.test.js

@@ -0,0 +1,98 @@
+import {test, expect} from 'bun:test';
+import {convertGoRegexp} from '../src/highlight/go-regexp.js';
+import {SyntaxDefinition,parseHeaderYaml} from '../src/highlight/parser.js';
+const regex = s => new RegExp(convertGoRegexp(s), 'u');
+test('Go flags apply to the remaining alternatives, preserving precedence', () => {
+  const r = regex('^a(?i)b$|^c$');
+  expect(r.test('aB')).toBe(true);
+  expect(r.test('AB')).toBe(false);
+  expect(r.test('C')).toBe(true);
+  expect(r.test('aC')).toBe(false);
+});
+test('flag changes stay inside groups and can be disabled', () => {
+  const r = regex('^(a(?i)b|c)d$');
+  expect(r.test('aBd')).toBe(true);
+  expect(r.test('Cd')).toBe(true);
+  expect(r.test('CD')).toBe(false);
+  expect(regex('^(?i)a(?-i)b$').test('Ab')).toBe(true);
+  expect(regex('^(?i)a(?-i)b$').test('AB')).toBe(false);
+  expect(regex('^(?i:a(?-i:b))c$').test('Abc')).toBe(true);
+  expect(regex('^(?i:a(?-i:b))c$').test('ABC')).toBe(false);
+});
+test('capture numbers, scoped flags, escaped literals and class brackets survive', () => {
+  expect(regex('^(?i)(a)(b)$').exec('AB').slice(1)).toEqual(['A','B']);
+  expect(regex('(?i:a)+').test('AAA')).toBe(true);
+  expect(regex('\\(\\?i\\)').test('(?i)')).toBe(true);
+  const url = regex('(https?|ftp|ssh)://\\S*[^])>\\s,.]');
+  expect(url.exec('https://example.com)')[0]).toBe('https://example.com');
+  expect(regex('(?s)^a.b$').test('a\nb')).toBe(true);
+  expect(regex('(?m)^b$').test('a\nb\nc')).toBe(true);
+  expect(convertGoRegexp('\\bword\\b')).toBe('\\bword\\b');
+});
+test('all bundled syntax regexes compile, and Dockerfile keywords match', async () => {
+  const root = new URL('../runtime/syntax/', import.meta.url).pathname;
+  const failures = [];
+  function walk(rules, file) {
+    for (const r of rules) {
+      if (r.type === 'pattern' && !r.regex) failures.push(file+': '+r.source);
+      if (r.type === 'region') {
+        for (const k of ['start','end','skip']) if (r.source[k] && !r[k]) failures.push(file+': '+r.source[k]);
+        walk(r.rules,file);
+      }
+    }
+  }
+  for await (const file of new Bun.Glob('*.yaml').scan(root)) {
+    const source = Bun.YAML.parse(await Bun.file(root+'/'+file).text());
+    const header = parseHeaderYaml(source);
+    for (const [key,re] of [['filename','fileNameRegex'],['header','headerRegex'],['signature','signatureRegex']])
+      if (header[key] && !header[re]) failures.push(file+': '+key);
+    const def = new SyntaxDefinition(header,source);
+    walk(def.rules,file);
+    if (file === 'dockerfile.yaml') {
+      expect(header.matchFileName('/tmp/Dockerfile')).toBe(true);
+      const keyword = def.rules.find(r=>r.group==='type.keyword').regex;
+      for (const line of ['FROM debian','run echo hi','COPY . /app']) expect(keyword.test(line)).toBe(true);
+      expect(keyword.test('FROMAGE debian')).toBe(false);
+    }
+  }
+  expect(failures).toEqual([]);
+});
+test('mixed and negated POSIX classes retain ASCII Go semantics',()=>{
+ expect(regex('^[[:alnum:].%_+-]+@[[:alnum:].-]+$').test('a.b+tag@example.com')).toBe(true);
+ expect(regex('^[^[:space:]]+:$').test('Subject:')).toBe(true);
+ expect(regex('^[^[:space:]]+:$').test('Bad Header:')).toBe(false);
+ expect(regex('^[{[:space:]]-block([[:space:]{}]|$)').test(' -block ')).toBe(true);
+ expect(regex('^[x[:space:]]$').test('\t')).toBe(true);
+ expect(regex('^[x[:space:]]$').test('\u00a0')).toBe(false);
+ expect(regex('^[x[:punct:]]$').test('[')).toBe(true);
+ expect(regex('^[x[:punct:]]$').test('A')).toBe(false);
+});
+test('modifiers are emitted only where flags change',()=>{
+ expect(convertGoRegexp('[]a]')).toBe('[\\]a]');
+ expect(convertGoRegexp('(?P<x>a)')).toBe('(?<x>a)');
+ expect(convertGoRegexp('[[:alpha:]_]')).toBe('[A-Za-z_]');
+ expect(convertGoRegexp('(?i)\\b(select|from)\\b')).toBe('(?i:\\b(select|from)\\b)');
+ expect(regex('^(?i)a(?-i:b)$').test('Ab')).toBe(true);
+ expect(regex('^(?i)a(?-i:b)$').test('AB')).toBe(false);
+});
+
+test('converter bounds nested groups without limiting adjacent groups',()=>{
+ expect(()=>convertGoRegexp('(?i)'+'('.repeat(50000)+'x'+')'.repeat(50000))).toThrow('nesting exceeds');
+ expect(regex('(?i)'+'('.repeat(256)+'x'+')'.repeat(256)).test('X')).toBe(true);
+ expect(()=>convertGoRegexp('(?i)'+'(x)'.repeat(50000))).not.toThrow();
+});
+
+test('conversion failure disables only its rule and preserves the loaded syntax',async()=>{
+ const {loadSyntaxDefinitions}=await import('../src/highlight/parser.js');
+ const {Highlighter}=await import('../src/highlight/highlighter.js');
+ const deep='(?i)'+'('.repeat(50000)+'x'+')'.repeat(50000);
+ const source={filetype:'guarded',detect:{filename:'\\.guarded$'},rules:[{bad:deep},{keyword:'(?i)hello'},{invalid:'['}]};
+ const def=new SyntaxDefinition(parseHeaderYaml(source),source);
+ expect(def.rules[0].regex).toBeNull();expect(def.rules[2].regex).toBeNull();
+ expect(def.rules[1].regex.test('HELLO')).toBe(true);
+ const runtime={list:type=>type===1?[{name:'guarded',text:async()=>JSON.stringify(source)}]:[]};
+ const defs=await loadSyntaxDefinitions(runtime);
+ expect(defs.map(d=>d.filetype)).toEqual(['guarded']);
+ expect(defs[0].header.matchFileName('example.guarded')).toBe(true);
+ expect(new Highlighter(defs[0],defs).highlightLine('HELLO').changes.get(0)).toBe('keyword');
+});

package/apps/jsmdcui/tests/heading-ids.test.js

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test";
+import { escapesSlashTags } from "./markdown-behavior.mjs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -347,23 +348,27 @@ test("raw heading markers do not change quoted attribute parsing", () => {
   expect(rendered.html).toContain('<h1 id="中文-1">中文</h1>');
 });
 
-test("raw heading markers preserve slash-separated HTML attributes", () => {
-  const markdown = `<h1/id=中文>Raw</h1>
-
-# 中文
-`;
-  expect(collectRawHtmlHeadingDeclarations(markdown)).toEqual([
-    {
-      id: "中文",
-      kind: "raw HTML heading",
-      line: 1,
-      source: "<h1/id=中文>Raw</h1>",
-    },
+test("raw heading markers follow Bun's slash-separated HTML behavior", () => {
+  const markdown = "<h1/id=中文>Raw</h1>\n\n# 中文\n";
+  expect(collectRawHtmlHeadingDeclarations(markdown)).toEqual(escapesSlashTags ? [] : [
+    { id: "中文", kind: "raw HTML heading", line: 1, source: "<h1/id=中文>Raw</h1>" },
   ]);
   const rendered = renderMarkdownWithHeadingIds(markdown);
-  expect(rendered.headings.map(heading => heading.id)).toEqual(["中文-1"]);
-  expect(rendered.html).toContain("<h1/id=中文>Raw</h1>");
-  expect(rendered.html).toContain('<h1 id="中文-1">中文</h1>');
+  const id = escapesSlashTags ? "中文" : "中文-1";
+  expect(rendered.normalized).toBe(true);
+  expect(rendered.headings.map(heading => heading.id)).toEqual([id]);
+  expect(rendered.html).toContain(escapesSlashTags
+    ? "<p>&lt;h1/id=中文&gt;Raw</h1></p>"
+    : "<h1/id=中文>Raw</h1>");
+  expect(rendered.html).toContain(`<h1 id="${id}">中文</h1>`);
+});
+
+test("slash-tag ambiguity follows Bun's actual Markdown output", () => {
+  const rendered = renderMarkdownWithHeadingIds('<div/a< x=">TAIL\n\n# 中文\n');
+  expect(rendered.normalized).toBe(escapesSlashTags);
+  expect(rendered.headings.map(heading => heading.id)).toEqual(escapesSlashTags ? ["中文"] : []);
+  expect(rendered.html).toContain(escapesSlashTags
+    ? '<h1 id="中文">中文</h1>' : '<h1 id="">中文</h1>');
 });
 
 test("self-closing inline headings cannot suppress other raw collisions", () => {
@@ -511,7 +516,7 @@ test("quoted tag delimiters preserve raw IDs and Markdown heading metadata", ()
 });
 
 test("browser alignment failures never fall back to lexical heading rewrites", () => {
-  const markdown = '<div/a< x=">TAIL\n\n# 中文\n';
+  const markdown = '<div x=">TAIL\n\n# 中文\n';
   const rendered = renderMarkdownWithHeadingIds(markdown);
   expect(rendered.normalized).toBe(false);
   expect(rendered.headings).toEqual([]);

package/apps/jsmdcui/tests/highlight-regions.test.js

@@ -0,0 +1,73 @@
+import {test,expect} from 'bun:test';
+import {SyntaxDefinition,parseHeaderYaml} from '../src/highlight/parser.js';
+import {Highlighter} from '../src/highlight/highlighter.js';
+async function highlighter(name){
+ const source=Bun.YAML.parse(await Bun.file(new URL('../runtime/syntax/'+name+'.yaml',import.meta.url)).text());
+ return new Highlighter(new SyntaxDefinition(parseHeaderYaml(source),source));
+}
+function groupAt(result,index){let group='default';for(const [pos,value]of result.changes){if(pos>index)break;group=value;}return group;}
+for(const [syntax,first]of [['html','<div class="hello">Hello</div>'],['xml','<Project Sdk="Microsoft.NET.Sdk">']]){
+ test(syntax+' nested attribute returns to outer tag and does not leak to next line',async()=>{
+  const h=await highlighter(syntax),r=h.highlightLine(first);
+  expect(r.state).toBeNull();
+  expect(groupAt(r,first.indexOf('>'))).toBe('symbol.tag');
+  const next=h.highlightLine('<p>Next line</p>',r.state);
+  expect(groupAt(next,3)).toBe('default');
+  expect(next.state).toBeNull();
+  expect([...r.changes.keys()].every(p=>p<=first.length)).toBe(true);
+ });
+ test(syntax+' retains an unfinished attribute across lines then exits it',async()=>{
+  const h=await highlighter(syntax);
+  const a=h.highlightLine('<div title="first');expect(a.state?.group).toBe('constant.string');
+  const b=h.highlightLine('second">Text</div>',a.state);
+  expect(groupAt(b,0)).toBe('constant.string');
+  expect(groupAt(b,8)).toBe('default');expect(b.state).toBeNull();
+ });
+}
+test('HTML multiple attributes, adjacent tags and nested escaped quotes',async()=>{
+ const h=await highlighter('html');
+ const line='<a href="/path" title="say \\"hi\\"">Link</a><b>next</b>';
+ const r=h.highlightLine(line);
+ expect(r.state).toBeNull();expect(groupAt(r,line.indexOf('Link'))).toBe('default');
+ expect(groupAt(r,line.indexOf('next'))).toBe('default');
+});
+test('zero-width child/parent loop steps forward and keeps highlighting the line',()=>{
+ const h=new Highlighter({rules:[{type:'region',group:'outer',start:/</u,end:/>/u,rules:[{type:'region',group:'inner',start:/(?=x)/u,end:/(?=x)/u,rules:[]}]},{type:'pattern',group:'keyword',regex:/END/u}]});
+ let calls=0;const line='<x>END';const r=h.highlightLine(line,null,()=>{if(++calls>100)throw Error('loop');});
+ expect(r.state).toBeNull();expect(calls).toBeLessThan(100);
+ expect(groupAt(r,1)).toBe('outer');expect(groupAt(r,line.indexOf('END'))).toBe('keyword');
+});
+test('empty pattern matches advance past full Unicode characters, with or without progress',()=>{
+ const h=new Highlighter({rules:[{type:'pattern',group:'empty',regex:/(?=.)/u},{type:'pattern',group:'number',regex:/42/u}]});
+ for(const progress of [null,()=>{}]){
+  const r=h.highlightLine('😀\0\ud80042',null,progress);
+  expect(groupAt(r,4)).toBe('number');expect(r.state).toBeNull();
+ }
+});
+test('NUL and isolated surrogate units inside HTML do not leak state',async()=>{
+ const h=await highlighter('html');
+ const r=h.highlightLine('<a title="\0😀\ud800">hello\0\udc00</a>');
+ expect(r.state).toBeNull();
+ expect(h.highlightLine('\0'.repeat(10000)).state).toBeNull();
+});
+test('long lines finish at their final token without recursion or truncation',()=>{
+ const h=new Highlighter({rules:[{type:'region',group:'string',start:/"/u,end:/"/u,rules:[]},{type:'pattern',group:'keyword',regex:/END/u}]});
+ const line='"x";'.repeat(50000)+'END';
+ const r=h.highlightLine(line);
+ expect(r.state).toBeNull();expect(groupAt(r,line.length-1)).toBe('keyword');
+ expect([...r.changes.keys()].at(-1)).toBe(line.length);
+},30000);
+test('cyclic incoming state and cyclic syntax trees cannot recurse forever',()=>{
+ const region={type:'region',group:'cycle',start:/</u,end:/>/u,rules:[]};region.rules.push(region);
+ const h=new Highlighter({rules:[region]});
+ expect(h.highlightLine('plain').state).toBeNull();
+ const state={group:'cycle',rules:[]};state.parent=state;
+ expect(h.highlightLine('plain',state).state).toBeNull();
+});
+test('externally supplied zero-width recursive state has a no-progress bound',()=>{
+ const child={type:'region',group:'inner',start:/(?=x)/u,end:/$/u,rules:[]};child.rules.push(child);
+ const state={group:'outer',end:/$/u,rules:[child]};
+ const h=new Highlighter({rules:[]});let calls=0;
+ const r=h.highlightLine('x',state,()=>{if(++calls>5000)throw Error('loop');});
+ expect(r.state).toBeNull();expect(calls).toBeLessThan(5000);
+});

package/apps/jsmdcui/tests/id-collision.test.js

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test";
+import { escapesSlashTags } from "./markdown-behavior.mjs";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -39,7 +40,7 @@ test("--check exits 0 and reports unique IDs", async () => {
 });
 
 test("--check fails closed when browser heading parsing is ambiguous", async () => {
-  const result = await runCheck('<div/a< x=">TAIL\n\n# 中文\n');
+  const result = await runCheck('<div x=">TAIL\n\n# 中文\n');
   expect(result.exitCode).toBe(2);
   expect(result.stderr.toString()).toContain(
     "Markdown headings could not be classified safely",
@@ -359,15 +360,37 @@ test("--check ignores heading-looking text inside raw attributes", async () => {
   expect(output).toContain("FAILED");
 });
 
-test("--check preserves slash-separated raw heading attributes", async () => {
+test("--check follows Bun's slash-separated raw heading behavior", async () => {
   const result = await runCheck("<h1/id=中文>Raw</h1>\n\n# 中文\n");
   const output = Bun.stripANSI(result.stdout.toString());
-  expect(result.exitCode).toBe(1);
-  expect(output).toContain("ID #中文");
-  expect(output).toContain("Type: raw HTML heading");
-  expect(output).toContain("Type: heading");
-  expect(output).toContain("FAILED");
-});
+  expect(result.exitCode).toBe(escapesSlashTags ? 0 : 1);
+  if (escapesSlashTags) {
+    expect(output).toContain("Selectable IDs: 1");
+    expect(output).toContain("PASSED");
+    expect(output).not.toContain("Type: raw HTML heading");
+  } else {
+    expect(output).toContain("ID #中文");
+    expect(output).toContain("Type: raw HTML heading");
+    expect(output).toContain("Type: heading");
+    expect(output).toContain("FAILED");
+  }
+});
+
+for (const [command, run] of [["--check", runCheck], ["--outline", runOutline]]) {
+  test(`${command} follows Bun's slash-tag ambiguity behavior`, async () => {
+    const result = await run('<div/a< x=">TAIL\n\n# 中文\n');
+    expect(result.exitCode).toBe(escapesSlashTags ? 0 : 2);
+    if (escapesSlashTags) {
+      expect(result.stderr.toString()).toBe("");
+      if (command === "--check") expect(result.stdout.toString()).toContain("PASSED");
+      else expect(result.stdout.toString()).toContain("中文");
+    } else {
+      expect(result.stderr.toString()).toContain("Markdown headings could not be classified safely");
+      expect(result.stdout.toString()).not.toContain("PASSED");
+      if (command === "--outline") expect(result.stdout.toString()).toBe("");
+    }
+  });
+}
 
 test("--check ignores heading-like custom tag names", async () => {
   const result = await runCheck(
@@ -494,7 +517,7 @@ value
 });
 
 test("--outline fails closed when browser heading parsing is ambiguous", async () => {
-  const result = await runOutline('<div/a< x=">TAIL\n\n# 中文\n');
+  const result = await runOutline('<div x=">TAIL\n\n# 中文\n');
   expect(result.exitCode).toBe(2);
   expect(result.stderr.toString()).toContain(
     "Markdown headings could not be classified safely",

package/apps/jsmdcui/tests/markdown-behavior.mjs

@@ -0,0 +1,9 @@
+// Probe the parser, not Bun.version: canaries and backports can differ.
+// CommonMark allows `/` after a block tag name only as part of `/>`.
+const probe = Bun.markdown.html("<h1/id=x>Raw</h1>\n");
+const raw = "<h1/id=x>Raw</h1>\n";
+const escaped = "<p>&lt;h1/id=x&gt;Raw</h1></p>\n";
+if (probe !== raw && probe !== escaped) {
+  throw new Error(`Unexpected Bun Markdown slash-tag behavior: ${JSON.stringify(probe)}`);
+}
+export const escapesSlashTags = probe === escaped;