xslt-processor 4.8.4 → 4.8.5

package/index.mjs

@@ -10962,6 +10962,9 @@ function xmlElementLogicTrivial(node, buffer, options) {
     if (!attribute) {
       continue;
     }
+    if (options.outputMethod === "html" && (attribute.nodeName === "xmlns" || attribute.nodeName.startsWith("xmlns:"))) {
+      continue;
+    }
     if (attribute.nodeName && attribute.nodeValue !== null && attribute.nodeValue !== void 0) {
       buffer.push(` ${xmlFullNodeName(attribute)}="${xmlEscapeAttr(attribute.nodeValue)}"`);
     }
@@ -14464,7 +14467,40 @@ var Xslt = class {
       } = currentTemplateContext;
       const currentNode = context.nodeList[context.position];
       const top = template.ownerDocument.documentElement;
-      const allTemplates = collectAndExpandTemplates(top, currentMode, this.xPath, this.templateSourceMap);
+      const stylesheetRoots = [];
+      if (top) {
+        stylesheetRoots.push(top);
+      }
+      this.importedStylesheets.forEach((doc) => {
+        if (!doc) {
+          return;
+        }
+        if (doc.nodeType === DOM_DOCUMENT_NODE) {
+          const rootElement = doc.childNodes.find(
+            (child) => child.nodeType === DOM_ELEMENT_NODE
+          );
+          if (rootElement) {
+            stylesheetRoots.push(rootElement);
+          }
+        } else if (doc.nodeType === DOM_ELEMENT_NODE) {
+          stylesheetRoots.push(doc);
+        }
+      });
+      let allTemplates = [];
+      let docOrderOffset = 0;
+      for (const root2 of stylesheetRoots) {
+        const templates = collectAndExpandTemplates(
+          root2,
+          currentMode,
+          this.xPath,
+          this.templateSourceMap
+        );
+        for (const templateEntry of templates) {
+          templateEntry.documentOrder += docOrderOffset;
+        }
+        docOrderOffset += templates.length;
+        allTemplates = allTemplates.concat(templates);
+      }
       const importedTemplates = allTemplates.filter((t) => {
         const metadata2 = this.templateSourceMap.get(t.template);
         return metadata2 && metadata2.importDepth > currentDepth;
@@ -14600,7 +14636,11 @@ var Xslt = class {
     if (source.nodeType == DOM_ELEMENT_NODE) {
       let node = domCreateElement(this.outputDocument, source.nodeName);
       if (source.namespaceUri !== null && source.namespaceUri !== void 0) {
-        domSetAttribute(node, "xmlns", source.namespaceUri);
+        const prefix = source.prefix || (source.nodeName.includes(":") ? source.nodeName.split(":")[0] : null);
+        const nsAttr = prefix ? `xmlns:${prefix}` : "xmlns";
+        if (!this.isNamespaceDeclaredOnAncestor(destination, nsAttr, source.namespaceUri)) {
+          domSetAttribute(node, nsAttr, source.namespaceUri);
+        }
       }
       node.siblingPosition = destination.childNodes.length;
       domAppendChild(destination, node);
@@ -16343,6 +16383,17 @@ var Xslt = class {
    * @returns The formatted number string.
    */
   xsltFormatNumber(number, format, groupingSeparator, groupingSize) {
+    if (format.match(/^0+1$/)) {
+      const width = format.length;
+      let result2 = number.toString().padStart(width, "0");
+      if (groupingSeparator && groupingSize) {
+        const size = parseInt(groupingSize, 10);
+        if (size > 0 && !isNaN(size)) {
+          result2 = this.applyGrouping(result2, groupingSeparator, size);
+        }
+      }
+      return result2;
+    }
     const formatChar = format.charAt(0);
     let result;
     switch (formatChar) {
@@ -16471,6 +16522,54 @@ var Xslt = class {
     }
     this.xPath.xPathSort(context, sort2);
   }
+  resolveNamespaceUriForPrefix(node, prefix) {
+    const attrName = prefix ? `xmlns:${prefix}` : "xmlns";
+    let current = node;
+    while (current) {
+      const attributes = current.childNodes.filter(
+        (child) => child.nodeType === DOM_ATTRIBUTE_NODE
+      );
+      for (const attribute of attributes) {
+        if (attribute.nodeName === attrName) {
+          return attribute.nodeValue;
+        }
+        if (prefix && attribute.prefix === "xmlns" && attribute.localName === prefix) {
+          return attribute.nodeValue;
+        }
+        if (!prefix && attribute.nodeName === "xmlns") {
+          return attribute.nodeValue;
+        }
+      }
+      current = current.parentNode;
+    }
+    return null;
+  }
+  isNamespaceDeclaredOnAncestor(node, nsAttr, nsUri) {
+    let current = node;
+    while (current) {
+      const value = domGetAttributeValue(current, nsAttr);
+      if (value === nsUri) {
+        return true;
+      }
+      current = current.parentNode;
+    }
+    return false;
+  }
+  parseWhitespacePattern(pattern, template) {
+    if (pattern === "*") {
+      return { namespaceUri: null, localName: "*", isWildcard: true };
+    }
+    if (pattern.includes(":")) {
+      const [prefix, localPart] = pattern.split(":");
+      const namespaceUri = this.resolveNamespaceUriForPrefix(template, prefix);
+      return {
+        namespaceUri: namespaceUri != null ? namespaceUri : null,
+        localName: localPart || "*",
+        isWildcard: localPart === "*"
+      };
+    }
+    return { namespaceUri: null, localName: pattern, isWildcard: false };
+  }
   /**
    * Implements `xsl:strip-space`.
    * Collects element name patterns for which whitespace-only text nodes should be stripped.
@@ -16480,7 +16579,9 @@ var Xslt = class {
     const elements = xmlGetAttribute(template, "elements");
     if (elements) {
       const patterns = elements.trim().split(/\s+/);
-      this.stripSpacePatterns.push(...patterns);
+      for (const pattern of patterns) {
+        this.stripSpacePatterns.push(this.parseWhitespacePattern(pattern, template));
+      }
     }
   }
   /**
@@ -16493,7 +16594,9 @@ var Xslt = class {
     const elements = xmlGetAttribute(template, "elements");
     if (elements) {
       const patterns = elements.trim().split(/\s+/);
-      this.preserveSpacePatterns.push(...patterns);
+      for (const pattern of patterns) {
+        this.preserveSpacePatterns.push(this.parseWhitespacePattern(pattern, template));
+      }
     }
   }
   /**
@@ -16550,19 +16653,19 @@ var Xslt = class {
    * @returns True if the element matches the pattern.
    */
   matchesNamePattern(elementName, pattern, element) {
-    if (pattern === "*") {
-      return true;
-    }
-    if (pattern.includes(":")) {
-      const [prefix, localPart] = pattern.split(":");
-      const elementPrefix = element.prefix || "";
-      if (localPart === "*") {
-        return elementPrefix === prefix;
-      } else {
-        return elementPrefix === prefix && elementName === localPart;
+    var _a;
+    const elementNamespace = (_a = element.namespaceUri) != null ? _a : this.resolveNamespaceUriForPrefix(element, element.prefix || null);
+    if (pattern.namespaceUri !== null) {
+      if (elementNamespace !== pattern.namespaceUri) {
+        return false;
       }
+    } else if (!pattern.isWildcard && elementNamespace) {
+      return false;
+    }
+    if (pattern.isWildcard) {
+      return true;
     }
-    return elementName === pattern;
+    return elementName === pattern.localName;
   }
   /**
    * Implements `xsl:template`.
@@ -17448,9 +17551,38 @@ var Xslt = class {
           let elementContext = context;
           node = context.nodeList[context.position];
           let newNode;
-          newNode = domCreateElement(this.outputDocument, template.nodeName);
+          let qualifiedName = template.nodeName;
+          let namespaceUri = template.namespaceUri;
+          const templatePrefix = template.prefix || "";
+          const aliasPrefix = this.namespaceAliases.get(templatePrefix);
+          if (aliasPrefix) {
+            const localName = template.localName || template.nodeName;
+            if (aliasPrefix === "#default") {
+              qualifiedName = localName;
+              namespaceUri = this.resolveNamespaceUriForPrefix(template, null);
+            } else {
+              qualifiedName = `${aliasPrefix}:${localName}`;
+              namespaceUri = this.resolveNamespaceUriForPrefix(template, aliasPrefix);
+            }
+          }
+          newNode = domCreateElement(this.outputDocument, qualifiedName);
           newNode.siblingPosition = (output || this.outputDocument).childNodes.length;
           domAppendChild(output || this.outputDocument, newNode);
+          if (aliasPrefix) {
+            if (aliasPrefix === "#default") {
+              if (namespaceUri) {
+                domSetAttribute(newNode, "xmlns", namespaceUri);
+              }
+            } else if (namespaceUri) {
+              domSetAttribute(newNode, `xmlns:${aliasPrefix}`, namespaceUri);
+            }
+          } else if (namespaceUri) {
+            const prefix = templatePrefix || (qualifiedName.includes(":") ? qualifiedName.split(":")[0] : null);
+            const nsAttr = prefix ? `xmlns:${prefix}` : "xmlns";
+            if (!this.isNamespaceDeclaredOnAncestor(output, nsAttr, namespaceUri)) {
+              domSetAttribute(newNode, nsAttr, namespaceUri);
+            }
+          }
           const useAttributeSetsAttr = template.childNodes.find(
             (a) => (a == null ? void 0 : a.nodeType) === DOM_ATTRIBUTE_NODE && a.nodeName === "use-attribute-sets"
           );