gtsocial-umbx

node.go (5649B)

---

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package html
 
 import (
 	"golang.org/x/net/html/atom"
 )
 
 // A NodeType is the type of a Node.
 type NodeType uint32
 
 const (
 	ErrorNode NodeType = iota
 	TextNode
 	DocumentNode
 	ElementNode
 	CommentNode
 	DoctypeNode
 	// RawNode nodes are not returned by the parser, but can be part of the
 	// Node tree passed to func Render to insert raw HTML (without escaping).
 	// If so, this package makes no guarantee that the rendered HTML is secure
 	// (from e.g. Cross Site Scripting attacks) or well-formed.
 	RawNode
 	scopeMarkerNode
 )
 
 // Section 12.2.4.3 says "The markers are inserted when entering applet,
 // object, marquee, template, td, th, and caption elements, and are used
 // to prevent formatting from "leaking" into applet, object, marquee,
 // template, td, th, and caption elements".
 var scopeMarker = Node{Type: scopeMarkerNode}
 
 // A Node consists of a NodeType and some Data (tag name for element nodes,
 // content for text) and are part of a tree of Nodes. Element nodes may also
 // have a Namespace and contain a slice of Attributes. Data is unescaped, so
 // that it looks like "a<b" rather than "a&lt;b". For element nodes, DataAtom
 // is the atom for Data, or zero if Data is not a known tag name.
 //
 // An empty Namespace implies a "http://www.w3.org/1999/xhtml" namespace.
 // Similarly, "math" is short for "http://www.w3.org/1998/Math/MathML", and
 // "svg" is short for "http://www.w3.org/2000/svg".
 type Node struct {
 	Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node
 
 	Type      NodeType
 	DataAtom  atom.Atom
 	Data      string
 	Namespace string
 	Attr      []Attribute
 }
 
 // InsertBefore inserts newChild as a child of n, immediately before oldChild
 // in the sequence of n's children. oldChild may be nil, in which case newChild
 // is appended to the end of n's children.
 //
 // It will panic if newChild already has a parent or siblings.
 func (n *Node) InsertBefore(newChild, oldChild *Node) {
 	if newChild.Parent != nil || newChild.PrevSibling != nil || newChild.NextSibling != nil {
 		panic("html: InsertBefore called for an attached child Node")
 	}
 	var prev, next *Node
 	if oldChild != nil {
 		prev, next = oldChild.PrevSibling, oldChild
 	} else {
 		prev = n.LastChild
 	}
 	if prev != nil {
 		prev.NextSibling = newChild
 	} else {
 		n.FirstChild = newChild
 	}
 	if next != nil {
 		next.PrevSibling = newChild
 	} else {
 		n.LastChild = newChild
 	}
 	newChild.Parent = n
 	newChild.PrevSibling = prev
 	newChild.NextSibling = next
 }
 
 // AppendChild adds a node c as a child of n.
 //
 // It will panic if c already has a parent or siblings.
 func (n *Node) AppendChild(c *Node) {
 	if c.Parent != nil || c.PrevSibling != nil || c.NextSibling != nil {
 		panic("html: AppendChild called for an attached child Node")
 	}
 	last := n.LastChild
 	if last != nil {
 		last.NextSibling = c
 	} else {
 		n.FirstChild = c
 	}
 	n.LastChild = c
 	c.Parent = n
 	c.PrevSibling = last
 }
 
 // RemoveChild removes a node c that is a child of n. Afterwards, c will have
 // no parent and no siblings.
 //
 // It will panic if c's parent is not n.
 func (n *Node) RemoveChild(c *Node) {
 	if c.Parent != n {
 		panic("html: RemoveChild called for a non-child Node")
 	}
 	if n.FirstChild == c {
 		n.FirstChild = c.NextSibling
 	}
 	if c.NextSibling != nil {
 		c.NextSibling.PrevSibling = c.PrevSibling
 	}
 	if n.LastChild == c {
 		n.LastChild = c.PrevSibling
 	}
 	if c.PrevSibling != nil {
 		c.PrevSibling.NextSibling = c.NextSibling
 	}
 	c.Parent = nil
 	c.PrevSibling = nil
 	c.NextSibling = nil
 }
 
 // reparentChildren reparents all of src's child nodes to dst.
 func reparentChildren(dst, src *Node) {
 	for {
 		child := src.FirstChild
 		if child == nil {
 			break
 		}
 		src.RemoveChild(child)
 		dst.AppendChild(child)
 	}
 }
 
 // clone returns a new node with the same type, data and attributes.
 // The clone has no parent, no siblings and no children.
 func (n *Node) clone() *Node {
 	m := &Node{
 		Type:     n.Type,
 		DataAtom: n.DataAtom,
 		Data:     n.Data,
 		Attr:     make([]Attribute, len(n.Attr)),
 	}
 	copy(m.Attr, n.Attr)
 	return m
 }
 
 // nodeStack is a stack of nodes.
 type nodeStack []*Node
 
 // pop pops the stack. It will panic if s is empty.
 func (s *nodeStack) pop() *Node {
 	i := len(*s)
 	n := (*s)[i-1]
 	*s = (*s)[:i-1]
 	return n
 }
 
 // top returns the most recently pushed node, or nil if s is empty.
 func (s *nodeStack) top() *Node {
 	if i := len(*s); i > 0 {
 		return (*s)[i-1]
 	}
 	return nil
 }
 
 // index returns the index of the top-most occurrence of n in the stack, or -1
 // if n is not present.
 func (s *nodeStack) index(n *Node) int {
 	for i := len(*s) - 1; i >= 0; i-- {
 		if (*s)[i] == n {
 			return i
 		}
 	}
 	return -1
 }
 
 // contains returns whether a is within s.
 func (s *nodeStack) contains(a atom.Atom) bool {
 	for _, n := range *s {
 		if n.DataAtom == a && n.Namespace == "" {
 			return true
 		}
 	}
 	return false
 }
 
 // insert inserts a node at the given index.
 func (s *nodeStack) insert(i int, n *Node) {
 	(*s) = append(*s, nil)
 	copy((*s)[i+1:], (*s)[i:])
 	(*s)[i] = n
 }
 
 // remove removes a node from the stack. It is a no-op if n is not present.
 func (s *nodeStack) remove(n *Node) {
 	i := s.index(n)
 	if i == -1 {
 		return
 	}
 	copy((*s)[i:], (*s)[i+1:])
 	j := len(*s) - 1
 	(*s)[j] = nil
 	*s = (*s)[:j]
 }
 
 type insertionModeStack []insertionMode
 
 func (s *insertionModeStack) pop() (im insertionMode) {
 	i := len(*s)
 	im = (*s)[i-1]
 	*s = (*s)[:i-1]
 	return im
 }
 
 func (s *insertionModeStack) top() insertionMode {
 	if i := len(*s); i > 0 {
 		return (*s)[i-1]
 	}
 	return nil
 }