xmldsigjs/build/index.js

XMLDSIGjs provides an implementation of XMLDSIG in Typescript/Javascript based on WebCrypto

'use strict';

var XmlCore = require('xml-core');
var pkijs = require('pkijs');
var tslib = require('tslib');
var Asn1Js = require('asn1js');
var pvtsutils = require('pvtsutils');

function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n.default = e;
    return Object.freeze(n);
}

var XmlCore__namespace = /*#__PURE__*/_interopNamespaceDefault(XmlCore);
var Asn1Js__namespace = /*#__PURE__*/_interopNamespaceDefault(Asn1Js);

let engineCrypto = null;
class Application {
    static setEngine(name, crypto) {
        engineCrypto = Object.assign(crypto, { name });
        pkijs.setEngine(name, new pkijs.CryptoEngine({ name, crypto }));
    }
    static get crypto() {
        if (!engineCrypto) {
            throw new XmlCore.XmlError(XmlCore.XE.CRYPTOGRAPHIC_NO_MODULE);
        }
        return engineCrypto;
    }
    static isNodePlugin() {
        return (typeof self === "undefined" && typeof window === "undefined");
    }
}
function init() {
    if (!Application.isNodePlugin()) {
        Application.setEngine("W3 WebCrypto module", self.crypto);
    }
}
init();

class XmlAlgorithm {
    getAlgorithmName() {
        return this.namespaceURI;
    }
}
class HashAlgorithm extends XmlAlgorithm {
    async Digest(xml) {
        let buf;
        if (typeof xml === "string") {
            buf = XmlCore.Convert.FromString(xml, "utf8");
        }
        else if (ArrayBuffer.isView(xml)) {
            buf = new Uint8Array(xml.buffer);
        }
        else if (xml instanceof ArrayBuffer) {
            buf = new Uint8Array(xml);
        }
        else {
            const txt = new XMLSerializer().serializeToString(xml);
            buf = XmlCore.Convert.FromString(txt, "utf8");
        }
        const hash = await Application.crypto.subtle.digest(this.algorithm, buf);
        return new Uint8Array(hash);
    }
}
class SignatureAlgorithm extends XmlAlgorithm {
    async Sign(signedInfo, signingKey, algorithm) {
        const info = XmlCore.Convert.FromString(signedInfo, "utf8");
        return Application.crypto.subtle.sign(algorithm, signingKey, info);
    }
    async Verify(signedInfo, key, signatureValue, algorithm) {
        const info = XmlCore.Convert.FromString(signedInfo, "utf8");
        return Application.crypto.subtle.verify((algorithm || this.algorithm), key, signatureValue, info);
    }
}

const SHA1 = "SHA-1";
const SHA256 = "SHA-256";
const SHA384 = "SHA-384";
const SHA512 = "SHA-512";
const SHA1_NAMESPACE = "http://www.w3.org/2000/09/xmldsig#sha1";
const SHA256_NAMESPACE = "http://www.w3.org/2001/04/xmlenc#sha256";
const SHA384_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#sha384";
const SHA512_NAMESPACE = "http://www.w3.org/2001/04/xmlenc#sha512";
class Sha1 extends HashAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = { name: SHA1 };
        this.namespaceURI = SHA1_NAMESPACE;
    }
}
class Sha256 extends HashAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = { name: SHA256 };
        this.namespaceURI = SHA256_NAMESPACE;
    }
}
class Sha384 extends HashAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = { name: SHA384 };
        this.namespaceURI = SHA384_NAMESPACE;
    }
}
class Sha512 extends HashAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = { name: SHA512 };
        this.namespaceURI = SHA512_NAMESPACE;
    }
}

const ECDSA = "ECDSA";
const ECDSA_SHA1_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1";
const ECDSA_SHA256_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256";
const ECDSA_SHA384_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384";
const ECDSA_SHA512_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512";
class EcdsaSha1 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: ECDSA,
            hash: {
                name: SHA1,
            },
        };
        this.namespaceURI = ECDSA_SHA1_NAMESPACE;
    }
}
class EcdsaSha256 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: ECDSA,
            hash: {
                name: SHA256,
            },
        };
        this.namespaceURI = ECDSA_SHA256_NAMESPACE;
    }
}
class EcdsaSha384 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: ECDSA,
            hash: {
                name: SHA384,
            },
        };
        this.namespaceURI = ECDSA_SHA384_NAMESPACE;
    }
}
class EcdsaSha512 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: ECDSA,
            hash: {
                name: SHA512,
            },
        };
        this.namespaceURI = ECDSA_SHA512_NAMESPACE;
    }
}

const HMAC = "HMAC";
const HMAC_SHA1_NAMESPACE = "http://www.w3.org/2000/09/xmldsig#hmac-sha1";
const HMAC_SHA256_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha256";
const HMAC_SHA384_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha384";
const HMAC_SHA512_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha512";
class HmacSha1 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: HMAC,
            hash: {
                name: SHA1,
            },
        };
        this.namespaceURI = HMAC_SHA1_NAMESPACE;
    }
}
class HmacSha256 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: HMAC,
            hash: {
                name: SHA256,
            },
        };
        this.namespaceURI = HMAC_SHA256_NAMESPACE;
    }
}
class HmacSha384 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: HMAC,
            hash: {
                name: SHA384,
            },
        };
        this.namespaceURI = HMAC_SHA384_NAMESPACE;
    }
}
class HmacSha512 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: HMAC,
            hash: {
                name: SHA512,
            },
        };
        this.namespaceURI = HMAC_SHA512_NAMESPACE;
    }
}

const RSA_PKCS1 = "RSASSA-PKCS1-v1_5";
const RSA_PKCS1_SHA1_NAMESPACE = "http://www.w3.org/2000/09/xmldsig#rsa-sha1";
const RSA_PKCS1_SHA256_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256";
const RSA_PKCS1_SHA384_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384";
const RSA_PKCS1_SHA512_NAMESPACE = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512";
class RsaPkcs1Sha1 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: RSA_PKCS1,
            hash: {
                name: SHA1,
            },
        };
        this.namespaceURI = RSA_PKCS1_SHA1_NAMESPACE;
    }
}
class RsaPkcs1Sha256 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: RSA_PKCS1,
            hash: {
                name: SHA256,
            },
        };
        this.namespaceURI = RSA_PKCS1_SHA256_NAMESPACE;
    }
}
class RsaPkcs1Sha384 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: RSA_PKCS1,
            hash: {
                name: SHA384,
            },
        };
        this.namespaceURI = RSA_PKCS1_SHA384_NAMESPACE;
    }
}
class RsaPkcs1Sha512 extends SignatureAlgorithm {
    constructor() {
        super(...arguments);
        this.algorithm = {
            name: RSA_PKCS1,
            hash: {
                name: SHA512,
            },
        };
        this.namespaceURI = RSA_PKCS1_SHA512_NAMESPACE;
    }
}

const RSA_PSS = "RSA-PSS";
const RSA_PSS_WITH_PARAMS_NAMESPACE = "http://www.w3.org/2007/05/xmldsig-more#rsa-pss";
class RsaPssBase extends SignatureAlgorithm {
    constructor(saltLength) {
        super();
        this.algorithm = {
            name: RSA_PSS,
            hash: {
                name: SHA1,
            },
        };
        this.namespaceURI = RSA_PSS_WITH_PARAMS_NAMESPACE;
        if (saltLength) {
            this.algorithm.saltLength = saltLength;
        }
    }
}
class RsaPssSha1 extends RsaPssBase {
    constructor(saltLength) {
        super(saltLength);
        this.algorithm.hash.name = SHA1;
    }
}
class RsaPssSha256 extends RsaPssBase {
    constructor(saltLength) {
        super(saltLength);
        this.algorithm.hash.name = SHA256;
    }
}
class RsaPssSha384 extends RsaPssBase {
    constructor(saltLength) {
        super(saltLength);
        this.algorithm.hash.name = SHA384;
    }
}
class RsaPssSha512 extends RsaPssBase {
    constructor(saltLength) {
        super(saltLength);
        this.algorithm.hash.name = SHA512;
    }
}

const RSA_PSS_SHA1_NAMESPACE = "http://www.w3.org/2007/05/xmldsig-more#sha1-rsa-MGF1";
const RSA_PSS_SHA256_NAMESPACE = "http://www.w3.org/2007/05/xmldsig-more#sha256-rsa-MGF1";
const RSA_PSS_SHA384_NAMESPACE = "http://www.w3.org/2007/05/xmldsig-more#sha384-rsa-MGF1";
const RSA_PSS_SHA512_NAMESPACE = "http://www.w3.org/2007/05/xmldsig-more#sha512-rsa-MGF1";
class RsaPssWithoutParamsBase extends SignatureAlgorithm {
    constructor() {
        super();
        this.algorithm = {
            name: RSA_PSS,
            hash: {
                name: SHA1,
            },
        };
        this.namespaceURI = RSA_PSS_SHA1_NAMESPACE;
    }
}
class RsaPssWithoutParamsSha1 extends RsaPssWithoutParamsBase {
    constructor() {
        super();
        this.algorithm.hash.name = SHA1;
        this.algorithm.saltLength = 20;
    }
}
class RsaPssWithoutParamsSha256 extends RsaPssWithoutParamsBase {
    constructor() {
        super();
        this.algorithm.hash.name = SHA256;
        this.algorithm.saltLength = 32;
    }
}
class RsaPssWithoutParamsSha384 extends RsaPssWithoutParamsBase {
    constructor() {
        super();
        this.algorithm.hash.name = SHA384;
        this.algorithm.saltLength = 48;
    }
}
class RsaPssWithoutParamsSha512 extends RsaPssWithoutParamsBase {
    constructor() {
        super();
        this.algorithm.hash.name = SHA512;
        this.algorithm.saltLength = 64;
    }
}

exports.XmlCanonicalizerState = void 0;
(function (XmlCanonicalizerState) {
    XmlCanonicalizerState[XmlCanonicalizerState["BeforeDocElement"] = 0] = "BeforeDocElement";
    XmlCanonicalizerState[XmlCanonicalizerState["InsideDocElement"] = 1] = "InsideDocElement";
    XmlCanonicalizerState[XmlCanonicalizerState["AfterDocElement"] = 2] = "AfterDocElement";
})(exports.XmlCanonicalizerState || (exports.XmlCanonicalizerState = {}));
class XmlCanonicalizer {
    constructor(withComments, excC14N, propagatedNamespaces = new XmlCore__namespace.NamespaceManager()) {
        this.propagatedNamespaces = new XmlCore__namespace.NamespaceManager();
        this.result = [];
        this.visibleNamespaces = new XmlCore__namespace.NamespaceManager();
        this.inclusiveNamespacesPrefixList = [];
        this.state = exports.XmlCanonicalizerState.BeforeDocElement;
        this.withComments = withComments;
        this.exclusive = excC14N;
        this.propagatedNamespaces = propagatedNamespaces;
    }
    get InclusiveNamespacesPrefixList() {
        return this.inclusiveNamespacesPrefixList.join(" ");
    }
    set InclusiveNamespacesPrefixList(value) {
        this.inclusiveNamespacesPrefixList = value.split(" ");
    }
    Canonicalize(node) {
        if (!node) {
            throw new XmlCore__namespace.XmlError(XmlCore__namespace.XE.CRYPTOGRAPHIC, "Parameter 1 is not Node");
        }
        this.WriteNode(node);
        const res = this.result.join("");
        return res;
    }
    WriteNode(node) {
        switch (node.nodeType) {
            case XmlCore__namespace.XmlNodeType.Document:
            case XmlCore__namespace.XmlNodeType.DocumentFragment:
                this.WriteDocumentNode(node);
                break;
            case XmlCore__namespace.XmlNodeType.Element:
                this.WriteElementNode(node);
                break;
            case XmlCore__namespace.XmlNodeType.CDATA:
            case XmlCore__namespace.XmlNodeType.SignificantWhitespace:
            case XmlCore__namespace.XmlNodeType.Text:
                if (!XmlCore__namespace.isDocument(node.parentNode)) {
                    this.WriteTextNode(node);
                }
                break;
            case XmlCore__namespace.XmlNodeType.Whitespace:
                if (this.state === exports.XmlCanonicalizerState.InsideDocElement) {
                    this.WriteTextNode(node);
                }
                break;
            case XmlCore__namespace.XmlNodeType.Comment:
                this.WriteCommentNode(node);
                break;
            case XmlCore__namespace.XmlNodeType.ProcessingInstruction:
                this.WriteProcessingInstructionNode(node);
                break;
            case XmlCore__namespace.XmlNodeType.EntityReference:
                for (let i = 0; i < node.childNodes.length; i++) {
                    this.WriteNode(node.childNodes[i]);
                }
                break;
            case XmlCore__namespace.XmlNodeType.Attribute:
                throw new XmlCore__namespace.XmlError(XmlCore__namespace.XE.CRYPTOGRAPHIC, "Attribute node is impossible here");
            case XmlCore__namespace.XmlNodeType.EndElement:
                throw new XmlCore__namespace.XmlError(XmlCore__namespace.XE.CRYPTOGRAPHIC, "Attribute node is impossible here");
            case XmlCore__namespace.XmlNodeType.EndEntity:
                throw new XmlCore__namespace.XmlError(XmlCore__namespace.XE.CRYPTOGRAPHIC, "Attribute node is impossible here");
            case XmlCore__namespace.XmlNodeType.DocumentType:
            case XmlCore__namespace.XmlNodeType.Entity:
            case XmlCore__namespace.XmlNodeType.Notation:
            case XmlCore__namespace.XmlNodeType.XmlDeclaration:
                break;
        }
    }
    WriteDocumentNode(node) {
        this.state = exports.XmlCanonicalizerState.BeforeDocElement;
        for (let child = node.firstChild; child != null; child = child.nextSibling) {
            this.WriteNode(child);
        }
    }
    WriteCommentNode(node) {
        if (this.withComments) {
            if (this.state === exports.XmlCanonicalizerState.AfterDocElement) {
                this.result.push(String.fromCharCode(10) + "<!--");
            }
            else {
                this.result.push("<!--");
            }
            this.result.push(this.NormalizeString(node.nodeValue, XmlCore__namespace.XmlNodeType.Comment));
            if (this.state === exports.XmlCanonicalizerState.BeforeDocElement) {
                this.result.push("-->" + String.fromCharCode(10));
            }
            else {
                this.result.push("-->");
            }
        }
    }
    WriteTextNode(node) {
        this.result.push(this.NormalizeString(node.nodeValue, node.nodeType));
    }
    WriteProcessingInstructionNode(node) {
        const nodeName = node.nodeName || node.tagName;
        if (nodeName === "xml") {
            return;
        }
        if (this.state === exports.XmlCanonicalizerState.AfterDocElement) {
            this.result.push("\u000A<?");
        }
        else {
            this.result.push("<?");
        }
        this.result.push(nodeName);
        if (node.nodeValue) {
            this.result.push(" ");
            this.result.push(this.NormalizeString(node.nodeValue, XmlCore__namespace.XmlNodeType.ProcessingInstruction));
        }
        if (this.state === exports.XmlCanonicalizerState.BeforeDocElement) {
            this.result.push("?>\u000A");
        }
        else {
            this.result.push("?>");
        }
    }
    WriteElementNode(node) {
        const state = this.state;
        if (this.state === exports.XmlCanonicalizerState.BeforeDocElement) {
            this.state = exports.XmlCanonicalizerState.InsideDocElement;
        }
        this.result.push("<");
        this.result.push(node.nodeName);
        let visibleNamespacesCount = this.WriteNamespacesAxis(node);
        this.WriteAttributesAxis(node);
        this.result.push(">");
        for (let n = node.firstChild; n != null; n = n.nextSibling) {
            this.WriteNode(n);
        }
        this.result.push("</");
        this.result.push(node.nodeName);
        this.result.push(">");
        if (state === exports.XmlCanonicalizerState.BeforeDocElement) {
            this.state = exports.XmlCanonicalizerState.AfterDocElement;
        }
        while (visibleNamespacesCount--) {
            this.visibleNamespaces.Pop();
        }
    }
    WriteNamespacesAxis(node) {
        const list = [];
        let visibleNamespacesCount = 0;
        for (let i = 0; i < node.attributes.length; i++) {
            const attribute = node.attributes[i];
            if (!IsNamespaceNode(attribute)) {
                if (attribute.prefix && !this.IsNamespaceRendered(attribute.prefix, attribute.namespaceURI)) {
                    const ns = { prefix: attribute.prefix, namespace: attribute.namespaceURI };
                    list.push(ns);
                    this.visibleNamespaces.Add(ns);
                    visibleNamespacesCount++;
                }
                continue;
            }
            if (attribute.localName === "xmlns" && !attribute.prefix && !attribute.nodeValue) {
                const ns = { prefix: attribute.prefix, namespace: attribute.nodeValue };
                list.push(ns);
                this.visibleNamespaces.Add(ns);
                visibleNamespacesCount++;
            }
            let prefix = null;
            let matches;
            if (matches = /xmlns:([\w\.-]+)/.exec(attribute.nodeName)) {
                prefix = matches[1];
            }
            let printable = true;
            if (this.exclusive && !this.IsNamespaceInclusive(node, prefix)) {
                const used = IsNamespaceUsed(node, prefix);
                if (used > 1) {
                    printable = false;
                }
                else if (used === 0) {
                    continue;
                }
            }
            if (this.IsNamespaceRendered(prefix, attribute.nodeValue)) {
                continue;
            }
            if (printable) {
                const ns = { prefix, namespace: attribute.nodeValue };
                list.push(ns);
                this.visibleNamespaces.Add(ns);
                visibleNamespacesCount++;
            }
        }
        if (!this.IsNamespaceRendered(node.prefix, node.namespaceURI) && node.namespaceURI !== "http://www.w3.org/2000/xmlns/") {
            const ns = { prefix: node.prefix, namespace: node.namespaceURI };
            list.push(ns);
            this.visibleNamespaces.Add(ns);
            visibleNamespacesCount++;
        }
        list.sort(XmlDsigC14NTransformNamespacesComparer);
        let prevPrefix = null;
        list.forEach((n) => {
            if (n.prefix === prevPrefix) {
                return;
            }
            prevPrefix = n.prefix;
            this.result.push(" xmlns");
            if (n.prefix) {
                this.result.push(":" + n.prefix);
            }
            this.result.push("=\"");
            this.result.push(n.namespace);
            this.result.push("\"");
        });
        return visibleNamespacesCount;
    }
    WriteAttributesAxis(node) {
        const list = [];
        for (let i = 0; i < node.attributes.length; i++) {
            const attribute = node.attributes[i];
            if (!IsNamespaceNode(attribute)) {
                list.push(attribute);
            }
        }
        list.sort(XmlDsigC14NTransformAttributesComparer);
        list.forEach((attribute) => {
            if (attribute != null) {
                this.result.push(" ");
                this.result.push(attribute.nodeName);
                this.result.push("=\"");
                this.result.push(this.NormalizeString(attribute.nodeValue, XmlCore__namespace.XmlNodeType.Attribute));
                this.result.push("\"");
            }
        });
    }
    NormalizeString(input, type) {
        const sb = [];
        if (input) {
            for (let i = 0; i < input.length; i++) {
                const ch = input[i];
                if (ch === "<" && (type === XmlCore__namespace.XmlNodeType.Attribute || this.IsTextNode(type))) {
                    sb.push("&lt;");
                }
                else if (ch === ">" && this.IsTextNode(type)) {
                    sb.push("&gt;");
                }
                else if (ch === "&" && (type === XmlCore__namespace.XmlNodeType.Attribute || this.IsTextNode(type))) {
                    sb.push("&amp;");
                }
                else if (ch === "\"" && type === XmlCore__namespace.XmlNodeType.Attribute) {
                    sb.push("&quot;");
                }
                else if (ch === "\u0009" && type === XmlCore__namespace.XmlNodeType.Attribute) {
                    sb.push("&#x9;");
                }
                else if (ch === "\u000A" && type === XmlCore__namespace.XmlNodeType.Attribute) {
                    sb.push("&#xA;");
                }
                else if (ch === "\u000D") {
                    sb.push("&#xD;");
                }
                else {
                    sb.push(ch);
                }
            }
        }
        return sb.join("");
    }
    IsTextNode(type) {
        switch (type) {
            case XmlCore__namespace.XmlNodeType.Text:
            case XmlCore__namespace.XmlNodeType.CDATA:
            case XmlCore__namespace.XmlNodeType.SignificantWhitespace:
            case XmlCore__namespace.XmlNodeType.Whitespace:
                return true;
        }
        return false;
    }
    IsNamespaceInclusive(node, prefix) {
        const prefix2 = prefix || null;
        if (node.prefix === prefix2) {
            return false;
        }
        return this.inclusiveNamespacesPrefixList.indexOf(prefix2 || "") !== -1;
    }
    IsNamespaceRendered(prefix, uri) {
        prefix = prefix || "";
        uri = uri || "";
        if (!prefix && !uri) {
            return true;
        }
        if (prefix === "xml" && uri === "http://www.w3.org/XML/1998/namespace") {
            return true;
        }
        const ns = this.visibleNamespaces.GetPrefix(prefix);
        if (ns) {
            return ns.namespace === uri;
        }
        return false;
    }
}
function XmlDsigC14NTransformNamespacesComparer(x, y) {
    if (x == y) {
        return 0;
    }
    else if (!x) {
        return -1;
    }
    else if (!y) {
        return 1;
    }
    else if (!x.prefix) {
        return -1;
    }
    else if (!y.prefix) {
        return 1;
    }
    else if (x.prefix < y.prefix) {
        return -1;
    }
    else if (x.prefix > y.prefix) {
        return 1;
    }
    else {
        return 0;
    }
}
function XmlDsigC14NTransformAttributesComparer(x, y) {
    if (!x.namespaceURI && y.namespaceURI) {
        return -1;
    }
    if (!y.namespaceURI && x.namespaceURI) {
        return 1;
    }
    const left = x.namespaceURI + x.localName;
    const right = y.namespaceURI + y.localName;
    if (left === right) {
        return 0;
    }
    else if (left < right) {
        return -1;
    }
    else {
        return 1;
    }
}
function IsNamespaceUsed(node, prefix, result = 0) {
    const prefix2 = prefix || null;
    if (node.prefix === prefix2) {
        return ++result;
    }
    if (node.attributes) {
        for (let i = 0; i < node.attributes.length; i++) {
            const attr = node.attributes[i];
            if (!IsNamespaceNode(attr) && prefix && node.attributes[i].prefix === prefix) {
                return ++result;
            }
        }
    }
    for (let n = node.firstChild; !!n; n = n.nextSibling) {
        if (n.nodeType === XmlCore__namespace.XmlNodeType.Element) {
            const el = n;
            const res = IsNamespaceUsed(el, prefix, result);
            if (n.nodeType === XmlCore__namespace.XmlNodeType.Element && res) {
                return ++result + res;
            }
        }
    }
    return result;
}
function IsNamespaceNode(node) {
    const reg = /xmlns:/;
    if (node !== null && node.nodeType === XmlCore__namespace.XmlNodeType.Attribute && (node.nodeName === "xmlns" || reg.test(node.nodeName))) {
        return true;
    }
    return false;
}

const XmlSignature = {
    DefaultCanonMethod: "http://www.w3.org/TR/2001/REC-xml-c14n-20010315",
    DefaultDigestMethod: "http://www.w3.org/2001/04/xmlenc#sha256",
    DefaultPrefix: "ds",
    ElementNames: {
        CanonicalizationMethod: "CanonicalizationMethod",
        DigestMethod: "DigestMethod",
        DigestValue: "DigestValue",
        DSAKeyValue: "DSAKeyValue",
        DomainParameters: "DomainParameters",
        EncryptedKey: "EncryptedKey",
        HMACOutputLength: "HMACOutputLength",
        RSAPSSParams: "RSAPSSParams",
        MaskGenerationFunction: "MaskGenerationFunction",
        SaltLength: "SaltLength",
        KeyInfo: "KeyInfo",
        KeyName: "KeyName",
        KeyValue: "KeyValue",
        Modulus: "Modulus",
        Exponent: "Exponent",
        Manifest: "Manifest",
        Object: "Object",
        Reference: "Reference",
        RetrievalMethod: "RetrievalMethod",
        RSAKeyValue: "RSAKeyValue",
        ECDSAKeyValue: "ECDSAKeyValue",
        NamedCurve: "NamedCurve",
        PublicKey: "PublicKey",
        Signature: "Signature",
        SignatureMethod: "SignatureMethod",
        SignatureValue: "SignatureValue",
        SignedInfo: "SignedInfo",
        Transform: "Transform",
        Transforms: "Transforms",
        X509Data: "X509Data",
        PGPData: "PGPData",
        SPKIData: "SPKIData",
        SPKIexp: "SPKIexp",
        MgmtData: "MgmtData",
        X509IssuerSerial: "X509IssuerSerial",
        X509IssuerName: "X509IssuerName",
        X509SerialNumber: "X509SerialNumber",
        X509SKI: "X509SKI",
        X509SubjectName: "X509SubjectName",
        X509Certificate: "X509Certificate",
        X509CRL: "X509CRL",
        XPath: "XPath",
        X: "X",
        Y: "Y",
    },
    AttributeNames: {
        Algorithm: "Algorithm",
        Encoding: "Encoding",
        Id: "Id",
        MimeType: "MimeType",
        Type: "Type",
        URI: "URI",
    },
    AlgorithmNamespaces: {
        XmlDsigBase64Transform: "http://www.w3.org/2000/09/xmldsig#base64",
        XmlDsigC14NTransform: "http://www.w3.org/TR/2001/REC-xml-c14n-20010315",
        XmlDsigC14NWithCommentsTransform: "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments",
        XmlDsigEnvelopedSignatureTransform: "http://www.w3.org/2000/09/xmldsig#enveloped-signature",
        XmlDsigXPathTransform: "http://www.w3.org/TR/1999/REC-xpath-19991116",
        XmlDsigXsltTransform: "http://www.w3.org/TR/1999/REC-xslt-19991116",
        XmlDsigExcC14NTransform: "http://www.w3.org/2001/10/xml-exc-c14n#",
        XmlDsigExcC14NWithCommentsTransform: "http://www.w3.org/2001/10/xml-exc-c14n#WithComments",
        XmlDecryptionTransform: "http://www.w3.org/2002/07/decrypt#XML",
        XmlLicenseTransform: "urn:mpeg:mpeg21:2003:01-REL-R-NS:licenseTransform",
    },
    Uri: {
        Manifest: "http://www.w3.org/2000/09/xmldsig#Manifest",
    },
    NamespaceURI: "http://www.w3.org/2000/09/xmldsig#",
    NamespaceURIMore: "http://www.w3.org/2007/05/xmldsig-more#",
    NamespaceURIPss: "http://www.example.org/xmldsig-pss/#",
};

exports.XmlSignatureObject = class XmlSignatureObject extends XmlCore.XmlObject {
};
exports.XmlSignatureObject = tslib.__decorate([
    XmlCore.XmlElement({
        localName: "xmldsig",
        namespaceURI: XmlSignature.NamespaceURI,
        prefix: XmlSignature.DefaultPrefix,
    })
], exports.XmlSignatureObject);
exports.XmlSignatureCollection = class XmlSignatureCollection extends XmlCore.XmlCollection {
};
exports.XmlSignatureCollection = tslib.__decorate([
    XmlCore.XmlElement({
        localName: "xmldsig_collection",
        namespaceURI: XmlSignature.NamespaceURI,
        prefix: XmlSignature.DefaultPrefix,
    })
], exports.XmlSignatureCollection);

class KeyInfoClause extends exports.XmlSignatureObject {
}

exports.CanonicalizationMethod = class CanonicalizationMethod extends exports.XmlSignatureObject {
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Algorithm,
        required: true,
        defaultValue: XmlSignature.DefaultCanonMethod,
    })
], exports.CanonicalizationMethod.prototype, "Algorithm", void 0);
exports.CanonicalizationMethod = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.CanonicalizationMethod,
    })
], exports.CanonicalizationMethod);

exports.DataObject = class DataObject extends exports.XmlSignatureObject {
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Id,
        defaultValue: "",
    })
], exports.DataObject.prototype, "Id", void 0);
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.MimeType,
        defaultValue: "",
    })
], exports.DataObject.prototype, "MimeType", void 0);
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Encoding,
        defaultValue: "",
    })
], exports.DataObject.prototype, "Encoding", void 0);
exports.DataObject = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.Object,
    })
], exports.DataObject);
exports.DataObjects = class DataObjects extends exports.XmlSignatureCollection {
};
exports.DataObjects = tslib.__decorate([
    XmlCore.XmlElement({
        localName: "xmldsig_objects",
        parser: exports.DataObject,
    })
], exports.DataObjects);

exports.DigestMethod = class DigestMethod extends exports.XmlSignatureObject {
    constructor(hashNamespace) {
        super();
        if (hashNamespace) {
            this.Algorithm = hashNamespace;
        }
    }
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Algorithm,
        required: true,
        defaultValue: XmlSignature.DefaultDigestMethod,
    })
], exports.DigestMethod.prototype, "Algorithm", void 0);
exports.DigestMethod = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.DigestMethod,
    })
], exports.DigestMethod);

exports.KeyInfo = class KeyInfo extends exports.XmlSignatureCollection {
    OnLoadXml(element) {
        for (let i = 0; i < element.childNodes.length; i++) {
            const node = element.childNodes.item(i);
            if (node.nodeType !== XmlCore.XmlNodeType.Element) {
                continue;
            }
            let KeyInfoClass = null;
            switch (node.localName) {
                case XmlSignature.ElementNames.KeyValue:
                    KeyInfoClass = exports.KeyValue;
                    break;
                case XmlSignature.ElementNames.X509Data:
                    KeyInfoClass = exports.KeyInfoX509Data;
                    break;
                case XmlSignature.ElementNames.SPKIData:
                    KeyInfoClass = exports.SPKIData;
                    break;
                case XmlSignature.ElementNames.KeyName:
                case XmlSignature.ElementNames.RetrievalMethod:
                case XmlSignature.ElementNames.PGPData:
                case XmlSignature.ElementNames.MgmtData:
            }
            if (KeyInfoClass) {
                const item = new KeyInfoClass();
                item.LoadXml(node);
                this.Add(item);
            }
        }
    }
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Id,
        defaultValue: "",
    })
], exports.KeyInfo.prototype, "Id", void 0);
exports.KeyInfo = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.KeyInfo,
    })
], exports.KeyInfo);

exports.Transform = class Transform extends exports.XmlSignatureObject {
    constructor() {
        super(...arguments);
        this.innerXml = null;
    }
    GetOutput() {
        throw new XmlCore.XmlError(XmlCore.XE.METHOD_NOT_IMPLEMENTED);
    }
    LoadInnerXml(node) {
        if (!node) {
            throw new XmlCore.XmlError(XmlCore.XE.PARAM_REQUIRED, "node");
        }
        this.innerXml = node;
    }
    GetInnerXml() {
        return this.innerXml;
    }
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Algorithm,
        defaultValue: "",
    })
], exports.Transform.prototype, "Algorithm", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        localName: XmlSignature.ElementNames.XPath,
        defaultValue: "",
    })
], exports.Transform.prototype, "XPath", void 0);
exports.Transform = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.Transform,
    })
], exports.Transform);

class XmlDsigBase64Transform extends exports.Transform {
    constructor() {
        super(...arguments);
        this.Algorithm = XmlSignature.AlgorithmNamespaces.XmlDsigBase64Transform;
    }
    GetOutput() {
        if (!this.innerXml) {
            throw new XmlCore.XmlError(XmlCore.XE.PARAM_REQUIRED, "innerXml");
        }
        return XmlCore.Convert.FromString(this.innerXml.textContent || "", "base64");
    }
}

class XmlDsigC14NTransform extends exports.Transform {
    constructor() {
        super(...arguments);
        this.Algorithm = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
        this.xmlCanonicalizer = new XmlCanonicalizer(false, false);
    }
    GetOutput() {
        if (!this.innerXml) {
            throw new XmlCore.XmlError(XmlCore.XE.PARAM_REQUIRED, "innerXml");
        }
        return this.xmlCanonicalizer.Canonicalize(this.innerXml);
    }
}
class XmlDsigC14NWithCommentsTransform extends XmlDsigC14NTransform {
    constructor() {
        super(...arguments);
        this.Algorithm = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments";
        this.xmlCanonicalizer = new XmlCanonicalizer(true, false);
    }
}

class XmlDsigEnvelopedSignatureTransform extends exports.Transform {
    constructor() {
        super(...arguments);
        this.Algorithm = "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
    }
    GetOutput() {
        var _a;
        if (!this.innerXml) {
            throw new XmlCore.XmlError(XmlCore.XE.PARAM_REQUIRED, "innerXml");
        }
        let child = this.innerXml.firstChild;
        const signatures = [];
        while (child) {
            if (XmlCore.isElement(child)
                && child.localName === XmlSignature.ElementNames.Signature
                && child.namespaceURI === XmlSignature.NamespaceURI) {
                signatures.push(child);
            }
            child = child.nextSibling;
        }
        for (const signature of signatures) {
            (_a = signature.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(signature);
        }
        return this.innerXml;
    }
}

class XmlDsigExcC14NTransform extends exports.Transform {
    constructor() {
        super(...arguments);
        this.Algorithm = "http://www.w3.org/2001/10/xml-exc-c14n#";
        this.xmlCanonicalizer = new XmlCanonicalizer(false, true);
    }
    get InclusiveNamespacesPrefixList() {
        return this.xmlCanonicalizer.InclusiveNamespacesPrefixList;
    }
    set InclusiveNamespacesPrefixList(value) {
        this.xmlCanonicalizer.InclusiveNamespacesPrefixList = value;
    }
    LoadXml(param) {
        super.LoadXml(param);
        if (this.Element && this.Element.childNodes) {
            for (let i = 0; i < this.Element.childNodes.length; i++) {
                const element = this.Element.childNodes[i];
                if (element && element.nodeType === 1) {
                    switch (element.localName) {
                        case 'InclusiveNamespaces':
                            this.setInclusiveNamespacesElement(element);
                            break;
                    }
                }
            }
        }
    }
    GetOutput() {
        if (!this.innerXml) {
            throw new XmlCore.XmlError(XmlCore.XE.PARAM_REQUIRED, "innerXml");
        }
        return this.xmlCanonicalizer.Canonicalize(this.innerXml);
    }
    setInclusiveNamespacesElement(element) {
        const prefixList = element.getAttribute('PrefixList');
        if (prefixList && prefixList.length > 0) {
            this.xmlCanonicalizer.InclusiveNamespacesPrefixList = prefixList;
        }
    }
}
class XmlDsigExcC14NWithCommentsTransform extends XmlDsigExcC14NTransform {
    constructor() {
        super(...arguments);
        this.Algorithm = "http://www.w3.org/2001/10/xml-exc-c14n#WithComments";
        this.xmlCanonicalizer = new XmlCanonicalizer(true, true);
    }
}

function lookupParentNode(node) {
    return node.parentNode
        ? lookupParentNode(node.parentNode)
        : node;
}
class XmlDsigXPathTransform extends exports.Transform {
    constructor() {
        super(...arguments);
        this.Algorithm = XmlSignature.AlgorithmNamespaces.XmlDsigXPathTransform;
    }
    GetOutput() {
        if (!this.innerXml) {
            throw new XmlCore__namespace.XmlError(XmlCore__namespace.XE.PARAM_REQUIRED, "innerXml");
        }
        this.Filter(lookupParentNode(this.innerXml), this.XPath);
    }
    Filter(node, xpath) {
        const childNodes = node.childNodes;
        const nodes = [];
        for (let i = 0; childNodes && i < childNodes.length; i++) {
            const child = childNodes.item(i);
            nodes.push(child);
        }
        nodes.forEach((child) => {
            if (this.Evaluate(child, xpath)) {
                if (child.parentNode) {
                    child.parentNode.removeChild(child);
                }
            }
            else {
                this.Filter(child, xpath);
            }
        });
    }
    GetEvaluator(node) {
        if (typeof (self) !== "undefined") {
            return (node.ownerDocument == null ? node : node.ownerDocument);
        }
        else {
            return require("xpath");
        }
    }
    Evaluate(node, xpath) {
        try {
            const evaluator = this.GetEvaluator(node);
            const xpathEl = this.GetXml().firstChild;
            const xPath = `boolean(${xpath})`;
            const xpathResult = evaluator.evaluate(xPath, node, {
                lookupNamespaceURI: (prefix) => {
                    return xpathEl.lookupNamespaceURI(prefix);
                },
            }, (typeof (self) === "undefined" ? require("xpath") : self).XPathResult.ANY_TYPE, null);
            return !xpathResult.booleanValue;
        }
        catch (e) {
            return false;
        }
    }
}
tslib.__decorate([
    XmlCore__namespace.XmlChildElement({
        localName: XmlSignature.ElementNames.XPath,
        namespaceURI: XmlSignature.NamespaceURI,
        prefix: XmlSignature.DefaultPrefix,
        required: true,
    })
], XmlDsigXPathTransform.prototype, "XPath", void 0);

exports.Transforms = class Transforms extends exports.XmlSignatureCollection {
    OnLoadXml(element) {
        super.OnLoadXml(element);
        this.items = this.GetIterator().map((item) => {
            switch (item.Algorithm) {
                case XmlSignature.AlgorithmNamespaces.XmlDsigEnvelopedSignatureTransform:
                    return ChangeTransform(item, XmlDsigEnvelopedSignatureTransform);
                case XmlSignature.AlgorithmNamespaces.XmlDsigC14NTransform:
                    return ChangeTransform(item, XmlDsigC14NTransform);
                case XmlSignature.AlgorithmNamespaces.XmlDsigC14NWithCommentsTransform:
                    return ChangeTransform(item, XmlDsigC14NWithCommentsTransform);
                case XmlSignature.AlgorithmNamespaces.XmlDsigExcC14NTransform:
                    return ChangeTransform(item, XmlDsigExcC14NTransform);
                case XmlSignature.AlgorithmNamespaces.XmlDsigExcC14NWithCommentsTransform:
                    return ChangeTransform(item, XmlDsigExcC14NWithCommentsTransform);
                case XmlSignature.AlgorithmNamespaces.XmlDsigBase64Transform:
                    return ChangeTransform(item, XmlDsigBase64Transform);
                case XmlSignature.AlgorithmNamespaces.XmlDsigXPathTransform:
                    return ChangeTransform(item, XmlDsigXPathTransform);
                default:
                    throw new XmlCore.XmlError(XmlCore.XE.CRYPTOGRAPHIC_UNKNOWN_TRANSFORM, item.Algorithm);
            }
        });
    }
};
exports.Transforms = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.Transforms,
        parser: exports.Transform,
    })
], exports.Transforms);
function ChangeTransform(t1, t2) {
    const t = new t2();
    t.LoadXml(t1.Element);
    return t;
}

exports.Reference = class Reference extends exports.XmlSignatureObject {
    constructor(uri) {
        super();
        this.DigestMethod = new exports.DigestMethod();
        if (uri) {
            this.Uri = uri;
        }
    }
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        defaultValue: "",
    })
], exports.Reference.prototype, "Id", void 0);
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.URI,
    })
], exports.Reference.prototype, "Uri", void 0);
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Type,
        defaultValue: "",
    })
], exports.Reference.prototype, "Type", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.Transforms,
    })
], exports.Reference.prototype, "Transforms", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        required: true,
        parser: exports.DigestMethod,
    })
], exports.Reference.prototype, "DigestMethod", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        required: true,
        localName: XmlSignature.ElementNames.DigestValue,
        namespaceURI: XmlSignature.NamespaceURI,
        prefix: XmlSignature.DefaultPrefix,
        converter: XmlCore.XmlBase64Converter,
    })
], exports.Reference.prototype, "DigestValue", void 0);
exports.Reference = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.Reference,
    })
], exports.Reference);
exports.References = class References extends exports.XmlSignatureCollection {
};
exports.References = tslib.__decorate([
    XmlCore.XmlElement({
        localName: "References",
        parser: exports.Reference,
    })
], exports.References);

exports.SignatureMethodOther = class SignatureMethodOther extends exports.XmlSignatureCollection {
    OnLoadXml(element) {
        for (let i = 0; i < element.childNodes.length; i++) {
            const node = element.childNodes.item(i);
            if (node.nodeType !== XmlCore__namespace.XmlNodeType.Element ||
                node.nodeName === XmlSignature.ElementNames.HMACOutputLength) {
                continue;
            }
            let ParserClass;
            switch (node.localName) {
                case XmlSignature.ElementNames.RSAPSSParams:
                    ParserClass = exports.PssAlgorithmParams;
                    break;
            }
            if (ParserClass) {
                const xml = new ParserClass();
                xml.LoadXml(node);
                this.Add(xml);
            }
        }
    }
};
exports.SignatureMethodOther = tslib.__decorate([
    XmlCore.XmlElement({
        localName: "Other",
    })
], exports.SignatureMethodOther);
exports.SignatureMethod = class SignatureMethod extends exports.XmlSignatureObject {
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Algorithm,
        required: true,
        defaultValue: "",
    })
], exports.SignatureMethod.prototype, "Algorithm", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        localName: XmlSignature.ElementNames.HMACOutputLength,
        namespaceURI: XmlSignature.NamespaceURI,
        prefix: XmlSignature.DefaultPrefix,
        converter: XmlCore.XmlNumberConverter,
    })
], exports.SignatureMethod.prototype, "HMACOutputLength", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.SignatureMethodOther,
        noRoot: true,
        minOccurs: 0,
    })
], exports.SignatureMethod.prototype, "Any", void 0);
exports.SignatureMethod = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.SignatureMethod,
    })
], exports.SignatureMethod);

exports.SignedInfo = class SignedInfo extends exports.XmlSignatureObject {
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Id,
        defaultValue: "",
    })
], exports.SignedInfo.prototype, "Id", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.CanonicalizationMethod,
        required: true,
    })
], exports.SignedInfo.prototype, "CanonicalizationMethod", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.SignatureMethod,
        required: true,
    })
], exports.SignedInfo.prototype, "SignatureMethod", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.References,
        minOccurs: 1,
        noRoot: true,
    })
], exports.SignedInfo.prototype, "References", void 0);
exports.SignedInfo = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.SignedInfo,
    })
], exports.SignedInfo);

exports.Signature = class Signature extends exports.XmlSignatureObject {
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.Id,
        defaultValue: "",
    })
], exports.Signature.prototype, "Id", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.SignedInfo,
        required: true,
    })
], exports.Signature.prototype, "SignedInfo", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        localName: XmlSignature.ElementNames.SignatureValue,
        namespaceURI: XmlSignature.NamespaceURI,
        prefix: XmlSignature.DefaultPrefix,
        required: true,
        converter: XmlCore.XmlBase64Converter,
        defaultValue: null,
    })
], exports.Signature.prototype, "SignatureValue", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.KeyInfo,
    })
], exports.Signature.prototype, "KeyInfo", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.DataObjects,
        noRoot: true,
    })
], exports.Signature.prototype, "ObjectList", void 0);
exports.Signature = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.Signature,
    })
], exports.Signature);

const NAMESPACE_URI$1 = "http://www.w3.org/2001/04/xmldsig-more#";
const PREFIX$1 = "ecdsa";
exports.EcdsaPublicKey = class EcdsaPublicKey extends XmlCore.XmlObject {
};
tslib.__decorate([
    XmlCore.XmlChildElement({
        localName: XmlSignature.ElementNames.X,
        namespaceURI: NAMESPACE_URI$1,
        prefix: PREFIX$1,
        required: true,
        converter: XmlCore.XmlBase64Converter,
    })
], exports.EcdsaPublicKey.prototype, "X", void 0);
tslib.__decorate([
    XmlCore.XmlChildElement({
        localName: XmlSignature.ElementNames.Y,
        namespaceURI: NAMESPACE_URI$1,
        prefix: PREFIX$1,
        required: true,
        converter: XmlCore.XmlBase64Converter,
    })
], exports.EcdsaPublicKey.prototype, "Y", void 0);
exports.EcdsaPublicKey = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.PublicKey,
        namespaceURI: NAMESPACE_URI$1,
        prefix: PREFIX$1,
    })
], exports.EcdsaPublicKey);
exports.NamedCurve = class NamedCurve extends XmlCore.XmlObject {
};
tslib.__decorate([
    XmlCore.XmlAttribute({
        localName: XmlSignature.AttributeNames.URI,
        required: true,
    })
], exports.NamedCurve.prototype, "Uri", void 0);
exports.NamedCurve = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.NamedCurve,
        namespaceURI: NAMESPACE_URI$1,
        prefix: PREFIX$1,
    })
], exports.NamedCurve);
exports.DomainParameters = class DomainParameters extends XmlCore.XmlObject {
};
tslib.__decorate([
    XmlCore.XmlChildElement({
        parser: exports.NamedCurve,
    })
], exports.DomainParameters.prototype, "NamedCurve", void 0);
exports.DomainParameters = tslib.__decorate([
    XmlCore.XmlElement({
        localName: XmlSignature.ElementNames.DomainParameters,
        namespaceURI: NAMESPACE_URI$1,
        prefix: PREFIX$1,
    })
], exports.DomainParameters);
exports.EcdsaKeyValue = class EcdsaKeyValue extends KeyInfoClause {
    constructor() {
        super(...arguments);
        this.name = XmlSignature.ElementNames.ECDSAKeyValue;
        this.key = null;
        this.jwk = null;
        this.keyUsage = null;
    }
    get NamedCurve() {
        return GetNamedCurveOid(this.DomainParameters.NamedCurve.Uri);
    }
    async importKey(key) {
        if (key.algorithm.name.