package main
import (
	"bytes"
	"golang.org/x/net/html"
	"golang.org/x/net/html/atom"
	"log"
	"strings"
)
func nodeIndexOffset(context *html.Node, node *html.Node) (int, int) {
	if node.Type != html.TextNode {
		node = node.FirstChild
	}
	originalData := node.Data
	var buf bytes.Buffer
	node.Data = "|start|" + originalData
	_ = html.Render(&buf, context.FirstChild)
	start := strings.Index(buf.String(), "|start|")
	buf = bytes.Buffer{}
	node.Data = originalData + "|end|"
	_ = html.Render(&buf, context.FirstChild)
	end := strings.Index(buf.String(), "|end|")
	node.Data = originalData
	return start, end
}
func main() {
	s := "<div>Hello, <b>World!</b></div>"
	var context html.Node
	context = html.Node{
		Type:     html.ElementNode,
		Data:     "body",
		DataAtom: atom.Body,
	}
	nodes, err := html.ParseFragment(strings.NewReader(s), &context)
	if err != nil {
		log.Fatal(err)
	}
	for _, node := range nodes {
		context.AppendChild(node)
	}
	world := nodes[0].FirstChild.NextSibling.FirstChild
	log.Println("target", world)
	log.Println(nodeIndexOffset(&context, world))
}

func parseWithIndexes(p *parser) (map[*Node][2]int, error) {
    // 迭代直到文件结束。任何其他错误将导致提前返回。
    var err error
    var globalBufDif int
    var prevEndBuf int
    var tokenIndex [2]int
    tokenMap := make(map[*Node][2]int)
    for err != io.EOF {
        // 仅在外部内容中允许CDATA部分。
        n := p.oe.top()
        p.tokenizer.AllowCDATA(n != nil && n.Namespace != "")
        t := p.top().FirstChild
        for {
            if t != nil && t.NextSibling != nil {
                t = t.NextSibling
            } else {
                break
            }
        }
        tokenMap[t] = tokenIndex
        if prevEndBuf > p.tokenizer.data.end {
            globalBufDif += prevEndBuf
        }
        prevEndBuf = p.tokenizer.data.end
        // 读取并解析下一个标记。
        p.tokenizer.Next()
        tokenIndex = [2]int{p.tokenizer.data.start + globalBufDif, p.tokenizer.data.end + globalBufDif}
        p.tok = p.tokenizer.Token()
        if p.tok.Type == ErrorToken {
            err = p.tokenizer.Err()
            if err != nil && err != io.EOF {
                return tokenMap, err
            }
        }
        p.parseCurrentToken()
    }
    return tokenMap, nil
}
// ParseFragmentWithIndexes解析HTML片段并返回找到的节点。如果片段是现有元素的InnerHTML，请将该元素传递给上下文。
func ParseFragmentWithIndexes(r io.Reader, context *Node) ([]*Node, map[*Node][2]int, error) {
    contextTag := ""
    if context != nil {
        if context.Type != ElementNode {
            return nil, nil, errors.New("html: ParseFragment of non-element Node")
        }
        // 下面的检查不仅仅是 context.DataAtom.String() == context.Data，因为传递一个标签不是已知原子的元素是有效的。例如，DataAtom == 0 并且 Data = "tagfromthefuture" 是完全一致的。
        if context.DataAtom != a.Lookup([]byte(context.Data)) {
            return nil, nil, fmt.Errorf("html: inconsistent Node: DataAtom=%q, Data=%q", context.DataAtom, context.Data)
        }
        contextTag = context.DataAtom.String()
    }
    p := &parser{
        tokenizer: NewTokenizerFragment(r, contextTag),
        doc: &Node{
            Type: DocumentNode,
        },
        scripting: true,
        fragment:  true,
        context:   context,
    }
    root := &Node{
        Type:     ElementNode,
        DataAtom: a.Html,
        Data:     a.Html.String(),
    }
    p.doc.AppendChild(root)
    p.oe = nodeStack{root}
    p.resetInsertionMode()
    for n := context; n != nil; n = n.Parent {
        if n.Type == ElementNode && n.DataAtom == a.Form {
            p.form = n
            break
        }
    }
    tokenMap, err := parseWithIndexes(p)
    if err != nil {
        return nil, nil, err
    }
    parent := p.doc
    if context != nil {
        parent = root
    }
    var result []*Node
    for c := parent.FirstChild; c != nil; {
        next := c.NextSibling
        parent.RemoveChild(c)
        result = append(result, c)
        c = next
    }
    return result, tokenMap, nil
}