openxml.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

Version: 1.01.01
    Fixed a problem where serialization of UTF8 was not correct if the XDocument for the
    part was not loaded.

Version: 1.01
    Added support for loading and saving blobs.
    In distribution, replaced jszip.js, jszip-load.js, jszip-inflate.js, jszip-deflate.js
    Added support for asynchronous loading and saving of blobs, flatOpc, and base64

Version: 1.00
    Initial release.

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

/*
OpenXmlPackage(document)
- document can be either base64 DOCX or FlatOPC in string form
- fields:
  - parts: hash of OpenXmlPart objects, by uri
  - ctXDoc: XDocument of content type file

- addPart(uri, contentType, partType, data)
- addRelationship(rId, relationshipType, target, targetMode) - if targetMode is not set, then it is internal
- deletePart(part)
- deleteRelationship(rId)
- getContentType(uri)
- getPartById(rId) - gets part that is target of the package
- getPartByRelationshipType(relationshipType)
- getPartByUri(uri) - gets any part in the package
- getParts() - returns all parts in the package
- getPartsByContentType(contentType)
- getPartsByRelationshipType(relationshipType)
- getRelationshipById(rId) - gets one of the 2 or 3 relationships from the package
- getRelationships() - gets the relationships from the package
- getRelationshipsByContentType(contentType) - gets the relationships from the package
- getRelationshipsByRelationshipType(relationshipType)
- saveToBase64() - returns base64
- saveToFlatOpc() - returns flatOpc

OpenXmlPart(pkg, uri, contentType, partType, data)
- fields:
  - pkg
  - uri
  - contentType
  - partType   // "binary", "base64", "xml"
  - data

- addRelationship(rId, relationshipType, target, targetMode) - if targetMode is not set, then it is internal
- deleteRelationship(rId)
- getPartById(rId)
- getPartByRelationshipType(relationshipType)
- getParts() - returns all related parts of the source part
- getPartsByContentType(contentType)
- getPartsByRelationshipType(relationshipType)
- getRelationshipById(rId) - gets the relationship from the part
- getRelationships() - gets the relationships from the package
- getRelationshipsByContentType(contentType) - gets the relationships from the part
- getRelationshipsByRelationshipType(relationshipType) - gets the relationships from the part
- getXDocument()

OpenXmlRelationship
- fields:
  - fromPkg - if from a part, this will be null
  - fromPart - if from the package, this will be null.
  - relationshipId
  - relationshipType
  - target
  - targetMode
  - targetFullName
*/

(function (root) {
    "use strict";

    function defineOpenXml(Enumerable, Ltxml, XEnumerable) {

        var openXml = {};

        var XAttribute = Ltxml.XAttribute;
        var XCData = Ltxml.XCData;
        var XComment = Ltxml.XComment;
        var XContainer = Ltxml.XContainer;
        var XDeclaration = Ltxml.XDeclaration;
        var XDocument = Ltxml.XDocument;
        var XElement = Ltxml.XElement;
        var XEntity = Ltxml.XEntity;
        var XName = Ltxml.XName;
        var XNamespace = Ltxml.XNamespace;
        var XNode = Ltxml.XNode;
        var XObject = Ltxml.XObject;
        var XProcessingInstruction = Ltxml.XProcessingInstruction;
        var XText = Ltxml.XText;
        var cast = Ltxml.cast;
        var castInt = Ltxml.castInt;

        /******************************** OpenXmlPackage ********************************/

        function openFromZip(zip, pkg) {
            for (var f in zip.files) {
                var zipFile = zip.files[f];
                if (!openXml.util.endsWith(f, "/")) {
                    var partType = null;

                    var f2 = f;
                    if (f !== "[Content_Types].xml")
                        f2 = "/" + f;
                    var newPart = new openXml.OpenXmlPart(pkg, f2, null, null, zipFile.data);
                    pkg.parts[f2] = newPart;

                }
            }
            var ctf = pkg.parts["[Content_Types].xml"];
            if (ctf === null) {
                throw "Invalid Open XML document: no [Content_Types].xml";
            }
            pkg.ctXDoc = XDocument.parse(ctf.data);

            for (var part in pkg.parts) {
                if (part === "[Content_Types].xml")
                    continue;
                var ct = pkg.getContentType(part);
                var thisPart = pkg.parts[part];
                thisPart.contentType = ct;
                if (openXml.util.endsWith(ct, "xml")) {
                    thisPart.partType = "xml";
                }
                if (!openXml.util.endsWith(ct, "xml")) {
                    thisPart.partType = "binary";
                }
            }
        }

        function openFromBase64Internal(pkg, base64data) {
            var zip = new JSZip(base64data, {
                base64: true,
                checkCRC32: false
            });
            openFromZip(zip, pkg)
        }
        
        function openFromBase64InternalAsync(pkg, base64data, cb) {
            var zip = null;
            var state = 1;
            var intervalId = setInterval(function () {
                if (state === 1) {
                    zip = new JSZip(base64data, {
                        base64: true,
                        checkCRC32: false
                    });
                    state = 2;
                    return;
                }
                if (state === 2) {
                    openFromZip(zip, pkg, cb)
                    clearInterval(intervalId);
                    cb(pkg);
                    return;
                }
            }, 10);
        }

        function openFromBlobInternal(pkg, blob) {
            var zip = new JSZip(blob);
            openFromZip(zip, pkg)
        }

        function openFromBlobInternalAsync(pkg, blob, cb) {
            var zip = null;
            var state = 1;
            var intervalId = setInterval(function () {
                if (state === 1) {
                    zip = new JSZip(blob);
                    state = 2;
                    return;
                }
                if (state === 2) {
                    openFromZip(zip, pkg)
                    clearInterval(intervalId);
                    cb(pkg);
                    return;
                }
            }, 10);
        }

        function openFlatOpcFromXDoc(pkg, doc) {
            var root = doc.getRoot();
            pkg.ctXDoc = new XDocument(
                new XDeclaration("1.0", "utf-8", "yes"),
                new XElement(CT.Types,
                    new XAttribute("xmlns", ctNs.namespaceName),
                    new XElement(CT.Default,
                        new XAttribute("Extension", "rels"),
                        new XAttribute("ContentType", openXml.contentTypes.relationships)),
                    new XElement(CT.Default,
                        new XAttribute("Extension", "xml"),
                        new XAttribute("ContentType", "application/xml"))));
            root.elements(FLATOPC.part).forEach(function (p) {
                var uri = p.attribute(FLATOPC.name).value;
                var contentType = p.attribute(FLATOPC.contentType).value;
                var partType = "xml";
                if (!openXml.util.endsWith(contentType, "xml"))
                    partType = "base64";
                if (partType === "xml") {
                    var newPart = new openXml.OpenXmlPart(pkg, uri, contentType, partType,
                        new XDocument(p.element(FLATOPC.xmlData).elements().firstOrDefault()));
                    pkg.parts[uri] = newPart;
                    if (contentType !== 'application/vnd.openxmlformats-package.relationships+xml') {
                        pkg.ctXDoc.getRoot().add(
                            new XElement(CT.Override,
                                new XAttribute("PartName", uri),
                                new XAttribute("ContentType", contentType)));
                    }
                }
                if (partType === "base64") {
                    var newPart = new openXml.OpenXmlPart(pkg, uri, contentType, partType, p.element(FLATOPC.binaryData).value);
                    pkg.parts[uri] = newPart;
                    pkg.ctXDoc.getRoot().add(
                        new XElement(CT.Override,
                            new XAttribute("PartName", uri),
                            new XAttribute("ContentType", contentType)));
                }
            })
            var newPart = new openXml.OpenXmlPart(pkg, "[Content_Types].xml", null, "xml", pkg.ctXDoc);
            pkg.parts["[Content_Types].xml"] = newPart;
        }

        function openFromFlatOpcInternal(pkg, flatOpc) {
            var xDoc = XDocument.parse(flatOpc);
            openFlatOpcFromXDoc(pkg, xDoc);
        }
        
        function openFromFlatOpcInternalAsync(pkg, flatOpc, cb) {
            var doc = null;
            var state = 1;
            var intervalId = setInterval(function () {
                if (state === 1) {
                    doc = XDocument.parse(flatOpc);
                    state = 2;
                    return;
                }
                if (state === 2) {
                    openFlatOpcFromXDoc(pkg, doc);
                    clearInterval(intervalId);
                    cb(pkg);
                    return;
                }
            }, 10);
        }

        openXml.OpenXmlPackage = function (documentToOpen) {
            this.parts = {};
            this.ctXDoc = null;
            if (documentToOpen !== undefined) {
                if (openXml.util.isBase64(documentToOpen)) {
                    openFromBase64Internal(this, documentToOpen);
                }
                else if (typeof documentToOpen === 'string') {
                    openFromFlatOpcInternal(this, documentToOpen);
                }
                else {
                    openFromBlobInternal(this, documentToOpen);
                }
            }
        }

        openXml.OpenXmlPackage.prototype.openFromBase64 = function (base64data) {
            openFromBase64Internal(this, base64data);
        }
        
        openXml.OpenXmlPackage.prototype.openFromBase64Async = function (base64data, cb) {
            openFromBase64InternalAsync(this, base64data, cb);
        }

        openXml.OpenXmlPackage.prototype.openFromFlatOpc = function (flatOpc) {
            openFromFlatOpcInternal(this, flatOpc);
        }

        openXml.OpenXmlPackage.prototype.openFromFlatOpcAsync = function (flatOpc, cb) {
            openFromFlatOpcInternalAsync(this, flatOpc, cb);
        }

        openXml.OpenXmlPackage.prototype.openFromBlob = function (blob) {
            openFromBlobInternal(this, blob);
        }

        openXml.OpenXmlPackage.prototype.openFromBlobAsync = function (blob, cb) {
            openFromBlobInternalAsync(this, blob, cb);
        }

        function saveToZip(that) {
            var zip = new JSZip();
            for (var part in that.parts) {
                var ct;
                var thisPart = that.parts[part];
                // test for null because if the part was deleted, it will be set to null, not undefined
                if (thisPart !== null) {
                    if (part === "[Content_Types].xml") {
                        zip.file("[Content_Types].xml", that.ctXDoc.toString(false));
                    }
                    else {
                        var cte = that.ctXDoc.getRoot().elements(CT.Override).firstOrDefault(function (e) {
                            return e.attribute("PartName").value === part;
                        });
                        if (cte === null) {
                            var extension = part
                                .substring(part.lastIndexOf('.') + 1)
                                .toLowerCase();
                            var dct = that.ctXDoc.getRoot().elements(CT.Default).firstOrDefault(function (e) {
                                return e.attribute("Extension").value.toLowerCase() === extension;
                            });
                            if (!dct) {
                                throw "internal error";
                            }
                            ct = dct.attribute("ContentType").value;
                        }
                        else {
                            ct = cte.attribute("ContentType").value;
                        }

                        var name = part;
                        if (name.charAt(0) === "/") {
                            name = name.substring(1);
                        }

                        if (thisPart.partType === "binary") {
                            zip.file(name, thisPart.data, { binary: true});
                        }
                        if (thisPart.partType === "xml" && typeof thisPart.data === "string") {
                            var data = thisPart.data;
                            var utf8 = openXml.util.decode_utf8(data);
                            zip.file(name, utf8);
                        }
                        if (thisPart.partType === "xml" && thisPart.data.nodeType) {
                            zip.file(name, thisPart.data.toString(false));
                        }
                        if (thisPart.partType === "base64") {
                            var nsp = thisPart.data;
                            var sp = [];
                            var pos = 0;
                            var len = nsp.length;
                            while (true) {
                                if (pos >= len) { break; }
                                sp.push(nsp.substring(pos, pos + 76) + '\n');
                                pos += 76;
                            }
                            zip.file(name, sp.join(''), { base64: true });
                        }
                    }
                }
            }
            return zip;
        }

        openXml.OpenXmlPackage.prototype.saveToBase64 = function () {
            var zip = saveToZip(this);
            var b64 = zip.generate({
                base64: true,
                compression: "deflate",
                type: "base64"
            });
            return b64;
        };
        
        openXml.OpenXmlPackage.prototype.saveToBase64Async = function (cb) {
            var zip = null;
            var state = 1;
            var pkg = this;
            var intervalId = setInterval(function () {
                if (state === 1) {
                    zip = saveToZip(pkg);
                    state = 2;
                    return;
                }
                if (state === 2) {
                    var b64 = zip.generate({
                        base64: true,
                        compression: "deflate",
                        type: "base64"
                    });
                    clearInterval(intervalId);
                    cb(b64);
                    return;
                }
            }, 10);
        };

        openXml.OpenXmlPackage.prototype.saveToBlob = function () {
            var zip = saveToZip(this);
            var blob = zip.generate({
                blob: true,
                base64: false,
                type: "blob"
            });
            return blob;
        };

        openXml.OpenXmlPackage.prototype.saveToBlobAsync = function (cb) {
            var zip = null;
            var state = 1;
            var pkg = this;
            var intervalId = setInterval(function () {
                if (state === 1) {
                    zip = saveToZip(pkg);
                    state = 2;
                    return;
                }
                if (state === 2) {
                    var blob = zip.generate({
                        blob: true,
                        base64: false,
                        type: "blob"
                    });
                    clearInterval(intervalId);
                    cb(blob);
                    return;
                }
            }, 10);
        };

        openXml.OpenXmlPackage.prototype.saveToFlatOpc = function () {
            var xdec = new XDeclaration("1.0", "UTF-8", "yes");
            var nsa = new XAttribute(XNamespace.xmlns + "pkg",
                "http://schemas.microsoft.com/office/2006/xmlPackage");
            var pkg = new XElement(FLATOPC._package, nsa);
            var flatOpc = new XDocument(xdec,
                new XProcessingInstruction('mso-application', 'progid="Word.Document"'),
                pkg);
            for (var part in this.parts) {
                if (part !== "[Content_Types].xml") {
                    var ct;
                    var thisPart = this.parts[part];
                    // test for null because if the part was deleted, it will be set to null, not undefined
                    if (thisPart !== null) {
                        var cte = this.ctXDoc.getRoot().elements(CT.Override).firstOrDefault(function (e) {
                            var ctpn = e.attribute("PartName").value;
                            var thpn = part;
                            var b = ctpn === thpn;
                            return b;
                        });
                        if (cte === null) {
                            var extension = part
                                .substring(part.lastIndexOf('.') + 1).toLowerCase();
                            var dct = this.ctXDoc.getRoot().elements(CT.Default).firstOrDefault(function (e) {
                                return e.attribute("Extension").value.toLowerCase() === extension;
                            });
                            if (!dct) {
                                throw "internal error";
                            }
                            ct = dct.attribute("ContentType").value;
                        }
                        else {
                            ct = cte.attribute("ContentType").value;
                        }
                        var compression = null;
                        var partContent = null;

                        if (thisPart.partType === "xml" && typeof thisPart.data === "string") {
                            partContent = XDocument.parse(openXml.util.decode_utf8(thisPart.data)).root;
                            partContent = transformToEntities(partContent);
                        }
                        if (thisPart.partType === "xml" && thisPart.data.nodeType) {
                            if (thisPart.data.nodeType === "Document") {
                                partContent = thisPart.data.getRoot();
                            }
                            else if (thisPart.data.nodeType === "Element") {
                                partContent = thisPart.data;
                            }
                            else {
                                throw "internal error";
                            }
                        }
                        if (thisPart.partType === "base64") {
                            var nsp = thisPart.data;
                            var sp = [];
                            var pos = 0;
                            var len = nsp.length;
                            while (true) {
                                if (pos >= len) { break; }
                                sp.push(nsp.substring(pos, pos + 76) + '\n');
                                pos += 76;
                            }
                            partContent = sp.join('');
                            compression = 'store';
                        }
                        if (thisPart.partType === "binary") {
                            partContent = openXml.util.encode64(thisPart.data);
                            compression = 'store';
                        }

                        var nameAtt = new XAttribute(FLATOPC.name, part);
                        var ctAtt = new XAttribute(FLATOPC.contentType, ct);
                        var compressionAtt = null;
                        if (compression) {
                            compressionAtt = new XAttribute(FLATOPC.compression, compression);
                        }
                        var dataElement = null;
                        if (thisPart.partType === 'base64' || thisPart.partType === 'binary') {
                            dataElement = new XElement(FLATOPC.binaryData, partContent);
                        }
                        if (thisPart.partType === 'xml') {
                            dataElement = new XElement(FLATOPC.xmlData, partContent);
                        }
                        var partElement = new XElement(FLATOPC.part, nameAtt, ctAtt, compressionAtt, dataElement);
                        pkg.add(partElement);
                    }
                }
            }
            return flatOpc.toString(true);
        };
        
        openXml.OpenXmlPackage.prototype.saveToFlatOpcAsync = function (cb) {
            var xdec = new XDeclaration("1.0", "UTF-8", "yes");
            var nsa = new XAttribute(XNamespace.xmlns + "pkg",
                "http://schemas.microsoft.com/office/2006/xmlPackage");
            var pkg = new XElement(FLATOPC._package, nsa);
            var flatOpc = new XDocument(xdec,
                new XProcessingInstruction('mso-application', 'progid="Word.Document"'),
                pkg);

            var partQueue = [];
            for (var part in this.parts) {
                if (part !== "[Content_Types].xml") {
                    var thisPart = this.parts[part];
                    // test for null because if the part was deleted, it will be set to null, not undefined
                    if (thisPart !== null) {
                        partQueue.push(thisPart);
                    }
                }
            }

            var count = 0;
            var docpkg = this;
            var partCount = partQueue.length;

            var intervalId = setInterval(function () {
                if (count < partCount) {
                    for (var i = 0; i < 10; i++) {
                        var thisPart = partQueue[count];
                        var cte = docpkg.ctXDoc.getRoot().elements(CT.Override).firstOrDefault(function (e) {
                            var ctpn = e.attribute("PartName").value;
                            var thpn = thisPart.uri;
                            var b = ctpn === thpn;
                            return b;
                        });
                        var ct = null;
                        if (cte === null) {
                            var extension = thisPart.uri
                                .substring(thisPart.uri.lastIndexOf('.') + 1).toLowerCase();
                            var dct = docpkg.ctXDoc.getRoot().elements(CT.Default).firstOrDefault(function (e) {
                                return e.attribute("Extension").value.toLowerCase() === extension;
                            });
                            if (!dct) {
                                throw "internal error";
                            }
                            ct = dct.attribute("ContentType").value;
                        }
                        else {
                            ct = cte.attribute("ContentType").value;
                        }
                        var compression = null;
                        var partContent = null;

                        if (thisPart.partType === "xml" && typeof thisPart.data === "string") {
                            partContent = XDocument.parse(openXml.util.decode_utf8(thisPart.data)).root;
                            partContent = transformToEntities(partContent);
                        }
                        if (thisPart.partType === "xml" && thisPart.data.nodeType) {
                            if (thisPart.data.nodeType === "Document") {
                                partContent = thisPart.data.getRoot();
                            }
                            else if (thisPart.data.nodeType === "Element") {
                                partContent = thisPart.data;
                            }
                            else {
                                throw "internal error";
                            }
                        }
                        if (thisPart.partType === "base64") {
                            var nsp = thisPart.data;
                            var sp = [];
                            var pos = 0;
                            var len = nsp.length;
                            while (true) {
                                if (pos >= len) { break; }
                                sp.push(nsp.substring(pos, pos + 76) + '\n');
                                pos += 76;
                            }
                            partContent = sp.join('');
                            compression = 'store';
                        }
                        if (thisPart.partType === "binary") {
                            partContent = openXml.util.encode64(thisPart.data);
                            compression = 'store';
                        }

                        var nameAtt = new XAttribute(FLATOPC.name, thisPart.uri);
                        var ctAtt = new XAttribute(FLATOPC.contentType, ct);
                        var compressionAtt = null;
                        if (compression) {
                            compressionAtt = new XAttribute(FLATOPC.compression, compression);
                        }
                        var dataElement = null;
                        if (thisPart.partType === 'base64' || thisPart.partType === 'binary') {
                            dataElement = new XElement(FLATOPC.binaryData, partContent);
                        }
                        if (thisPart.partType === 'xml') {
                            dataElement = new XElement(FLATOPC.xmlData, partContent);
                        }
                        var partElement = new XElement(FLATOPC.part, nameAtt, ctAtt, compressionAtt, dataElement);
                        pkg.add(partElement);
                        count += 1;
                        if (count >= partCount) {
                            break;
                        }
                    }
                    return;
                }
                else {
                    clearInterval(intervalId);
                    cb(flatOpc.toString(true));
                    return;
                }
            }, 10);
        };


        openXml.OpenXmlPackage.prototype.addPart = function (uri, contentType, partType, data) {
            var ctEl = this.ctXDoc.getRoot().elements(CT.Override)
                .firstOrDefault(function (or) {
                    var orn = or.attribute("PartName").value;
                    if (uri === orn) {
                        return true;
                    }
                    return false;
                });
            if (ctEl || this.parts[uri]) {
                throw "Invalid operation, trying to add a part that already exists";
            }

            var newPart = new openXml.OpenXmlPart(this, uri, contentType, partType, data);
            this.parts[uri] = newPart;

            // update [Content_Types].xml
            this.ctXDoc.getRoot().add(
                new XElement(CT.Override,
                    new XAttribute("PartName", uri),
                    new XAttribute("ContentType", contentType)));

            return newPart;
        }
        
        openXml.OpenXmlPackage.prototype.deletePart = function (part) {
            var uri = part.uri;
            this.parts[uri] = null;

            // update [Content_Types].xml
            var ctEl = this.ctXDoc.getRoot().elements(CT.Override)
                .firstOrDefault(function (or) {
                    var orn = or.attribute("PartName").value;
                    if (uri === orn) {
                        return true;
                    }
                    return false;
                });
            if (ctEl) {
                ctEl.remove();
            }
        }
        
        function getRelationshipsFromRelsXml(pkg, part, relationshipPart) {
            var rxDoc = relationshipPart.getXDocument();
            var rels = rxDoc.getRoot().elements(PKGREL.Relationship)
                .select(function (r) {
                    var targetMode = null;
                    var tm = r.attribute("TargetMode");
                    if (tm) {
                        targetMode = tm.value;
                    }
                    var theRel = new openXml.OpenXmlRelationship(
                        pkg,
                        part,
                        r.attribute("Id").value,
                        r.attribute("Type").value,
                        r.attribute("Target").value,
                        targetMode);
                    return theRel;
                })
                .toArray();
            return rels;
        }

        openXml.OpenXmlPackage.prototype.getRelationships = function () {
            var rootRelationshipsPart = this.getPartByUri("/_rels/.rels");
            var rels = getRelationshipsFromRelsXml(this, null, rootRelationshipsPart);
            return rels;
        }
        
        openXml.OpenXmlPackage.prototype.getParts = function () {
            var parts = [];
            for (var part in this.parts) {
                if (this.parts[part].contentType !== openXml.contentTypes.relationships &&
                    part !== "[Content_Types].xml") {
                    parts.push(this.parts[part]);
                }
            }
            return parts;
        }
        
        openXml.OpenXmlPackage.prototype.getRelationshipsByRelationshipType = function (relationshipType) {
            var rootRelationshipsPart = this.getPartByUri("/_rels/.rels");
            var rxDoc = rootRelationshipsPart.getXDocument();
            var that = this;
            var rels = rxDoc.getRoot().elements(PKGREL.Relationship)
                .where(function (r) {
                    return r.attribute("Type").value === relationshipType;
                })
                .select(function (r) {
                    var targetMode = null;
                    var tm = r.attribute("TargetMode");
                    if (tm) {
                        targetMode = tm.value;
                    }
                    var theRel = new openXml.OpenXmlRelationship(
                        that,
                        null,
                        r.attribute("Id").value,
                        relationshipType,
                        r.attribute("Target").value,
                        targetMode);
                    return theRel;
                })
                .toArray();
            return rels;
        }
        
        openXml.OpenXmlPackage.prototype.getPartsByRelationshipType = function (relationshipType) {
            var rels = this.getRelationshipsByRelationshipType(relationshipType);
            var parts = [];
            for (var i = 0; i < rels.length; ++i) {
                var part = this.getPartByUri(rels[i].targetFullName);
                parts.push(part);
            }
            return parts;
        }

        openXml.OpenXmlPackage.prototype.getPartByRelationshipType = function (relationshipType) {
            var parts = this.getPartsByRelationshipType(relationshipType);
            if (parts.length < 1) {
                return null;
            }
            return parts[0];
        }
        
        openXml.OpenXmlPackage.prototype.getRelationshipsByContentType = function (contentType) {
            var rootRelationshipsPart = this.getPartByUri("/_rels/.rels");
            if (rootRelationshipsPart) {
                var allRels = getRelationshipsFromRelsXml(this, null, rootRelationshipsPart);
                var rels = [];
                for (var i = 0; i < allRels.length; ++i) {
                    if (allRels[i].targetMode === "External") {
                        continue;
                    }
                    var ct = this.getContentType(allRels[i].targetFullName);
                    if (ct !== contentType) {
                        continue;
                    }
                    rels.push(allRels[i]);
                }
                return rels;
            }
            return [];
        }
        
        openXml.OpenXmlPackage.prototype.getPartsByContentType = function (contentType) {
            var rels = this.getRelationshipsByContentType(contentType);
            var parts = [];
            for (var i = 0; i < rels.length; ++i) {
                var part = this.getPartByUri(rels[i].targetFullName);
                parts.push(part);
            }
            return parts;
        };

        openXml.OpenXmlPackage.prototype.getRelationshipById = function (rId) {
            var rel = Enumerable.from(this.getRelationships())
                .firstOrDefault(function (r) {
                    return r.relationshipId == rId;
                });
            return rel;
        }
        
        openXml.OpenXmlPackage.prototype.getPartById = function (rId) {
            var rel = Enumerable.from(this.getRelationships())
                .firstOrDefault(function (r) {
                    return r.relationshipId == rId;
                });
            if (!rel) {
                return null;
            }
            var part = this.getPartByUri(rel.targetFullName);
            return part;
        }
        
        openXml.OpenXmlPackage.prototype.getPartByUri = function (uri) {
            var part = this.parts[uri];
            return part;
        }

        function addRelationshipToRelPart(part, relationshipId, relationshipType, target, targetMode) {
            var rxDoc = part.getXDocument();
            var tm = null;
            if (targetMode !== "Internal")
                tm = new XAttribute("TargetMode", "External");
            rxDoc.getRoot().add(
                new XElement(PKGREL.Relationship,
                    new XAttribute("Id", relationshipId),
                    new XAttribute("Type", relationshipType),
                    new XAttribute("Target", target),
                    tm));
        }

        openXml.OpenXmlPackage.prototype.addRelationship = function (relationshipId, relationshipType, target, targetMode) {
            if (!targetMode) {
                targetMode = "Internal";
            }
            var rootRelationshipPart = this.getPartByUri("/_rels/.rels");
            if (!rootRelationshipPart) {
                rootRelationshipsPart = this.addPart("/_rels/.rels", this.contentTypes.relationships, "xml",
                    new XDocument(
                        new XElement(PKGREL.Relationships,
                            new XAttribute("xmlns", pkgRelNs.namespaceName))));
            }
            addRelationshipToRelPart(rootRelationshipPart, relationshipId, relationshipType, target, targetMode);
        }

        openXml.OpenXmlPackage.prototype.deleteRelationship = function (relationshipId) {
            var rootRelationshipsPart = this.getPartByUri("/_rels/.rels");
            var rxDoc = rootRelationshipsPart.getXDocument();
            var rxe = rxDoc.getRoot().elements(PKGREL.Relationship)
                .firstOrDefault(function (r) {
                    return r.attribute("Id").value == relationshipId;
                });
            if (rxe) {
                rxe.remove();
            }
        }

        openXml.OpenXmlPackage.prototype.getContentType = function (uri) {
            var ctfile, ct, c;
                
            ct = this.ctXDoc.descendants(CT.Override)
                .firstOrDefault(function (o) {
                    return o.attribute("PartName").value === uri;
                });
            if (ct === null) {
                var exti = uri.lastIndexOf(".");
                var ext = uri.substring(exti + 1);
                var dct = this.ctXDoc.descendants(CT.Default)
                    .firstOrDefault(function (d) {
                        return d.attribute("Extension").value === ext;
                    });
                if (dct !== null) {
                    return dct.attribute("ContentType").value;
                }
                return null;
            }
            c = ct.attribute("ContentType").value;
            return c;
        };

        // The following on OpenXmlPackage because they have a relationship from the package to the part.
        openXml.OpenXmlPackage.prototype.mainDocumentPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.mainDocument);
        };

        openXml.OpenXmlPackage.prototype.coreFilePropertiesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.coreFileProperties);
        };

        openXml.OpenXmlPackage.prototype.extendedFilePropertiesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.extendedFileProperties);
        };

        openXml.OpenXmlPackage.prototype.workbookPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.workbook);
        };

        openXml.OpenXmlPackage.prototype.customFilePropertiesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.customFileProperties);
        };

        openXml.OpenXmlPackage.prototype.presentationPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.presentation);
        };

        openXml.OpenXmlPackage.prototype.contentParts = function () {
            var main = this.mainDocumentPart();
            var pa = [main];
            var headers = main.headerParts();
            for (var i = 0; i < headers.length; i++) {
                pa.push(headers[i]);
            }
            var footers = main.footerParts();
            for (var i = 0; i < footers.length; i++) {
                pa.push(footers[i]);
            }
            var endNotes = main.endnotesPart();
            var footNotes = main.footnotesPart();
            if (endNotes) {
                pa.push(endNotes);
            }
            if (footNotes) {
                pa.push(footNotes);
            }
            return pa;
        };
        
        /*********** OpenXmlPart ***********/

        openXml.OpenXmlPart = function (pkg, uri, contentType, partType, data) {
            this.pkg = pkg;      // reference to the parent package
            this.uri = uri;      // the part is also indexed by uri in the package
            this.contentType = contentType;
            this.partType = partType;
            if (uri === "[Content_Types].xml") {
                partType = "xml";
            }
            this.data = data;
        };
        
        openXml.OpenXmlPart.prototype.getXDocument = function () {
            if (this.partType === 'xml' && typeof this.data === 'string') {
                var data = this.data;
                var utf = openXml.util.decode_utf8(data);
                this.data = XDocument.parse(utf);
                this.partType = 'xml';
            }
            return this.data;
        };

        openXml.OpenXmlPart.prototype.putXDocument = function (xDoc) {
            if (xDoc) {
                this.data = xDoc;
            }
        };

        function getRelsPartUriOfPart(part) {
            var uri = part.uri;
            var lastSlash = uri.lastIndexOf('/');
            var partFileName = uri.substring(lastSlash + 1);
            var relsFileName = uri.substring(0, lastSlash) + "/_rels/" + partFileName + ".rels";
            return relsFileName;
        }
        
        function getRelsPartOfPart(part) {
            var relsFileName = getRelsPartUriOfPart(part);
            var relsPart = part.pkg.getPartByUri(relsFileName);
            return relsPart;
        }
        
        // returns all relationships
        openXml.OpenXmlPart.prototype.getRelationships = function () {
            var relsPart = getRelsPartOfPart(this);
            if (relsPart) {
                var rels = getRelationshipsFromRelsXml(null, this, relsPart);
                return rels;
            }
            return [];
        }
        
        // returns all related parts of the source part
        openXml.OpenXmlPart.prototype.getParts = function () {
            var parts = [];
            var rels = this.getRelationships();
            for (var i = 0; i < rels.length; ++i) {
                if (rels[i].targetMode === "Internal") {
                    var part = this.pkg.getPartByUri(rels[i].targetFullName);
                    parts.push(part);
                }
            }
            return parts;
        }
        
        openXml.OpenXmlPart.prototype.getRelationshipsByRelationshipType = function (relationshipType) {
            var rels = [];
            var allRels = this.getRelationships();
            for (var i = 0; i < allRels.length; ++i) {
                if (allRels[i].relationshipType === relationshipType) {
                    rels.push(allRels[i]);
                }
            }
            return rels;
        }
        
        // returns all related parts of the source part with the given relationship type
        openXml.OpenXmlPart.prototype.getPartsByRelationshipType = function (relationshipType) {
            var parts = [];
            var rels = this.getRelationshipsByRelationshipType(relationshipType);
            for (var i = 0; i < rels.length; ++i) {
                var part = this.pkg.getPartByUri(rels[i].targetFullName);
                parts.push(part);
            }
            return parts;
        }

        openXml.OpenXmlPart.prototype.getPartByRelationshipType = function (relationshipType) {
            var parts = this.getPartsByRelationshipType(relationshipType);
            if (parts.length < 1) {
                return null;
            }
            return parts[0];
        }

        openXml.OpenXmlPart.prototype.getRelationshipsByContentType = function (contentType) {
            var rels = [];
            var allRels = this.getRelationships();
            for (var i = 0; i < allRels.length; ++i) {
                if (allRels[i].targetMode === "Internal") {
                    var ct = this.pkg.getContentType(allRels[i].targetFullName);
                    if (ct === contentType) {
                        rels.push(allRels[i]);
                    }
                }
            }
            return rels;
        }
        
        openXml.OpenXmlPart.prototype.getPartsByContentType = function (contentType) {
            var parts = [];
            var rels = this.getRelationshipsByContentType(contentType);
            for (var i = 0; i < rels.length; ++i) {
                var part = this.pkg.getPartByUri(rels[i].targetFullName);
                parts.push(part);
            }
            return parts;
        }

        openXml.OpenXmlPart.prototype.getRelationshipById = function (relationshipId) {
            var rels = this.getRelationships();
            for (var i = 0; i < rels.length; ++i) {
                if (rels[i].relationshipId === relationshipId) {
                    return rels[i];
                }
            }
            return null;
        }

        openXml.OpenXmlPart.prototype.getPartById = function (relationshipId) {
            var rel = this.getRelationshipById(relationshipId);
            if (rel) {
                var part = this.pkg.getPartByUri(rel.targetFullName);
                return part;
            }
            return null;
        }

        // if targetMode is not set, then it is Internal
        openXml.OpenXmlPart.prototype.addRelationship = function (relationshipId, relationshipType, target, targetMode) {
            var relsPart = getRelsPartOfPart(this);
            if (!relsPart) {
                var relsPartUri = getRelsPartUriOfPart(this);
                relsPart = this.pkg.addPart(relsPartUri, openXml.contentTypes.relationships, "xml",
                    new XDocument(
                        new XElement(PKGREL.Relationships,
                            new XAttribute(XNamespace.xmlns + "rel", pkgRelNs.namespaceName))));
            }
            addRelationshipToRelPart(relsPart, relationshipId, relationshipType, target, targetMode);
        }

        openXml.OpenXmlPart.prototype.deleteRelationship = function (relationshipId) {
            var relsPart = getRelsPartOfPart(this);
            if (relsPart) {
                var relsPartXDoc = relsPart.getXDocument();
                var theRel = relsPartXDoc.getRoot().elements(PKGREL.Relationship).firstOrDefault(function (r) {
                    if (r.attribute("Id").value === relationshipId) {
                        return true;
                    }
                });
            }
            if (theRel) {
                theRel.remove();
            }
        }

        openXml.OpenXmlPart.prototype.wordprocessingCommentsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.wordprocessingComments);
        };

        openXml.OpenXmlPart.prototype.fontTablePart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.fontTable);
        };

        openXml.OpenXmlPart.prototype.numberingDefinitionsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.numberingDefinitions);
        };

        openXml.OpenXmlPart.prototype.headerParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.header);
        };

        openXml.OpenXmlPart.prototype.footerParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.footer);
        };

        openXml.OpenXmlPart.prototype.customXmlPropertiesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.customXmlProperties);
        };

        openXml.OpenXmlPart.prototype.footnotesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.footnotes);
        };

        openXml.OpenXmlPart.prototype.endnotesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.endnotes);
        };

        openXml.OpenXmlPart.prototype.styleDefinitionsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.styles);
        };

        openXml.OpenXmlPart.prototype.webSettingsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.webSettings);
        };

        openXml.OpenXmlPart.prototype.documentSettingsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.documentSettings);
        };

        openXml.OpenXmlPart.prototype.glossaryDocumentPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.glossaryDocument);
        };

        openXml.OpenXmlPart.prototype.calculationChainPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.calculationChain);
        };

        openXml.OpenXmlPart.prototype.cellMetadataPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.cellMetadata);
        };

        openXml.OpenXmlPart.prototype.chartsheetParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.chartsheet);
        };

        openXml.OpenXmlPart.prototype.sharedStringTablePart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.sharedStringTable);
        };

        openXml.OpenXmlPart.prototype.themePart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.theme);
        };

        openXml.OpenXmlPart.prototype.thumbnailPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.thumbnail);
        };

        openXml.OpenXmlPart.prototype.workbookRevisionHeaderPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.workbookRevisionHeader);
        };

        openXml.OpenXmlPart.prototype.workbookStylesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.workbookStyles);
        };

        openXml.OpenXmlPart.prototype.worksheetParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.worksheet);
        };

        openXml.OpenXmlPart.prototype.drawingsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.drawings);  // todo is this plural?
        };

        openXml.OpenXmlPart.prototype.imageParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.image);
        };

        openXml.OpenXmlPart.prototype.pivotTableParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.pivotTable);
        };

        openXml.OpenXmlPart.prototype.queryTableParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.queryTable);
        };

        openXml.OpenXmlPart.prototype.tableDefinitionParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.tableDefinition);
        };

        openXml.OpenXmlPart.prototype.timeLineParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.timeLine);
        };

        openXml.OpenXmlPart.prototype.worksheetCommentsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.worksheetComments);
        };

        openXml.OpenXmlPart.prototype.commentAuthorsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.commentAuthors);
        };

        openXml.OpenXmlPart.prototype.customXmlParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.customXml);
        };

        openXml.OpenXmlPart.prototype.fontParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.font);
        };

        openXml.OpenXmlPart.prototype.handoutMasterPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.handoutMaster);
        };

        openXml.OpenXmlPart.prototype.notesMasterPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.notesMaster);
        };

        openXml.OpenXmlPart.prototype.notesSlidePart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.notesSlide);
        };

        openXml.OpenXmlPart.prototype.presentationPropertiesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.presentationProperties);
        };

        openXml.OpenXmlPart.prototype.slideMasterParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.slideMaster);
        };

        openXml.OpenXmlPart.prototype.slideParts = function () {
            return this.getPartsByRelationshipType(openXml.relationshipTypes.slide);
        };

        openXml.OpenXmlPart.prototype.tableStylesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.tableStyles);
        };

        openXml.OpenXmlPart.prototype.themePart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.theme);
        };

        openXml.OpenXmlPart.prototype.userDefinedTagsPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.userDefinedTags);
        };

        openXml.OpenXmlPart.prototype.viewPropertiesPart = function () {
            return this.getPartByRelationshipType(openXml.relationshipTypes.viewProperties);
        };

        /******************************** OpenXmlRelationship ********************************/

        openXml.OpenXmlRelationship = function (pkg, part, relationshipId, relationshipType, target, targetMode) {
            this.fromPkg = pkg;        // if from a part, this will be null
            this.fromPart = part;      // if from a package, this will be null;
            this.relationshipId = relationshipId;
            this.relationshipType = relationshipType;
            this.target = target;
            this.targetMode = targetMode;
            if (!targetMode)
                this.targetMode = "Internal";

            var workingTarget = target;
            var workingCurrentPath;
            if (this.fromPkg) {
                workingCurrentPath = "/";
            }
            if (this.fromPart) {
                var slashIndex = this.fromPart.uri.lastIndexOf('/');
                if (slashIndex === -1) {
                    workingCurrentPath = "/";
                }
                else {
                    workingCurrentPath = this.fromPart.uri.substring(0, slashIndex) + "/";
                }
            }
            if (targetMode === "External") {
                this.targetFullName = this.target;
                return;
            }
            while (openXml.util.startsWith(workingTarget, '../')) {
                if (openXml.util.endsWith(workingCurrentPath, '/')) {
                    workingCurrentPath = workingCurrentPath.substring(0, workingCurrentPath.length - 1);
                }
                var indexOfLastSlash = workingCurrentPath.lastIndexOf('/');
                if (indexOfLastSlash === -1) {
                    throw "internal error when processing relationships";
                }
                workingCurrentPath = workingCurrentPath.substring(0, indexOfLastSlash + 1);
                workingTarget = workingTarget.substring(3);
            }

            this.targetFullName = workingCurrentPath + workingTarget;
        }
        
        /******************************** OpenXmlRelationship ********************************/

        openXml.util = {};

        openXml.util.isBase64 = function (str) {
            if (typeof str !== 'string') {
                return false;
            }
            var sub = str.substring(0, 500);
            for (var i = 0; i < sub.length; i++) {
                var s = sub[i];
                if (s >= 'A' && s <= 'Z') continue;
                if (s >= 'a' && s <= 'z') continue;
                if (s >= '0' && s <= '9') continue;
                if (s === '+' || s === '/') continue;
                return false;
            }
            return true;
        }

        openXml.util.trim = function (str, arg) {
            var pat1, pat2;

            if (!arg) {
                arg = '\\s\\xA0\\t';
            }
            pat1 = '^[' + arg + ']+';
            pat2 = '[' + arg + ']+$';
            return (str.replace(new RegExp(pat1), "").replace(new RegExp(pat2), ""));
        };

        openXml.util.trimStart = function (str, arg) {
            var pat1;

            if (!arg) {
                arg = '\\s\\xA0\\t';
            }
            pat1 = '^[' + arg + ']+';
            return (str.replace(new RegExp(pat1), ""));
        };

        openXml.util.trimEnd = function (str, arg) {
            var pat2;

            if (!arg) {
                arg = '\\s\\xA0\\t';
            }
            pat2 = '[' + arg + ']+$';
            return (str.replace(new RegExp(pat2), ""));
        };

        openXml.util.startsWith = function (str, mat) {
            var m = str.match("^" + mat);
            if (m) {
                return m.join('') === mat;
            }
            return false;
        };

        openXml.util.endsWith = function (str, mat) {
            var m = str.match(mat + "$");
            if (m) {
                return m.join('') === mat;
            }
            return false;
        };

        openXml.util.trimEndingNewlines = function (str) {
            var newStr;

            newStr = str;
            while (newStr.substr(newStr.length - 1) === '\n') {
                newStr = newStr.substr(0, newStr.length - 1);
            }
            return newStr;
        };

        openXml.util.bucketTimer = {};

        var bucketTimer = openXml.util.bucketTimer;

        bucketTimer.init = function () {
            var prop;

            bucketTimer.currentTime = (new Date()).getTime();
            bucketTimer.beginningTime = bucketTimer.currentTime;
            bucketTimer.currentBucket = '';
            for (prop in bucketTimer) {
                if (typeof bucketTimer[prop] !== 'function' &&
                            prop !== 'currentTime' &&
                            prop !== 'currentBucket' &&
                            prop !== 'beginningTime') {
                    delete bucketTimer[prop];
                }
            }
        };

        bucketTimer.bucket = function (b) {
            var ct, diff, z;

            ct = (new Date()).getTime();
            diff = ct - bucketTimer.currentTime;
            if (bucketTimer.currentBucket !== '') {
                if (bucketTimer[bucketTimer.currentBucket]) {
                    bucketTimer[bucketTimer.currentBucket].time += diff;
                    bucketTimer[bucketTimer.currentBucket].count += 1;
                }
                else {
                    z = {};
                    z.time = diff;
                    z.count = 1;
                    bucketTimer[bucketTimer.currentBucket] = z;
                }
            }
            bucketTimer.currentTime = ct;
            bucketTimer.currentBucket = b;
        };

        openXml.util.lPad = function (str, padLength, padChar) {
            //Use: openXml.util.lPad(string, Number of Characters, Character to Pad)
            //Returns: string with the padChar appended to the left until the string
            // is padLength in length
            var p = Math.max((padLength + 1) - str.length, 0);
            return Array(p).join(padChar) + str;
        };

        openXml.util.rPad = function (str, padLength, padChar) {
            //Use: openXml.util.rPad(string, Number of Characters, Character to Pad)
            //Returns: string with the padChar appended to the right until the string 
            // is padLength in length
            var p = Math.max((padLength + 1) - str.length, 0);  //ignore jslint
            return str + Array(p).join(padChar);
        };

        bucketTimer.dump = function () {
            var prop, s, a, a2, a3, a4, diffFromBeginning, i;

            bucketTimer.bucket('');
            s = '';
            a = [];
            for (prop in bucketTimer) {
                if (typeof bucketTimer[prop] !== 'function' &&
                            prop !== 'currentTime' &&
                            prop !== 'currentBucket' &&
                            prop !== 'beginningTime') {
                    a.push(openXml.util.rPad(prop.toString(), 50, "-") + ': ' +
                        openXml.util.lPad(bucketTimer[prop].time.toString(), 8, " ") +
                        " " + openXml.util.lPad(bucketTimer[prop].count.toString(), 8, " "));
                }
            }
            a2 = Enumerable.from(a);
            a3 = a2.orderBy("z=>z");
            a4 = a3.toArray();
            for (i = 0; i < a4.length; i += 1) {
                s += a4[i] + '\n';
            }

            diffFromBeginning = bucketTimer.currentTime - bucketTimer.beginningTime;
            s += "total time: " + diffFromBeginning + "\n";
            return s;
        };

        openXml.util.encode_utf8 = function (s) {
            return unescape(encodeURIComponent(s));
        }

        openXml.util.decode_utf8 = function (s) {
            return decodeURIComponent(escape(s));
        }

        var keyStr = "ABCDEFGHIJKLMNOP" +
                       "QRSTUVWXYZabcdef" +
                       "ghijklmnopqrstuv" +
                       "wxyz0123456789+/" +
                       "=";

        function getChar(input, i) {
            if (input.charAt(i) === '%') {
                i++;
                var h1 = input.charAt(i++);
                h1 += input.charAt(i++);
                var chr = parseInt(h1, 16);
                return {
                    chr: chr,
                    i: i
                }
            }
            var chr = input.charCodeAt(i);
            i++;
            return {
                chr: chr,
                i: i
            }
        }
        
        openXml.util.encode64 = function (input) {
            input = escape(input);
            var output = "";
            var chr1, chr2, chr3 = "";
            var enc1, enc2, enc3, enc4 = "";

            var i = 0;

            do {
                var r = getChar(input, i);
                chr1 = r.chr;
                i = r.i;
                var r = getChar(input, i);
                chr2 = r.chr;
                i = r.i;
                var r = getChar(input, i);
                chr3 = r.chr;
                i = r.i;

                enc1 = chr1 >> 2;
                enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
                enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
                enc4 = chr3 & 63;

                if (isNaN(chr2)) {
                    enc3 = enc4 = 64;
                } else if (isNaN(chr3)) {
                    enc4 = 64;
                }

                output = output +
                   keyStr.charAt(enc1) +
                   keyStr.charAt(enc2) +
                   keyStr.charAt(enc3) +
                   keyStr.charAt(enc4);
                chr1 = chr2 = chr3 = "";
                enc1 = enc2 = enc3 = enc4 = "";
            } while (i < input.length);

            return output;
        }
        
        openXml.util.decode64 = function (input) {
            var output = "";
            var chr1, chr2, chr3 = "";
            var enc1, enc2, enc3, enc4 = "";
            var i = 0;

            // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
            var base64test = /[^A-Za-z0-9\+\/\=]/g;
            if (base64test.exec(input)) {
                alert("There were invalid base64 characters in the input text.\n" +
                      "Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='\n" +
                      "Expect errors in decoding.");
            }
            input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

            do {
                enc1 = keyStr.indexOf(input.charAt(i++));
                enc2 = keyStr.indexOf(input.charAt(i++));
                enc3 = keyStr.indexOf(input.charAt(i++));
                enc4 = keyStr.indexOf(input.charAt(i++));

                chr1 = (enc1 << 2) | (enc2 >> 4);
                chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
                chr3 = ((enc3 & 3) << 6) | enc4;

                output = output + String.fromCharCode(chr1);

                if (enc3 != 64) {
                    output = output + String.fromCharCode(chr2);
                }
                if (enc4 != 64) {
                    output = output + String.fromCharCode(chr3);
                }

                chr1 = chr2 = chr3 = "";
                enc1 = enc2 = enc3 = enc4 = "";

            } while (i < input.length);

            return unescape(output);
        }
        
        openXml.entityMap =
        {
            "160": "nbsp",
            "161": "iexcl",
            "162": "cent",
            "163": "pound",
            "164": "curren",
            "165": "yen",
            "166": "brvbar",
            "167": "sect",
            "168": "uml",
            "169": "copy",
            "170": "ordf",
            "171": "laquo",
            "172": "not",
            "173": "shy",
            "174": "reg",
            "175": "macr",
            "176": "deg",
            "177": "plusmn",
            "178": "sup2",
            "179": "sup3",
            "180": "acute",
            "181": "micro",
            "182": "para",
            "183": "middot",
            "184": "cedil",
            "185": "sup1",
            "186": "ordm",
            "187": "raquo",
            "188": "frac14",
            "189": "frac12",
            "190": "frac34",
            "191": "iquest",
            "192": "Agrave",
            "193": "Aacute",
            "194": "Acirc",
            "195": "Atilde",
            "196": "Auml",
            "197": "Aring",
            "198": "AElig",
            "199": "Ccedil",
            "200": "Egrave",
            "201": "Eacute",
            "202": "Ecirc",
            "203": "Euml",
            "204": "Igrave",
            "205": "Iacute",
            "206": "Icirc",
            "207": "Iuml",
            "208": "ETH",
            "209": "Ntilde",
            "210": "Ograve",
            "211": "Oacute",
            "212": "Ocirc",
            "213": "Otilde",
            "214": "Ouml",
            "215": "times",
            "216": "Oslash",
            "217": "Ugrave",
            "218": "Uacute",
            "219": "Ucirc",
            "220": "Uuml",
            "221": "Yacute",
            "222": "THORN",
            "223": "szlig",
            "224": "agrave",
            "225": "aacute",
            "226": "acirc",
            "227": "atilde",
            "228": "auml",
            "229": "aring",
            "230": "aelig",
            "231": "ccedil",
            "232": "egrave",
            "233": "eacute",
            "234": "ecirc",
            "235": "euml",
            "236": "igrave",
            "237": "iacute",
            "238": "icirc",
            "239": "iuml",
            "240": "eth",
            "241": "ntilde",
            "242": "ograve",
            "243": "oacute",
            "244": "ocirc",
            "245": "otilde",
            "246": "ouml",
            "247": "divide",
            "248": "oslash",
            "249": "ugrave",
            "250": "uacute",
            "251": "ucirc",
            "252": "uuml",
            "253": "yacute",
            "254": "thorn",
            "255": "yuml",
            "338": "OElig",
            "339": "oelig",
            "352": "Scaron",
            "353": "scaron",
            "376": "Yuml",
            "402": "fnof",
            "710": "circ",
            "732": "tilde",
            "913": "Alpha",
            "914": "Beta",
            "915": "Gamma",
            "916": "Delta",
            "917": "Epsilon",
            "918": "Zeta",
            "919": "Eta",
            "920": "Theta",
            "921": "Iota",
            "922": "Kappa",
            "923": "Lambda",
            "924": "Mu",
            "925": "Nu",
            "926": "Xi",
            "927": "Omicron",
            "928": "Pi",
            "929": "Rho",
            "931": "Sigma",
            "932": "Tau",
            "933": "Upsilon",
            "934": "Phi",
            "935": "Chi",
            "936": "Psi",
            "937": "Omega",
            "945": "alpha",
            "946": "beta",
            "947": "gamma",
            "948": "delta",
            "949": "epsilon",
            "950": "zeta",
            "951": "eta",
            "952": "theta",
            "953": "iota",
            "954": "kappa",
            "955": "lambda",
            "956": "mu",
            "957": "nu",
            "958": "xi",
            "959": "omicron",
            "960": "pi",
            "961": "rho",
            "962": "sigmaf",
            "963": "sigma",
            "964": "tau",
            "965": "upsilon",
            "966": "phi",
            "967": "chi",
            "968": "psi",
            "969": "omega",
            "977": "thetasym",
            "978": "upsih",
            "982": "piv",
            "8194": "ensp",
            "8195": "emsp",
            "8201": "thinsp",
            "8204": "zwnj",
            "8205": "zwj",
            "8206": "lrm",
            "8207": "rlm",
            "8211": "ndash",
            "8212": "mdash",
            "8216": "lsquo",
            "8217": "rsquo",
            "8218": "sbquo",
            "8220": "ldquo",
            "8221": "rdquo",
            "8222": "bdquo",
            "8224": "dagger",
            "8225": "Dagger",
            "8226": "bull",
            "8230": "hellip",
            "8240": "permil",
            "8242": "prime",
            "8243": "Prime",
            "8249": "lsaquo",
            "8250": "rsaquo",
            "8254": "oline",
            "8260": "frasl",
            "8364": "euro",
            "8465": "image",
            "8472": "weierp",
            "8476": "real",
            "8482": "trade",
            "8501": "alefsym",
            "8592": "larr",
            "8593": "uarr",
            "8594": "rarr",
            "8595": "darr",
            "8596": "harr",
            "8629": "crarr",
            "8656": "lArr",
            "8657": "uArr",
            "8658": "rArr",
            "8659": "dArr",
            "8660": "hArr",
            "8704": "forall",
            "8706": "part",
            "8707": "exist",
            "8709": "empty",
            "8711": "nabla",
            "8712": "isin",
            "8713": "notin",
            "8715": "ni",
            "8719": "prod",
            "8721": "sum",
            "8722": "minus",
            "8727": "lowast",
            "8730": "radic",
            "8733": "prop",
            "8734": "infin",
            "8736": "ang",
            "8743": "and",
            "8744": "or",
            "8745": "cap",
            "8746": "cup",
            "8747": "int",
            "8756": "there4",
            "8764": "sim",
            "8773": "cong",
            "8776": "asymp",
            "8800": "ne",
            "8801": "equiv",
            "8804": "le",
            "8805": "ge",
            "8834": "sub",
            "8835": "sup",
            "8836": "nsub",
            "8838": "sube",
            "8839": "supe",
            "8853": "oplus",
            "8855": "otimes",
            "8869": "perp",
            "8901": "sdot",
            "8968": "lceil",
            "8969": "rceil",
            "8970": "lfloor",
            "8971": "rfloor",
            "9001": "lang",
            "9002": "rang",
            "9674": "loz",
            "9824": "spades",
            "9827": "clubs",
            "9829": "hearts",
            "9830": "diams"
        };
        
        function convertToEntities(text) {
            var o, len, i, c, cs, em, grouped, retValue, str;

            if (text === null) {
                return null;
            }
            o = [];
            len = text.length;
            for (i = 0; i < len; i += 1) {
                c = text.charCodeAt(i);
                if (c === 0xf0b7 ||
                    c === 0xf0a7 ||
                    c === 0xf076 ||
                    c === 0xf0d8 ||
                    c === 0xf0a8 ||
                    c === 0xf0fc ||
                    c === 0xf0e0 ||
                    c === 0xf0b2) {
                    o.push(new XEntity("bull"));
                    continue; //ignore jslint
                }
                if (c >= 0xf000) {
                    o.push(new XEntity("loz"));
                    continue; //ignore jslint
                }
                if (c >= 128) {
                    cs = c.toString();
                    em = openXml.entityMap[cs];
                    if (em) {
                        o.push(new XEntity(em));
                        continue; //ignore jslint
                    }
                    var zz = c.toString(16);//ignore jslint
                    o.push(new XEntity("#" + zz));
                    //o.push("ÆŒŠ" + c.toString());
                    continue; //ignore jslint
                }
                o.push(text.charAt(i));
            }
            grouped = new XEnumerable(Enumerable.from(o)).groupAdjacent(function (e) {
                var b = typeof e === 'string';
                return b;
            });
            retValue = grouped.select(function (g) {
                if (g.Key === true) {
                    str = g.Group.toJoinedString();
                    return str;
                }
                return g.Group;
            });
            return retValue;
        };

        function transformToEntities(node) {
            if (node.nodeType === 'Element') {
                return new XElement(node.name,
                    node.attributes(),
                    node.nodes().select(function (n) { return transformToEntities(n); }));
            }
            if (node.nodeType === 'Text') {
                return convertToEntities(node.value);
            }
            return node;
        };

        // ********************* content types ***********************
        openXml.contentTypes = {
            calculationChain: "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml",
            cellMetadata: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml",
            chart: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",
            chartColorStyle: "application/vnd.ms-office.chartcolorstyle+xml",
            chartDrawing: "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml",
            chartsheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml",
            chartStyle: "application/vnd.ms-office.chartstyle+xml",
            commentAuthors: "application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml",
            connections: "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml",
            coreFileProperties: "application/vnd.openxmlformats-package.core-properties+xml",
            customFileProperties: "application/vnd.openxmlformats-officedocument.custom-properties+xml",
            customization: "application/vnd.ms-word.keyMapCustomizations+xml",
            customProperty: "application/vnd.openxmlformats-officedocument.spreadsheetml.customProperty",
            customXmlProperties: "application/vnd.openxmlformats-officedocument.customXmlProperties+xml",
            diagramColors: "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml",
            diagramData: "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml",
            diagramLayoutDefinition: "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml",
            diagramPersistLayout: "application/vnd.ms-office.drawingml.diagramDrawing+xml",
            diagramStyle: "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml",
            dialogsheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml",
            digitalSignatureOrigin: "application/vnd.openxmlformats-package.digital-signature-origin",
            documentSettings: "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
            drawings: "application/vnd.openxmlformats-officedocument.drawing+xml",
            endnotes: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
            excelAttachedToolbars: "application/vnd.ms-excel.attachedToolbars",
            extendedFileProperties: "application/vnd.openxmlformats-officedocument.extended-properties+xml",
            externalWorkbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml",
            fontData: "application/x-fontdata",
            fontTable: "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml",
            footer: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
            footnotes: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
            gif: "image/gif",
            glossaryDocument: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml",
            handoutMaster: "application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml",
            header: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
            jpeg: "image/jpeg",
            mainDocument: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
            notesMaster: "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml",
            notesSlide: "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml",
            numberingDefinitions: "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
            pict: "image/pict",
            pivotTable: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml",
            pivotTableCacheDefinition: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml",
            pivotTableCacheRecords: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml",
            png: "image/png",
            presentation: "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml",
            presentationProperties: "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml",
            presentationTemplate: "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml",
            queryTable: "application/vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml",
            relationships: "application/vnd.openxmlformats-package.relationships+xml",
            ribbonAndBackstageCustomizations: "http://schemas.microsoft.com/office/2009/07/customui",
            sharedStringTable: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml",
            singleCellTable: "application/vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml",
            slicerCache: "application/vnd.openxmlformats-officedocument.spreadsheetml.slicerCache+xml",
            slicers: "application/vnd.openxmlformats-officedocument.spreadsheetml.slicer+xml",
            slide: "application/vnd.openxmlformats-officedocument.presentationml.slide+xml",
            slideComments: "application/vnd.openxmlformats-officedocument.presentationml.comments+xml",
            slideLayout: "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml",
            slideMaster: "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml",
            slideShow: "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml",
            slideSyncData: "application/vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml",
            styles: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
            tableDefinition: "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml",
            tableStyles: "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml",
            theme: "application/vnd.openxmlformats-officedocument.theme+xml",
            themeOverride: "application/vnd.openxmlformats-officedocument.themeOverride+xml",
            tiff: "image/tiff",
            trueTypeFont: "application/x-font-ttf",
            userDefinedTags: "application/vnd.openxmlformats-officedocument.presentationml.tags+xml",
            viewProperties: "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml",
            vmlDrawing: "application/vnd.openxmlformats-officedocument.vmlDrawing",
            volatileDependencies: "application/vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml",
            webSettings: "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml",
            wordAttachedToolbars: "application/vnd.ms-word.attachedToolbars",
            wordprocessingComments: "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml",
            wordprocessingTemplate: "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml",
            workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
            workbookRevisionHeader: "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml",
            workbookRevisionLog: "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml",
            workbookStyles: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
            workbookTemplate: "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml",
            workbookUserData: "application/vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml",
            worksheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
            worksheetComments: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
            worksheetSortMap: "application/vnd.ms-excel.wsSortMap+xml",
            xmlSignature: "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml",
        };

        // *********** relationship types ***********
        openXml.relationshipTypes = {
            alternativeFormatImport: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk",
            calculationChain: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain",
            cellMetadata: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sheetMetadata",
            chart: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
            chartColorStyle: "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle",
            chartDrawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chartUserShapes",
            chartsheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chartsheet",
            chartStyle: "http://schemas.microsoft.com/office/2011/relationships/chartStyle",
            commentAuthors: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/commentAuthors",
            connections: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/connections",
            coreFileProperties: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
            customFileProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties",
            customization: "http://schemas.microsoft.com/office/2006/relationships/keyMapCustomizations",
            customProperty: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customProperty",
            customXml: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml",
            customXmlMappings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/xmlMaps",
            customXmlProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps",
            diagramColors: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramColors",
            diagramData: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData",
            diagramLayoutDefinition: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramLayout",
            diagramPersistLayout: "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing",
            diagramStyle: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramQuickStyle",
            dialogsheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/dialogsheet",
            digitalSignatureOrigin: "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin",
            documentSettings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings",
            drawings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
            endnotes: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes",
            excelAttachedToolbars: "http://schemas.microsoft.com/office/2006/relationships/attachedToolbars",
            extendedFileProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
            externalWorkbook: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLink",
            font: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font",
            fontTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable",
            footer: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer",
            footnotes: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
            glossaryDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/glossaryDocument",
            handoutMaster: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/handoutMaster",
            header: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header",
            image: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
            mainDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
            notesSlide: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide",
            numberingDefinitions: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering",
            pivotTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable",
            pivotTableCacheDefinition: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
            pivotTableCacheRecords: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/ pivotCacheRecords",
            presentation: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
            presentationProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps",
            queryTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/queryTable",
            ribbonAndBackstageCustomizations: "http://schemas.microsoft.com/office/2007/relationships/ui/extensibility",
            sharedStringTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
            singleCellTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableSingleCells",
            slide: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide",
            slideComments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
            slideLayout: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
            slideMaster: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster",
            slideSyncData: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideUpdateInfo",
            styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
            tableDefinition: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table",
            tableStyles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles",
            theme: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
            themeOverride: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/themeOverride",
            thumbnail: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail",
            userDefinedTags: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags",
            viewProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps",
            vmlDrawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing",
            volatileDependencies: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/volatileDependencies",
            webSettings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings",
            wordAttachedToolbars: "http://schemas.microsoft.com/office/2006/relationships/attachedToolbars",
            wordprocessingComments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
            workbook: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
            workbookRevisionHeader: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/revisionHeaders",
            workbookRevisionLog: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/revisionLog",
            workbookStyles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
            workbookUserData: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/usernames",
            worksheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
            worksheetComments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
            worksheetSortMap: "http://schemas.microsoft.com/office/2006/relationships/wsSortMap",
            xmlSignature: "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/signature",
        };

        /******************************** automatically generated code ********************************/

        openXml.aNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/main");
        var aNs = openXml.aNs;
        openXml.A = {
            accent1: new XName(aNs, "accent1"),
            accent2: new XName(aNs, "accent2"),
            accent3: new XName(aNs, "accent3"),
            accent4: new XName(aNs, "accent4"),
            accent5: new XName(aNs, "accent5"),
            accent6: new XName(aNs, "accent6"),
            ahLst: new XName(aNs, "ahLst"),
            ahPolar: new XName(aNs, "ahPolar"),
            ahXY: new XName(aNs, "ahXY"),
            alpha: new XName(aNs, "alpha"),
            alphaBiLevel: new XName(aNs, "alphaBiLevel"),
            alphaCeiling: new XName(aNs, "alphaCeiling"),
            alphaFloor: new XName(aNs, "alphaFloor"),
            alphaInv: new XName(aNs, "alphaInv"),
            alphaMod: new XName(aNs, "alphaMod"),
            alphaModFix: new XName(aNs, "alphaModFix"),
            alphaOff: new XName(aNs, "alphaOff"),
            alphaOutset: new XName(aNs, "alphaOutset"),
            alphaRepl: new XName(aNs, "alphaRepl"),
            anchor: new XName(aNs, "anchor"),
            arcTo: new XName(aNs, "arcTo"),
            audioCd: new XName(aNs, "audioCd"),
            audioFile: new XName(aNs, "audioFile"),
            avLst: new XName(aNs, "avLst"),
            backdrop: new XName(aNs, "backdrop"),
            band1H: new XName(aNs, "band1H"),
            band1V: new XName(aNs, "band1V"),
            band2H: new XName(aNs, "band2H"),
            band2V: new XName(aNs, "band2V"),
            bevel: new XName(aNs, "bevel"),
            bevelB: new XName(aNs, "bevelB"),
            bevelT: new XName(aNs, "bevelT"),
            bgClr: new XName(aNs, "bgClr"),
            bgFillStyleLst: new XName(aNs, "bgFillStyleLst"),
            biLevel: new XName(aNs, "biLevel"),
            bldChart: new XName(aNs, "bldChart"),
            bldDgm: new XName(aNs, "bldDgm"),
            blend: new XName(aNs, "blend"),
            blip: new XName(aNs, "blip"),
            blipFill: new XName(aNs, "blipFill"),
            blue: new XName(aNs, "blue"),
            blueMod: new XName(aNs, "blueMod"),
            blueOff: new XName(aNs, "blueOff"),
            blur: new XName(aNs, "blur"),
            bodyPr: new XName(aNs, "bodyPr"),
            bottom: new XName(aNs, "bottom"),
            br: new XName(aNs, "br"),
            buAutoNum: new XName(aNs, "buAutoNum"),
            buBlip: new XName(aNs, "buBlip"),
            buChar: new XName(aNs, "buChar"),
            buClr: new XName(aNs, "buClr"),
            buClrTx: new XName(aNs, "buClrTx"),
            buFont: new XName(aNs, "buFont"),
            buFontTx: new XName(aNs, "buFontTx"),
            buNone: new XName(aNs, "buNone"),
            buSzPct: new XName(aNs, "buSzPct"),
            buSzPts: new XName(aNs, "buSzPts"),
            buSzTx: new XName(aNs, "buSzTx"),
            camera: new XName(aNs, "camera"),
            cell3D: new XName(aNs, "cell3D"),
            chart: new XName(aNs, "chart"),
            chExt: new XName(aNs, "chExt"),
            chOff: new XName(aNs, "chOff"),
            close: new XName(aNs, "close"),
            clrChange: new XName(aNs, "clrChange"),
            clrFrom: new XName(aNs, "clrFrom"),
            clrMap: new XName(aNs, "clrMap"),
            clrRepl: new XName(aNs, "clrRepl"),
            clrScheme: new XName(aNs, "clrScheme"),
            clrTo: new XName(aNs, "clrTo"),
            cNvCxnSpPr: new XName(aNs, "cNvCxnSpPr"),
            cNvGraphicFramePr: new XName(aNs, "cNvGraphicFramePr"),
            cNvGrpSpPr: new XName(aNs, "cNvGrpSpPr"),
            cNvPicPr: new XName(aNs, "cNvPicPr"),
            cNvPr: new XName(aNs, "cNvPr"),
            cNvSpPr: new XName(aNs, "cNvSpPr"),
            comp: new XName(aNs, "comp"),
            cont: new XName(aNs, "cont"),
            contourClr: new XName(aNs, "contourClr"),
            cs: new XName(aNs, "cs"),
            cubicBezTo: new XName(aNs, "cubicBezTo"),
            custClr: new XName(aNs, "custClr"),
            custClrLst: new XName(aNs, "custClrLst"),
            custDash: new XName(aNs, "custDash"),
            custGeom: new XName(aNs, "custGeom"),
            cxn: new XName(aNs, "cxn"),
            cxnLst: new XName(aNs, "cxnLst"),
            cxnSp: new XName(aNs, "cxnSp"),
            cxnSpLocks: new XName(aNs, "cxnSpLocks"),
            defPPr: new XName(aNs, "defPPr"),
            defRPr: new XName(aNs, "defRPr"),
            dgm: new XName(aNs, "dgm"),
            dk1: new XName(aNs, "dk1"),
            dk2: new XName(aNs, "dk2"),
            ds: new XName(aNs, "ds"),
            duotone: new XName(aNs, "duotone"),
            ea: new XName(aNs, "ea"),
            effect: new XName(aNs, "effect"),
            effectDag: new XName(aNs, "effectDag"),
            effectLst: new XName(aNs, "effectLst"),
            effectRef: new XName(aNs, "effectRef"),
            effectStyle: new XName(aNs, "effectStyle"),
            effectStyleLst: new XName(aNs, "effectStyleLst"),
            end: new XName(aNs, "end"),
            endCxn: new XName(aNs, "endCxn"),
            endParaRPr: new XName(aNs, "endParaRPr"),
            ext: new XName(aNs, "ext"),
            extLst: new XName(aNs, "extLst"),
            extraClrScheme: new XName(aNs, "extraClrScheme"),
            extraClrSchemeLst: new XName(aNs, "extraClrSchemeLst"),
            extrusionClr: new XName(aNs, "extrusionClr"),
            fgClr: new XName(aNs, "fgClr"),
            fill: new XName(aNs, "fill"),
            fillOverlay: new XName(aNs, "fillOverlay"),
            fillRect: new XName(aNs, "fillRect"),
            fillRef: new XName(aNs, "fillRef"),
            fillStyleLst: new XName(aNs, "fillStyleLst"),
            fillToRect: new XName(aNs, "fillToRect"),
            firstCol: new XName(aNs, "firstCol"),
            firstRow: new XName(aNs, "firstRow"),
            flatTx: new XName(aNs, "flatTx"),
            fld: new XName(aNs, "fld"),
            fmtScheme: new XName(aNs, "fmtScheme"),
            folHlink: new XName(aNs, "folHlink"),
            font: new XName(aNs, "font"),
            fontRef: new XName(aNs, "fontRef"),
            fontScheme: new XName(aNs, "fontScheme"),
            gamma: new XName(aNs, "gamma"),
            gd: new XName(aNs, "gd"),
            gdLst: new XName(aNs, "gdLst"),
            glow: new XName(aNs, "glow"),
            gradFill: new XName(aNs, "gradFill"),
            graphic: new XName(aNs, "graphic"),
            graphicData: new XName(aNs, "graphicData"),
            graphicFrame: new XName(aNs, "graphicFrame"),
            graphicFrameLocks: new XName(aNs, "graphicFrameLocks"),
            gray: new XName(aNs, "gray"),
            grayscl: new XName(aNs, "grayscl"),
            green: new XName(aNs, "green"),
            greenMod: new XName(aNs, "greenMod"),
            greenOff: new XName(aNs, "greenOff"),
            gridCol: new XName(aNs, "gridCol"),
            grpFill: new XName(aNs, "grpFill"),
            grpSp: new XName(aNs, "grpSp"),
            grpSpLocks: new XName(aNs, "grpSpLocks"),
            grpSpPr: new XName(aNs, "grpSpPr"),
            gs: new XName(aNs, "gs"),
            gsLst: new XName(aNs, "gsLst"),
            headEnd: new XName(aNs, "headEnd"),
            highlight: new XName(aNs, "highlight"),
            hlink: new XName(aNs, "hlink"),
            hlinkClick: new XName(aNs, "hlinkClick"),
            hlinkHover: new XName(aNs, "hlinkHover"),
            hlinkMouseOver: new XName(aNs, "hlinkMouseOver"),
            hsl: new XName(aNs, "hsl"),
            hslClr: new XName(aNs, "hslClr"),
            hue: new XName(aNs, "hue"),
            hueMod: new XName(aNs, "hueMod"),
            hueOff: new XName(aNs, "hueOff"),
            innerShdw: new XName(aNs, "innerShdw"),
            insideH: new XName(aNs, "insideH"),
            insideV: new XName(aNs, "insideV"),
            inv: new XName(aNs, "inv"),
            invGamma: new XName(aNs, "invGamma"),
            lastCol: new XName(aNs, "lastCol"),
            lastRow: new XName(aNs, "lastRow"),
            latin: new XName(aNs, "latin"),
            left: new XName(aNs, "left"),
            lightRig: new XName(aNs, "lightRig"),
            lin: new XName(aNs, "lin"),
            ln: new XName(aNs, "ln"),
            lnB: new XName(aNs, "lnB"),
            lnBlToTr: new XName(aNs, "lnBlToTr"),
            lnDef: new XName(aNs, "lnDef"),
            lnL: new XName(aNs, "lnL"),
            lnR: new XName(aNs, "lnR"),
            lnRef: new XName(aNs, "lnRef"),
            lnSpc: new XName(aNs, "lnSpc"),
            lnStyleLst: new XName(aNs, "lnStyleLst"),
            lnT: new XName(aNs, "lnT"),
            lnTlToBr: new XName(aNs, "lnTlToBr"),
            lnTo: new XName(aNs, "lnTo"),
            lstStyle: new XName(aNs, "lstStyle"),
            lt1: new XName(aNs, "lt1"),
            lt2: new XName(aNs, "lt2"),
            lum: new XName(aNs, "lum"),
            lumMod: new XName(aNs, "lumMod"),
            lumOff: new XName(aNs, "lumOff"),
            lvl1pPr: new XName(aNs, "lvl1pPr"),
            lvl2pPr: new XName(aNs, "lvl2pPr"),
            lvl3pPr: new XName(aNs, "lvl3pPr"),
            lvl4pPr: new XName(aNs, "lvl4pPr"),
            lvl5pPr: new XName(aNs, "lvl5pPr"),
            lvl6pPr: new XName(aNs, "lvl6pPr"),
            lvl7pPr: new XName(aNs, "lvl7pPr"),
            lvl8pPr: new XName(aNs, "lvl8pPr"),
            lvl9pPr: new XName(aNs, "lvl9pPr"),
            majorFont: new XName(aNs, "majorFont"),
            masterClrMapping: new XName(aNs, "masterClrMapping"),
            minorFont: new XName(aNs, "minorFont"),
            miter: new XName(aNs, "miter"),
            moveTo: new XName(aNs, "moveTo"),
            neCell: new XName(aNs, "neCell"),
            noAutofit: new XName(aNs, "noAutofit"),
            noFill: new XName(aNs, "noFill"),
            norm: new XName(aNs, "norm"),
            normAutofit: new XName(aNs, "normAutofit"),
            nvCxnSpPr: new XName(aNs, "nvCxnSpPr"),
            nvGraphicFramePr: new XName(aNs, "nvGraphicFramePr"),
            nvGrpSpPr: new XName(aNs, "nvGrpSpPr"),
            nvPicPr: new XName(aNs, "nvPicPr"),
            nvSpPr: new XName(aNs, "nvSpPr"),
            nwCell: new XName(aNs, "nwCell"),
            objectDefaults: new XName(aNs, "objectDefaults"),
            off: new XName(aNs, "off"),
            outerShdw: new XName(aNs, "outerShdw"),
            overrideClrMapping: new XName(aNs, "overrideClrMapping"),
            p: new XName(aNs, "p"),
            path: new XName(aNs, "path"),
            pathLst: new XName(aNs, "pathLst"),
            pattFill: new XName(aNs, "pattFill"),
            pic: new XName(aNs, "pic"),
            picLocks: new XName(aNs, "picLocks"),
            pos: new XName(aNs, "pos"),
            pPr: new XName(aNs, "pPr"),
            prstClr: new XName(aNs, "prstClr"),
            prstDash: new XName(aNs, "prstDash"),
            prstGeom: new XName(aNs, "prstGeom"),
            prstShdw: new XName(aNs, "prstShdw"),
            prstTxWarp: new XName(aNs, "prstTxWarp"),
            pt: new XName(aNs, "pt"),
            quadBezTo: new XName(aNs, "quadBezTo"),
            quickTimeFile: new XName(aNs, "quickTimeFile"),
            r: new XName(aNs, "r"),
            rect: new XName(aNs, "rect"),
            red: new XName(aNs, "red"),
            redMod: new XName(aNs, "redMod"),
            redOff: new XName(aNs, "redOff"),
            reflection: new XName(aNs, "reflection"),
            relIds: new XName(aNs, "relIds"),
            relOff: new XName(aNs, "relOff"),
            right: new XName(aNs, "right"),
            rot: new XName(aNs, "rot"),
            round: new XName(aNs, "round"),
            rPr: new XName(aNs, "rPr"),
            sat: new XName(aNs, "sat"),
            satMod: new XName(aNs, "satMod"),
            satOff: new XName(aNs, "satOff"),
            scene3d: new XName(aNs, "scene3d"),
            schemeClr: new XName(aNs, "schemeClr"),
            scrgbClr: new XName(aNs, "scrgbClr"),
            seCell: new XName(aNs, "seCell"),
            shade: new XName(aNs, "shade"),
            snd: new XName(aNs, "snd"),
            softEdge: new XName(aNs, "softEdge"),
            solidFill: new XName(aNs, "solidFill"),
            sp: new XName(aNs, "sp"),
            sp3d: new XName(aNs, "sp3d"),
            spAutoFit: new XName(aNs, "spAutoFit"),
            spcAft: new XName(aNs, "spcAft"),
            spcBef: new XName(aNs, "spcBef"),
            spcPct: new XName(aNs, "spcPct"),
            spcPts: new XName(aNs, "spcPts"),
            spDef: new XName(aNs, "spDef"),
            spLocks: new XName(aNs, "spLocks"),
            spPr: new XName(aNs, "spPr"),
            srcRect: new XName(aNs, "srcRect"),
            srgbClr: new XName(aNs, "srgbClr"),
            st: new XName(aNs, "st"),
            stCxn: new XName(aNs, "stCxn"),
            stretch: new XName(aNs, "stretch"),
            style: new XName(aNs, "style"),
            swCell: new XName(aNs, "swCell"),
            sx: new XName(aNs, "sx"),
            sy: new XName(aNs, "sy"),
            sym: new XName(aNs, "sym"),
            sysClr: new XName(aNs, "sysClr"),
            t: new XName(aNs, "t"),
            tab: new XName(aNs, "tab"),
            tableStyle: new XName(aNs, "tableStyle"),
            tableStyleId: new XName(aNs, "tableStyleId"),
            tabLst: new XName(aNs, "tabLst"),
            tailEnd: new XName(aNs, "tailEnd"),
            tbl: new XName(aNs, "tbl"),
            tblBg: new XName(aNs, "tblBg"),
            tblGrid: new XName(aNs, "tblGrid"),
            tblPr: new XName(aNs, "tblPr"),
            tblStyle: new XName(aNs, "tblStyle"),
            tblStyleLst: new XName(aNs, "tblStyleLst"),
            tc: new XName(aNs, "tc"),
            tcBdr: new XName(aNs, "tcBdr"),
            tcPr: new XName(aNs, "tcPr"),
            tcStyle: new XName(aNs, "tcStyle"),
            tcTxStyle: new XName(aNs, "tcTxStyle"),
            theme: new XName(aNs, "theme"),
            themeElements: new XName(aNs, "themeElements"),
            themeOverride: new XName(aNs, "themeOverride"),
            tile: new XName(aNs, "tile"),
            tileRect: new XName(aNs, "tileRect"),
            tint: new XName(aNs, "tint"),
            top: new XName(aNs, "top"),
            tr: new XName(aNs, "tr"),
            txBody: new XName(aNs, "txBody"),
            txDef: new XName(aNs, "txDef"),
            txSp: new XName(aNs, "txSp"),
            uFill: new XName(aNs, "uFill"),
            uFillTx: new XName(aNs, "uFillTx"),
            uLn: new XName(aNs, "uLn"),
            uLnTx: new XName(aNs, "uLnTx"),
            up: new XName(aNs, "up"),
            useSpRect: new XName(aNs, "useSpRect"),
            videoFile: new XName(aNs, "videoFile"),
            wavAudioFile: new XName(aNs, "wavAudioFile"),
            wholeTbl: new XName(aNs, "wholeTbl"),
            xfrm: new XName(aNs, "xfrm"),
        }
        var A = openXml.A;

        openXml.a14Ns = new XNamespace("http://schemas.microsoft.com/office/drawing/2010/main");
        var a14Ns = openXml.a14Ns;
        openXml.A14 = {
            artisticChalkSketch: new XName(a14Ns, "artisticChalkSketch"),
            artisticGlass: new XName(a14Ns, "artisticGlass"),
            artisticGlowEdges: new XName(a14Ns, "artisticGlowEdges"),
            artisticLightScreen: new XName(a14Ns, "artisticLightScreen"),
            artisticPlasticWrap: new XName(a14Ns, "artisticPlasticWrap"),
            artisticTexturizer: new XName(a14Ns, "artisticTexturizer"),
            backgroundMark: new XName(a14Ns, "backgroundMark"),
            backgroundRemoval: new XName(a14Ns, "backgroundRemoval"),
            brightnessContrast: new XName(a14Ns, "brightnessContrast"),
            cameraTool: new XName(a14Ns, "cameraTool"),
            colorTemperature: new XName(a14Ns, "colorTemperature"),
            compatExt: new XName(a14Ns, "compatExt"),
            cpLocks: new XName(a14Ns, "cpLocks"),
            extLst: new XName(a14Ns, "extLst"),
            foregroundMark: new XName(a14Ns, "foregroundMark"),
            hiddenEffects: new XName(a14Ns, "hiddenEffects"),
            hiddenFill: new XName(a14Ns, "hiddenFill"),
            hiddenLine: new XName(a14Ns, "hiddenLine"),
            hiddenScene3d: new XName(a14Ns, "hiddenScene3d"),
            hiddenSp3d: new XName(a14Ns, "hiddenSp3d"),
            imgEffect: new XName(a14Ns, "imgEffect"),
            imgLayer: new XName(a14Ns, "imgLayer"),
            imgProps: new XName(a14Ns, "imgProps"),
            legacySpreadsheetColorIndex: new XName(a14Ns, "legacySpreadsheetColorIndex"),
            m: new XName(a14Ns, "m"),
            saturation: new XName(a14Ns, "saturation"),
            shadowObscured: new XName(a14Ns, "shadowObscured"),
            sharpenSoften: new XName(a14Ns, "sharpenSoften"),
            useLocalDpi: new XName(a14Ns, "useLocalDpi"),
        }
        var A14 = openXml.A14;

        openXml.cNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/chart");
        var cNs = openXml.cNs;
        openXml.C = {
            applyToEnd: new XName(cNs, "applyToEnd"),
            applyToFront: new XName(cNs, "applyToFront"),
            applyToSides: new XName(cNs, "applyToSides"),
            area3DChart: new XName(cNs, "area3DChart"),
            areaChart: new XName(cNs, "areaChart"),
            auto: new XName(cNs, "auto"),
            autoTitleDeleted: new XName(cNs, "autoTitleDeleted"),
            autoUpdate: new XName(cNs, "autoUpdate"),
            axId: new XName(cNs, "axId"),
            axPos: new XName(cNs, "axPos"),
            backWall: new XName(cNs, "backWall"),
            backward: new XName(cNs, "backward"),
            bandFmt: new XName(cNs, "bandFmt"),
            bandFmts: new XName(cNs, "bandFmts"),
            bar3DChart: new XName(cNs, "bar3DChart"),
            barChart: new XName(cNs, "barChart"),
            barDir: new XName(cNs, "barDir"),
            baseTimeUnit: new XName(cNs, "baseTimeUnit"),
            bubble3D: new XName(cNs, "bubble3D"),
            bubbleChart: new XName(cNs, "bubbleChart"),
            bubbleScale: new XName(cNs, "bubbleScale"),
            bubbleSize: new XName(cNs, "bubbleSize"),
            builtInUnit: new XName(cNs, "builtInUnit"),
            cat: new XName(cNs, "cat"),
            catAx: new XName(cNs, "catAx"),
            chart: new XName(cNs, "chart"),
            chartObject: new XName(cNs, "chartObject"),
            chartSpace: new XName(cNs, "chartSpace"),
            clrMapOvr: new XName(cNs, "clrMapOvr"),
            crossAx: new XName(cNs, "crossAx"),
            crossBetween: new XName(cNs, "crossBetween"),
            crosses: new XName(cNs, "crosses"),
            crossesAt: new XName(cNs, "crossesAt"),
            custSplit: new XName(cNs, "custSplit"),
            custUnit: new XName(cNs, "custUnit"),
            data: new XName(cNs, "data"),
            date1904: new XName(cNs, "date1904"),
            dateAx: new XName(cNs, "dateAx"),
            delete: new XName(cNs, "delete"),
            depthPercent: new XName(cNs, "depthPercent"),
            dispBlanksAs: new XName(cNs, "dispBlanksAs"),
            dispEq: new XName(cNs, "dispEq"),
            dispRSqr: new XName(cNs, "dispRSqr"),
            dispUnits: new XName(cNs, "dispUnits"),
            dispUnitsLbl: new XName(cNs, "dispUnitsLbl"),
            dLbl: new XName(cNs, "dLbl"),
            dLblPos: new XName(cNs, "dLblPos"),
            dLbls: new XName(cNs, "dLbls"),
            doughnutChart: new XName(cNs, "doughnutChart"),
            downBars: new XName(cNs, "downBars"),
            dPt: new XName(cNs, "dPt"),
            dropLines: new XName(cNs, "dropLines"),
            dTable: new XName(cNs, "dTable"),
            errBars: new XName(cNs, "errBars"),
            errBarType: new XName(cNs, "errBarType"),
            errDir: new XName(cNs, "errDir"),
            errValType: new XName(cNs, "errValType"),
            explosion: new XName(cNs, "explosion"),
            ext: new XName(cNs, "ext"),
            externalData: new XName(cNs, "externalData"),
            extLst: new XName(cNs, "extLst"),
            f: new XName(cNs, "f"),
            firstSliceAng: new XName(cNs, "firstSliceAng"),
            floor: new XName(cNs, "floor"),
            fmtId: new XName(cNs, "fmtId"),
            formatCode: new XName(cNs, "formatCode"),
            formatting: new XName(cNs, "formatting"),
            forward: new XName(cNs, "forward"),
            gapDepth: new XName(cNs, "gapDepth"),
            gapWidth: new XName(cNs, "gapWidth"),
            grouping: new XName(cNs, "grouping"),
            h: new XName(cNs, "h"),
            headerFooter: new XName(cNs, "headerFooter"),
            hiLowLines: new XName(cNs, "hiLowLines"),
            hMode: new XName(cNs, "hMode"),
            holeSize: new XName(cNs, "holeSize"),
            hPercent: new XName(cNs, "hPercent"),
            idx: new XName(cNs, "idx"),
            intercept: new XName(cNs, "intercept"),
            invertIfNegative: new XName(cNs, "invertIfNegative"),
            lang: new XName(cNs, "lang"),
            layout: new XName(cNs, "layout"),
            layoutTarget: new XName(cNs, "layoutTarget"),
            lblAlgn: new XName(cNs, "lblAlgn"),
            lblOffset: new XName(cNs, "lblOffset"),
            leaderLines: new XName(cNs, "leaderLines"),
            legend: new XName(cNs, "legend"),
            legendEntry: new XName(cNs, "legendEntry"),
            legendPos: new XName(cNs, "legendPos"),
            line3DChart: new XName(cNs, "line3DChart"),
            lineChart: new XName(cNs, "lineChart"),
            logBase: new XName(cNs, "logBase"),
            lvl: new XName(cNs, "lvl"),
            majorGridlines: new XName(cNs, "majorGridlines"),
            majorTickMark: new XName(cNs, "majorTickMark"),
            majorTimeUnit: new XName(cNs, "majorTimeUnit"),
            majorUnit: new XName(cNs, "majorUnit"),
            manualLayout: new XName(cNs, "manualLayout"),
            marker: new XName(cNs, "marker"),
            max: new XName(cNs, "max"),
            min: new XName(cNs, "min"),
            minorGridlines: new XName(cNs, "minorGridlines"),
            minorTickMark: new XName(cNs, "minorTickMark"),
            minorTimeUnit: new XName(cNs, "minorTimeUnit"),
            minorUnit: new XName(cNs, "minorUnit"),
            minus: new XName(cNs, "minus"),
            multiLvlStrCache: new XName(cNs, "multiLvlStrCache"),
            multiLvlStrRef: new XName(cNs, "multiLvlStrRef"),
            name: new XName(cNs, "name"),
            noEndCap: new XName(cNs, "noEndCap"),
            noMultiLvlLbl: new XName(cNs, "noMultiLvlLbl"),
            numCache: new XName(cNs, "numCache"),
            numFmt: new XName(cNs, "numFmt"),
            numLit: new XName(cNs, "numLit"),
            numRef: new XName(cNs, "numRef"),
            oddFooter: new XName(cNs, "oddFooter"),
            oddHeader: new XName(cNs, "oddHeader"),
            ofPieChart: new XName(cNs, "ofPieChart"),
            ofPieType: new XName(cNs, "ofPieType"),
            order: new XName(cNs, "order"),
            orientation: new XName(cNs, "orientation"),
            overlap: new XName(cNs, "overlap"),
            overlay: new XName(cNs, "overlay"),
            pageMargins: new XName(cNs, "pageMargins"),
            pageSetup: new XName(cNs, "pageSetup"),
            period: new XName(cNs, "period"),
            perspective: new XName(cNs, "perspective"),
            pictureFormat: new XName(cNs, "pictureFormat"),
            pictureOptions: new XName(cNs, "pictureOptions"),
            pictureStackUnit: new XName(cNs, "pictureStackUnit"),
            pie3DChart: new XName(cNs, "pie3DChart"),
            pieChart: new XName(cNs, "pieChart"),
            pivotFmt: new XName(cNs, "pivotFmt"),
            pivotFmts: new XName(cNs, "pivotFmts"),
            pivotSource: new XName(cNs, "pivotSource"),
            plotArea: new XName(cNs, "plotArea"),
            plotVisOnly: new XName(cNs, "plotVisOnly"),
            plus: new XName(cNs, "plus"),
            printSettings: new XName(cNs, "printSettings"),
            protection: new XName(cNs, "protection"),
            pt: new XName(cNs, "pt"),
            ptCount: new XName(cNs, "ptCount"),
            radarChart: new XName(cNs, "radarChart"),
            radarStyle: new XName(cNs, "radarStyle"),
            rAngAx: new XName(cNs, "rAngAx"),
            rich: new XName(cNs, "rich"),
            rotX: new XName(cNs, "rotX"),
            rotY: new XName(cNs, "rotY"),
            roundedCorners: new XName(cNs, "roundedCorners"),
            scaling: new XName(cNs, "scaling"),
            scatterChart: new XName(cNs, "scatterChart"),
            scatterStyle: new XName(cNs, "scatterStyle"),
            secondPiePt: new XName(cNs, "secondPiePt"),
            secondPieSize: new XName(cNs, "secondPieSize"),
            selection: new XName(cNs, "selection"),
            separator: new XName(cNs, "separator"),
            ser: new XName(cNs, "ser"),
            serAx: new XName(cNs, "serAx"),
            serLines: new XName(cNs, "serLines"),
            shape: new XName(cNs, "shape"),
            showBubbleSize: new XName(cNs, "showBubbleSize"),
            showCatName: new XName(cNs, "showCatName"),
            showDLblsOverMax: new XName(cNs, "showDLblsOverMax"),
            showHorzBorder: new XName(cNs, "showHorzBorder"),
            showKeys: new XName(cNs, "showKeys"),
            showLeaderLines: new XName(cNs, "showLeaderLines"),
            showLegendKey: new XName(cNs, "showLegendKey"),
            showNegBubbles: new XName(cNs, "showNegBubbles"),
            showOutline: new XName(cNs, "showOutline"),
            showPercent: new XName(cNs, "showPercent"),
            showSerName: new XName(cNs, "showSerName"),
            showVal: new XName(cNs, "showVal"),
            showVertBorder: new XName(cNs, "showVertBorder"),
            sideWall: new XName(cNs, "sideWall"),
            size: new XName(cNs, "size"),
            sizeRepresents: new XName(cNs, "sizeRepresents"),
            smooth: new XName(cNs, "smooth"),
            splitPos: new XName(cNs, "splitPos"),
            splitType: new XName(cNs, "splitType"),
            spPr: new XName(cNs, "spPr"),
            stockChart: new XName(cNs, "stockChart"),
            strCache: new XName(cNs, "strCache"),
            strLit: new XName(cNs, "strLit"),
            strRef: new XName(cNs, "strRef"),
            style: new XName(cNs, "style"),
            surface3DChart: new XName(cNs, "surface3DChart"),
            surfaceChart: new XName(cNs, "surfaceChart"),
            symbol: new XName(cNs, "symbol"),
            thickness: new XName(cNs, "thickness"),
            tickLblPos: new XName(cNs, "tickLblPos"),
            tickLblSkip: new XName(cNs, "tickLblSkip"),
            tickMarkSkip: new XName(cNs, "tickMarkSkip"),
            title: new XName(cNs, "title"),
            trendline: new XName(cNs, "trendline"),
            trendlineLbl: new XName(cNs, "trendlineLbl"),
            trendlineType: new XName(cNs, "trendlineType"),
            tx: new XName(cNs, "tx"),
            txPr: new XName(cNs, "txPr"),
            upBars: new XName(cNs, "upBars"),
            upDownBars: new XName(cNs, "upDownBars"),
            userInterface: new XName(cNs, "userInterface"),
            userShapes: new XName(cNs, "userShapes"),
            v: new XName(cNs, "v"),
            val: new XName(cNs, "val"),
            valAx: new XName(cNs, "valAx"),
            varyColors: new XName(cNs, "varyColors"),
            view3D: new XName(cNs, "view3D"),
            w: new XName(cNs, "w"),
            wireframe: new XName(cNs, "wireframe"),
            wMode: new XName(cNs, "wMode"),
            x: new XName(cNs, "x"),
            xMode: new XName(cNs, "xMode"),
            xVal: new XName(cNs, "xVal"),
            y: new XName(cNs, "y"),
            yMode: new XName(cNs, "yMode"),
            yVal: new XName(cNs, "yVal"),
        }
        var C = openXml.C;

        openXml.cdrNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/chartDrawing");
        var cdrNs = openXml.cdrNs;
        openXml.CDR = {
            absSizeAnchor: new XName(cdrNs, "absSizeAnchor"),
            blipFill: new XName(cdrNs, "blipFill"),
            cNvCxnSpPr: new XName(cdrNs, "cNvCxnSpPr"),
            cNvGraphicFramePr: new XName(cdrNs, "cNvGraphicFramePr"),
            cNvGrpSpPr: new XName(cdrNs, "cNvGrpSpPr"),
            cNvPicPr: new XName(cdrNs, "cNvPicPr"),
            cNvPr: new XName(cdrNs, "cNvPr"),
            cNvSpPr: new XName(cdrNs, "cNvSpPr"),
            cxnSp: new XName(cdrNs, "cxnSp"),
            ext: new XName(cdrNs, "ext"),
            from: new XName(cdrNs, "from"),
            graphicFrame: new XName(cdrNs, "graphicFrame"),
            grpSp: new XName(cdrNs, "grpSp"),
            grpSpPr: new XName(cdrNs, "grpSpPr"),
            nvCxnSpPr: new XName(cdrNs, "nvCxnSpPr"),
            nvGraphicFramePr: new XName(cdrNs, "nvGraphicFramePr"),
            nvGrpSpPr: new XName(cdrNs, "nvGrpSpPr"),
            nvPicPr: new XName(cdrNs, "nvPicPr"),
            nvSpPr: new XName(cdrNs, "nvSpPr"),
            pic: new XName(cdrNs, "pic"),
            relSizeAnchor: new XName(cdrNs, "relSizeAnchor"),
            sp: new XName(cdrNs, "sp"),
            spPr: new XName(cdrNs, "spPr"),
            style: new XName(cdrNs, "style"),
            to: new XName(cdrNs, "to"),
            txBody: new XName(cdrNs, "txBody"),
            x: new XName(cdrNs, "x"),
            xfrm: new XName(cdrNs, "xfrm"),
            y: new XName(cdrNs, "y"),
        }
        var CDR = openXml.CDR;

        openXml.comNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/compatibility");
        var comNs = openXml.comNs;
        openXml.COM = {
            legacyDrawing: new XName(comNs, "legacyDrawing"),
        }
        var COM = openXml.COM;

        openXml.cpNs = new XNamespace("http://schemas.openxmlformats.org/package/2006/metadata/core-properties");
        var cpNs = openXml.cpNs;
        openXml.CP = {
            category: new XName(cpNs, "category"),
            contentStatus: new XName(cpNs, "contentStatus"),
            contentType: new XName(cpNs, "contentType"),
            coreProperties: new XName(cpNs, "coreProperties"),
            keywords: new XName(cpNs, "keywords"),
            lastModifiedBy: new XName(cpNs, "lastModifiedBy"),
            lastPrinted: new XName(cpNs, "lastPrinted"),
            revision: new XName(cpNs, "revision"),
        }
        var CP = openXml.CP;

        openXml.custproNs = new XNamespace("http://schemas.openxmlformats.org/officeDocument/2006/custom-properties");
        var custproNs = openXml.custproNs;
        openXml.CUSTPRO = {
            Properties: new XName(custproNs, "Properties"),
            property: new XName(custproNs, "property"),
        }
        var CUSTPRO = openXml.CUSTPRO;

        openXml.dcNs = new XNamespace("http://purl.org/dc/elements/1.1/");
        var dcNs = openXml.dcNs;
        openXml.DC = {
            creator: new XName(dcNs, "creator"),
            description: new XName(dcNs, "description"),
            subject: new XName(dcNs, "subject"),
            title: new XName(dcNs, "title"),
        }
        var DC = openXml.DC;

        openXml.dctermsNs = new XNamespace("http://purl.org/dc/terms/");
        var dctermsNs = openXml.dctermsNs;
        openXml.DCTERMS = {
            created: new XName(dctermsNs, "created"),
            modified: new XName(dctermsNs, "modified"),
        }
        var DCTERMS = openXml.DCTERMS;

        openXml.dgmNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/diagram");
        var dgmNs = openXml.dgmNs;
        openXml.DGM = {
            adj: new XName(dgmNs, "adj"),
            adjLst: new XName(dgmNs, "adjLst"),
            alg: new XName(dgmNs, "alg"),
            animLvl: new XName(dgmNs, "animLvl"),
            animOne: new XName(dgmNs, "animOne"),
            bg: new XName(dgmNs, "bg"),
            bulletEnabled: new XName(dgmNs, "bulletEnabled"),
            cat: new XName(dgmNs, "cat"),
            catLst: new XName(dgmNs, "catLst"),
            chMax: new XName(dgmNs, "chMax"),
            choose: new XName(dgmNs, "choose"),
            chPref: new XName(dgmNs, "chPref"),
            clrData: new XName(dgmNs, "clrData"),
            colorsDef: new XName(dgmNs, "colorsDef"),
            constr: new XName(dgmNs, "constr"),
            constrLst: new XName(dgmNs, "constrLst"),
            cxn: new XName(dgmNs, "cxn"),
            cxnLst: new XName(dgmNs, "cxnLst"),
            dataModel: new XName(dgmNs, "dataModel"),
            desc: new XName(dgmNs, "desc"),
            dir: new XName(dgmNs, "dir"),
            effectClrLst: new XName(dgmNs, "effectClrLst"),
            _else: new XName(dgmNs, "else"),
            extLst: new XName(dgmNs, "extLst"),
            fillClrLst: new XName(dgmNs, "fillClrLst"),
            forEach: new XName(dgmNs, "forEach"),
            hierBranch: new XName(dgmNs, "hierBranch"),
            _if: new XName(dgmNs, "if"),
            layoutDef: new XName(dgmNs, "layoutDef"),
            layoutNode: new XName(dgmNs, "layoutNode"),
            linClrLst: new XName(dgmNs, "linClrLst"),
            orgChart: new XName(dgmNs, "orgChart"),
            param: new XName(dgmNs, "param"),
            presLayoutVars: new XName(dgmNs, "presLayoutVars"),
            presOf: new XName(dgmNs, "presOf"),
            prSet: new XName(dgmNs, "prSet"),
            pt: new XName(dgmNs, "pt"),
            ptLst: new XName(dgmNs, "ptLst"),
            relIds: new XName(dgmNs, "relIds"),
            resizeHandles: new XName(dgmNs, "resizeHandles"),
            rule: new XName(dgmNs, "rule"),
            ruleLst: new XName(dgmNs, "ruleLst"),
            sampData: new XName(dgmNs, "sampData"),
            scene3d: new XName(dgmNs, "scene3d"),
            shape: new XName(dgmNs, "shape"),
            sp3d: new XName(dgmNs, "sp3d"),
            spPr: new XName(dgmNs, "spPr"),
            style: new XName(dgmNs, "style"),
            styleData: new XName(dgmNs, "styleData"),
            styleDef: new XName(dgmNs, "styleDef"),
            styleLbl: new XName(dgmNs, "styleLbl"),
            t: new XName(dgmNs, "t"),
            title: new XName(dgmNs, "title"),
            txEffectClrLst: new XName(dgmNs, "txEffectClrLst"),
            txFillClrLst: new XName(dgmNs, "txFillClrLst"),
            txLinClrLst: new XName(dgmNs, "txLinClrLst"),
            txPr: new XName(dgmNs, "txPr"),
            varLst: new XName(dgmNs, "varLst"),
            whole: new XName(dgmNs, "whole"),
        }
        var DGM = openXml.DGM;

        openXml.dgm14Ns = new XNamespace("http://schemas.microsoft.com/office/drawing/2010/diagram");
        var dgm14Ns = openXml.dgm14Ns;
        openXml.DGM14 = {
            cNvPr: new XName(dgm14Ns, "cNvPr"),
            recolorImg: new XName(dgm14Ns, "recolorImg"),
        }
        var DGM14 = openXml.DGM14;

        openXml.digsigNs = new XNamespace("http://schemas.microsoft.com/office/2006/digsig");
        var digsigNs = openXml.digsigNs;
        openXml.DIGSIG = {
            ApplicationVersion: new XName(digsigNs, "ApplicationVersion"),
            ColorDepth: new XName(digsigNs, "ColorDepth"),
            HorizontalResolution: new XName(digsigNs, "HorizontalResolution"),
            ManifestHashAlgorithm: new XName(digsigNs, "ManifestHashAlgorithm"),
            Monitors: new XName(digsigNs, "Monitors"),
            OfficeVersion: new XName(digsigNs, "OfficeVersion"),
            SetupID: new XName(digsigNs, "SetupID"),
            SignatureComments: new XName(digsigNs, "SignatureComments"),
            SignatureImage: new XName(digsigNs, "SignatureImage"),
            SignatureInfoV1: new XName(digsigNs, "SignatureInfoV1"),
            SignatureProviderDetails: new XName(digsigNs, "SignatureProviderDetails"),
            SignatureProviderId: new XName(digsigNs, "SignatureProviderId"),
            SignatureProviderUrl: new XName(digsigNs, "SignatureProviderUrl"),
            SignatureText: new XName(digsigNs, "SignatureText"),
            SignatureType: new XName(digsigNs, "SignatureType"),
            VerticalResolution: new XName(digsigNs, "VerticalResolution"),
            WindowsVersion: new XName(digsigNs, "WindowsVersion"),
        }
        var DIGSIG = openXml.DIGSIG;

        openXml.dsNs = new XNamespace("http://schemas.openxmlformats.org/officeDocument/2006/customXml");
        var dsNs = openXml.dsNs;
        openXml.DS = {
            datastoreItem: new XName(dsNs, "datastoreItem"),
            itemID: new XName(dsNs, "itemID"),
            schemaRef: new XName(dsNs, "schemaRef"),
            schemaRefs: new XName(dsNs, "schemaRefs"),
            uri: new XName(dsNs, "uri"),
        }
        var DS = openXml.DS;

        openXml.dspNs = new XNamespace("http://schemas.microsoft.com/office/drawing/2008/diagram");
        var dspNs = openXml.dspNs;
        openXml.DSP = {
            dataModelExt: new XName(dspNs, "dataModelExt"),
        }
        var DSP = openXml.DSP;

        openXml.epNs = new XNamespace("http://schemas.openxmlformats.org/officeDocument/2006/extended-properties");
        var epNs = openXml.epNs;
        openXml.EP = {
            Application: new XName(epNs, "Application"),
            AppVersion: new XName(epNs, "AppVersion"),
            Characters: new XName(epNs, "Characters"),
            CharactersWithSpaces: new XName(epNs, "CharactersWithSpaces"),
            Company: new XName(epNs, "Company"),
            DocSecurity: new XName(epNs, "DocSecurity"),
            HeadingPairs: new XName(epNs, "HeadingPairs"),
            HiddenSlides: new XName(epNs, "HiddenSlides"),
            HLinks: new XName(epNs, "HLinks"),
            HyperlinkBase: new XName(epNs, "HyperlinkBase"),
            HyperlinksChanged: new XName(epNs, "HyperlinksChanged"),
            Lines: new XName(epNs, "Lines"),
            LinksUpToDate: new XName(epNs, "LinksUpToDate"),
            Manager: new XName(epNs, "Manager"),
            MMClips: new XName(epNs, "MMClips"),
            Notes: new XName(epNs, "Notes"),
            Pages: new XName(epNs, "Pages"),
            Paragraphs: new XName(epNs, "Paragraphs"),
            PresentationFormat: new XName(epNs, "PresentationFormat"),
            Properties: new XName(epNs, "Properties"),
            ScaleCrop: new XName(epNs, "ScaleCrop"),
            SharedDoc: new XName(epNs, "SharedDoc"),
            Slides: new XName(epNs, "Slides"),
            Template: new XName(epNs, "Template"),
            TitlesOfParts: new XName(epNs, "TitlesOfParts"),
            TotalTime: new XName(epNs, "TotalTime"),
            Words: new XName(epNs, "Words"),
        }
        var EP = openXml.EP;

        openXml.lcNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas");
        var lcNs = openXml.lcNs;
        openXml.LC = {
            lockedCanvas: new XName(lcNs, "lockedCanvas"),
        }
        var LC = openXml.LC;

        openXml.mNs = new XNamespace("http://schemas.openxmlformats.org/officeDocument/2006/math");
        var mNs = openXml.mNs;
        openXml.M = {
            acc: new XName(mNs, "acc"),
            accPr: new XName(mNs, "accPr"),
            aln: new XName(mNs, "aln"),
            alnAt: new XName(mNs, "alnAt"),
            alnScr: new XName(mNs, "alnScr"),
            argPr: new XName(mNs, "argPr"),
            argSz: new XName(mNs, "argSz"),
            bar: new XName(mNs, "bar"),
            barPr: new XName(mNs, "barPr"),
            baseJc: new XName(mNs, "baseJc"),
            begChr: new XName(mNs, "begChr"),
            borderBox: new XName(mNs, "borderBox"),
            borderBoxPr: new XName(mNs, "borderBoxPr"),
            box: new XName(mNs, "box"),
            boxPr: new XName(mNs, "boxPr"),
            brk: new XName(mNs, "brk"),
            brkBin: new XName(mNs, "brkBin"),
            brkBinSub: new XName(mNs, "brkBinSub"),
            cGp: new XName(mNs, "cGp"),
            cGpRule: new XName(mNs, "cGpRule"),
            chr: new XName(mNs, "chr"),
            count: new XName(mNs, "count"),
            cSp: new XName(mNs, "cSp"),
            ctrlPr: new XName(mNs, "ctrlPr"),
            d: new XName(mNs, "d"),
            defJc: new XName(mNs, "defJc"),
            deg: new XName(mNs, "deg"),
            degHide: new XName(mNs, "degHide"),
            den: new XName(mNs, "den"),
            diff: new XName(mNs, "diff"),
            dispDef: new XName(mNs, "dispDef"),
            dPr: new XName(mNs, "dPr"),
            e: new XName(mNs, "e"),
            endChr: new XName(mNs, "endChr"),
            eqArr: new XName(mNs, "eqArr"),
            eqArrPr: new XName(mNs, "eqArrPr"),
            f: new XName(mNs, "f"),
            fName: new XName(mNs, "fName"),
            fPr: new XName(mNs, "fPr"),
            func: new XName(mNs, "func"),
            funcPr: new XName(mNs, "funcPr"),
            groupChr: new XName(mNs, "groupChr"),
            groupChrPr: new XName(mNs, "groupChrPr"),
            grow: new XName(mNs, "grow"),
            hideBot: new XName(mNs, "hideBot"),
            hideLeft: new XName(mNs, "hideLeft"),
            hideRight: new XName(mNs, "hideRight"),
            hideTop: new XName(mNs, "hideTop"),
            interSp: new XName(mNs, "interSp"),
            intLim: new XName(mNs, "intLim"),
            intraSp: new XName(mNs, "intraSp"),
            jc: new XName(mNs, "jc"),
            lim: new XName(mNs, "lim"),
            limLoc: new XName(mNs, "limLoc"),
            limLow: new XName(mNs, "limLow"),
            limLowPr: new XName(mNs, "limLowPr"),
            limUpp: new XName(mNs, "limUpp"),
            limUppPr: new XName(mNs, "limUppPr"),
            lit: new XName(mNs, "lit"),
            lMargin: new XName(mNs, "lMargin"),
            _m: new XName(mNs, "m"),
            mathFont: new XName(mNs, "mathFont"),
            mathPr: new XName(mNs, "mathPr"),
            maxDist: new XName(mNs, "maxDist"),
            mc: new XName(mNs, "mc"),
            mcJc: new XName(mNs, "mcJc"),
            mcPr: new XName(mNs, "mcPr"),
            mcs: new XName(mNs, "mcs"),
            mPr: new XName(mNs, "mPr"),
            mr: new XName(mNs, "mr"),
            nary: new XName(mNs, "nary"),
            naryLim: new XName(mNs, "naryLim"),
            naryPr: new XName(mNs, "naryPr"),
            noBreak: new XName(mNs, "noBreak"),
            nor: new XName(mNs, "nor"),
            num: new XName(mNs, "num"),
            objDist: new XName(mNs, "objDist"),
            oMath: new XName(mNs, "oMath"),
            oMathPara: new XName(mNs, "oMathPara"),
            oMathParaPr: new XName(mNs, "oMathParaPr"),
            opEmu: new XName(mNs, "opEmu"),
            phant: new XName(mNs, "phant"),
            phantPr: new XName(mNs, "phantPr"),
            plcHide: new XName(mNs, "plcHide"),
            pos: new XName(mNs, "pos"),
            postSp: new XName(mNs, "postSp"),
            preSp: new XName(mNs, "preSp"),
            r: new XName(mNs, "r"),
            rad: new XName(mNs, "rad"),
            radPr: new XName(mNs, "radPr"),
            rMargin: new XName(mNs, "rMargin"),
            rPr: new XName(mNs, "rPr"),
            rSp: new XName(mNs, "rSp"),
            rSpRule: new XName(mNs, "rSpRule"),
            scr: new XName(mNs, "scr"),
            sepChr: new XName(mNs, "sepChr"),
            show: new XName(mNs, "show"),
            shp: new XName(mNs, "shp"),
            smallFrac: new XName(mNs, "smallFrac"),
            sPre: new XName(mNs, "sPre"),
            sPrePr: new XName(mNs, "sPrePr"),
            sSub: new XName(mNs, "sSub"),
            sSubPr: new XName(mNs, "sSubPr"),
            sSubSup: new XName(mNs, "sSubSup"),
            sSubSupPr: new XName(mNs, "sSubSupPr"),
            sSup: new XName(mNs, "sSup"),
            sSupPr: new XName(mNs, "sSupPr"),
            strikeBLTR: new XName(mNs, "strikeBLTR"),
            strikeH: new XName(mNs, "strikeH"),
            strikeTLBR: new XName(mNs, "strikeTLBR"),
            strikeV: new XName(mNs, "strikeV"),
            sty: new XName(mNs, "sty"),
            sub: new XName(mNs, "sub"),
            subHide: new XName(mNs, "subHide"),
            sup: new XName(mNs, "sup"),
            supHide: new XName(mNs, "supHide"),
            t: new XName(mNs, "t"),
            transp: new XName(mNs, "transp"),
            type: new XName(mNs, "type"),
            val: new XName(mNs, "val"),
            vertJc: new XName(mNs, "vertJc"),
            wrapIndent: new XName(mNs, "wrapIndent"),
            wrapRight: new XName(mNs, "wrapRight"),
            zeroAsc: new XName(mNs, "zeroAsc"),
            zeroDesc: new XName(mNs, "zeroDesc"),
            zeroWid: new XName(mNs, "zeroWid"),
        }
        var M = openXml.M;

        openXml.mcNs = new XNamespace("http://schemas.openxmlformats.org/markup-compatibility/2006");
        var mcNs = openXml.mcNs;
        openXml.MC = {
            AlternateContent: new XName(mcNs, "AlternateContent"),
            Choice: new XName(mcNs, "Choice"),
            Fallback: new XName(mcNs, "Fallback"),
            Ignorable: new XName(mcNs, "Ignorable"),
            PreserveAttributes: new XName(mcNs, "PreserveAttributes"),
        }
        var MC = openXml.MC;

        openXml.mdssiNs = new XNamespace("http://schemas.openxmlformats.org/package/2006/digital-signature");
        var mdssiNs = openXml.mdssiNs;
        openXml.MDSSI = {
            Format: new XName(mdssiNs, "Format"),
            RelationshipReference: new XName(mdssiNs, "RelationshipReference"),
            SignatureTime: new XName(mdssiNs, "SignatureTime"),
            Value: new XName(mdssiNs, "Value"),
        }
        var MDSSI = openXml.MDSSI;

        openXml.mpNs = new XNamespace("http://schemas.microsoft.com/office/mac/powerpoint/2008/main");
        var mpNs = openXml.mpNs;
        openXml.MP = {
            cube: new XName(mpNs, "cube"),
            flip: new XName(mpNs, "flip"),
            transition: new XName(mpNs, "transition"),
        }
        var MP = openXml.MP;

        openXml.mvNs = new XNamespace("urn:schemas-microsoft-com:mac:vml");
        var mvNs = openXml.mvNs;
        openXml.MV = {
            blur: new XName(mvNs, "blur"),
            complextextbox: new XName(mvNs, "complextextbox"),
        }
        var MV = openXml.MV;

        openXml.NoNamespace = {
            a: new XName("a"),
            accent1: new XName("accent1"),
            accent2: new XName("accent2"),
            accent3: new XName("accent3"),
            accent4: new XName("accent4"),
            accent5: new XName("accent5"),
            accent6: new XName("accent6"),
            action: new XName("action"),
            activeCell: new XName("activeCell"),
            activeCol: new XName("activeCol"),
            activePane: new XName("activePane"),
            activeRow: new XName("activeRow"),
            advise: new XName("advise"),
            algn: new XName("algn"),
            Algorithm: new XName("Algorithm"),
            alignWithMargins: new XName("alignWithMargins"),
            allowcomments: new XName("allowcomments"),
            allowOverlap: new XName("allowOverlap"),
            allUniqueName: new XName("allUniqueName"),
            alt: new XName("alt"),
            alwaysShow: new XName("alwaysShow"),
            amount: new XName("amount"),
            amt: new XName("amt"),
            anchor: new XName("anchor"),
            anchorCtr: new XName("anchorCtr"),
            ang: new XName("ang"),
            animBg: new XName("animBg"),
            annotation: new XName("annotation"),
            applyAlignment: new XName("applyAlignment"),
            applyAlignmentFormats: new XName("applyAlignmentFormats"),
            applyBorder: new XName("applyBorder"),
            applyBorderFormats: new XName("applyBorderFormats"),
            applyFill: new XName("applyFill"),
            applyFont: new XName("applyFont"),
            applyFontFormats: new XName("applyFontFormats"),
            applyNumberFormat: new XName("applyNumberFormat"),
            applyNumberFormats: new XName("applyNumberFormats"),
            applyPatternFormats: new XName("applyPatternFormats"),
            applyProtection: new XName("applyProtection"),
            applyWidthHeightFormats: new XName("applyWidthHeightFormats"),
            arcsize: new XName("arcsize"),
            arg: new XName("arg"),
            aspectratio: new XName("aspectratio"),
            assign: new XName("assign"),
            attribute: new XName("attribute"),
            author: new XName("author"),
            authorId: new XName("authorId"),
            auto: new XName("auto"),
            autoEnd: new XName("autoEnd"),
            autoFormatId: new XName("autoFormatId"),
            autoLine: new XName("autoLine"),
            autoStart: new XName("autoStart"),
            axis: new XName("axis"),
            b: new XName("b"),
            backdepth: new XName("backdepth"),
            bandRow: new XName("bandRow"),
            _base: new XName("base"),
            baseField: new XName("baseField"),
            baseItem: new XName("baseItem"),
            baseline: new XName("baseline"),
            baseType: new XName("baseType"),
            behindDoc: new XName("behindDoc"),
            bestFit: new XName("bestFit"),
            bg1: new XName("bg1"),
            bg2: new XName("bg2"),
            bIns: new XName("bIns"),
            bld: new XName("bld"),
            bldStep: new XName("bldStep"),
            blend: new XName("blend"),
            blurRad: new XName("blurRad"),
            bmkName: new XName("bmkName"),
            borderId: new XName("borderId"),
            bottom: new XName("bottom"),
            bright: new XName("bright"),
            brightness: new XName("brightness"),
            builtinId: new XName("builtinId"),
            bwMode: new XName("bwMode"),
            by: new XName("by"),
            c: new XName("c"),
            cacheId: new XName("cacheId"),
            cacheIndex: new XName("cacheIndex"),
            calcmode: new XName("calcmode"),
            cap: new XName("cap"),
            caption: new XName("caption"),
            categoryIdx: new XName("categoryIdx"),
            cell: new XName("cell"),
            cellColor: new XName("cellColor"),
            cellRange: new XName("cellRange"),
            _char: new XName("char"),
            charset: new XName("charset"),
            chart: new XName("chart"),
            clearComments: new XName("clearComments"),
            clearFormats: new XName("clearFormats"),
            click: new XName("click"),
            clientInsertedTime: new XName("clientInsertedTime"),
            clrIdx: new XName("clrIdx"),
            clrSpc: new XName("clrSpc"),
            cmd: new XName("cmd"),
            cmpd: new XName("cmpd"),
            codeName: new XName("codeName"),
            coerce: new XName("coerce"),
            colId: new XName("colId"),
            color: new XName("color"),
            colors: new XName("colors"),
            colorTemp: new XName("colorTemp"),
            colPageCount: new XName("colPageCount"),
            cols: new XName("cols"),
            comma: new XName("comma"),
            command: new XName("command"),
            commandType: new XName("commandType"),
            comment: new XName("comment"),
            compatLnSpc: new XName("compatLnSpc"),
            concurrent: new XName("concurrent"),
            connection: new XName("connection"),
            connectionId: new XName("connectionId"),
            connectloc: new XName("connectloc"),
            consecutive: new XName("consecutive"),
            constrainbounds: new XName("constrainbounds"),
            containsInteger: new XName("containsInteger"),
            containsNumber: new XName("containsNumber"),
            containsSemiMixedTypes: new XName("containsSemiMixedTypes"),
            containsString: new XName("containsString"),
            contrast: new XName("contrast"),
            control1: new XName("control1"),
            control2: new XName("control2"),
            coordorigin: new XName("coordorigin"),
            coordsize: new XName("coordsize"),
            copy: new XName("copy"),
            count: new XName("count"),
            createdVersion: new XName("createdVersion"),
            cryptAlgorithmClass: new XName("cryptAlgorithmClass"),
            cryptAlgorithmSid: new XName("cryptAlgorithmSid"),
            cryptAlgorithmType: new XName("cryptAlgorithmType"),
            cryptProviderType: new XName("cryptProviderType"),
            csCatId: new XName("csCatId"),
            cstate: new XName("cstate"),
            csTypeId: new XName("csTypeId"),
            culture: new XName("culture"),
            current: new XName("current"),
            customFormat: new XName("customFormat"),
            customList: new XName("customList"),
            customWidth: new XName("customWidth"),
            cx: new XName("cx"),
            cy: new XName("cy"),
            d: new XName("d"),
            data: new XName("data"),
            dataCaption: new XName("dataCaption"),
            dataDxfId: new XName("dataDxfId"),
            dataField: new XName("dataField"),
            dateTime: new XName("dateTime"),
            dateTimeGrouping: new XName("dateTimeGrouping"),
            dde: new XName("dde"),
            ddeService: new XName("ddeService"),
            ddeTopic: new XName("ddeTopic"),
            def: new XName("def"),
            defaultMemberUniqueName: new XName("defaultMemberUniqueName"),
            defaultPivotStyle: new XName("defaultPivotStyle"),
            defaultRowHeight: new XName("defaultRowHeight"),
            defaultSize: new XName("defaultSize"),
            defaultTableStyle: new XName("defaultTableStyle"),
            defStyle: new XName("defStyle"),
            defTabSz: new XName("defTabSz"),
            degree: new XName("degree"),
            delay: new XName("delay"),
            descending: new XName("descending"),
            descr: new XName("descr"),
            destId: new XName("destId"),
            destination: new XName("destination"),
            destinationFile: new XName("destinationFile"),
            destOrd: new XName("destOrd"),
            dgmfontsize: new XName("dgmfontsize"),
            dgmstyle: new XName("dgmstyle"),
            diagonalDown: new XName("diagonalDown"),
            diagonalUp: new XName("diagonalUp"),
            dimension: new XName("dimension"),
            dimensionUniqueName: new XName("dimensionUniqueName"),
            dir: new XName("dir"),
            dirty: new XName("dirty"),
            display: new XName("display"),
            displayFolder: new XName("displayFolder"),
            displayName: new XName("displayName"),
            dist: new XName("dist"),
            distB: new XName("distB"),
            distL: new XName("distL"),
            distR: new XName("distR"),
            distT: new XName("distT"),
            divId: new XName("divId"),
            dpi: new XName("dpi"),
            dr: new XName("dr"),
            DrawAspect: new XName("DrawAspect"),
            dt: new XName("dt"),
            dur: new XName("dur"),
            dx: new XName("dx"),
            dxfId: new XName("dxfId"),
            dy: new XName("dy"),
            dz: new XName("dz"),
            eaLnBrk: new XName("eaLnBrk"),
            eb: new XName("eb"),
            edited: new XName("edited"),
            editPage: new XName("editPage"),
            end: new XName("end"),
            endA: new XName("endA"),
            endangle: new XName("endangle"),
            endDate: new XName("endDate"),
            endPos: new XName("endPos"),
            endSnd: new XName("endSnd"),
            eqn: new XName("eqn"),
            evalOrder: new XName("evalOrder"),
            evt: new XName("evt"),
            exp: new XName("exp"),
            extProperty: new XName("extProperty"),
            f: new XName("f"),
            fact: new XName("fact"),
            field: new XName("field"),
            fieldId: new XName("fieldId"),
            fieldListSortAscending: new XName("fieldListSortAscending"),
            fieldPosition: new XName("fieldPosition"),
            fileType: new XName("fileType"),
            fillcolor: new XName("fillcolor"),
            filled: new XName("filled"),
            fillId: new XName("fillId"),
            filter: new XName("filter"),
            filterVal: new XName("filterVal"),
            first: new XName("first"),
            firstDataCol: new XName("firstDataCol"),
            firstDataRow: new XName("firstDataRow"),
            firstHeaderRow: new XName("firstHeaderRow"),
            firstRow: new XName("firstRow"),
            fitshape: new XName("fitshape"),
            fitToPage: new XName("fitToPage"),
            fld: new XName("fld"),
            flip: new XName("flip"),
            fmla: new XName("fmla"),
            fmtid: new XName("fmtid"),
            folHlink: new XName("folHlink"),
            followColorScheme: new XName("followColorScheme"),
            fontId: new XName("fontId"),
            footer: new XName("footer"),
            _for: new XName("for"),
            forceAA: new XName("forceAA"),
            format: new XName("format"),
            formatCode: new XName("formatCode"),
            formula: new XName("formula"),
            forName: new XName("forName"),
            fov: new XName("fov"),
            frame: new XName("frame"),
            from: new XName("from"),
            fromWordArt: new XName("fromWordArt"),
            fullCalcOnLoad: new XName("fullCalcOnLoad"),
            func: new XName("func"),
            g: new XName("g"),
            gdRefAng: new XName("gdRefAng"),
            gdRefR: new XName("gdRefR"),
            gdRefX: new XName("gdRefX"),
            gdRefY: new XName("gdRefY"),
            goal: new XName("goal"),
            gradientshapeok: new XName("gradientshapeok"),
            groupBy: new XName("groupBy"),
            grpId: new XName("grpId"),
            guid: new XName("guid"),
            h: new XName("h"),
            hangingPunct: new XName("hangingPunct"),
            hashData: new XName("hashData"),
            header: new XName("header"),
            headerRowBorderDxfId: new XName("headerRowBorderDxfId"),
            headerRowDxfId: new XName("headerRowDxfId"),
            hidden: new XName("hidden"),
            hier: new XName("hier"),
            hierarchy: new XName("hierarchy"),
            hierarchyUsage: new XName("hierarchyUsage"),
            highlightClick: new XName("highlightClick"),
            hlink: new XName("hlink"),
            horizontal: new XName("horizontal"),
            horizontalCentered: new XName("horizontalCentered"),
            horizontalDpi: new XName("horizontalDpi"),
            horzOverflow: new XName("horzOverflow"),
            hR: new XName("hR"),
            htmlFormat: new XName("htmlFormat"),
            htmlTables: new XName("htmlTables"),
            hue: new XName("hue"),
            i: new XName("i"),
            i1: new XName("i1"),
            iconId: new XName("iconId"),
            iconSet: new XName("iconSet"),
            id: new XName("id"),
            Id: new XName("Id"),
            iddest: new XName("iddest"),
            idref: new XName("idref"),
            idsrc: new XName("idsrc"),
            idx: new XName("idx"),
            imgH: new XName("imgH"),
            imgW: new XName("imgW"),
            _in: new XName("in"),
            includeNewItemsInFilter: new XName("includeNewItemsInFilter"),
            indent: new XName("indent"),
            index: new XName("index"),
            indexed: new XName("indexed"),
            initials: new XName("initials"),
            insetpen: new XName("insetpen"),
            invalEndChars: new XName("invalEndChars"),
            invalidUrl: new XName("invalidUrl"),
            invalStChars: new XName("invalStChars"),
            isInverted: new XName("isInverted"),
            issignatureline: new XName("issignatureline"),
            item: new XName("item"),
            itemPrintTitles: new XName("itemPrintTitles"),
            joinstyle: new XName("joinstyle"),
            justifyLastLine: new XName("justifyLastLine"),
            key: new XName("key"),
            keyAttribute: new XName("keyAttribute"),
            l: new XName("l"),
            lang: new XName("lang"),
            lastClr: new XName("lastClr"),
            lastIdx: new XName("lastIdx"),
            lat: new XName("lat"),
            latinLnBrk: new XName("latinLnBrk"),
            layout: new XName("layout"),
            layoutInCell: new XName("layoutInCell"),
            left: new XName("left"),
            len: new XName("len"),
            length: new XName("length"),
            level: new XName("level"),
            lightharsh2: new XName("lightharsh2"),
            lightlevel: new XName("lightlevel"),
            lightlevel2: new XName("lightlevel2"),
            lightposition: new XName("lightposition"),
            lightposition2: new XName("lightposition2"),
            lim: new XName("lim"),
            link: new XName("link"),
            lIns: new XName("lIns"),
            loCatId: new XName("loCatId"),
            locked: new XName("locked"),
            lon: new XName("lon"),
            loop: new XName("loop"),
            loTypeId: new XName("loTypeId"),
            lum: new XName("lum"),
            lvl: new XName("lvl"),
            macro: new XName("macro"),
            man: new XName("man"),
            manualBreakCount: new XName("manualBreakCount"),
            mapId: new XName("mapId"),
            marL: new XName("marL"),
            max: new XName("max"),
            maxAng: new XName("maxAng"),
            maxR: new XName("maxR"),
            maxRank: new XName("maxRank"),
            maxSheetId: new XName("maxSheetId"),
            maxValue: new XName("maxValue"),
            maxX: new XName("maxX"),
            maxY: new XName("maxY"),
            mdx: new XName("mdx"),
            measureGroup: new XName("measureGroup"),
            memberName: new XName("memberName"),
            merge: new XName("merge"),
            meth: new XName("meth"),
            min: new XName("min"),
            minAng: new XName("minAng"),
            minR: new XName("minR"),
            minRefreshableVersion: new XName("minRefreshableVersion"),
            minSupportedVersion: new XName("minSupportedVersion"),
            minValue: new XName("minValue"),
            minVer: new XName("minVer"),
            minX: new XName("minX"),
            minY: new XName("minY"),
            modelId: new XName("modelId"),
            moveWithCells: new XName("moveWithCells"),
            n: new XName("n"),
            name: new XName("name"),
            _new: new XName("new"),
            newLength: new XName("newLength"),
            newName: new XName("newName"),
            nextAc: new XName("nextAc"),
            nextId: new XName("nextId"),
            noChangeArrowheads: new XName("noChangeArrowheads"),
            noChangeAspect: new XName("noChangeAspect"),
            noChangeShapeType: new XName("noChangeShapeType"),
            nodeType: new XName("nodeType"),
            noEditPoints: new XName("noEditPoints"),
            noGrp: new XName("noGrp"),
            noRot: new XName("noRot"),
            noUngrp: new XName("noUngrp"),
            np: new XName("np"),
            ns: new XName("ns"),
            numCol: new XName("numCol"),
            numFmtId: new XName("numFmtId"),
            o: new XName("o"),
            ObjectID: new XName("ObjectID"),
            objects: new XName("objects"),
            ObjectType: new XName("ObjectType"),
            objId: new XName("objId"),
            offset: new XName("offset"),
            old: new XName("old"),
            oldComment: new XName("oldComment"),
            oldName: new XName("oldName"),
            oleUpdate: new XName("oleUpdate"),
            on: new XName("on"),
            op: new XName("op"),
            orient: new XName("orient"),
            orientation: new XName("orientation"),
            origin: new XName("origin"),
            _out: new XName("out"),
            outline: new XName("outline"),
            outlineData: new XName("outlineData"),
            p: new XName("p"),
            pane: new XName("pane"),
            panose: new XName("panose"),
            paperSize: new XName("paperSize"),
            par: new XName("par"),
            parameterType: new XName("parameterType"),
            parent: new XName("parent"),
            password: new XName("password"),
            pasteAll: new XName("pasteAll"),
            pasteValues: new XName("pasteValues"),
            path: new XName("path"),
            pathEditMode: new XName("pathEditMode"),
            patternType: new XName("patternType"),
            phldr: new XName("phldr"),
            pid: new XName("pid"),
            pitchFamily: new XName("pitchFamily"),
            pivot: new XName("pivot"),
            points: new XName("points"),
            pos: new XName("pos"),
            position: new XName("position"),
            post: new XName("post"),
            preferPic: new XName("preferPic"),
            preserve: new XName("preserve"),
            pressure: new XName("pressure"),
            previousCol: new XName("previousCol"),
            previousRow: new XName("previousRow"),
            pri: new XName("pri"),
            priority: new XName("priority"),
            progId: new XName("progId"),
            ProgID: new XName("ProgID"),
            provid: new XName("provid"),
            prst: new XName("prst"),
            prstMaterial: new XName("prstMaterial"),
            ptsTypes: new XName("ptsTypes"),
            ptType: new XName("ptType"),
            qsCatId: new XName("qsCatId"),
            qsTypeId: new XName("qsTypeId"),
            r: new XName("r"),
            rad: new XName("rad"),
            readingOrder: new XName("readingOrder"),
            recordCount: new XName("recordCount"),
            _ref: new XName("ref"),
            ref3D: new XName("ref3D"),
            refersTo: new XName("refersTo"),
            refreshedBy: new XName("refreshedBy"),
            refreshedDate: new XName("refreshedDate"),
            refreshedVersion: new XName("refreshedVersion"),
            refreshOnLoad: new XName("refreshOnLoad"),
            refType: new XName("refType"),
            relativeFrom: new XName("relativeFrom"),
            relativeHeight: new XName("relativeHeight"),
            relId: new XName("relId"),
            Requires: new XName("Requires"),
            restart: new XName("restart"),
            rev: new XName("rev"),
            rgb: new XName("rgb"),
            rId: new XName("rId"),
            rig: new XName("rig"),
            right: new XName("right"),
            rIns: new XName("rIns"),
            rot: new XName("rot"),
            rotWithShape: new XName("rotWithShape"),
            rowColShift: new XName("rowColShift"),
            rowDrillCount: new XName("rowDrillCount"),
            rowPageCount: new XName("rowPageCount"),
            rows: new XName("rows"),
            rtl: new XName("rtl"),
            rtlCol: new XName("rtlCol"),
            s: new XName("s"),
            saltData: new XName("saltData"),
            sat: new XName("sat"),
            saveData: new XName("saveData"),
            saveSubsetFonts: new XName("saveSubsetFonts"),
            sb: new XName("sb"),
            scaled: new XName("scaled"),
            scaling: new XName("scaling"),
            scenarios: new XName("scenarios"),
            scope: new XName("scope"),
            script: new XName("script"),
            securityDescriptor: new XName("securityDescriptor"),
            seek: new XName("seek"),
            sendLocale: new XName("sendLocale"),
            series: new XName("series"),
            seriesIdx: new XName("seriesIdx"),
            serverSldId: new XName("serverSldId"),
            serverSldModifiedTime: new XName("serverSldModifiedTime"),
            setDefinition: new XName("setDefinition"),
            shapeId: new XName("shapeId"),
            ShapeID: new XName("ShapeID"),
            sheet: new XName("sheet"),
            sheetId: new XName("sheetId"),
            sheetPosition: new XName("sheetPosition"),
            show: new XName("show"),
            showAll: new XName("showAll"),
            showCaptions: new XName("showCaptions"),
            showColHeaders: new XName("showColHeaders"),
            showColStripes: new XName("showColStripes"),
            showColumnStripes: new XName("showColumnStripes"),
            showErrorMessage: new XName("showErrorMessage"),
            showFirstColumn: new XName("showFirstColumn"),
            showHeader: new XName("showHeader"),
            showInputMessage: new XName("showInputMessage"),
            showLastColumn: new XName("showLastColumn"),
            showRowHeaders: new XName("showRowHeaders"),
            showRowStripes: new XName("showRowStripes"),
            showValue: new XName("showValue"),
            shrinkToFit: new XName("shrinkToFit"),
            si: new XName("si"),
            sId: new XName("sId"),
            simplePos: new XName("simplePos"),
            size: new XName("size"),
            skewangle: new XName("skewangle"),
            smoothness: new XName("smoothness"),
            smtClean: new XName("smtClean"),
            source: new XName("source"),
            sourceFile: new XName("sourceFile"),
            SourceId: new XName("SourceId"),
            sourceLinked: new XName("sourceLinked"),
            sourceSheetId: new XName("sourceSheetId"),
            sourceType: new XName("sourceType"),
            sp: new XName("sp"),
            spans: new XName("spans"),
            spcCol: new XName("spcCol"),
            spcFirstLastPara: new XName("spcFirstLastPara"),
            spid: new XName("spid"),
            spidmax: new XName("spidmax"),
            spinCount: new XName("spinCount"),
            splitFirst: new XName("splitFirst"),
            spokes: new XName("spokes"),
            sqlType: new XName("sqlType"),
            sqref: new XName("sqref"),
            src: new XName("src"),
            srcId: new XName("srcId"),
            srcOrd: new XName("srcOrd"),
            st: new XName("st"),
            stA: new XName("stA"),
            stAng: new XName("stAng"),
            start: new XName("start"),
            startangle: new XName("startangle"),
            startDate: new XName("startDate"),
            status: new XName("status"),
            strike: new XName("strike"),
            _string: new XName("string"),
            strokecolor: new XName("strokecolor"),
            stroked: new XName("stroked"),
            strokeweight: new XName("strokeweight"),
            style: new XName("style"),
            styleId: new XName("styleId"),
            styleName: new XName("styleName"),
            subtotal: new XName("subtotal"),
            summaryBelow: new XName("summaryBelow"),
            swAng: new XName("swAng"),
            sx: new XName("sx"),
            sy: new XName("sy"),
            sz: new XName("sz"),
            t: new XName("t"),
            tab: new XName("tab"),
            tableBorderDxfId: new XName("tableBorderDxfId"),
            tableColumnId: new XName("tableColumnId"),
            Target: new XName("Target"),
            textlink: new XName("textlink"),
            textRotation: new XName("textRotation"),
            theme: new XName("theme"),
            thresh: new XName("thresh"),
            thruBlk: new XName("thruBlk"),
            time: new XName("time"),
            tIns: new XName("tIns"),
            tint: new XName("tint"),
            tm: new XName("tm"),
            to: new XName("to"),
            tooltip: new XName("tooltip"),
            top: new XName("top"),
            topLabels: new XName("topLabels"),
            topLeftCell: new XName("topLeftCell"),
            totalsRowShown: new XName("totalsRowShown"),
            track: new XName("track"),
            trans: new XName("trans"),
            transition: new XName("transition"),
            trend: new XName("trend"),
            twoDigitTextYear: new XName("twoDigitTextYear"),
            tx: new XName("tx"),
            tx1: new XName("tx1"),
            tx2: new XName("tx2"),
            txBox: new XName("txBox"),
            txbxSeq: new XName("txbxSeq"),
            txbxStory: new XName("txbxStory"),
            ty: new XName("ty"),
            type: new XName("type"),
            Type: new XName("Type"),
            typeface: new XName("typeface"),
            u: new XName("u"),
            ua: new XName("ua"),
            uiExpand: new XName("uiExpand"),
            unbalanced: new XName("unbalanced"),
            uniqueCount: new XName("uniqueCount"),
            uniqueId: new XName("uniqueId"),
            uniqueName: new XName("uniqueName"),
            uniqueParent: new XName("uniqueParent"),
            updateAutomatic: new XName("updateAutomatic"),
            updatedVersion: new XName("updatedVersion"),
            uri: new XName("uri"),
            URI: new XName("URI"),
            url: new XName("url"),
            useAutoFormatting: new XName("useAutoFormatting"),
            useDef: new XName("useDef"),
            user: new XName("user"),
            userName: new XName("userName"),
            v: new XName("v"),
            val: new XName("val"),
            value: new XName("value"),
            valueType: new XName("valueType"),
            varScale: new XName("varScale"),
            vert: new XName("vert"),
            vertical: new XName("vertical"),
            verticalCentered: new XName("verticalCentered"),
            verticalDpi: new XName("verticalDpi"),
            vertOverflow: new XName("vertOverflow"),
            viewpoint: new XName("viewpoint"),
            viewpointorigin: new XName("viewpointorigin"),
            w: new XName("w"),
            weight: new XName("weight"),
            width: new XName("width"),
            workbookViewId: new XName("workbookViewId"),
            wR: new XName("wR"),
            wrap: new XName("wrap"),
            wrapText: new XName("wrapText"),
            x: new XName("x"),
            x1: new XName("x1"),
            x2: new XName("x2"),
            xfId: new XName("xfId"),
            xl97: new XName("xl97"),
            xmlDataType: new XName("xmlDataType"),
            xpath: new XName("xpath"),
            xSplit: new XName("xSplit"),
            y: new XName("y"),
            y1: new XName("y1"),
            y2: new XName("y2"),
            year: new XName("year"),
            yrange: new XName("yrange"),
            ySplit: new XName("ySplit"),
            z: new XName("z"),
        }
        var NoNamespace = openXml.NoNamespace;

        openXml.oNs = new XNamespace("urn:schemas-microsoft-com:office:office");
        var oNs = openXml.oNs;
        openXml.O = {
            allowincell: new XName(oNs, "allowincell"),
            allowoverlap: new XName(oNs, "allowoverlap"),
            althref: new XName(oNs, "althref"),
            borderbottomcolor: new XName(oNs, "borderbottomcolor"),
            borderleftcolor: new XName(oNs, "borderleftcolor"),
            borderrightcolor: new XName(oNs, "borderrightcolor"),
            bordertopcolor: new XName(oNs, "bordertopcolor"),
            bottom: new XName(oNs, "bottom"),
            bullet: new XName(oNs, "bullet"),
            button: new XName(oNs, "button"),
            bwmode: new XName(oNs, "bwmode"),
            bwnormal: new XName(oNs, "bwnormal"),
            bwpure: new XName(oNs, "bwpure"),
            callout: new XName(oNs, "callout"),
            clip: new XName(oNs, "clip"),
            clippath: new XName(oNs, "clippath"),
            cliptowrap: new XName(oNs, "cliptowrap"),
            colormenu: new XName(oNs, "colormenu"),
            colormru: new XName(oNs, "colormru"),
            column: new XName(oNs, "column"),
            complex: new XName(oNs, "complex"),
            connectangles: new XName(oNs, "connectangles"),
            connectlocs: new XName(oNs, "connectlocs"),
            connectortype: new XName(oNs, "connectortype"),
            connecttype: new XName(oNs, "connecttype"),
            detectmouseclick: new XName(oNs, "detectmouseclick"),
            dgmlayout: new XName(oNs, "dgmlayout"),
            dgmlayoutmru: new XName(oNs, "dgmlayoutmru"),
            dgmnodekind: new XName(oNs, "dgmnodekind"),
            diagram: new XName(oNs, "diagram"),
            doubleclicknotify: new XName(oNs, "doubleclicknotify"),
            entry: new XName(oNs, "entry"),
            extrusion: new XName(oNs, "extrusion"),
            extrusionok: new XName(oNs, "extrusionok"),
            FieldCodes: new XName(oNs, "FieldCodes"),
            fill: new XName(oNs, "fill"),
            forcedash: new XName(oNs, "forcedash"),
            gfxdata: new XName(oNs, "gfxdata"),
            hr: new XName(oNs, "hr"),
            hralign: new XName(oNs, "hralign"),
            href: new XName(oNs, "href"),
            hrnoshade: new XName(oNs, "hrnoshade"),
            hrpct: new XName(oNs, "hrpct"),
            hrstd: new XName(oNs, "hrstd"),
            idmap: new XName(oNs, "idmap"),
            ink: new XName(oNs, "ink"),
            insetmode: new XName(oNs, "insetmode"),
            left: new XName(oNs, "left"),
            LinkType: new XName(oNs, "LinkType"),
            _lock: new XName(oNs, "lock"),
            LockedField: new XName(oNs, "LockedField"),
            master: new XName(oNs, "master"),
            ole: new XName(oNs, "ole"),
            oleicon: new XName(oNs, "oleicon"),
            OLEObject: new XName(oNs, "OLEObject"),
            oned: new XName(oNs, "oned"),
            opacity2: new XName(oNs, "opacity2"),
            preferrelative: new XName(oNs, "preferrelative"),
            proxy: new XName(oNs, "proxy"),
            r: new XName(oNs, "r"),
            regroupid: new XName(oNs, "regroupid"),
            regrouptable: new XName(oNs, "regrouptable"),
            rel: new XName(oNs, "rel"),
            relationtable: new XName(oNs, "relationtable"),
            relid: new XName(oNs, "relid"),
            right: new XName(oNs, "right"),
            rules: new XName(oNs, "rules"),
            shapedefaults: new XName(oNs, "shapedefaults"),
            shapelayout: new XName(oNs, "shapelayout"),
            signatureline: new XName(oNs, "signatureline"),
            singleclick: new XName(oNs, "singleclick"),
            skew: new XName(oNs, "skew"),
            spid: new XName(oNs, "spid"),
            spt: new XName(oNs, "spt"),
            suggestedsigner: new XName(oNs, "suggestedsigner"),
            suggestedsigner2: new XName(oNs, "suggestedsigner2"),
            suggestedsigneremail: new XName(oNs, "suggestedsigneremail"),
            tablelimits: new XName(oNs, "tablelimits"),
            tableproperties: new XName(oNs, "tableproperties"),
            targetscreensize: new XName(oNs, "targetscreensize"),
            title: new XName(oNs, "title"),
            top: new XName(oNs, "top"),
            userdrawn: new XName(oNs, "userdrawn"),
            userhidden: new XName(oNs, "userhidden"),
            v: new XName(oNs, "v"),
        }
        var O = openXml.O;

        openXml.pNs = new XNamespace("http://schemas.openxmlformats.org/presentationml/2006/main");
        var pNs = openXml.pNs;
        openXml.P = {
            anim: new XName(pNs, "anim"),
            animClr: new XName(pNs, "animClr"),
            animEffect: new XName(pNs, "animEffect"),
            animMotion: new XName(pNs, "animMotion"),
            animRot: new XName(pNs, "animRot"),
            animScale: new XName(pNs, "animScale"),
            attrName: new XName(pNs, "attrName"),
            attrNameLst: new XName(pNs, "attrNameLst"),
            audio: new XName(pNs, "audio"),
            bg: new XName(pNs, "bg"),
            bgPr: new XName(pNs, "bgPr"),
            bgRef: new XName(pNs, "bgRef"),
            bldAsOne: new XName(pNs, "bldAsOne"),
            bldDgm: new XName(pNs, "bldDgm"),
            bldGraphic: new XName(pNs, "bldGraphic"),
            bldLst: new XName(pNs, "bldLst"),
            bldOleChart: new XName(pNs, "bldOleChart"),
            bldP: new XName(pNs, "bldP"),
            bldSub: new XName(pNs, "bldSub"),
            blinds: new XName(pNs, "blinds"),
            blipFill: new XName(pNs, "blipFill"),
            bodyStyle: new XName(pNs, "bodyStyle"),
            bold: new XName(pNs, "bold"),
            boldItalic: new XName(pNs, "boldItalic"),
            boolVal: new XName(pNs, "boolVal"),
            by: new XName(pNs, "by"),
            cBhvr: new XName(pNs, "cBhvr"),
            charRg: new XName(pNs, "charRg"),
            checker: new XName(pNs, "checker"),
            childTnLst: new XName(pNs, "childTnLst"),
            circle: new XName(pNs, "circle"),
            clrMap: new XName(pNs, "clrMap"),
            clrMapOvr: new XName(pNs, "clrMapOvr"),
            clrVal: new XName(pNs, "clrVal"),
            cm: new XName(pNs, "cm"),
            cmAuthor: new XName(pNs, "cmAuthor"),
            cmAuthorLst: new XName(pNs, "cmAuthorLst"),
            cmd: new XName(pNs, "cmd"),
            cMediaNode: new XName(pNs, "cMediaNode"),
            cmLst: new XName(pNs, "cmLst"),
            cNvCxnSpPr: new XName(pNs, "cNvCxnSpPr"),
            cNvGraphicFramePr: new XName(pNs, "cNvGraphicFramePr"),
            cNvGrpSpPr: new XName(pNs, "cNvGrpSpPr"),
            cNvPicPr: new XName(pNs, "cNvPicPr"),
            cNvPr: new XName(pNs, "cNvPr"),
            cNvSpPr: new XName(pNs, "cNvSpPr"),
            comb: new XName(pNs, "comb"),
            cond: new XName(pNs, "cond"),
            contentPart: new XName(pNs, "contentPart"),
            control: new XName(pNs, "control"),
            controls: new XName(pNs, "controls"),
            cover: new XName(pNs, "cover"),
            cSld: new XName(pNs, "cSld"),
            cSldViewPr: new XName(pNs, "cSldViewPr"),
            cTn: new XName(pNs, "cTn"),
            custData: new XName(pNs, "custData"),
            custDataLst: new XName(pNs, "custDataLst"),
            custShow: new XName(pNs, "custShow"),
            custShowLst: new XName(pNs, "custShowLst"),
            cut: new XName(pNs, "cut"),
            cViewPr: new XName(pNs, "cViewPr"),
            cxnSp: new XName(pNs, "cxnSp"),
            defaultTextStyle: new XName(pNs, "defaultTextStyle"),
            diamond: new XName(pNs, "diamond"),
            dissolve: new XName(pNs, "dissolve"),
            embed: new XName(pNs, "embed"),
            embeddedFont: new XName(pNs, "embeddedFont"),
            embeddedFontLst: new XName(pNs, "embeddedFontLst"),
            endCondLst: new XName(pNs, "endCondLst"),
            endSnd: new XName(pNs, "endSnd"),
            endSync: new XName(pNs, "endSync"),
            ext: new XName(pNs, "ext"),
            extLst: new XName(pNs, "extLst"),
            fade: new XName(pNs, "fade"),
            fltVal: new XName(pNs, "fltVal"),
            font: new XName(pNs, "font"),
            from: new XName(pNs, "from"),
            graphicEl: new XName(pNs, "graphicEl"),
            graphicFrame: new XName(pNs, "graphicFrame"),
            gridSpacing: new XName(pNs, "gridSpacing"),
            grpSp: new XName(pNs, "grpSp"),
            grpSpPr: new XName(pNs, "grpSpPr"),
            guide: new XName(pNs, "guide"),
            guideLst: new XName(pNs, "guideLst"),
            handoutMaster: new XName(pNs, "handoutMaster"),
            handoutMasterId: new XName(pNs, "handoutMasterId"),
            handoutMasterIdLst: new XName(pNs, "handoutMasterIdLst"),
            hf: new XName(pNs, "hf"),
            hsl: new XName(pNs, "hsl"),
            inkTgt: new XName(pNs, "inkTgt"),
            italic: new XName(pNs, "italic"),
            iterate: new XName(pNs, "iterate"),
            kinsoku: new XName(pNs, "kinsoku"),
            link: new XName(pNs, "link"),
            modifyVerifier: new XName(pNs, "modifyVerifier"),
            newsflash: new XName(pNs, "newsflash"),
            nextCondLst: new XName(pNs, "nextCondLst"),
            normalViewPr: new XName(pNs, "normalViewPr"),
            notes: new XName(pNs, "notes"),
            notesMaster: new XName(pNs, "notesMaster"),
            notesMasterId: new XName(pNs, "notesMasterId"),
            notesMasterIdLst: new XName(pNs, "notesMasterIdLst"),
            notesStyle: new XName(pNs, "notesStyle"),
            notesSz: new XName(pNs, "notesSz"),
            notesTextViewPr: new XName(pNs, "notesTextViewPr"),
            notesViewPr: new XName(pNs, "notesViewPr"),
            nvCxnSpPr: new XName(pNs, "nvCxnSpPr"),
            nvGraphicFramePr: new XName(pNs, "nvGraphicFramePr"),
            nvGrpSpPr: new XName(pNs, "nvGrpSpPr"),
            nvPicPr: new XName(pNs, "nvPicPr"),
            nvPr: new XName(pNs, "nvPr"),
            nvSpPr: new XName(pNs, "nvSpPr"),
            oleChartEl: new XName(pNs, "oleChartEl"),
            oleObj: new XName(pNs, "oleObj"),
            origin: new XName(pNs, "origin"),
            otherStyle: new XName(pNs, "otherStyle"),
            outlineViewPr: new XName(pNs, "outlineViewPr"),
            par: new XName(pNs, "par"),
            ph: new XName(pNs, "ph"),
            photoAlbum: new XName(pNs, "photoAlbum"),
            pic: new XName(pNs, "pic"),
            plus: new XName(pNs, "plus"),
            pos: new XName(pNs, "pos"),
            presentation: new XName(pNs, "presentation"),
            prevCondLst: new XName(pNs, "prevCondLst"),
            pRg: new XName(pNs, "pRg"),
            pull: new XName(pNs, "pull"),
            push: new XName(pNs, "push"),
            random: new XName(pNs, "random"),
            randomBar: new XName(pNs, "randomBar"),
            rCtr: new XName(pNs, "rCtr"),
            regular: new XName(pNs, "regular"),
            restoredLeft: new XName(pNs, "restoredLeft"),
            restoredTop: new XName(pNs, "restoredTop"),
            rgb: new XName(pNs, "rgb"),
            rtn: new XName(pNs, "rtn"),
            scale: new XName(pNs, "scale"),
            seq: new XName(pNs, "seq"),
            set: new XName(pNs, "set"),
            sld: new XName(pNs, "sld"),
            sldId: new XName(pNs, "sldId"),
            sldIdLst: new XName(pNs, "sldIdLst"),
            sldLayout: new XName(pNs, "sldLayout"),
            sldLayoutId: new XName(pNs, "sldLayoutId"),
            sldLayoutIdLst: new XName(pNs, "sldLayoutIdLst"),
            sldLst: new XName(pNs, "sldLst"),
            sldMaster: new XName(pNs, "sldMaster"),
            sldMasterId: new XName(pNs, "sldMasterId"),
            sldMasterIdLst: new XName(pNs, "sldMasterIdLst"),
            sldSyncPr: new XName(pNs, "sldSyncPr"),
            sldSz: new XName(pNs, "sldSz"),
            sldTgt: new XName(pNs, "sldTgt"),
            slideViewPr: new XName(pNs, "slideViewPr"),
            snd: new XName(pNs, "snd"),
            sndAc: new XName(pNs, "sndAc"),
            sndTgt: new XName(pNs, "sndTgt"),
            sorterViewPr: new XName(pNs, "sorterViewPr"),
            sp: new XName(pNs, "sp"),
            split: new XName(pNs, "split"),
            spPr: new XName(pNs, "spPr"),
            spTgt: new XName(pNs, "spTgt"),
            spTree: new XName(pNs, "spTree"),
            stCondLst: new XName(pNs, "stCondLst"),
            strips: new XName(pNs, "strips"),
            strVal: new XName(pNs, "strVal"),
            stSnd: new XName(pNs, "stSnd"),
            style: new XName(pNs, "style"),
            subSp: new XName(pNs, "subSp"),
            subTnLst: new XName(pNs, "subTnLst"),
            tag: new XName(pNs, "tag"),
            tagLst: new XName(pNs, "tagLst"),
            tags: new XName(pNs, "tags"),
            tav: new XName(pNs, "tav"),
            tavLst: new XName(pNs, "tavLst"),
            text: new XName(pNs, "text"),
            tgtEl: new XName(pNs, "tgtEl"),
            timing: new XName(pNs, "timing"),
            titleStyle: new XName(pNs, "titleStyle"),
            tmAbs: new XName(pNs, "tmAbs"),
            tmPct: new XName(pNs, "tmPct"),
            tmpl: new XName(pNs, "tmpl"),
            tmplLst: new XName(pNs, "tmplLst"),
            tn: new XName(pNs, "tn"),
            tnLst: new XName(pNs, "tnLst"),
            to: new XName(pNs, "to"),
            transition: new XName(pNs, "transition"),
            txBody: new XName(pNs, "txBody"),
            txEl: new XName(pNs, "txEl"),
            txStyles: new XName(pNs, "txStyles"),
            val: new XName(pNs, "val"),
            video: new XName(pNs, "video"),
            viewPr: new XName(pNs, "viewPr"),
            wedge: new XName(pNs, "wedge"),
            wheel: new XName(pNs, "wheel"),
            wipe: new XName(pNs, "wipe"),
            xfrm: new XName(pNs, "xfrm"),
            zoom: new XName(pNs, "zoom"),
        }
        var P = openXml.P;

        openXml.p14Ns = new XNamespace("http://schemas.microsoft.com/office/powerpoint/2010/main");
        var p14Ns = openXml.p14Ns;
        openXml.P14 = {
            bmk: new XName(p14Ns, "bmk"),
            bmkLst: new XName(p14Ns, "bmkLst"),
            bmkTgt: new XName(p14Ns, "bmkTgt"),
            bounceEnd: new XName(p14Ns, "bounceEnd"),
            bwMode: new XName(p14Ns, "bwMode"),
            cNvContentPartPr: new XName(p14Ns, "cNvContentPartPr"),
            cNvPr: new XName(p14Ns, "cNvPr"),
            conveyor: new XName(p14Ns, "conveyor"),
            creationId: new XName(p14Ns, "creationId"),
            doors: new XName(p14Ns, "doors"),
            dur: new XName(p14Ns, "dur"),
            extLst: new XName(p14Ns, "extLst"),
            fade: new XName(p14Ns, "fade"),
            ferris: new XName(p14Ns, "ferris"),
            flash: new XName(p14Ns, "flash"),
            flip: new XName(p14Ns, "flip"),
            flythrough: new XName(p14Ns, "flythrough"),
            gallery: new XName(p14Ns, "gallery"),
            glitter: new XName(p14Ns, "glitter"),
            honeycomb: new XName(p14Ns, "honeycomb"),
            laserTraceLst: new XName(p14Ns, "laserTraceLst"),
            media: new XName(p14Ns, "media"),
            modId: new XName(p14Ns, "modId"),
            nvContentPartPr: new XName(p14Ns, "nvContentPartPr"),
            nvPr: new XName(p14Ns, "nvPr"),
            pan: new XName(p14Ns, "pan"),
            pauseEvt: new XName(p14Ns, "pauseEvt"),
            playEvt: new XName(p14Ns, "playEvt"),
            presetBounceEnd: new XName(p14Ns, "presetBounceEnd"),
            prism: new XName(p14Ns, "prism"),
            resumeEvt: new XName(p14Ns, "resumeEvt"),
            reveal: new XName(p14Ns, "reveal"),
            ripple: new XName(p14Ns, "ripple"),
            section: new XName(p14Ns, "section"),
            sectionLst: new XName(p14Ns, "sectionLst"),
            seekEvt: new XName(p14Ns, "seekEvt"),
            showEvtLst: new XName(p14Ns, "showEvtLst"),
            shred: new XName(p14Ns, "shred"),
            sldId: new XName(p14Ns, "sldId"),
            sldIdLst: new XName(p14Ns, "sldIdLst"),
            stopEvt: new XName(p14Ns, "stopEvt"),
            _switch: new XName(p14Ns, "switch"),
            tracePt: new XName(p14Ns, "tracePt"),
            tracePtLst: new XName(p14Ns, "tracePtLst"),
            triggerEvt: new XName(p14Ns, "triggerEvt"),
            trim: new XName(p14Ns, "trim"),
            vortex: new XName(p14Ns, "vortex"),
            warp: new XName(p14Ns, "warp"),
            wheelReverse: new XName(p14Ns, "wheelReverse"),
            window: new XName(p14Ns, "window"),
            xfrm: new XName(p14Ns, "xfrm"),
        }
        var P14 = openXml.P14;

        openXml.p15Ns = new XNamespace("http://schemas.microsoft.com/office15/powerpoint");
        var p15Ns = openXml.p15Ns;
        openXml.P15 = {
            extElement: new XName(p15Ns, "extElement"),
        }
        var P15 = openXml.P15;

        openXml.picNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/picture");
        var picNs = openXml.picNs;
        openXml.Pic = {
            blipFill: new XName(picNs, "blipFill"),
            cNvPicPr: new XName(picNs, "cNvPicPr"),
            cNvPr: new XName(picNs, "cNvPr"),
            nvPicPr: new XName(picNs, "nvPicPr"),
            _pic: new XName(picNs, "pic"),
            spPr: new XName(picNs, "spPr"),
        }
        var Pic = openXml.Pic;

        openXml.rNs = new XNamespace("http://schemas.openxmlformats.org/officeDocument/2006/relationships");

        var rNs = openXml.rNs;
        openXml.R = {
            blip: new XName(rNs, "blip"),
            cs: new XName(rNs, "cs"),
            dm: new XName(rNs, "dm"),
            embed: new XName(rNs, "embed"),
            href: new XName(rNs, "href"),
            id: new XName(rNs, "id"),
            link: new XName(rNs, "link"),
            lo: new XName(rNs, "lo"),
            pict: new XName(rNs, "pict"),
            qs: new XName(rNs, "qs"),
            verticalDpi: new XName(rNs, "verticalDpi"),
        }
        var R = openXml.R;

        openXml.sNs = new XNamespace("http://schemas.openxmlformats.org/spreadsheetml/2006/main");
        var sNs = openXml.sNs;
        openXml.S = {
            alignment: new XName(sNs, "alignment"),
            anchor: new XName(sNs, "anchor"),
            author: new XName(sNs, "author"),
            authors: new XName(sNs, "authors"),
            autoFilter: new XName(sNs, "autoFilter"),
            autoSortScope: new XName(sNs, "autoSortScope"),
            b: new XName(sNs, "b"),
            bgColor: new XName(sNs, "bgColor"),
            bk: new XName(sNs, "bk"),
            border: new XName(sNs, "border"),
            borders: new XName(sNs, "borders"),
            bottom: new XName(sNs, "bottom"),
            brk: new XName(sNs, "brk"),
            c: new XName(sNs, "c"),
            cacheField: new XName(sNs, "cacheField"),
            cacheFields: new XName(sNs, "cacheFields"),
            cacheHierarchies: new XName(sNs, "cacheHierarchies"),
            cacheHierarchy: new XName(sNs, "cacheHierarchy"),
            cacheSource: new XName(sNs, "cacheSource"),
            calcChain: new XName(sNs, "calcChain"),
            calcPr: new XName(sNs, "calcPr"),
            calculatedColumnFormula: new XName(sNs, "calculatedColumnFormula"),
            calculatedItem: new XName(sNs, "calculatedItem"),
            calculatedItems: new XName(sNs, "calculatedItems"),
            calculatedMember: new XName(sNs, "calculatedMember"),
            calculatedMembers: new XName(sNs, "calculatedMembers"),
            cell: new XName(sNs, "cell"),
            cellMetadata: new XName(sNs, "cellMetadata"),
            cellSmartTag: new XName(sNs, "cellSmartTag"),
            cellSmartTagPr: new XName(sNs, "cellSmartTagPr"),
            cellSmartTags: new XName(sNs, "cellSmartTags"),
            cellStyle: new XName(sNs, "cellStyle"),
            cellStyles: new XName(sNs, "cellStyles"),
            cellStyleXfs: new XName(sNs, "cellStyleXfs"),
            cellWatch: new XName(sNs, "cellWatch"),
            cellWatches: new XName(sNs, "cellWatches"),
            cellXfs: new XName(sNs, "cellXfs"),
            cfRule: new XName(sNs, "cfRule"),
            cfvo: new XName(sNs, "cfvo"),
            charset: new XName(sNs, "charset"),
            chartFormat: new XName(sNs, "chartFormat"),
            chartFormats: new XName(sNs, "chartFormats"),
            chartsheet: new XName(sNs, "chartsheet"),
            col: new XName(sNs, "col"),
            colBreaks: new XName(sNs, "colBreaks"),
            colFields: new XName(sNs, "colFields"),
            colHierarchiesUsage: new XName(sNs, "colHierarchiesUsage"),
            colHierarchyUsage: new XName(sNs, "colHierarchyUsage"),
            colItems: new XName(sNs, "colItems"),
            color: new XName(sNs, "color"),
            colorFilter: new XName(sNs, "colorFilter"),
            colors: new XName(sNs, "colors"),
            colorScale: new XName(sNs, "colorScale"),
            cols: new XName(sNs, "cols"),
            comment: new XName(sNs, "comment"),
            commentList: new XName(sNs, "commentList"),
            comments: new XName(sNs, "comments"),
            condense: new XName(sNs, "condense"),
            conditionalFormat: new XName(sNs, "conditionalFormat"),
            conditionalFormats: new XName(sNs, "conditionalFormats"),
            conditionalFormatting: new XName(sNs, "conditionalFormatting"),
            connection: new XName(sNs, "connection"),
            connections: new XName(sNs, "connections"),
            consolidation: new XName(sNs, "consolidation"),
            control: new XName(sNs, "control"),
            controlPr: new XName(sNs, "controlPr"),
            controls: new XName(sNs, "controls"),
            customFilter: new XName(sNs, "customFilter"),
            customFilters: new XName(sNs, "customFilters"),
            customPr: new XName(sNs, "customPr"),
            customProperties: new XName(sNs, "customProperties"),
            customSheetView: new XName(sNs, "customSheetView"),
            customSheetViews: new XName(sNs, "customSheetViews"),
            d: new XName(sNs, "d"),
            dataBar: new XName(sNs, "dataBar"),
            dataConsolidate: new XName(sNs, "dataConsolidate"),
            dataField: new XName(sNs, "dataField"),
            dataFields: new XName(sNs, "dataFields"),
            dataRef: new XName(sNs, "dataRef"),
            dataRefs: new XName(sNs, "dataRefs"),
            dataValidation: new XName(sNs, "dataValidation"),
            dataValidations: new XName(sNs, "dataValidations"),
            dateGroupItem: new XName(sNs, "dateGroupItem"),
            dbPr: new XName(sNs, "dbPr"),
            ddeItem: new XName(sNs, "ddeItem"),
            ddeItems: new XName(sNs, "ddeItems"),
            ddeLink: new XName(sNs, "ddeLink"),
            definedName: new XName(sNs, "definedName"),
            definedNames: new XName(sNs, "definedNames"),
            deletedField: new XName(sNs, "deletedField"),
            diagonal: new XName(sNs, "diagonal"),
            dialogsheet: new XName(sNs, "dialogsheet"),
            dimension: new XName(sNs, "dimension"),
            dimensions: new XName(sNs, "dimensions"),
            discretePr: new XName(sNs, "discretePr"),
            drawing: new XName(sNs, "drawing"),
            dxf: new XName(sNs, "dxf"),
            dxfs: new XName(sNs, "dxfs"),
            dynamicFilter: new XName(sNs, "dynamicFilter"),
            e: new XName(sNs, "e"),
            entries: new XName(sNs, "entries"),
            evenFooter: new XName(sNs, "evenFooter"),
            evenHeader: new XName(sNs, "evenHeader"),
            ext: new XName(sNs, "ext"),
            extend: new XName(sNs, "extend"),
            externalBook: new XName(sNs, "externalBook"),
            externalLink: new XName(sNs, "externalLink"),
            extLst: new XName(sNs, "extLst"),
            f: new XName(sNs, "f"),
            family: new XName(sNs, "family"),
            fgColor: new XName(sNs, "fgColor"),
            field: new XName(sNs, "field"),
            fieldGroup: new XName(sNs, "fieldGroup"),
            fieldsUsage: new XName(sNs, "fieldsUsage"),
            fieldUsage: new XName(sNs, "fieldUsage"),
            fill: new XName(sNs, "fill"),
            fills: new XName(sNs, "fills"),
            filter: new XName(sNs, "filter"),
            filterColumn: new XName(sNs, "filterColumn"),
            filters: new XName(sNs, "filters"),
            firstFooter: new XName(sNs, "firstFooter"),
            firstHeader: new XName(sNs, "firstHeader"),
            font: new XName(sNs, "font"),
            fonts: new XName(sNs, "fonts"),
            foo: new XName(sNs, "foo"),
            format: new XName(sNs, "format"),
            formats: new XName(sNs, "formats"),
            formula: new XName(sNs, "formula"),
            formula1: new XName(sNs, "formula1"),
            formula2: new XName(sNs, "formula2"),
            from: new XName(sNs, "from"),
            futureMetadata: new XName(sNs, "futureMetadata"),
            gradientFill: new XName(sNs, "gradientFill"),
            group: new XName(sNs, "group"),
            groupItems: new XName(sNs, "groupItems"),
            groupLevel: new XName(sNs, "groupLevel"),
            groupLevels: new XName(sNs, "groupLevels"),
            groupMember: new XName(sNs, "groupMember"),
            groupMembers: new XName(sNs, "groupMembers"),
            groups: new XName(sNs, "groups"),
            header: new XName(sNs, "header"),
            headerFooter: new XName(sNs, "headerFooter"),
            headers: new XName(sNs, "headers"),
            horizontal: new XName(sNs, "horizontal"),
            hyperlink: new XName(sNs, "hyperlink"),
            hyperlinks: new XName(sNs, "hyperlinks"),
            i: new XName(sNs, "i"),
            iconFilter: new XName(sNs, "iconFilter"),
            iconSet: new XName(sNs, "iconSet"),
            ignoredError: new XName(sNs, "ignoredError"),
            ignoredErrors: new XName(sNs, "ignoredErrors"),
            indexedColors: new XName(sNs, "indexedColors"),
            inputCells: new XName(sNs, "inputCells"),
            _is: new XName(sNs, "is"),
            item: new XName(sNs, "item"),
            items: new XName(sNs, "items"),
            k: new XName(sNs, "k"),
            kpi: new XName(sNs, "kpi"),
            kpis: new XName(sNs, "kpis"),
            left: new XName(sNs, "left"),
            legacyDrawing: new XName(sNs, "legacyDrawing"),
            legacyDrawingHF: new XName(sNs, "legacyDrawingHF"),
            location: new XName(sNs, "location"),
            m: new XName(sNs, "m"),
            main: new XName(sNs, "main"),
            map: new XName(sNs, "map"),
            maps: new XName(sNs, "maps"),
            mdx: new XName(sNs, "mdx"),
            mdxMetadata: new XName(sNs, "mdxMetadata"),
            measureGroup: new XName(sNs, "measureGroup"),
            measureGroups: new XName(sNs, "measureGroups"),
            member: new XName(sNs, "member"),
            members: new XName(sNs, "members"),
            mergeCell: new XName(sNs, "mergeCell"),
            mergeCells: new XName(sNs, "mergeCells"),
            metadata: new XName(sNs, "metadata"),
            metadataStrings: new XName(sNs, "metadataStrings"),
            metadataType: new XName(sNs, "metadataType"),
            metadataTypes: new XName(sNs, "metadataTypes"),
            mp: new XName(sNs, "mp"),
            mpMap: new XName(sNs, "mpMap"),
            mps: new XName(sNs, "mps"),
            mruColors: new XName(sNs, "mruColors"),
            ms: new XName(sNs, "ms"),
            n: new XName(sNs, "n"),
            name: new XName(sNs, "name"),
            nc: new XName(sNs, "nc"),
            ndxf: new XName(sNs, "ndxf"),
            numFmt: new XName(sNs, "numFmt"),
            numFmts: new XName(sNs, "numFmts"),
            objectPr: new XName(sNs, "objectPr"),
            oc: new XName(sNs, "oc"),
            oddFooter: new XName(sNs, "oddFooter"),
            oddHeader: new XName(sNs, "oddHeader"),
            odxf: new XName(sNs, "odxf"),
            olapPr: new XName(sNs, "olapPr"),
            oldFormula: new XName(sNs, "oldFormula"),
            oleItem: new XName(sNs, "oleItem"),
            oleItems: new XName(sNs, "oleItems"),
            oleLink: new XName(sNs, "oleLink"),
            oleObject: new XName(sNs, "oleObject"),
            oleObjects: new XName(sNs, "oleObjects"),
            outline: new XName(sNs, "outline"),
            outlinePr: new XName(sNs, "outlinePr"),
            p: new XName(sNs, "p"),
            page: new XName(sNs, "page"),
            pageField: new XName(sNs, "pageField"),
            pageFields: new XName(sNs, "pageFields"),
            pageItem: new XName(sNs, "pageItem"),
            pageMargins: new XName(sNs, "pageMargins"),
            pages: new XName(sNs, "pages"),
            pageSetup: new XName(sNs, "pageSetup"),
            pageSetUpPr: new XName(sNs, "pageSetUpPr"),
            pane: new XName(sNs, "pane"),
            parameter: new XName(sNs, "parameter"),
            parameters: new XName(sNs, "parameters"),
            patternFill: new XName(sNs, "patternFill"),
            phoneticPr: new XName(sNs, "phoneticPr"),
            picture: new XName(sNs, "picture"),
            pivotArea: new XName(sNs, "pivotArea"),
            pivotAreas: new XName(sNs, "pivotAreas"),
            pivotCache: new XName(sNs, "pivotCache"),
            pivotCacheDefinition: new XName(sNs, "pivotCacheDefinition"),
            pivotCacheRecords: new XName(sNs, "pivotCacheRecords"),
            pivotCaches: new XName(sNs, "pivotCaches"),
            pivotField: new XName(sNs, "pivotField"),
            pivotFields: new XName(sNs, "pivotFields"),
            pivotHierarchies: new XName(sNs, "pivotHierarchies"),
            pivotHierarchy: new XName(sNs, "pivotHierarchy"),
            pivotSelection: new XName(sNs, "pivotSelection"),
            pivotTableDefinition: new XName(sNs, "pivotTableDefinition"),
            pivotTableStyleInfo: new XName(sNs, "pivotTableStyleInfo"),
            printOptions: new XName(sNs, "printOptions"),
            protectedRange: new XName(sNs, "protectedRange"),
            protectedRanges: new XName(sNs, "protectedRanges"),
            protection: new XName(sNs, "protection"),
            query: new XName(sNs, "query"),
            queryCache: new XName(sNs, "queryCache"),
            queryTable: new XName(sNs, "queryTable"),
            queryTableDeletedFields: new XName(sNs, "queryTableDeletedFields"),
            queryTableField: new XName(sNs, "queryTableField"),
            queryTableFields: new XName(sNs, "queryTableFields"),
            queryTableRefresh: new XName(sNs, "queryTableRefresh"),
            r: new XName(sNs, "r"),
            raf: new XName(sNs, "raf"),
            rangePr: new XName(sNs, "rangePr"),
            rangeSet: new XName(sNs, "rangeSet"),
            rangeSets: new XName(sNs, "rangeSets"),
            rc: new XName(sNs, "rc"),
            rcc: new XName(sNs, "rcc"),
            rcft: new XName(sNs, "rcft"),
            rcmt: new XName(sNs, "rcmt"),
            rcv: new XName(sNs, "rcv"),
            rdn: new XName(sNs, "rdn"),
            reference: new XName(sNs, "reference"),
            references: new XName(sNs, "references"),
            reviewed: new XName(sNs, "reviewed"),
            reviewedList: new XName(sNs, "reviewedList"),
            revisions: new XName(sNs, "revisions"),
            rfmt: new XName(sNs, "rfmt"),
            rFont: new XName(sNs, "rFont"),
            rgbColor: new XName(sNs, "rgbColor"),
            right: new XName(sNs, "right"),
            ris: new XName(sNs, "ris"),
            rm: new XName(sNs, "rm"),
            row: new XName(sNs, "row"),
            rowBreaks: new XName(sNs, "rowBreaks"),
            rowFields: new XName(sNs, "rowFields"),
            rowHierarchiesUsage: new XName(sNs, "rowHierarchiesUsage"),
            rowHierarchyUsage: new XName(sNs, "rowHierarchyUsage"),
            rowItems: new XName(sNs, "rowItems"),
            rPh: new XName(sNs, "rPh"),
            rPr: new XName(sNs, "rPr"),
            rqt: new XName(sNs, "rqt"),
            rrc: new XName(sNs, "rrc"),
            rsnm: new XName(sNs, "rsnm"),
            _s: new XName(sNs, "s"),
            scenario: new XName(sNs, "scenario"),
            scenarios: new XName(sNs, "scenarios"),
            scheme: new XName(sNs, "scheme"),
            selection: new XName(sNs, "selection"),
            serverFormat: new XName(sNs, "serverFormat"),
            serverFormats: new XName(sNs, "serverFormats"),
            set: new XName(sNs, "set"),
            sets: new XName(sNs, "sets"),
            shadow: new XName(sNs, "shadow"),
            sharedItems: new XName(sNs, "sharedItems"),
            sheet: new XName(sNs, "sheet"),
            sheetCalcPr: new XName(sNs, "sheetCalcPr"),
            sheetData: new XName(sNs, "sheetData"),
            sheetDataSet: new XName(sNs, "sheetDataSet"),
            sheetFormatPr: new XName(sNs, "sheetFormatPr"),
            sheetId: new XName(sNs, "sheetId"),
            sheetIdMap: new XName(sNs, "sheetIdMap"),
            sheetName: new XName(sNs, "sheetName"),
            sheetNames: new XName(sNs, "sheetNames"),
            sheetPr: new XName(sNs, "sheetPr"),
            sheetProtection: new XName(sNs, "sheetProtection"),
            sheets: new XName(sNs, "sheets"),
            sheetView: new XName(sNs, "sheetView"),
            sheetViews: new XName(sNs, "sheetViews"),
            si: new XName(sNs, "si"),
            singleXmlCell: new XName(sNs, "singleXmlCell"),
            singleXmlCells: new XName(sNs, "singleXmlCells"),
            smartTags: new XName(sNs, "smartTags"),
            sortByTuple: new XName(sNs, "sortByTuple"),
            sortCondition: new XName(sNs, "sortCondition"),
            sortState: new XName(sNs, "sortState"),
            sst: new XName(sNs, "sst"),
            stop: new XName(sNs, "stop"),
            stp: new XName(sNs, "stp"),
            strike: new XName(sNs, "strike"),
            styleSheet: new XName(sNs, "styleSheet"),
            sz: new XName(sNs, "sz"),
            t: new XName(sNs, "t"),
            tabColor: new XName(sNs, "tabColor"),
            table: new XName(sNs, "table"),
            tableColumn: new XName(sNs, "tableColumn"),
            tableColumns: new XName(sNs, "tableColumns"),
            tablePart: new XName(sNs, "tablePart"),
            tableParts: new XName(sNs, "tableParts"),
            tables: new XName(sNs, "tables"),
            tableStyle: new XName(sNs, "tableStyle"),
            tableStyleElement: new XName(sNs, "tableStyleElement"),
            tableStyleInfo: new XName(sNs, "tableStyleInfo"),
            tableStyles: new XName(sNs, "tableStyles"),
            text: new XName(sNs, "text"),
            textField: new XName(sNs, "textField"),
            textFields: new XName(sNs, "textFields"),
            textPr: new XName(sNs, "textPr"),
            to: new XName(sNs, "to"),
            top: new XName(sNs, "top"),
            top10: new XName(sNs, "top10"),
            totalsRowFormula: new XName(sNs, "totalsRowFormula"),
            tp: new XName(sNs, "tp"),
            tpl: new XName(sNs, "tpl"),
            tpls: new XName(sNs, "tpls"),
            tr: new XName(sNs, "tr"),
            tupleCache: new XName(sNs, "tupleCache"),
            u: new XName(sNs, "u"),
            undo: new XName(sNs, "undo"),
            userInfo: new XName(sNs, "userInfo"),
            users: new XName(sNs, "users"),
            v: new XName(sNs, "v"),
            val: new XName(sNs, "val"),
            value: new XName(sNs, "value"),
            valueMetadata: new XName(sNs, "valueMetadata"),
            values: new XName(sNs, "values"),
            vertAlign: new XName(sNs, "vertAlign"),
            vertical: new XName(sNs, "vertical"),
            volType: new XName(sNs, "volType"),
            volTypes: new XName(sNs, "volTypes"),
            webPr: new XName(sNs, "webPr"),
            webPublishItem: new XName(sNs, "webPublishItem"),
            webPublishItems: new XName(sNs, "webPublishItems"),
            worksheet: new XName(sNs, "worksheet"),
            worksheetEx14: new XName(sNs, "worksheetEx14"),
            worksheetSource: new XName(sNs, "worksheetSource"),
            x: new XName(sNs, "x"),
            xf: new XName(sNs, "xf"),
            xmlCellPr: new XName(sNs, "xmlCellPr"),
            xmlColumnPr: new XName(sNs, "xmlColumnPr"),
            xmlPr: new XName(sNs, "xmlPr"),
        }
        var S = openXml.S;

        openXml.slNs = new XNamespace("http://schemas.openxmlformats.org/schemaLibrary/2006/main");
        var slNs = openXml.slNs;
        openXml.SL = {
            manifestLocation: new XName(slNs, "manifestLocation"),
            schema: new XName(slNs, "schema"),
            schemaLibrary: new XName(slNs, "schemaLibrary"),
            uri: new XName(slNs, "uri"),
        }
        var SL = openXml.SL;

        openXml.sleNs = new XNamespace("http://schemas.microsoft.com/office/drawing/2010/slicer");
        var sleNs = openXml.sleNs;
        openXml.SLE = {
            slicer: new XName(sleNs, "slicer"),
        }
        var SLE = openXml.SLE;

        openXml.vmlNs = new XNamespace("urn:schemas-microsoft-com:vml");
        var vmlNs = openXml.vmlNs;
        openXml.VML = {
            arc: new XName(vmlNs, "arc"),
            background: new XName(vmlNs, "background"),
            curve: new XName(vmlNs, "curve"),
            ext: new XName(vmlNs, "ext"),
            f: new XName(vmlNs, "f"),
            fill: new XName(vmlNs, "fill"),
            formulas: new XName(vmlNs, "formulas"),
            group: new XName(vmlNs, "group"),
            h: new XName(vmlNs, "h"),
            handles: new XName(vmlNs, "handles"),
            image: new XName(vmlNs, "image"),
            imagedata: new XName(vmlNs, "imagedata"),
            line: new XName(vmlNs, "line"),
            oval: new XName(vmlNs, "oval"),
            path: new XName(vmlNs, "path"),
            polyline: new XName(vmlNs, "polyline"),
            rect: new XName(vmlNs, "rect"),
            roundrect: new XName(vmlNs, "roundrect"),
            shadow: new XName(vmlNs, "shadow"),
            shape: new XName(vmlNs, "shape"),
            shapetype: new XName(vmlNs, "shapetype"),
            stroke: new XName(vmlNs, "stroke"),
            textbox: new XName(vmlNs, "textbox"),
            textpath: new XName(vmlNs, "textpath"),
        }
        var VML = openXml.VML;

        openXml.vtNs = new XNamespace("http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes");
        var vtNs = openXml.vtNs;
        openXml.VT = {
            _bool: new XName(vtNs, "bool"),
            filetime: new XName(vtNs, "filetime"),
            i4: new XName(vtNs, "i4"),
            lpstr: new XName(vtNs, "lpstr"),
            lpwstr: new XName(vtNs, "lpwstr"),
            r8: new XName(vtNs, "r8"),
            variant: new XName(vtNs, "variant"),
            vector: new XName(vtNs, "vector"),
        }
        var VT = openXml.VT;

        openXml.wNs = new XNamespace("http://schemas.openxmlformats.org/wordprocessingml/2006/main");
        var wNs = openXml.wNs;
        openXml.W = {
            abstractNum: new XName(wNs, "abstractNum"),
            abstractNumId: new XName(wNs, "abstractNumId"),
            accent1: new XName(wNs, "accent1"),
            accent2: new XName(wNs, "accent2"),
            accent3: new XName(wNs, "accent3"),
            accent4: new XName(wNs, "accent4"),
            accent5: new XName(wNs, "accent5"),
            accent6: new XName(wNs, "accent6"),
            activeRecord: new XName(wNs, "activeRecord"),
            activeWritingStyle: new XName(wNs, "activeWritingStyle"),
            actualPg: new XName(wNs, "actualPg"),
            addressFieldName: new XName(wNs, "addressFieldName"),
            adjustLineHeightInTable: new XName(wNs, "adjustLineHeightInTable"),
            adjustRightInd: new XName(wNs, "adjustRightInd"),
            after: new XName(wNs, "after"),
            afterAutospacing: new XName(wNs, "afterAutospacing"),
            afterLines: new XName(wNs, "afterLines"),
            algIdExt: new XName(wNs, "algIdExt"),
            algIdExtSource: new XName(wNs, "algIdExtSource"),
            alias: new XName(wNs, "alias"),
            aliases: new XName(wNs, "aliases"),
            alignBordersAndEdges: new XName(wNs, "alignBordersAndEdges"),
            alignment: new XName(wNs, "alignment"),
            alignTablesRowByRow: new XName(wNs, "alignTablesRowByRow"),
            allowPNG: new XName(wNs, "allowPNG"),
            allowSpaceOfSameStyleInTable: new XName(wNs, "allowSpaceOfSameStyleInTable"),
            altChunk: new XName(wNs, "altChunk"),
            altChunkPr: new XName(wNs, "altChunkPr"),
            altName: new XName(wNs, "altName"),
            alwaysMergeEmptyNamespace: new XName(wNs, "alwaysMergeEmptyNamespace"),
            alwaysShowPlaceholderText: new XName(wNs, "alwaysShowPlaceholderText"),
            anchor: new XName(wNs, "anchor"),
            anchorLock: new XName(wNs, "anchorLock"),
            annotationRef: new XName(wNs, "annotationRef"),
            applyBreakingRules: new XName(wNs, "applyBreakingRules"),
            appName: new XName(wNs, "appName"),
            ascii: new XName(wNs, "ascii"),
            asciiTheme: new XName(wNs, "asciiTheme"),
            attachedSchema: new XName(wNs, "attachedSchema"),
            attachedTemplate: new XName(wNs, "attachedTemplate"),
            attr: new XName(wNs, "attr"),
            author: new XName(wNs, "author"),
            autofitToFirstFixedWidthCell: new XName(wNs, "autofitToFirstFixedWidthCell"),
            autoFormatOverride: new XName(wNs, "autoFormatOverride"),
            autoHyphenation: new XName(wNs, "autoHyphenation"),
            autoRedefine: new XName(wNs, "autoRedefine"),
            autoSpaceDE: new XName(wNs, "autoSpaceDE"),
            autoSpaceDN: new XName(wNs, "autoSpaceDN"),
            autoSpaceLikeWord95: new XName(wNs, "autoSpaceLikeWord95"),
            b: new XName(wNs, "b"),
            background: new XName(wNs, "background"),
            balanceSingleByteDoubleByteWidth: new XName(wNs, "balanceSingleByteDoubleByteWidth"),
            bar: new XName(wNs, "bar"),
            basedOn: new XName(wNs, "basedOn"),
            bCs: new XName(wNs, "bCs"),
            bdr: new XName(wNs, "bdr"),
            before: new XName(wNs, "before"),
            beforeAutospacing: new XName(wNs, "beforeAutospacing"),
            beforeLines: new XName(wNs, "beforeLines"),
            behavior: new XName(wNs, "behavior"),
            behaviors: new XName(wNs, "behaviors"),
            between: new XName(wNs, "between"),
            bg1: new XName(wNs, "bg1"),
            bg2: new XName(wNs, "bg2"),
            bibliography: new XName(wNs, "bibliography"),
            bidi: new XName(wNs, "bidi"),
            bidiVisual: new XName(wNs, "bidiVisual"),
            blockQuote: new XName(wNs, "blockQuote"),
            body: new XName(wNs, "body"),
            bodyDiv: new XName(wNs, "bodyDiv"),
            bookFoldPrinting: new XName(wNs, "bookFoldPrinting"),
            bookFoldPrintingSheets: new XName(wNs, "bookFoldPrintingSheets"),
            bookFoldRevPrinting: new XName(wNs, "bookFoldRevPrinting"),
            bookmarkEnd: new XName(wNs, "bookmarkEnd"),
            bookmarkStart: new XName(wNs, "bookmarkStart"),
            bordersDoNotSurroundFooter: new XName(wNs, "bordersDoNotSurroundFooter"),
            bordersDoNotSurroundHeader: new XName(wNs, "bordersDoNotSurroundHeader"),
            bottom: new XName(wNs, "bottom"),
            bottomFromText: new XName(wNs, "bottomFromText"),
            br: new XName(wNs, "br"),
            cachedColBalance: new XName(wNs, "cachedColBalance"),
            calcOnExit: new XName(wNs, "calcOnExit"),
            calendar: new XName(wNs, "calendar"),
            cantSplit: new XName(wNs, "cantSplit"),
            caps: new XName(wNs, "caps"),
            category: new XName(wNs, "category"),
            cellDel: new XName(wNs, "cellDel"),
            cellIns: new XName(wNs, "cellIns"),
            cellMerge: new XName(wNs, "cellMerge"),
            chapSep: new XName(wNs, "chapSep"),
            chapStyle: new XName(wNs, "chapStyle"),
            _char: new XName(wNs, "char"),
            characterSpacingControl: new XName(wNs, "characterSpacingControl"),
            charset: new XName(wNs, "charset"),
            charSpace: new XName(wNs, "charSpace"),
            checkBox: new XName(wNs, "checkBox"),
            _checked: new XName(wNs, "checked"),
            checkErrors: new XName(wNs, "checkErrors"),
            checkStyle: new XName(wNs, "checkStyle"),
            citation: new XName(wNs, "citation"),
            clear: new XName(wNs, "clear"),
            clickAndTypeStyle: new XName(wNs, "clickAndTypeStyle"),
            clrSchemeMapping: new XName(wNs, "clrSchemeMapping"),
            cnfStyle: new XName(wNs, "cnfStyle"),
            code: new XName(wNs, "code"),
            col: new XName(wNs, "col"),
            colDelim: new XName(wNs, "colDelim"),
            colFirst: new XName(wNs, "colFirst"),
            colLast: new XName(wNs, "colLast"),
            color: new XName(wNs, "color"),
            cols: new XName(wNs, "cols"),
            column: new XName(wNs, "column"),
            combine: new XName(wNs, "combine"),
            combineBrackets: new XName(wNs, "combineBrackets"),
            comboBox: new XName(wNs, "comboBox"),
            comment: new XName(wNs, "comment"),
            commentRangeEnd: new XName(wNs, "commentRangeEnd"),
            commentRangeStart: new XName(wNs, "commentRangeStart"),
            commentReference: new XName(wNs, "commentReference"),
            comments: new XName(wNs, "comments"),
            compat: new XName(wNs, "compat"),
            compatSetting: new XName(wNs, "compatSetting"),
            connectString: new XName(wNs, "connectString"),
            consecutiveHyphenLimit: new XName(wNs, "consecutiveHyphenLimit"),
            contextualSpacing: new XName(wNs, "contextualSpacing"),
            continuationSeparator: new XName(wNs, "continuationSeparator"),
            control: new XName(wNs, "control"),
            convMailMergeEsc: new XName(wNs, "convMailMergeEsc"),
            count: new XName(wNs, "count"),
            countBy: new XName(wNs, "countBy"),
            cr: new XName(wNs, "cr"),
            cryptAlgorithmClass: new XName(wNs, "cryptAlgorithmClass"),
            cryptAlgorithmSid: new XName(wNs, "cryptAlgorithmSid"),
            cryptAlgorithmType: new XName(wNs, "cryptAlgorithmType"),
            cryptProvider: new XName(wNs, "cryptProvider"),
            cryptProviderType: new XName(wNs, "cryptProviderType"),
            cryptProviderTypeExt: new XName(wNs, "cryptProviderTypeExt"),
            cryptProviderTypeExtSource: new XName(wNs, "cryptProviderTypeExtSource"),
            cryptSpinCount: new XName(wNs, "cryptSpinCount"),
            cs: new XName(wNs, "cs"),
            csb0: new XName(wNs, "csb0"),
            csb1: new XName(wNs, "csb1"),
            cstheme: new XName(wNs, "cstheme"),
            customMarkFollows: new XName(wNs, "customMarkFollows"),
            customStyle: new XName(wNs, "customStyle"),
            customXml: new XName(wNs, "customXml"),
            customXmlDelRangeEnd: new XName(wNs, "customXmlDelRangeEnd"),
            customXmlDelRangeStart: new XName(wNs, "customXmlDelRangeStart"),
            customXmlInsRangeEnd: new XName(wNs, "customXmlInsRangeEnd"),
            customXmlInsRangeStart: new XName(wNs, "customXmlInsRangeStart"),
            customXmlMoveFromRangeEnd: new XName(wNs, "customXmlMoveFromRangeEnd"),
            customXmlMoveFromRangeStart: new XName(wNs, "customXmlMoveFromRangeStart"),
            customXmlMoveToRangeEnd: new XName(wNs, "customXmlMoveToRangeEnd"),
            customXmlMoveToRangeStart: new XName(wNs, "customXmlMoveToRangeStart"),
            customXmlPr: new XName(wNs, "customXmlPr"),
            dataBinding: new XName(wNs, "dataBinding"),
            dataSource: new XName(wNs, "dataSource"),
            dataType: new XName(wNs, "dataType"),
            date: new XName(wNs, "date"),
            dateFormat: new XName(wNs, "dateFormat"),
            dayLong: new XName(wNs, "dayLong"),
            dayShort: new XName(wNs, "dayShort"),
            ddList: new XName(wNs, "ddList"),
            decimalSymbol: new XName(wNs, "decimalSymbol"),
            _default: new XName(wNs, "default"),
            defaultTableStyle: new XName(wNs, "defaultTableStyle"),
            defaultTabStop: new XName(wNs, "defaultTabStop"),
            defLockedState: new XName(wNs, "defLockedState"),
            defQFormat: new XName(wNs, "defQFormat"),
            defSemiHidden: new XName(wNs, "defSemiHidden"),
            defUIPriority: new XName(wNs, "defUIPriority"),
            defUnhideWhenUsed: new XName(wNs, "defUnhideWhenUsed"),
            del: new XName(wNs, "del"),
            delInstrText: new XName(wNs, "delInstrText"),
            delText: new XName(wNs, "delText"),
            description: new XName(wNs, "description"),
            destination: new XName(wNs, "destination"),
            dirty: new XName(wNs, "dirty"),
            displacedByCustomXml: new XName(wNs, "displacedByCustomXml"),
            display: new XName(wNs, "display"),
            displayBackgroundShape: new XName(wNs, "displayBackgroundShape"),
            displayHangulFixedWidth: new XName(wNs, "displayHangulFixedWidth"),
            displayHorizontalDrawingGridEvery: new XName(wNs, "displayHorizontalDrawingGridEvery"),
            displayText: new XName(wNs, "displayText"),
            displayVerticalDrawingGridEvery: new XName(wNs, "displayVerticalDrawingGridEvery"),
            distance: new XName(wNs, "distance"),
            div: new XName(wNs, "div"),
            divBdr: new XName(wNs, "divBdr"),
            divId: new XName(wNs, "divId"),
            divs: new XName(wNs, "divs"),
            divsChild: new XName(wNs, "divsChild"),
            dllVersion: new XName(wNs, "dllVersion"),
            docDefaults: new XName(wNs, "docDefaults"),
            docGrid: new XName(wNs, "docGrid"),
            docLocation: new XName(wNs, "docLocation"),
            docPart: new XName(wNs, "docPart"),
            docPartBody: new XName(wNs, "docPartBody"),
            docPartCategory: new XName(wNs, "docPartCategory"),
            docPartGallery: new XName(wNs, "docPartGallery"),
            docPartList: new XName(wNs, "docPartList"),
            docPartObj: new XName(wNs, "docPartObj"),
            docPartPr: new XName(wNs, "docPartPr"),
            docParts: new XName(wNs, "docParts"),
            docPartUnique: new XName(wNs, "docPartUnique"),
            document: new XName(wNs, "document"),
            documentProtection: new XName(wNs, "documentProtection"),
            documentType: new XName(wNs, "documentType"),
            docVar: new XName(wNs, "docVar"),
            docVars: new XName(wNs, "docVars"),
            doNotAutoCompressPictures: new XName(wNs, "doNotAutoCompressPictures"),
            doNotAutofitConstrainedTables: new XName(wNs, "doNotAutofitConstrainedTables"),
            doNotBreakConstrainedForcedTable: new XName(wNs, "doNotBreakConstrainedForcedTable"),
            doNotBreakWrappedTables: new XName(wNs, "doNotBreakWrappedTables"),
            doNotDemarcateInvalidXml: new XName(wNs, "doNotDemarcateInvalidXml"),
            doNotDisplayPageBoundaries: new XName(wNs, "doNotDisplayPageBoundaries"),
            doNotEmbedSmartTags: new XName(wNs, "doNotEmbedSmartTags"),
            doNotExpandShiftReturn: new XName(wNs, "doNotExpandShiftReturn"),
            doNotHyphenateCaps: new XName(wNs, "doNotHyphenateCaps"),
            doNotIncludeSubdocsInStats: new XName(wNs, "doNotIncludeSubdocsInStats"),
            doNotLeaveBackslashAlone: new XName(wNs, "doNotLeaveBackslashAlone"),
            doNotOrganizeInFolder: new XName(wNs, "doNotOrganizeInFolder"),
            doNotRelyOnCSS: new XName(wNs, "doNotRelyOnCSS"),
            doNotSaveAsSingleFile: new XName(wNs, "doNotSaveAsSingleFile"),
            doNotShadeFormData: new XName(wNs, "doNotShadeFormData"),
            doNotSnapToGridInCell: new XName(wNs, "doNotSnapToGridInCell"),
            doNotSuppressBlankLines: new XName(wNs, "doNotSuppressBlankLines"),
            doNotSuppressIndentation: new XName(wNs, "doNotSuppressIndentation"),
            doNotSuppressParagraphBorders: new XName(wNs, "doNotSuppressParagraphBorders"),
            doNotTrackFormatting: new XName(wNs, "doNotTrackFormatting"),
            doNotTrackMoves: new XName(wNs, "doNotTrackMoves"),
            doNotUseEastAsianBreakRules: new XName(wNs, "doNotUseEastAsianBreakRules"),
            doNotUseHTMLParagraphAutoSpacing: new XName(wNs, "doNotUseHTMLParagraphAutoSpacing"),
            doNotUseIndentAsNumberingTabStop: new XName(wNs, "doNotUseIndentAsNumberingTabStop"),
            doNotUseLongFileNames: new XName(wNs, "doNotUseLongFileNames"),
            doNotUseMarginsForDrawingGridOrigin: new XName(wNs, "doNotUseMarginsForDrawingGridOrigin"),
            doNotValidateAgainstSchema: new XName(wNs, "doNotValidateAgainstSchema"),
            doNotVertAlignCellWithSp: new XName(wNs, "doNotVertAlignCellWithSp"),
            doNotVertAlignInTxbx: new XName(wNs, "doNotVertAlignInTxbx"),
            doNotWrapTextWithPunct: new XName(wNs, "doNotWrapTextWithPunct"),
            drawing: new XName(wNs, "drawing"),
            drawingGridHorizontalOrigin: new XName(wNs, "drawingGridHorizontalOrigin"),
            drawingGridHorizontalSpacing: new XName(wNs, "drawingGridHorizontalSpacing"),
            drawingGridVerticalOrigin: new XName(wNs, "drawingGridVerticalOrigin"),
            drawingGridVerticalSpacing: new XName(wNs, "drawingGridVerticalSpacing"),
            dropCap: new XName(wNs, "dropCap"),
            dropDownList: new XName(wNs, "dropDownList"),
            dstrike: new XName(wNs, "dstrike"),
            dxaOrig: new XName(wNs, "dxaOrig"),
            dyaOrig: new XName(wNs, "dyaOrig"),
            dynamicAddress: new XName(wNs, "dynamicAddress"),
            eastAsia: new XName(wNs, "eastAsia"),
            eastAsianLayout: new XName(wNs, "eastAsianLayout"),
            eastAsiaTheme: new XName(wNs, "eastAsiaTheme"),
            ed: new XName(wNs, "ed"),
            edGrp: new XName(wNs, "edGrp"),
            edit: new XName(wNs, "edit"),
            effect: new XName(wNs, "effect"),
            element: new XName(wNs, "element"),
            em: new XName(wNs, "em"),
            embedBold: new XName(wNs, "embedBold"),
            embedBoldItalic: new XName(wNs, "embedBoldItalic"),
            embedItalic: new XName(wNs, "embedItalic"),
            embedRegular: new XName(wNs, "embedRegular"),
            embedSystemFonts: new XName(wNs, "embedSystemFonts"),
            embedTrueTypeFonts: new XName(wNs, "embedTrueTypeFonts"),
            emboss: new XName(wNs, "emboss"),
            enabled: new XName(wNs, "enabled"),
            encoding: new XName(wNs, "encoding"),
            endnote: new XName(wNs, "endnote"),
            endnotePr: new XName(wNs, "endnotePr"),
            endnoteRef: new XName(wNs, "endnoteRef"),
            endnoteReference: new XName(wNs, "endnoteReference"),
            endnotes: new XName(wNs, "endnotes"),
            enforcement: new XName(wNs, "enforcement"),
            entryMacro: new XName(wNs, "entryMacro"),
            equalWidth: new XName(wNs, "equalWidth"),
            equation: new XName(wNs, "equation"),
            evenAndOddHeaders: new XName(wNs, "evenAndOddHeaders"),
            exitMacro: new XName(wNs, "exitMacro"),
            family: new XName(wNs, "family"),
            ffData: new XName(wNs, "ffData"),
            fHdr: new XName(wNs, "fHdr"),
            fieldMapData: new XName(wNs, "fieldMapData"),
            fill: new XName(wNs, "fill"),
            first: new XName(wNs, "first"),
            firstColumn: new XName(wNs, "firstColumn"),
            firstLine: new XName(wNs, "firstLine"),
            firstLineChars: new XName(wNs, "firstLineChars"),
            firstRow: new XName(wNs, "firstRow"),
            fitText: new XName(wNs, "fitText"),
            flatBorders: new XName(wNs, "flatBorders"),
            fldChar: new XName(wNs, "fldChar"),
            fldCharType: new XName(wNs, "fldCharType"),
            fldData: new XName(wNs, "fldData"),
            fldLock: new XName(wNs, "fldLock"),
            fldSimple: new XName(wNs, "fldSimple"),
            fmt: new XName(wNs, "fmt"),
            followedHyperlink: new XName(wNs, "followedHyperlink"),
            font: new XName(wNs, "font"),
            fontKey: new XName(wNs, "fontKey"),
            fonts: new XName(wNs, "fonts"),
            fontSz: new XName(wNs, "fontSz"),
            footer: new XName(wNs, "footer"),
            footerReference: new XName(wNs, "footerReference"),
            footnote: new XName(wNs, "footnote"),
            footnoteLayoutLikeWW8: new XName(wNs, "footnoteLayoutLikeWW8"),
            footnotePr: new XName(wNs, "footnotePr"),
            footnoteRef: new XName(wNs, "footnoteRef"),
            footnoteReference: new XName(wNs, "footnoteReference"),
            footnotes: new XName(wNs, "footnotes"),
            forceUpgrade: new XName(wNs, "forceUpgrade"),
            forgetLastTabAlignment: new XName(wNs, "forgetLastTabAlignment"),
            format: new XName(wNs, "format"),
            formatting: new XName(wNs, "formatting"),
            formProt: new XName(wNs, "formProt"),
            formsDesign: new XName(wNs, "formsDesign"),
            frame: new XName(wNs, "frame"),
            frameLayout: new XName(wNs, "frameLayout"),
            framePr: new XName(wNs, "framePr"),
            frameset: new XName(wNs, "frameset"),
            framesetSplitbar: new XName(wNs, "framesetSplitbar"),
            ftr: new XName(wNs, "ftr"),
            fullDate: new XName(wNs, "fullDate"),
            gallery: new XName(wNs, "gallery"),
            glossaryDocument: new XName(wNs, "glossaryDocument"),
            grammar: new XName(wNs, "grammar"),
            gridAfter: new XName(wNs, "gridAfter"),
            gridBefore: new XName(wNs, "gridBefore"),
            gridCol: new XName(wNs, "gridCol"),
            gridSpan: new XName(wNs, "gridSpan"),
            group: new XName(wNs, "group"),
            growAutofit: new XName(wNs, "growAutofit"),
            guid: new XName(wNs, "guid"),
            gutter: new XName(wNs, "gutter"),
            gutterAtTop: new XName(wNs, "gutterAtTop"),
            h: new XName(wNs, "h"),
            hAnchor: new XName(wNs, "hAnchor"),
            hanging: new XName(wNs, "hanging"),
            hangingChars: new XName(wNs, "hangingChars"),
            hAnsi: new XName(wNs, "hAnsi"),
            hAnsiTheme: new XName(wNs, "hAnsiTheme"),
            hash: new XName(wNs, "hash"),
            hdr: new XName(wNs, "hdr"),
            hdrShapeDefaults: new XName(wNs, "hdrShapeDefaults"),
            header: new XName(wNs, "header"),
            headerReference: new XName(wNs, "headerReference"),
            headerSource: new XName(wNs, "headerSource"),
            helpText: new XName(wNs, "helpText"),
            hidden: new XName(wNs, "hidden"),
            hideGrammaticalErrors: new XName(wNs, "hideGrammaticalErrors"),
            hideMark: new XName(wNs, "hideMark"),
            hideSpellingErrors: new XName(wNs, "hideSpellingErrors"),
            highlight: new XName(wNs, "highlight"),
            hint: new XName(wNs, "hint"),
            history: new XName(wNs, "history"),
            hMerge: new XName(wNs, "hMerge"),
            horzAnchor: new XName(wNs, "horzAnchor"),
            hps: new XName(wNs, "hps"),
            hpsBaseText: new XName(wNs, "hpsBaseText"),
            hpsRaise: new XName(wNs, "hpsRaise"),
            hRule: new XName(wNs, "hRule"),
            hSpace: new XName(wNs, "hSpace"),
            hyperlink: new XName(wNs, "hyperlink"),
            hyphenationZone: new XName(wNs, "hyphenationZone"),
            i: new XName(wNs, "i"),
            iCs: new XName(wNs, "iCs"),
            id: new XName(wNs, "id"),
            ignoreMixedContent: new XName(wNs, "ignoreMixedContent"),
            ilvl: new XName(wNs, "ilvl"),
            imprint: new XName(wNs, "imprint"),
            ind: new XName(wNs, "ind"),
            initials: new XName(wNs, "initials"),
            inkAnnotations: new XName(wNs, "inkAnnotations"),
            ins: new XName(wNs, "ins"),
            insDel: new XName(wNs, "insDel"),
            insideH: new XName(wNs, "insideH"),
            insideV: new XName(wNs, "insideV"),
            instr: new XName(wNs, "instr"),
            instrText: new XName(wNs, "instrText"),
            isLgl: new XName(wNs, "isLgl"),
            jc: new XName(wNs, "jc"),
            keepLines: new XName(wNs, "keepLines"),
            keepNext: new XName(wNs, "keepNext"),
            kern: new XName(wNs, "kern"),
            kinsoku: new XName(wNs, "kinsoku"),
            lang: new XName(wNs, "lang"),
            lastColumn: new XName(wNs, "lastColumn"),
            lastRenderedPageBreak: new XName(wNs, "lastRenderedPageBreak"),
            lastRow: new XName(wNs, "lastRow"),
            lastValue: new XName(wNs, "lastValue"),
            latentStyles: new XName(wNs, "latentStyles"),
            layoutRawTableWidth: new XName(wNs, "layoutRawTableWidth"),
            layoutTableRowsApart: new XName(wNs, "layoutTableRowsApart"),
            leader: new XName(wNs, "leader"),
            left: new XName(wNs, "left"),
            leftChars: new XName(wNs, "leftChars"),
            leftFromText: new XName(wNs, "leftFromText"),
            legacy: new XName(wNs, "legacy"),
            legacyIndent: new XName(wNs, "legacyIndent"),
            legacySpace: new XName(wNs, "legacySpace"),
            lid: new XName(wNs, "lid"),
            line: new XName(wNs, "line"),
            linePitch: new XName(wNs, "linePitch"),
            lineRule: new XName(wNs, "lineRule"),
            lines: new XName(wNs, "lines"),
            lineWrapLikeWord6: new XName(wNs, "lineWrapLikeWord6"),
            link: new XName(wNs, "link"),
            linkedToFile: new XName(wNs, "linkedToFile"),
            linkStyles: new XName(wNs, "linkStyles"),
            linkToQuery: new XName(wNs, "linkToQuery"),
            listEntry: new XName(wNs, "listEntry"),
            listItem: new XName(wNs, "listItem"),
            listSeparator: new XName(wNs, "listSeparator"),
            lnNumType: new XName(wNs, "lnNumType"),
            _lock: new XName(wNs, "lock"),
            locked: new XName(wNs, "locked"),
            lsdException: new XName(wNs, "lsdException"),
            lvl: new XName(wNs, "lvl"),
            lvlJc: new XName(wNs, "lvlJc"),
            lvlOverride: new XName(wNs, "lvlOverride"),
            lvlPicBulletId: new XName(wNs, "lvlPicBulletId"),
            lvlRestart: new XName(wNs, "lvlRestart"),
            lvlText: new XName(wNs, "lvlText"),
            mailAsAttachment: new XName(wNs, "mailAsAttachment"),
            mailMerge: new XName(wNs, "mailMerge"),
            mailSubject: new XName(wNs, "mailSubject"),
            mainDocumentType: new XName(wNs, "mainDocumentType"),
            mappedName: new XName(wNs, "mappedName"),
            marBottom: new XName(wNs, "marBottom"),
            marH: new XName(wNs, "marH"),
            markup: new XName(wNs, "markup"),
            marLeft: new XName(wNs, "marLeft"),
            marRight: new XName(wNs, "marRight"),
            marTop: new XName(wNs, "marTop"),
            marW: new XName(wNs, "marW"),
            matchSrc: new XName(wNs, "matchSrc"),
            maxLength: new XName(wNs, "maxLength"),
            mirrorIndents: new XName(wNs, "mirrorIndents"),
            mirrorMargins: new XName(wNs, "mirrorMargins"),
            monthLong: new XName(wNs, "monthLong"),
            monthShort: new XName(wNs, "monthShort"),
            moveFrom: new XName(wNs, "moveFrom"),
            moveFromRangeEnd: new XName(wNs, "moveFromRangeEnd"),
            moveFromRangeStart: new XName(wNs, "moveFromRangeStart"),
            moveTo: new XName(wNs, "moveTo"),
            moveToRangeEnd: new XName(wNs, "moveToRangeEnd"),
            moveToRangeStart: new XName(wNs, "moveToRangeStart"),
            multiLevelType: new XName(wNs, "multiLevelType"),
            multiLine: new XName(wNs, "multiLine"),
            mwSmallCaps: new XName(wNs, "mwSmallCaps"),
            name: new XName(wNs, "name"),
            namespaceuri: new XName(wNs, "namespaceuri"),
            next: new XName(wNs, "next"),
            nlCheck: new XName(wNs, "nlCheck"),
            noBorder: new XName(wNs, "noBorder"),
            noBreakHyphen: new XName(wNs, "noBreakHyphen"),
            noColumnBalance: new XName(wNs, "noColumnBalance"),
            noEndnote: new XName(wNs, "noEndnote"),
            noExtraLineSpacing: new XName(wNs, "noExtraLineSpacing"),
            noHBand: new XName(wNs, "noHBand"),
            noLeading: new XName(wNs, "noLeading"),
            noLineBreaksAfter: new XName(wNs, "noLineBreaksAfter"),
            noLineBreaksBefore: new XName(wNs, "noLineBreaksBefore"),
            noProof: new XName(wNs, "noProof"),
            noPunctuationKerning: new XName(wNs, "noPunctuationKerning"),
            noResizeAllowed: new XName(wNs, "noResizeAllowed"),
            noSpaceRaiseLower: new XName(wNs, "noSpaceRaiseLower"),
            noTabHangInd: new XName(wNs, "noTabHangInd"),
            notTrueType: new XName(wNs, "notTrueType"),
            noVBand: new XName(wNs, "noVBand"),
            noWrap: new XName(wNs, "noWrap"),
            nsid: new XName(wNs, "nsid"),
            _null: new XName(wNs, "null"),
            num: new XName(wNs, "num"),
            numbering: new XName(wNs, "numbering"),
            numberingChange: new XName(wNs, "numberingChange"),
            numFmt: new XName(wNs, "numFmt"),
            numId: new XName(wNs, "numId"),
            numIdMacAtCleanup: new XName(wNs, "numIdMacAtCleanup"),
            numPicBullet: new XName(wNs, "numPicBullet"),
            numPicBulletId: new XName(wNs, "numPicBulletId"),
            numPr: new XName(wNs, "numPr"),
            numRestart: new XName(wNs, "numRestart"),
            numStart: new XName(wNs, "numStart"),
            numStyleLink: new XName(wNs, "numStyleLink"),
            _object: new XName(wNs, "object"),
            odso: new XName(wNs, "odso"),
            offsetFrom: new XName(wNs, "offsetFrom"),
            oMath: new XName(wNs, "oMath"),
            optimizeForBrowser: new XName(wNs, "optimizeForBrowser"),
            orient: new XName(wNs, "orient"),
            original: new XName(wNs, "original"),
            other: new XName(wNs, "other"),
            outline: new XName(wNs, "outline"),
            outlineLvl: new XName(wNs, "outlineLvl"),
            overflowPunct: new XName(wNs, "overflowPunct"),
            p: new XName(wNs, "p"),
            pageBreakBefore: new XName(wNs, "pageBreakBefore"),
            panose1: new XName(wNs, "panose1"),
            paperSrc: new XName(wNs, "paperSrc"),
            pBdr: new XName(wNs, "pBdr"),
            percent: new XName(wNs, "percent"),
            permEnd: new XName(wNs, "permEnd"),
            permStart: new XName(wNs, "permStart"),
            personal: new XName(wNs, "personal"),
            personalCompose: new XName(wNs, "personalCompose"),
            personalReply: new XName(wNs, "personalReply"),
            pgBorders: new XName(wNs, "pgBorders"),
            pgMar: new XName(wNs, "pgMar"),
            pgNum: new XName(wNs, "pgNum"),
            pgNumType: new XName(wNs, "pgNumType"),
            pgSz: new XName(wNs, "pgSz"),
            pict: new XName(wNs, "pict"),
            picture: new XName(wNs, "picture"),
            pitch: new XName(wNs, "pitch"),
            pixelsPerInch: new XName(wNs, "pixelsPerInch"),
            placeholder: new XName(wNs, "placeholder"),
            pos: new XName(wNs, "pos"),
            position: new XName(wNs, "position"),
            pPr: new XName(wNs, "pPr"),
            pPrChange: new XName(wNs, "pPrChange"),
            pPrDefault: new XName(wNs, "pPrDefault"),
            prefixMappings: new XName(wNs, "prefixMappings"),
            printBodyTextBeforeHeader: new XName(wNs, "printBodyTextBeforeHeader"),
            printColBlack: new XName(wNs, "printColBlack"),
            printerSettings: new XName(wNs, "printerSettings"),
            printFormsData: new XName(wNs, "printFormsData"),
            printFractionalCharacterWidth: new XName(wNs, "printFractionalCharacterWidth"),
            printPostScriptOverText: new XName(wNs, "printPostScriptOverText"),
            printTwoOnOne: new XName(wNs, "printTwoOnOne"),
            proofErr: new XName(wNs, "proofErr"),
            proofState: new XName(wNs, "proofState"),
            pStyle: new XName(wNs, "pStyle"),
            ptab: new XName(wNs, "ptab"),
            qFormat: new XName(wNs, "qFormat"),
            query: new XName(wNs, "query"),
            r: new XName(wNs, "r"),
            readModeInkLockDown: new XName(wNs, "readModeInkLockDown"),
            recipientData: new XName(wNs, "recipientData"),
            recommended: new XName(wNs, "recommended"),
            relativeTo: new XName(wNs, "relativeTo"),
            relyOnVML: new XName(wNs, "relyOnVML"),
            removeDateAndTime: new XName(wNs, "removeDateAndTime"),
            removePersonalInformation: new XName(wNs, "removePersonalInformation"),
            restart: new XName(wNs, "restart"),
            result: new XName(wNs, "result"),
            revisionView: new XName(wNs, "revisionView"),
            rFonts: new XName(wNs, "rFonts"),
            right: new XName(wNs, "right"),
            rightChars: new XName(wNs, "rightChars"),
            rightFromText: new XName(wNs, "rightFromText"),
            rPr: new XName(wNs, "rPr"),
            rPrChange: new XName(wNs, "rPrChange"),
            rPrDefault: new XName(wNs, "rPrDefault"),
            rsid: new XName(wNs, "rsid"),
            rsidDel: new XName(wNs, "rsidDel"),
            rsidP: new XName(wNs, "rsidP"),
            rsidR: new XName(wNs, "rsidR"),
            rsidRDefault: new XName(wNs, "rsidRDefault"),
            rsidRoot: new XName(wNs, "rsidRoot"),
            rsidRPr: new XName(wNs, "rsidRPr"),
            rsids: new XName(wNs, "rsids"),
            rsidSect: new XName(wNs, "rsidSect"),
            rsidTr: new XName(wNs, "rsidTr"),
            rStyle: new XName(wNs, "rStyle"),
            rt: new XName(wNs, "rt"),
            rtl: new XName(wNs, "rtl"),
            rtlGutter: new XName(wNs, "rtlGutter"),
            ruby: new XName(wNs, "ruby"),
            rubyAlign: new XName(wNs, "rubyAlign"),
            rubyBase: new XName(wNs, "rubyBase"),
            rubyPr: new XName(wNs, "rubyPr"),
            salt: new XName(wNs, "salt"),
            saveFormsData: new XName(wNs, "saveFormsData"),
            saveInvalidXml: new XName(wNs, "saveInvalidXml"),
            savePreviewPicture: new XName(wNs, "savePreviewPicture"),
            saveSmartTagsAsXml: new XName(wNs, "saveSmartTagsAsXml"),
            saveSubsetFonts: new XName(wNs, "saveSubsetFonts"),
            saveThroughXslt: new XName(wNs, "saveThroughXslt"),
            saveXmlDataOnly: new XName(wNs, "saveXmlDataOnly"),
            scrollbar: new XName(wNs, "scrollbar"),
            sdt: new XName(wNs, "sdt"),
            sdtContent: new XName(wNs, "sdtContent"),
            sdtEndPr: new XName(wNs, "sdtEndPr"),
            sdtPr: new XName(wNs, "sdtPr"),
            sectPr: new XName(wNs, "sectPr"),
            sectPrChange: new XName(wNs, "sectPrChange"),
            selectFldWithFirstOrLastChar: new XName(wNs, "selectFldWithFirstOrLastChar"),
            semiHidden: new XName(wNs, "semiHidden"),
            sep: new XName(wNs, "sep"),
            separator: new XName(wNs, "separator"),
            settings: new XName(wNs, "settings"),
            shadow: new XName(wNs, "shadow"),
            shapeDefaults: new XName(wNs, "shapeDefaults"),
            shapeid: new XName(wNs, "shapeid"),
            shapeLayoutLikeWW8: new XName(wNs, "shapeLayoutLikeWW8"),
            shd: new XName(wNs, "shd"),
            showBreaksInFrames: new XName(wNs, "showBreaksInFrames"),
            showEnvelope: new XName(wNs, "showEnvelope"),
            showingPlcHdr: new XName(wNs, "showingPlcHdr"),
            showXMLTags: new XName(wNs, "showXMLTags"),
            sig: new XName(wNs, "sig"),
            size: new XName(wNs, "size"),
            sizeAuto: new XName(wNs, "sizeAuto"),
            smallCaps: new XName(wNs, "smallCaps"),
            smartTag: new XName(wNs, "smartTag"),
            smartTagPr: new XName(wNs, "smartTagPr"),
            smartTagType: new XName(wNs, "smartTagType"),
            snapToGrid: new XName(wNs, "snapToGrid"),
            softHyphen: new XName(wNs, "softHyphen"),
            solutionID: new XName(wNs, "solutionID"),
            sourceFileName: new XName(wNs, "sourceFileName"),
            space: new XName(wNs, "space"),
            spaceForUL: new XName(wNs, "spaceForUL"),
            spacing: new XName(wNs, "spacing"),
            spacingInWholePoints: new XName(wNs, "spacingInWholePoints"),
            specVanish: new XName(wNs, "specVanish"),
            spelling: new XName(wNs, "spelling"),
            splitPgBreakAndParaMark: new XName(wNs, "splitPgBreakAndParaMark"),
            src: new XName(wNs, "src"),
            start: new XName(wNs, "start"),
            startOverride: new XName(wNs, "startOverride"),
            statusText: new XName(wNs, "statusText"),
            storeItemID: new XName(wNs, "storeItemID"),
            storeMappedDataAs: new XName(wNs, "storeMappedDataAs"),
            strictFirstAndLastChars: new XName(wNs, "strictFirstAndLastChars"),
            strike: new XName(wNs, "strike"),
            style: new XName(wNs, "style"),
            styleId: new XName(wNs, "styleId"),
            styleLink: new XName(wNs, "styleLink"),
            styleLockQFSet: new XName(wNs, "styleLockQFSet"),
            styleLockTheme: new XName(wNs, "styleLockTheme"),
            stylePaneFormatFilter: new XName(wNs, "stylePaneFormatFilter"),
            stylePaneSortMethod: new XName(wNs, "stylePaneSortMethod"),
            styles: new XName(wNs, "styles"),
            subDoc: new XName(wNs, "subDoc"),
            subFontBySize: new XName(wNs, "subFontBySize"),
            subsetted: new XName(wNs, "subsetted"),
            suff: new XName(wNs, "suff"),
            summaryLength: new XName(wNs, "summaryLength"),
            suppressAutoHyphens: new XName(wNs, "suppressAutoHyphens"),
            suppressBottomSpacing: new XName(wNs, "suppressBottomSpacing"),
            suppressLineNumbers: new XName(wNs, "suppressLineNumbers"),
            suppressOverlap: new XName(wNs, "suppressOverlap"),
            suppressSpacingAtTopOfPage: new XName(wNs, "suppressSpacingAtTopOfPage"),
            suppressSpBfAfterPgBrk: new XName(wNs, "suppressSpBfAfterPgBrk"),
            suppressTopSpacing: new XName(wNs, "suppressTopSpacing"),
            suppressTopSpacingWP: new XName(wNs, "suppressTopSpacingWP"),
            swapBordersFacingPages: new XName(wNs, "swapBordersFacingPages"),
            sym: new XName(wNs, "sym"),
            sz: new XName(wNs, "sz"),
            szCs: new XName(wNs, "szCs"),
            t: new XName(wNs, "t"),
            t1: new XName(wNs, "t1"),
            t2: new XName(wNs, "t2"),
            tab: new XName(wNs, "tab"),
            table: new XName(wNs, "table"),
            tabs: new XName(wNs, "tabs"),
            tag: new XName(wNs, "tag"),
            targetScreenSz: new XName(wNs, "targetScreenSz"),
            tbl: new XName(wNs, "tbl"),
            tblBorders: new XName(wNs, "tblBorders"),
            tblCellMar: new XName(wNs, "tblCellMar"),
            tblCellSpacing: new XName(wNs, "tblCellSpacing"),
            tblGrid: new XName(wNs, "tblGrid"),
            tblGridChange: new XName(wNs, "tblGridChange"),
            tblHeader: new XName(wNs, "tblHeader"),
            tblInd: new XName(wNs, "tblInd"),
            tblLayout: new XName(wNs, "tblLayout"),
            tblLook: new XName(wNs, "tblLook"),
            tblOverlap: new XName(wNs, "tblOverlap"),
            tblpPr: new XName(wNs, "tblpPr"),
            tblPr: new XName(wNs, "tblPr"),
            tblPrChange: new XName(wNs, "tblPrChange"),
            tblPrEx: new XName(wNs, "tblPrEx"),
            tblPrExChange: new XName(wNs, "tblPrExChange"),
            tblpX: new XName(wNs, "tblpX"),
            tblpXSpec: new XName(wNs, "tblpXSpec"),
            tblpY: new XName(wNs, "tblpY"),
            tblpYSpec: new XName(wNs, "tblpYSpec"),
            tblStyle: new XName(wNs, "tblStyle"),
            tblStyleColBandSize: new XName(wNs, "tblStyleColBandSize"),
            tblStylePr: new XName(wNs, "tblStylePr"),
            tblStyleRowBandSize: new XName(wNs, "tblStyleRowBandSize"),
            tblW: new XName(wNs, "tblW"),
            tc: new XName(wNs, "tc"),
            tcBorders: new XName(wNs, "tcBorders"),
            tcFitText: new XName(wNs, "tcFitText"),
            tcMar: new XName(wNs, "tcMar"),
            tcPr: new XName(wNs, "tcPr"),
            tcPrChange: new XName(wNs, "tcPrChange"),
            tcW: new XName(wNs, "tcW"),
            temporary: new XName(wNs, "temporary"),
            tentative: new XName(wNs, "tentative"),
            text: new XName(wNs, "text"),
            textAlignment: new XName(wNs, "textAlignment"),
            textboxTightWrap: new XName(wNs, "textboxTightWrap"),
            textDirection: new XName(wNs, "textDirection"),
            textInput: new XName(wNs, "textInput"),
            tgtFrame: new XName(wNs, "tgtFrame"),
            themeColor: new XName(wNs, "themeColor"),
            themeFill: new XName(wNs, "themeFill"),
            themeFillShade: new XName(wNs, "themeFillShade"),
            themeFillTint: new XName(wNs, "themeFillTint"),
            themeFontLang: new XName(wNs, "themeFontLang"),
            themeShade: new XName(wNs, "themeShade"),
            themeTint: new XName(wNs, "themeTint"),
            titlePg: new XName(wNs, "titlePg"),
            tl2br: new XName(wNs, "tl2br"),
            tmpl: new XName(wNs, "tmpl"),
            tooltip: new XName(wNs, "tooltip"),
            top: new XName(wNs, "top"),
            topFromText: new XName(wNs, "topFromText"),
            topLinePunct: new XName(wNs, "topLinePunct"),
            tplc: new XName(wNs, "tplc"),
            tr: new XName(wNs, "tr"),
            tr2bl: new XName(wNs, "tr2bl"),
            trackRevisions: new XName(wNs, "trackRevisions"),
            trHeight: new XName(wNs, "trHeight"),
            trPr: new XName(wNs, "trPr"),
            trPrChange: new XName(wNs, "trPrChange"),
            truncateFontHeightsLikeWP6: new XName(wNs, "truncateFontHeightsLikeWP6"),
            txbxContent: new XName(wNs, "txbxContent"),
            type: new XName(wNs, "type"),
            types: new XName(wNs, "types"),
            u: new XName(wNs, "u"),
            udl: new XName(wNs, "udl"),
            uiCompat97To2003: new XName(wNs, "uiCompat97To2003"),
            uiPriority: new XName(wNs, "uiPriority"),
            ulTrailSpace: new XName(wNs, "ulTrailSpace"),
            underlineTabInNumList: new XName(wNs, "underlineTabInNumList"),
            unhideWhenUsed: new XName(wNs, "unhideWhenUsed"),
            updateFields: new XName(wNs, "updateFields"),
            uri: new XName(wNs, "uri"),
            url: new XName(wNs, "url"),
            usb0: new XName(wNs, "usb0"),
            usb1: new XName(wNs, "usb1"),
            usb2: new XName(wNs, "usb2"),
            usb3: new XName(wNs, "usb3"),
            useAltKinsokuLineBreakRules: new XName(wNs, "useAltKinsokuLineBreakRules"),
            useAnsiKerningPairs: new XName(wNs, "useAnsiKerningPairs"),
            useFELayout: new XName(wNs, "useFELayout"),
            useNormalStyleForList: new XName(wNs, "useNormalStyleForList"),
            usePrinterMetrics: new XName(wNs, "usePrinterMetrics"),
            useSingleBorderforContiguousCells: new XName(wNs, "useSingleBorderforContiguousCells"),
            useWord2002TableStyleRules: new XName(wNs, "useWord2002TableStyleRules"),
            useWord97LineBreakRules: new XName(wNs, "useWord97LineBreakRules"),
            useXSLTWhenSaving: new XName(wNs, "useXSLTWhenSaving"),
            val: new XName(wNs, "val"),
            vAlign: new XName(wNs, "vAlign"),
            value: new XName(wNs, "value"),
            vAnchor: new XName(wNs, "vAnchor"),
            vanish: new XName(wNs, "vanish"),
            vendorID: new XName(wNs, "vendorID"),
            vert: new XName(wNs, "vert"),
            vertAlign: new XName(wNs, "vertAlign"),
            vertAnchor: new XName(wNs, "vertAnchor"),
            vertCompress: new XName(wNs, "vertCompress"),
            view: new XName(wNs, "view"),
            viewMergedData: new XName(wNs, "viewMergedData"),
            vMerge: new XName(wNs, "vMerge"),
            vMergeOrig: new XName(wNs, "vMergeOrig"),
            vSpace: new XName(wNs, "vSpace"),
            _w: new XName(wNs, "w"),
            wAfter: new XName(wNs, "wAfter"),
            wBefore: new XName(wNs, "wBefore"),
            webHidden: new XName(wNs, "webHidden"),
            webSettings: new XName(wNs, "webSettings"),
            widowControl: new XName(wNs, "widowControl"),
            wordWrap: new XName(wNs, "wordWrap"),
            wpJustification: new XName(wNs, "wpJustification"),
            wpSpaceWidth: new XName(wNs, "wpSpaceWidth"),
            wrap: new XName(wNs, "wrap"),
            wrapTrailSpaces: new XName(wNs, "wrapTrailSpaces"),
            writeProtection: new XName(wNs, "writeProtection"),
            x: new XName(wNs, "x"),
            xAlign: new XName(wNs, "xAlign"),
            xpath: new XName(wNs, "xpath"),
            y: new XName(wNs, "y"),
            yAlign: new XName(wNs, "yAlign"),
            yearLong: new XName(wNs, "yearLong"),
            yearShort: new XName(wNs, "yearShort"),
            zoom: new XName(wNs, "zoom"),
            zOrder: new XName(wNs, "zOrder"),
        }
        var W = openXml.W;

        openXml.w10Ns = new XNamespace("urn:schemas-microsoft-com:office:word");
        var w10Ns = openXml.w10Ns;
        openXml.W10 = {
            anchorlock: new XName(w10Ns, "anchorlock"),
            borderbottom: new XName(w10Ns, "borderbottom"),
            borderleft: new XName(w10Ns, "borderleft"),
            borderright: new XName(w10Ns, "borderright"),
            bordertop: new XName(w10Ns, "bordertop"),
            wrap: new XName(w10Ns, "wrap"),
        }
        var W10 = openXml.W10;

        openXml.w14Ns = new XNamespace("http://schemas.microsoft.com/office/word/2010/wordml");
        var w14Ns = openXml.w14Ns;
        openXml.W14 = {
            algn: new XName(w14Ns, "algn"),
            alpha: new XName(w14Ns, "alpha"),
            ang: new XName(w14Ns, "ang"),
            b: new XName(w14Ns, "b"),
            bevel: new XName(w14Ns, "bevel"),
            bevelB: new XName(w14Ns, "bevelB"),
            bevelT: new XName(w14Ns, "bevelT"),
            blurRad: new XName(w14Ns, "blurRad"),
            camera: new XName(w14Ns, "camera"),
            cap: new XName(w14Ns, "cap"),
            checkbox: new XName(w14Ns, "checkbox"),
            _checked: new XName(w14Ns, "checked"),
            checkedState: new XName(w14Ns, "checkedState"),
            cmpd: new XName(w14Ns, "cmpd"),
            cntxtAlts: new XName(w14Ns, "cntxtAlts"),
            cNvContentPartPr: new XName(w14Ns, "cNvContentPartPr"),
            conflictMode: new XName(w14Ns, "conflictMode"),
            contentPart: new XName(w14Ns, "contentPart"),
            contourClr: new XName(w14Ns, "contourClr"),
            contourW: new XName(w14Ns, "contourW"),
            defaultImageDpi: new XName(w14Ns, "defaultImageDpi"),
            dir: new XName(w14Ns, "dir"),
            discardImageEditingData: new XName(w14Ns, "discardImageEditingData"),
            dist: new XName(w14Ns, "dist"),
            docId: new XName(w14Ns, "docId"),
            editId: new XName(w14Ns, "editId"),
            enableOpenTypeKerning: new XName(w14Ns, "enableOpenTypeKerning"),
            endA: new XName(w14Ns, "endA"),
            endPos: new XName(w14Ns, "endPos"),
            entityPicker: new XName(w14Ns, "entityPicker"),
            extrusionClr: new XName(w14Ns, "extrusionClr"),
            extrusionH: new XName(w14Ns, "extrusionH"),
            fadeDir: new XName(w14Ns, "fadeDir"),
            fillToRect: new XName(w14Ns, "fillToRect"),
            font: new XName(w14Ns, "font"),
            glow: new XName(w14Ns, "glow"),
            gradFill: new XName(w14Ns, "gradFill"),
            gs: new XName(w14Ns, "gs"),
            gsLst: new XName(w14Ns, "gsLst"),
            h: new XName(w14Ns, "h"),
            hueMod: new XName(w14Ns, "hueMod"),
            id: new XName(w14Ns, "id"),
            kx: new XName(w14Ns, "kx"),
            ky: new XName(w14Ns, "ky"),
            l: new XName(w14Ns, "l"),
            lat: new XName(w14Ns, "lat"),
            ligatures: new XName(w14Ns, "ligatures"),
            lightRig: new XName(w14Ns, "lightRig"),
            lim: new XName(w14Ns, "lim"),
            lin: new XName(w14Ns, "lin"),
            lon: new XName(w14Ns, "lon"),
            lumMod: new XName(w14Ns, "lumMod"),
            lumOff: new XName(w14Ns, "lumOff"),
            miter: new XName(w14Ns, "miter"),
            noFill: new XName(w14Ns, "noFill"),
            numForm: new XName(w14Ns, "numForm"),
            numSpacing: new XName(w14Ns, "numSpacing"),
            nvContentPartPr: new XName(w14Ns, "nvContentPartPr"),
            paraId: new XName(w14Ns, "paraId"),
            path: new XName(w14Ns, "path"),
            pos: new XName(w14Ns, "pos"),
            props3d: new XName(w14Ns, "props3d"),
            prst: new XName(w14Ns, "prst"),
            prstDash: new XName(w14Ns, "prstDash"),
            prstMaterial: new XName(w14Ns, "prstMaterial"),
            r: new XName(w14Ns, "r"),
            rad: new XName(w14Ns, "rad"),
            reflection: new XName(w14Ns, "reflection"),
            rev: new XName(w14Ns, "rev"),
            rig: new XName(w14Ns, "rig"),
            rot: new XName(w14Ns, "rot"),
            round: new XName(w14Ns, "round"),
            sat: new XName(w14Ns, "sat"),
            satMod: new XName(w14Ns, "satMod"),
            satOff: new XName(w14Ns, "satOff"),
            scaled: new XName(w14Ns, "scaled"),
            scene3d: new XName(w14Ns, "scene3d"),
            schemeClr: new XName(w14Ns, "schemeClr"),
            shade: new XName(w14Ns, "shade"),
            shadow: new XName(w14Ns, "shadow"),
            solidFill: new XName(w14Ns, "solidFill"),
            srgbClr: new XName(w14Ns, "srgbClr"),
            stA: new XName(w14Ns, "stA"),
            stPos: new XName(w14Ns, "stPos"),
            styleSet: new XName(w14Ns, "styleSet"),
            stylisticSets: new XName(w14Ns, "stylisticSets"),
            sx: new XName(w14Ns, "sx"),
            sy: new XName(w14Ns, "sy"),
            t: new XName(w14Ns, "t"),
            textFill: new XName(w14Ns, "textFill"),
            textId: new XName(w14Ns, "textId"),
            textOutline: new XName(w14Ns, "textOutline"),
            tint: new XName(w14Ns, "tint"),
            uncheckedState: new XName(w14Ns, "uncheckedState"),
            val: new XName(w14Ns, "val"),
            w: new XName(w14Ns, "w"),
            wProps3d: new XName(w14Ns, "wProps3d"),
            wScene3d: new XName(w14Ns, "wScene3d"),
            wShadow: new XName(w14Ns, "wShadow"),
            wTextFill: new XName(w14Ns, "wTextFill"),
            wTextOutline: new XName(w14Ns, "wTextOutline"),
            xfrm: new XName(w14Ns, "xfrm"),
        }
        var W14 = openXml.W14;

        openXml.w3digsigNs = new XNamespace("http://www.w3.org/2000/09/xmldsig#");
        var w3digsigNs = openXml.w3digsigNs;
        openXml.W3DIGSIG = {
            CanonicalizationMethod: new XName(w3digsigNs, "CanonicalizationMethod"),
            DigestMethod: new XName(w3digsigNs, "DigestMethod"),
            DigestValue: new XName(w3digsigNs, "DigestValue"),
            Exponent: new XName(w3digsigNs, "Exponent"),
            KeyInfo: new XName(w3digsigNs, "KeyInfo"),
            KeyValue: new XName(w3digsigNs, "KeyValue"),
            Manifest: new XName(w3digsigNs, "Manifest"),
            Modulus: new XName(w3digsigNs, "Modulus"),
            Object: new XName(w3digsigNs, "Object"),
            Reference: new XName(w3digsigNs, "Reference"),
            RSAKeyValue: new XName(w3digsigNs, "RSAKeyValue"),
            Signature: new XName(w3digsigNs, "Signature"),
            SignatureMethod: new XName(w3digsigNs, "SignatureMethod"),
            SignatureProperties: new XName(w3digsigNs, "SignatureProperties"),
            SignatureProperty: new XName(w3digsigNs, "SignatureProperty"),
            SignatureValue: new XName(w3digsigNs, "SignatureValue"),
            SignedInfo: new XName(w3digsigNs, "SignedInfo"),
            Transform: new XName(w3digsigNs, "Transform"),
            Transforms: new XName(w3digsigNs, "Transforms"),
            X509Certificate: new XName(w3digsigNs, "X509Certificate"),
            X509Data: new XName(w3digsigNs, "X509Data"),
            X509IssuerName: new XName(w3digsigNs, "X509IssuerName"),
            X509SerialNumber: new XName(w3digsigNs, "X509SerialNumber"),
        }
        var W3DIGSIG = openXml.W3DIGSIG;

        openXml.wpNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing");
        var wpNs = openXml.wpNs;
        openXml.WP = {
            align: new XName(wpNs, "align"),
            anchor: new XName(wpNs, "anchor"),
            cNvGraphicFramePr: new XName(wpNs, "cNvGraphicFramePr"),
            docPr: new XName(wpNs, "docPr"),
            effectExtent: new XName(wpNs, "effectExtent"),
            extent: new XName(wpNs, "extent"),
            inline: new XName(wpNs, "inline"),
            lineTo: new XName(wpNs, "lineTo"),
            positionH: new XName(wpNs, "positionH"),
            positionV: new XName(wpNs, "positionV"),
            posOffset: new XName(wpNs, "posOffset"),
            simplePos: new XName(wpNs, "simplePos"),
            start: new XName(wpNs, "start"),
            wrapNone: new XName(wpNs, "wrapNone"),
            wrapPolygon: new XName(wpNs, "wrapPolygon"),
            wrapSquare: new XName(wpNs, "wrapSquare"),
            wrapThrough: new XName(wpNs, "wrapThrough"),
            wrapTight: new XName(wpNs, "wrapTight"),
            wrapTopAndBottom: new XName(wpNs, "wrapTopAndBottom"),
        }
        var WP = openXml.WP;

        openXml.wp14Ns = new XNamespace("http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing");
        var wp14Ns = openXml.wp14Ns;
        openXml.WP14 = {
            editId: new XName(wp14Ns, "editId"),
            pctHeight: new XName(wp14Ns, "pctHeight"),
            pctPosVOffset: new XName(wp14Ns, "pctPosVOffset"),
            pctWidth: new XName(wp14Ns, "pctWidth"),
            sizeRelH: new XName(wp14Ns, "sizeRelH"),
            sizeRelV: new XName(wp14Ns, "sizeRelV"),
        }
        var WP14 = openXml.WP14;

        openXml.wpsNs = new XNamespace("http://schemas.microsoft.com/office/word/2010/wordprocessingShape");
        var wpsNs = openXml.wpsNs;
        openXml.WPS = {
            altTxbx: new XName(wpsNs, "altTxbx"),
            bodyPr: new XName(wpsNs, "bodyPr"),
            cNvSpPr: new XName(wpsNs, "cNvSpPr"),
            spPr: new XName(wpsNs, "spPr"),
            style: new XName(wpsNs, "style"),
            textbox: new XName(wpsNs, "textbox"),
            txbx: new XName(wpsNs, "txbx"),
            wsp: new XName(wpsNs, "wsp"),
        }
        var WPS = openXml.WPS;

        openXml.xNs = new XNamespace("urn:schemas-microsoft-com:office:excel");
        var xNs = openXml.xNs;
        openXml.X = {
            Anchor: new XName(xNs, "Anchor"),
            AutoFill: new XName(xNs, "AutoFill"),
            ClientData: new XName(xNs, "ClientData"),
            Column: new XName(xNs, "Column"),
            MoveWithCells: new XName(xNs, "MoveWithCells"),
            Row: new XName(xNs, "Row"),
            SizeWithCells: new XName(xNs, "SizeWithCells"),
        }
        var X = openXml.X;

        openXml.xdrNs = new XNamespace("http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing");
        var xdrNs = openXml.xdrNs;
        openXml.XDR = {
            absoluteAnchor: new XName(xdrNs, "absoluteAnchor"),
            blipFill: new XName(xdrNs, "blipFill"),
            clientData: new XName(xdrNs, "clientData"),
            cNvCxnSpPr: new XName(xdrNs, "cNvCxnSpPr"),
            cNvGraphicFramePr: new XName(xdrNs, "cNvGraphicFramePr"),
            cNvGrpSpPr: new XName(xdrNs, "cNvGrpSpPr"),
            cNvPicPr: new XName(xdrNs, "cNvPicPr"),
            cNvPr: new XName(xdrNs, "cNvPr"),
            cNvSpPr: new XName(xdrNs, "cNvSpPr"),
            col: new XName(xdrNs, "col"),
            colOff: new XName(xdrNs, "colOff"),
            contentPart: new XName(xdrNs, "contentPart"),
            cxnSp: new XName(xdrNs, "cxnSp"),
            ext: new XName(xdrNs, "ext"),
            from: new XName(xdrNs, "from"),
            graphicFrame: new XName(xdrNs, "graphicFrame"),
            grpSp: new XName(xdrNs, "grpSp"),
            grpSpPr: new XName(xdrNs, "grpSpPr"),
            nvCxnSpPr: new XName(xdrNs, "nvCxnSpPr"),
            nvGraphicFramePr: new XName(xdrNs, "nvGraphicFramePr"),
            nvGrpSpPr: new XName(xdrNs, "nvGrpSpPr"),
            nvPicPr: new XName(xdrNs, "nvPicPr"),
            nvSpPr: new XName(xdrNs, "nvSpPr"),
            oneCellAnchor: new XName(xdrNs, "oneCellAnchor"),
            pic: new XName(xdrNs, "pic"),
            pos: new XName(xdrNs, "pos"),
            row: new XName(xdrNs, "row"),
            rowOff: new XName(xdrNs, "rowOff"),
            sp: new XName(xdrNs, "sp"),
            spPr: new XName(xdrNs, "spPr"),
            style: new XName(xdrNs, "style"),
            to: new XName(xdrNs, "to"),
            twoCellAnchor: new XName(xdrNs, "twoCellAnchor"),
            txBody: new XName(xdrNs, "txBody"),
            wsDr: new XName(xdrNs, "wsDr"),
            xfrm: new XName(xdrNs, "xfrm"),
        }
        var XDR = openXml.XDR;

        openXml.xdr14Ns = new XNamespace("http://schemas.microsoft.com/office/excel/2010/spreadsheetDrawing");
        var xdr14Ns = openXml.xdr14Ns;
        openXml.XDR14 = {
            cNvContentPartPr: new XName(xdr14Ns, "cNvContentPartPr"),
            cNvPr: new XName(xdr14Ns, "cNvPr"),
            nvContentPartPr: new XName(xdr14Ns, "nvContentPartPr"),
            nvPr: new XName(xdr14Ns, "nvPr"),
            xfrm: new XName(xdr14Ns, "xfrm"),
        }
        var XDR14 = openXml.XDR14;

        openXml.xmNs = new XNamespace("http://schemas.microsoft.com/office/excel/2006/main");
        var xmNs = openXml.xmNs;
        openXml.XM = {
            f: new XName(xmNs, "f"),
            _ref: new XName(xmNs, "ref"),
            sqref: new XName(xmNs, "sqref"),
        }
        var XM = openXml.XM;

        openXml.xsiNs = new XNamespace("http://www.w3.org/2001/XMLSchema-instance");
        var xsiNs = openXml.xsiNs;
        openXml.XSI = {
            type: new XName(xsiNs, "type"),
        }
        var XSI = openXml.XSI;

        /******************************** end automatically generated code ********************************/

        openXml.ctNs = new XNamespace("http://schemas.openxmlformats.org/package/2006/content-types");
        var ctNs = openXml.ctNs;
        openXml.CT = {
            Override: new XName(ctNs, "Override"),
            Default: new XName(ctNs, "Default"),
            Types: new XName(ctNs, "Types"),
        }
        var CT = openXml.CT;

        openXml.pkgRelNs = new XNamespace("http://schemas.openxmlformats.org/package/2006/relationships");
        var pkgRelNs = openXml.pkgRelNs;
        openXml.PKGREL = {
            Relationships: new XName(pkgRelNs, "Relationships"),
            Relationship: new XName(pkgRelNs, "Relationship"),
        }
        var PKGREL = openXml.PKGREL;

        openXml.flatOpcPkgNs = new XNamespace("http://schemas.microsoft.com/office/2006/xmlPackage");
        var flatOpcPkgNs = openXml.flatOpcPkgNs;
        openXml.FLATOPC = {
            _package: new XName(flatOpcPkgNs + "package"),
            part: new XName(flatOpcPkgNs + "part"),
            name: new XName(flatOpcPkgNs + "name"),
            contentType: new XName(flatOpcPkgNs + "contentType"),
            padding: new XName(flatOpcPkgNs + "padding"),
            xmlData: new XName(flatOpcPkgNs + "xmlData"),
            binaryData: new XName(flatOpcPkgNs + "binaryData"),
            compression: new XName(flatOpcPkgNs + "compression"),
        }
        var FLATOPC = openXml.FLATOPC;

        return openXml;
    }

    // module export
    if (typeof define === typeof function () { } && define.amd) { // AMD
        define("openxml", ["linq", "ltxml", "ltxml-extensions"],
            function (Enumerable, Ltxml, XEnumerable) {
                var openXml = defineOpenXml(Enumerable, Ltxml, XEnumerable);
                return openXml;
            });
    }
    else if (typeof module !== typeof undefined && module.exports) { // Node
        var openXml = defineOpenXml(Enumerable, Ltxml, XEnumerable);
        module.exports = openXml;
    }
    else {
        // Enumerable, Ltxml, and XEnumerable must be defined before including ltxml.js.
        var openXml = defineOpenXml(Enumerable, Ltxml, XEnumerable);
        root.openXml = openXml;
    }

}(this));