func (n *Node) Entry() []byte {
	return n.entry
}
Entry returns the value stored on the specific path.
package mantaray
import (
	"bytes"
	"context"
	"errors"
	"fmt"
)
const (
	PathSeparator = '/'  
)
var (
	ZeroObfuscationKey []byte
)
func init() {
	ZeroObfuscationKey = make([]byte, 32)
}
var (
	ErrNotFound         = errors.New("not found")
	ErrEmptyPath        = errors.New("empty path")
	ErrMetadataTooLarge = errors.New("metadata too large")
)
type Node struct {
	nodeType       uint8
	refBytesSize   int
	obfuscationKey []byte
	ref            []byte  
	entry          []byte
	metadata       map[string]string
	forks          map[byte]*fork
}
type fork struct {
	prefix []byte  
	*Node          
}
const (
	nodeTypeValue             = uint8(2)
	nodeTypeEdge              = uint8(4)
	nodeTypeWithPathSeparator = uint8(8)
	nodeTypeWithMetadata      = uint8(16)
	nodeTypeMask = uint8(255)
)
func nodeTypeIsWithMetadataType(nodeType uint8) bool {
	return nodeType&nodeTypeWithMetadata == nodeTypeWithMetadata
}
func NewNodeRef(ref []byte) *Node {
	return &Node{ref: ref}
}
func New() *Node {
	return &Node{forks: make(map[byte]*fork)}
}
func notFound(path []byte) error {
	return fmt.Errorf("entry on '%s' ('%x'): %w", path, path, ErrNotFound)
}
func (n *Node) IsValueType() bool {
	return n.nodeType&nodeTypeValue == nodeTypeValue
}
func (n *Node) IsEdgeType() bool {
	return n.nodeType&nodeTypeEdge == nodeTypeEdge
}
func (n *Node) IsWithPathSeparatorType() bool {
	return n.nodeType&nodeTypeWithPathSeparator == nodeTypeWithPathSeparator
}
func (n *Node) IsWithMetadataType() bool {
	return n.nodeType&nodeTypeWithMetadata == nodeTypeWithMetadata
}
func (n *Node) makeValue() {
	n.nodeType = n.nodeType | nodeTypeValue
}
func (n *Node) makeEdge() {
	n.nodeType = n.nodeType | nodeTypeEdge
}
func (n *Node) makeWithPathSeparator() {
	n.nodeType = n.nodeType | nodeTypeWithPathSeparator
}
func (n *Node) makeWithMetadata() {
	n.nodeType = n.nodeType | nodeTypeWithMetadata
}
func (n *Node) makeNotValue() {  
	n.nodeType = (nodeTypeMask ^ nodeTypeValue) & n.nodeType
}
func (n *Node) makeNotEdge() {  
	n.nodeType = (nodeTypeMask ^ nodeTypeEdge) & n.nodeType
}
func (n *Node) makeNotWithPathSeparator() {
	n.nodeType = (nodeTypeMask ^ nodeTypeWithPathSeparator) & n.nodeType
}
func (n *Node) makeNotWithMetadata() {  
	n.nodeType = (nodeTypeMask ^ nodeTypeWithMetadata) & n.nodeType
}
func (n *Node) SetObfuscationKey(obfuscationKey []byte) {
	bytes := make([]byte, 32)
	copy(bytes, obfuscationKey)
	n.obfuscationKey = bytes
}
func (n *Node) Reference() []byte {
	return n.ref
}