feat: Refactor italic node to support nested inline elements

ast/inline.go

@@ -48,16 +48,20 @@ type Italic struct {
 	BaseInline
 
 	// Symbol is "*" or "_".
-	Symbol  string
-	Content string
+	Symbol   string
+	Children []Node
 }
 
 func (*Italic) Type() NodeType {
 	return ItalicNode
 }
 
 func (n *Italic) Restore() string {
-	return fmt.Sprintf("%s%s%s", n.Symbol, n.Content, n.Symbol)
+	content := ""
+	for _, child := range n.Children {
+		content += child.Restore()
+	}
+	return fmt.Sprintf("%s%s%s", n.Symbol, content, n.Symbol)
 }
 
 type BoldItalic struct {

parser/blockquote.go

@@ -15,7 +15,7 @@ func (*BlockquoteParser) Match(tokens []*tokenizer.Token) (ast.Node, int) {
 	rows := tokenizer.Split(tokens, tokenizer.NewLine)
 	contentRows := [][]*tokenizer.Token{}
 	for _, row := range rows {
-		if len(row) < 3 || row[0].Type != tokenizer.GreaterThan || row[1].Type != tokenizer.Space {
+		if len(row) < 2 || row[0].Type != tokenizer.GreaterThan || row[1].Type != tokenizer.Space {
 			break
 		}
 		contentRows = append(contentRows, row)
@@ -26,17 +26,25 @@ func (*BlockquoteParser) Match(tokens []*tokenizer.Token) (ast.Node, int) {
 
 	children := []ast.Node{}
 	size := 0
+
 	for index, row := range contentRows {
 		contentTokens := row[2:]
-		nodes, err := ParseBlockWithParsers(contentTokens, []BlockParser{NewBlockquoteParser(), NewParagraphParser()})
-		if err != nil {
-			return nil, 0
-		}
-		if len(nodes) != 1 {
-			return nil, 0
+		var node ast.Node
+		if len(contentTokens) == 0 {
+			node = &ast.Paragraph{
+				Children: []ast.Node{&ast.Text{Content: " "}},
+			}
+		} else {
+			nodes, err := ParseBlockWithParsers(contentTokens, []BlockParser{NewBlockquoteParser(), NewParagraphParser()})
+			if err != nil {
+				return nil, 0
+			}
+			if len(nodes) != 1 {
+				return nil, 0
+			}
+			node = nodes[0]
 		}
-
-		children = append(children, nodes[0])
+		children = append(children, node)
 		size += len(row)
 		if index != len(contentRows)-1 {
 			size++ // NewLine.

parser/bold.go

@@ -22,7 +22,7 @@ func (*BoldParser) Match(tokens []*tokenizer.Token) (ast.Node, int) {
 		return nil, 0
 	}
 	prefixTokenType := prefixTokens[0].Type
-	if prefixTokenType != tokenizer.Asterisk {
+	if prefixTokenType != tokenizer.Asterisk && prefixTokenType != tokenizer.Underscore {
 		return nil, 0
 	}
 

parser/italic.go

@@ -20,7 +20,7 @@ func (*ItalicParser) Match(tokens []*tokenizer.Token) (ast.Node, int) {
 	}
 
 	prefixTokens := matchedTokens[:1]
-	if prefixTokens[0].Type != tokenizer.Asterisk {
+	if prefixTokens[0].Type != tokenizer.Asterisk && prefixTokens[0].Type != tokenizer.Underscore {
 		return nil, 0
 	}
 	prefixTokenType := prefixTokens[0].Type
@@ -37,8 +37,13 @@ func (*ItalicParser) Match(tokens []*tokenizer.Token) (ast.Node, int) {
 		return nil, 0
 	}
 
+	children, err := ParseInlineWithParsers(contentTokens, []InlineParser{NewLinkParser(), NewTextParser()})
+	if err != nil || len(children) == 0 {
+		return nil, 0
+	}
+
 	return &ast.Italic{
-		Symbol:  prefixTokenType,
-		Content: tokenizer.Stringify(contentTokens),
+		Symbol:   prefixTokenType,
+		Children: children,
 	}, len(contentTokens) + 2
 }

parser/tests/bold_test.go

@@ -52,6 +52,36 @@ func TestBoldParser(t *testing.T) {
 			text: "* * Hello **",
 			node: nil,
 		},
+		{
+			text: "__Hello__",
+			node: &ast.Bold{
+				Symbol: "_",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: "Hello",
+					},
+				},
+			},
+		},
+		{
+			text: "__ Hello __",
+			node: &ast.Bold{
+				Symbol: "_",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: " Hello ",
+					},
+				},
+			},
+		},
+		{
+			text: "__ Hello _ _",
+			node: nil,
+		},
+		{
+			text: "_ _ Hello __",
+			node: nil,
+		},
 	}
 
 	for _, test := range tests {

parser/tests/italic_test.go

@@ -21,22 +21,83 @@ func TestItalicParser(t *testing.T) {
 		{
 			text: "*Hello*",
 			node: &ast.Italic{
-				Symbol:  "*",
-				Content: "Hello",
+				Symbol: "*",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: "Hello",
+					},
+				},
 			},
 		},
 		{
 			text: "* Hello *",
 			node: &ast.Italic{
-				Symbol:  "*",
-				Content: " Hello ",
+				Symbol: "*",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: " Hello ",
+					},
+				},
 			},
 		},
 		{
 			text: "*1* Hello * *",
 			node: &ast.Italic{
-				Symbol:  "*",
-				Content: "1",
+				Symbol: "*",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: "1",
+					},
+				},
+			},
+		},
+		{
+			text: "_Hello_",
+			node: &ast.Italic{
+				Symbol: "_",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: "Hello",
+					},
+				},
+			},
+		},
+		{
+			text: "_ Hello _",
+			node: &ast.Italic{
+				Symbol: "_",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: " Hello ",
+					},
+				},
+			},
+		},
+		{
+			text: "_1_ Hello _ _",
+			node: &ast.Italic{
+				Symbol: "_",
+				Children: []ast.Node{
+					&ast.Text{
+						Content: "1",
+					},
+				},
+			},
+		},
+		{
+			text: "*[Hello](https://example.com)*",
+			node: &ast.Italic{
+				Symbol: "*",
+				Children: []ast.Node{
+					&ast.Link{
+						Content: []ast.Node{
+							&ast.Text{
+								Content: "Hello",
+							},
+						},
+						URL: "https://example.com",
+					},
+				},
 			},
 		},
 	}

parser/tests/ordered_list_item_test.go

@@ -55,8 +55,12 @@ func TestOrderedListItemParser(t *testing.T) {
 						Content: "Hello ",
 					},
 					&ast.Italic{
-						Symbol:  "*",
-						Content: "World",
+						Symbol: "*",
+						Children: []ast.Node{
+							&ast.Text{
+								Content: "World",
+							},
+						},
 					},
 				},
 			},

renderer/html/html.go

@@ -249,7 +249,7 @@ func (r *HTMLRenderer) renderBold(node *ast.Bold) {
 
 func (r *HTMLRenderer) renderItalic(node *ast.Italic) {
 	r.output.WriteString("<em>")
-	r.output.WriteString(node.Content)
+	r.RenderNodes(node.Children)
 	r.output.WriteString("</em>")
 }
 

renderer/string/string.go

@@ -197,7 +197,7 @@ func (r *StringRenderer) renderBold(node *ast.Bold) {
 }
 
 func (r *StringRenderer) renderItalic(node *ast.Italic) {
-	r.output.WriteString(node.Content)
+	r.RenderNodes(node.Children)
 }
 
 func (r *StringRenderer) renderBoldItalic(node *ast.BoldItalic) {