func getClassWeight(s *goquery.Selection) float32 {
	weight := 0
	class, _ := s.Attr("class")
	id, _ := s.Attr("id")
	if class != "" {
		if negativeRegexp.MatchString(class) {
			weight -= 25
		}
		if positiveRegexp.MatchString(class) {
			weight += 25
		}
	}
	if id != "" {
		if negativeRegexp.MatchString(id) {
			weight -= 25
		}
		if positiveRegexp.MatchString(id) {
			weight += 25
		}
	}
	return float32(weight)
}
Get an elements class/id weight. Uses regular expressions to tell if this
element looks good or bad.
package readability  
import (
	"bytes"
	"fmt"
	"io"
	"math"
	"regexp"
	"strings"
	"miniflux.app/logger"
	"github.com/PuerkitoBio/goquery"
	"golang.org/x/net/html"
)
const (
	defaultTagsToScore = "section,h2,h3,h4,h5,h6,p,td,pre,div"
)
var (
	divToPElementsRegexp = regexp.MustCompile(`(?i)<(a|blockquote|dl|div|img|ol|p|pre|table|ul)`)
	sentenceRegexp       = regexp.MustCompile(`\.( |$)`)
	blacklistCandidatesRegexp  = regexp.MustCompile(`(?i)popupbody|-ad|g-plus`)
	okMaybeItsACandidateRegexp = regexp.MustCompile(`(?i)and|article|body|column|main|shadow`)
	unlikelyCandidatesRegexp   = regexp.MustCompile(`(?i)banner|breadcrumbs|combx|comment|community|cover-wrap|disqus|extra|foot|header|legends|menu|modal|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote`)
	negativeRegexp = regexp.MustCompile(`(?i)hidden|^hid$|hid$|hid|^hid |banner|combx|comment|com-|contact|foot|footer|footnote|masthead|media|meta|modal|outbrain|promo|related|scroll|share|shoutbox|sidebar|skyscraper|sponsor|shopping|tags|tool|widget|byline|author|dateline|writtenby|p-author`)
	positiveRegexp = regexp.MustCompile(`(?i)article|body|content|entry|hentry|h-entry|main|page|pagination|post|text|blog|story`)
)
type candidate struct {
	selection *goquery.Selection
	score     float32
}
func (c *candidate) Node() *html.Node {
	return c.selection.Get(0)
}
func (c *candidate) String() string {
	id, _ := c.selection.Attr("id")
	class, _ := c.selection.Attr("class")
	if id != "" && class != "" {
		return fmt.Sprintf("%s#%s.%s => %f", c.Node().DataAtom, id, class, c.score)
	} else if id != "" {
		return fmt.Sprintf("%s#%s => %f", c.Node().DataAtom, id, c.score)
	} else if class != "" {
		return fmt.Sprintf("%s.%s => %f", c.Node().DataAtom, class, c.score)
	}
	return fmt.Sprintf("%s => %f", c.Node().DataAtom, c.score)
}
type candidateList map[*html.Node]*candidate
func (c candidateList) String() string {
	var output []string
	for _, candidate := range c {
		output = append(output, candidate.String())
	}
	return strings.Join(output, ", ")
}
func ExtractContent(page io.Reader) (string, error) {
	document, err := goquery.NewDocumentFromReader(page)
	if err != nil {
		return "", err
	}
	document.Find("script,style").Each(func(i int, s *goquery.Selection) {
		removeNodes(s)
	})
	transformMisusedDivsIntoParagraphs(document)
	removeUnlikelyCandidates(document)
	candidates := getCandidates(document)
	logger.Debug("[Readability] Candidates: %v", candidates)
	topCandidate := getTopCandidate(document, candidates)
	logger.Debug("[Readability] TopCandidate: %v", topCandidate)
	output := getArticle(topCandidate, candidates)
	return output, nil
}
func getArticle(topCandidate *candidate, candidates candidateList) string {
	output := bytes.NewBufferString("<div>")
	siblingScoreThreshold := float32(math.Max(10, float64(topCandidate.score*.2)))
	topCandidate.selection.Siblings().Union(topCandidate.selection).Each(func(i int, s *goquery.Selection) {
		append := false
		node := s.Get(0)
		if node == topCandidate.Node() {
			append = true
		} else if c, ok := candidates[node]; ok && c.score >= siblingScoreThreshold {
			append = true
		}
		if s.Is("p") {
			linkDensity := getLinkDensity(s)
			content := s.Text()
			contentLength := len(content)
			if contentLength >= 80 && linkDensity < .25 {
				append = true
			} else if contentLength < 80 && linkDensity == 0 && sentenceRegexp.MatchString(content) {
				append = true
			}
		}
		if append {
			tag := "div"
			if s.Is("p") {
				tag = node.Data
			}
			html, _ := s.Html()
			fmt.Fprintf(output, "<%s>%s</%s>", tag, html, tag)
		}
	})
	output.Write([]byte("</div>"))
	return output.String()
}
func removeUnlikelyCandidates(document *goquery.Document) {
	document.Find("*").Not("html,body").Each(func(i int, s *goquery.Selection) {
		class, _ := s.Attr("class")
		id, _ := s.Attr("id")
		str := class + id
		if blacklistCandidatesRegexp.MatchString(str) || (unlikelyCandidatesRegexp.MatchString(str) && !okMaybeItsACandidateRegexp.MatchString(str)) {
			removeNodes(s)
		}
	})
}
func getTopCandidate(document *goquery.Document, candidates candidateList) *candidate {
	var best *candidate
	for _, c := range candidates {
		if best == nil {
			best = c
		} else if best.score < c.score {
			best = c
		}
	}
	if best == nil {
		best = &candidate{document.Find("body"), 0}
	}
	return best
}
func getCandidates(document *goquery.Document) candidateList {
	candidates := make(candidateList)
	document.Find(defaultTagsToScore).Each(func(i int, s *goquery.Selection) {
		text := s.Text()
		if len(text) < 25 {
			return
		}
		parent := s.Parent()
		parentNode := parent.Get(0)
		grandParent := parent.Parent()
		var grandParentNode *html.Node
		if grandParent.Length() > 0 {
			grandParentNode = grandParent.Get(0)
		}
		if _, found := candidates[parentNode]; !found {
			candidates[parentNode] = scoreNode(parent)
		}
		if grandParentNode != nil {
			if _, found := candidates[grandParentNode]; !found {
				candidates[grandParentNode] = scoreNode(grandParent)
			}
		}
		contentScore := float32(1.0)
		contentScore += float32(strings.Count(text, ",") + 1)
		contentScore += float32(math.Min(float64(int(len(text)/100.0)), 3))
		candidates[parentNode].score += contentScore
		if grandParentNode != nil {
			candidates[grandParentNode].score += contentScore / 2.0
		}
	})
	for _, candidate := range candidates {
		candidate.score = candidate.score * (1 - getLinkDensity(candidate.selection))
	}
	return candidates
}
func scoreNode(s *goquery.Selection) *candidate {
	c := &candidate{selection: s, score: 0}
	switch s.Get(0).DataAtom.String() {
	case "div":
		c.score += 5
	case "pre", "td", "blockquote", "img":
		c.score += 3
	case "address", "ol", "ul", "dl", "dd", "dt", "li", "form":
		c.score -= 3
	case "h1", "h2", "h3", "h4", "h5", "h6", "th":
		c.score -= 5
	}
	c.score += getClassWeight(s)
	return c
}
func getLinkDensity(s *goquery.Selection) float32 {
	linkLength := len(s.Find("a").Text())
	textLength := len(s.Text())
	if textLength == 0 {
		return 0
	}
	return float32(linkLength) / float32(textLength)
}