refactor: markdown parser and renderer to support HTML elements

- Simplified ParserConfig by removing extension configuration and enabling all features by default.
- Enhanced HTML element parsing to support self-closing tags and attributes for <img>, <br>, <kbd>, <small>, and <mark>.
- Updated the rendering logic to handle HTML elements correctly, including attribute escaping and self-closing tags.
- Improved test coverage for HTML element parsing and rendering.
- Updated documentation to reflect changes in usage and configuration.

Author: github-actions[bot]

ARCHITECTURE.md

@@ -28,7 +28,7 @@ gomark is built on the principle of **pragmatic simplicity**:
 - **Reusability**: Tokens can be reused by multiple parsers
 - **Memory Efficiency**: Tokens reference original string data
 
-**Alternative Considered**: Text-based parsing (like goldmark)
+**Alternative Considered**: Text-based parsing
 **Why Rejected**: Added complexity without clear benefits for our use cases
 
 ### 2. Simple AST Interface ✅
@@ -48,7 +48,7 @@ type Node interface {
 - **Focused**: Only implements what's actually needed
 - **Memory Efficient**: No overhead for unused tree navigation features
 
-**Alternative Considered**: Complex tree interface (like goldmark)
+**Alternative Considered**: Complex tree interface
 **Why Rejected**: Analysis showed no actual usage of tree navigation in our codebase
 
 ### 3. Stateless Parsers ✅
@@ -106,7 +106,7 @@ const ParagraphNode NodeType = "PARAGRAPH"
 
 ### Public vs Internal
 
-**Public Packages** (goldmark-style):
+**Public Packages**:
 ```
 ├── ast/              # AST definitions - users need access
 ├── config/           # Configuration - users need to configure
@@ -122,7 +122,7 @@ const ParagraphNode NodeType = "PARAGRAPH"
 **Rationale**:
 - Public APIs allow extensibility where it matters
 - Internal packages keep implementation details hidden
-- Follows goldmark patterns for familiarity
+- Clean separation of concerns
 
 ## Performance Optimizations
 
@@ -171,18 +171,7 @@ These are **conscious decisions**, not oversights:
 ### Package Refactoring
 **Problem**: Everything was in `internal/` packages
 **Solution**: Moved key packages to public for extensibility
-**Result**: goldmark-style architecture with better extensibility
-
-## Comparison with goldmark
-
-| Aspect | goldmark | gomark |
-|--------|----------|--------|
-| **Complexity** | High | Low |
-| **Performance** | Good | Excellent |
-| **Extensibility** | Very High | Moderate |
-| **Maintainability** | Moderate | High |
-| **Learning Curve** | Steep | Gentle |
-| **Feature Set** | Comprehensive | Focused |
+**Result**: Modular architecture with better extensibility
 
 ## When to Choose gomark
 
@@ -191,12 +180,51 @@ These are **conscious decisions**, not oversights:
 - You want simple, maintainable code
 - You're building applications, not markdown libraries
 - You need good performance with moderate extensibility
+- You want zero-configuration setup with all features enabled
+
+## Recent Architecture Evolutions
+
+### HTML Elements Support (Phase 1) ✅
+
+**Addition**: Added support for essential HTML elements: `<kbd>`, `<br>`, `<img>`, `<small>`, `<mark>`
+
+**Approach**:
+- **Reused existing `HTMLElementNode`** rather than creating separate node types
+- **Enhanced with `Children` and `IsSelfClosing`** fields for flexibility
+- **Smart parsing**: Different strategies for self-closing vs container elements
+- **Attribute handling**: Proper parsing with quote support and sanitization
+- **Security-first**: HTML-escaped attributes and content validation
+
+**Rationale**:
+- These elements have no markdown equivalents (can't be achieved with existing syntax)
+- Essential for documentation and note-taking (especially `<kbd>` for shortcuts)
+- CommonMark and GFM standards support for these elements
+
+### Configuration Simplification ✅
 
-❌ **Choose goldmark when**:
-- You need maximum extensibility
-- You're building a markdown processing library
-- You need complex AST transformations
-- You need full CommonMark compliance edge cases
+**Change**: Simplified configuration to "zero-config by default"
+
+**Before**:
+```go
+// Required configuration for HTML elements
+cfg := config.DefaultConfig().WithAllowHTML(true)
+engine := gomark.NewEngine(gomark.WithConfig(cfg))
+```
+
+**After**:
+```go
+// HTML elements work by default - no config needed!
+doc, err := gomark.Parse("Press <kbd>Ctrl</kbd> to copy")
+```
+
+**New Configuration Approach**:
+1. **`gomark.Parse()`** → Uses `DefaultConfig()` (all features enabled)
+2. **`config.DefaultConfig()`** → Single configuration with sensible defaults
+
+**Rationale**:
+- gomark is primarily used in memos where users want all features
+- Configuration complexity was barrier to adoption
+- Smart defaults reduce cognitive load
 
 ## Future Evolution
 
@@ -210,16 +238,16 @@ gomark is designed to evolve pragmatically:
 ### Potential Future Additions
 
 **Only if there's demonstrated need**:
+- **Phase 2 HTML Elements**: `<details>/<summary>`, `<a>` with attributes, `<div>`
 - AST walking API (if users request it)
 - More output formats (if users request them)
-- Advanced HTML attributes (if simple approach proves insufficient)
-- Text-based parsing (if token-based proves limiting)
+- Advanced HTML attribute parsing (if current approach proves insufficient)
 
 ## Conclusion
 
 gomark represents a **pragmatic approach** to markdown parsing:
 
-- **Goldmark-inspired architecture** for familiarity and extensibility
+- **Clean modular architecture** for extensibility
 - **Performance-focused implementation** for real-world applications
 - **Simple, maintainable code** that developers can understand and modify
 - **Focused feature set** that solves real problems without over-engineering

README.md

@@ -1,6 +1,6 @@
 # gomark
 
-A fast, extensible, and well-structured markdown parser for Go, inspired by [goldmark](https://github.com/yuin/goldmark) but optimized for simplicity and performance.
+A fast, extensible, and well-structured markdown parser for Go, optimized for simplicity and performance.
 
 ## Features
 
@@ -29,27 +29,47 @@ A fast, extensible, and well-structured markdown parser for Go, inspired by [gol
 - **Tags**: `#hashtag` syntax
 - **Referenced Content**: `[[wiki-style]]` links
 - **Embedded Content**: `![[embeds]]`
-- **HTML Elements**: Basic HTML tag support
+- **HTML Elements**: `<kbd>`, `<br>`, `<img>`, `<small>`, `<mark>`, and more
 
 ## Quick Start
 
+gomark is designed for **zero-configuration usage** - all features are enabled by default:
+
 ```go
 package main
 
 import (
     "fmt"
     "github.com/usememos/gomark"
+    "github.com/usememos/gomark/renderer/html"
 )
 
 func main() {
-    // Parse markdown
-    markdown := "# Hello\n\nThis is **bold** and *italic* text."
+    // All features enabled by default - no configuration needed!
+    markdown := `# Hello Memos!
+
+**Bold** and *italic* text with ==highlighting==.
+
+Press <kbd>Ctrl</kbd>+<kbd>C</kbd> to copy.
+
+Math: $E = mc^2$ and task lists:
+- [x] HTML elements supported
+- [ ] Even more features coming
+
+#gomark ||works great||!`
+
+    // Parse with all features enabled
     doc, err := gomark.Parse(markdown)
     if err != nil {
         panic(err)
     }
 
-    // Restore back to markdown
+    // Render to HTML
+    renderer := html.NewHTMLRenderer()
+    html := renderer.RenderDocument(doc)
+    fmt.Println(html)
+
+    // Or restore back to markdown
     restored := gomark.Restore(doc)
     fmt.Println(restored)
 }
@@ -59,19 +79,18 @@ func main() {
 
 ### Custom Configuration
 
+While gomark works great with zero configuration, you can customize it if needed:
+
 ```go
 import (
     "github.com/usememos/gomark"
     "github.com/usememos/gomark/config"
 )
 
-// Create engine with custom configuration
-engine := gomark.NewEngine(
-    gomark.WithConfig(config.StrictConfig()),           // Use strict CommonMark
-    gomark.WithExtension("tables", false),              // Disable tables
-    gomark.WithExtension("math", true),                 // Enable math
-    gomark.WithStrictMode(true),                        // Enable strict parsing
-)
+// Customize limits if needed
+engine := gomark.NewEngine(gomark.WithConfig(
+    config.DefaultConfig().WithMaxDepth(100).WithMaxFileSize(1024 * 1024), // 1MB limit
+))
 
 doc, err := engine.Parse(markdown)
 ```
@@ -100,28 +119,23 @@ textOutput := stringRenderer.RenderDocument(doc)
 markdownOutput := gomark.Restore(doc)
 ```
 
-### Configuration Options
+### Available Configurations
 
 ```go
 import "github.com/usememos/gomark/config"
 
-// Default configuration (all extensions enabled)
+// Default configuration: all features enabled with generous limits
 cfg := config.DefaultConfig()
 
-// Strict CommonMark configuration
-cfg := config.StrictConfig()
-
-// Custom configuration
+// Custom limits if needed
 cfg := config.DefaultConfig().
-    WithExtension("tables", false).
-    WithExtension("math", true).
-    WithStrictMode(true).
-    WithSafeMode(true)
+    WithMaxDepth(50).                   // Limit nesting depth
+    WithMaxFileSize(1024 * 1024)        // 1MB file size limit
 ```
 
 ## Architecture
 
-gomark follows a clean, modular architecture inspired by goldmark:
+gomark follows a clean, modular architecture:
 
 ```
 gomark/
@@ -192,11 +206,13 @@ cfg = cfg.WithSafeMode(true)
 
 ## Recent Improvements
 
+- ✅ **Phase 1 HTML Elements**: Added support for `<kbd>`, `<br>`, `<img>`, `<small>`, `<mark>`
+- ✅ **Simplified Configuration**: Zero-config usage with sensible defaults
+- ✅ **Enhanced HTML Parsing**: Proper attribute handling and self-closing tag support
 - ✅ **Fixed blockquote blank lines** (GitHub issue #19)
-- ✅ **Refactored to goldmark-style architecture**
+- ✅ **Refactored to modular architecture**
 - ✅ **Improved package organization** with public APIs
-- ✅ **Enhanced test coverage**
-- ✅ **Better documentation**
+- ✅ **Enhanced test coverage** with 26+ HTML element test cases
 
 ## Contributing
 
@@ -212,4 +228,4 @@ This project is part of the [Memos](https://github.com/usememos/memos) ecosystem
 
 ## Inspiration
 
-Inspired by [goldmark](https://github.com/yuin/goldmark) but designed for simplicity, performance, and ease of use. While goldmark provides comprehensive CommonMark compliance with complex extensibility, gomark focuses on practical markdown parsing with clean, maintainable code.
+Designed for simplicity, performance, and ease of use. gomark focuses on practical markdown parsing with clean, maintainable code.

ast/block.go

@@ -124,7 +124,7 @@ type ListKind string
 const (
 	UnorderedList   ListKind = "ul"
 	OrderedList     ListKind = "ol"
-	DescrpitionList ListKind = "dl"
+	DescriptionList ListKind = "dl"
 )
 
 type List struct {

ast/inline.go

@@ -286,8 +286,10 @@ func (n *Spoiler) Restore() string {
 type HTMLElement struct {
 	BaseInline
 
-	TagName    string
-	Attributes map[string]string
+	TagName       string
+	Attributes    map[string]string
+	Children      []Node // For container elements like <kbd>, <small>, <mark>
+	IsSelfClosing bool   // For self-closing elements like <br>, <img>
 }
 
 func (*HTMLElement) Type() NodeType {
@@ -303,5 +305,26 @@ func (n *HTMLElement) Restore() string {
 	if len(attributes) > 0 {
 		attrStr = " " + strings.Join(attributes, " ")
 	}
-	return fmt.Sprintf("<%s%s />", n.TagName, attrStr)
+
+	if n.IsSelfClosing {
+		return fmt.Sprintf("<%s%s />", n.TagName, attrStr)
+	}
+
+	// Container element with children
+	childrenStr := ""
+	if len(n.Children) == 1 {
+		// For simple text content elements like <kbd>text</kbd>
+		if textNode, ok := n.Children[0].(*Text); ok {
+			childrenStr = textNode.Content
+		} else {
+			childrenStr = n.Children[0].Restore()
+		}
+	} else {
+		// For complex nested content
+		for _, child := range n.Children {
+			childrenStr += child.Restore()
+		}
+	}
+
+	return fmt.Sprintf("<%s%s>%s</%s>", n.TagName, attrStr, childrenStr, n.TagName)
 }

ast/util.go

@@ -16,7 +16,7 @@ func GetListItemKindAndIndent(node Node) (ListKind, int) {
 	case *UnorderedListItem:
 		return UnorderedList, n.Indent
 	case *TaskListItem:
-		return DescrpitionList, n.Indent
+		return DescriptionList, n.Indent
 	default:
 		return "", 0
 	}