xml-crypto-next 7.0.3 → 8.0.0

package/types/c14n-canonicalization.d.ts

@@ -0,0 +1,49 @@
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, NamespacePrefix, RenderedNamespace, XmlVersion } from "./types.ts";
+export declare class C14nCanonicalization implements CanonicalizationOrTransformationAlgorithm {
+    protected includeComments: boolean;
+    protected xmlVersion: XmlVersion;
+    constructor(xmlVersion?: XmlVersion);
+    attrCompare(a: Attr, b: Attr): number;
+    nsCompare(a: {
+        prefix: string;
+        namespaceURI: string;
+    }, b: {
+        prefix: string;
+        namespaceURI: string;
+    }): number;
+    renderAttrs(node: Node): string;
+    /**
+     * Create the string of all namespace declarations that should appear on this element
+     */
+    renderNs(node: Element, prefixesInScope: string[], defaultNs: string, defaultNsForPrefix: Record<string, string>, ancestorNamespaces: NamespacePrefix[]): RenderedNamespace;
+    /**
+     * Process inner nodes with optimized string building
+     */
+    processInner(node: Node, prefixesInScope: string[], defaultNs: string, defaultNsForPrefix: Record<string, string>, ancestorNamespaces: NamespacePrefix[]): string;
+    renderComment(node: Comment): string;
+    /**
+     * Perform canonicalization of the given node
+     */
+    process(node: Node, options: CanonicalizationOrTransformationAlgorithmProcessOptions): string;
+    getAlgorithmName(): string;
+}
+/**
+ * C14n with comments support
+ */
+export declare class C14nCanonicalizationWithComments extends C14nCanonicalization {
+    constructor(xmlVersion?: XmlVersion);
+    getAlgorithmName(): string;
+}
+/**
+ * XML 1.1 specific C14n canonicalization
+ */
+export declare class C14nCanonicalizationXml11 extends C14nCanonicalization {
+    constructor();
+}
+/**
+ * XML 1.1 C14n with comments support
+ */
+export declare class C14nCanonicalizationWithCommentsXml11 extends C14nCanonicalizationWithComments {
+    constructor();
+}
+//# sourceMappingURL=c14n-canonicalization.d.ts.map

package/types/c14n-canonicalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c14n-canonicalization.d.ts","sourceRoot":"","sources":["../src/c14n-canonicalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yCAAyC,EACzC,uDAAuD,EACvD,eAAe,EACf,iBAAiB,EACjB,UAAU,EACX,MAAM,YAAY,CAAC;AAOpB,qBAAa,oBAAqB,YAAW,yCAAyC;IACpF,SAAS,CAAC,eAAe,UAAS;IAClC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAS;gBAE7B,UAAU,CAAC,EAAE,UAAU;IAOnC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM;IAoBrC,SAAS,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAO3G,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAiC/B;;OAEG;IACH,QAAQ,CACN,IAAI,EAAE,OAAO,EACb,eAAe,EAAE,MAAM,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,kBAAkB,EAAE,eAAe,EAAE,GACpC,iBAAiB;IA+EpB;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,MAAM,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,kBAAkB,EAAE,eAAe,EAAE,GACpC,MAAM;IAsDT,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAwCpC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,uDAAuD,GAAG,MAAM;IAoB7F,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,gCAAiC,SAAQ,oBAAoB;gBAC5D,UAAU,CAAC,EAAE,UAAU;IAKnC,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,oBAAoB;;CAIlE;AAED;;GAEG;AACH,qBAAa,qCAAsC,SAAQ,gCAAgC;;CAI1F"}

package/types/enveloped-signature.d.ts

@@ -0,0 +1,8 @@
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, CanonicalizationOrTransformAlgorithmType } from "./types.ts";
+export declare class EnvelopedSignature implements CanonicalizationOrTransformationAlgorithm {
+    protected includeComments: boolean;
+    constructor();
+    process(node: Node, options: CanonicalizationOrTransformationAlgorithmProcessOptions): Node;
+    getAlgorithmName(): CanonicalizationOrTransformAlgorithmType;
+}
+//# sourceMappingURL=enveloped-signature.d.ts.map

package/types/enveloped-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enveloped-signature.d.ts","sourceRoot":"","sources":["../src/enveloped-signature.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,yCAAyC,EACzC,uDAAuD,EACvD,wCAAwC,EACzC,MAAM,YAAY,CAAC;AAEpB,qBAAa,kBAAmB,YAAW,yCAAyC;IAClF,SAAS,CAAC,eAAe,UAAS;;IAMlC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,uDAAuD,GAAG,IAAI;IAyC3F,gBAAgB,IAAI,wCAAwC;CAG7D"}

package/types/exclusive-canonicalization.d.ts

@@ -0,0 +1,58 @@
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, XmlVersion } from "./types.ts";
+export declare class ExclusiveCanonicalization implements CanonicalizationOrTransformationAlgorithm {
+    protected includeComments: boolean;
+    protected xmlVersion: XmlVersion;
+    constructor(xmlVersion?: XmlVersion);
+    attrCompare(a: Attr, b: Attr): number;
+    nsCompare(a: {
+        prefix: string;
+        namespaceURI: string;
+    }, b: {
+        prefix: string;
+        namespaceURI: string;
+    }): number;
+    renderAttrs(node: Node): string;
+    /**
+     * Create the string of all namespace declarations
+     */
+    renderNs(node: Element, prefixesInScope: Array<{
+        prefix: string;
+        namespaceURI: string;
+    }>, defaultNs: string, defaultNsForPrefix: Record<string, string>, inclusiveNamespacesPrefixList: string[]): {
+        rendered: string;
+        newDefaultNs: string;
+    };
+    /**
+     * Process inner nodes with optimized string building
+     */
+    processInner(node: Node, prefixesInScope: Array<{
+        prefix: string;
+        namespaceURI: string;
+    }>, defaultNs: string, defaultNsForPrefix: Record<string, string>, inclusiveNamespacesPrefixList: string[]): string;
+    renderComment(node: Comment): string;
+    /**
+     * Perform canonicalization of the given element node
+     */
+    process(elem: Element, options: CanonicalizationOrTransformationAlgorithmProcessOptions): string;
+    getAlgorithmName(): string;
+}
+/**
+ * Exclusive C14n with comments support
+ */
+export declare class ExclusiveCanonicalizationWithComments extends ExclusiveCanonicalization {
+    constructor(xmlVersion?: XmlVersion);
+    getAlgorithmName(): string;
+}
+/**
+ * XML 1.1 specific Exclusive C14n
+ */
+export declare class ExclusiveCanonicalizationXml11 extends ExclusiveCanonicalization {
+    constructor();
+}
+/**
+ * XML 1.1 Exclusive C14n with comments support
+ */
+export declare class ExclusiveCanonicalizationWithCommentsXml11 extends ExclusiveCanonicalizationWithComments {
+    constructor();
+}
+//# sourceMappingURL=exclusive-canonicalization.d.ts.map

package/types/exclusive-canonicalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exclusive-canonicalization.d.ts","sourceRoot":"","sources":["../src/exclusive-canonicalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yCAAyC,EACzC,uDAAuD,EAEvD,UAAU,EACX,MAAM,YAAY,CAAC;AAuBpB,qBAAa,yBAA0B,YAAW,yCAAyC;IACzF,SAAS,CAAC,eAAe,UAAS;IAClC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAS;gBAE7B,UAAU,CAAC,EAAE,UAAU;IAOnC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM;IAoBrC,SAAS,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAO3G,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAiC/B;;OAEG;IACH,QAAQ,CACN,IAAI,EAAE,OAAO,EACb,eAAe,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,EAChE,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,6BAA6B,EAAE,MAAM,EAAE,GACtC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;IA0D7C;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,EAChE,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,6BAA6B,EAAE,MAAM,EAAE,GACtC,MAAM;IAsDT,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAwCpC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,uDAAuD,GAAG,MAAM;IAgDhG,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,qCAAsC,SAAQ,yBAAyB;gBACtE,UAAU,CAAC,EAAE,UAAU;IAKnC,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,yBAAyB;;CAI5E;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,qCAAqC;;CAIpG"}

package/types/hash-algorithms.d.ts

@@ -0,0 +1,26 @@
+import type { HashAlgorithm } from "./types.ts";
+export declare class Sha1 implements HashAlgorithm {
+    getHash: (xml: any) => string;
+    getAlgorithmName: () => string;
+}
+export declare class Sha224 implements HashAlgorithm {
+    getHash: (xml: any) => string;
+    getAlgorithmName: () => string;
+}
+export declare class Sha256 implements HashAlgorithm {
+    getHash: (xml: any) => string;
+    getAlgorithmName: () => string;
+}
+export declare class Sha384 implements HashAlgorithm {
+    getHash: (xml: any) => string;
+    getAlgorithmName: () => string;
+}
+export declare class Sha512 implements HashAlgorithm {
+    getHash: (xml: any) => string;
+    getAlgorithmName: () => string;
+}
+export declare class Shake256 implements HashAlgorithm {
+    getHash: (xml: any) => string;
+    getAlgorithmName: () => string;
+}
+//# sourceMappingURL=hash-algorithms.d.ts.map

package/types/hash-algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-algorithms.d.ts","sourceRoot":"","sources":["../src/hash-algorithms.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,IAAK,YAAW,aAAa;IACxC,OAAO,GAAa,QAAG,YAKrB;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,MAAO,YAAW,aAAa;IAC1C,OAAO,GAAa,QAAG,YAKrB;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,MAAO,YAAW,aAAa;IAC1C,OAAO,GAAa,QAAG,YAKrB;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,MAAO,YAAW,aAAa;IAC1C,OAAO,GAAa,QAAG,YAKrB;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,MAAO,YAAW,aAAa;IAC1C,OAAO,GAAa,QAAG,YAKrB;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,QAAS,YAAW,aAAa;IAG5C,OAAO,GAAa,QAAG,YAOrB;IAEF,gBAAgB,eAEd;CACH"}

package/types/index.d.ts

@@ -0,0 +1,10 @@
+export { C14nCanonicalization, C14nCanonicalizationWithComments, C14nCanonicalizationXml11, C14nCanonicalizationWithCommentsXml11, } from "./c14n-canonicalization";
+export { C14nCanonicalization2, C14nCanonicalization2WithComments, } from "./c14n-canonicalization-2";
+export { ExclusiveCanonicalization, ExclusiveCanonicalizationWithComments, ExclusiveCanonicalizationXml11, ExclusiveCanonicalizationWithCommentsXml11, } from "./exclusive-canonicalization";
+export { XmlDsig2Transform } from "./xmldsig2-transform";
+export { SignedXml } from "./signed-xml";
+export * from "./types";
+export * from "./utils";
+export { Sha1, Sha224, Sha256, Sha384, Sha512, Shake256 } from "./hash-algorithms";
+export { RsaSha1, RsaSha224, RsaSha256, RsaSha384, RsaSha512, RsaSha256Mgf1, RsaSha384Mgf1, RsaSha512Mgf1, EcdsaSha1, EcdsaSha224, EcdsaSha256, EcdsaSha384, EcdsaSha512, DsaSha1, DsaSha256, Ed25519, Ed448, HmacSha1, HmacSha224, HmacSha256, HmacSha384, HmacSha512, } from "./signature-algorithms";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,gCAAgC,EAChC,yBAAyB,EACzB,qCAAqC,GACtC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,qBAAqB,EACrB,iCAAiC,GAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yBAAyB,EACzB,qCAAqC,EACrC,8BAA8B,EAC9B,0CAA0C,GAC3C,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEnF,OAAO,EAEL,OAAO,EACP,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EAET,aAAa,EACb,aAAa,EACb,aAAa,EAEb,SAAS,EACT,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EAEX,OAAO,EACP,SAAS,EAET,OAAO,EACP,KAAK,EAEL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,wBAAwB,CAAC"}

package/types/signature-algorithms.d.ts

@@ -0,0 +1,112 @@
+import { type SignatureAlgorithm } from "./types";
+export declare class RsaSha1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha224 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha256 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha384 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha512 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha256Mgf1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha384Mgf1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class RsaSha512Mgf1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class EcdsaSha1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class EcdsaSha224 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class EcdsaSha256 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class EcdsaSha384 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class EcdsaSha512 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class DsaSha1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class DsaSha256 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class Ed25519 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class Ed448 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class HmacSha1 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class HmacSha224 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class HmacSha256 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class HmacSha384 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+export declare class HmacSha512 implements SignatureAlgorithm {
+    getSignature: any;
+    verifySignature: any;
+    getAlgorithmName: () => string;
+}
+//# sourceMappingURL=signature-algorithms.d.ts.map

package/types/signature-algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-algorithms.d.ts","sourceRoot":"","sources":["../src/signature-algorithms.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAkC,MAAM,SAAS,CAAC;AAMlF,qBAAa,OAAQ,YAAW,kBAAkB;IAChD,YAAY,MAQV;IAEF,eAAe,MAQb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,SAAU,YAAW,kBAAkB;IAClD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,SAAU,YAAW,kBAAkB;IAClD,YAAY,MAQV;IAEF,eAAe,MAQb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,SAAU,YAAW,kBAAkB;IAClD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,SAAU,YAAW,kBAAkB;IAClD,YAAY,MAQV;IAEF,eAAe,MAQb;IAEF,gBAAgB,eAEd;CACH;AAMD,qBAAa,aAAc,YAAW,kBAAkB;IACtD,YAAY,MAkBV;IAEF,eAAe,MAmBb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,aAAc,YAAW,kBAAkB;IACtD,YAAY,MAkBV;IAEF,eAAe,MAmBb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,aAAc,YAAW,kBAAkB;IACtD,YAAY,MAkBV;IAEF,eAAe,MAmBb;IAEF,gBAAgB,eAEd;CACH;AAMD,qBAAa,SAAU,YAAW,kBAAkB;IAClD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,WAAY,YAAW,kBAAkB;IACpD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,WAAY,YAAW,kBAAkB;IACpD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,WAAY,YAAW,kBAAkB;IACpD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,WAAY,YAAW,kBAAkB;IACpD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAMD,qBAAa,OAAQ,YAAW,kBAAkB;IAChD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,SAAU,YAAW,kBAAkB;IAClD,YAAY,MAOV;IAEF,eAAe,MAOb;IAEF,gBAAgB,eAEd;CACH;AAMD,qBAAa,OAAQ,YAAW,kBAAkB;IAChD,YAAY,MAaV;IAEF,eAAe,MAab;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,KAAM,YAAW,kBAAkB;IAC9C,YAAY,MAaV;IAEF,eAAe,MAab;IAEF,gBAAgB,eAEd;CACH;AAMD,qBAAa,QAAS,YAAW,kBAAkB;IACjD,YAAY,MAQV;IAEF,eAAe,MAkBb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,UAAW,YAAW,kBAAkB;IACnD,YAAY,MAOV;IAEF,eAAe,MAeb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,UAAW,YAAW,kBAAkB;IACnD,YAAY,MAOV;IAEF,eAAe,MAeb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,UAAW,YAAW,kBAAkB;IACnD,YAAY,MAOV;IAEF,eAAe,MAeb;IAEF,gBAAgB,eAEd;CACH;AAED,qBAAa,UAAW,YAAW,kBAAkB;IACnD,YAAY,MAOV;IAEF,eAAe,MAeb;IAEF,gBAAgB,eAEd;CACH"}

package/types/signed-xml.d.ts

@@ -0,0 +1,237 @@
+import type { CanonicalizationAlgorithmType, CanonicalizationOrTransformAlgorithmType, CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, ComputeSignatureOptions, ErrorFirstCallback, GetKeyInfoContentArgs, HashAlgorithm, HashAlgorithmType, ObjectAttributes, Reference, SignatureAlgorithm, SignatureAlgorithmType, SignedXmlOptions } from "./types";
+import * as crypto from "crypto";
+export declare class SignedXml {
+    idMode?: "wssecurity";
+    idAttributes: string[];
+    /**
+     * A {@link Buffer} or pem encoded {@link String} containing your private key
+     */
+    privateKey?: crypto.KeyLike;
+    publicCert?: crypto.KeyLike;
+    /**
+     * One of the supported signature algorithms.
+     * @see {@link SignatureAlgorithmType}
+     */
+    signatureAlgorithm?: SignatureAlgorithmType;
+    /**
+     * Rules used to convert an XML document into its canonical form.
+     */
+    canonicalizationAlgorithm?: CanonicalizationAlgorithmType;
+    /**
+     * It specifies a list of namespace prefixes that should be considered "inclusive" during the canonicalization process.
+     */
+    inclusiveNamespacesPrefixList: string[];
+    namespaceResolver: XPathNSResolver;
+    implicitTransforms: ReadonlyArray<CanonicalizationOrTransformAlgorithmType>;
+    keyInfoAttributes: {
+        [attrName: string]: string;
+    };
+    getKeyInfoContent: typeof SignedXml.getKeyInfoContent;
+    getCertFromKeyInfo: typeof SignedXml.getCertFromKeyInfo;
+    objects?: Array<{
+        content: string;
+        attributes?: ObjectAttributes;
+    }>;
+    private id;
+    private signedXml;
+    private signatureXml;
+    private signatureNode;
+    private signatureValue;
+    private originalXmlWithIds;
+    private keyInfo;
+    /**
+     * Contains the references that were signed.
+     * @see {@link Reference}
+     */
+    private references;
+    /**
+     * Contains the canonicalized XML of the references that were validly signed.
+     *
+     * This populates with the canonical XML of the reference only after
+     * verifying the signature is cryptographically authentic.
+     */
+    private signedReferences;
+    /**
+     *  To add a new transformation algorithm create a new class that implements the {@link TransformationAlgorithm} interface, and register it here. More info: {@link https://github.com/node-saml/xml-crypto#customizing-algorithms|Customizing Algorithms}
+     */
+    CanonicalizationAlgorithms: Record<CanonicalizationOrTransformAlgorithmType, new () => CanonicalizationOrTransformationAlgorithm>;
+    /**
+     * To add a new hash algorithm create a new class that implements the {@link HashAlgorithm} interface, and register it here. More info: {@link https://github.com/node-saml/xml-crypto#customizing-algorithms|Customizing Algorithms}
+     */
+    HashAlgorithms: Record<HashAlgorithmType, new () => HashAlgorithm>;
+    /**
+     * To add a new signature algorithm create a new class that implements the {@link SignatureAlgorithm} interface, and register it here. More info: {@link https://github.com/node-saml/xml-crypto#customizing-algorithms|Customizing Algorithms}
+     */
+    SignatureAlgorithms: Record<SignatureAlgorithmType, new () => SignatureAlgorithm>;
+    static defaultNsForPrefix: {
+        ds: string;
+    };
+    static noop: () => any;
+    /**
+     * The SignedXml constructor provides an abstraction for sign and verify xml documents. The object is constructed using
+     * @param options {@link SignedXmlOptions}
+     */
+    constructor(options?: SignedXmlOptions);
+    /**
+     * Due to key-confusion issues, it's risky to have both hmac
+     * and digital signature algorithms enabled at the same time.
+     * This enables HMAC and disables other signing algorithms.
+     */
+    enableHMAC(): void;
+    /**
+     * Builds the contents of a KeyInfo element as an XML string.
+     *
+     * For example, if the value of the prefix argument is 'foo', then
+     * the resultant XML string will be "<foo:X509Data></foo:X509Data>"
+     *
+     * @return an XML string representation of the contents of a KeyInfo element, or `null` if no `KeyInfo` element should be included
+     */
+    static getKeyInfoContent({ publicCert, prefix }: GetKeyInfoContentArgs): string | null;
+    /**
+     * Returns the value of the signing certificate based on the contents of the
+     * specified KeyInfo.
+     *
+     * @param keyInfo KeyInfo element (@see https://www.w3.org/TR/2008/REC-xmldsig-core-20080610/#sec-X509Data)
+     * @return the signing certificate as a string in PEM format
+     */
+    static getCertFromKeyInfo(keyInfo?: Node | null): string | null;
+    /**
+     * Validates the signature of the provided XML document synchronously using the configured key info provider.
+     *
+     * @param xml The XML document containing the signature to be validated.
+     * @returns `true` if the signature is valid
+     * @throws Error if no key info resolver is provided.
+     */
+    checkSignature(xml: string): boolean;
+    /**
+     * Validates the signature of the provided XML document synchronously using the configured key info provider.
+     *
+     * @param xml The XML document containing the signature to be validated.
+     * @param callback Callback function to handle the validation result asynchronously.
+     * @throws Error if the last parameter is provided and is not a function, or if no key info resolver is provided.
+     */
+    checkSignature(xml: string, callback: (error: Error | null, isValid?: boolean) => void): void;
+    private getCanonSignedInfoXml;
+    private getCanonReferenceXml;
+    private calculateSignatureValue;
+    private findSignatureAlgorithm;
+    private findCanonicalizationAlgorithm;
+    private findHashAlgorithm;
+    validateElementAgainstReferences(elemOrXpath: Element | string, doc: Document): Reference;
+    private validateReference;
+    findSignatures(doc: Node): Node[];
+    /**
+     * Loads the signature information from the provided XML node or string.
+     *
+     * @param signatureNode The XML node or string representing the signature.
+     */
+    loadSignature(signatureNode: Node | string): void;
+    /**
+     * Load the reference xml node to a model
+     *
+     */
+    private loadReference;
+    /**
+     * Adds a reference to the signature.
+     *
+     * @param xpath The XPath expression to select the XML nodes to be referenced.
+     * @param transforms An array of transform algorithms to be applied to the selected nodes.
+     * @param digestAlgorithm The digest algorithm to use for computing the digest value.
+     * @param uri The URI identifier for the reference. If empty, an empty URI will be used.
+     * @param digestValue The expected digest value for the reference.
+     * @param inclusiveNamespacesPrefixList The prefix list for inclusive namespace canonicalization.
+     * @param isEmptyUri Indicates whether the URI is empty. Defaults to `false`.
+     * @param id An optional `Id` attribute for the reference.
+     * @param type An optional `Type` attribute for the reference.
+     */
+    addReference({ xpath, transforms, digestAlgorithm, uri, digestValue, inclusiveNamespacesPrefixList, isEmptyUri, id, type, }: Partial<Reference> & Pick<Reference, "xpath">): void;
+    /**
+     * Returns the list of references.
+     */
+    getReferences(): Reference[];
+    getSignedReferences(): string[];
+    /**
+     * Compute the signature of the given XML (using the already defined settings).
+     *
+     * @param xml The XML to compute the signature for.
+     * @param callback A callback function to handle the signature computation asynchronously.
+     * @returns void
+     * @throws TypeError If the xml can not be parsed.
+     */
+    computeSignature(xml: string): void;
+    /**
+     * Compute the signature of the given XML (using the already defined settings).
+     *
+     * @param xml The XML to compute the signature for.
+     * @param callback A callback function to handle the signature computation asynchronously.
+     * @returns void
+     * @throws TypeError If the xml can not be parsed.
+     */
+    computeSignature(xml: string, callback: ErrorFirstCallback<SignedXml>): void;
+    /**
+     * Compute the signature of the given XML (using the already defined settings).
+     *
+     * @param xml The XML to compute the signature for.
+     * @param opts An object containing options for the signature computation.
+     * @returns If no callback is provided, returns `this` (the instance of SignedXml).
+     * @throws TypeError If the xml can not be parsed, or Error if there were invalid options passed.
+     */
+    computeSignature(xml: string, options: ComputeSignatureOptions): void;
+    /**
+     * Compute the signature of the given XML (using the already defined settings).
+     *
+     * @param xml The XML to compute the signature for.
+     * @param opts An object containing options for the signature computation.
+     * @param callback A callback function to handle the signature computation asynchronously.
+     * @returns void
+     * @throws TypeError If the xml can not be parsed, or Error if there were invalid options passed.
+     */
+    computeSignature(xml: string, options: ComputeSignatureOptions, callback: ErrorFirstCallback<SignedXml>): void;
+    /**
+     * Adds all references to the SignedInfo after the signature placeholder is inserted.
+     */
+    private addAllReferences;
+    private getKeyInfo;
+    /**
+     * Creates XML for Object elements to be included in the signature
+     *
+     * @param prefix Optional namespace prefix
+     * @returns XML string with Object elements or empty string if none
+     */
+    private getObjects;
+    getCanonXml(transforms: Reference["transforms"], node: Node, options?: CanonicalizationOrTransformationAlgorithmProcessOptions): string;
+    /**
+     * Ensure an element has Id attribute. If not create it with unique value.
+     * Work with both normal and wssecurity Id flavour
+     */
+    private ensureHasId;
+    /**
+     * Create the SignedInfo element
+     *
+     */
+    private createSignedInfo;
+    /**
+     * Create the Signature element
+     *
+     */
+    private createSignature;
+    /**
+     * Returns just the signature part, must be called only after {@link computeSignature}
+     *
+     * @returns The signature XML.
+     */
+    getSignatureXml(): string;
+    /**
+     * Returns the original xml with Id attributes added on relevant elements (required for validation), must be called only after {@link computeSignature}
+     *
+     * @returns The original XML with IDs.
+     */
+    getOriginalXmlWithIds(): string;
+    /**
+     * Returns the original xml document with the signature in it, must be called only after {@link computeSignature}
+     *
+     * @returns The signed XML.
+     */
+    getSignedXml(): string;
+}
+//# sourceMappingURL=signed-xml.d.ts.map

package/types/signed-xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-xml.d.ts","sourceRoot":"","sources":["../src/signed-xml.ts"],"names":[],"mappings":"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"}

package/types/src/c14n-canonicalization-2.d.ts

@@ -0,0 +1,38 @@
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, NamespacePrefix, RenderedNamespace, XmlVersion } from "./types.js";
+/**
+ * Canonical XML 2.0
+ * @see https://www.w3.org/TR/xml-c14n2/
+ *
+ * Key differences from C14N 1.1:
+ * - Inheritable attributes are handled differently
+ * - XML base attributes are inherited
+ * - XML language attributes are inherited
+ * - Default attributes are handled per XML spec
+ */
+export declare class C14nCanonicalization2 implements CanonicalizationOrTransformationAlgorithm {
+    protected includeComments: boolean;
+    protected xmlVersion: XmlVersion;
+    constructor(xmlVersion?: XmlVersion, includeComments?: boolean);
+    attrCompare(a: Attr, b: Attr): number;
+    nsCompare(a: {
+        prefix: string;
+        namespaceURI: string;
+    }, b: {
+        prefix: string;
+        namespaceURI: string;
+    }): number;
+    renderAttrs(node: Node): string;
+    renderNs(node: Element, prefixesInScope: string[], defaultNs: string, defaultNsForPrefix: Record<string, string>, ancestorNamespaces: NamespacePrefix[]): RenderedNamespace;
+    processInner(node: Node, prefixesInScope: string[], defaultNs: string, defaultNsForPrefix: Record<string, string>, ancestorNamespaces: NamespacePrefix[]): string;
+    renderComment(node: Comment): string;
+    process(node: Node, options: CanonicalizationOrTransformationAlgorithmProcessOptions): string;
+    getAlgorithmName(): string;
+}
+/**
+ * Canonical XML 2.0 with comments
+ */
+export declare class C14nCanonicalization2WithComments extends C14nCanonicalization2 {
+    constructor(xmlVersion?: XmlVersion);
+    getAlgorithmName(): string;
+}
+//# sourceMappingURL=c14n-canonicalization-2.d.ts.map

package/types/src/c14n-canonicalization-2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c14n-canonicalization-2.d.ts","sourceRoot":"","sources":["../../src/c14n-canonicalization-2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yCAAyC,EACzC,uDAAuD,EACvD,eAAe,EACf,iBAAiB,EACjB,UAAU,EACX,MAAM,YAAY,CAAC;AAOpB;;;;;;;;;GASG;AACH,qBAAa,qBAAsB,YAAW,yCAAyC;IACrF,SAAS,CAAC,eAAe,UAAS;IAClC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAS;gBAE7B,UAAU,CAAC,EAAE,UAAU,EAAE,eAAe,CAAC,EAAE,OAAO;IAO9D,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM;IAoBrC,SAAS,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAO3G,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAiC/B,QAAQ,CACN,IAAI,EAAE,OAAO,EACb,eAAe,EAAE,MAAM,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,kBAAkB,EAAE,eAAe,EAAE,GACpC,iBAAiB;IA2EpB,YAAY,CACV,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,MAAM,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,kBAAkB,EAAE,eAAe,EAAE,GACpC,MAAM;IAoDT,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAwCpC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,uDAAuD,GAAG,MAAM;IAoB7F,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,iCAAkC,SAAQ,qBAAqB;gBAC9D,UAAU,CAAC,EAAE,UAAU;IAInC,gBAAgB;CAGjB"}

package/types/src/c14n-canonicalization.d.ts

@@ -0,0 +1,49 @@
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, NamespacePrefix, RenderedNamespace, XmlVersion } from "./types.ts";
+export declare class C14nCanonicalization implements CanonicalizationOrTransformationAlgorithm {
+    protected includeComments: boolean;
+    protected xmlVersion: XmlVersion;
+    constructor(xmlVersion?: XmlVersion);
+    attrCompare(a: Attr, b: Attr): number;
+    nsCompare(a: {
+        prefix: string;
+        namespaceURI: string;
+    }, b: {
+        prefix: string;
+        namespaceURI: string;
+    }): number;
+    renderAttrs(node: Node): string;
+    /**
+     * Create the string of all namespace declarations that should appear on this element
+     */
+    renderNs(node: Element, prefixesInScope: string[], defaultNs: string, defaultNsForPrefix: Record<string, string>, ancestorNamespaces: NamespacePrefix[]): RenderedNamespace;
+    /**
+     * Process inner nodes with optimized string building
+     */
+    processInner(node: Node, prefixesInScope: string[], defaultNs: string, defaultNsForPrefix: Record<string, string>, ancestorNamespaces: NamespacePrefix[]): string;
+    renderComment(node: Comment): string;
+    /**
+     * Perform canonicalization of the given node
+     */
+    process(node: Node, options: CanonicalizationOrTransformationAlgorithmProcessOptions): string;
+    getAlgorithmName(): string;
+}
+/**
+ * C14n with comments support
+ */
+export declare class C14nCanonicalizationWithComments extends C14nCanonicalization {
+    constructor(xmlVersion?: XmlVersion);
+    getAlgorithmName(): string;
+}
+/**
+ * XML 1.1 specific C14n canonicalization
+ */
+export declare class C14nCanonicalizationXml11 extends C14nCanonicalization {
+    constructor();
+}
+/**
+ * XML 1.1 C14n with comments support
+ */
+export declare class C14nCanonicalizationWithCommentsXml11 extends C14nCanonicalizationWithComments {
+    constructor();
+}
+//# sourceMappingURL=c14n-canonicalization.d.ts.map

package/types/src/c14n-canonicalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c14n-canonicalization.d.ts","sourceRoot":"","sources":["../../src/c14n-canonicalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yCAAyC,EACzC,uDAAuD,EACvD,eAAe,EACf,iBAAiB,EACjB,UAAU,EACX,MAAM,YAAY,CAAC;AAOpB,qBAAa,oBAAqB,YAAW,yCAAyC;IACpF,SAAS,CAAC,eAAe,UAAS;IAClC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAS;gBAE7B,UAAU,CAAC,EAAE,UAAU;IAOnC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM;IAoBrC,SAAS,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAO3G,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAiC/B;;OAEG;IACH,QAAQ,CACN,IAAI,EAAE,OAAO,EACb,eAAe,EAAE,MAAM,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,kBAAkB,EAAE,eAAe,EAAE,GACpC,iBAAiB;IA+EpB;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,MAAM,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,kBAAkB,EAAE,eAAe,EAAE,GACpC,MAAM;IAsDT,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAwCpC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,uDAAuD,GAAG,MAAM;IAoB7F,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,gCAAiC,SAAQ,oBAAoB;gBAC5D,UAAU,CAAC,EAAE,UAAU;IAKnC,gBAAgB;CAGjB;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,oBAAoB;;CAIlE;AAED;;GAEG;AACH,qBAAa,qCAAsC,SAAQ,gCAAgC;;CAI1F"}

package/types/src/enveloped-signature.d.ts

@@ -0,0 +1,8 @@
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, CanonicalizationOrTransformAlgorithmType } from "./types.ts";
+export declare class EnvelopedSignature implements CanonicalizationOrTransformationAlgorithm {
+    protected includeComments: boolean;
+    constructor();
+    process(node: Node, options: CanonicalizationOrTransformationAlgorithmProcessOptions): Node;
+    getAlgorithmName(): CanonicalizationOrTransformAlgorithmType;
+}
+//# sourceMappingURL=enveloped-signature.d.ts.map

package/types/src/enveloped-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enveloped-signature.d.ts","sourceRoot":"","sources":["../../src/enveloped-signature.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,yCAAyC,EACzC,uDAAuD,EACvD,wCAAwC,EACzC,MAAM,YAAY,CAAC;AAEpB,qBAAa,kBAAmB,YAAW,yCAAyC;IAClF,SAAS,CAAC,eAAe,UAAS;;IAMlC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,uDAAuD,GAAG,IAAI;IAyC3F,gBAAgB,IAAI,wCAAwC;CAG7D"}