feat(micron): parity with micron-parser-js ce24ce4

Port upstream accessibility, field sizing, anchors and serif support:

- Parser.Accessibility: heading role/aria-level, divider separator,
  fold glyph and anchor aria-hidden, partial status roles, field
  aria-label, Mu-sr readable text next to monospace visual spans
- Parser.Serif: Mu-serif root class
- Field WxR flags render textarea with rows/cols
- Explicit `:name anchors and generated heading slug anchors
- Bare-# links resolve to the next heading slug (_resolveEmptyAnchors)
- FormatNomadnetworkURL keeps #-prefixed URLs unwrapped
- CRLF/CR input normalized to LF
- WASM convert accepts accessibility and serif args; libmicron exports
  micron_convert_opts
- Vendored reference JS bumped to upstream ce24ce4 with DOMPurify
  factory shim for the node harness and real purify.min.js for bench

Author: Sudo-Ivan

CHANGELOG.md

@@ -2,6 +2,32 @@
 
 Dates use YYYY-MM-DD.
 
+## [1.3.0] - 2026-09-17
+
+### Added
+
+- `Parser.Accessibility` option matching micron-parser-js `options.accessibility`. When enabled:
+  - Headings emit `role="heading"` and `aria-level` on the inner div.
+  - Dividers emit `role="separator"`.
+  - Fold glyphs and generated anchors emit `aria-hidden="true"`.
+  - Partial placeholders emit `role="status"`, `aria-live="polite"` and `aria-busy="true"`.
+  - Field inputs and textareas emit `aria-label` with the field name.
+  - Monospace per-segment visual spans are paired with `Mu-sr` readable text so screen readers see coherent words.
+- `Parser.Serif` option adds `Mu-serif` to the root element for serif rendering.
+- Field `WxR` flags: `` `<20x3|bio`text> `` renders a `<textarea rows="3" cols="20">` instead of an `<input>`.
+- Explicit `` `:name `` anchors emit `<a id="name" class="micron-anchor">`.
+- Headings emit a generated slug anchor `<a id="slug" class="micron-anchor micron-header-anchor">` before their content.
+- Links with a bare `#` destination keep `href="#"` and are rewritten to the first following heading slug, matching `_resolveEmptyAnchors`.
+- CRLF and CR input is normalized to LF before parsing.
+- WASM `convert` accepts optional accessibility and serif boolean arguments (4th and 5th).
+- `libmicron` exports `micron_convert_opts` accepting accessibility and serif flags.
+- Vendored reference JS updated to micron-parser-js `ce24ce4`; `web/static/vendor/dompurify.min.js` added since upstream now requires DOMPurify.
+- Added `micron/a11y_test.go` covering the new emit paths.
+
+### Changed
+
+- `FormatNomadnetworkURL` returns `#`-prefixed URLs unchanged instead of wrapping them in `nomadnetwork://`.
+
 ## [1.2.0] - 2026-09-10
 
 ### Added

README.md

@@ -29,6 +29,9 @@ p := micron.Parser{DarkTheme: true, ForceMonospace: true}
 html := p.ConvertMicronToHTML("> Title\n\nHello `!world`! and `*micron`*.\n")
 ```
 
+Optional flags: `Accessibility` emits heading/separator/partial roles, `aria-level`,
+`aria-label` and `Mu-sr` readable text. `Serif` adds `Mu-serif` to the root element.
+
 Parser is safe to reuse across goroutines. Related APIs:
 
 ```text

cmd/libmicron/main.go

@@ -40,6 +40,17 @@ func micron_convert(markup *C.char, darkTheme, forceMonospace C.int) *C.char {
 	return cString(p.ConvertMicronToHTML(goString(markup)))
 }
 
+//export micron_convert_opts
+func micron_convert_opts(markup *C.char, darkTheme, forceMonospace, accessibility, serif C.int) *C.char {
+	p := micron.Parser{
+		DarkTheme:      darkTheme != 0,
+		ForceMonospace: forceMonospace != 0,
+		Accessibility:  accessibility != 0,
+		Serif:          serif != 0,
+	}
+	return cString(p.ConvertMicronToHTML(goString(markup)))
+}
+
 //export micron_parse_header_tags
 func micron_parse_header_tags(markup *C.char) *C.char {
 	colors := micron.ParseHeaderTags(goString(markup))

cmd/wasm/main.go

@@ -29,7 +29,15 @@ func main() {
 		if len(args) > 2 {
 			mono = args[2].Bool()
 		}
-		p := micron.Parser{DarkTheme: dark, ForceMonospace: mono}
+		a11y := false
+		if len(args) > 3 {
+			a11y = args[3].Bool()
+		}
+		serif := false
+		if len(args) > 4 {
+			serif = args[4].Bool()
+		}
+		p := micron.Parser{DarkTheme: dark, ForceMonospace: mono, Accessibility: a11y, Serif: serif}
 		return p.ConvertMicronToHTML(markup)
 	})
 	collectFields := js.FuncOf(func(this js.Value, args []js.Value) any {

micron/a11y_test.go

@@ -0,0 +1,192 @@
+// Copyright Quad4 2026
+// SPDX-License-Identifier: 0BSD
+
+package micron
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestAccessibilityHeadingRole(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML("> Title\n")
+	if !strings.Contains(out, `role="heading"`) {
+		t.Fatalf("expected role=heading, got: %s", out)
+	}
+	if !strings.Contains(out, `aria-level="1"`) {
+		t.Fatalf("expected aria-level=1, got: %s", out)
+	}
+	if strings.Count(out, `role="heading"`) != 1 {
+		t.Fatalf("expected exactly one heading role, got: %s", out)
+	}
+}
+
+func TestAccessibilityHeadingLevel(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML(">>> Deep\n")
+	if !strings.Contains(out, `aria-level="3"`) {
+		t.Fatalf("expected aria-level=3, got: %s", out)
+	}
+}
+
+func TestAccessibilityOffByDefault(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("> Title\n-=\nx\n")
+	for _, frag := range []string{`role="heading"`, `aria-level`, `role="separator"`, `Mu-sr`, `aria-live`} {
+		if strings.Contains(out, frag) {
+			t.Fatalf("expected no %q without Accessibility, got: %s", frag, out)
+		}
+	}
+}
+
+func TestAccessibilityDividerSeparator(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML("-=\n")
+	if !strings.Contains(out, `role="separator"`) {
+		t.Fatalf("expected role=separator on divider, got: %s", out)
+	}
+}
+
+func TestAccessibilityFoldGlyphHidden(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML("`+> Fold\nbody\n`-\n")
+	if !strings.Contains(out, `class="Mu-fold-glyph" aria-hidden="true"`) {
+		t.Fatalf("expected aria-hidden fold glyph, got: %s", out)
+	}
+}
+
+func TestAccessibilityPartialStatus(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML("`{file.mu`30`a=b}\n")
+	if !strings.Contains(out, `role="status"`) {
+		t.Fatalf("expected role=status on partial, got: %s", out)
+	}
+	if !strings.Contains(out, `aria-live="polite"`) {
+		t.Fatalf("expected aria-live=polite on partial, got: %s", out)
+	}
+}
+
+func TestAccessibilityReadableText(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML("hello world\n")
+	if !strings.Contains(out, `class="Mu-sr"`) {
+		t.Fatalf("expected Mu-sr readable span, got: %s", out)
+	}
+	if !strings.Contains(out, `aria-hidden="true"`) {
+		t.Fatalf("expected aria-hidden visual span, got: %s", out)
+	}
+}
+
+func TestAccessibilityFieldLabel(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Accessibility: true}
+	out := p.ConvertMicronToHTML("`<24|username`alice>\n")
+	if !strings.Contains(out, `aria-label="username"`) {
+		t.Fatalf("expected aria-label on field, got: %s", out)
+	}
+	if !strings.Contains(out, `name="username"`) {
+		t.Fatalf("expected name attribute preserved, got: %s", out)
+	}
+}
+
+func TestFieldWidthAndRows(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("`<40|name`bob>\n")
+	if !strings.Contains(out, `size="40"`) {
+		t.Fatalf("expected size=40 on input, got: %s", out)
+	}
+	if !strings.Contains(out, "<input") {
+		t.Fatalf("expected input element, got: %s", out)
+	}
+}
+
+func TestFieldRowsTextarea(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("`<20x3|bio`hello>\n")
+	if !strings.Contains(out, "<textarea") {
+		t.Fatalf("expected textarea for WxR field, got: %s", out)
+	}
+	if !strings.Contains(out, `rows="3"`) {
+		t.Fatalf("expected rows=3, got: %s", out)
+	}
+	if !strings.Contains(out, `cols="20"`) {
+		t.Fatalf("expected cols=20, got: %s", out)
+	}
+	if !strings.Contains(out, `name="bio"`) {
+		t.Fatalf("expected name=bio, got: %s", out)
+	}
+}
+
+func TestHeadingAnchorSlug(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("> My Section!\n")
+	if !strings.Contains(out, `id="my-section"`) {
+		t.Fatalf("expected slug anchor id=my-section, got: %s", out)
+	}
+	if !strings.Contains(out, `micron-header-anchor`) {
+		t.Fatalf("expected micron-header-anchor class, got: %s", out)
+	}
+}
+
+func TestExplicitAnchor(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("text `:target` more\n")
+	if !strings.Contains(out, `id="target"`) {
+		t.Fatalf("expected explicit anchor id=target, got: %s", out)
+	}
+	if !strings.Contains(out, `class="micron-anchor"`) {
+		t.Fatalf("expected micron-anchor class, got: %s", out)
+	}
+}
+
+func TestEmptyAnchorResolvesToNextHeading(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("`[next`#]\n> Second\n")
+	if !strings.Contains(out, `href="#second"`) {
+		t.Fatalf("expected href resolved to #second, got: %s", out)
+	}
+	if strings.Contains(out, `href="#"`) {
+		t.Fatalf("expected no unresolved empty anchor, got: %s", out)
+	}
+}
+
+func TestEmptyAnchorUnmatchedStays(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("> First\n`[next`#]\n")
+	if !strings.Contains(out, `href="#"`) {
+		t.Fatalf("expected unresolved empty anchor to stay href=#, got: %s", out)
+	}
+}
+
+func TestSerifRootClass(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true, Serif: true}
+	out := p.ConvertMicronToHTML("body\n")
+	if !strings.Contains(out, `Mu-serif`) {
+		t.Fatalf("expected Mu-serif root class, got: %s", out)
+	}
+}
+
+func TestSerifOffByDefault(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("body\n")
+	if strings.Contains(out, `Mu-serif`) {
+		t.Fatalf("expected no Mu-serif without Serif, got: %s", out)
+	}
+}
+
+func TestCRLFNormalization(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	crlf := p.ConvertMicronToHTML("> Title\r\nbody\r\n")
+	lf := p.ConvertMicronToHTML("> Title\nbody\n")
+	if crlf != lf {
+		t.Fatalf("CRLF and LF input must render identically.\nCRLF: %s\nLF: %s", crlf, lf)
+	}
+}
+
+func TestHashLinkNotNomadWrapped(t *testing.T) {
+	p := Parser{DarkTheme: true, ForceMonospace: true}
+	out := p.ConvertMicronToHTML("> Target\n`[back`#]\n")
+	if strings.Contains(out, `href="nomadnetwork://#"`) {
+		t.Fatalf("expected bare # href, got nomadnetwork-wrapped: %s", out)
+	}
+}

micron/anchor.go

@@ -0,0 +1,97 @@
+// Copyright Quad4 2026
+// SPDX-License-Identifier: 0BSD
+
+package micron
+
+import (
+	"regexp"
+	"strings"
+)
+
+// micronStripRe mirrors micron-parser-js _MICRON_STRIP_RE: inline format
+// toggles, F/B colors, and `:name anchor codes removed before slugification.
+var micronStripRe = regexp.MustCompile("`[FB]T[0-9a-fA-F]{6}|`[FB][0-9a-fA-F]{3}|`:[A-Za-z0-9_-]*|`[!*_=fbacrl`<>{]")
+
+var slugNonAlnumRe = regexp.MustCompile(`[^A-Za-z0-9]+`)
+
+// slugifyMicron derives a same-page anchor id from heading source text,
+// matching micron-parser-js slugifyMicron.
+func slugifyMicron(text string) string {
+	stripped := micronStripRe.ReplaceAllString(text, "")
+	slug := slugNonAlnumRe.ReplaceAllString(stripped, "-")
+	slug = strings.Trim(slug, "-")
+	return strings.ToLower(slug)
+}
+
+const (
+	headerAnchorClassMarker = `" class="micron-anchor micron-header-anchor"`
+	emptyHrefAttr           = `href="#"`
+	emptyTitleAttr          = ` title="#"`
+)
+
+// resolveEmptyAnchorHrefs rewrites href="#" links to the id of the first
+// micron-header-anchor that follows them, matching micron-parser-js
+// _resolveEmptyAnchors. The link title is updated to match.
+func resolveEmptyAnchorHrefs(html string) string {
+	if !strings.Contains(html, emptyHrefAttr) || !strings.Contains(html, headerAnchorClassMarker) {
+		return html
+	}
+
+	type headerAnchor struct {
+		pos int
+		id  string
+	}
+	var headers []headerAnchor
+	for off := 0; off < len(html); {
+		idx := strings.Index(html[off:], headerAnchorClassMarker)
+		if idx < 0 {
+			break
+		}
+		pos := off + idx
+		start := pos
+		for start > 0 && pos-start < 128 && html[start-1] != '<' {
+			start--
+		}
+		seg := html[start:pos]
+		if _, after, ok := strings.Cut(seg, `id="`); ok {
+			headers = append(headers, headerAnchor{pos: pos, id: after})
+		}
+		off = pos + 1
+	}
+	if len(headers) == 0 {
+		return html
+	}
+
+	var out strings.Builder
+	out.Grow(len(html) + 64)
+	last := 0
+	hi := 0
+	for {
+		idx := strings.Index(html[last:], emptyHrefAttr)
+		if idx < 0 {
+			break
+		}
+		pos := last + idx
+		for hi < len(headers) && headers[hi].pos <= pos {
+			hi++
+		}
+		if hi >= len(headers) {
+			break
+		}
+		id := headers[hi].id
+		out.WriteString(html[last:pos])
+		out.WriteString(`href="#`)
+		out.WriteString(id)
+		out.WriteByte('"')
+		pos += len(emptyHrefAttr)
+		if strings.HasPrefix(html[pos:], emptyTitleAttr) {
+			out.WriteString(` title="#`)
+			out.WriteString(id)
+			out.WriteByte('"')
+			pos += len(emptyTitleAttr)
+		}
+		last = pos
+	}
+	out.WriteString(html[last:])
+	return out.String()
+}

micron/ast.go

@@ -60,6 +60,10 @@ type Inline struct {
 	Field   *Field   `json:"field,omitempty"`
 	Link    *Link    `json:"link,omitempty"`
 	Partial *Partial `json:"partial,omitempty"`
+	// AnchorName carries a `:name anchor identifier; AnchorHeader marks
+	// auto-generated heading slugs rendered as micron-header-anchor.
+	AnchorName   string `json:"anchor_name,omitempty"`
+	AnchorHeader bool   `json:"anchor_header,omitempty"`
 }
 
 // Severity ranks a diagnostic.