ltxml.js

/***************************************************************************

Copyright (c) Microsoft Corporation 2013.

This code is licensed using the Microsoft Public License (Ms-PL).  You can find the text of the license here:

http://www.microsoft.com/resources/sharedsource/licensingbasics/publiclicense.mspx

Published at http://OpenXmlDeveloper.org
Resource Center and Documentation: http://openxmldeveloper.org/wiki/w/wiki/open-xml-sdk-for-javascript.aspx

Developer: Eric White
Blog: http://www.ericwhite.com
Twitter: @EricWhiteDev
Email: eric@ericwhite.com

***************************************************************************/

/*********************** API ***********************/
/*

***** Ltxml *****
* Ltxml.clearCache()

****************************************************
*===== XName =====
* new XName(namespace, name)      // namespace is an XNamespace object, name is string
* new XName(name)                 // name is string, is in no namespace
* new XName(name)                 // name = '{namespaceURI}name'
* XName.get(expandedName)
* XName.get(namespace, localName)
* XName.toString()

***** props implemented as fields *****
* XName.localName
* XName.namespace
* XName.namespaceName

****************************************************
*===== XNamespace =====
* new XNamespace(uri)
* XNamespace.get(uri)
* XNamespace.getName(localName)
* XNamespace.toString()

***** props implemented as fields *****
* XNamespace.namespaceName

***** static props *****
* XNamespace.getNone()               // returns namespace for 'no namespace'
* XNamespace.none

* XNamespace.getXml()                // http://www.w3.org/XML/1998/namespace
* XNamespace.xml

* XNamespace.getXmlns()              // http://www.w3.org/2000/xmlns/
* XNamespace.xmlns

****************************************************
*===== XObject (abstract) =====
* XObject.addAnnotation(type, object)  // type is string
* XObject.annotation(type)
* XObject.annotations(type)
* XObject.removeAnnotations
* XObject.removeAnnotations(type)

***** props implemented as fields *****
* XObject.nodeType
* XObject.parent

***** props *****
* XObject.getDocument()
* XObject.document

****************************************************
*===== XNode: XObject (abstract) =====
* XNode.addAfterSelf(varargs)
* XNode.addBeforeSelf(varargs)
* XNode.ancestors()
* XNode.ancestors(xname)
* XNode.deepEquals
* XNode.elementsAfterSelf()
* XNode.elementsAfterSelf(xname)
* XNode.elementsBeforeSelf()
* XNode.elementsBeforeSelf(xname)
* XNode.nodesAfterSelf()
* XNode.nodesBeforeSelf()
* XNode.remove()
* XNode.replaceWith(content)

***** props implemented as field *****
* XNode.nodeType
* XNode.parent

***** props *****
* XNode.getNextNode()
* XNode.nextNode

* XNode.getPreviousNode()
* XNode.previousNode

****************************************************
*===== XAttribute: XObject =====
* new XAttribute(name, value)
* new XAttribute(XAttribute)
* XAttribute.remove()
* XAttribute.setValue(value)
* XAttribute.toString()

***** props implemented as fields *****
* XAttribute.isNamespaceDeclaration
* XAttribute.name
* XAttribute.nodeType
* XAttribute.parent
* XAttribute.value

***** props *****
* XAttribute.getNextAttribute()
* XAttribute.nextAttribute

* XAttribute.getPreviousAttribute()
* XAttribute.previousAttribute

****************************************************
*===== XComment: XNode =====
* new XComment(value)
* new XComment(xcomment)
* XComment.toString()
* XComment.toString(indent)

***** props implemented as fields *****
* XComment.nodeType
* XComment.parent
* XComment.value

****************************************************
*===== XContainer: XNode =====
* XContainer.add(content)
* XContainer.addFirst(content)
* XContainer.descendantNodes
* XContainer.descendants()
* XContainer.descendants(xname)
* XContainer.element(xname)
* XContainer.elements()
* XContainer.elements(xname)
* XContainer.nodes()
* XContainer.removeNodes()
* XContainer.replaceNodes(content)

***** props implemented as fields *****
* XContainer.nodeType
* XContainer.parent

***** props *****
* XContainer.getFirstNode()
* XContainer.firstNode

* XContainer.getLastNode()
* XContainer.lastNode

****************************************************
*===== XDeclaration =====
* new XDeclaration(version, encoding, standalone)
* new XDeclaration(xdeclaration)
* XDeclaration.toString(indent)

***** props implemented as fields *****
* XDeclaration.encoding
* XDeclaration.standalone
* XDeclaration.version

****************************************************
*===== XDocument: XContainer =====
* new XDocument()
* new XDocument(content)
* new XDocument(xdocument)
* new XDocument(xdeclaration, content)
* XDocument.descendants()
* XDocument.descendants(xname)
* XDocument.parse(xml)
* XDocument.load(XMLDocument)
* XDocument.toString()
* XDocument.toString(indent)

***** props implemented as fields *****
* XDocument.nodeType
* XDocument.parent
* XDocument.declaration

***** props *****
* XDocument.getRoot()
* XDocument.root

****************************************************
*===== XElement: XContainer =====
* new XElement(xelement)          copy constructor
* new XElement(xname)
* new XElement(xname, varargs)
* XElement.ancestorsAndSelf()
* XElement.ancestorsAndSelf(xname)
* XElement.attribute(xname)
* XElement.attributes()
* XElement.attributes(xname)
* XElement.descendantNodesAndSelf()
* XElement.descendantsAndSelf()
* XElement.descendantsAndSelf(xname)
* XElement.getDefaultNamespace()
* XElement.getNamespaceOfPrefix()
* XElement.getPrefixOfNamespace()
* XElement.load(XMLDocument)
* XElement.parse()
* XElement.removeAll()
* XElement.removeAttributes()
* XElement.replaceAll(content)
* XElement.replaceAttributes(content)
* XElement.setAttributeValue(xname, value)
* XElement.setElementValue(xname, value)
* XElement.toString()
* XElement.toString(indent)

***** props implemented as fields *****
* XElement.name
* XElement.nodeType
* XElement.parent

***** props *****
* XElement.getFirstAttribute()
* XElement.firstAttribute

* XElement.getHasAttributes()
* XElement.hasAttributes

* XElement.getHasElements()
* XElement.hasElements

* XElement.getIsEmpty()
* XElement.isEmpty

* XElement.getLastAttribute()
* XElement.lastAttribute

* XElement.getValue
* XElement.setValue()
* XElement.value

****************************************************
*===== XProcessingInstruction: XNode =====
* new XProcessingInstruction(xprocessingInstruction)
* new XProcessingInstruction(target, data)
* XProcessingInstruction.toString()
* XProcessingInstruction.toString(indent)

***** props implemented as fields *****
* XProcessingInstruction.data
* XProcessingInstruction.nodeType
* XProcessingInstruction.parent
* XProcessingInstruction.target

****************************************************
*===== XText: XNode =====
* new XText(value)
* new XText(XText)
* XText.toString()

***** props implemented as fields *****
* XText.nodeType
* XText.parent
* XText.value

****************************************************
*===== XEntity: XNode =====
* new XEntity(value)
* new XEntity(XEntity)
* XEntity.toString()

***** props implemented as fields *****
* XEntity.nodeType
* XEntity.parent
* XEntity.value

****************************************************
*===== XCData: XText =====
* new XCData(value)
* new XCData(XCData)
* XCData.toString()

***** props implemented as fields *****
* XCData.nodeType
* XCData.parent
* XCData.value

****************************************************
*===== Extension methods =====
* ancestors()
* ancestors(xname)
* ancestorsAndSelf()
* ancestorsAndSelf(xname)
* attributes()
* attributes(xname)
* descendantNodes()
* descendantNodesAndSelf()
* descendants()
* descendants(xname)
* descendantsAndSelf()
* descendantsAndSelf(xname)
* elements()
* elements(xname)
* nodes()
* remove(xname)

*/

"use strict";

var Enumerable = require('linq');
var Ltxml;

var parseXml, Functions, Ltxml, addContentThatCanContainEntities,
    serializeAttributeContent, annotateRootForNamespaces,
    prefixCounter, entityCodePoints, entities,
    ancestors, ancestorsAndSelf, attributes, descendantNodes, descendantNodesAndSelf, descendants, descendantsAndSelf, elements,
    inDocumentOrder, nodes, remove
;

/********************** utility **********************/

// if using JQuery
//Enumerable = $.Enumerable;

if (!Array.isArray) {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) == '[object Array]'; //ignore jslint
    };
}

Functions = {
    Identity: function (x) { return x; },
    True: function () { return true; },
    Blank: function () { }
};

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (item) {
        var i;

        for (i = 0; i < this.length; i += 1) {
            if (this[i] === item) {
                return i;
            }
        }
        return -1;
    };
}

/*ignore jslint start*/
parseXml = function (xmlStr) {
    var domParser;

    // If there is a BOM at the beginning of the XML, then remove it.  The DOMParser in Chrome (V8 browser)
    // does not process the BOM correctly.  The BOM is processed correctly by the IE Chakra engine, as well
    // as the DOMParser in NodeJS.
    if (xmlStr.charCodeAt(0) === 0xFEFF) {
        xmlStr = xmlStr.substring(1);
    }

    if (typeof Ltxml.DOMParser !== "undefined") {
        domParser = (new Ltxml.DOMParser()).parseFromString(xmlStr, "application/xml");
        return domParser;
    }
    else if (typeof window.DOMParser !== "undefined") {
        domParser = (new window.DOMParser()).parseFromString(xmlStr, "application/xml");
        return domParser;
    } else if (typeof window.ActiveXObject !== "undefined" &&
            new window.ActiveXObject("Microsoft.XMLDOM")) {
        var xmlDoc = new window.ActiveXObject("Microsoft.XMLDOM");
        xmlDoc.async = "false";
        xmlDoc.loadXML(xmlStr);
        return xmlDoc;
    } else {
        throw new Error("No XML parser found");
    }
};
/*ignore jslint end*/

/********************** global **********************/

Ltxml = {};  // container(namespace)

Ltxml.namespaceCache = {};
Ltxml.nameCache = {};
Ltxml.spaces = '                                             ' +
    '                                             ';
function getStringBuilder() {
    var data, counter;

    data = [];
    counter = 0;
    return {
        a: function (s) { data[counter += 1] = s; return this; },  //ignore jslint
        toString: function (s) { return data.join(s || ""); }
    };
}

Ltxml.clearCache = function () {
    this.namespaceCache = {};
    this.nameCache = {};
};

Ltxml.cast = function (elementOrAttribute) {
    if (!elementOrAttribute) {
        return null;
    }
    return elementOrAttribute.value;
};

Ltxml.castInt = function (elementOrAttribute) {
    if (!elementOrAttribute) {
        return null;
    }
    return parseInt(elementOrAttribute.value, 10);
};

function addContent(xobj, putContentFunc, putAttributeFunc) {
    var t, ta, newEl, newTx, newCo, newCd, newAt, newPi, i, j, k;

    for (i = 3; i < arguments.length; i += 1) {
        t = arguments[i];
        if (t !== null && t !== undefined) {
            if (Array.isArray(t)) {
                for (j = 0; j < t.length; j += 1) {
                    addContent(xobj, putContentFunc, putAttributeFunc, t[j]);
                }
            } else if (t.select) {
                ta = t.toArray();
                for (k = 0; k < ta.length; k += 1) {
                    addContent(xobj, putContentFunc, putAttributeFunc, ta[k]);
                }
            } else if (t.isXEnumerable) {
                ta = t.asEnumerable().toArray();
                for (k = 0; k < ta.length; k += 1) {
                    addContent(xobj, putContentFunc, putAttributeFunc, ta[k]);
                }
            } else if (typeof t === 'object' && t.nodeType) {
                if (t.nodeType === 'Element' ||
                        t.nodeType === 'Text' ||
                        t.nodeType === 'Comment' ||
                        t.nodeType === 'CDATA' ||
                        t.nodeType === 'ProcessingInstruction' ||
                        t.nodeType === 'Entity') {
                    if (t.parent && t.parent !== null) {
                        // then need to clone
                        if (t.nodeType === 'Element') {
                            newEl = new Ltxml.XElement(t);
                            newEl.parent = xobj;
                            putContentFunc(newEl);
                            return;
                        }
                        if (t.nodeType === 'Entity') {
                            newTx = new Ltxml.XEntity(t);
                            newTx.parent = xobj;
                            putContentFunc(newTx);
                            return;
                        }
                        if (t.nodeType === 'Text') {
                            newTx = new Ltxml.XText(t);
                            newTx.parent = xobj;
                            putContentFunc(newTx);
                            return;
                        }
                        if (t.nodeType === 'Comment') {
                            newCo = new Ltxml.XComment(t);
                            newCo.parent = xobj;
                            putContentFunc(newCo);
                            return;
                        }
                        if (t.nodeType === 'CDATA') {
                            newCd = new Ltxml.XCData(t);
                            newCd.parent = xobj;
                            putContentFunc(newCd);
                            return;
                        }
                        if (t.nodeType === 'ProcessingInstruction') {
                            newPi = new Ltxml.XProcessingInstruction(t);
                            newPi.parent = xobj;
                            putContentFunc(newPi);
                            return;
                        }
                    }
                    t.parent = xobj;
                    putContentFunc(t);
                    return;
                }
                if (t.nodeType === 'Attribute') {
                    if (t.parent && t.parent !== null) {
                        // then need to clone
                        newAt = new Ltxml.XAttribute(t);
                        newAt.parent = xobj;
                        putAttributeFunc(newAt);
                        return;
                    }
                    t.parent = xobj;
                    putAttributeFunc(t);
                    return;
                }
            } else {
                if (typeof t === 'string' && t === '') {
                    newTx = new Ltxml.XText('');
                    newTx.parent = xobj;
                    putContentFunc(newTx);
                    return;
                }
                addContentThatCanContainEntities(t.toString(), xobj, true, putContentFunc);
            }
        }
    }
}

entityCodePoints = [
    60,
    62,
    39,
    34,
    38
    /*,
    160,
    161,
    162,
    163,
    164,
    165,
    166,
    167,
    168,
    169,
    170,
    171,
    172,
    173,
    174,
    175,
    176,
    177,
    178,
    179,
    180,
    181,
    182,
    183,
    184,
    185,
    186,
    187,
    188,
    189,
    190,
    191,
    192,
    193,
    194,
    195,
    196,
    197,
    198,
    199,
    200,
    201,
    202,
    203,
    204,
    205,
    206,
    207,
    208,
    209,
    210,
    211,
    212,
    213,
    214,
    215,
    216,
    217,
    218,
    219,
    220,
    221,
    222,
    223,
    224,
    225,
    226,
    227,
    228,
    229,
    230,
    231,
    232,
    233,
    234,
    235,
    236,
    237,
    238,
    239,
    240,
    241,
    242,
    243,
    244,
    245,
    246,
    247,
    248,
    249,
    250,
    251,
    252,
    253,
    254,
    255,
    338,
    339,
    352,
    353,
    376,
    402,
    710,
    732,
    913,
    914,
    915,
    916,
    917,
    918,
    919,
    920,
    921,
    922,
    923,
    924,
    925,
    926,
    927,
    928,
    929,
    931,
    932,
    933,
    934,
    935,
    936,
    937,
    945,
    946,
    947,
    948,
    949,
    950,
    951,
    952,
    953,
    954,
    955,
    956,
    957,
    958,
    959,
    960,
    961,
    962,
    963,
    964,
    965,
    966,
    967,
    968,
    969,
    977,
    978,
    982,
    8194,
    8195,
    8201,
    8204,
    8205,
    8206,
    8207,
    8211,
    8212,
    8216,
    8217,
    8218,
    8220,
    8221,
    8222,
    8224,
    8225,
    8226,
    8230,
    8240,
    8242,
    8243,
    8249,
    8250,
    8254,
    8260,
    8364,
    8465,
    8472,
    8476,
    8482,
    8501,
    8592,
    8593,
    8594,
    8595,
    8596,
    8629,
    8656,
    8657,
    8658,
    8659,
    8660,
    8704,
    8706,
    8707,
    8709,
    8711,
    8712,
    8713,
    8715,
    8719,
    8721,
    8722,
    8727,
    8730,
    8733,
    8734,
    8736,
    8743,
    8744,
    8745,
    8746,
    8747,
    8756,
    8764,
    8773,
    8776,
    8800,
    8801,
    8804,
    8805,
    8834,
    8835,
    8836,
    8838,
    8839,
    8853,
    8855,
    8869,
    8901,
    8968,
    8969,
    8970,
    8971,
    9001,
    9002,
    9674,
    9824,
    9827,
    9829,
    9830 */
];

entities = [
    "lt",
    "gt",
    "apos",
    "quot",
    "amp"
    /*,
    "nbsp",
    "iexcl",
    "cent",
    "pound",
    "curren",
    "yen",
    "brvbar",
    "sect",
    "uml",
    "copy",
    "ordf",
    "laquo",
    "not",
    "shy",
    "reg",
    "macr",
    "deg",
    "plusmn",
    "sup2",
    "sup3",
    "acute",
    "micro",
    "para",
    "middot",
    "cedil",
    "sup1",
    "ordm",
    "raquo",
    "frac14",
    "frac12",
    "frac34",
    "iquest",
    "Agrave",
    "Aacute",
    "Acirc",
    "Atilde",
    "Auml",
    "Aring",
    "AElig",
    "Ccedil",
    "Egrave",
    "Eacute",
    "Ecirc",
    "Euml",
    "Igrave",
    "Iacute",
    "Icirc",
    "Iuml",
    "ETH",
    "Ntilde",
    "Ograve",
    "Oacute",
    "Ocirc",
    "Otilde",
    "Ouml",
    "times",
    "Oslash",
    "Ugrave",
    "Uacute",
    "Ucirc",
    "Uuml",
    "Yacute",
    "THORN",
    "szlig",
    "agrave",
    "aacute",
    "acirc",
    "atilde",
    "auml",
    "aring",
    "aelig",
    "ccedil",
    "egrave",
    "eacute",
    "ecirc",
    "euml",
    "igrave",
    "iacute",
    "icirc",
    "iuml",
    "eth",
    "ntilde",
    "ograve",
    "oacute",
    "ocirc",
    "otilde",
    "ouml",
    "divide",
    "oslash",
    "ugrave",
    "uacute",
    "ucirc",
    "uuml",
    "yacute",
    "thorn",
    "yuml",
    "OElig",
    "oelig",
    "Scaron",
    "scaron",
    "Yuml",
    "fnof",
    "circ",
    "tilde",
    "Alpha",
    "Beta",
    "Gamma",
    "Delta",
    "Epsilon",
    "Zeta",
    "Eta",
    "Theta",
    "Iota",
    "Kappa",
    "Lambda",
    "Mu",
    "Nu",
    "Xi",
    "Omicron",
    "Pi",
    "Rho",
    "Sigma",
    "Tau",
    "Upsilon",
    "Phi",
    "Chi",
    "Psi",
    "Omega",
    "alpha",
    "beta",
    "gamma",
    "delta",
    "epsilon",
    "zeta",
    "eta",
    "theta",
    "iota",
    "kappa",
    "lambda",
    "mu",
    "nu",
    "xi",
    "omicron",
    "pi",
    "rho",
    "sigmaf",
    "sigma",
    "tau",
    "upsilon",
    "phi",
    "chi",
    "psi",
    "omega",
    "thetasym",
    "upsih",
    "piv",
    "ensp",
    "emsp",
    "thinsp",
    "zwnj",
    "zwj",
    "lrm",
    "rlm",
    "ndash",
    "mdash",
    "lsquo",
    "rsquo",
    "sbquo",
    "ldquo",
    "rdquo",
    "bdquo",
    "dagger",
    "Dagger",
    "bull",
    "hellip",
    "permil",
    "prime",
    "Prime",
    "lsaquo",
    "rsaquo",
    "oline",
    "frasl",
    "euro",
    "image",
    "weierp",
    "real",
    "trade",
    "alefsym",
    "larr",
    "uarr",
    "rarr",
    "darr",
    "harr",
    "crarr",
    "lArr",
    "uArr",
    "rArr",
    "dArr",
    "hArr",
    "forall",
    "part",
    "exist",
    "empty",
    "nabla",
    "isin",
    "notin",
    "ni",
    "prod",
    "sum",
    "minus",
    "lowast",
    "radic",
    "prop",
    "infin",
    "ang",
    "and",
    "or",
    "cap",
    "cup",
    "int",
    "there4",
    "sim",
    "cong",
    "asymp",
    "ne",
    "equiv",
    "le",
    "ge",
    "sub",
    "sup",
    "nsub",
    "sube",
    "supe",
    "oplus",
    "otimes",
    "perp",
    "sdot",
    "lceil",
    "rceil",
    "lfloor",
    "rfloor",
    "lang",
    "rang",
    "loz",
    "spades",
    "clubs",
    "hearts",
    "diams"
    */
];

addContentThatCanContainEntities = function (textToAdd, xobj, isElement, putContentFunc) {
    var xt, xe, ts, tc, length, char, ind;

    if (typeof textToAdd === 'string') {
        ts = 0;
        tc = 0;
        length = textToAdd.length;
        while (true) {
            if (tc === length) {
                break;
            }
            char = textToAdd.charCodeAt(tc);
            if ((char >= 40 && char <= 59) ||
                (char >= 63 && char <= 126)) {
                tc++;
                continue;
            }
            if (char >= 32 && char <= 126 &&
                char !== 34 && char !== 38 && char !== 39 && char !== 60 && char !== 62) {
                tc++;
                continue;
            }
            if (char === 9 || char === 10 || char === 13) {
                if (isElement) {
                    tc++;
                    continue;
                }
            }
            if (char === 9 && !isElement) {
                tc++;
                continue;
            }
            if (char < 32) {
                if (ts !== tc) {
                    if (isElement) {
                        xt = new Ltxml.XText(textToAdd.substring(ts, tc));
                        xt.parent = xobj;
                    }
                    else {
                        xt = textToAdd.substring(ts, tc);
                    }
                    putContentFunc(xt);
                }
                xe = new Ltxml.XEntity("#x" + char.toString(16));
                xe.parent = xobj;
                putContentFunc(xe);
                tc++;
                ts = tc;
                continue;
            }
            ind = entityCodePoints.indexOf(char);
            if (ind === -1) {
                tc++;
                continue;
            }
            if (ts !== tc) {
                if (isElement) {
                    xt = new Ltxml.XText(textToAdd.substring(ts, tc));
                    xt.parent = xobj;
                }
                else {
                    xt = textToAdd.substring(ts, tc);
                }
                putContentFunc(xt);
            }
            xe = new Ltxml.XEntity(entities[ind]);
            xe.parent = xobj;
            putContentFunc(xe);
            tc++;
            ts = tc;
        }
        if (ts !== tc) {
            if (isElement) {
                xt = new Ltxml.XText(textToAdd.substring(ts, tc));
                xt.parent = xobj;
            }
            else {
                xt = textToAdd.substring(ts, tc);
            }
            putContentFunc(xt);
        }
        return;
    }
    if (isElement) {
        xt = new Ltxml.XText(textToAdd);
        xt.parent = xobj;
        putContentFunc(xt);
    }
    else {
        putContentFunc(textToAdd);
    }
    return;
};

/********************** XNamespace **********************/

// takes a string, returns an atomized object
Ltxml.XNamespace = function (namespace, prefix) {
    var namespaceCache, nso, ns;

    namespaceCache = Ltxml.namespaceCache;

    if (prefix === null) {
        prefix = undefined;
    }
    if (namespaceCache[namespace] === undefined) {
        nso = {
            namespaceName: namespace,
            preferredPrefix: null,
            getName: Ltxml.XNamespace.getName,
            toString: Ltxml.XNamespace.toString
        };
        namespaceCache[namespace] = nso;
        return nso;
    }
    ns = namespaceCache[namespace];
    return ns;
};

Ltxml.XNamespace.getName = function (name) {
    return new Ltxml.XName(this.namespaceName, name);
};

Ltxml.XNamespace.toString = function () {
    if (this === Ltxml.XNamespace.getNone()) {
        return "";
    }
    return "{" + this.namespaceName + "}";
};

Ltxml.XNamespace.getNone = function () {
    var namespaceCache, namespace, nso;

    namespaceCache = Ltxml.namespaceCache;
    namespace = '__none';
    if (namespaceCache[namespace] === undefined) {
        nso = {
            namespaceName: namespace,
            preferredPrefix: null,
            getName: Ltxml.XNamespace.getName,
            toString: Ltxml.XNamespace.toString
        };
        namespaceCache[namespace] = nso;
        return nso;
    }
    return namespaceCache[namespace];
};

Ltxml.XNamespace.get = function (uri) {
    return new Ltxml.XNamespace(uri);
};

Ltxml.XNamespace.getXml = function () {
    return new Ltxml.XNamespace("http://www.w3.org/XML/1998/namespace", "xml");
};

Ltxml.XNamespace.getXmlns = function () {
    return new Ltxml.XNamespace("http://www.w3.org/2000/xmlns/", "xmlns");
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XNamespace, "none", {
        get: function () {
            return Ltxml.XNamespace.getNone();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XNamespace, "xml", {
        get: function () {
            return Ltxml.XNamespace.getXml();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XNamespace, "xmlns", {
        get: function () {
            return Ltxml.XNamespace.getXmlns();
        },
        enumerable: true,
        configurable: true
    });

}

/********************** XName **********************/

// for namespace, takes either a string or an atomized XNamespace object.
// for name, takes a string
Ltxml.XName = function (arg1, arg2) {
    var nameCache, expandedNamespaceObject, expandedNamespaceQName,
        namespaceOfExpandedName, noNamespaceObject, noNamespaceQName,
        noNamespaceNameObject, namespaceObject, namespaceQName,
        namespaceNameObject, indexOfClosingBrace;

    nameCache = Ltxml.nameCache;

    if (typeof arg1 === 'string' && arg2 === undefined && arg1.charAt(0) === '{') {
        indexOfClosingBrace = arg1.indexOf('}');
        namespaceOfExpandedName = arg1.substring(1, indexOfClosingBrace);
        expandedNamespaceObject = new Ltxml.XNamespace(namespaceOfExpandedName);
        arg2 = arg1.substring(indexOfClosingBrace + 1);
        expandedNamespaceQName = "{" + namespaceOfExpandedName + "}" + arg2;
        if (nameCache[expandedNamespaceQName] === undefined) {
            nameCache[expandedNamespaceQName] = {
                namespace: expandedNamespaceObject,
                namespaceName: namespaceOfExpandedName,
                localName: arg2,
                toString: Ltxml.XName.toString
            };
            return nameCache[expandedNamespaceQName];
        }
        return nameCache[expandedNamespaceQName];
    }

    if (typeof arg1 === 'string' && arg2 === undefined) {
        noNamespaceObject = Ltxml.XNamespace.getNone();
        noNamespaceQName = "{" + noNamespaceObject.namespaceName + "}" + arg1;
        if (nameCache[noNamespaceQName] === undefined) {
            noNamespaceNameObject = {
                namespace: noNamespaceObject,
                namespaceName: '',
                localName: arg1,
                toString: Ltxml.XName.toString
            };
            nameCache[noNamespaceQName] = noNamespaceNameObject;
            return noNamespaceNameObject;
        }
        return nameCache[noNamespaceQName];
    }

    namespaceObject = arg1;
    if (typeof arg1 !== 'object') {
        namespaceObject = Ltxml.XNamespace(arg1);
    }
    namespaceQName = "{" + namespaceObject.namespaceName + "}" + arg2;
    if (nameCache[namespaceQName] === undefined) {
        namespaceNameObject = {
            namespace: namespaceObject,
            namespaceName: namespaceObject.namespaceName,
            localName: arg2,
            toString: Ltxml.XName.toString
        };
        nameCache[namespaceQName] = namespaceNameObject;
        return namespaceNameObject;
    }
    return nameCache[namespaceQName];
};

Ltxml.XName.toString = function () {
    return this.namespace + this.localName;
};

Ltxml.XName.qualify = function (xname, element, isAttribute) {
    if (xname.namespace === Ltxml.XNamespace.getNone()) {
        return xname.localName;
    }
    var prefix = element.getPrefixOfNamespace(xname.namespace, isAttribute);
    if (prefix === '') {
        return xname.localName;
    }
    return prefix + ":" + xname.localName;
};

Ltxml.XName.get = function (arg1, arg2) {
    var xn;

    if (typeof arg1 === 'string' && arg2 === undefined) {
        xn = new Ltxml.XName(arg1);
        return xn;
    }
    if ((typeof arg1 === 'string' || arg1.namespaceName) &&
            typeof arg2 === 'string') {
        xn = new Ltxml.XName(arg1, arg2);
        return xn;
    }
    throw 'XName.get: invalid arguments';
};

/********************** XObject **********************/

Ltxml.XObject = function () { };

Ltxml.XObject.prototype.addAnnotation = function (type, object) {
    if (!object) {
        object = {};
    }
    this.annotationsArray.push({
        Type: type,
        Object: object
    });
};

Ltxml.XObject.prototype.annotation = function (type) {
    var i;

    for (i = 0; i < this.annotationsArray.length; i += 1) {
        if (this.annotationsArray[i].Type === type) {
            return this.annotationsArray[i].Object;
        }
    }
    return null;
};

Ltxml.XObject.prototype.annotations = function (type) {
    var retVal, i;

    retVal = [];
    for (i = 0; i < this.annotationsArray.length; i += 1) {
        if (type === undefined || this.annotationsArray[i].Type === type) {
            retVal.push(this.annotationsArray[i].Object);
        }
    }
    return Enumerable.from(retVal);
};

Ltxml.XObject.prototype.removeAnnotations = function (type) {
    var j;

    if (type === undefined) {
        this.annotationsArray = [];
    } else {
        while (true) {
            for (j = 0; j < this.annotationsArray.length; j += 1) {
                if (this.annotationsArray[j].Type === type) {
                    break;
                }
            }
            if (j === this.annotationsArray.length) {
                break;
            }
            this.annotationsArray.splice(j, 1);
        }
    }
};

Ltxml.XObject.prototype.getDocument = function () {
    var current = this;

    while (true) {
        if (current.nodeType === 'Document') {
            return current;
        }
        current = current.parent;
        if (current === null) {
            return null;
        }
    }
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XObject.prototype, "document", {
        get: function () {
            return this.getDocument();
        },
        enumerable: true,
        configurable: true
    });

}

/********************** XNode: XObject **********************/

Ltxml.XNode = function () { };

Ltxml.XNode.prototype = new Ltxml.XObject();

Ltxml.XNode.prototype.addAfterSelf = function () {
    var indexOfSelf, args, contentToInsert, newContent, i, z;

    args = [];
    newContent = [];

    if (this.parent === null) {
        throw "addAfterSelf: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    contentToInsert = [];
    addContent(this,
        function (c) { contentToInsert.push(c); },
        function () { throw "addAfterSelf: invalid content"; },
        args);
    newContent = this.parent.nodesArray.slice(0, indexOfSelf + 1)
        .concat(contentToInsert)
        .concat(this.parent.nodesArray.slice(indexOfSelf + 1));
    for (z = 0; z < newContent.length; z += 1) {
        newContent[z].parent = this.parent;
    }
    this.parent.nodesArray = newContent;
};

Ltxml.XNode.prototype.addBeforeSelf = function () {
    var indexOfSelf, args, contentToInsert, newContent, i, z;

    args = [];
    contentToInsert = [];
    newContent = [];

    if (this.parent === null) {
        throw "addBeforeSelf: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    contentToInsert = [];
    addContent(this,
        function (c) { contentToInsert.push(c); },
        function () { throw "addBeforeSelf: invalid content"; },
        args);
    newContent = this.parent.nodesArray.slice(0, indexOfSelf)
        .concat(contentToInsert)
        .concat(this.parent.nodesArray.slice(indexOfSelf));
    for (z = 0; z < newContent.length; z += 1) {
        newContent[z].parent = this.parent;
    }
    this.parent.nodesArray = newContent;
};

Ltxml.XNode.prototype.CompareDocumentOrder = function () {
    throw "Not implemented";
};

Ltxml.XNode.prototype.deepEquals = function (other) {
    var atts1, atts2, nodes1, nodes2;

    if (this.nodeType !== other.nodeType) {
        return false;
    }
    if (this.nodeType === 'Element' && this.name !== other.name) {
        return false;
    }
    if (this.nodeType === 'Comment' ||
            this.nodeType === 'Text' ||
            this.nodeType === 'CData' ||
            this.nodeType === 'ProcessingInstruction' ||
            this.nodeType === 'Entity') {
        return this.value === other.value;
    }
    if (this.attributesArray.length !== other.attributesArray.length) {
        return false;
    }

    if (this.attributesArray.length !== 0) {
        atts1 = Enumerable
            .from(this.attributesArray)
            .where(function (a) {
                return !a.isNamespaceDeclaration;
            })
            .orderBy("k=>k.name");
        atts2 = Enumerable
            .from(other.attributesArray)
            .where(function (a) {
                return !a.isNamespaceDeclaration;
            })
            .orderBy("k=>k.name");
        // in following lambda, return true if any do NOT match
        if (atts1.zip(atts2, function (a, b) {
            return {
            att1: a,
            att2: b
        };
        })
            .any(function (p) {
                if (p.att1.name !== p.att2.name) {
                    return true;
        }
                if (p.att1.value !== p.att2.value) {
                    return true;
        }
                return false;
        })) {
            return false;
        }
    }
    if (this.nodesArray.length !== other.nodesArray.length) {
        return false;
    }
    if (this.nodesArray.length === 0 && other.nodesArray.length === 0) {
        return true;
    }
    nodes1 = Enumerable.from(this.nodesArray);
    nodes2 = Enumerable.from(other.nodesArray);
    if (nodes1
        .zip(nodes2, function (a, b) {
            return {
        node1: a,
        node2: b
    };
    })
        .any(function (z) { return !z.node1.deepEquals(z.node2); })) {
        return false;
    }
    return true;
};

Ltxml.XNode.prototype.isAfter = function () {
    throw "Not implemented";
};

Ltxml.XNode.prototype.isBefore = function () {
    throw "Not implemented";
};

Ltxml.XNode.prototype.getNextNode = function () {
    var indexOfSelf;

    if (this.parent === null) {
        throw "getNextNode: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    if (indexOfSelf < this.parent.nodesArray.length - 2) {
        return this.parent.nodesArray[indexOfSelf + 1];
    }
    return null;
};

Ltxml.XNode.prototype.remove = function () {
    var indexOfSelf, newContent;

    if (this.parent === null) {
        throw "remove: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    newContent = this.parent
        .nodesArray
        .slice(0, indexOfSelf)
        .concat(this.parent.nodesArray.slice(indexOfSelf + 1));
    this.parent.nodesArray = newContent;
};

Ltxml.XNode.prototype.replaceWith = function () {
    var indexOfSelf, newContent, args, contentToInsert, i, z;

    args = [];
    contentToInsert = [];
    if (this.parent === null) {
        throw "replaceWith: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    contentToInsert = [];
    addContent(this,
        function (c) { contentToInsert.push(c); },
        function () { throw "replaceWith: invalid content"; },
        args);
    newContent = this.parent
        .nodesArray
        .slice(0, indexOfSelf)
        .concat(contentToInsert)
        .concat(this.parent.nodesArray.slice(indexOfSelf + 1));
    for (z = 0; z < newContent.length; z += 1) {
        newContent[z].parent = this.parent;
    }
    this.parent.nodesArray = newContent;
};

Ltxml.XNode.prototype.getPreviousNode = function () {
    var indexOfSelf;

    if (this.parent === null) {
        throw "previousNode: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    if (indexOfSelf > 0) {
        return this.parent.nodesArray[indexOfSelf - 1];
    }
    return null;
};

// xname optional
Ltxml.XNode.prototype.ancestors = function (xname) {
    var self, result, current;

    self = this;

    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var current;

            return Enumerable.Utils.createEnumerator(
                function () {
                    current = self.parent;
                },  // initialize
                function () { // tryGetNext
                    while (current !== null) {
                        if (xname && current.name !== xname) {
                            current = current.parent;
                        } else {
                            var thisOne = current;
                            current = current.parent;
                            return this.yieldReturn(thisOne);
                        }
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    result = [];
    current = this.parent;
    if (xname === undefined) {
        while (current !== null) {
            result.push(current);
            current = current.parent;
        }
        return Enumerable.from(result);
    }
    while (current !== null) {
        if (current.name === xname) {
            result.push(current);
        }
        current = current.parent;
    }
    return Enumerable.from(result);
};

Ltxml.XNode.prototype.nodesAfterSelf = function () {
    var indexOfSelf, returnValue, self;

    self = this;
    if (this.parent === null) {
        throw "nodesAfterSelf: no parent element";
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var i, length, parent;

            return Enumerable.Utils.createEnumerator(
                function () {
                    parent = self.parent;
                    i = parent.nodesArray.indexOf(self) + 1;
                    length = parent.nodesArray.length;
                },  // initialize
                function () { // tryGetNext
                    var n;

                    while (i < length) {
                        n = parent.nodesArray[i];
                        i += 1;
                        return this.yieldReturn(n);  //ignore jslint
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    returnValue = Enumerable
        .from(this.parent.nodesArray.slice(indexOfSelf + 1));
    return returnValue;
};

Ltxml.XNode.prototype.nodesBeforeSelf = function () {
    var indexOfSelf, returnValue, self;

    self = this;
    if (this.parent === null) {
        throw "nodesBeforeSelf: no parent element";
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var parent, i, selfIndex;

            return Enumerable.Utils.createEnumerator(
                function () {
                    parent = self.parent;
                    i = 0;
                    selfIndex = parent.nodesArray.indexOf(self);
                },  // initialize
                function () { // tryGetNext
                    var n;

                    while (i < selfIndex) {
                        n = parent.nodesArray[i];
                        i += 1;
                        return this.yieldReturn(n);  //ignore jslint
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    if (this.parent === null) {
        throw "nodesBeforeSelf: no parent element";
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    returnValue = Enumerable
        .from(this.parent.nodesArray.slice(0, indexOfSelf));
    return returnValue;
};

// xname optional
Ltxml.XNode.prototype.elementsAfterSelf = function (xname) {
    var indexOfSelf, returnValue, self;

    self = this;
    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    if (this.parent === null) {
        throw "elementsAfterSelf: no parent element";
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var i, length, parent;

            return Enumerable.Utils.createEnumerator(
                function () {
                    parent = self.parent;
                    i = parent.nodesArray.indexOf(self) + 1;
                    length = parent.nodesArray.length;
                },  // initialize
                function () { // tryGetNext
                    while (i < length) {
                        var n = parent.nodesArray[i];
                        if (n.nodeType !== 'Element' || (xname && n.name !== xname)) {
                            i += 1;
                        }
                        else {
                            i += 1;
                            return this.yieldReturn(n);
                        }
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }

    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    returnValue = Enumerable
        .from(this.parent.nodesArray.slice(indexOfSelf + 1))
        .where(function (e) { return e.nodeType === 'Element'; });
    if (xname) {
        returnValue = returnValue.where(function (e) { return e.name === xname; });
    }
    return returnValue;
};

// xname is optional
Ltxml.XNode.prototype.elementsBeforeSelf = function (xname) {
    var indexOfSelf, returnValue, self;

    self = this;
    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    if (this.parent === null) {
        throw "elementsBeforeSelf: no parent element";
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var parent, i, selfIndex;

            return Enumerable.Utils.createEnumerator(
                function () {
                    parent = self.parent;
                    i = 0;
                    selfIndex = parent.nodesArray.indexOf(self);
                },  // initialize
                function () { // tryGetNext
                    var n;

                    while (i < selfIndex) {
                        n = parent.nodesArray[i];
                        if (n.nodeType !== 'Element' || (xname && n.name !== xname)) {
                            i += 1;
                        }
                        else {
                            i += 1;
                            return this.yieldReturn(n);
                        }
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    returnValue = Enumerable
        .from(this.parent.nodesArray.slice(0, indexOfSelf))
        .where(function (e) { return e.nodeType === 'Element'; });
    if (xname) {
        returnValue = returnValue.where(function (e) { return e.name === xname; });
    }
    return returnValue;
};

// xname is optional
Ltxml.XNode.prototype.elementsBeforeSelfReverseDocumentOrder = function (xname) {
    var indexOfSelf, returnValue, self;

    self = this;
    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    if (this.parent === null) {
        throw "elementsBeforeSelfReverseDocumentOrder: no parent element";
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var parent, i;

            return Enumerable.Utils.createEnumerator(
                function () {
                    parent = self.parent;
                    i = parent.nodesArray.indexOf(self) - 1;
                },  // initialize
                function () { // tryGetNext
                    while (i >= 0) {
                        var n = parent.nodesArray[i];
                        if (n.nodeType !== 'Element' || (xname && n.name !== xname)) {
                            i -= 1;
                        }
                        else {
                            i -= 1;
                            return this.yieldReturn(n);
                        }
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    indexOfSelf = this.parent.nodesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    returnValue = Enumerable
        .from(this.parent.nodesArray.slice(0, indexOfSelf))
        .where(function (e) { return e.nodeType === 'Element'; })
        .reverse();
    if (xname) {
        returnValue = returnValue.where(function (e) { return e.name === xname; });
    }
    return returnValue;
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XNode.prototype, "previousNode", {
        get: function () {
            return this.getPreviousNode();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XNode.prototype, "nextNode", {
        get: function () {
            return this.getNextNode();
        },
        enumerable: true,
        configurable: true
    });

}

/********************** XAttribute: XObject **********************/

Ltxml.XAttribute = function (arg1, arg2) {
    var xnameObj, attContent, i, xmlns;

    this.nodeType = 'Attribute';
    this.simpleValue = null;
    this.attributeNodesArray = null;
    this.isNamespaceDeclaration = false;
    this.name = null;

    if (Object.defineProperties) {

        Object.defineProperty(this, "value", {
            get: Ltxml.XAttribute.prototype.getValue,
            set: Ltxml.XAttribute.prototype.setValue,
            enumerable: true,
            configurable: true
        });

    }

    if (arg1.nodeType && arg1.nodeType === 'Attribute') {
        if (arg2 !== undefined) {
            throw "XAttribute constructor: invalid arguments";
        }
        this.isNamespaceDeclaration = arg1.isNamespaceDeclaration;
        if (arg1.simpleValue !== null && arg1.simpleValue !== undefined) {
            this.simpleValue = arg1.simpleValue;
        }
        else {
            attContent = [];
            for (i = 0; i < arg1.attributeNodesArray.length; i += 1) {
                attContent.push(arg1.attributeNodesArray[i]);
            }
            this.attributeNodesArray = attContent;
        }
        this.name = arg1.name;
        return;
    }

    if (arg2 === undefined) {
        throw "XAttribute constructor: invalid arguments";
    }

    // external properties
    if (arg2.namespaceName) {
        this.attributeNodesArray = [arg2.namespaceName];
    }
    else {
        attContent = [];
        addContentThatCanContainEntities(arg2.toString(), this, false, function (c) {
            attContent.push(c);
        });
        if (attContent.length === 1) {
            this.simpleValue = attContent[0];
        }
        else {
            this.attributeNodesArray = attContent;
        }
    }

    // constructor
    xnameObj = arg1;
    xmlns = Ltxml.XNamespace.getXmlns();
    if (typeof arg1 === 'string') {
        if (arg1 === "xmlns") {
            xnameObj = new Ltxml.XName(xmlns + "xmlns");
        }
        else {
            xnameObj = new Ltxml.XName(arg1);
        }
    }
    this.isNamespaceDeclaration = xnameObj.namespace === xmlns;
    this.name = xnameObj;
};

Ltxml.XAttribute.prototype = new Ltxml.XObject();

serializeAttributeContent = function (a, o) {
    var na, i;

    if (a.simpleValue !== null && a.simpleValue !== undefined) {
        o.a(a.simpleValue);
    }
    else {
        na = a.attributeNodesArray;
        for (i = 0; i < na.length; i += 1) {
            if (na[i].nodeType) {
                na[i].serialize(o);
            }
            else {
                o.a(na[i]);
            }
        }
    }
};

Ltxml.XAttribute.prototype.serialize = function (o) {
    if (this.name.namespace === Ltxml.XNamespace.getXmlns()) {
        if (this.name.localName === 'xmlns') {
            o.a("xmlns='");
            serializeAttributeContent(this, o);
            o.a("'");
            return;
        }
        o.a("xmlns:").a(this.name.localName).a("='");
        serializeAttributeContent(this, o);
        o.a("'");
        return;
    }
    if (this.name.namespace === Ltxml.XNamespace.getNone()) {
        o.a(this.name.localName).a("='");
        serializeAttributeContent(this, o);
        o.a("'");
        return;
    }
    if (this.name.namespace === Ltxml.XNamespace.getXml()) {
        if (typeof this.value === "string") {
            o.a("xml:")
                .a(this.name.localName)
                .a("='");
            serializeAttributeContent(this, o);
            o.a("'");
        }
        else {
            o.a("xml:")
                .a(this.name.localName)
                .a("='");
            serializeAttributeContent(this, o);
            o.a("'");
        }
        return;
    }
    o.a(Ltxml.XName.qualify(this.name, this.parent, true)).a("='");
    serializeAttributeContent(this, o);
    o.a("'");
    return;
};

Ltxml.XAttribute.prototype.toString = function () {
    var o = getStringBuilder();
    this.serialize(o);
    return o.toString();
};

Ltxml.XAttribute.prototype.remove = function () {
    var indexOfSelf, newAtts;

    newAtts = [];
    if (this.parent === null) {
        throw "XAttribute.remove: no parent element";
    }
    indexOfSelf = this.parent.attributesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    newAtts = this.parent
        .attributesArray
        .slice(0, indexOfSelf)
        .concat(this.parent.attributesArray.slice(indexOfSelf + 1));
    this.parent.attributesArray = newAtts;
};

Ltxml.XAttribute.prototype.setValue = function (value) {
    var newContent = [];
    addContentThatCanContainEntities(value.toString(), this, false, function (a) {
        newContent.push(a);
    });
    if (newContent.length === 1) {
        this.simpleValue = newContent[0];
    }
    else {
        this.attributeNodesArray = newContent;
    }
};

Ltxml.XAttribute.prototype.getValue = function () {
    var o, s;

    o = getStringBuilder();
    serializeAttributeContent(this, o);
    s = o.toString();
    return s;
};

Ltxml.XAttribute.prototype.getNextAttribute = function () {
    var indexOfSelf;

    if (this.parent === null) {
        throw "getNextAttribute: no parent element";
    }
    indexOfSelf = this.parent.attributesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    if (indexOfSelf < this.parent.attributesArray.length - 2) {
        return this.parent.attributesArray[indexOfSelf + 1];
    }
    return null;
};

Ltxml.XAttribute.prototype.getPreviousAttribute = function () {
    var indexOfSelf;

    if (!this.parent) {
        throw "getPreviousAttribute: no parent element";
    }
    indexOfSelf = this.parent.attributesArray.indexOf(this);
    if (indexOfSelf === -1) {
        throw "Internal Error";
    }
    if (indexOfSelf > 0) {
        return this.parent.attributesArray[indexOfSelf - 1];
    }
    return null;
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XAttribute.prototype, "previousAttribute", {
        get: function () {
            return this.getPreviousAttribute();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XAttribute.prototype, "nextAttribute", {
        get: function () {
            return this.getNextAttribute();
        },
        enumerable: true,
        configurable: true
    });

}

/********************** XComment: XNode **********************/

Ltxml.XComment = function (arg1) {
    this.nodeType = 'Comment';
    this.parent = null;

    if (arg1.nodeType && arg1.nodeType === 'Comment') {
        // copy constructor
        this.value = arg1.value.toString();
    }
    else {
        this.value = arg1.toString();
    }
};

Ltxml.XComment.prototype = new Ltxml.XNode();

Ltxml.XComment.prototype.serialize = function (o, indent, depth) {
    var indent_spaces;

    if (!depth) {
        depth = 0;
    }
    if (indent) {
        indent_spaces = Ltxml.spaces.substring(0, depth);
        o.a(indent_spaces).a("<!--").a(this.value).a("-->\n");
        return;
    }
    o.a('<!--').a(this.value).a('-->');
    return;
};

Ltxml.XComment.prototype.toString = function (indent) {
    var o = getStringBuilder();
    this.serialize(o, indent);
    return o.toString();
};

/********************** XContainer: XNode **********************/

Ltxml.XContainer = function () { };

Ltxml.XContainer.prototype = new Ltxml.XNode();

Ltxml.XContainer.prototype.add = function () {
    var nodesToInsert, attributesToInsert, args, i, newNodes, newAttributes;

    nodesToInsert = [];
    attributesToInsert = [];
    args = [];

    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    nodesToInsert = [];
    addContent(this,
        function (c) { nodesToInsert.push(c); },
        function (a) { attributesToInsert.push(a); },
        args);
    newNodes = this.nodesArray.concat(nodesToInsert);
    newAttributes = this.attributesArray.concat(attributesToInsert);
    this.nodesArray = newNodes;
    this.attributesArray = newAttributes;
};

Ltxml.XContainer.prototype.addFirst = function () {
    var nodesToInsert, attributesToInsert, args, i, newNodes, newAttributes;

    nodesToInsert = [];
    attributesToInsert = [];
    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    nodesToInsert = [];
    addContent(this,
        function (c) { nodesToInsert.push(c); },
        function (a) { attributesToInsert.push(a); },
        args);
    newNodes = nodesToInsert.concat(this.nodesArray);
    newAttributes = this.attributesArray.concat(attributesToInsert);
    this.nodesArray = newNodes;
    this.attributesArray = newAttributes;
};

Ltxml.XContainer.prototype.element = function (name) {
    var i, length;

    if (typeof name === 'string') {
        name = new Ltxml.XName(name);
    }
    length = this.nodesArray.length;
    for (i = 0; i < length; i += 1) {
        if (this.nodesArray[i].name === name) {
            return this.nodesArray[i];
        }
    }
    return null;
};

Ltxml.XContainer.prototype.nodes = function () {
    return Enumerable.from(this.nodesArray);
};

Ltxml.XContainer.prototype.removeNodes = function () {
    this.nodesArray = [];
};

Ltxml.XContainer.prototype.replaceNodes = function () {
    var nodesToInsert, attributesToInsert, args, i, newAttributes;

    nodesToInsert = [];
    attributesToInsert = [];
    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    addContent(this,
        function (c) { nodesToInsert.push(c); },
        function (a) { attributesToInsert.push(a); },
        args);
    newAttributes = this.attributesArray.concat(attributesToInsert);
    this.nodesArray = nodesToInsert;
    this.attributesArray = newAttributes;
};

Ltxml.XContainer.prototype.getFirstNode = function () {
    if (this.nodesArray.length >= 1) {
        return this.nodesArray[0];
    }
    return null;
};

Ltxml.XContainer.prototype.getLastNode = function () {
    if (this.nodesArray.length >= 1) {
        return this.nodesArray[this.nodesArray.length - 1];
    }
    return null;
};

function descendantNodesHelper(element, pushFunc) {
    var i;

    for (i = 0; i < element.nodesArray.length; i += 1) {
        pushFunc(element.nodesArray[i]);
        if (element.nodesArray[i].nodeType === 'Element') {
            descendantNodesHelper(element.nodesArray[i], pushFunc);
        }
    }
}

Ltxml.XContainer.prototype.descendantNodes = function () {
    var result, returnValue;

    if (this.lazy) {
        returnValue = Enumerable
            .from(this.nodesArray)
            .traverseDepthFirst(function (node) {
                return Enumerable.from(node.nodesArray);
            });
        return returnValue;
    }
    result = [];
    descendantNodesHelper(this, function (e) { result.push(e); });
    return Enumerable.from(result);
};

function lazyDescendantHelper(container, xname) {
    var returnValue = Enumerable
        .from(container.nodesArray)
        .traverseDepthFirst(function (node) {
            return Enumerable.from(node.nodesArray).where(function (node) {
                return node.nodeType === 'Element';
            });
        })
        .where(function (node) { return node.nodeType === 'Element'; });
    if (xname) {
        returnValue = returnValue.where(function (e) { return e.name === xname; });
    }
    return returnValue;
}

function eagarDescendantHelper(container, xname, pushFunc) {
    var i;

    for (i = 0; i < container.nodesArray.length; i += 1) {
        if (container.nodesArray[i].nodeType === 'Element') {
            if (xname === undefined) {
                pushFunc(container.nodesArray[i]);
                eagarDescendantHelper(container.nodesArray[i], xname, pushFunc);
            }
            else {
                if (container.nodesArray[i].name === xname) {
                    pushFunc(container.nodesArray[i]);
                }
                eagarDescendantHelper(container.nodesArray[i], xname, pushFunc);
            }
        }
    }
}

// xname optional
Ltxml.XContainer.prototype.descendants = function (xname) {
    var result;

    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    if (this.lazy) {
        return lazyDescendantHelper(this, xname);
    }
    result = [];
    eagarDescendantHelper(this, xname, function (e) { result.push(e); });
    return Enumerable.from(result);
};

// xname optional
Ltxml.XContainer.prototype.elements = function (xname) {
    var returnValue, self;

    self = this;
    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var i, length;

            return Enumerable.Utils.createEnumerator(
                function () {
                    i = 0;
                    length = self.nodesArray.length;
                },  // initialize
                function () { // tryGetNext
                    while (i < length) {
                        var n = self.nodesArray[i];
                        if (n.nodeType !== 'Element' || (xname && n.name !== xname)) {
                            i += 1;
                        }
                        else {
                            i += 1;
                            return this.yieldReturn(n);
                        }
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    if (xname) {
        returnValue = Enumerable
            .from(this.nodesArray)
            .where(function (e) { return e.nodeType === 'Element' && e.name === xname; });
    }
    else {
        returnValue = Enumerable
            .from(this.nodesArray)
            .where(function (e) { return e.nodeType === 'Element'; });
    }
    return returnValue;
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XContainer.prototype, "firstNode", {
        get: function () {
            return this.getFirstNode();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XContainer.prototype, "lastNode", {
        get: function () {
            return this.getLastNode();
        },
        enumerable: true,
        configurable: true
    });

}

/*********************** XDeclaration ***********************/

//new XDeclaration(version, encoding, standalone)
//new XDeclaration(xdeclaration)
Ltxml.XDeclaration = function (arg1, arg2, arg3) {
    if (arg1 && typeof arg1 === 'object' && arguments.length === 1) {
        this.type = 'XDeclaration';
        this.encoding = arg1.encoding ? arg1.encoding : ''; //ignore jslint
        this.standalone = arg1.standalone ? arg1.standalone : ''; //ignore jslint
        this.version = arg1.version ? arg1.version : ''; //ignore jslint
        return;
    }
    if (arguments.length === 3) {
        this.type = 'XDeclaration';
        this.version = arg1;
        this.encoding = arg2;
        this.standalone = arg3;
        return;
    }
    this.type = 'XDeclaration';
    this.version = '';
    this.encoding = '';
    this.standalone = '';
};

Ltxml.XDeclaration.prototype.serialize = function (o, indent) {
    if (this.version || this.encoding || this.standalone) {
        if (indent) {
            o.a("<?xml");
            if (this.version) {
                o.a(" version=\"").a(this.version).a("\"");
            }
            if (this.encoding) {
                o.a(" encoding=\"").a(this.encoding).a("\"");
            }
            if (this.standalone) {
                o.a(" standalone=\"").a(this.standalone).a("\"");
            }
            o.a("?>\n");
            return;
        }
        o.a("<?xml");
        if (this.version) {
            o.a(" version=\"").a(this.version).a("\"");
        }
        if (this.encoding) {
            o.a(" encoding=\"").a(this.encoding).a("\"");
        }
        if (this.standalone) {
            o.a(" standalone=\"").a(this.standalone).a("\"");
        }
        o.a("?>");
        return;
    }
    return;
};

Ltxml.XDeclaration.prototype.toString = function (indent) {
    var o = getStringBuilder();
    this.serialize(o, indent);
    return o.toString();
};

/********************** XDocument: XContainer **********************/

//new XDocument()
//new XDocument(content)
//new XDocument(xdocument)
//new XDocument(xdeclaration, content)
Ltxml.XDocument = function (arg1) {
    var tempNodes, tempNodes2, start, args, i;

    this.annotationsArray = [];
    this.parent = null;
    this.nodeType = 'Document';
    this.nodesArray = [];
    this.declaration = new Ltxml.XDeclaration();

    if (typeof arg1 === 'object' && arg1.nodeType && arg1.nodeType === 'Document') {
        if (arguments.length > 1) {
            throw "XDocument constructor: invalid arguments";
        }
        tempNodes = [];
        if (arg1.declaration !== null) {
            this.declaration = new Ltxml.XDeclaration(arg1.declaration);
        }
        addContent(this,
                    function (z) { tempNodes.push(z); },
                    function () { throw "Internal Error"; },
                    arg1.nodesArray);
        this.nodesArray = tempNodes;
        return;
    }

    if (arguments.length > 0) {
        if (typeof arg1 === 'object' && arg1.type && arg1.type === 'XDeclaration') {
            start = 1;
            this.declaration = arg1;
        }
        else {
            start = 0;
        }
        args = [];
        for (i = start; i < arguments.length; i += 1) {
            args.push(arguments[i]);
        }
        tempNodes2 = [];
        addContent(this,
                        function (z) { tempNodes2.push(z); },
                        function () { throw "Internal Error"; },
                        args);
        this.nodesArray = tempNodes2;
    }
};

Ltxml.XDocument.prototype = new Ltxml.XContainer();

Ltxml.XDocument.prototype.serialize = function (o, indent) {
    var i;

    if (indent) {
        this.declaration.serialize(o, true);
        for (i = 0; i < this.nodesArray.length; i += 1) {
            this.nodesArray[i].serialize(o, true);
        }
        return;
    }
    this.declaration.serialize(o, false);
    for (i = 0; i < this.nodesArray.length; i += 1) {
        this.nodesArray[i].serialize(o, false);
    }
    return;
};

Ltxml.XDocument.prototype.toString = function (indent) {
    var clone, o, newRoot;

    o = getStringBuilder();
    clone = new Ltxml.XDocument(this.declaration,
        this.nodes().select(function (n) {
            if (n.nodeType === 'Element') {
                newRoot = new Ltxml.XElement(n);
                annotateRootForNamespaces(newRoot);
                return newRoot;
            }
            return n;
        }));

    clone.serialize(o, indent);
    return o.toString();
};

Ltxml.XDocument.parse = function (xml) {
    var xmlDoc, e;

    xmlDoc = parseXml(xml);
    e = Ltxml.XDocument.load(xmlDoc);
    return e;
};

Ltxml.XDocument.prototype.DocumentType = function () {
    throw "Not implemented";
};

function xmlNodeLoad(node, depth) {
    var ns, xn, aa, aa2, cn, cn2, el, at, doc,
        xcd, xcm, pi, xdec, cnt1, cnt2, cnt3, tn, newAtt,
        cn_doc, cnt4, nc, version, encoding, standalone;

    if (node.nodeType) {
        if (node.nodeType === 1) {
            if (node.namespaceURI === null ||
                node.namespaceURI === undefined ||
                (node.namespaceURI === "" && node.nodeName !== "xmlns")) {
                ns = Ltxml.XNamespace.getNone();
            }
            else {
                ns = new Ltxml.XNamespace(
                    node.namespaceURI,
                    node.prefix && node.prefix !== "" ?
                        node.prefix.toString() :
                        null);
            }
            if (node.localName) {
                xn = new Ltxml.XName(ns, node.localName);
            }
            else {
                xn = new Ltxml.XName(ns, node.baseName);
            }

            aa = node.attributes;
            cn = node.childNodes;

            if (aa !== null && aa !== undefined && aa.length > 0) {
                cn2 = [];
                for (cnt1 = 0; cnt1 < cn.length; cnt1 += 1) {
                    tn = xmlNodeLoad(cn[cnt1], depth + 1);
                    cn2.push(tn);
                }
                aa2 = [];
                for (cnt2 = 0; cnt2 < aa.length; cnt2 += 1) {
                    newAtt = xmlNodeLoad(aa[cnt2], depth + 1);
                    aa2.push(newAtt);
                }
                el = new Ltxml.XElement(xn, aa2, cn2);
            }
            else {
                cn2 = [];
                for (cnt3 = 0; cnt3 < cn.length; cnt3 += 1) {
                    cn2.push(xmlNodeLoad(cn[cnt3], depth + 1));
                }
                el = new Ltxml.XElement(xn, cn2);
            }
            return el;
        }

        if (node.nodeType === 2) {
            if (node.namespaceURI === null || node.namespaceURI === undefined ||
                    (node.namespaceURI === "" && node.prefix !== "xmlns")) {
                if (node.prefix === "xml") {
                    ns = Ltxml.XNamespace.getXml();
                }
                else {
                    ns = Ltxml.XNamespace.getNone();
                }
            }
            else {
                if (node.namespaceURI === "http://www.w3.org/2000/xmlns/" ||
                        node.prefix === "xmlns") {
                    ns = Ltxml.XNamespace.getXmlns();
                }
                else if (node.namespaceURI ===
                        "http://www.w3.org/XML/1998/namespace") {
                    ns = Ltxml.XNamespace.getXml();
                }
                else {
                    ns = new Ltxml.XNamespace(
                        node.namespaceURI,
                            node.prefix ?
                            node.prefix.toString() :
                            null);
                }
            }
            if (node.localName) {
                xn = new Ltxml.XName(ns, node.localName);
            }
            else {
                if (node.nodeName === "xmlns") {
                    xn = new Ltxml.XName(ns, "xmlns");
                }
                else {
                    xn = new Ltxml.XName(ns, node.baseName);
                }
            }
            at = new Ltxml.XAttribute(xn, node.nodeValue);
            return at;
        }

        if (node.nodeType === 3) {
            nc = [];
            addContentThatCanContainEntities(node.nodeValue, null, true, function (c) {
                nc.push(c);
            });
            return nc;
        }

        if (node.nodeType === 4) {
            xcd = new Ltxml.XCData(node.nodeValue);
            return xcd;
        }

        if (node.nodeType === 7) {
            if (node.target === 'xml') {
                return null;
            }
            pi = new Ltxml.XProcessingInstruction(node.target, node.data);
            return pi;
        }

        if (node.nodeType === 8) {
            xcm = new Ltxml.XComment(node.nodeValue);
            return xcm;
        }

        if (node.nodeType === 9) {
            version = node.xmlVersion;
            encoding = node.xmlEncoding;
            standalone = node.xmlStandalone;
            if (!version) { version = "1.0"; }
            if (!encoding) { encoding = "UTF-8"; }
            if (!standalone) { standalone = "yes"; }
            xdec = new Ltxml.XDeclaration(
                version,
                encoding,
                standalone ? "yes" : "no");
            cn = node.childNodes;
            cn_doc = [];
            for (cnt4 = 0; cnt4 < cn.length; cnt4 += 1) {
                cn_doc.push(xmlNodeLoad(cn[cnt4], depth + 1));
            }
            doc = new Ltxml.XDocument(xdec, cn_doc);
            return doc;
        }
    }

    throw ("Internal Error");
}

Ltxml.XDocument.load = function (document) {
    var d = xmlNodeLoad(document);
    return d;
};

Ltxml.XDocument.prototype.getRoot = function () {
    return Enumerable
        .from(this.nodesArray)
        .firstOrDefault(function (f) {
            return f.nodeType === 'Element';
        });
};

// xname is optional
Ltxml.XDocument.prototype.descendants = function (xname) {
    var result;

    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }

    if (this.lazy) {
        return lazyDescendantHelper(this, xname);
    }
    // not lazy
    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    result = [];
    eagarDescendantHelper(this, xname, function (e) { result.push(e); });
    return Enumerable.from(result);
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XDocument.prototype, "root", {
        get: function () {
            return this.getRoot();
        },
        enumerable: true,
        configurable: true
    });

}

/********************** XElement: XContainer **********************/

// new XElement(xelement)         // copy constructor
// new XElement(xname)
// new XElement(xname, content)
Ltxml.XElement = function (arg1) {
    var tempNodes, tempAtts, tempNodes2, tempAtts2, xnameObj, args, i;

    this.annotationsArray = [];
    this.parent = null;
    this.nodeType = 'Element';
    this.nodesArray = null;
    this.attributesArray = null;
    this.name = null;
    this.nsCache = null;

    if (Object.defineProperties) {

        Object.defineProperty(this, "value", {
            get: Ltxml.XElement.prototype.getValue,
            set: Ltxml.XElement.prototype.setValue,
            enumerable: true,
            configurable: true
        });

    }

    if (typeof arg1 === 'object' && arg1.nodeType && arg1.nodeType === 'Element') {
        if (arguments.length > 1) {
            throw "XElement constructor: invalid arguments";
        }
        this.name = arg1.name;
        tempNodes = [];
        tempAtts = [];
        addContent(this,
                    function (z) { tempNodes.push(z); },
                    function (z) { tempAtts.push(z); },
                    arg1.attributesArray,
                    arg1.nodesArray);
        this.attributesArray = tempAtts;
        this.nodesArray = tempNodes;
        return;
    }

    xnameObj = arg1;
    if (typeof arg1 === 'string') {
        xnameObj = new Ltxml.XName(arg1);
    }
    this.name = xnameObj;
    if (arguments.length > 1) {
        args = [];
        for (i = 1; i < arguments.length; i += 1) {
            args.push(arguments[i]);
        }
        tempNodes2 = [];
        tempAtts2 = [];
        addContent(this,
                    function (z) { tempNodes2.push(z); },
                    function (z) { tempAtts2.push(z); },
                    args);
        this.attributesArray = tempAtts2;
        this.nodesArray = tempNodes2;
    }
    if (this.nodesArray === null) {
        this.nodesArray = [];
    }
    if (this.attributesArray === null) {
        this.attributesArray = [];
    }
};

Ltxml.XElement.prototype = new Ltxml.XContainer();

Ltxml.XElement.prototype.attribute = function (xname) {
    var i;

    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    for (i = 0; i < this.attributesArray.length; i += 1) {
        if (this.attributesArray[i].name === xname) {
            return this.attributesArray[i];
        }
    }
    return null;
};

Ltxml.XElement.prototype.attributes = function (xname) {
    var atts;

    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }

    if (xname === undefined) {
        atts = Enumerable.from(this.attributesArray);
        return atts;
    }
    // have XName
    atts = Enumerable.from(this.attributesArray)
        .where(function (a) { return a.name === xname; });
    return atts;
};

Ltxml.XElement.prototype.serialize = function (o, indent, depth) {
    var attributesToUse, indent_spaces, middle_take, mixed_content,
        attribute_indent_spaces, qn, as, bs, i, n;

    if (!depth) {
        depth = 0;
    }
    qn = Ltxml.XName.qualify(this.name, this, false);
    attributesToUse = [].concat(this.attributesArray);
    attributesToUse.sort(function (a, b) {
        as = a.name.toString();
        bs = b.name.toString();
        if (as < bs) {
            return -1;
        }
        if (as > bs) {
            return 1;
        }
        return 0;
    });
    if (this.nodesArray.length === 0) {
        // ================================ content:no
        if (indent) {
            // ================================ content:no indent:yes
            indent_spaces = Ltxml.spaces.substring(0, depth);
            if (attributesToUse.length === 0) {
                // ============ content:no indent:yes attributes:no
                o.a(indent_spaces).a("<").a(qn).a("/>\n");
                return;
            }
            if (attributesToUse.length === 1) {
                // ================================ content:no indent:yes attributes:1
                o.a(indent_spaces).a("<").a(qn).a(" ")
                    .a(attributesToUse[0]).a("/>\n");
                return;
            }
            // ================================ content:no indent:yes attributes:*
            attribute_indent_spaces = indent_spaces +
                Ltxml.spaces.substring(0, 2 + qn.length);
            middle_take = attributesToUse.length - 2;
            o.a(indent_spaces).a("<").a(qn).a(" ");
            attributesToUse[0].serialize(o);
            o.a("\n");
            Enumerable.from(attributesToUse)
                .skip(1)
                .take(middle_take)
                .forEach(function (a) {
                    o.a(attribute_indent_spaces);
                    a.serialize(o);
                    o.a("\n");
                });
            o.a(attribute_indent_spaces);
            attributesToUse[attributesToUse.length - 1].serialize(o);
            o.a("/>\n");
            return;
        }
        // ================================ content:no indent:no
        o.a("<").a(qn).a(attributesToUse.length === 0 ? "" : " ");
        for (i = 0; i < attributesToUse.length; i += 1) {
            attributesToUse[i].serialize(o);
            if (i < attributesToUse.length - 1) {
                o.a(' ');
            }
        }
        o.a("/>");
        return;
    }
    // ================================ content:yes
    if (indent) {
        // ================================ content:yes indent:yes
        indent_spaces = Ltxml.spaces.substring(0, depth);
        mixed_content = false;
        for (i = 0; i < this.nodesArray.length; ++i) {
            n = this.nodesArray[i];
            if ((n.nodeType === 'Text' && n.value !== '') ||
                n.nodeType === 'Entity') {
                mixed_content = true;
                break;
            }
        }
        //mixed_content = (this.nodesArray[0].nodeType === 'Text' ||
        //    this.nodesArray[0].nodeType === 'CDATA' ||
        //    this.nodesArray[0].nodeType === 'Entity');
        if (mixed_content) {
            // =============== content:yes indent:yes first_child_text:yes
            if (attributesToUse.length === 0) {
                // ========== content:yes indent:yes first_child_text:yes attributes:0
                o.a(indent_spaces).a("<").a(qn).a(">");
                for (i = 0; i < this.nodesArray.length; i += 1) {
                    this.nodesArray[i].serialize(o);
                }
                o.a("</").a(qn).a(">\n");
                return;
            }
            if (attributesToUse.length === 1) {
                // ========= content:yes indent:yes first_child_text:yes attributes:1
                o.a(indent_spaces).a("<").a(qn).a(" ");
                attributesToUse[0].serialize(o);
                o.a(">");
                for (i = 0; i < this.nodesArray.length; i += 1) {
                    this.nodesArray[i].serialize(o, false);
                }
                o.a("</").a(qn).a(">\n");
                return;
            }
            // ============ content:yes indent:yes first_child_text:yes attributes:*
            attribute_indent_spaces = indent_spaces +
                Ltxml.spaces.substring(0, 2 + qn.length);
            middle_take = attributesToUse.length - 2;
            o.a(indent_spaces).a("<").a(qn).a(" ");
            attributesToUse[0].serialize(o);
            o.a("\n");
            Enumerable.from(attributesToUse)
                .skip(1)
                .take(middle_take)
                .forEach(function (a) { o.a(attribute_indent_spaces).a(a).a("\n"); });
            o.a(attribute_indent_spaces);
            attributesToUse[attributesToUse.length - 1].serialize(o);
            o.a(">");
            Enumerable.from(this.nodesArray)
                        .forEach(function (c) { c.serialize(o, false); });
            o.a("</").a(qn).a(">\n");
            // following is implementation that does not use LINQ
            // var first = indent_spaces + "<" + qn + " " + attributesToUse[0] + "\n";
            // var atum = [];
            // for (var i = 1; i < attributesToUse.length - 1; i += 1) {
            //     atum.push(attributesToUse[i]);
            // }
            // var z9 = '';
            // for (var j = 0; j < atum.length; j += 1) {
            //     z9 += attribute_indent_spaces + atum[j].toString() + "\n";
            // }
            // var second = z9;

            // var third = attribute_indent_spaces +
            //     attributesToUse[attributesToUse.length - 1] + ">" +
            //             Enumerable.from(this.nodesArray)
            //                 .select(function (c) { return c.serialize(false) })
            //        .aggregate('', function (a, b) { return a + b; }) +
            //                   "</" + qn + ">\n";
            // var es = first + second + third;
            return;
        }
        // ================================ content:yes indent:yes first_child_text:no
        if (attributesToUse.length === 0) {
            // =============== content:yes indent:yes first_child_text:no attributes:0
            o.a(indent_spaces).a("<").a(qn).a(">\n");
            Enumerable.from(this.nodesArray)
                .forEach(function (c) { c.serialize(o, true, depth + 2); });
            o.a(indent_spaces).a("</").a(qn).a(">\n");
            return;
        }
        if (attributesToUse.length === 1) {
            // ============== content:yes indent:yes first_child_text:no attributes:1
            o.a(indent_spaces).a("<").a(qn).a(" ");
            attributesToUse[0].serialize(o);
            o.a(">\n");
            Enumerable.from(this.nodesArray)
                .forEach(function (c) { c.serialize(o, true, depth + 2); });
            o.a(indent_spaces).a("</").a(qn).a(">\n");
            return;
        }
        // ================ content:yes indent:yes first_child_text:no attributes:*
        attribute_indent_spaces = indent_spaces +
            Ltxml.spaces.substring(0, 2 + qn.length);
        middle_take = attributesToUse.length - 2;
        o.a(indent_spaces).a("<").a(qn).a(" ");
        attributesToUse[0].serialize(o);
        o.a("\n");
        Enumerable.from(attributesToUse)
                    .skip(1)
                    .take(middle_take)
                    .forEach(function (a) {
                        o.a(attribute_indent_spaces); a.serialize(o); o.a("\n");
                    });
        o.a(attribute_indent_spaces);
        attributesToUse[attributesToUse.length - 1].serialize(o);
        o.a(">\n");
        Enumerable.from(this.nodesArray)
            .forEach(function (c) { c.serialize(o, true, depth + 2); });
        o.a(indent_spaces).a("</").a(qn).a(">\n");
        return;
    }
    // ================================ content:yes indent:no
    o.a("<").a(qn);
    Enumerable.from(attributesToUse)
        .forEach(function (a) { o.a(" "); a.serialize(o); });
    o.a(">");
    Enumerable.from(this.nodesArray)
        .forEach(function (n) { n.serialize(o); });
    o.a("</").a(qn).a(">");
    return;
};

function cloneCache(original) {
    var len, clonedCache;

    clonedCache = {
        prefixesFromNamespaceObjects: false,
        namespaceArray: [],
        prefixArray: []
    };
    len = original.namespaceArray.length;
    clonedCache.namespaceArray = original.namespaceArray.slice(0, len);
    clonedCache.prefixArray = original.prefixArray.slice(0, len);
    return clonedCache;
}

function annotateElementForNamespaces(element, nsCache, xmlns, xml, none) {
    var needToProcess, aa, na, ns, len, i, j, nd, newNsCache, el, prefix, nn, localNamespaceCacheLen,
        newPrefix, newAtt, workingNsCache, index;

    needToProcess = false;

    // The code in this method always examines and modifies the workingNsCache.  If there is no need to
    // modify the local namespace cache, then workingNsCache will always be set to the inherited local
    // namespace cache.  If this method needs to modify the local namespace cache, then it will clone the
    // local namespace cache and set workingNsCache to the cloned cache.  If this method were to modify the
    // inherited local namespace cache, then it would be modifying the namespace cache for all ancestor
    // elements that currently are using that specific namespace cache.
    workingNsCache = nsCache;

    // If there are any namespace attributes where the prefix does not match the current prefix in use for
    // that namespace, then this method will need to build a new local namespace cache.
    aa = element.attributesArray;
    len = aa.length;
    for (i = 0; i < len; i += 1) {
        nd = aa[i];
        if (nd.isNamespaceDeclaration) {
            ns = new Ltxml.XNamespace(nd.value);
            prefix = nd.name.localName;
            if (workingNsCache.prefixesFromNamespaceObjects && prefix !== ns.preferredPrefix) {
                if (workingNsCache === nsCache) {
                    workingNsCache = cloneCache(nsCache);
                }
                index = workingNsCache.prefixArray.indexOf(prefix);
                if (index !== -1) {
                    workingNsCache.namespaceArray[index] = ns;
                }
                else {
                    workingNsCache.namespaceArray.push(ns);
                    workingNsCache.prefixArray.push(prefix);
                }
                needToProcess = true;
                break;
            }
            else {
                index = workingNsCache.namespaceArray.indexOf(ns);
                if (index === -1 || prefix !== workingNsCache.prefixArray[index]) {
                    if (workingNsCache === nsCache) {
                        workingNsCache = cloneCache(nsCache);
                    }
                    index = workingNsCache.prefixArray.indexOf(prefix);
                    if (index !== -1) {
                        workingNsCache.namespaceArray[index] = ns;
                    }
                    needToProcess = true;
                    break;
                }
            }
        }
    }

    // If there are any attributes that are in a namespace and if the attribute is not defined with
    // a prefix, then fabricate a prefix, and add it as an attribute to the element, then clone
    // the local namespace cache and add the namespace with prefix to the local namespace cache.
    for (i = 0; i < len; i += 1) {
        nd = aa[i];
        if (!nd.isNamespaceDeclaration && nd.name.namespace !== none && nd.name.namespace !== xml) {

            localNamespaceCacheLen = workingNsCache.namespaceArray.length;
            index = -1;
            for (j = 0; j < localNamespaceCacheLen; ++j) {
                if (workingNsCache.namespaceArray[j] === nd.name.namespace && workingNsCache.prefixArray[j] !== "xmlns") {
                    index = j;
                    break;
                }
            }

            if (index === -1) {
                while (true) {
                    newPrefix = "p" + prefixCounter;
                    if (workingNsCache.prefixArray.indexOf(newPrefix) === -1) {
                        break;
                    }
                    prefixCounter += 1;
                }
                newAtt = new Ltxml.XAttribute(Ltxml.XNamespace.getXmlns() + newPrefix,
                    nd.name.namespace.namespaceName);
                element.add(newAtt);
                if (workingNsCache === nsCache) {
                    workingNsCache = cloneCache(nsCache);
                }
                workingNsCache.namespaceArray.push(nd.name.namespace);
                workingNsCache.prefixArray.push(newPrefix);
                needToProcess = true;
            }
        }
    }

    // If the element is in a namespace and that namespace is not in the local namespace cache
    // (either as the default namespace or as a namespace with a prefix), then fabricate a prefix,
    // add an attribute to the element, clone the local namespace cache, and add the namespace to
    // the local namespace cache.
    if (element.name.namespace !== none && workingNsCache.namespaceArray.indexOf(element.name.namespace) === -1) {
        while (true) {
            newPrefix = "p" + prefixCounter;
            if (workingNsCache.prefixArray.indexOf(newPrefix) === -1) {
                break;
            }
            prefixCounter += 1;
        }
        newAtt = new Ltxml.XAttribute(Ltxml.XNamespace.getXmlns() + newPrefix,
            element.name.namespace.namespaceName);
        element.add(newAtt);
        if (workingNsCache === nsCache) {
            workingNsCache = cloneCache(nsCache);
        }
        workingNsCache.namespaceArray.push(element.name.namespace);
        workingNsCache.prefixArray.push(newPrefix);
        needToProcess = true;
    }

    // If the element is in no namespace and if there is a default namespace, then add an attribute
    // to the element that unbinds the default namespace.
    if (element.name.namespace === none) {
        index = workingNsCache.prefixArray.indexOf("xmlns");
        // if there is a default namespace
        if (index !== -1) {
            if (workingNsCache.namespaceArray[index] !== none) {
                // If there is no namespace attribute that undeclares the default namespace
                if (!Enumerable.from(element.attributesArray).any(function (a) {
                    return a.name.namespace === xmlns && a.name.localName === "xmlns" && a.value === "";
                })) {
                    // Then add a namespace attribute that undeclares the default namespace.
                    nn = new Ltxml.XAttribute("xmlns", "");
                    element.add(nn);
                    needToProcess = true;
                }
            }
        }
    }

    // If it is necessary to build a new local namespace cache...
    if (needToProcess) {

        // Create a new local namespace cache.
        newNsCache = {
            prefixesFromNamespaceObjects: false,
            namespaceArray: [],
            prefixArray: []
        };

        // Go through all namespace attributes and add all namespace declarations to the new
        // local namespace cache.
        aa = element.attributesArray;
        len = aa.length;
        for (i = 0; i < len; i += 1) {
            nd = aa[i];
            if (nd.isNamespaceDeclaration) {
                if (nd.value === "") {
                    ns = none;
                }
                else {
                    ns = new Ltxml.XNamespace(nd.value);
                }
                prefix = nd.name.localName;
                newNsCache.namespaceArray.push(ns);
                newNsCache.prefixArray.push(prefix);
            }
        }

        // For all namespaces in the inherited local namespace cache, if the namespace is not already
        // in the new local namespace cache, then add it.
        for (i = 0; i < workingNsCache.namespaceArray.length; i += 1) {
            if (newNsCache.namespaceArray.indexOf(workingNsCache.namespaceArray[i]) === -1) {
                // If there already is a namespace with the same prefix in the local namespace cache,
                // then don't copy the namespace from the inherited local namespace cache into the new
                // local namespace cache.
                if (newNsCache.prefixArray.indexOf(workingNsCache.prefixArray[i]) === -1) {
                    newNsCache.namespaceArray.push(workingNsCache.namespaceArray[i]);
                    newNsCache.prefixArray.push(workingNsCache.prefixArray[i]);
                }
            }
        }

        // Annotate the element with the new local namespace cache.
        element.nsCache = newNsCache;

        // Recursivly annotate descendant elements.
        na = element.nodesArray;
        len = na.length;
        for (j = 0; j < len; j += 1) {
            el = na[j];
            if (el.nodeType === 'Element') {
                annotateElementForNamespaces(el, newNsCache, xmlns, xml, none);
            }
        }
        return;
    }

    // Annotate the element with the inherited local namespace cache.
    element.nsCache = workingNsCache;

    // Recursivly annotate descendant elements.
    na = element.nodesArray;
    len = na.length;
    for (j = 0; j < len; j += 1) {
        el = na[j];
        if (el.nodeType === 'Element') {
            annotateElementForNamespaces(el, workingNsCache, xmlns, xml, none);
        }
    }
}

annotateRootForNamespaces = function (rootElement) {
    var aa, na, len, i, j, nd, newPrefix, newAtt, index, aalen,
        nsCache, ns, prefix, el, xmlns, none, xml;

    // Clear the preferred prefix for all namespaces in the global namespace cache.
    xmlns = Ltxml.XNamespace.getXmlns();
    none = Ltxml.XNamespace.getNone();
    xml = Ltxml.XNamespace.getXml();
    for (ns in Ltxml.namespaceCache) {
        if (Ltxml.namespaceCache.hasOwnProperty(ns)) {
            if (Ltxml.namespaceCache[ns].namespaceName) {
                Ltxml.namespaceCache[ns].preferredPrefix = null;
            }
        }
    }

    // Initialize the local namespace cache.
    prefixCounter = 0;
    nsCache = {
        prefixesFromNamespaceObjects: true,
        namespaceArray: [],
        prefixArray: []
    };

    // Add all namespace attributes at the root level to the local namespace cache, and set the
    // preferred prefix in the global namespace cache.
    aa = rootElement.attributesArray;
    len = aa.length;
    for (i = 0; i < len; i += 1) {
        nd = aa[i];
        if (nd.isNamespaceDeclaration) {
            ns = new Ltxml.XNamespace(nd.value);
            prefix = nd.name.localName;
            ns.preferredPrefix = prefix;
            nsCache.namespaceArray.push(ns);
            nsCache.prefixArray.push(prefix);
        }
    }

    // For all non-namespace attributes of the root element, if the namespace of the attribute is not in
    // the local namespace cache, then fabricate a prefix and add it.
    for (i = 0; i < len; i += 1) {
        nd = aa[i];
        if (!nd.isNamespaceDeclaration &&
            nd.name.namespace !== none &&
            nd.name.namespace !== xml) {
            index = -1;
            aalen = nsCache.namespaceArray.length;
            for (j = 0; j < aalen; ++j) {
                if (nsCache.namespaceArray[j] === nd.name.namespace && nsCache.prefixArray[j] !== "xmlns") {
                    index = j;
                    break;
                }
            }
            if (index === -1) {
                while (true) {
                    newPrefix = "p" + prefixCounter;
                    if (nsCache.prefixArray.indexOf(newPrefix) === -1) {
                        break;
                    }
                    prefixCounter += 1;
                }
                newAtt = new Ltxml.XAttribute(Ltxml.XNamespace.getXmlns() + newPrefix,
                    nd.name.namespace.namespaceName);
                rootElement.add(newAtt);
                nsCache.namespaceArray.push(nd.name.namespace);
                nsCache.prefixArray.push(newPrefix);
                nd.name.namespace.preferredPrefix = newPrefix;
            }
        }
    }

    // If the namespace for the root element is not in the local namespace cache,
    // fabricate a prefix and add it.
    if (rootElement.name.namespace !== none && nsCache.namespaceArray.indexOf(rootElement.name.namespace) === -1) {
        while (true) {
            newPrefix = "p" + prefixCounter;
            if (nsCache.prefixArray.indexOf(newPrefix) === -1) {
                break;
            }
            prefixCounter += 1;
        }
        newAtt = new Ltxml.XAttribute(Ltxml.XNamespace.getXmlns() + newPrefix,
            rootElement.name.namespace.namespaceName);
        rootElement.add(newAtt);
        nsCache.namespaceArray.push(rootElement.name.namespace);
        nsCache.prefixArray.push(newPrefix);
        rootElement.name.namespace.preferredPrefix = newPrefix;
    }

    // Set the local namespace cache for the root element.
    rootElement.nsCache = nsCache;

    // Recursively annotate descendant elements.
    na = rootElement.nodesArray;
    len = na.length;
    for (j = 0; j < len; j += 1) {
        el = na[j];
        if (el.nodeType === 'Element') {
            annotateElementForNamespaces(el, nsCache, xmlns, xml, none);
        }
    }
};

Ltxml.XElement.prototype.toString = function (indent) {
    var clone, o;

    if (indent === undefined)
        indent = true;
    o = getStringBuilder();
    clone = new Ltxml.XElement(this);
    annotateRootForNamespaces(clone);
    clone.serialize(o, indent, 0);
    return o.toString();
};


Ltxml.XElement.load = function (element) {
    var el = xmlNodeLoad(element);
    return el;
};

Ltxml.XElement.prototype.getFirstAttribute = function () {
    if (this.attributesArray.length > 0) {
        return this.attributesArray[0];
    }
    return null;
};

Ltxml.XElement.prototype.getDefaultNamespaceHelper = function () {
    var attributesToUse, defNamespaceAtt;

    attributesToUse = [].concat(this.attributesArray);
    defNamespaceAtt = Enumerable
        .from(attributesToUse)
        .where(function (a) { return a.isNamespaceDeclaration; })
        .firstOrDefault(function (a) {
            return a.name.namespace === Ltxml.XNamespace.getXmlns() &&
            a.name.localName === "xmlns";
        });
    return defNamespaceAtt;
};

Ltxml.XElement.prototype.getDefaultNamespace = function (namespace) {
    var current, dna;

    current = this;
    while (true) {
        dna = current.getDefaultNamespaceHelper(namespace);
        if (dna !== null) {
            return new Ltxml.XNamespace(dna.value);
        }
        current = current.parent;
        if (current === null || current.nodeType === 'Document') {
            return Ltxml.XNamespace.getNone();
        }
    }
};

Ltxml.XElement.prototype.getNamespaceOfPrefixForThisElement = function (prefix) {
    var a = Enumerable.from(this.attributesArray)
        .firstOrDefault(function (a) {
            return a.isNamespaceDeclaration &&
                a.name.namespace === Ltxml.XNamespace.getXmlns() &&
                a.name.localName === prefix;
        });
    return a;
};

Ltxml.XElement.prototype.getNamespaceOfPrefix = function (prefix) {
    var current, ns;

    current = this;
    while (true) {
        ns = current.getNamespaceOfPrefixForThisElement(prefix);
        if (ns !== null) {
            return ns;
        }
        current = current.parent;
        if (current === null || current.nodeType === 'Document') {
            return null;
        }
    }
};

prefixCounter = 0;

Ltxml.XElement.prototype.getPrefixOfNamespace = function (namespace, isAttribute) {
    var current, prefix, nsCache, prefixesFromNamespaceObjects, index,
        newPrefix, newAtt;

    current = this;
    nsCache = this.nsCache;

    // If the code is in the mode of retrieving prefixes from namespace objects, and if
    // the namespace object has a preferredPrefix, then return it.
    prefixesFromNamespaceObjects = nsCache.prefixesFromNamespaceObjects;
    if (prefixesFromNamespaceObjects && namespace.preferredPrefix) {
        if (namespace.preferredPrefix === "xmlns") {
            return "";
        }
        return namespace.preferredPrefix;
    }
    if (isAttribute === undefined) {
        isAttribute = false;
    }

    index = nsCache.namespaceArray.indexOf(namespace);

    if (index === -1) {
        throw ("Local namespace cache is invalid");
    }

    // If the namespace is for an element, and if the namespace is the default namespace,
    // then return the empty string.
    if (!isAttribute) {
        if (index !== -1 && nsCache.prefixArray[index] === "xmlns") {
            return '';
        }
    }

    prefix = nsCache.prefixArray[index];
    return prefix;  //ignore jslint
};

Ltxml.XElement.prototype.getHasAttributes = function () {
    return this.attributesArray && this.attributesArray.length > 0;
};

Ltxml.XElement.prototype.getHasElements = function () {
    return Enumerable.from(this.nodesArray).any(function (n) {
        return n.nodeType === 'Element';
    });
};

Ltxml.XElement.prototype.getIsEmpty = function () {
    return this.nodesArray.length === 0;
};

Ltxml.XElement.prototype.getLastAttribute = function () {
    if (this.attributesArray.length > 0) {
        return this.attributesArray[this.attributesArray.length - 1];
    }
    return null;
};

Ltxml.XElement.parse = function (xml) {
    var xmlDoc, el;

    xmlDoc = parseXml(xml);
    el = Ltxml.XElement.load(xmlDoc.documentElement);
    return el;
};

Ltxml.XElement.prototype.removeAll = function () {
    this.nodesArray = [];
    this.attributesArray = [];
};

Ltxml.XElement.prototype.removeAttributes = function () {
    this.attributesArray = [];
};

Ltxml.XElement.prototype.replaceAll = function () {
    var args, contentToInsert, i;

    args = [];
    contentToInsert = [];

    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    contentToInsert = [];
    addContent(this,
        function (c) { contentToInsert.push(c); },
        function () { throw "replaceAll: invalid content"; },
        args);
    this.nodesArray = contentToInsert;
};

Ltxml.XElement.prototype.replaceAttributes = function () {
    var args, contentToInsert, i;

    args = [];
    contentToInsert = [];

    args = [];
    for (i = 0; i < arguments.length; i += 1) {
        args.push(arguments[i]);
    }
    contentToInsert = [];
    addContent(this,
        function () { throw "replaceAttributes: invalid content"; },
        function (a) { contentToInsert.push(a); },
        args);
    this.attributesArray = contentToInsert;
};

Ltxml.XElement.prototype.setAttributeValue = function (xname, value) {
    var xa;

    if (typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    xa = this.attribute(xname);
    if (xa !== null) {
        if (value === null) {
            if (xa.parent !== null) {
                xa.remove();
            }
            return;
        }
        xa.setValue(value);
        return;
    }
    xa = new Ltxml.XAttribute(xname, value);
    xa.parent = this;
    this.attributesArray.push(xa);
};

Ltxml.XElement.prototype.setElementValue = function (xname, value) {
    var xe, nc;

    if (typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }
    xe = this.element(xname);
    if (xe !== null) {
        if (value === null) {
            if (xe.parent !== null) {
                xe.remove();
            }
            return;
        }
        nc = [];
        addContentThatCanContainEntities(value, xe, true, function (v) {
            nc.push(v);
        });
        xe.nodesArray = nc;
        return;
    }
    xe = new Ltxml.XElement(xname, value);
    xe.parent = this;
    this.nodesArray.push(xe);
};

Ltxml.XElement.prototype.setValue = function (value) {
    var nc = [];
    addContentThatCanContainEntities(value.toString(), this, true, function (c) {
        nc.push(c);
    });
    this.nodesArray = nc;
};

Ltxml.XElement.prototype.getValue = function () {
    var returnValue = this
        .descendantNodes()
        .where(function (n) {
            return n.nodeType === 'Text' ||
            n.nodeType === 'CDATA' ||
            n.nodeType === 'Entity';
        })
        .select(function (n) { return n.value; })
        .toArray()
        .join('');
    return returnValue;
};

Ltxml.XElement.prototype.ancestorsAndSelf = function (xname) {
    var result, current, self;

    self = this;
    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }

    if (this.lazy) {
        return Enumerable.Utils.createEnumerable(function () {
            var current;

            return Enumerable.Utils.createEnumerator(
                function () {
                    current = self;
                },  // initialize
                function () { // tryGetNext
                    while (current !== null) {
                        if (xname && current.name !== xname) {
                            current = current.parent;
                        }
                        else {
                            var thisOne = current;
                            current = current.parent;
                            return this.yieldReturn(thisOne);
                        }
                    }
                    return this.yieldBreak();
                },
                Functions.Blank
            );
        });
    }
    result = [];
    current = this.parent;
    if (xname === undefined) {
        result.push(this);
        while (current !== null) {
            result.push(current);
            current = current.parent;
        }
        return Enumerable.from(result);
    }
    if (this.name === xname) {
        result.push(this);
    }
    while (current !== null) {
        if (current.name === xname) {
            result.push(current);
        }
        current = current.parent;
    }
    return Enumerable.from(result);
};

function descendantNodesAndSelfHelper(element, pushFunc) {
    var i;

    for (i = 0; i < element.nodesArray.length; i += 1) {
        pushFunc(element.nodesArray[i]);
        if (element.nodesArray[i].nodeType === 'Element' ||
                element.nodesArray[i].nodeType === 'Document') {
            descendantNodesAndSelfHelper(element.nodesArray[i], pushFunc);
        }
    }
}

Ltxml.XElement.prototype.descendantNodesAndSelf = function () {
    var result, returnValue;

    if (this.lazy) {
        returnValue = Enumerable
            .from(this.nodesArray)
            .traverseDepthFirst(function (node) {
                return Enumerable.from(node.nodesArray);
            });
        return Enumerable.from([this]).concat(returnValue);
    }

    result = [];
    result.push(this);
    descendantNodesAndSelfHelper(this, function (e) { result.push(e); });
    return Enumerable.from(result);
};

// xname is optional
Ltxml.XElement.prototype.descendantsAndSelf = function (xname) {
    var result, self;

    if (xname && typeof xname === 'string') {
        xname = new Ltxml.XName(xname);
    }

    if (this.lazy) {
        if (!xname) {
            self = Enumerable.from([this]);
        }
        else {
            if (xname === this.name) {
                self = Enumerable.from([this]);
            }
            else {
                self = Enumerable.from([]);
            }
        }
        return self.concat(lazyDescendantHelper(this, xname));
    }
    result = [];
    if (!xname) {
        result.push(this);
    }
    else {
        if (xname === this.name) {
            result.push(this);
        }
    }
    eagarDescendantHelper(this, xname, function (e) { result.push(e); });
    return Enumerable.from(result);
};

if (Object.defineProperties) {

    Object.defineProperty(Ltxml.XElement.prototype, "firstAttribute", {
        get: function () {
            return this.getFirstAttribute();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XElement.prototype, "hasAttributes", {
        get: function () {
            return this.getHasAttributes();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XElement.prototype, "hasElements", {
        get: function () {
            return this.getHasElements();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XElement.prototype, "isEmpty", {
        get: function () {
            return this.getIsEmpty();
        },
        enumerable: true,
        configurable: true
    });

    Object.defineProperty(Ltxml.XElement.prototype, "lastAttribute", {
        get: function () {
            return this.getLastAttribute();
        },
        enumerable: true,
        configurable: true
    });
}

/********************* XProcessingInstruction: XNode *********************/

//new XProcessingInstruction(xprocessingInstruction)
//new XProcessingInstruction(target, data)
Ltxml.XProcessingInstruction = function (arg1, arg2) {
    this.nodeType = 'ProcessingInstruction';
    this.parent = null;
    this.target = null;
    this.data = null;

    if (arg1 && arg1.nodeType && arg1.nodeType === 'ProcessingInstruction') {
        if (arg1.target) {
            this.target = arg1.target;
        }
        if (arg1.data) {
            this.data = arg1.data;
        }
    }
    else {
        this.target = arg1;
        this.data = arg2;
    }
};

Ltxml.XProcessingInstruction.prototype = new Ltxml.XNode();

Ltxml.XProcessingInstruction.prototype.serialize = function (o, indent, depth) {
    var indent_spaces;

    if (!depth) {
        depth = 0;
    }
    if (indent) {
        indent_spaces = Ltxml.spaces.substring(0, depth);
        o.a(indent_spaces).a("<?").a(this.target).a(" ").a(this.data).a("?>\n");
        return;
    }
    o.a("<?").a(this.target).a(" ").a(this.data).a("?>");
    return;
};

Ltxml.XProcessingInstruction.prototype.toString = function (indent) {
    var o = getStringBuilder();
    this.serialize(o, indent);
    return o.toString();
};

/********************** XText: XNode **********************/

Ltxml.XText = function (arg1) {
    this.nodeType = 'Text';
    this.parent = null;

    if (arg1 && arg1.nodeType && arg1.nodeType === 'Text') {
        // copy constructor
        this.value = arg1.value.toString();
    }
    else {
        this.value = arg1;
    }

    // methods
    this.serialize = function (o) {
        o.a(this.value);
    };

    this.toString = function () {
        return this.value;
    };
};

Ltxml.XText.prototype = new Ltxml.XNode();

/********************** XEntity: XNode **********************/

Ltxml.XEntity = function (arg1) {
    this.nodeType = 'Entity';
    this.parent = null;

    if (arg1 && arg1.nodeType && arg1.nodeType === 'Entity') {
        // copy constructor
        this.value = arg1.value;
    }
    else {
        if (typeof arg1 === 'string') {
            this.value = arg1;
        }
        else {
            this.value = arg1.toString();
        }
    }

    // methods
    this.serialize = function (o) {
        var s = "&" + this.value + ";";
        o.a(s);
    };

    this.toString = function () {
        return "&" + this.value + ";";
    };
};

Ltxml.XEntity.prototype = new Ltxml.XNode();

/******************* XCData: XText *******************/

Ltxml.XCData = function (arg1) {
    this.nodeType = 'CDATA';
    this.parent = null;

    if (arg1 && arg1.nodeType && arg1.nodeType === 'CDATA') {
        // copy constructor
        this.value = arg1.value.toString();
    }
    else {
        this.value = arg1.toString();
    }
};

Ltxml.XCData.prototype = new Ltxml.XText();

Ltxml.XCData.prototype.serialize = function (o, indent, depth) {
    var indent_spaces;

    if (!depth) {
        depth = 0;
    }
    if (indent) {
        indent_spaces = Ltxml.spaces.substring(0, depth);
        o.a(indent_spaces).a('<![CDATA[').a(this.value).a(']]>\n');
        return;
    }
    o.a('<![CDATA[').a(this.value).a(']]>');
    return;
};

Ltxml.XCData.prototype.toString = function (indent) {
    var o = getStringBuilder();
    this.serialize(o, indent);
    return o.toString();
};

module.exports = Ltxml;