markdown

var DefaultSerializer = NewSerializer(map[string]NodeSerializerFunc{
	"blockquote": func(state *SerializerState, node, _parent *model.Node, _index int) {
		state.WrapBlock("> ", nil, node, func() { state.RenderContent(node) })
	},
	"code_block": func(state *SerializerState, node, _parent *model.Node, _index int) {
		params, _ := node.Attrs["params"].(string)
		state.Write("```" + params + "\n")
		state.Text(node.TextContent(), false)
		state.EnsureNewLine()
		state.Write("```")
		state.CloseBlock(node)
	},
	"heading": func(state *SerializerState, node, _parent *model.Node, _index int) {
		level := getAttrInt(node.Attrs, "level", 1)
		state.Write(strings.Repeat("#", level) + " ")
		state.RenderInline(node)
		state.CloseBlock(node)
	},
	"horizontal_rule": func(state *SerializerState, node, _parent *model.Node, _index int) {
		markup := "---"
		if m, ok := node.Attrs["markup"].(string); ok {
			markup = m
		}
		state.Write(markup)
		state.CloseBlock(node)
	},
	"bullet_list": func(state *SerializerState, node, _parent *model.Node, _index int) {
		bullet := "*"
		if b, ok := node.Attrs["bullet"].(string); ok {
			bullet = b
		}
		state.RenderList(node, "  ", func(_ int) string { return bullet + " " })
	},
	"ordered_list": func(state *SerializerState, node, _parent *model.Node, _index int) {
		start := getAttrInt(node.Attrs, "order", 1)
		maxW := len(fmt.Sprintf("%d", start+node.ChildCount()-1))
		space := strings.Repeat(" ", maxW+2)
		state.RenderList(node, space, func(i int) string {
			nStr := fmt.Sprintf("%d", start+i)
			return strings.Repeat(" ", maxW-len(nStr)) + nStr + ". "
		})
	},
	"list_item": func(state *SerializerState, node, _parent *model.Node, _index int) {
		state.RenderContent(node)
	},
	"paragraph": func(state *SerializerState, node, _parent *model.Node, _index int) {
		state.RenderInline(node)
		state.CloseBlock(node)
	},
	"image": func(state *SerializerState, node, _parent *model.Node, _index int) {
		alt, _ := node.Attrs["alt"].(string)
		src, _ := node.Attrs["src"].(string)
		title := ""
		if t, ok := node.Attrs["title"].(string); ok {
			title = state.Quote(t)
		}
		state.Write(fmt.Sprintf("![%s](%s)%s", state.Esc(alt), state.Esc(src), title))
	},
	"hard_break": func(state *SerializerState, node, parent *model.Node, index int) {
		for i := index; i < parent.ChildCount(); i++ {
			if child, err := parent.Child(i); err == nil {
				if child.Type != node.Type {
					state.Write("\\\n")
					return
				}
			}
		}
	},
	"text": func(state *SerializerState, node, _parent *model.Node, _index int) {
		state.Text(*node.Text)
	},
}, map[string]MarkSerializerSpec{
	"em":     {Open: "*", Close: "*", Mixable: true, ExpelEnclosingWhitespace: true},
	"strong": {Open: "**", Close: "**", Mixable: true, ExpelEnclosingWhitespace: true},
	"link": {
		Open: func(_state *SerializerState, mark *model.Mark, parent *model.Node, index int) string {
			if isPlainURL(mark, parent, index, 1) {
				return "<"
			}
			return "["
		},
		Close: func(state *SerializerState, mark *model.Mark, parent *model.Node, index int) string {
			if isPlainURL(mark, parent, index, -1) {
				return ">"
			}
			href, _ := mark.Attrs["href"].(string)
			title, _ := mark.Attrs["title"].(string)
			if title != "" {
				title = " " + state.Quote(title)
			}
			return fmt.Sprintf("](%s%s)", state.Esc(href), title)
		},
	},
	"code": {
		Open: func(_state *SerializerState, _mark *model.Mark, parent *model.Node, index int) string {
			child, err := parent.Child(index)
			if err != nil {
				return "`"
			}
			return backticksFor(child, -1)
		},
		Close: func(_state *SerializerState, _mark *model.Mark, parent *model.Node, index int) string {
			child, err := parent.Child(index - 1)
			if err != nil {
				return "`"
			}
			return backticksFor(child, 1)
		},
		NoEscape: true,
	},
})