xml-crypto-next 7.0.3 → 8.0.0

package/build/c14n-canonicalization-2.d.ts

@@ -0,0 +1,37 @@
+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;
+}

package/build/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/build/c14n-canonicalization-2.js

@@ -0,0 +1,228 @@
+import * as utils from "./utils.js";
+import * as isDomNode from "@xmldom/is-dom-node";
+// Pre-compiled regex for better performance
+const XMLNS_ATTR_REGEX = /^xmlns/;
+/**
+ * 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 class C14nCanonicalization2 {
+    includeComments = false;
+    xmlVersion = "1.1";
+    constructor(xmlVersion, includeComments) {
+        if (xmlVersion) {
+            this.xmlVersion = xmlVersion;
+        }
+        this.includeComments = includeComments ?? false;
+    }
+    attrCompare(a, b) {
+        if (!a.namespaceURI && b.namespaceURI) {
+            return -1;
+        }
+        if (!b.namespaceURI && a.namespaceURI) {
+            return 1;
+        }
+        const left = a.namespaceURI + a.localName;
+        const right = b.namespaceURI + b.localName;
+        if (left === right) {
+            return 0;
+        }
+        else if (left < right) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
+    nsCompare(a, b) {
+        if (a.prefix === b.prefix) {
+            return 0;
+        }
+        return a.prefix.localeCompare(b.prefix);
+    }
+    renderAttrs(node) {
+        if (isDomNode.isCommentNode(node)) {
+            return this.renderComment(node);
+        }
+        if (!isDomNode.isElementNode(node) || !node.attributes) {
+            return "";
+        }
+        const attrListToRender = [];
+        for (let i = 0; i < node.attributes.length; i++) {
+            const attr = node.attributes[i];
+            // Ignore namespace definition attributes
+            if (!XMLNS_ATTR_REGEX.test(attr.name)) {
+                attrListToRender.push(attr);
+            }
+        }
+        attrListToRender.sort(this.attrCompare.bind(this));
+        const encodeFn = this.xmlVersion === "1.1"
+            ? utils.encodeSpecialCharactersInAttributeXml11
+            : utils.encodeSpecialCharactersInAttribute;
+        const res = new Array(attrListToRender.length);
+        for (let i = 0; i < attrListToRender.length; i++) {
+            const attr = attrListToRender[i];
+            res[i] = ` ${attr.name}="${encodeFn(attr.value)}"`;
+        }
+        return res.join("");
+    }
+    renderNs(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces) {
+        const res = [];
+        let newDefaultNs = defaultNs;
+        const nsListToRender = [];
+        const currNs = node.namespaceURI || "";
+        // Handle the namespace of the node itself
+        if (node.prefix) {
+            if (prefixesInScope.indexOf(node.prefix) === -1) {
+                nsListToRender.push({
+                    prefix: node.prefix,
+                    namespaceURI: node.namespaceURI || defaultNsForPrefix[node.prefix],
+                });
+                prefixesInScope.push(node.prefix);
+            }
+        }
+        else if (defaultNs !== currNs) {
+            newDefaultNs = node.namespaceURI || "";
+            res.push(' xmlns="', newDefaultNs, '"');
+        }
+        // Handle the attributes namespace
+        if (node.attributes) {
+            for (let i = 0; i < node.attributes.length; i++) {
+                const attr = node.attributes[i];
+                if (attr.prefix === "xmlns" && prefixesInScope.indexOf(attr.localName) === -1) {
+                    nsListToRender.push({ prefix: attr.localName, namespaceURI: attr.value });
+                    prefixesInScope.push(attr.localName);
+                }
+                if (attr.prefix &&
+                    prefixesInScope.indexOf(attr.prefix) === -1 &&
+                    attr.prefix !== "xmlns" &&
+                    attr.prefix !== "xml") {
+                    nsListToRender.push({ prefix: attr.prefix, namespaceURI: attr.namespaceURI });
+                    prefixesInScope.push(attr.prefix);
+                }
+            }
+        }
+        // Add ancestor namespaces
+        if (utils.isArrayHasLength(ancestorNamespaces)) {
+            for (const ancestorNamespace of ancestorNamespaces) {
+                let alreadyListed = false;
+                for (const nsToRender of nsListToRender) {
+                    if (nsToRender.prefix === ancestorNamespace.prefix &&
+                        nsToRender.namespaceURI === ancestorNamespace.namespaceURI) {
+                        alreadyListed = true;
+                        break;
+                    }
+                }
+                if (!alreadyListed) {
+                    nsListToRender.push(ancestorNamespace);
+                }
+            }
+        }
+        nsListToRender.sort(this.nsCompare.bind(this));
+        for (const attr of nsListToRender) {
+            if (attr.prefix) {
+                res.push(` xmlns:${attr.prefix}="${attr.namespaceURI}"`);
+            }
+            else {
+                res.push(` xmlns="${attr.namespaceURI}"`);
+            }
+        }
+        return { rendered: res.join(""), newDefaultNs };
+    }
+    processInner(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces) {
+        if (isDomNode.isCommentNode(node)) {
+            return this.renderComment(node);
+        }
+        if (isDomNode.isTextNode(node) && node.data) {
+            const encodeFn = this.xmlVersion === "1.1"
+                ? utils.encodeSpecialCharactersInTextXml11
+                : utils.encodeSpecialCharactersInText;
+            return encodeFn(node.data);
+        }
+        // Handle CDATA sections
+        if (isDomNode.isCDATASectionNode(node) && node.data) {
+            const encodeFn = this.xmlVersion === "1.1"
+                ? utils.encodeSpecialCharactersInTextXml11
+                : utils.encodeSpecialCharactersInText;
+            return encodeFn(node.data);
+        }
+        if (isDomNode.isElementNode(node)) {
+            const ns = this.renderNs(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces);
+            const childCount = node.childNodes.length;
+            const parts = new Array(childCount + 3);
+            parts[0] = `<${node.tagName}${ns.rendered}${this.renderAttrs(node)}>`;
+            let partIndex = 1;
+            for (let i = 0; i < childCount; i++) {
+                const pfxCopy = prefixesInScope.slice(0);
+                parts[partIndex++] = this.processInner(node.childNodes[i], pfxCopy, ns.newDefaultNs, defaultNsForPrefix, []);
+            }
+            parts[partIndex] = `</${node.tagName}>`;
+            return parts.join("");
+        }
+        throw new Error(`Unable to canonicalize node type: ${node.nodeType}`);
+    }
+    renderComment(node) {
+        if (!this.includeComments) {
+            return "";
+        }
+        const isOutsideDocument = node.ownerDocument === node.parentNode;
+        let isBeforeDocument = false;
+        let isAfterDocument = false;
+        if (isOutsideDocument) {
+            let nextNode = node;
+            let previousNode = node;
+            while (nextNode !== null) {
+                if (nextNode === node.ownerDocument.documentElement) {
+                    isBeforeDocument = true;
+                    break;
+                }
+                nextNode = nextNode.nextSibling;
+            }
+            while (previousNode !== null) {
+                if (previousNode === node.ownerDocument.documentElement) {
+                    isAfterDocument = true;
+                    break;
+                }
+                previousNode = previousNode.previousSibling;
+            }
+        }
+        const afterDocument = isAfterDocument ? "\n" : "";
+        const beforeDocument = isBeforeDocument ? "\n" : "";
+        const encodeFn = this.xmlVersion === "1.1"
+            ? utils.encodeSpecialCharactersInTextXml11
+            : utils.encodeSpecialCharactersInText;
+        const encodedText = encodeFn(node.data);
+        return `${afterDocument}<!--${encodedText}-->${beforeDocument}`;
+    }
+    process(node, options) {
+        options = options || {};
+        const defaultNs = options.defaultNs || "";
+        const defaultNsForPrefix = options.defaultNsForPrefix || {};
+        const ancestorNamespaces = options.ancestorNamespaces || [];
+        const prefixesInScope = [];
+        for (let i = 0; i < ancestorNamespaces.length; i++) {
+            prefixesInScope.push(ancestorNamespaces[i].prefix);
+        }
+        return this.processInner(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces);
+    }
+    getAlgorithmName() {
+        return "http://www.w3.org/2010/xml-c14n2";
+    }
+}
+/**
+ * Canonical XML 2.0 with comments
+ */
+export class C14nCanonicalization2WithComments extends C14nCanonicalization2 {
+    constructor(xmlVersion) {
+        super(xmlVersion, true);
+    }
+    getAlgorithmName() {
+        return "http://www.w3.org/2010/xml-c14n2#WithComments";
+    }
+}

package/build/c14n-canonicalization.d.ts

@@ -0,0 +1,48 @@
+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();
+}

package/build/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/{lib → build}/c14n-canonicalization.js

@@ -1,12 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.C14nCanonicalizationWithComments = exports.C14nCanonicalization = void 0;
-const utils = require("./utils");
-const isDomNode = require("@xmldom/is-dom-node");
-class C14nCanonicalization {
-    constructor() {
-        this.includeComments = false;
+import * as utils from "./utils.js";
+import * as isDomNode from "@xmldom/is-dom-node";
+// Pre-compiled regex for better performance
+const XMLNS_ATTR_REGEX = /^xmlns/;
+export class C14nCanonicalization {
+    includeComments = false;
+    xmlVersion = "1.0";
+    constructor(xmlVersion) {
         this.includeComments = false;
+        if (xmlVersion) {
+            this.xmlVersion = xmlVersion;
+        }
     }
     attrCompare(a, b) {
         if (!a.namespaceURI && b.namespaceURI) {
@@ -28,54 +31,46 @@ class C14nCanonicalization {
         }
     }
     nsCompare(a, b) {
-        const attr1 = a.prefix;
-        const attr2 = b.prefix;
-        if (attr1 === attr2) {
+        if (a.prefix === b.prefix) {
             return 0;
         }
-        return attr1.localeCompare(attr2);
+        return a.prefix.localeCompare(b.prefix);
     }
     renderAttrs(node) {
-        let i;
-        let attr;
-        const attrListToRender = [];
         if (isDomNode.isCommentNode(node)) {
             return this.renderComment(node);
         }
-        if (node.attributes) {
-            for (i = 0; i < node.attributes.length; ++i) {
-                attr = node.attributes[i];
-                //ignore namespace definition attributes
-                if (attr.name.indexOf("xmlns") === 0) {
-                    continue;
-                }
+        if (!isDomNode.isElementNode(node) || !node.attributes) {
+            return "";
+        }
+        const attrListToRender = [];
+        for (let i = 0; i < node.attributes.length; i++) {
+            const attr = node.attributes[i];
+            // Ignore namespace definition attributes
+            if (!XMLNS_ATTR_REGEX.test(attr.name)) {
                 attrListToRender.push(attr);
             }
         }
-        attrListToRender.sort(this.attrCompare);
-        const res = attrListToRender.map((attr) => {
-            return ` ${attr.name}="${utils.encodeSpecialCharactersInAttribute(attr.value)}"`;
-        });
+        attrListToRender.sort(this.attrCompare.bind(this));
+        const encodeFn = this.xmlVersion === "1.1"
+            ? utils.encodeSpecialCharactersInAttributeXml11
+            : utils.encodeSpecialCharactersInAttribute;
+        const res = new Array(attrListToRender.length);
+        for (let i = 0; i < attrListToRender.length; i++) {
+            const attr = attrListToRender[i];
+            res[i] = ` ${attr.name}="${encodeFn(attr.value)}"`;
+        }
         return res.join("");
     }
     /**
      * Create the string of all namespace declarations that should appear on this element
-     *
-     * @param node The node we now render
-     * @param prefixesInScope The prefixes defined on this node parents which are a part of the output set
-     * @param defaultNs The current default namespace
-     * @param defaultNsForPrefix
-     * @param ancestorNamespaces Import ancestor namespaces if it is specified
-     * @api private
      */
     renderNs(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces) {
-        let i;
-        let attr;
         const res = [];
         let newDefaultNs = defaultNs;
         const nsListToRender = [];
         const currNs = node.namespaceURI || "";
-        //handle the namespace of the node itself
+        // Handle the namespace of the node itself
         if (node.prefix) {
             if (prefixesInScope.indexOf(node.prefix) === -1) {
                 nsListToRender.push({
@@ -86,22 +81,20 @@ class C14nCanonicalization {
             }
         }
         else if (defaultNs !== currNs) {
-            //new default ns
+            // New default ns
             newDefaultNs = node.namespaceURI || "";
             res.push(' xmlns="', newDefaultNs, '"');
         }
-        //handle the attributes namespace
+        // Handle the attributes namespace
         if (node.attributes) {
-            for (i = 0; i < node.attributes.length; ++i) {
-                attr = node.attributes[i];
-                //handle all prefixed attributes that are included in the prefix list and where
-                //the prefix is not defined already. New prefixes can only be defined by `xmlns:`.
+            for (let i = 0; i < node.attributes.length; i++) {
+                const attr = node.attributes[i];
+                // Handle all prefixed attributes that are included in the prefix list
                 if (attr.prefix === "xmlns" && prefixesInScope.indexOf(attr.localName) === -1) {
                     nsListToRender.push({ prefix: attr.localName, namespaceURI: attr.value });
                     prefixesInScope.push(attr.localName);
                 }
-                //handle all prefixed attributes that are not xmlns definitions and where
-                //the prefix is not defined already
+                // Handle all prefixed attributes that are not xmlns definitions
                 if (attr.prefix &&
                     prefixesInScope.indexOf(attr.prefix) === -1 &&
                     attr.prefix !== "xmlns" &&
@@ -111,14 +104,15 @@ class C14nCanonicalization {
                 }
             }
         }
+        // Add ancestor namespaces
         if (utils.isArrayHasLength(ancestorNamespaces)) {
-            // Remove namespaces which are already present in nsListToRender
             for (const ancestorNamespace of ancestorNamespaces) {
                 let alreadyListed = false;
                 for (const nsToRender of nsListToRender) {
                     if (nsToRender.prefix === ancestorNamespace.prefix &&
                         nsToRender.namespaceURI === ancestorNamespace.namespaceURI) {
                         alreadyListed = true;
+                        break;
                     }
                 }
                 if (!alreadyListed) {
@@ -126,37 +120,51 @@ class C14nCanonicalization {
                 }
             }
         }
-        nsListToRender.sort(this.nsCompare);
-        //render namespaces
-        res.push(...nsListToRender.map((attr) => {
+        nsListToRender.sort(this.nsCompare.bind(this));
+        // Render namespaces
+        for (const attr of nsListToRender) {
             if (attr.prefix) {
-                return ` xmlns:${attr.prefix}="${attr.namespaceURI}"`;
+                res.push(` xmlns:${attr.prefix}="${attr.namespaceURI}"`);
+            }
+            else {
+                res.push(` xmlns="${attr.namespaceURI}"`);
             }
-            return ` xmlns="${attr.namespaceURI}"`;
-        }));
+        }
         return { rendered: res.join(""), newDefaultNs };
     }
     /**
-     * @param node Node
+     * Process inner nodes with optimized string building
      */
     processInner(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces) {
         if (isDomNode.isCommentNode(node)) {
             return this.renderComment(node);
         }
-        if (node.data) {
-            return utils.encodeSpecialCharactersInText(node.data);
+        if (isDomNode.isTextNode(node) && node.data) {
+            const encodeFn = this.xmlVersion === "1.1"
+                ? utils.encodeSpecialCharactersInTextXml11
+                : utils.encodeSpecialCharactersInText;
+            return encodeFn(node.data);
+        }
+        // Handle CDATA sections - treat as text content
+        if (isDomNode.isCDATASectionNode(node) && node.data) {
+            const encodeFn = this.xmlVersion === "1.1"
+                ? utils.encodeSpecialCharactersInTextXml11
+                : utils.encodeSpecialCharactersInText;
+            return encodeFn(node.data);
         }
         if (isDomNode.isElementNode(node)) {
-            let i;
-            let pfxCopy;
             const ns = this.renderNs(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces);
-            const res = ["<", node.tagName, ns.rendered, this.renderAttrs(node), ">"];
-            for (i = 0; i < node.childNodes.length; ++i) {
-                pfxCopy = prefixesInScope.slice(0);
-                res.push(this.processInner(node.childNodes[i], pfxCopy, ns.newDefaultNs, defaultNsForPrefix, []));
+            // Pre-allocate array for better performance
+            const childCount = node.childNodes.length;
+            const parts = new Array(childCount + 3);
+            parts[0] = `<${node.tagName}${ns.rendered}${this.renderAttrs(node)}>`;
+            let partIndex = 1;
+            for (let i = 0; i < childCount; i++) {
+                const pfxCopy = prefixesInScope.slice(0);
+                parts[partIndex++] = this.processInner(node.childNodes[i], pfxCopy, ns.newDefaultNs, defaultNsForPrefix, []);
             }
-            res.push("</", node.tagName, ">");
-            return res.join("");
+            parts[partIndex] = `</${node.tagName}>`;
+            return parts.join("");
         }
         throw new Error(`Unable to canonicalize node type: ${node.nodeType}`);
     }
@@ -188,14 +196,14 @@ class C14nCanonicalization {
         }
         const afterDocument = isAfterDocument ? "\n" : "";
         const beforeDocument = isBeforeDocument ? "\n" : "";
-        const encodedText = utils.encodeSpecialCharactersInText(node.data);
+        const encodeFn = this.xmlVersion === "1.1"
+            ? utils.encodeSpecialCharactersInTextXml11
+            : utils.encodeSpecialCharactersInText;
+        const encodedText = encodeFn(node.data);
         return `${afterDocument}<!--${encodedText}-->${beforeDocument}`;
     }
     /**
      * Perform canonicalization of the given node
-     *
-     * @param node
-     * @api public
      */
     process(node, options) {
         options = options || {};
@@ -206,25 +214,37 @@ class C14nCanonicalization {
         for (let i = 0; i < ancestorNamespaces.length; i++) {
             prefixesInScope.push(ancestorNamespaces[i].prefix);
         }
-        const res = this.processInner(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces);
-        return res;
+        return this.processInner(node, prefixesInScope, defaultNs, defaultNsForPrefix, ancestorNamespaces);
     }
     getAlgorithmName() {
         return "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
     }
 }
-exports.C14nCanonicalization = C14nCanonicalization;
 /**
- * Add c14n#WithComments here (very simple subclass)
+ * C14n with comments support
  */
-class C14nCanonicalizationWithComments extends C14nCanonicalization {
-    constructor() {
-        super();
+export class C14nCanonicalizationWithComments extends C14nCanonicalization {
+    constructor(xmlVersion) {
+        super(xmlVersion);
         this.includeComments = true;
     }
     getAlgorithmName() {
         return "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments";
     }
 }
-exports.C14nCanonicalizationWithComments = C14nCanonicalizationWithComments;
-//# sourceMappingURL=c14n-canonicalization.js.map
+/**
+ * XML 1.1 specific C14n canonicalization
+ */
+export class C14nCanonicalizationXml11 extends C14nCanonicalization {
+    constructor() {
+        super("1.1");
+    }
+}
+/**
+ * XML 1.1 C14n with comments support
+ */
+export class C14nCanonicalizationWithCommentsXml11 extends C14nCanonicalizationWithComments {
+    constructor() {
+        super("1.1");
+    }
+}

package/{lib → build}/enveloped-signature.d.ts

@@ -1,4 +1,4 @@
-import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, CanonicalizationOrTransformAlgorithmType } from "./types";
+import type { CanonicalizationOrTransformationAlgorithm, CanonicalizationOrTransformationAlgorithmProcessOptions, CanonicalizationOrTransformAlgorithmType } from "./types.ts";
 export declare class EnvelopedSignature implements CanonicalizationOrTransformationAlgorithm {
     protected includeComments: boolean;
     constructor();

package/build/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/{lib → build}/enveloped-signature.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvelopedSignature = void 0;
-const xpath = require("xpath");
-const isDomNode = require("@xmldom/is-dom-node");
-class EnvelopedSignature {
+import * as xpath from "xpath";
+import * as isDomNode from "@xmldom/is-dom-node";
+export class EnvelopedSignature {
+    includeComments = false;
     constructor() {
         this.includeComments = false;
-        this.includeComments = false;
     }
     process(node, options) {
         if (null == options.signatureNode) {
@@ -39,5 +36,3 @@ class EnvelopedSignature {
         return "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
     }
 }
-exports.EnvelopedSignature = EnvelopedSignature;
-//# sourceMappingURL=enveloped-signature.js.map