// =========================================================================
//
// tinyxmldom.js - an XML DOM parser in JavaScript compressed for downloading
//
//	This is the classic DOM that has shipped with XML for <SCRIPT>
//  since the beginning. For a more standards-compliant DOM, you may
//  wish to use the standards-compliant W3C DOM that is included
//  with XML for <SCRIPT> versions 3.0 and above
//
//
// version 3.1
//
// =========================================================================
//
// Copyright (C) 2000 - 2002, 2003 Michael Houghton (mike@idle.org), Raymond Irving and David Joham (djoham@yahoo.com)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Visit the XML for <SCRIPT> home page at http://xmljs.sourceforge.net
//

var whitespace = "\n\r\t ";
var quotes = "\"'";
function convertEscapes(str) {
    var gt;
    gt = -1;
    while (str.indexOf("&lt;", gt + 1) > -1) {
        var gt = str.indexOf("&lt;", gt + 1);
        var newStr = str.substr(0, gt);
        newStr += "<";
        newStr = newStr + str.substr(gt + 4, str.length);
        str = newStr;
    }
    gt = -1;
    while (str.indexOf("&gt;", gt + 1) > -1) {
        var gt = str.indexOf("&gt;", gt + 1);
        var newStr = str.substr(0, gt);
        newStr += ">";
        newStr = newStr + str.substr(gt + 4, str.length);
        str = newStr;
    }
    gt = -1;
    while (str.indexOf("&amp;", gt + 1) > -1) {
        var gt = str.indexOf("&amp;", gt + 1);
        var newStr = str.substr(0, gt);
        newStr += "&";
        newStr = newStr + str.substr(gt + 5, str.length);
        str = newStr;
    }
    return str;
}
function convertToEscapes(str) {
    var gt = -1;
    while (str.indexOf("&", gt + 1) > -1) {
        gt = str.indexOf("&", gt + 1);
        var newStr = str.substr(0, gt);
        newStr += "&amp;";
        newStr = newStr + str.substr(gt + 1, str.length);
        str = newStr;
    }
    gt = -1;
    while (str.indexOf("<", gt + 1) > -1) {
        var gt = str.indexOf("<", gt + 1);
        var newStr = str.substr(0, gt);
        newStr += "&lt;";
        newStr = newStr + str.substr(gt + 1, str.length);
        str = newStr;
    }
    gt = -1;
    while (str.indexOf(">", gt + 1) > -1) {
        var gt = str.indexOf(">", gt + 1);
        var newStr = str.substr(0, gt);
        newStr += "&gt;";
        newStr = newStr + str.substr(gt + 1, str.length);
        str = newStr;
    }
    return str;
}
function _displayElement(domElement, strRet) {
    if (domElement == null) {
        return;
    }
    if (!(domElement.nodeType == 'ELEMENT')) {
        return;
    }
    var tagName = domElement.tagName;
    var tagInfo = "";
    tagInfo = "<" + tagName;
    var attributeList = domElement.getAttributeNames();
    for (var intLoop = 0; intLoop < attributeList.length; intLoop++) {
        var attribute = attributeList[intLoop];
        tagInfo = tagInfo + " " + attribute + "=";
        tagInfo = tagInfo + "\"" + domElement.getAttribute(attribute) + "\"";
    }
    tagInfo = tagInfo + ">";
    strRet = strRet + tagInfo;
    if (domElement.children != null) {
        var domElements = domElement.children;
        for (var intLoop = 0; intLoop < domElements.length; intLoop++) {
            var childNode = domElements[intLoop];
            if (childNode.nodeType == 'COMMENT') {
                strRet = strRet + "<!--" + childNode.content + "-->";
            }
            else if (childNode.nodeType == 'TEXT') {
                var cont = trim(childNode.content, true, true);
                strRet = strRet + childNode.content;
            }
            else if (childNode.nodeType == 'CDATA') {
                var cont = trim(childNode.content, true, true);
                strRet = strRet + "<![CDATA[" + cont + "]]>";
            }
            else {
                strRet = _displayElement(childNode, strRet);
            }
        }
    }
    strRet = strRet + "</" + tagName + ">";
    return strRet;
}
function firstWhiteChar(str, pos) {
    if (isEmpty(str)) {
        return -1;
    }
    while (pos < str.length) {
        if (whitespace.indexOf(str.charAt(pos)) != -1) {
            return pos;
        }
        else {
            pos++;
        }
    }
    return str.length;
}
function isEmpty(str) {
    return (str == null) || (str.length == 0);
}
function trim(trimString, leftTrim, rightTrim) {
    if (isEmpty(trimString)) {
        return "";
    }
    if (leftTrim == null) {
        leftTrim = true;
    }
    if (rightTrim == null) {
        rightTrim = true;
    }
    var left = 0;
    var right = 0;
    var i = 0;
    var k = 0;
    if (leftTrim == true) {
        while ((i < trimString.length) && (whitespace.indexOf(trimString.charAt(i++)) != -1)) {
            left++;
        }
    }
    if (rightTrim == true) {
        k = trimString.length - 1;
        while ((k >= left) && (whitespace.indexOf(trimString.charAt(k--)) != -1)) {
            right++;
        }
    }
    return trimString.substring(left, trimString.length - right);
}
function XMLDoc(source, errFn) {
    this.topNode = null;
    this.errFn = errFn;
    this.createXMLNode = _XMLDoc_createXMLNode;
    this.error = _XMLDoc_error;
    this.getUnderlyingXMLText = _XMLDoc_getUnderlyingXMLText;
    this.handleNode = _XMLDoc_handleNode;
    this.hasErrors = false;
    this.insertNodeAfter = _XMLDoc_insertNodeAfter;
    this.insertNodeInto = _XMLDoc_insertNodeInto;
    this.loadXML = _XMLDoc_loadXML;
    this.parse = _XMLDoc_parse;
    this.parseAttribute = _XMLDoc_parseAttribute;
    this.parseDTD = _XMLDoc_parseDTD;
    this.parsePI = _XMLDoc_parsePI;
    this.parseTag = _XMLDoc_parseTag;
    this.removeNodeFromTree = _XMLDoc_removeNodeFromTree;
    this.replaceNodeContents = _XMLDoc_replaceNodeContents;
    this.selectNode = _XMLDoc_selectNode;
    this.selectNodeText = _XMLDoc_selectNodeText;
    this.source = source;
    if (this.parse()) {
        if (this.topNode != null) {
            return this.error("expected close " + this.topNode.tagName);
        }
        else {
            return true;
        }
    }
}
function _XMLDoc_createXMLNode(strXML) {
    return new XMLDoc(strXML, this.errFn).docNode;
}
function _XMLDoc_error(str) {
    this.hasErrors = true;
    if (this.errFn) {
        this.errFn("ERROR: " + str);
    } else if (this.onerror) {
        this.onerror("ERROR: " + str);
    }
    return 0;
}
function _XMLDoc_getTagNameParams(tag, obj) {
    var elm = -1,e,s = tag.indexOf('[');
    var attr = [];
    if (s >= 0) {
        e = tag.indexOf(']');
        if (e >= 0)elm = tag.substr(s + 1, (e - s) - 1); else obj.error('expected ] near ' + tag);
        tag = tag.substr(0, s);
        if (isNaN(elm) && elm != '*') {
            attr = elm.substr(1, elm.length - 1);
            attr = attr.split('=');
            if (attr[1]) {
                s = attr[1].indexOf('"');
                attr[1] = attr[1].substr(s + 1, attr[1].length - 1);
                e = attr[1].indexOf('"');
                if (e >= 0) attr[1] = attr[1].substr(0, e); else obj.error('expected " near ' + tag)
            }
            ;
            elm = -1;
        } else if (elm == '*') elm = -1;
    }
    return [tag,elm,attr[0],attr[1]]
}
function _XMLDoc_getUnderlyingXMLText() {
    var strRet = "";
    strRet = strRet + "<?xml version=\"1.0\"?>";
    if (this.docNode == null) {
        return;
    }
    strRet = _displayElement(this.docNode, strRet);
    return strRet;
}
function _XMLDoc_handleNode(current) {
    if ((current.nodeType == 'COMMENT') && (this.topNode != null)) {
        return this.topNode.addElement(current);
    }
    else if ((current.nodeType == 'TEXT') || (current.nodeType == 'CDATA')) {
        if (this.topNode == null) {
            if (trim(current.content, true, false) == "") {
                return true;
            }
            else {
                return this.error("expected document node, found: " + current);
            }
        }
        else {
            return this.topNode.addElement(current);
        }
    }
    else if ((current.nodeType == 'OPEN') || (current.nodeType == 'SINGLE')) {
        var success = false;
        if (this.topNode == null) {
            this.docNode = current;
            current.parent = null;
            success = true;
        }
        else {
            success = this.topNode.addElement(current);
        }
        if (success && (current.nodeType != 'SINGLE')) {
            this.topNode = current;
        }
        current.nodeType = "ELEMENT";
        return success;
    }
    else if (current.nodeType == 'CLOSE') {
        if (this.topNode == null) {
            return this.error("close tag without open: " + current.toString());
        }
        else {
            if (current.tagName != this.topNode.tagName) {
                return this.error("expected closing " + this.topNode.tagName + ", found closing " + current.tagName);
            }
            else {
                this.topNode = this.topNode.getParent();
            }
        }
    }
    return true;
}
function _XMLDoc_insertNodeAfter(referenceNode, newNode) {
    var parentXMLText = this.getUnderlyingXMLText();
    var selectedNodeXMLText = referenceNode.getUnderlyingXMLText();
    var originalNodePos = parentXMLText.indexOf(selectedNodeXMLText) + selectedNodeXMLText.length;
    var newXML = parentXMLText.substr(0, originalNodePos);
    newXML += newNode.getUnderlyingXMLText();
    newXML += parentXMLText.substr(originalNodePos);
    var newDoc = new XMLDoc(newXML, this.errFn);
    return newDoc;
}
function _XMLDoc_insertNodeInto(referenceNode, insertNode) {
    var parentXMLText = this.getUnderlyingXMLText();
    var selectedNodeXMLText = referenceNode.getUnderlyingXMLText();
    var endFirstTag = selectedNodeXMLText.indexOf(">") + 1;
    var originalNodePos = parentXMLText.indexOf(selectedNodeXMLText) + endFirstTag;
    var newXML = parentXMLText.substr(0, originalNodePos);
    newXML += insertNode.getUnderlyingXMLText();
    newXML += parentXMLText.substr(originalNodePos);
    var newDoc = new XMLDoc(newXML, this.errFn);
    return newDoc;
}
function _XMLDoc_loadXML(source) {
    this.topNode = null;
    this.hasErrors = false;
    this.source = source;
    return this.parse();
}
function _XMLDoc_parse() {
    var pos = 0;
    err = false;
    while (!err) {
        var closing_tag_prefix = '';
        var chpos = this.source.indexOf('<', pos);
        var open_length = 1;
        var open;
        var close;
        if (chpos == -1) {
            break;
        }
        open = chpos;
        var str = this.source.substring(pos, open);
        if (str.length != 0) {
            err = !this.handleNode(new XMLNode('TEXT', this, str));
        }
        if (chpos == this.source.indexOf("<?", pos)) {
            pos = this.parsePI(this.source, pos + 2);
            if (pos == 0) {
                err = true;
            }
            continue;
        }
        if (chpos == this.source.indexOf("<!DOCTYPE", pos)) {
            pos = this.parseDTD(this.source, chpos + 9);
            if (pos == 0) {
                err = true;
            }
            continue;
        }
        if (chpos == this.source.indexOf('<!--', pos)) {
            open_length = 4;
            closing_tag_prefix = '--';
        }
        if (chpos == this.source.indexOf('<![CDATA[', pos)) {
            open_length = 9;
            closing_tag_prefix = ']]';
        }
        chpos = this.source.indexOf(closing_tag_prefix + '>', chpos);
        if (chpos == -1) {
            return this.error("expected closing tag sequence: " + closing_tag_prefix + '>');
        }
        close = chpos + closing_tag_prefix.length;
        str = this.source.substring(open + 1, close);
        var n = this.parseTag(str);
        if (n) {
            err = !this.handleNode(n);
        }
        pos = close + 1;
    }
    return !err;
}
function _XMLDoc_parseAttribute(src, pos, node) {
    while ((pos < src.length) && (whitespace.indexOf(src.charAt(pos)) != -1)) {
        pos++;
    }
    if (pos >= src.length) {
        return pos;
    }
    var p1 = pos;
    while ((pos < src.length) && (src.charAt(pos) != '=')) {
        pos++;
    }
    var msg = "attributes must have values";
    if (pos >= src.length) {
        return this.error(msg);
    }
    var paramname = trim(src.substring(p1, pos++), false, true);
    while ((pos < src.length) && (whitespace.indexOf(src.charAt(pos)) != -1)) {
        pos++;
    }
    if (pos >= src.length) {
        return this.error(msg);
    }
    msg = "attribute values must be in quotes";
    var quote = src.charAt(pos++);
    if (quotes.indexOf(quote) == -1) {
        return this.error(msg);
    }
    p1 = pos;
    while ((pos < src.length) && (src.charAt(pos) != quote)) {
        pos++;
    }
    if (pos >= src.length) {
        return this.error(msg);
    }
    if (!node.addAttribute(paramname, trim(src.substring(p1, pos++), false, true))) {
        return 0;
    }
    return pos;
}
function _XMLDoc_parseDTD(str, pos) {
    var firstClose = str.indexOf('>', pos);
    if (firstClose == -1) {
        return this.error("error in DTD: expected '>'");
    }
    var closing_tag_prefix = '';
    var firstOpenSquare = str.indexOf('[', pos);
    if ((firstOpenSquare != -1) && (firstOpenSquare < firstClose)) {
        closing_tag_prefix = ']';
    }
    while (true) {
        var closepos = str.indexOf(closing_tag_prefix + '>', pos);
        if (closepos == -1) {
            return this.error("expected closing tag sequence: " + closing_tag_prefix + '>');
        }
        pos = closepos + closing_tag_prefix.length + 1;
        if (str.substring(closepos - 1, closepos + 2) != ']]>') {
            break;
        }
    }
    return pos;
}
function _XMLDoc_parsePI(str, pos) {
    var closepos = str.indexOf('?>', pos);
    return closepos + 2;
}
function _XMLDoc_parseTag(src) {
    if (src.indexOf('!--') == 0) {
        return new XMLNode('COMMENT', this, src.substring(3, src.length - 2));
    }
    if (src.indexOf('![CDATA[') == 0) {
        return new XMLNode('CDATA', this, src.substring(8, src.length - 2));
    }
    var n = new XMLNode();
    n.doc = this;
    if (src.charAt(0) == '/') {
        n.nodeType = 'CLOSE';
        src = src.substring(1);
    }
    else {
        n.nodeType = 'OPEN';
    }
    if (src.charAt(src.length - 1) == '/') {
        if (n.nodeType == 'CLOSE') {
            return this.error("singleton close tag");
        }
        else {
            n.nodeType = 'SINGLE';
        }
        src = src.substring(0, src.length - 1);
    }
    if (n.nodeType != 'CLOSE') {
        n.attributes = new Array();
    }
    if (n.nodeType == 'OPEN') {
        n.children = new Array();
    }
    src = trim(src, true, true);
    if (src.length == 0) {
        return this.error("empty tag");
    }
    var endOfName = firstWhiteChar(src, 0);
    if (endOfName == -1) {
        n.tagName = src;
        return n;
    }
    n.tagName = src.substring(0, endOfName);
    var pos = endOfName;
    while (pos < src.length) {
        pos = this.parseAttribute(src, pos, n);
        if (this.pos == 0) {
            return null;
        }
    }
    return n;
}
function _XMLDoc_removeNodeFromTree(node) {
    var parentXMLText = this.getUnderlyingXMLText();
    var selectedNodeXMLText = node.getUnderlyingXMLText();
    var originalNodePos = parentXMLText.indexOf(selectedNodeXMLText);
    var newXML = parentXMLText.substr(0, originalNodePos);
    newXML += parentXMLText.substr(originalNodePos + selectedNodeXMLText.length);
    var newDoc = new XMLDoc(newXML, this.errFn);
    return newDoc;
}
function _XMLDoc_replaceNodeContents(referenceNode, newContents) {
    var newNode = this.createXMLNode("<X>" + newContents + "</X>");
    referenceNode.children = newNode.children;
    return this;
}
function _XMLDoc_selectNode(tagpath) {
    tagpath = trim(tagpath, true, true);
    var srcnode,node,tag,params,elm,rg;
    var tags,attrName,attrValue,ok;
    srcnode = node = ((this.source)?this.docNode:this);
    if (!tagpath) return node;
    if (tagpath.indexOf('/') == 0)tagpath = tagpath.substr(1);
    tagpath = tagpath.replace(tag, '');
    tags = tagpath.split('/');
    tag = tags[0];
    if (tag) {
        if (tagpath.indexOf('/') == 0)tagpath = tagpath.substr(1);
        tagpath = tagpath.replace(tag, '');
        params = _XMLDoc_getTagNameParams(tag, this);
        tag = params[0];
        elm = params[1];
        attrName = params[2];
        attrValue = params[3];
        node = (tag == '*')? node.getElements():node.getElements(tag);
        if (node.length) {
            if (elm < 0) {
                srcnode = node;
                var i = 0;
                while (i < srcnode.length) {
                    if (attrName) {
                        if (srcnode[i].getAttribute(attrName) != attrValue) ok = false; else ok = true;
                    } else ok = true;
                    if (ok) {
                        node = srcnode[i].selectNode(tagpath);
                        if (node) return node;
                    }
                    i++;
                }
            } else if (elm < node.length) {
                node = node[elm].selectNode(tagpath);
                if (node) return node;
            }
        }
    }
}
function _XMLDoc_selectNodeText(tagpath) {
    var node = this.selectNode(tagpath);
    if (node != null) {
        return node.getText();
    }
    else {
        return null;
    }
}
function XMLNode(nodeType, doc, str) {
    if (nodeType == 'TEXT' || nodeType == 'CDATA' || nodeType == 'COMMENT') {
        this.content = str;
    }
    else {
        this.content = null;
    }
    this.attributes = null;
    this.children = null;
    this.doc = doc;
    this.nodeType = nodeType;
    this.parent = "";
    this.tagName = "";
    this.addAttribute = _XMLNode_addAttribute;
    this.addElement = _XMLNode_addElement;
    this.getAttribute = _XMLNode_getAttribute;
    this.getAttributeNames = _XMLNode_getAttributeNames;
    this.getElementById = _XMLNode_getElementById;
    this.getElements = _XMLNode_getElements;
    this.getText = _XMLNode_getText;
    this.getParent = _XMLNode_getParent;
    this.getUnderlyingXMLText = _XMLNode_getUnderlyingXMLText;
    this.removeAttribute = _XMLNode_removeAttribute;
    this.selectNode = _XMLDoc_selectNode;
    this.selectNodeText = _XMLDoc_selectNodeText;
    this.toString = _XMLNode_toString;
}
function _XMLNode_addAttribute(attributeName, attributeValue) {
    this.attributes['_' + attributeName] = attributeValue;
    return true;
}
function _XMLNode_addElement(node) {
    node.parent = this;
    this.children[this.children.length] = node;
    return true;
}
function _XMLNode_getAttribute(name) {
    if (this.attributes == null) {
        return null;
    }
    return this.attributes['_' + name];
}
function _XMLNode_getAttributeNames() {
    if (this.attributes == null) {
        var ret = new Array();
        return ret;
    }
    var attlist = new Array();
    for (var a in this.attributes) {
        attlist[attlist.length] = a.substring(1);
    }
    return attlist;
}
function _XMLNode_getElementById(id) {
    var node = this;
    var ret;
    if (node.getAttribute("id") == id) {
        return node;
    }
    else {
        var elements = node.getElements();
        var intLoop = 0;
        while (intLoop < elements.length) {
            var element = elements[intLoop];
            ret = element.getElementById(id);
            if (ret != null) {
                break;
            }
            intLoop++;
        }
    }
    return ret;
}
function _XMLNode_getElements(byName) {
    if (this.children == null) {
        var ret = new Array();
        return ret;
    }
    var elements = new Array();
    for (var i = 0; i < this.children.length; i++) {
        if ((this.children[i].nodeType == 'ELEMENT') && ((byName == null) || (this.children[i].tagName == byName))) {
            elements[elements.length] = this.children[i];
        }
    }
    return elements;
}
function _XMLNode_getText() {
    if (this.nodeType == 'ELEMENT') {
        if (this.children == null) {
            return null;
        }
        var str = "";
        for (var i = 0; i < this.children.length; i++) {
            var t = this.children[i].getText();
            str += (t == null ? "" : t);
        }
        return str;
    }
    else if (this.nodeType == 'TEXT') {
        return convertEscapes(this.content);
    }
    else {
        return this.content;
    }
}
function _XMLNode_getParent() {
    return this.parent;
}
function _XMLNode_getUnderlyingXMLText() {
    var strRet = "";
    strRet = _displayElement(this, strRet);
    return strRet;
}
function _XMLNode_removeAttribute(attributeName) {
    if (attributeName == null) {
        return this.doc.error("You must pass an attribute name into the removeAttribute function");
    }
    var attributes = this.getAttributeNames();
    var intCount = attributes.length;
    var tmpAttributeValues = new Array();
    for (intLoop = 0; intLoop < intCount; intLoop++) {
        tmpAttributeValues[intLoop] = this.getAttribute(attributes[intLoop]);
    }
    this.attributes = new Array();
    for (intLoop = 0; intLoop < intCount; intLoop++) {
        if (attributes[intLoop] != attributeName) {
            this.addAttribute(attributes[intLoop], tmpAttributeValues[intLoop]);
        }
    }
    return true;
}
function _XMLNode_toString() {
    return "" + this.nodeType + ":" + (this.nodeType == 'TEXT' || this.nodeType == 'CDATA' || this.nodeType == 'COMMENT' ? this.content : this.tagName);
}