Content inside gojax<br />
(The <a href='#raw'>raw file</a> follows this syntax highlighted file.)<br /><br />
<link rel="stylesheet" href="https://unpkg.com/@highlightjs/cdn-assets@11.6.0/styles/stackoverflow-light.min.css">
<script src="https://unpkg.com/@highlightjs/cdn-assets@11.6.0/highlight.min.js"></script>
<script>hljs.highlightAll();</script>
<pre><code>/*
Gojax provides a json-ish and xml-ish tool to convert json-ish to xml-ish so you can use an
xpath-ish expression to manipulate the resulting xml. If you can set aside the ishs, you can use
this package to work with JSON and XML.

The Consequences of ish

For JSON, the following are meant by the expression of &#39;ish&#39; above:
  - A single object is the only allowed root element
  - For numbers, only sequences of digits possibly prefixed with a negative sign are supported,
    including zero prefixed numbers
  - For strings, anything can be escaped, but unicode hexadecimal expressions are not supported
  - Finally, for whitespace, anything that returns true from unicode.IsSpace is accepted

For XML, only the least is supported - hence the &#39;ish&#39; above.
  - Nodes can have names from any JSON string
  - Attribute keys and values are any Golang string
  - JSON arrays have each inner-element nested inside a node with the following
    format: `&lt;n index=&#34;0&#34;&gt;...&lt;/n&gt;`, where the 0 is replaced with the element&#39;s index in the array
  - The JSON values of true, false, and null all convert to XML content as those runes
  - Also, XML attributes are sorted in the output

For XPath, also, only the least is supported.
  - You can separate path parts with either a / or // as in `/firstPathPart/secondPathPart`
  - A single / requires the successive path part to match the node name of a child of the current XMLNode
  - The double // allows the successive path part to match any descendant node name and
    can occur as a prefix to any path part such as `/firstPathPart//secondPathPart``
  - Filters are placed after node names in any path part following a syntax
    such as `/nodeName[k=v]`, where k is any attribute key (or any descendant node name) and v is any attribute value
    (or that same descendant node&#39;s AnyContent result) with both being required to match the entire key or value respectively
  - As an example of a descendant node content filter, given structure like
    `{&#34;a&#34;:[{&#34;b&#34;:{&#34;c&#34;:1}}, {&#34;b&#34;:{&#34;c&#34;:1}}, {&#34;b&#34;:{&#34;c&#34;:2}}]}` and a path like `//b[c=2]`, you could
    find the node `&lt;b&gt;&lt;c&gt;2&lt;/c&gt;&lt;/b&gt;`
  - Filters also support two special keys: meta and position(). The meta special key only
    supports one value &#39;no_attrs&#39;, which will only match nodes that have no attributes. The position()
    special key supports digits as values and checks that the position of that node in it&#39;s parents slice
    of children matches the given value.
  - In addition to checking an exact match for the childs position with an =, the position() special
    key supports &gt; and &lt; operators that filter nodes as expected.
  - The wildcard * is supported and matches any node name

As noted below, the above results in some restrictions:
  - Node names cannot contain [ or / (unless you use [ in the givenName parameter when calling NewXMLNode)
  - Node attribute keys and values cannot contain [ or ] or = or &gt; or &lt; or /

Sample Code

All that given, here is a simple sample usage:

	package main

	import (
		&#34;fmt&#34;
		&#34;git.ondollo.com/gojax&#34;
	)

	func main() {
			r := gojax.NewXMLNode(&#34;root#123[a=1]&#34;)
			b := gojax.NewXMLNode(&#34;b&#34;)
			b.Add(gojax.NewXMLContentNode(&#34;2&#34;))
			r.Add(b)
			c := gojax.NewXMLNode(&#34;c&#34;)
			d := gojax.NewXMLNode(&#34;d&#34;)
			d.Add(gojax.NewXMLContentNode(&#34;3&#34;))
			c.Add(d)
			r.Add(c)
			fmt.Println(r) // &lt;root a=&#34;1&#34; id=&#34;123&#34;&gt;&lt;b&gt;2&lt;/b&gt;&lt;c&gt;&lt;d&gt;3&lt;/d&gt;&lt;/c&gt;&lt;/root&gt;

			x, err := gojax.FromJSON(&#34;root&#34;, `{&#34;a&#34;:{&#34;b&#34;:1}}`)
			if err != nil {
				fmt.Println(&#34;Failed to build an XMLNode from the given JSON:&#34;, err)
			}
			fmt.Println(x.Path(&#34;//b&#34;)) // [&lt;b&gt;1&lt;/b&gt;] &lt;nil&gt;

			x, err = gojax.FromJSON(&#34;root&#34;, `{&#34;a&#34;:[{&#34;b&#34;:&#34;c&#34;},{&#34;b&#34;:&#34;d&#34;}]}`)
			if err != nil {
				fmt.Println(&#34;Failed to build an XMLNode from the given JSON:&#34;, err)
			}
			fmt.Println(x.Path(&#34;//n[index=0]&#34;)) // [&lt;n index=&#34;0&#34;&gt;&lt;b&gt;c&lt;/b&gt;&lt;/n&gt;] &lt;nil&gt;
		}
	}

*/
package gojax

import (
	&#34;bufio&#34;
	&#34;errors&#34;
	&#34;fmt&#34;
	&#34;io&#34;
	&#34;regexp&#34;
	&#34;runtime/debug&#34;
	&#34;sort&#34;
	&#34;strconv&#34;
	&#34;strings&#34;
	&#34;unicode&#34;
	&#34;unicode/utf8&#34;
)

// Options allows setting any of three options to make minor adjustments to the output of this library.
// For functions ending in `WithOptions`, the final parameter will have the Options type.
//
// When Debug is true additional data is available. Avoid using this.
// The default is false.
//
// When OutputHeader is true, the string `&lt;?xml version=&#34;1.0&#34;?&gt;` will be output on any call to
// String for an XMLNode without a parent.
// The default is true.
//
// When WrapArrayElements is true, each element in an array will be wrapped with an element that follows the
// format: `&lt;n index=&#34;0&#34;&gt;...&lt;/n&gt;`, where the 0 is replaced with the element&#39;s index in the array.
// The default is true.
type Options struct {
	Debug             bool
	OutputHeader      bool
	WrapArrayElements bool
}

// DefaultTestOptions provide a reference to the default test Options
var DefaultTestOptions = Options{false, false, true}
var defaultOptions = Options{false, true, true}
var defaultDebugOptions = Options{true, true, true}

func setNoHeader(givenOptions Options) Options {
	return Options{givenOptions.Debug, false, givenOptions.WrapArrayElements}
}

/*
XMLNode provides just enough structure for the subset of XML that gojax supports.
*/
type XMLNode struct {
	givenName     string
	name          string
	Content       string
	Attrs         map[string]string
	children      []*XMLNode
	parent        *XMLNode
	ntype         possibleState
	cameFromCDATA bool
}

var invalidPath = errors.New(&#34;Invalid path&#34;)

var attrsRegex = regexp.MustCompile(`\[([^=&gt;&lt;]&#43;[=&gt;&lt;][^\]]&#43;)\]`)
var innerAttrsRegex = regexp.MustCompile(`[=&gt;&lt;]`)
var cleanNameRegex = regexp.MustCompile(`[^-a-zA-Z0-9_.]`)
var xmlPrefixRegex = regexp.MustCompile(`^(?i)xml`)
var letterOrUnderscorePrefixRegex = regexp.MustCompile(`^[a-zA-Z_]`)
var namespaceRegex = regexp.MustCompile(`^([a-zA-Z_][-a-zA-Z0-9_.]&#43;):`)

func protectNamespace(s string) string          { return namespaceRegex.ReplaceAllString(s, &#34;${1}NSPROTECTION&#34;) }
func removeNamespaceProtection(s string) string { return strings.Replace(s, &#34;NSPROTECTION&#34;, &#34;:&#34;, 1) }

var notEnough = errors.New(&#34;Not enough XMLNodes in slice&#34;)

// First returns the first XMLNode from a slice.
// The parameters are meant to match the Path return values.
// The error either came from Path or was a result of calling First on an empty slice of XMLNodes.
func First(xns []*XMLNode, err error) (*XMLNode, error) { // Tied to output of Path
	if err != nil {
		return nil, err
	}
	if len(xns) &lt; 1 {
		return nil, notEnough
	}
	return xns[0], nil
}

// FirstOr will call Path on the givenNode passing in the givenPath, and either return the first match, or panic
func FirstOr(givenNode *XMLNode, givenPath string) *XMLNode {
	xns, err := givenNode.Path(givenPath)
	if err != nil {
		panic(fmt.Sprintf(
			&#34;The path `%s` matched zero nodes when at least one was required with an error of: %s.&#34;,
			givenPath,
			err,
		))
	}
	if len(xns) &lt; 1 {
		panic(fmt.Sprintf(&#34;The path `%s` matched zero nodes when at least one was required.&#34;, givenPath))
	}
	return xns[0]
}

// Last returns the last XMLNode from a slice.
// The parameters are meant to match the Path return values.
// The error either came from Path or was a result of calling Last on an empty slice of XMLNodes.
func Last(xns []*XMLNode, err error) (*XMLNode, error) { // Tied to output of Path
	if err != nil {
		return nil, err
	}
	if len(xns) &lt; 1 {
		return nil, notEnough
	}
	return xns[len(xns)-1], nil
}

// LastOr will return the last in a slice of XMLNode, or panic.
// The parameters are meant to match the Path return values.
// The error either came from Path or was a result of calling Last on an empty slice of XMLNodes.
func LastOr(givenNodes []*XMLNode, err error) *XMLNode { // Tied to output of Path
	xn, err := Last(givenNodes, err)
	if err != nil {
		panic(fmt.Sprintf(&#34;Failed to get last node with an error of: %s.&#34;, err))
	}
	return xn
}

// Reprocess runs the givenPath on each of the XMLNodes in givenNodes, collecting and then returning a unique list of matches
func Reprocess(givenNodes []*XMLNode, givenPath string) []*XMLNode {
	result := []*XMLNode{}
	for _, xn := range givenNodes {
		innerXNS, err := xn.Path(givenPath)
		if err == nil {
			for _, innerXN := range innerXNS {
				shouldAdd := true
				for _, tmpxn := range result {
					if tmpxn == innerXN {
						shouldAdd = false
						break
					}
				}
				if shouldAdd {
					result = append(result, innerXN)
				}
			}
		}
	}
	return result
}

var specialKeys = []string{
	&#34;meta&#34;,
	&#34;position()&#34;, // Here to block setting this attr through a givenName
	&#34;=position()&#34;,
	&#34;&gt;position()&#34;,
	&#34;&lt;position()&#34;,
}

func isSpecialKey(k string) bool {
	for _, sk := range specialKeys {
		if k == sk {
			return true
		}
	}
	return false
}

// PathOr will call Path on the givenNode passing in the givenPath, and either return all matches, or panic
func (x *XMLNode) PathOr(givenPath string) []*XMLNode {
	xns, err := x.Path(givenPath)
	if err != nil {
		panic(fmt.Sprintf(
			&#34;The path `%s` matched zero nodes when at least one was required with an error of: %s.&#34;,
			givenPath,
			err,
		))
	}
	if len(xns) &lt; 1 {
		panic(fmt.Sprintf(&#34;The path `%s` matched zero nodes when at least one was required.&#34;, givenPath))
	}
	return xns
}

/*
Path will take the givenPath and attempt to traverse the XMLNode structure.
If it is successful it will return all XMLNodes that satisfy the constraints
of the givenPath, or an empty XMLNode slice with an error.

At each node we can have some remainder of the givenPath (with double prioritized to disambiguate):
	/		- return the node we&#39;re at
	//a		- find all descendants with a name of &#39;a&#39; and return them
	/a		- find a child with a name of &#39;a&#39; and return it
	//a/&lt;rest&gt;	- recurse into all descendants with a name of &#39;a&#39; and run Path(`/&lt;rest&gt;`) on every descendant - keep any full match
	/a/&lt;rest&gt;	- recurse into a child with a name of &#39;a&#39; and run Path(`/&lt;rest&gt;`) on that child - keep any full match

Attribute filters look like:
	nodeName[k=v]	- only match the node with a name of &#39;nodeName&#39; if it has an attribute &#39;k&#39; with a value of &#39;v&#39;

Consequences of this approach:
  - Node names cannot contain [ or / (unless you use [ in the givenName parameter when calling NewXMLNode)
  - Node attribute keys and values cannot contain [ or ] or = or &gt; or &lt; or /
*/
func (x *XMLNode) Path(givenPath string) ([]*XMLNode, error) {
	if len(givenPath) &gt; 1 {
		givenPath = strings.TrimRight(givenPath, &#34;/&#34;)
	}
	startsWithDouble := strings.HasPrefix(givenPath, &#34;//&#34;)
	startsWithSingle := !startsWithDouble &amp;&amp; strings.HasPrefix(givenPath, &#34;/&#34;)
	if !startsWithSingle &amp;&amp; !startsWithDouble {
		return nil, invalidPath
	}
	cleans := strings.TrimLeft(givenPath, &#34;/&#34;)
	part := cleans
	rest := &#34;&#34;
	firstSep := strings.Index(cleans, &#34;/&#34;)
	hasParts := firstSep &gt; 0
	onlyPart := !hasParts
	if hasParts {
		part = cleans[:firstSep]
		rest = cleans[firstSep:]
	}
	attrFilterStart := strings.Index(part, &#34;[&#34;)
	mightHaveAttrFilter := attrFilterStart &gt; 0
	filters := map[string]string{}
	filtersPass := func(x *XMLNode) bool {
		for k, v := range filters {
			if isSpecialKey(k) {
				continue
			}
			if x.Attrs[k] != v {
				cleank := strings.TrimLeft(k, &#34;/&#34;)
				xns, err := x.Path(fmt.Sprintf(&#34;//%s&#34;, cleank))
				if err == nil {
					for _, xn := range xns {
						if xn.AnyContent() == v {
							return true
						}
					}
				}
				return false
			}
		}
		return true
	}
	specialAttrsMatch := func(x *XMLNode) bool {
		for k, v := range filters {
			if !isSpecialKey(k) {
				continue
			}
			switch {
			case k == &#34;meta&#34;:
				if v == &#34;no_attrs&#34; &amp;&amp; len(x.Attrs) &gt; 0 {
					return false
				}
			case strings.HasSuffix(k, &#34;position()&#34;):
				iv, err := strconv.Atoi(v)
				if err != nil || x.parent == nil {
					return false
				}
				for i, child := range x.parent.children {
					if child == x {
						switch string(k[0]) {
						case &#34;=&#34;:
							return i == iv
						case &#34;&gt;&#34;:
							return i &gt; iv
						case &#34;&lt;&#34;:
							return i &lt; iv
						}
					}
				}
				return false
			}
		}
		return true
	}
	if mightHaveAttrFilter {
		matches := attrsRegex.FindAllStringSubmatch(part[attrFilterStart:], -1)
		if len(matches) &gt; 0 {
			part = part[:attrFilterStart]
			for _, match := range matches {
				parts := innerAttrsRegex.Split(match[1], -1)
				if len(parts) != 2 {
					panic(&#34;Regex for attr parts failed to split in two&#34;)
				}
				k := parts[0]
				if k == &#34;position()&#34; {
					tmppos := len(parts[0])
					k = match[1][tmppos:tmppos&#43;1] &#43; k
				}
				filters[k] = parts[1]
			}
		}
	}
	if givenPath == &#34;/&#34; {
		return []*XMLNode{x}, nil
	} else if startsWithDouble &amp;&amp; onlyPart {
		matched := []*XMLNode{}
		pending := []*XMLNode{x}
		for i := 0; i &lt; len(pending); i&#43;&#43; {
			current := pending[i]
			for _, child := range current.children {
				pending = append(pending, child)
			}
			if (part == &#34;*&#34; || current.GetName() == part) &amp;&amp; filtersPass(current) &amp;&amp; specialAttrsMatch(current) {
				matched = append(matched, current)
			}
		}
		return matched, nil
	} else if startsWithSingle &amp;&amp; onlyPart {
		if (part == &#34;*&#34; || x.GetName() == part) &amp;&amp; filtersPass(x) &amp;&amp; specialAttrsMatch(x) {
			return []*XMLNode{x}, nil
		}
	} else if startsWithDouble &amp;&amp; hasParts {
		matched := []*XMLNode{}
		pending := []*XMLNode{x}
		for i := 0; i &lt; len(pending); i&#43;&#43; {
			current := pending[i]
			for _, child := range current.children {
				pending = append(pending, child)
			}
			matches, err := current.Path(givenPath[1:])
			if err == nil {
				for _, match := range matches {
					matched = append(matched, match)
				}
			}
		}
		return matched, nil
	} else if startsWithSingle &amp;&amp; hasParts {
		if (part == &#34;*&#34; || x.GetName() == part) &amp;&amp; filtersPass(x) &amp;&amp; specialAttrsMatch(x) {
			possibleResults := []*XMLNode{}
			for _, child := range x.children {
				possibleResult, err := child.Path(rest)
				if err == nil {
					possibleResults = append(possibleResults, possibleResult...)
				}
			}
			return possibleResults, nil
		}
	} else {
		return nil, invalidPath
	}
	return []*XMLNode{}, nil
}

// UnwrappedOr will call FromJSON passing in an internally known root and then return the contents inside that root, or panic
func UnwrappedOr(givenJson string) []*XMLNode {
	return UnwrappedOrWithOptions(givenJson, defaultOptions)
}

/*
UnwrappedOrWithOptions is the same as UnwrappedOr, but allows passing custom Options in.
You will likely want to just use UnwrappedOr.
*/
func UnwrappedOrWithOptions(givenJson string, givenOptions Options) []*XMLNode {
	xn, err := FromJSONWithOptions(`r`, givenJson, givenOptions)
	if err != nil {
		panic(&#34;The givenJson was invalid when it was required to be valid: &#34; &#43; err.Error())
	}
	return xn.PathOr(`/r/*`)
}

// NewXMLNode returns an XMLNode with the givenName as it&#39;s name.
// There are some supported variations to express attributes, including an id, inside the givenName:
//
//  * You can set the id attribute with nodeName#idValue
//  * You can set attributes with nodeName[k=v]
//  * If any, the id needs to come before attrs and will override any attribute key &#39;id&#39; set through [] notation
//
// So, combining the above, you can set attrs and id with:
//    nodeName#idValue[k=v]
// Additionally, the special attribute keys available in paths won&#39;t hold specific meaning here and are ignored.
//
// Finally, no attempt is made to ensure the uniqueness of any id attribute within any XMLNode
func NewXMLNode(givenName string) *XMLNode { return stateXMLNode(givenName, none) }
func stateXMLNode(givenName string, state possibleState) *XMLNode {
	result := &amp;XMLNode{givenName, &#34;&#34;, &#34;&#34;, map[string]string{}, []*XMLNode{}, nil, state, false}
	name, attrs := nameAttrsFrom(givenName)
	result.name = name
	for k, v := range attrs {
		result.Set(k, v)
	}
	return result
}
func nameAttrsFrom(givenName string) (string, map[string]string) {
	attrStart := strings.Index(givenName, &#34;[&#34;)
	mightHaveAttrs := attrStart &gt; 0
	givenAttrs := map[string]string{}
	if mightHaveAttrs {
		matches := attrsRegex.FindAllStringSubmatch(givenName[attrStart:], -1)
		if len(matches) &gt; 0 {
			for _, match := range matches {
				parts := innerAttrsRegex.Split(match[1], -1)
				if len(parts) != 2 {
					panic(&#34;Regex for attr parts failed to split in two&#34;)
				}
				k := parts[0]
				if !isSpecialKey(k) {
					givenAttrs[k] = parts[1]
				}
			}
			givenName = givenName[:attrStart]
		}
	}
	if parts := strings.Split(givenName, &#34;#&#34;); len(parts) &gt; 1 &amp;&amp; len(parts[1]) &gt; 0 {
		givenName = parts[0]
		givenAttrs[&#34;id&#34;] = parts[1]
	}
	return givenName, givenAttrs
}

// NewXMLContentNode returns an XMLNode with the givenContent as it&#39;s Content
func NewXMLContentNode(givenContent string) *XMLNode {
	return stateXMLContentNode(givenContent, none)
}
func stateXMLContentNode(givenContent string, state possibleState) *XMLNode {
	return &amp;XMLNode{&#34;&#34;, &#34;&#34;, givenContent, map[string]string{}, []*XMLNode{}, nil, state, false}
}

// String will output XML from an XMLNode structure.
// If you&#39;d like to output JSON, use the JSON method.
func (x XMLNode) String() string {
	return x.StringWithOptions(defaultOptions)
}

/*
StringWithOptions is the same as String, but allows passing custom Options in.
You will likely want to just use String.
*/
func (x XMLNode) StringWithOptions(givenOptions Options) string {
	if len(x.Content) &gt; 0 {
		result := x.Content
		shouldBeWrapped := x.cameFromCDATA ||
			strings.Contains(result, `&amp;`) ||
			strings.Contains(result, `&lt;`) ||
			strings.Contains(result, `]]&gt;`)
		if shouldBeWrapped {
			result = `&lt;![CDATA[` &#43; strings.ReplaceAll(result, `]]&gt;`, `]]]]&gt;&lt;![CDATA[&gt;`) &#43; `]]&gt;`
		}
		return result
	}
	var result strings.Builder
	if x.parent == nil &amp;&amp; givenOptions.OutputHeader {
		result.WriteString(`&lt;?xml version=&#34;1.0&#34;?&gt;`)
	}
	cleanName := protectNamespace(x.GetName())
	cleanName = cleanNameRegex.ReplaceAllString(cleanName, &#34;_&#34;)
	if xmlPrefixRegex.MatchString(cleanName) || !letterOrUnderscorePrefixRegex.MatchString(cleanName) {
		cleanName = &#34;_&#34; &#43; cleanName
	}
	cleanName = removeNamespaceProtection(cleanName)
	result.WriteString(&#34;&lt;&#34; &#43; cleanName)
	tmpks := []string{}
	for k, _ := range x.Attrs {
		tmpks = append(tmpks, k)
	}
	sort.Strings(tmpks)
	for _, k := range tmpks {
		result.WriteString(fmt.Sprintf(&#34; %s=%q&#34;, k, x.Attrs[k]))
	}
	result.WriteString(&#34;&gt;&#34;)
	for _, child := range x.children {
		result.WriteString(child.StringWithOptions(givenOptions))
	}
	result.WriteString(&#34;&lt;/&#34; &#43; cleanName &#43; &#34;&gt;&#34;)
	return result.String()
}

// JSON produces a JSON output from an XMLNode structure.
// Children are output in the same order they exist in in the XMLNode structure with matching names simply repeated.
func (x XMLNode) JSON() string {
	if len(x.Content) &gt; 0 {
		return fmt.Sprintf(`%q`, x.Content)
	}
	var result strings.Builder
	cleanName := protectNamespace(x.GetName())
	cleanName = cleanNameRegex.ReplaceAllString(cleanName, &#34;_&#34;)
	if xmlPrefixRegex.MatchString(cleanName) || !letterOrUnderscorePrefixRegex.MatchString(cleanName) {
		cleanName = &#34;_&#34; &#43; cleanName
	}
	cleanName = removeNamespaceProtection(cleanName)
	if x.parent == nil {
		result.WriteString(`{`)
	}
	result.WriteString(`&#34;` &#43; cleanName)
	result.WriteString(`&#34;:`)
	if len(x.children) &gt; 0 { // TODO - so attrs will only show up on a node with children and NOT content...
		if len(x.children[0].Content) == 0 {
			result.WriteString(&#34;{&#34;)
			tmpks := []string{}
			for k, _ := range x.Attrs {
				tmpks = append(tmpks, k)
			}
			sort.Strings(tmpks)
			for _, k := range tmpks {
				result.WriteString(fmt.Sprintf(&#34;%q:%q&#34;, k, x.Attrs[k]))
				result.WriteString(&#34;,&#34;) // This isn&#39;t written &#39;before&#39;, since we know there&#39;ll be children
			}
		}
		childrenNames := []string{}
		childrenByName := map[string][]*XMLNode{}
		for _, child := range x.children {
			//cn := child.givenName
			cn := child.name
			previousValue, exists := childrenByName[cn]
			if exists {
				childrenByName[cn] = append(previousValue, child)
			} else {
				childrenByName[cn] = []*XMLNode{child}
				childrenNames = append(childrenNames, cn)
			}
		}
		sort.Strings(childrenNames)
		notFirstChild := false
		for _, name := range childrenNames {
			v := childrenByName[name]
			if notFirstChild {
				result.WriteString(&#34;,&#34;)
			}
			if len(v) == 1 {
				result.WriteString(v[0].JSON())
			} else {
				childKey := strings.SplitN(v[0].JSON(), &#34;:&#34;, 2)[0]
				result.WriteString(childKey)
				result.WriteString(&#34;:[&#34;)
				for i, childV := range v {
					if i &gt; 0 {
						result.WriteString(&#34;,&#34;)
					}
					result.WriteString(strings.SplitN(childV.JSON(), &#34;:&#34;, 2)[1])
				}
				result.WriteString(&#34;]&#34;)
			}
			notFirstChild = true
		}
		if len(x.children[0].Content) == 0 {
			result.WriteString(&#34;}&#34;)
		}
	} else {
		result.WriteString(`&#34;&#34;`)
	}
	if x.parent == nil {
		result.WriteString(`}`)
	}
	return result.String()
}

// SetName will turn any valid givenName expression into the resulting name and attributes, including id.
func (x *XMLNode) SetName(givenName string) {
	x.givenName = givenName
	name, attrs := nameAttrsFrom(givenName)
	x.name = name
	for k, v := range attrs {
		x.Set(k, v)
	}
}

// GetName will return the calculated name of the node.
func (x *XMLNode) GetName() string { return x.name }

func (x *XMLNode) updateName(givenRune rune) { x.SetName(x.givenName &#43; string(givenRune)) }

// Set will assign the value v to the attribute key k
func (x *XMLNode) Set(k string, v string) { x.Attrs[k] = v }

// Get will the value v that is assigned to the attribute key k
func (x *XMLNode) Get(k string) string { return x.Attrs[k] }

// AnyContent will return either the content inside x or, if x has only one child that is a content node, the content of that one
func (x *XMLNode) AnyContent() string {
	if len(x.children) == 1 &amp;&amp; len(x.children[0].name) == 0 {
		return x.children[0].Content
	}
	return x.Content
}

// Add appends the XMLNode xn as a child in the children XMLNode slice of the XMLNode x
func (x *XMLNode) Add(xn *XMLNode) {
	if x == xn {
		panic(&#34;You can&#39;t add a node to itself&#34;)
	}
	xn.parent = x
	x.children = append(x.children, xn)
}

// AddAll appends all of the XMLNodes xns as children to the XMLNode x
func (x *XMLNode) AddAll(xns []*XMLNode) {
	for _, xn := range xns {
		if x == xn {
			panic(&#34;You can&#39;t add a node to itself&#34;)
		}
		x.Add(xn)
	}
}

var notAChild = errors.New(&#34;Unable to modify parent/child relationship. Given child is not in parent.&#34;)

// Remove will remove the XMLNode xn from x and possibly return an error if xn is not a child of x
func (x *XMLNode) Remove(xn *XMLNode) error {
	for i, n := range x.children {
		if n == xn {
			n.parent = nil
			x.children = append(x.children[:i], x.children[i&#43;1:]...)
			return nil
		}
	}
	return notAChild
}

// Cut will remove the XMLNode x from it&#39;s parent and possibly return an error if x is the root
func (x *XMLNode) Cut() error {
	if x.parent == nil {
		return nil
	}
	return x.parent.Remove(x)
}

func nodeIsRoot(action string) error {
	return errors.New(fmt.Sprintf(&#34;Unable to %s on root node&#34;, action))
}

// AddBefore will add xn as a sibling of x just before x&#39;s position in the list of the parents children
// and possibly return an error if x is the root.
// The XMLNode xn will be Cut before being added to x.
func (x *XMLNode) AddBefore(xn *XMLNode) error {
	if x.parent == nil {
		return nodeIsRoot(&#34;AddBefore&#34;)
	}
	p := x.parent
	if err := xn.Cut(); err != nil {
		return errors.New(&#34;Failed to cut xn inside call to AddBefore&#34;)
	}
	tmpxns := []*XMLNode{}
	for _, n := range p.children {
		tmpxns = append(tmpxns, n)
	}
	p.children = []*XMLNode{}
	for _, n := range tmpxns {
		if n == x {
			p.Add(xn)
			p.Add(n)
			continue
		}
		p.Add(n)
	}
	return nil
}

// Prepend will add the XMLNode xn to the beginning of the children of x possibly returning an error
func (x *XMLNode) Prepend(xn *XMLNode) error {
	if x.children == nil {
		x.children = []*XMLNode{}
	}
	if len(x.children) == 0 {
		x.Add(xn)
		return nil
	}
	return x.children[0].AddBefore(xn)
}

// Clone recursively clones X and returns the new XMLNode detatched from the x&#39;s parent
func (x *XMLNode) Clone() *XMLNode {
	newx := &amp;XMLNode{x.givenName, x.name, x.Content, map[string]string{}, []*XMLNode{}, nil, x.ntype, false}
	for k, v := range x.Attrs {
		newx.Set(k, v)
	}
	for _, child := range x.children {
		newx.Add(child.Clone())
	}
	return newx
}

// CloneInto calls Clone on x and then calls Add on the given parent passing in the new clone
func (x *XMLNode) CloneInto(parent *XMLNode) *XMLNode {
	newx := x.Clone()
	parent.Add(newx)
	return newx
}

// AddCloneOf calls Clone on the given nonChild and then calls Add on x passing in the new clone
func (x *XMLNode) AddCloneOf(nonChild *XMLNode) { x.Add(nonChild.Clone()) }

/*
   start: ws object ws
   ws: space | tab | newline | cr | &lt;nothing&gt;
   object: { pair *( ws , pair ) ws }
   pair: ws string ws : ws value
   string: &#34; *( \ &#34; | anyNotDouble ) &#34;
   array: ws [ ws value *( ws , ws value ) ws ]
   value: object | array | string | negativeOrPositiveDigits | &lt;true&gt; | &lt;false&gt; | &lt;null&gt;
   negativeOrPositiveDigits: *( - ) &#43;( digits )
*/

type possibleState int

const (
	none possibleState = iota
	object
	key
	colon
	value
	endValue
	sstring
	array
	strue
	sfalse
	snull
	digit
	end
)

func fromState(i possibleState) string {
	return []string{
		&#34;none&#34;,
		&#34;object&#34;,
		&#34;key&#34;,
		&#34;colon&#34;,
		&#34;value&#34;,
		&#34;endValue&#34;,
		&#34;sstring&#34;,
		&#34;array&#34;,
		&#34;strue&#34;,
		&#34;sfalse&#34;,
		&#34;snull&#34;,
		&#34;digit&#34;,
		&#34;end&#34;,
	}[i]
}

var invalidInput = errors.New(&#34;Invalid input&#34;)
var invalidInputNonObjectRoot = errors.New(&#34;Invalid input: root must be an object&#34;)

/*
FromJSON processes the givenJson and creates as much of an XML-ish structure as it can with root as the first XMLNode&#39;s name.

If there is any failure from invalid input, it will return as much of the resulting XMLNode structure as it can
and have an error in the location where the invalid input would have been placed (wrapped in an element with a name &#39;error&#39;).

The following invalid input:

	fmt.Println(gojax.FromJSON(&#34;j&#34;, `[1]`))

Would result in an output that contained:

	&lt;j&gt;&lt;error&gt;Invalid input: root must be an object&lt;/error&gt;&lt;/j&gt;

*/
func FromJSON(root string, givenJson string) (xn *XMLNode, returnedErr error) {
	return FromJSONWithOptions(root, givenJson, defaultOptions)
}

/*
FromJSONWithOptions is the same as FromJSON, but allows passing custom Options in.
You will likely want to just use FromJSON.
*/
func FromJSONWithOptions(root string, givenJson string, givenOptions Options) (xn *XMLNode, returnedErr error) {
	var pdbg func(...interface{})
	var dbg func(rune, possibleState)
	var r rune
	stk := []*XMLNode{NewXMLNode(root)}
	stk[0].ntype = object
	isEmpty := func() bool { return len(stk) == 0 }
	hasOnlyOne := func() bool { return len(stk) == 1 }
	hasSome := func() bool { return len(stk) &gt; 1 }
	push := func(xn *XMLNode) { stk = append(stk, xn) }
	getN := func(n int) *XMLNode {
		if isEmpty() {
			panic(&#34;Getting X on empty stack&#34;)
		}
		if len(stk)&#43;n &lt; 0 {
			panic(&#34;Going too far back for the length of the stack&#34;)
		}
		return stk[len(stk)&#43;n]
	}
	get := func() *XMLNode { return getN(-1) }
	pop := func() *XMLNode {
		if isEmpty() {
			panic(&#34;Popping X on empty stack&#34;)
		}
		result := getN(-1)
		stk = stk[:len(stk)-1]
		return result
	}
	getState := func() possibleState { return getN(-1).ntype }
	getStateN := func(n int) possibleState { return getN(n).ntype }
	givenJson = strings.TrimSpace(givenJson)
	if !strings.HasPrefix(givenJson, &#34;{&#34;) {
		panic(invalidInputNonObjectRoot)
	}
	jsonReader := strings.NewReader(givenJson)
	ri := -1 // To account for incrementing early and still being zero based
	defer func() {
		if r := recover(); r != nil {
			var errorContext strings.Builder
			errorContext.WriteString(&#34;\nERROR CONTEXT:\n&#34;)
			rBack := ri
			if rBack &gt; 10 {
				rBack -= 10
			} else {
				rBack = 0
			}
			rForward := rBack
			if rForward&#43;20 &lt; utf8.RuneCountInString(givenJson) {
				rForward &#43;= 20
			} else {
				rForward = utf8.RuneCountInString(givenJson)
			}
			jsonReader.Seek(int64(rBack), io.SeekStart)
			for i := 0; i &lt; (rForward - rBack); i&#43;&#43; {
				ru, _, err := jsonReader.ReadRune()
				if err != nil {
					errorContext.WriteString(&#34;Unable to gather error context&#34;)
				}
				errorContext.WriteRune(ru)
			}
			errorContext.WriteString(&#34;\n&#34;)
			if ri-rBack &gt; 0 {
				errorContext.WriteString(strings.Repeat(&#34; &#34;, (ri - rBack)))
			}
			errorContext.WriteString(&#34;^\n&#34;)
			jsonReader.Seek(int64(ri), io.SeekStart)
			returnedErr = errors.New(invalidInput.Error() &#43; errorContext.String())
			exn := NewXMLNode(&#34;error&#34; &#43; errorContext.String())
			if e, ok := r.(error); ok {
				exn.Add(NewXMLContentNode(e.Error() &#43; errorContext.String()))
			} else {
				if _, ok := r.(string); !ok {
					panic(&#34;Converting the error to a string failed&#34; &#43; errorContext.String())
				}
				exn.Add(NewXMLContentNode(invalidInput.Error() &#43; &#34;: &#34; &#43; r.(string) &#43; errorContext.String()))
			}
			if hasSome() {
				get().Add(exn)
			} else {
				if _, ok := r.(string); !ok {
					panic(&#34;Converting the error to a string failed&#34; &#43; errorContext.String())
				}
				panic(&#34;Unable to add node content: &#34; &#43; r.(string) &#43; errorContext.String())
				debug.PrintStack()
			}
		}
	}()
	nextEscaped := false
	isEscaped := false
	defer func() {
		if rerr := recover(); rerr != nil {
			pstate := &#34;N/A&#34;
			if hasSome() {
				pstate = fromState(getStateN(-2))
			}
			debug.PrintStack()
			if _, ok := rerr.(string); !ok {
				panic(&#34;ERROR: &#34; &#43; fromState(getState()) &#43; &#34; ~ &#34; &#43; string(r) &#43; &#34; ~ &#34; &#43; pstate &#43; &#34; ~ &#34; &#43; rerr.(error).Error())
			} else {
				panic(&#34;ERROR: &#34; &#43; fromState(getState()) &#43; &#34; ~ &#34; &#43; string(r) &#43; &#34; ~ &#34; &#43; pstate &#43; &#34; ~ &#34; &#43; rerr.(string))
			}
		}
	}()
	pdbg = func(s ...interface{}) {
		if !givenOptions.Debug {
			return
		}
		fmt.Println(s...)
	}
	dbg = func(r rune, state possibleState) {
		if !givenOptions.Debug {
			return
		}
		var ss strings.Builder
		var pxs strings.Builder
		for i, xn := range stk {
			if i &gt; 0 {
				ss.WriteString(&#34;, &#34;)
				pxs.WriteString(&#34;, &#34;)
			}
			ss.WriteString(fromState(xn.ntype))
			pxs.WriteString(xn.StringWithOptions(setNoHeader(givenOptions)))
		}
		fmt.Printf(`Debug:
	IN: %s
	States: %s
	PXs: %s
	Rune: %s
	ri: %d
`, givenJson, ss.String(), pxs.String(), string(r), ri)
	}
	br := bufio.NewReader(jsonReader)
	unread := func() { pdbg(&#34;UNREAD UNREAD UNREAD&#34;); br.UnreadRune(); ri -= 1 } // We ignore the err - we know we only ReadRune
	for {
		r, _, err := br.ReadRune()
		if err != nil {
			if err != io.EOF {
				panic(err)
			}
			break
		}
		if nextEscaped {
			nextEscaped = false
			isEscaped = true // This misses escaping the last rune... which I *think* would be invalid anyway
		}
		if r == utf8.RuneError {
			panic(&#34;Fail - invalid rune&#34;)
		}
		ri &#43;= 1
		pdbg(&#34;READ:&#34;, string(r), ri)
		pdbg(givenJson)
		if ri == 0 {
			pdbg(&#34;^&#34;)
		} else {
			pdbg(strings.Repeat(&#34; &#34;, ri-1), &#34;^&#34;)
		}
		isSpace := unicode.IsSpace(r)
		isLeftCurly := r == &#39;{&#39;
		isComma := r == &#39;,&#39;
		isColon := r == &#39;:&#39;
		isDouble := r == &#39;&#34;&#39;
		isRightCurly := r == &#39;}&#39;
		isLeftSquare := r == &#39;[&#39;
		isRightSquare := r == &#39;]&#39;
		isEscape := r == &#39;\\&#39;
		isT := r == &#39;t&#39;
		isF := r == &#39;f&#39;
		isN := r == &#39;n&#39;
		isDigit := unicode.IsDigit(r)
		isDash := r == &#39;-&#39;
	RERUN:
		dbg(r, getState())
		switch getState() {
		case object:
			if isSpace { // Ignore
			} else if isComma { // Ignore
			} else if isDouble {
				push(stateXMLNode(&#34;&#34;, key))
			} else if isLeftCurly {
				if ri &gt; 0 {
					push(stateXMLNode(&#34;&#34;, object))
				}
			} else if isRightCurly {
				pdbg(ri, len(givenJson))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				pdbg(&#34;About to panic&#34;)
				dbg(r, getState())
				panic(&#34;Failed to handle given rune in object state&#34;)
			}
		case key:
			if isEscape {
				nextEscaped = true
			} else if isEscaped {
				get().updateName(r)
			} else if isDouble {
				push(stateXMLNode(&#34;&#34;, colon))
			} else {
				get().updateName(r)
				pdbg(&#34;Current name of key:&#34;, get().GetName())
			}
		case colon:
			if isSpace { // Ignore
			} else if isColon {
				pop()
				push(stateXMLNode(&#34;&#34;, value))
			} else {
				panic(&#34;Failed to handle given rune in colon state&#34;)
			}
		case value:
			if isSpace {
			} else if isDigit || isDash {
				get().updateName(r)
				get().ntype = digit
			} else if isT {
				get().updateName(r)
				get().ntype = strue
			} else if isF {
				get().updateName(r)
				get().ntype = sfalse
			} else if isN {
				get().updateName(r)
				get().ntype = snull
			} else if isDouble {
				get().ntype = sstring
			} else if isLeftCurly {
				get().ntype = object
			} else if isLeftSquare {
				get().ntype = array
			} else {
				panic(&#34;Failed to handle given rune in value state&#34;)
			}
		case endValue:
			pop()
			valueNeedsToBeUnwrapped := getState() == object || getState() == array
			if isRightCurly &amp;&amp; hasOnlyOne() {
				push(stateXMLNode(&#34;&#34;, end))
				goto END
			} else if getStateN(-2) == key &amp;&amp; getStateN(-3) == object {
				if valueNeedsToBeUnwrapped {
					pdbg(&#34;Object and array are different - remove the wrapper and add each child to the key&#34;)
					o := pop()
					for _, child := range o.children {
						get().Add(child)
					}
				} else {
					pdbg(&#34;Assign value to key&#34;)
					v := pop()
					get().Add(v)
				}
				pdbg(&#34;Assign pair to object&#34;)
				pair := pop()
				get().Add(pair)
			} else {
				pdbg(&#34;Ending a value that belongs in an array&#34;)
				v := pop()
				if givenOptions.WrapArrayElements {
					xn := NewXMLNode(fmt.Sprintf(&#34;n[index=%d]&#34;, len(get().children)))
					if valueNeedsToBeUnwrapped {
						pdbg(&#34;Object and array are different - remove the wrapper and add each child to the key&#34;)
						for _, child := range v.children {
							xn.Add(child)
						}
					} else {
						xn.Add(v)
					}
					get().Add(xn)
				} else {
					if valueNeedsToBeUnwrapped {
						pdbg(&#34;Object and array are different - remove the wrapper and add each child to the key&#34;)
						for _, child := range v.children {
							get().Add(child)
						}
					} else {
						get().Add(v)
					}
				}
			}
		case sstring:
			if isEscape {
				nextEscaped = true
			} else if isEscaped {
				get().updateName(r)
			} else if isDouble {
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				get().updateName(r)
			}
		case digit:
			if isDigit {
				get().updateName(r)
			} else {
				unread() // This is unique, since digits don&#39;t have a safe ending rune like the others
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			}
		case strue:
			if get().GetName() == &#34;t&#34; &amp;&amp; r == &#39;r&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;tr&#34; &amp;&amp; r == &#39;u&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;tru&#34; &amp;&amp; r == &#39;e&#39; {
				get().updateName(r)
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				panic(&#34;Found an incomplete potential value of true&#34;)
			}
		case sfalse:
			if get().GetName() == &#34;f&#34; &amp;&amp; r == &#39;a&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;fa&#34; &amp;&amp; r == &#39;l&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;fal&#34; &amp;&amp; r == &#39;s&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;fals&#34; &amp;&amp; r == &#39;e&#39; {
				get().updateName(r)
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				panic(&#34;Found an incomplete potential value of false&#34;)
			}
		case snull:
			if get().GetName() == &#34;n&#34; &amp;&amp; r == &#39;u&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;nu&#34; &amp;&amp; r == &#39;l&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;nul&#34; &amp;&amp; r == &#39;l&#39; {
				get().updateName(r)
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				panic(&#34;Found an incomplete potential value of null&#34;)
			}
		case array:
			if isSpace { // Ignore
			} else if isLeftSquare {
				push(stateXMLNode(&#34;&#34;, array))
			} else if isComma {
				if getState() == digit {
					push(stateXMLNode(&#34;&#34;, endValue))
					pdbg(&#34;RERUN&#34;)
					goto RERUN
				}
			} else if isRightSquare {
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				push(stateXMLNode(&#34;&#34;, value))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			}
		default:
			panic(&#34;Current state has no handler&#34;)
		}
		isEscaped = false
		dbg(r, getState())
		pdbg(&#34;\n\n&#34;)
	}
END:
	if getState() != end {
		if getState() == sstring {
			panic(&#34;Unclosed string&#34;)
		}
		pdbg(&#34;Not ending at end&#34;)
		panic(&#34;Not ending at end&#34;)
	}
	return stk[0], nil
}

// FromJSONDebug sets the Debug Option and passes all given args to FromJSONWithOptions and
// returns all results from FromJSONWithOptions
func FromJSONDebug(root string, givenJson string) (xn *XMLNode, returnedErr error) {
	return FromJSONWithOptions(root, givenJson, defaultDebugOptions)
}

const (
	xnone possibleState = iota
	xstart
	xdecl
	xnodeName
	xconsumeEndNode
	xcontentNode
	xconsumeAttrs
	xcdata
	xcdataStart
	xcdataEnd
)

func fromXState(i possibleState) string {
	defer func() {
		if r := recover(); r != nil {
			panic(&#34;Failed to get state from (maybe you forgot to add a string for the given state?)&#34;)
		}
	}()
	return []string{
		&#34;none&#34;,
		&#34;start&#34;,
		&#34;decl&#34;,
		&#34;nodeName&#34;,
		&#34;consumeEndNode&#34;,
		&#34;contentNode&#34;,
		&#34;consumeAttrs&#34;,
		&#34;cdata&#34;,
		&#34;cdataStart&#34;,
		&#34;cdataEnd&#34;,
	}[i]
}

// FromXML will take xml-ish (see above) and produce an XMLNode structure to mimic.
// One goal with this method is to get JSON back out of an XMLNode structure with the JSON method.
func FromXML(givenXML string) (*XMLNode, error) {
	return FromXMLWithOptions(givenXML, defaultOptions)
}

/*
FromXMLWithOptions is the same as FromXML, but allows passing custom Options in.
You will likely want to just use FromXML.
*/
func FromXMLWithOptions(givenXML string, givenOptions Options) (*XMLNode, error) {
	var r rune
	//fmt.Println(&#34;FROM XML&#34;)
	var pdbg func(...interface{})
	var dbg func(rune, possibleState)
	stk := []*XMLNode{}
	isEmpty := func() bool { return len(stk) == 0 }
	//hasOnlyOne := func() bool { return len(stk) == 1 }
	hasSome := func() bool { return len(stk) &gt; 1 }
	push := func(xn *XMLNode) { stk = append(stk, xn) }
	getN := func(n int) *XMLNode {
		if isEmpty() {
			//debug.PrintStack()
			panic(&#34;Getting X on empty stack&#34;)
		}
		if len(stk)&#43;n &lt; 0 {
			panic(&#34;Going too far back for the length of the stack&#34;)
		}
		return stk[len(stk)&#43;n]
	}
	get := func() *XMLNode { return getN(-1) }
	pop := func() *XMLNode {
		if isEmpty() {
			panic(&#34;Popping X on empty stack&#34;)
		}
		result := getN(-1)
		stk = stk[:len(stk)-1]
		return result
	}
	getState := func() (rs possibleState) {
		defer func() {
			if r := recover(); r != nil {
				rs = xstart
			}
		}()
		return get().ntype
	}
	givenXML = strings.TrimSpace(givenXML)
	if !strings.HasPrefix(givenXML, &#34;&lt;&#34;) {
		panic(&#34;Given XML does not start with a &lt;: &#34; &#43; givenXML)
	}
	xmlReader := strings.NewReader(givenXML)
	ri := -1 // To account for incrementing early and still being zero based
	nextEscaped := false
	//isEscaped := false
	wasLessThan := false
	wasQuestion := false
	wasSolidus := false
	wasRightSquare := false
	wasA := false
	br := bufio.NewReader(xmlReader)
	unread := func() { br.UnreadRune(); ri -= 1 } // We ignore the err - we know we only ReadRune
	peek := func() rune {
		r, _, err := br.ReadRune()
		br.UnreadRune()
		if err != nil {
			fmt.Println(&#34;Failed to peek:&#34;, err)
			return 0
		}
		return r
	}
	pdbg = func(s ...interface{}) {
		if !givenOptions.Debug {
			return
		}
		fmt.Println(s...)
	}
	dbg = func(r rune, state possibleState) {
		if !givenOptions.Debug {
			return
		}
		var ss strings.Builder
		var pxs strings.Builder
		for i, xn := range stk {
			if i &gt; 0 {
				ss.WriteString(&#34;, &#34;)
				pxs.WriteString(&#34;, &#34;)
			}
			ss.WriteString(fromXState(xn.ntype))
			pxs.WriteString(xn.StringWithOptions(setNoHeader(givenOptions)))
		}
		fmt.Printf(`Debug:
	IN: %s
	States: %s
	PXs: %s
	Rune: %s
	ri: %d
`, givenXML, ss.String(), pxs.String(), string(r), ri)
	}
	var key strings.Builder
	var val strings.Builder
	collectVal := false
	//givenOptions.Debug = true
	for {
		previousr := r
		tmpr, _, err := br.ReadRune()
		if err != nil {
			if err != io.EOF {
				panic(err)
			}
			break
		}
		r = tmpr
		if nextEscaped {
			nextEscaped = false
			//isEscaped = true // This misses escaping the last rune... which I *think* would be invalid anyway
		}
		if r == utf8.RuneError {
			panic(&#34;Fail - invalid rune&#34;)
		}
		isSpace := unicode.IsSpace(r)
		isLessThan := r == &#39;&lt;&#39;
		isQuestion := r == &#39;?&#39;
		isGreaterThan := r == &#39;&gt;&#39;
		isSolidus := r == &#39;/&#39;
		isDouble := r == &#39;&#34;&#39;
		isEqual := r == &#39;=&#39;
		isRightSquare := r == &#39;]&#39;
		isLeftSquare := r == &#39;[&#39;
		isDeclStart := wasLessThan &amp;&amp; isQuestion
		isDeclEnd := wasQuestion &amp;&amp; isGreaterThan
		isPairedNodeEnd := wasLessThan &amp;&amp; isSolidus
		isNodeStart := wasLessThan &amp;&amp; !isSpace
		ri &#43;= 1
		pdbg(&#34;READ:&#34;, string(r), ri)
		pdbg(givenXML)
		if ri == 0 {
			pdbg(&#34;^&#34;)
		} else {
			pdbg(strings.Repeat(&#34; &#34;, ri-1), &#34;^&#34;)
		}
		wasLessThan = false // TODO - This is only useful *above* in the for loop... check the below usage...
		wasQuestion = false
		pdbg(&#34;Starting:&#34;)
		dbg(r, getState())
		switch getState() {
		case xstart:
			if isLessThan {
				wasLessThan = true
			} else if isDeclStart {
				push(stateXMLNode(&#34;&#34;, xdecl))
			} else if isPairedNodeEnd {
				get().ntype = xconsumeEndNode
			} else if isSpace { // Ignore
			} else if isNodeStart {
				if hasSome() &amp;&amp; getState() == xstart {
					pop()
				}
				push(stateXMLNode(&#34;&#34;, xnodeName))
				unread()
			} else if previousr == &#39;&gt;&#39; {
				get().ntype = xcontentNode
				get().updateName(r)
			} else if isSolidus {
				unread()
				get().ntype = xconsumeEndNode
			} else {
				panic(&#34;All supported cases are covered - this case is unsupported&#34;)
			}
		case xdecl:
			if isQuestion {
				wasQuestion = true
			}
			if isDeclEnd {
				pop()
			}
		case xnodeName:
			if len(get().name) == 0 &amp;&amp; r == &#39;!&#39; &amp;&amp; peek() == &#39;[&#39; {
				get().ntype = xcdataStart
			}
			if wasSolidus &amp;&amp; !isGreaterThan {
				wasSolidus = false
			}
			if isPairedNodeEnd || (wasLessThan &amp;&amp; isSolidus) {
				push(stateXMLNode(&#34;&#34;, xconsumeEndNode)) // This is the &lt;a&gt;&lt;/a&gt; case
			} else if isSolidus {
				wasSolidus = true
			} else if wasSolidus &amp;&amp; isGreaterThan { // This is the &lt;a/&gt; case
				if hasSome() {
					child := pop()
					get().Add(child)
					push(stateXMLNode(&#34;&#34;, xstart))
				}
			} else if isGreaterThan {
				push(stateXMLNode(&#34;&#34;, xstart))
			} else if isLessThan {
				if len(get().children) == 0 {
					push(NewXMLContentNode(pop().GetName()))
					child := pop()
					get().Add(child)
				}
				push(stateXMLNode(&#34;&#34;, xconsumeEndNode))
			} else if isSpace {
				push(stateXMLNode(&#34;&#34;, xconsumeAttrs))
			} else {
				get().updateName(r)
			}
		case xcdataStart:
			if wasA &amp;&amp; isLeftSquare {
				get().ntype = xcdata
				get().SetName(&#34;&#34;)
				wasA = false
			} else {
				wasA = true
			}
		case xcdata:
			if wasRightSquare &amp;&amp; isRightSquare &amp;&amp; peek() == &#39;&gt;&#39; {
				wasRightSquare = false
				get().ntype = xcdataEnd
			} else if !wasRightSquare &amp;&amp; isRightSquare {
				wasRightSquare = true
			} else {
				get().updateName(r)
				wasRightSquare = false
			}
		case xcdataEnd:
			if isGreaterThan {
				child := NewXMLContentNode(pop().givenName)
				child.cameFromCDATA = true
				get().Add(child)
				push(stateXMLNode(&#34;&#34;, xstart))
			} else {
				panic(&#34;There shouldn&#39;t be anything other than a &gt; to consume at this point&#34;)
			}
		case xconsumeAttrs:
			if isGreaterThan || isSolidus || isSpace {
				if len(val.String()) &gt; 0 { // TODO - bad cases v==0, k&gt;0... v&gt;0, k==0...
					getN(-2).updateName(&#39;[&#39;)
					for _, r := range key.String() {
						getN(-2).updateName(r)
					}
					getN(-2).updateName(&#39;=&#39;)
					for _, r := range val.String() {
						getN(-2).updateName(r)
					}
					getN(-2).updateName(&#39;]&#39;)
				}
				collectVal = false
				key.Reset()
				val.Reset()
				if isGreaterThan || isSolidus {
					unread()
					pop()
				}
			} else if isDouble {
				if len(key.String()) &gt; 0 {
					collectVal = true
				}
			} else if isEqual { // Ignore ??
			} else {
				if collectVal {
					val.WriteRune(r)
				} else {
					key.WriteRune(r)
				}
			}
		case xconsumeEndNode:
			if isGreaterThan {
				endingNode := pop()
				if endingNode.name != get().name {
					panic(fmt.Sprintf(
						&#34;Mismatched nodes. Maybe a child wasn&#39;t added to it&#39;s parent?\n\t%s\n\t%s&#34;,
						endingNode.name,
						get().name,
					))
				} else {
					if hasSome() {
						child := pop()
						get().Add(child)
					}
				}
				push(stateXMLNode(&#34;&#34;, xstart))
			} else if isSolidus { // IGNORE
			} else {
				get().updateName(r)
			}
		case xcontentNode: // TODO - needs work...
			if isLessThan {
				child := NewXMLContentNode(pop().GetName())
				get().Add(child)
				push(stateXMLNode(&#34;&#34;, xstart))
			} else {
				get().updateName(r)
			}
		default:
			panic(&#34;Unhandled state: &#34; &#43; fromXState(getState()))
		}
		//isEscaped = false
		pdbg(&#34;Ending:&#34;)
		dbg(r, getState())
		pdbg(&#34;\n\n&#34;)
	}
	return stk[0], nil
}
</code></pre>
<br /><br />
<div id='raw'>The raw file follows...</div>
<br /><br />
<div style="border:solid 1px black; padding:1em; overflow:scroll" contentEditable><pre>/*
Gojax provides a json-ish and xml-ish tool to convert json-ish to xml-ish so you can use an
xpath-ish expression to manipulate the resulting xml. If you can set aside the ishs, you can use
this package to work with JSON and XML.

The Consequences of ish

For JSON, the following are meant by the expression of &#39;ish&#39; above:
  - A single object is the only allowed root element
  - For numbers, only sequences of digits possibly prefixed with a negative sign are supported,
    including zero prefixed numbers
  - For strings, anything can be escaped, but unicode hexadecimal expressions are not supported
  - Finally, for whitespace, anything that returns true from unicode.IsSpace is accepted

For XML, only the least is supported - hence the &#39;ish&#39; above.
  - Nodes can have names from any JSON string
  - Attribute keys and values are any Golang string
  - JSON arrays have each inner-element nested inside a node with the following
    format: `&lt;n index=&#34;0&#34;&gt;...&lt;/n&gt;`, where the 0 is replaced with the element&#39;s index in the array
  - The JSON values of true, false, and null all convert to XML content as those runes
  - Also, XML attributes are sorted in the output

For XPath, also, only the least is supported.
  - You can separate path parts with either a / or // as in `/firstPathPart/secondPathPart`
  - A single / requires the successive path part to match the node name of a child of the current XMLNode
  - The double // allows the successive path part to match any descendant node name and
    can occur as a prefix to any path part such as `/firstPathPart//secondPathPart``
  - Filters are placed after node names in any path part following a syntax
    such as `/nodeName[k=v]`, where k is any attribute key (or any descendant node name) and v is any attribute value
    (or that same descendant node&#39;s AnyContent result) with both being required to match the entire key or value respectively
  - As an example of a descendant node content filter, given structure like
    `{&#34;a&#34;:[{&#34;b&#34;:{&#34;c&#34;:1}}, {&#34;b&#34;:{&#34;c&#34;:1}}, {&#34;b&#34;:{&#34;c&#34;:2}}]}` and a path like `//b[c=2]`, you could
    find the node `&lt;b&gt;&lt;c&gt;2&lt;/c&gt;&lt;/b&gt;`
  - Filters also support two special keys: meta and position(). The meta special key only
    supports one value &#39;no_attrs&#39;, which will only match nodes that have no attributes. The position()
    special key supports digits as values and checks that the position of that node in it&#39;s parents slice
    of children matches the given value.
  - In addition to checking an exact match for the childs position with an =, the position() special
    key supports &gt; and &lt; operators that filter nodes as expected.
  - The wildcard * is supported and matches any node name

As noted below, the above results in some restrictions:
  - Node names cannot contain [ or / (unless you use [ in the givenName parameter when calling NewXMLNode)
  - Node attribute keys and values cannot contain [ or ] or = or &gt; or &lt; or /

Sample Code

All that given, here is a simple sample usage:

	package main

	import (
		&#34;fmt&#34;
		&#34;git.ondollo.com/gojax&#34;
	)

	func main() {
			r := gojax.NewXMLNode(&#34;root#123[a=1]&#34;)
			b := gojax.NewXMLNode(&#34;b&#34;)
			b.Add(gojax.NewXMLContentNode(&#34;2&#34;))
			r.Add(b)
			c := gojax.NewXMLNode(&#34;c&#34;)
			d := gojax.NewXMLNode(&#34;d&#34;)
			d.Add(gojax.NewXMLContentNode(&#34;3&#34;))
			c.Add(d)
			r.Add(c)
			fmt.Println(r) // &lt;root a=&#34;1&#34; id=&#34;123&#34;&gt;&lt;b&gt;2&lt;/b&gt;&lt;c&gt;&lt;d&gt;3&lt;/d&gt;&lt;/c&gt;&lt;/root&gt;

			x, err := gojax.FromJSON(&#34;root&#34;, `{&#34;a&#34;:{&#34;b&#34;:1}}`)
			if err != nil {
				fmt.Println(&#34;Failed to build an XMLNode from the given JSON:&#34;, err)
			}
			fmt.Println(x.Path(&#34;//b&#34;)) // [&lt;b&gt;1&lt;/b&gt;] &lt;nil&gt;

			x, err = gojax.FromJSON(&#34;root&#34;, `{&#34;a&#34;:[{&#34;b&#34;:&#34;c&#34;},{&#34;b&#34;:&#34;d&#34;}]}`)
			if err != nil {
				fmt.Println(&#34;Failed to build an XMLNode from the given JSON:&#34;, err)
			}
			fmt.Println(x.Path(&#34;//n[index=0]&#34;)) // [&lt;n index=&#34;0&#34;&gt;&lt;b&gt;c&lt;/b&gt;&lt;/n&gt;] &lt;nil&gt;
		}
	}

*/
package gojax

import (
	&#34;bufio&#34;
	&#34;errors&#34;
	&#34;fmt&#34;
	&#34;io&#34;
	&#34;regexp&#34;
	&#34;runtime/debug&#34;
	&#34;sort&#34;
	&#34;strconv&#34;
	&#34;strings&#34;
	&#34;unicode&#34;
	&#34;unicode/utf8&#34;
)

// Options allows setting any of three options to make minor adjustments to the output of this library.
// For functions ending in `WithOptions`, the final parameter will have the Options type.
//
// When Debug is true additional data is available. Avoid using this.
// The default is false.
//
// When OutputHeader is true, the string `&lt;?xml version=&#34;1.0&#34;?&gt;` will be output on any call to
// String for an XMLNode without a parent.
// The default is true.
//
// When WrapArrayElements is true, each element in an array will be wrapped with an element that follows the
// format: `&lt;n index=&#34;0&#34;&gt;...&lt;/n&gt;`, where the 0 is replaced with the element&#39;s index in the array.
// The default is true.
type Options struct {
	Debug             bool
	OutputHeader      bool
	WrapArrayElements bool
}

// DefaultTestOptions provide a reference to the default test Options
var DefaultTestOptions = Options{false, false, true}
var defaultOptions = Options{false, true, true}
var defaultDebugOptions = Options{true, true, true}

func setNoHeader(givenOptions Options) Options {
	return Options{givenOptions.Debug, false, givenOptions.WrapArrayElements}
}

/*
XMLNode provides just enough structure for the subset of XML that gojax supports.
*/
type XMLNode struct {
	givenName     string
	name          string
	Content       string
	Attrs         map[string]string
	children      []*XMLNode
	parent        *XMLNode
	ntype         possibleState
	cameFromCDATA bool
}

var invalidPath = errors.New(&#34;Invalid path&#34;)

var attrsRegex = regexp.MustCompile(`\[([^=&gt;&lt;]&#43;[=&gt;&lt;][^\]]&#43;)\]`)
var innerAttrsRegex = regexp.MustCompile(`[=&gt;&lt;]`)
var cleanNameRegex = regexp.MustCompile(`[^-a-zA-Z0-9_.]`)
var xmlPrefixRegex = regexp.MustCompile(`^(?i)xml`)
var letterOrUnderscorePrefixRegex = regexp.MustCompile(`^[a-zA-Z_]`)
var namespaceRegex = regexp.MustCompile(`^([a-zA-Z_][-a-zA-Z0-9_.]&#43;):`)

func protectNamespace(s string) string          { return namespaceRegex.ReplaceAllString(s, &#34;${1}NSPROTECTION&#34;) }
func removeNamespaceProtection(s string) string { return strings.Replace(s, &#34;NSPROTECTION&#34;, &#34;:&#34;, 1) }

var notEnough = errors.New(&#34;Not enough XMLNodes in slice&#34;)

// First returns the first XMLNode from a slice.
// The parameters are meant to match the Path return values.
// The error either came from Path or was a result of calling First on an empty slice of XMLNodes.
func First(xns []*XMLNode, err error) (*XMLNode, error) { // Tied to output of Path
	if err != nil {
		return nil, err
	}
	if len(xns) &lt; 1 {
		return nil, notEnough
	}
	return xns[0], nil
}

// FirstOr will call Path on the givenNode passing in the givenPath, and either return the first match, or panic
func FirstOr(givenNode *XMLNode, givenPath string) *XMLNode {
	xns, err := givenNode.Path(givenPath)
	if err != nil {
		panic(fmt.Sprintf(
			&#34;The path `%s` matched zero nodes when at least one was required with an error of: %s.&#34;,
			givenPath,
			err,
		))
	}
	if len(xns) &lt; 1 {
		panic(fmt.Sprintf(&#34;The path `%s` matched zero nodes when at least one was required.&#34;, givenPath))
	}
	return xns[0]
}

// Last returns the last XMLNode from a slice.
// The parameters are meant to match the Path return values.
// The error either came from Path or was a result of calling Last on an empty slice of XMLNodes.
func Last(xns []*XMLNode, err error) (*XMLNode, error) { // Tied to output of Path
	if err != nil {
		return nil, err
	}
	if len(xns) &lt; 1 {
		return nil, notEnough
	}
	return xns[len(xns)-1], nil
}

// LastOr will return the last in a slice of XMLNode, or panic.
// The parameters are meant to match the Path return values.
// The error either came from Path or was a result of calling Last on an empty slice of XMLNodes.
func LastOr(givenNodes []*XMLNode, err error) *XMLNode { // Tied to output of Path
	xn, err := Last(givenNodes, err)
	if err != nil {
		panic(fmt.Sprintf(&#34;Failed to get last node with an error of: %s.&#34;, err))
	}
	return xn
}

// Reprocess runs the givenPath on each of the XMLNodes in givenNodes, collecting and then returning a unique list of matches
func Reprocess(givenNodes []*XMLNode, givenPath string) []*XMLNode {
	result := []*XMLNode{}
	for _, xn := range givenNodes {
		innerXNS, err := xn.Path(givenPath)
		if err == nil {
			for _, innerXN := range innerXNS {
				shouldAdd := true
				for _, tmpxn := range result {
					if tmpxn == innerXN {
						shouldAdd = false
						break
					}
				}
				if shouldAdd {
					result = append(result, innerXN)
				}
			}
		}
	}
	return result
}

var specialKeys = []string{
	&#34;meta&#34;,
	&#34;position()&#34;, // Here to block setting this attr through a givenName
	&#34;=position()&#34;,
	&#34;&gt;position()&#34;,
	&#34;&lt;position()&#34;,
}

func isSpecialKey(k string) bool {
	for _, sk := range specialKeys {
		if k == sk {
			return true
		}
	}
	return false
}

// PathOr will call Path on the givenNode passing in the givenPath, and either return all matches, or panic
func (x *XMLNode) PathOr(givenPath string) []*XMLNode {
	xns, err := x.Path(givenPath)
	if err != nil {
		panic(fmt.Sprintf(
			&#34;The path `%s` matched zero nodes when at least one was required with an error of: %s.&#34;,
			givenPath,
			err,
		))
	}
	if len(xns) &lt; 1 {
		panic(fmt.Sprintf(&#34;The path `%s` matched zero nodes when at least one was required.&#34;, givenPath))
	}
	return xns
}

/*
Path will take the givenPath and attempt to traverse the XMLNode structure.
If it is successful it will return all XMLNodes that satisfy the constraints
of the givenPath, or an empty XMLNode slice with an error.

At each node we can have some remainder of the givenPath (with double prioritized to disambiguate):
	/		- return the node we&#39;re at
	//a		- find all descendants with a name of &#39;a&#39; and return them
	/a		- find a child with a name of &#39;a&#39; and return it
	//a/&lt;rest&gt;	- recurse into all descendants with a name of &#39;a&#39; and run Path(`/&lt;rest&gt;`) on every descendant - keep any full match
	/a/&lt;rest&gt;	- recurse into a child with a name of &#39;a&#39; and run Path(`/&lt;rest&gt;`) on that child - keep any full match

Attribute filters look like:
	nodeName[k=v]	- only match the node with a name of &#39;nodeName&#39; if it has an attribute &#39;k&#39; with a value of &#39;v&#39;

Consequences of this approach:
  - Node names cannot contain [ or / (unless you use [ in the givenName parameter when calling NewXMLNode)
  - Node attribute keys and values cannot contain [ or ] or = or &gt; or &lt; or /
*/
func (x *XMLNode) Path(givenPath string) ([]*XMLNode, error) {
	if len(givenPath) &gt; 1 {
		givenPath = strings.TrimRight(givenPath, &#34;/&#34;)
	}
	startsWithDouble := strings.HasPrefix(givenPath, &#34;//&#34;)
	startsWithSingle := !startsWithDouble &amp;&amp; strings.HasPrefix(givenPath, &#34;/&#34;)
	if !startsWithSingle &amp;&amp; !startsWithDouble {
		return nil, invalidPath
	}
	cleans := strings.TrimLeft(givenPath, &#34;/&#34;)
	part := cleans
	rest := &#34;&#34;
	firstSep := strings.Index(cleans, &#34;/&#34;)
	hasParts := firstSep &gt; 0
	onlyPart := !hasParts
	if hasParts {
		part = cleans[:firstSep]
		rest = cleans[firstSep:]
	}
	attrFilterStart := strings.Index(part, &#34;[&#34;)
	mightHaveAttrFilter := attrFilterStart &gt; 0
	filters := map[string]string{}
	filtersPass := func(x *XMLNode) bool {
		for k, v := range filters {
			if isSpecialKey(k) {
				continue
			}
			if x.Attrs[k] != v {
				cleank := strings.TrimLeft(k, &#34;/&#34;)
				xns, err := x.Path(fmt.Sprintf(&#34;//%s&#34;, cleank))
				if err == nil {
					for _, xn := range xns {
						if xn.AnyContent() == v {
							return true
						}
					}
				}
				return false
			}
		}
		return true
	}
	specialAttrsMatch := func(x *XMLNode) bool {
		for k, v := range filters {
			if !isSpecialKey(k) {
				continue
			}
			switch {
			case k == &#34;meta&#34;:
				if v == &#34;no_attrs&#34; &amp;&amp; len(x.Attrs) &gt; 0 {
					return false
				}
			case strings.HasSuffix(k, &#34;position()&#34;):
				iv, err := strconv.Atoi(v)
				if err != nil || x.parent == nil {
					return false
				}
				for i, child := range x.parent.children {
					if child == x {
						switch string(k[0]) {
						case &#34;=&#34;:
							return i == iv
						case &#34;&gt;&#34;:
							return i &gt; iv
						case &#34;&lt;&#34;:
							return i &lt; iv
						}
					}
				}
				return false
			}
		}
		return true
	}
	if mightHaveAttrFilter {
		matches := attrsRegex.FindAllStringSubmatch(part[attrFilterStart:], -1)
		if len(matches) &gt; 0 {
			part = part[:attrFilterStart]
			for _, match := range matches {
				parts := innerAttrsRegex.Split(match[1], -1)
				if len(parts) != 2 {
					panic(&#34;Regex for attr parts failed to split in two&#34;)
				}
				k := parts[0]
				if k == &#34;position()&#34; {
					tmppos := len(parts[0])
					k = match[1][tmppos:tmppos&#43;1] &#43; k
				}
				filters[k] = parts[1]
			}
		}
	}
	if givenPath == &#34;/&#34; {
		return []*XMLNode{x}, nil
	} else if startsWithDouble &amp;&amp; onlyPart {
		matched := []*XMLNode{}
		pending := []*XMLNode{x}
		for i := 0; i &lt; len(pending); i&#43;&#43; {
			current := pending[i]
			for _, child := range current.children {
				pending = append(pending, child)
			}
			if (part == &#34;*&#34; || current.GetName() == part) &amp;&amp; filtersPass(current) &amp;&amp; specialAttrsMatch(current) {
				matched = append(matched, current)
			}
		}
		return matched, nil
	} else if startsWithSingle &amp;&amp; onlyPart {
		if (part == &#34;*&#34; || x.GetName() == part) &amp;&amp; filtersPass(x) &amp;&amp; specialAttrsMatch(x) {
			return []*XMLNode{x}, nil
		}
	} else if startsWithDouble &amp;&amp; hasParts {
		matched := []*XMLNode{}
		pending := []*XMLNode{x}
		for i := 0; i &lt; len(pending); i&#43;&#43; {
			current := pending[i]
			for _, child := range current.children {
				pending = append(pending, child)
			}
			matches, err := current.Path(givenPath[1:])
			if err == nil {
				for _, match := range matches {
					matched = append(matched, match)
				}
			}
		}
		return matched, nil
	} else if startsWithSingle &amp;&amp; hasParts {
		if (part == &#34;*&#34; || x.GetName() == part) &amp;&amp; filtersPass(x) &amp;&amp; specialAttrsMatch(x) {
			possibleResults := []*XMLNode{}
			for _, child := range x.children {
				possibleResult, err := child.Path(rest)
				if err == nil {
					possibleResults = append(possibleResults, possibleResult...)
				}
			}
			return possibleResults, nil
		}
	} else {
		return nil, invalidPath
	}
	return []*XMLNode{}, nil
}

// UnwrappedOr will call FromJSON passing in an internally known root and then return the contents inside that root, or panic
func UnwrappedOr(givenJson string) []*XMLNode {
	return UnwrappedOrWithOptions(givenJson, defaultOptions)
}

/*
UnwrappedOrWithOptions is the same as UnwrappedOr, but allows passing custom Options in.
You will likely want to just use UnwrappedOr.
*/
func UnwrappedOrWithOptions(givenJson string, givenOptions Options) []*XMLNode {
	xn, err := FromJSONWithOptions(`r`, givenJson, givenOptions)
	if err != nil {
		panic(&#34;The givenJson was invalid when it was required to be valid: &#34; &#43; err.Error())
	}
	return xn.PathOr(`/r/*`)
}

// NewXMLNode returns an XMLNode with the givenName as it&#39;s name.
// There are some supported variations to express attributes, including an id, inside the givenName:
//
//  * You can set the id attribute with nodeName#idValue
//  * You can set attributes with nodeName[k=v]
//  * If any, the id needs to come before attrs and will override any attribute key &#39;id&#39; set through [] notation
//
// So, combining the above, you can set attrs and id with:
//    nodeName#idValue[k=v]
// Additionally, the special attribute keys available in paths won&#39;t hold specific meaning here and are ignored.
//
// Finally, no attempt is made to ensure the uniqueness of any id attribute within any XMLNode
func NewXMLNode(givenName string) *XMLNode { return stateXMLNode(givenName, none) }
func stateXMLNode(givenName string, state possibleState) *XMLNode {
	result := &amp;XMLNode{givenName, &#34;&#34;, &#34;&#34;, map[string]string{}, []*XMLNode{}, nil, state, false}
	name, attrs := nameAttrsFrom(givenName)
	result.name = name
	for k, v := range attrs {
		result.Set(k, v)
	}
	return result
}
func nameAttrsFrom(givenName string) (string, map[string]string) {
	attrStart := strings.Index(givenName, &#34;[&#34;)
	mightHaveAttrs := attrStart &gt; 0
	givenAttrs := map[string]string{}
	if mightHaveAttrs {
		matches := attrsRegex.FindAllStringSubmatch(givenName[attrStart:], -1)
		if len(matches) &gt; 0 {
			for _, match := range matches {
				parts := innerAttrsRegex.Split(match[1], -1)
				if len(parts) != 2 {
					panic(&#34;Regex for attr parts failed to split in two&#34;)
				}
				k := parts[0]
				if !isSpecialKey(k) {
					givenAttrs[k] = parts[1]
				}
			}
			givenName = givenName[:attrStart]
		}
	}
	if parts := strings.Split(givenName, &#34;#&#34;); len(parts) &gt; 1 &amp;&amp; len(parts[1]) &gt; 0 {
		givenName = parts[0]
		givenAttrs[&#34;id&#34;] = parts[1]
	}
	return givenName, givenAttrs
}

// NewXMLContentNode returns an XMLNode with the givenContent as it&#39;s Content
func NewXMLContentNode(givenContent string) *XMLNode {
	return stateXMLContentNode(givenContent, none)
}
func stateXMLContentNode(givenContent string, state possibleState) *XMLNode {
	return &amp;XMLNode{&#34;&#34;, &#34;&#34;, givenContent, map[string]string{}, []*XMLNode{}, nil, state, false}
}

// String will output XML from an XMLNode structure.
// If you&#39;d like to output JSON, use the JSON method.
func (x XMLNode) String() string {
	return x.StringWithOptions(defaultOptions)
}

/*
StringWithOptions is the same as String, but allows passing custom Options in.
You will likely want to just use String.
*/
func (x XMLNode) StringWithOptions(givenOptions Options) string {
	if len(x.Content) &gt; 0 {
		result := x.Content
		shouldBeWrapped := x.cameFromCDATA ||
			strings.Contains(result, `&amp;`) ||
			strings.Contains(result, `&lt;`) ||
			strings.Contains(result, `]]&gt;`)
		if shouldBeWrapped {
			result = `&lt;![CDATA[` &#43; strings.ReplaceAll(result, `]]&gt;`, `]]]]&gt;&lt;![CDATA[&gt;`) &#43; `]]&gt;`
		}
		return result
	}
	var result strings.Builder
	if x.parent == nil &amp;&amp; givenOptions.OutputHeader {
		result.WriteString(`&lt;?xml version=&#34;1.0&#34;?&gt;`)
	}
	cleanName := protectNamespace(x.GetName())
	cleanName = cleanNameRegex.ReplaceAllString(cleanName, &#34;_&#34;)
	if xmlPrefixRegex.MatchString(cleanName) || !letterOrUnderscorePrefixRegex.MatchString(cleanName) {
		cleanName = &#34;_&#34; &#43; cleanName
	}
	cleanName = removeNamespaceProtection(cleanName)
	result.WriteString(&#34;&lt;&#34; &#43; cleanName)
	tmpks := []string{}
	for k, _ := range x.Attrs {
		tmpks = append(tmpks, k)
	}
	sort.Strings(tmpks)
	for _, k := range tmpks {
		result.WriteString(fmt.Sprintf(&#34; %s=%q&#34;, k, x.Attrs[k]))
	}
	result.WriteString(&#34;&gt;&#34;)
	for _, child := range x.children {
		result.WriteString(child.StringWithOptions(givenOptions))
	}
	result.WriteString(&#34;&lt;/&#34; &#43; cleanName &#43; &#34;&gt;&#34;)
	return result.String()
}

// JSON produces a JSON output from an XMLNode structure.
// Children are output in the same order they exist in in the XMLNode structure with matching names simply repeated.
func (x XMLNode) JSON() string {
	if len(x.Content) &gt; 0 {
		return fmt.Sprintf(`%q`, x.Content)
	}
	var result strings.Builder
	cleanName := protectNamespace(x.GetName())
	cleanName = cleanNameRegex.ReplaceAllString(cleanName, &#34;_&#34;)
	if xmlPrefixRegex.MatchString(cleanName) || !letterOrUnderscorePrefixRegex.MatchString(cleanName) {
		cleanName = &#34;_&#34; &#43; cleanName
	}
	cleanName = removeNamespaceProtection(cleanName)
	if x.parent == nil {
		result.WriteString(`{`)
	}
	result.WriteString(`&#34;` &#43; cleanName)
	result.WriteString(`&#34;:`)
	if len(x.children) &gt; 0 { // TODO - so attrs will only show up on a node with children and NOT content...
		if len(x.children[0].Content) == 0 {
			result.WriteString(&#34;{&#34;)
			tmpks := []string{}
			for k, _ := range x.Attrs {
				tmpks = append(tmpks, k)
			}
			sort.Strings(tmpks)
			for _, k := range tmpks {
				result.WriteString(fmt.Sprintf(&#34;%q:%q&#34;, k, x.Attrs[k]))
				result.WriteString(&#34;,&#34;) // This isn&#39;t written &#39;before&#39;, since we know there&#39;ll be children
			}
		}
		childrenNames := []string{}
		childrenByName := map[string][]*XMLNode{}
		for _, child := range x.children {
			//cn := child.givenName
			cn := child.name
			previousValue, exists := childrenByName[cn]
			if exists {
				childrenByName[cn] = append(previousValue, child)
			} else {
				childrenByName[cn] = []*XMLNode{child}
				childrenNames = append(childrenNames, cn)
			}
		}
		sort.Strings(childrenNames)
		notFirstChild := false
		for _, name := range childrenNames {
			v := childrenByName[name]
			if notFirstChild {
				result.WriteString(&#34;,&#34;)
			}
			if len(v) == 1 {
				result.WriteString(v[0].JSON())
			} else {
				childKey := strings.SplitN(v[0].JSON(), &#34;:&#34;, 2)[0]
				result.WriteString(childKey)
				result.WriteString(&#34;:[&#34;)
				for i, childV := range v {
					if i &gt; 0 {
						result.WriteString(&#34;,&#34;)
					}
					result.WriteString(strings.SplitN(childV.JSON(), &#34;:&#34;, 2)[1])
				}
				result.WriteString(&#34;]&#34;)
			}
			notFirstChild = true
		}
		if len(x.children[0].Content) == 0 {
			result.WriteString(&#34;}&#34;)
		}
	} else {
		result.WriteString(`&#34;&#34;`)
	}
	if x.parent == nil {
		result.WriteString(`}`)
	}
	return result.String()
}

// SetName will turn any valid givenName expression into the resulting name and attributes, including id.
func (x *XMLNode) SetName(givenName string) {
	x.givenName = givenName
	name, attrs := nameAttrsFrom(givenName)
	x.name = name
	for k, v := range attrs {
		x.Set(k, v)
	}
}

// GetName will return the calculated name of the node.
func (x *XMLNode) GetName() string { return x.name }

func (x *XMLNode) updateName(givenRune rune) { x.SetName(x.givenName &#43; string(givenRune)) }

// Set will assign the value v to the attribute key k
func (x *XMLNode) Set(k string, v string) { x.Attrs[k] = v }

// Get will the value v that is assigned to the attribute key k
func (x *XMLNode) Get(k string) string { return x.Attrs[k] }

// AnyContent will return either the content inside x or, if x has only one child that is a content node, the content of that one
func (x *XMLNode) AnyContent() string {
	if len(x.children) == 1 &amp;&amp; len(x.children[0].name) == 0 {
		return x.children[0].Content
	}
	return x.Content
}

// Add appends the XMLNode xn as a child in the children XMLNode slice of the XMLNode x
func (x *XMLNode) Add(xn *XMLNode) {
	if x == xn {
		panic(&#34;You can&#39;t add a node to itself&#34;)
	}
	xn.parent = x
	x.children = append(x.children, xn)
}

// AddAll appends all of the XMLNodes xns as children to the XMLNode x
func (x *XMLNode) AddAll(xns []*XMLNode) {
	for _, xn := range xns {
		if x == xn {
			panic(&#34;You can&#39;t add a node to itself&#34;)
		}
		x.Add(xn)
	}
}

var notAChild = errors.New(&#34;Unable to modify parent/child relationship. Given child is not in parent.&#34;)

// Remove will remove the XMLNode xn from x and possibly return an error if xn is not a child of x
func (x *XMLNode) Remove(xn *XMLNode) error {
	for i, n := range x.children {
		if n == xn {
			n.parent = nil
			x.children = append(x.children[:i], x.children[i&#43;1:]...)
			return nil
		}
	}
	return notAChild
}

// Cut will remove the XMLNode x from it&#39;s parent and possibly return an error if x is the root
func (x *XMLNode) Cut() error {
	if x.parent == nil {
		return nil
	}
	return x.parent.Remove(x)
}

func nodeIsRoot(action string) error {
	return errors.New(fmt.Sprintf(&#34;Unable to %s on root node&#34;, action))
}

// AddBefore will add xn as a sibling of x just before x&#39;s position in the list of the parents children
// and possibly return an error if x is the root.
// The XMLNode xn will be Cut before being added to x.
func (x *XMLNode) AddBefore(xn *XMLNode) error {
	if x.parent == nil {
		return nodeIsRoot(&#34;AddBefore&#34;)
	}
	p := x.parent
	if err := xn.Cut(); err != nil {
		return errors.New(&#34;Failed to cut xn inside call to AddBefore&#34;)
	}
	tmpxns := []*XMLNode{}
	for _, n := range p.children {
		tmpxns = append(tmpxns, n)
	}
	p.children = []*XMLNode{}
	for _, n := range tmpxns {
		if n == x {
			p.Add(xn)
			p.Add(n)
			continue
		}
		p.Add(n)
	}
	return nil
}

// Prepend will add the XMLNode xn to the beginning of the children of x possibly returning an error
func (x *XMLNode) Prepend(xn *XMLNode) error {
	if x.children == nil {
		x.children = []*XMLNode{}
	}
	if len(x.children) == 0 {
		x.Add(xn)
		return nil
	}
	return x.children[0].AddBefore(xn)
}

// Clone recursively clones X and returns the new XMLNode detatched from the x&#39;s parent
func (x *XMLNode) Clone() *XMLNode {
	newx := &amp;XMLNode{x.givenName, x.name, x.Content, map[string]string{}, []*XMLNode{}, nil, x.ntype, false}
	for k, v := range x.Attrs {
		newx.Set(k, v)
	}
	for _, child := range x.children {
		newx.Add(child.Clone())
	}
	return newx
}

// CloneInto calls Clone on x and then calls Add on the given parent passing in the new clone
func (x *XMLNode) CloneInto(parent *XMLNode) *XMLNode {
	newx := x.Clone()
	parent.Add(newx)
	return newx
}

// AddCloneOf calls Clone on the given nonChild and then calls Add on x passing in the new clone
func (x *XMLNode) AddCloneOf(nonChild *XMLNode) { x.Add(nonChild.Clone()) }

/*
   start: ws object ws
   ws: space | tab | newline | cr | &lt;nothing&gt;
   object: { pair *( ws , pair ) ws }
   pair: ws string ws : ws value
   string: &#34; *( \ &#34; | anyNotDouble ) &#34;
   array: ws [ ws value *( ws , ws value ) ws ]
   value: object | array | string | negativeOrPositiveDigits | &lt;true&gt; | &lt;false&gt; | &lt;null&gt;
   negativeOrPositiveDigits: *( - ) &#43;( digits )
*/

type possibleState int

const (
	none possibleState = iota
	object
	key
	colon
	value
	endValue
	sstring
	array
	strue
	sfalse
	snull
	digit
	end
)

func fromState(i possibleState) string {
	return []string{
		&#34;none&#34;,
		&#34;object&#34;,
		&#34;key&#34;,
		&#34;colon&#34;,
		&#34;value&#34;,
		&#34;endValue&#34;,
		&#34;sstring&#34;,
		&#34;array&#34;,
		&#34;strue&#34;,
		&#34;sfalse&#34;,
		&#34;snull&#34;,
		&#34;digit&#34;,
		&#34;end&#34;,
	}[i]
}

var invalidInput = errors.New(&#34;Invalid input&#34;)
var invalidInputNonObjectRoot = errors.New(&#34;Invalid input: root must be an object&#34;)

/*
FromJSON processes the givenJson and creates as much of an XML-ish structure as it can with root as the first XMLNode&#39;s name.

If there is any failure from invalid input, it will return as much of the resulting XMLNode structure as it can
and have an error in the location where the invalid input would have been placed (wrapped in an element with a name &#39;error&#39;).

The following invalid input:

	fmt.Println(gojax.FromJSON(&#34;j&#34;, `[1]`))

Would result in an output that contained:

	&lt;j&gt;&lt;error&gt;Invalid input: root must be an object&lt;/error&gt;&lt;/j&gt;

*/
func FromJSON(root string, givenJson string) (xn *XMLNode, returnedErr error) {
	return FromJSONWithOptions(root, givenJson, defaultOptions)
}

/*
FromJSONWithOptions is the same as FromJSON, but allows passing custom Options in.
You will likely want to just use FromJSON.
*/
func FromJSONWithOptions(root string, givenJson string, givenOptions Options) (xn *XMLNode, returnedErr error) {
	var pdbg func(...interface{})
	var dbg func(rune, possibleState)
	var r rune
	stk := []*XMLNode{NewXMLNode(root)}
	stk[0].ntype = object
	isEmpty := func() bool { return len(stk) == 0 }
	hasOnlyOne := func() bool { return len(stk) == 1 }
	hasSome := func() bool { return len(stk) &gt; 1 }
	push := func(xn *XMLNode) { stk = append(stk, xn) }
	getN := func(n int) *XMLNode {
		if isEmpty() {
			panic(&#34;Getting X on empty stack&#34;)
		}
		if len(stk)&#43;n &lt; 0 {
			panic(&#34;Going too far back for the length of the stack&#34;)
		}
		return stk[len(stk)&#43;n]
	}
	get := func() *XMLNode { return getN(-1) }
	pop := func() *XMLNode {
		if isEmpty() {
			panic(&#34;Popping X on empty stack&#34;)
		}
		result := getN(-1)
		stk = stk[:len(stk)-1]
		return result
	}
	getState := func() possibleState { return getN(-1).ntype }
	getStateN := func(n int) possibleState { return getN(n).ntype }
	givenJson = strings.TrimSpace(givenJson)
	if !strings.HasPrefix(givenJson, &#34;{&#34;) {
		panic(invalidInputNonObjectRoot)
	}
	jsonReader := strings.NewReader(givenJson)
	ri := -1 // To account for incrementing early and still being zero based
	defer func() {
		if r := recover(); r != nil {
			var errorContext strings.Builder
			errorContext.WriteString(&#34;\nERROR CONTEXT:\n&#34;)
			rBack := ri
			if rBack &gt; 10 {
				rBack -= 10
			} else {
				rBack = 0
			}
			rForward := rBack
			if rForward&#43;20 &lt; utf8.RuneCountInString(givenJson) {
				rForward &#43;= 20
			} else {
				rForward = utf8.RuneCountInString(givenJson)
			}
			jsonReader.Seek(int64(rBack), io.SeekStart)
			for i := 0; i &lt; (rForward - rBack); i&#43;&#43; {
				ru, _, err := jsonReader.ReadRune()
				if err != nil {
					errorContext.WriteString(&#34;Unable to gather error context&#34;)
				}
				errorContext.WriteRune(ru)
			}
			errorContext.WriteString(&#34;\n&#34;)
			if ri-rBack &gt; 0 {
				errorContext.WriteString(strings.Repeat(&#34; &#34;, (ri - rBack)))
			}
			errorContext.WriteString(&#34;^\n&#34;)
			jsonReader.Seek(int64(ri), io.SeekStart)
			returnedErr = errors.New(invalidInput.Error() &#43; errorContext.String())
			exn := NewXMLNode(&#34;error&#34; &#43; errorContext.String())
			if e, ok := r.(error); ok {
				exn.Add(NewXMLContentNode(e.Error() &#43; errorContext.String()))
			} else {
				if _, ok := r.(string); !ok {
					panic(&#34;Converting the error to a string failed&#34; &#43; errorContext.String())
				}
				exn.Add(NewXMLContentNode(invalidInput.Error() &#43; &#34;: &#34; &#43; r.(string) &#43; errorContext.String()))
			}
			if hasSome() {
				get().Add(exn)
			} else {
				if _, ok := r.(string); !ok {
					panic(&#34;Converting the error to a string failed&#34; &#43; errorContext.String())
				}
				panic(&#34;Unable to add node content: &#34; &#43; r.(string) &#43; errorContext.String())
				debug.PrintStack()
			}
		}
	}()
	nextEscaped := false
	isEscaped := false
	defer func() {
		if rerr := recover(); rerr != nil {
			pstate := &#34;N/A&#34;
			if hasSome() {
				pstate = fromState(getStateN(-2))
			}
			debug.PrintStack()
			if _, ok := rerr.(string); !ok {
				panic(&#34;ERROR: &#34; &#43; fromState(getState()) &#43; &#34; ~ &#34; &#43; string(r) &#43; &#34; ~ &#34; &#43; pstate &#43; &#34; ~ &#34; &#43; rerr.(error).Error())
			} else {
				panic(&#34;ERROR: &#34; &#43; fromState(getState()) &#43; &#34; ~ &#34; &#43; string(r) &#43; &#34; ~ &#34; &#43; pstate &#43; &#34; ~ &#34; &#43; rerr.(string))
			}
		}
	}()
	pdbg = func(s ...interface{}) {
		if !givenOptions.Debug {
			return
		}
		fmt.Println(s...)
	}
	dbg = func(r rune, state possibleState) {
		if !givenOptions.Debug {
			return
		}
		var ss strings.Builder
		var pxs strings.Builder
		for i, xn := range stk {
			if i &gt; 0 {
				ss.WriteString(&#34;, &#34;)
				pxs.WriteString(&#34;, &#34;)
			}
			ss.WriteString(fromState(xn.ntype))
			pxs.WriteString(xn.StringWithOptions(setNoHeader(givenOptions)))
		}
		fmt.Printf(`Debug:
	IN: %s
	States: %s
	PXs: %s
	Rune: %s
	ri: %d
`, givenJson, ss.String(), pxs.String(), string(r), ri)
	}
	br := bufio.NewReader(jsonReader)
	unread := func() { pdbg(&#34;UNREAD UNREAD UNREAD&#34;); br.UnreadRune(); ri -= 1 } // We ignore the err - we know we only ReadRune
	for {
		r, _, err := br.ReadRune()
		if err != nil {
			if err != io.EOF {
				panic(err)
			}
			break
		}
		if nextEscaped {
			nextEscaped = false
			isEscaped = true // This misses escaping the last rune... which I *think* would be invalid anyway
		}
		if r == utf8.RuneError {
			panic(&#34;Fail - invalid rune&#34;)
		}
		ri &#43;= 1
		pdbg(&#34;READ:&#34;, string(r), ri)
		pdbg(givenJson)
		if ri == 0 {
			pdbg(&#34;^&#34;)
		} else {
			pdbg(strings.Repeat(&#34; &#34;, ri-1), &#34;^&#34;)
		}
		isSpace := unicode.IsSpace(r)
		isLeftCurly := r == &#39;{&#39;
		isComma := r == &#39;,&#39;
		isColon := r == &#39;:&#39;
		isDouble := r == &#39;&#34;&#39;
		isRightCurly := r == &#39;}&#39;
		isLeftSquare := r == &#39;[&#39;
		isRightSquare := r == &#39;]&#39;
		isEscape := r == &#39;\\&#39;
		isT := r == &#39;t&#39;
		isF := r == &#39;f&#39;
		isN := r == &#39;n&#39;
		isDigit := unicode.IsDigit(r)
		isDash := r == &#39;-&#39;
	RERUN:
		dbg(r, getState())
		switch getState() {
		case object:
			if isSpace { // Ignore
			} else if isComma { // Ignore
			} else if isDouble {
				push(stateXMLNode(&#34;&#34;, key))
			} else if isLeftCurly {
				if ri &gt; 0 {
					push(stateXMLNode(&#34;&#34;, object))
				}
			} else if isRightCurly {
				pdbg(ri, len(givenJson))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				pdbg(&#34;About to panic&#34;)
				dbg(r, getState())
				panic(&#34;Failed to handle given rune in object state&#34;)
			}
		case key:
			if isEscape {
				nextEscaped = true
			} else if isEscaped {
				get().updateName(r)
			} else if isDouble {
				push(stateXMLNode(&#34;&#34;, colon))
			} else {
				get().updateName(r)
				pdbg(&#34;Current name of key:&#34;, get().GetName())
			}
		case colon:
			if isSpace { // Ignore
			} else if isColon {
				pop()
				push(stateXMLNode(&#34;&#34;, value))
			} else {
				panic(&#34;Failed to handle given rune in colon state&#34;)
			}
		case value:
			if isSpace {
			} else if isDigit || isDash {
				get().updateName(r)
				get().ntype = digit
			} else if isT {
				get().updateName(r)
				get().ntype = strue
			} else if isF {
				get().updateName(r)
				get().ntype = sfalse
			} else if isN {
				get().updateName(r)
				get().ntype = snull
			} else if isDouble {
				get().ntype = sstring
			} else if isLeftCurly {
				get().ntype = object
			} else if isLeftSquare {
				get().ntype = array
			} else {
				panic(&#34;Failed to handle given rune in value state&#34;)
			}
		case endValue:
			pop()
			valueNeedsToBeUnwrapped := getState() == object || getState() == array
			if isRightCurly &amp;&amp; hasOnlyOne() {
				push(stateXMLNode(&#34;&#34;, end))
				goto END
			} else if getStateN(-2) == key &amp;&amp; getStateN(-3) == object {
				if valueNeedsToBeUnwrapped {
					pdbg(&#34;Object and array are different - remove the wrapper and add each child to the key&#34;)
					o := pop()
					for _, child := range o.children {
						get().Add(child)
					}
				} else {
					pdbg(&#34;Assign value to key&#34;)
					v := pop()
					get().Add(v)
				}
				pdbg(&#34;Assign pair to object&#34;)
				pair := pop()
				get().Add(pair)
			} else {
				pdbg(&#34;Ending a value that belongs in an array&#34;)
				v := pop()
				if givenOptions.WrapArrayElements {
					xn := NewXMLNode(fmt.Sprintf(&#34;n[index=%d]&#34;, len(get().children)))
					if valueNeedsToBeUnwrapped {
						pdbg(&#34;Object and array are different - remove the wrapper and add each child to the key&#34;)
						for _, child := range v.children {
							xn.Add(child)
						}
					} else {
						xn.Add(v)
					}
					get().Add(xn)
				} else {
					if valueNeedsToBeUnwrapped {
						pdbg(&#34;Object and array are different - remove the wrapper and add each child to the key&#34;)
						for _, child := range v.children {
							get().Add(child)
						}
					} else {
						get().Add(v)
					}
				}
			}
		case sstring:
			if isEscape {
				nextEscaped = true
			} else if isEscaped {
				get().updateName(r)
			} else if isDouble {
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				get().updateName(r)
			}
		case digit:
			if isDigit {
				get().updateName(r)
			} else {
				unread() // This is unique, since digits don&#39;t have a safe ending rune like the others
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			}
		case strue:
			if get().GetName() == &#34;t&#34; &amp;&amp; r == &#39;r&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;tr&#34; &amp;&amp; r == &#39;u&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;tru&#34; &amp;&amp; r == &#39;e&#39; {
				get().updateName(r)
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				panic(&#34;Found an incomplete potential value of true&#34;)
			}
		case sfalse:
			if get().GetName() == &#34;f&#34; &amp;&amp; r == &#39;a&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;fa&#34; &amp;&amp; r == &#39;l&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;fal&#34; &amp;&amp; r == &#39;s&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;fals&#34; &amp;&amp; r == &#39;e&#39; {
				get().updateName(r)
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				panic(&#34;Found an incomplete potential value of false&#34;)
			}
		case snull:
			if get().GetName() == &#34;n&#34; &amp;&amp; r == &#39;u&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;nu&#34; &amp;&amp; r == &#39;l&#39; {
				get().updateName(r)
			} else if get().GetName() == &#34;nul&#34; &amp;&amp; r == &#39;l&#39; {
				get().updateName(r)
				xn := pop()
				push(NewXMLContentNode(xn.GetName()))
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				panic(&#34;Found an incomplete potential value of null&#34;)
			}
		case array:
			if isSpace { // Ignore
			} else if isLeftSquare {
				push(stateXMLNode(&#34;&#34;, array))
			} else if isComma {
				if getState() == digit {
					push(stateXMLNode(&#34;&#34;, endValue))
					pdbg(&#34;RERUN&#34;)
					goto RERUN
				}
			} else if isRightSquare {
				push(stateXMLNode(&#34;&#34;, endValue))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			} else {
				push(stateXMLNode(&#34;&#34;, value))
				pdbg(&#34;RERUN&#34;)
				goto RERUN
			}
		default:
			panic(&#34;Current state has no handler&#34;)
		}
		isEscaped = false
		dbg(r, getState())
		pdbg(&#34;\n\n&#34;)
	}
END:
	if getState() != end {
		if getState() == sstring {
			panic(&#34;Unclosed string&#34;)
		}
		pdbg(&#34;Not ending at end&#34;)
		panic(&#34;Not ending at end&#34;)
	}
	return stk[0], nil
}

// FromJSONDebug sets the Debug Option and passes all given args to FromJSONWithOptions and
// returns all results from FromJSONWithOptions
func FromJSONDebug(root string, givenJson string) (xn *XMLNode, returnedErr error) {
	return FromJSONWithOptions(root, givenJson, defaultDebugOptions)
}

const (
	xnone possibleState = iota
	xstart
	xdecl
	xnodeName
	xconsumeEndNode
	xcontentNode
	xconsumeAttrs
	xcdata
	xcdataStart
	xcdataEnd
)

func fromXState(i possibleState) string {
	defer func() {
		if r := recover(); r != nil {
			panic(&#34;Failed to get state from (maybe you forgot to add a string for the given state?)&#34;)
		}
	}()
	return []string{
		&#34;none&#34;,
		&#34;start&#34;,
		&#34;decl&#34;,
		&#34;nodeName&#34;,
		&#34;consumeEndNode&#34;,
		&#34;contentNode&#34;,
		&#34;consumeAttrs&#34;,
		&#34;cdata&#34;,
		&#34;cdataStart&#34;,
		&#34;cdataEnd&#34;,
	}[i]
}

// FromXML will take xml-ish (see above) and produce an XMLNode structure to mimic.
// One goal with this method is to get JSON back out of an XMLNode structure with the JSON method.
func FromXML(givenXML string) (*XMLNode, error) {
	return FromXMLWithOptions(givenXML, defaultOptions)
}

/*
FromXMLWithOptions is the same as FromXML, but allows passing custom Options in.
You will likely want to just use FromXML.
*/
func FromXMLWithOptions(givenXML string, givenOptions Options) (*XMLNode, error) {
	var r rune
	//fmt.Println(&#34;FROM XML&#34;)
	var pdbg func(...interface{})
	var dbg func(rune, possibleState)
	stk := []*XMLNode{}
	isEmpty := func() bool { return len(stk) == 0 }
	//hasOnlyOne := func() bool { return len(stk) == 1 }
	hasSome := func() bool { return len(stk) &gt; 1 }
	push := func(xn *XMLNode) { stk = append(stk, xn) }
	getN := func(n int) *XMLNode {
		if isEmpty() {
			//debug.PrintStack()
			panic(&#34;Getting X on empty stack&#34;)
		}
		if len(stk)&#43;n &lt; 0 {
			panic(&#34;Going too far back for the length of the stack&#34;)
		}
		return stk[len(stk)&#43;n]
	}
	get := func() *XMLNode { return getN(-1) }
	pop := func() *XMLNode {
		if isEmpty() {
			panic(&#34;Popping X on empty stack&#34;)
		}
		result := getN(-1)
		stk = stk[:len(stk)-1]
		return result
	}
	getState := func() (rs possibleState) {
		defer func() {
			if r := recover(); r != nil {
				rs = xstart
			}
		}()
		return get().ntype
	}
	givenXML = strings.TrimSpace(givenXML)
	if !strings.HasPrefix(givenXML, &#34;&lt;&#34;) {
		panic(&#34;Given XML does not start with a &lt;: &#34; &#43; givenXML)
	}
	xmlReader := strings.NewReader(givenXML)
	ri := -1 // To account for incrementing early and still being zero based
	nextEscaped := false
	//isEscaped := false
	wasLessThan := false
	wasQuestion := false
	wasSolidus := false
	wasRightSquare := false
	wasA := false
	br := bufio.NewReader(xmlReader)
	unread := func() { br.UnreadRune(); ri -= 1 } // We ignore the err - we know we only ReadRune
	peek := func() rune {
		r, _, err := br.ReadRune()
		br.UnreadRune()
		if err != nil {
			fmt.Println(&#34;Failed to peek:&#34;, err)
			return 0
		}
		return r
	}
	pdbg = func(s ...interface{}) {
		if !givenOptions.Debug {
			return
		}
		fmt.Println(s...)
	}
	dbg = func(r rune, state possibleState) {
		if !givenOptions.Debug {
			return
		}
		var ss strings.Builder
		var pxs strings.Builder
		for i, xn := range stk {
			if i &gt; 0 {
				ss.WriteString(&#34;, &#34;)
				pxs.WriteString(&#34;, &#34;)
			}
			ss.WriteString(fromXState(xn.ntype))
			pxs.WriteString(xn.StringWithOptions(setNoHeader(givenOptions)))
		}
		fmt.Printf(`Debug:
	IN: %s
	States: %s
	PXs: %s
	Rune: %s
	ri: %d
`, givenXML, ss.String(), pxs.String(), string(r), ri)
	}
	var key strings.Builder
	var val strings.Builder
	collectVal := false
	//givenOptions.Debug = true
	for {
		previousr := r
		tmpr, _, err := br.ReadRune()
		if err != nil {
			if err != io.EOF {
				panic(err)
			}
			break
		}
		r = tmpr
		if nextEscaped {
			nextEscaped = false
			//isEscaped = true // This misses escaping the last rune... which I *think* would be invalid anyway
		}
		if r == utf8.RuneError {
			panic(&#34;Fail - invalid rune&#34;)
		}
		isSpace := unicode.IsSpace(r)
		isLessThan := r == &#39;&lt;&#39;
		isQuestion := r == &#39;?&#39;
		isGreaterThan := r == &#39;&gt;&#39;
		isSolidus := r == &#39;/&#39;
		isDouble := r == &#39;&#34;&#39;
		isEqual := r == &#39;=&#39;
		isRightSquare := r == &#39;]&#39;
		isLeftSquare := r == &#39;[&#39;
		isDeclStart := wasLessThan &amp;&amp; isQuestion
		isDeclEnd := wasQuestion &amp;&amp; isGreaterThan
		isPairedNodeEnd := wasLessThan &amp;&amp; isSolidus
		isNodeStart := wasLessThan &amp;&amp; !isSpace
		ri &#43;= 1
		pdbg(&#34;READ:&#34;, string(r), ri)
		pdbg(givenXML)
		if ri == 0 {
			pdbg(&#34;^&#34;)
		} else {
			pdbg(strings.Repeat(&#34; &#34;, ri-1), &#34;^&#34;)
		}
		wasLessThan = false // TODO - This is only useful *above* in the for loop... check the below usage...
		wasQuestion = false
		pdbg(&#34;Starting:&#34;)
		dbg(r, getState())
		switch getState() {
		case xstart:
			if isLessThan {
				wasLessThan = true
			} else if isDeclStart {
				push(stateXMLNode(&#34;&#34;, xdecl))
			} else if isPairedNodeEnd {
				get().ntype = xconsumeEndNode
			} else if isSpace { // Ignore
			} else if isNodeStart {
				if hasSome() &amp;&amp; getState() == xstart {
					pop()
				}
				push(stateXMLNode(&#34;&#34;, xnodeName))
				unread()
			} else if previousr == &#39;&gt;&#39; {
				get().ntype = xcontentNode
				get().updateName(r)
			} else if isSolidus {
				unread()
				get().ntype = xconsumeEndNode
			} else {
				panic(&#34;All supported cases are covered - this case is unsupported&#34;)
			}
		case xdecl:
			if isQuestion {
				wasQuestion = true
			}
			if isDeclEnd {
				pop()
			}
		case xnodeName:
			if len(get().name) == 0 &amp;&amp; r == &#39;!&#39; &amp;&amp; peek() == &#39;[&#39; {
				get().ntype = xcdataStart
			}
			if wasSolidus &amp;&amp; !isGreaterThan {
				wasSolidus = false
			}
			if isPairedNodeEnd || (wasLessThan &amp;&amp; isSolidus) {
				push(stateXMLNode(&#34;&#34;, xconsumeEndNode)) // This is the &lt;a&gt;&lt;/a&gt; case
			} else if isSolidus {
				wasSolidus = true
			} else if wasSolidus &amp;&amp; isGreaterThan { // This is the &lt;a/&gt; case
				if hasSome() {
					child := pop()
					get().Add(child)
					push(stateXMLNode(&#34;&#34;, xstart))
				}
			} else if isGreaterThan {
				push(stateXMLNode(&#34;&#34;, xstart))
			} else if isLessThan {
				if len(get().children) == 0 {
					push(NewXMLContentNode(pop().GetName()))
					child := pop()
					get().Add(child)
				}
				push(stateXMLNode(&#34;&#34;, xconsumeEndNode))
			} else if isSpace {
				push(stateXMLNode(&#34;&#34;, xconsumeAttrs))
			} else {
				get().updateName(r)
			}
		case xcdataStart:
			if wasA &amp;&amp; isLeftSquare {
				get().ntype = xcdata
				get().SetName(&#34;&#34;)
				wasA = false
			} else {
				wasA = true
			}
		case xcdata:
			if wasRightSquare &amp;&amp; isRightSquare &amp;&amp; peek() == &#39;&gt;&#39; {
				wasRightSquare = false
				get().ntype = xcdataEnd
			} else if !wasRightSquare &amp;&amp; isRightSquare {
				wasRightSquare = true
			} else {
				get().updateName(r)
				wasRightSquare = false
			}
		case xcdataEnd:
			if isGreaterThan {
				child := NewXMLContentNode(pop().givenName)
				child.cameFromCDATA = true
				get().Add(child)
				push(stateXMLNode(&#34;&#34;, xstart))
			} else {
				panic(&#34;There shouldn&#39;t be anything other than a &gt; to consume at this point&#34;)
			}
		case xconsumeAttrs:
			if isGreaterThan || isSolidus || isSpace {
				if len(val.String()) &gt; 0 { // TODO - bad cases v==0, k&gt;0... v&gt;0, k==0...
					getN(-2).updateName(&#39;[&#39;)
					for _, r := range key.String() {
						getN(-2).updateName(r)
					}
					getN(-2).updateName(&#39;=&#39;)
					for _, r := range val.String() {
						getN(-2).updateName(r)
					}
					getN(-2).updateName(&#39;]&#39;)
				}
				collectVal = false
				key.Reset()
				val.Reset()
				if isGreaterThan || isSolidus {
					unread()
					pop()
				}
			} else if isDouble {
				if len(key.String()) &gt; 0 {
					collectVal = true
				}
			} else if isEqual { // Ignore ??
			} else {
				if collectVal {
					val.WriteRune(r)
				} else {
					key.WriteRune(r)
				}
			}
		case xconsumeEndNode:
			if isGreaterThan {
				endingNode := pop()
				if endingNode.name != get().name {
					panic(fmt.Sprintf(
						&#34;Mismatched nodes. Maybe a child wasn&#39;t added to it&#39;s parent?\n\t%s\n\t%s&#34;,
						endingNode.name,
						get().name,
					))
				} else {
					if hasSome() {
						child := pop()
						get().Add(child)
					}
				}
				push(stateXMLNode(&#34;&#34;, xstart))
			} else if isSolidus { // IGNORE
			} else {
				get().updateName(r)
			}
		case xcontentNode: // TODO - needs work...
			if isLessThan {
				child := NewXMLContentNode(pop().GetName())
				get().Add(child)
				push(stateXMLNode(&#34;&#34;, xstart))
			} else {
				get().updateName(r)
			}
		default:
			panic(&#34;Unhandled state: &#34; &#43; fromXState(getState()))
		}
		//isEscaped = false
		pdbg(&#34;Ending:&#34;)
		dbg(r, getState())
		pdbg(&#34;\n\n&#34;)
	}
	return stk[0], nil
}
<pre></div>