add vendoring

vendor/maunium.net/go/mautrix/format/mdext/discordunderline.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package mdext
+
+import (
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/parser"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/renderer/html"
+	"github.com/yuin/goldmark/text"
+	"github.com/yuin/goldmark/util"
+)
+
+type astDiscordUnderline struct {
+	ast.BaseInline
+}
+
+func (n *astDiscordUnderline) Dump(source []byte, level int) {
+	ast.DumpHelper(n, source, level, nil, nil)
+}
+
+var astKindDiscordUnderline = ast.NewNodeKind("DiscordUnderline")
+
+func (n *astDiscordUnderline) Kind() ast.NodeKind {
+	return astKindDiscordUnderline
+}
+
+type discordUnderlineDelimiterProcessor struct{}
+
+func (p *discordUnderlineDelimiterProcessor) IsDelimiter(b byte) bool {
+	return b == '_'
+}
+
+func (p *discordUnderlineDelimiterProcessor) CanOpenCloser(opener, closer *parser.Delimiter) bool {
+	return opener.Char == closer.Char
+}
+
+func (p *discordUnderlineDelimiterProcessor) OnMatch(consumes int) ast.Node {
+	if consumes == 1 {
+		// Slightly hacky hack: if the delimiter parser tries to give us text wrapped with a single underline,
+		// send it over to the emphasis area instead of returning an underline node.
+		return ast.NewEmphasis(consumes)
+	}
+	return &astDiscordUnderline{}
+}
+
+var defaultDiscordUnderlineDelimiterProcessor = &discordUnderlineDelimiterProcessor{}
+
+type discordUnderlineParser struct{}
+
+var defaultDiscordUnderlineParser = &discordUnderlineParser{}
+
+// NewDiscordUnderlineParser return a new InlineParser that parses
+// Discord underline expressions.
+func NewDiscordUnderlineParser() parser.InlineParser {
+	return defaultDiscordUnderlineParser
+}
+
+func (s *discordUnderlineParser) Trigger() []byte {
+	return []byte{'_'}
+}
+
+func (s *discordUnderlineParser) Parse(parent ast.Node, block text.Reader, pc parser.Context) ast.Node {
+	before := block.PrecendingCharacter()
+	line, segment := block.PeekLine()
+	node := parser.ScanDelimiter(line, before, 2, defaultDiscordUnderlineDelimiterProcessor)
+	if node == nil {
+		return nil
+	}
+	node.Segment = segment.WithStop(segment.Start + node.OriginalLength)
+	block.Advance(node.OriginalLength)
+	pc.PushDelimiter(node)
+	return node
+}
+
+func (s *discordUnderlineParser) CloseBlock(parent ast.Node, pc parser.Context) {
+	// nothing to do
+}
+
+// discordUnderlineHTMLRenderer is a renderer.NodeRenderer implementation that
+// renders discord underline nodes.
+type discordUnderlineHTMLRenderer struct {
+	html.Config
+}
+
+// NewDiscordUnderlineHTMLRenderer returns a new discordUnderlineHTMLRenderer.
+func NewDiscordUnderlineHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {
+	r := &discordUnderlineHTMLRenderer{
+		Config: html.NewConfig(),
+	}
+	for _, opt := range opts {
+		opt.SetHTMLOption(&r.Config)
+	}
+	return r
+}
+
+func (r *discordUnderlineHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	reg.Register(astKindDiscordUnderline, r.renderDiscordUnderline)
+}
+
+var DiscordUnderlineAttributeFilter = html.GlobalAttributeFilter
+
+func (r *discordUnderlineHTMLRenderer) renderDiscordUnderline(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		if n.Attributes() != nil {
+			_, _ = w.WriteString("<u")
+			html.RenderAttributes(w, n, DiscordUnderlineAttributeFilter)
+			_ = w.WriteByte('>')
+		} else {
+			_, _ = w.WriteString("<u>")
+		}
+	} else {
+		_, _ = w.WriteString("</u>")
+	}
+	return ast.WalkContinue, nil
+}
+
+type discordUnderline struct{}
+
+// DiscordUnderline is an extension that allow you to use underline expression like '__text__' .
+var DiscordUnderline = &discordUnderline{}
+
+func (e *discordUnderline) Extend(m goldmark.Markdown) {
+	m.Parser().AddOptions(parser.WithInlineParsers(
+		// This must be a higher priority (= lower priority number) than the emphasis parser
+		// in https://github.com/yuin/goldmark/blob/v1.4.12/parser/parser.go#L601
+		util.Prioritized(NewDiscordUnderlineParser(), 450),
+	))
+	m.Renderer().AddOptions(renderer.WithNodeRenderers(
+		util.Prioritized(NewDiscordUnderlineHTMLRenderer(), 500),
+	))
+}

vendor/maunium.net/go/mautrix/format/mdext/nohtml.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package mdext
+
+import (
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/renderer/html"
+	"github.com/yuin/goldmark/util"
+)
+
+type extEscapeHTML struct{}
+type escapingHTMLRenderer struct{}
+
+// EscapeHTML is an extension that escapes HTML in the input markdown instead of passing it through as-is.
+var EscapeHTML = &extEscapeHTML{}
+var defaultEHR = &escapingHTMLRenderer{}
+
+func (eeh *extEscapeHTML) Extend(m goldmark.Markdown) {
+	m.Renderer().AddOptions(renderer.WithNodeRenderers(util.Prioritized(defaultEHR, 0)))
+}
+
+func (ehr *escapingHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	reg.Register(ast.KindHTMLBlock, ehr.renderHTMLBlock)
+	reg.Register(ast.KindRawHTML, ehr.renderRawHTML)
+}
+
+func (ehr *escapingHTMLRenderer) renderRawHTML(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	if !entering {
+		return ast.WalkSkipChildren, nil
+	}
+	n := node.(*ast.RawHTML)
+	l := n.Segments.Len()
+	for i := 0; i < l; i++ {
+		segment := n.Segments.At(i)
+		html.DefaultWriter.RawWrite(w, segment.Value(source))
+	}
+	return ast.WalkSkipChildren, nil
+}
+
+func (ehr *escapingHTMLRenderer) renderHTMLBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
+	n := node.(*ast.HTMLBlock)
+	if entering {
+		l := n.Lines().Len()
+		for i := 0; i < l; i++ {
+			line := n.Lines().At(i)
+			html.DefaultWriter.RawWrite(w, line.Value(source))
+		}
+	} else {
+		if n.HasClosure() {
+			closure := n.ClosureLine
+			html.DefaultWriter.RawWrite(w, closure.Value(source))
+		}
+	}
+	return ast.WalkContinue, nil
+}

vendor/maunium.net/go/mautrix/format/mdext/simplespoiler.go

@@ -0,0 +1,62 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package mdext
+
+import (
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/parser"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/text"
+	"github.com/yuin/goldmark/util"
+)
+
+type simpleSpoilerParser struct{}
+
+var defaultSimpleSpoilerParser = &simpleSpoilerParser{}
+
+func NewSimpleSpoilerParser() parser.InlineParser {
+	return defaultSimpleSpoilerParser
+}
+
+func (s *simpleSpoilerParser) Trigger() []byte {
+	return []byte{'|'}
+}
+
+func (s *simpleSpoilerParser) Parse(parent ast.Node, block text.Reader, pc parser.Context) ast.Node {
+	// This is basically copied from https://github.com/yuin/goldmark/blob/master/extension/strikethrough.go
+	before := block.PrecendingCharacter()
+	line, segment := block.PeekLine()
+	node := parser.ScanDelimiter(line, before, 2, defaultSpoilerDelimiterProcessor)
+	if node == nil {
+		return nil
+	}
+	node.Segment = segment.WithStop(segment.Start + node.OriginalLength)
+	block.Advance(node.OriginalLength)
+	pc.PushDelimiter(node)
+	return node
+}
+
+func (s *simpleSpoilerParser) CloseBlock(parent ast.Node, pc parser.Context) {
+	// nothing to do
+}
+
+type simpleSpoiler struct{}
+
+// SimpleSpoiler is an extension that allow you to use simple spoiler expression like '||text||' .
+//
+// For spoilers with reasons ('||reason|text||'), use the Spoiler extension.
+var SimpleSpoiler = &simpleSpoiler{}
+
+func (e *simpleSpoiler) Extend(m goldmark.Markdown) {
+	m.Parser().AddOptions(parser.WithInlineParsers(
+		util.Prioritized(NewSimpleSpoilerParser(), 500),
+	))
+	m.Renderer().AddOptions(renderer.WithNodeRenderers(
+		util.Prioritized(NewSpoilerHTMLRenderer(), 500),
+	))
+}

vendor/maunium.net/go/mautrix/format/mdext/spoiler.go

@@ -0,0 +1,168 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package mdext
+
+import (
+	"bytes"
+	"fmt"
+	stdhtml "html"
+	"regexp"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/parser"
+	"github.com/yuin/goldmark/renderer"
+	"github.com/yuin/goldmark/renderer/html"
+	"github.com/yuin/goldmark/text"
+	"github.com/yuin/goldmark/util"
+)
+
+var astKindSpoiler = ast.NewNodeKind("Spoiler")
+
+type astSpoiler struct {
+	ast.BaseInline
+	reason string
+}
+
+func (n *astSpoiler) Dump(source []byte, level int) {
+	ast.DumpHelper(n, source, level, nil, nil)
+}
+
+func (n *astSpoiler) Kind() ast.NodeKind {
+	return astKindSpoiler
+}
+
+type spoilerDelimiterProcessor struct{}
+
+var defaultSpoilerDelimiterProcessor = &spoilerDelimiterProcessor{}
+
+func (p *spoilerDelimiterProcessor) IsDelimiter(b byte) bool {
+	return b == '|'
+}
+
+func (p *spoilerDelimiterProcessor) CanOpenCloser(opener, closer *parser.Delimiter) bool {
+	return opener.Char == closer.Char
+}
+
+func (p *spoilerDelimiterProcessor) OnMatch(consumes int) ast.Node {
+	return &astSpoiler{}
+}
+
+type spoilerParser struct{}
+
+var defaultSpoilerParser = &spoilerParser{}
+
+func NewSpoilerParser() parser.InlineParser {
+	return defaultSpoilerParser
+}
+
+func (s *spoilerParser) Trigger() []byte {
+	return []byte{'|'}
+}
+
+var spoilerRegex = regexp.MustCompile(`^\|\|(?:([^|]+?)\|[^|])?`)
+var spoilerContextKey = parser.NewContextKey()
+
+type spoilerContext struct {
+	reason  string
+	segment text.Segment
+	bottom  *parser.Delimiter
+}
+
+func (s *spoilerParser) Parse(parent ast.Node, block text.Reader, pc parser.Context) ast.Node {
+	line, segment := block.PeekLine()
+	if spoiler, ok := pc.Get(spoilerContextKey).(spoilerContext); ok {
+		if !bytes.HasPrefix(line, []byte("||")) {
+			return nil
+		}
+		block.Advance(2)
+		pc.Set(spoilerContextKey, nil)
+		n := &astSpoiler{
+			BaseInline: ast.BaseInline{},
+			reason:     spoiler.reason,
+		}
+		parser.ProcessDelimiters(spoiler.bottom, pc)
+		var c ast.Node = spoiler.bottom
+		for c != nil {
+			next := c.NextSibling()
+			parent.RemoveChild(parent, c)
+			n.AppendChild(n, c)
+			c = next
+		}
+		return n
+	}
+	match := spoilerRegex.FindSubmatch(line)
+	if match == nil {
+		return nil
+	}
+	length := 2
+	reason := string(match[1])
+	if len(reason) > 0 {
+		length += len(match[1]) + 1
+	}
+	block.Advance(length)
+	delim := parser.NewDelimiter(true, false, length, '|', defaultSpoilerDelimiterProcessor)
+	pc.Set(spoilerContextKey, spoilerContext{
+		reason:  reason,
+		segment: segment,
+		bottom:  delim,
+	})
+	return delim
+}
+
+func (s *spoilerParser) CloseBlock(parent ast.Node, pc parser.Context) {
+	// nothing to do
+}
+
+type spoilerHTMLRenderer struct {
+	html.Config
+}
+
+func NewSpoilerHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {
+	r := &spoilerHTMLRenderer{
+		Config: html.NewConfig(),
+	}
+	for _, opt := range opts {
+		opt.SetHTMLOption(&r.Config)
+	}
+	return r
+}
+
+func (r *spoilerHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
+	reg.Register(astKindSpoiler, r.renderSpoiler)
+}
+
+func (r *spoilerHTMLRenderer) renderSpoiler(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
+	if entering {
+		node := n.(*astSpoiler)
+		if len(node.reason) == 0 {
+			_, _ = w.WriteString("<span data-mx-spoiler>")
+		} else {
+			_, _ = fmt.Fprintf(w, `<span data-mx-spoiler="%s">`, stdhtml.EscapeString(node.reason))
+		}
+	} else {
+		_, _ = w.WriteString("</span>")
+	}
+	return ast.WalkContinue, nil
+}
+
+type extSpoiler struct{}
+
+// Spoiler is an extension that allow you to use spoiler expression like '||text||' or ||reason|text|| .
+//
+// There are some types of nested formatting that aren't supported with advanced spoilers.
+// The SimpleSpoiler extension that doesn't support reasons can be used to work around those.
+var Spoiler = &extSpoiler{}
+
+func (e *extSpoiler) Extend(m goldmark.Markdown) {
+	m.Parser().AddOptions(parser.WithInlineParsers(
+		util.Prioritized(NewSpoilerParser(), 500),
+	))
+	m.Renderer().AddOptions(renderer.WithNodeRenderers(
+		util.Prioritized(NewSpoilerHTMLRenderer(), 500),
+	))
+}