xslt-processor 4.8.4 → 4.9.0

package/README.md

@@ -4,7 +4,7 @@ _A JavaScript XSLT processor without native library dependencies._
 
   <p align="center">
     <a href="https://github.com/DesignLiquido/xslt-processor/issues" target="_blank">
-      <img src="https://img.shields.io/github/issues/Designliquido/xslt-processor" />
+      <img src="https://img.shields.io/github/issues/DesignLiquido/xslt-processor" />
     </a>
     <img src="https://img.shields.io/github/stars/Designliquido/xslt-processor" />
     <img src="https://img.shields.io/github/forks/Designliquido/xslt-processor" />
@@ -37,7 +37,7 @@ ohpm install xslt-processor
 yarn add xslt-processor
 ```
 
-Within your ES2015+ code, import the `Xslt` class, the `XmlParser` class and use this way:
+Within your ES2015+ code, import the `Xslt` class, the `XmlParser` class and use it this way:
 
 ```js
 import { Xslt, XmlParser } from 'xslt-processor'
@@ -80,11 +80,44 @@ const xslt = new Xslt(options);
 - `cData` (`boolean`, default `true`): resolves CDATA elements in the output. Content under CDATA is resolved as text. This overrides `escape` for CDATA content.
 - `escape` (`boolean`, default `true`): replaces symbols like `<`, `>`, `&` and `"` by the corresponding [HTML/XML entities](https://www.tutorialspoint.com/xml/xml_character_entities.htm). Can be overridden by `disable-output-escaping`, that also does the opposite, unescaping `&gt;` and `&lt;` by `<` and `>`, respectively.
 - `selfClosingTags` (`boolean`, default `true`): Self-closes tags that don't have inner elements, if `true`. For instance, `<test></test>` becomes `<test />`.
-- `outputMethod` (`string`, default `xml`): Specifies the default output method. if `<xsl:output>` is declared in your XSLT file, this will be overridden. Valid values: `xml`, `html`, `text`, `name`, `xhtml`, `json`, `adaptive`.
+- `outputMethod` (`string`, default `xml`): Specifies the default output method. If `<xsl:output>` is declared in your XSLT file, this will be overridden. Valid values: `xml`, `html`, `text`, `xhtml`, `json`, `adaptive`.
 - `parameters` (`array`, default `[]`): external parameters that you want to use.
     - `name`: the parameter name;
     - `namespaceUri` (optional): the namespace;
     - `value`: the value.
+- `fetchFunction` (`(uri: string) => Promise<string>`, optional): a custom function for loading external resources referenced by `<xsl:import>` and `<xsl:include>`. Receives the URI and must return the fetched content as a string. Defaults to the global `fetch` API. This is useful for:
+    - Denying external loading entirely;
+    - Loading from the local filesystem or other non-HTTP sources;
+    - Transforming or remapping URIs before fetching.
+
+**`fetchFunction` examples:**
+
+```js
+import { readFileSync } from 'fs';
+
+// Deny all external loading
+const xslt = new Xslt({
+  fetchFunction: async (uri) => {
+    throw new Error(`External loading is not allowed: ${uri}`);
+  }
+});
+
+// Load from local filesystem
+const xslt = new Xslt({
+  fetchFunction: async (uri) => {
+    return readFileSync(uri, 'utf-8');
+  }
+});
+
+// Remap URIs before fetching
+const xslt = new Xslt({
+  fetchFunction: async (uri) => {
+    const remapped = uri.replace('https://example.com/', '/local/stylesheets/');
+    const response = await fetch(remapped);
+    return response.text();
+  }
+});
+```
 
 #### JSON Output Format
 
@@ -182,10 +215,10 @@ console.log(result2); // "<users><user>John</user></users>" (XML)
 You can simply add a tag like this:
 
 ```html
-<script type="application/javascript" src="https://www.unpkg.com/xslt-processor@latest/umd/xslt-processor.global.js"></script>
+<script type="application/javascript" src="https://unpkg.com/xslt-processor@latest/umd/xslt-processor.global.js"></script>
 ```
 
-All the exports will live under `globalThis.XsltProcessor` and `window.XsltProcessor`. [See a usage example here](https://github.com/DesignLiquido/xslt-processor/blob/main/interactive-tests/xslt.html). 
+All the exports will live under `globalThis.XsltProcessor` and `window.XsltProcessor`. [See a usage example here](https://github.com/DesignLiquido/xslt-processor/blob/main/interactive-tests/xslt.html).
 
 ## XPath Parser
 
@@ -204,7 +237,7 @@ import { XPath } from 'xslt-processor'
 const xPath = new XPath();
 ```
 
-`XPath` class is an external dependency, [living in its own repository](https://github.com/DesignLiquido/xpath). 
+`XPath` class is an external dependency, [living in its own repository](https://github.com/DesignLiquido/xpath).
 
 ## Introduction
 
@@ -215,13 +248,40 @@ XSLT-processor builds on Google's [AJAXSLT](https://github.com/4031651/ajaxslt)
 
 This implementation of XSLT operates at the DOM level on its input documents. It internally uses a DOM implementation to create the output document, but usually returns the output document as text stream. The DOM to construct the output document can be supplied by the application, or else an internal minimal DOM implementation is used. This DOM comes with a minimal XML parser that can be used to generate a suitable DOM representation of the input documents if they are present as text.
 
+## Building from source
+
+The XPath engine lives in a Git submodule at `src/xpath/lib`. A regular `git clone` does **not** fetch it automatically, so the build will fail unless the submodule is initialised.
+
+### Fresh clone
+
+```sh
+git clone --recurse-submodules https://github.com/DesignLiquido/xslt-processor.git
+cd xslt-processor
+yarn install
+yarn build
+```
+
+### Already cloned without submodules
+
+```sh
+git submodule update --init --recursive
+yarn install
+yarn build
+```
+
+### Updating the submodule to the latest commit
+
+```sh
+git submodule update --remote src/xpath/lib
+```
+
 ## Tests and usage examples
 
-New tests are written in Jest an can be run by calling: `yarn test`.
+New tests are written in Jest and can be run by calling: `yarn test`.
 
 The files `xslt.html` and `xpath.html` in the directory `interactive-tests` are interactive tests. They can be run directly from the file system; no HTTP server is needed.
 
-Both interactive tests and automatic tests demonstrate the use of the library functions. 
+Both interactive tests and automatic tests demonstrate the use of the library functions.
 
 ## Conformance
 
@@ -233,9 +293,9 @@ So far, we have implemented XQuery functions for versions 1.0 and 2.0, but this
 
 The DOM implementation is minimal so as to support the XSLT processing, and not intended to be complete.
 
-The implementation is all agnostic about namespaces. It just expects XSLT elements to have tags that carry the `xsl:` prefix, but we disregard all namespace declaration for them.
+The implementation is all agnostic about namespaces. It just expects XSLT elements to have tags that carry the `xsl:` prefix, but we disregard all namespace declarations for them.
 
-[There are a few nonstandard XPath functions](https://github.com/search?q=repo%3ADesignLiquido%2Fxslt-processor%20ext-&type=code). 
+[There are a few nonstandard XPath functions](https://github.com/search?q=repo%3ADesignLiquido%2Fxslt-processor%20ext-&type=code).
 
 ### HTML Conformance
 

package/index.d.mts

@@ -172,6 +172,7 @@ type XsltOptions = {
     selfClosingTags: boolean;
     outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive';
     parameters?: XsltParameter[];
+    fetchFunction?: (uri: string) => Promise<string>;
 };
 
 interface NodeValue {
@@ -719,6 +720,11 @@ declare class MatchResolver {
     private relativeXsltMatch;
 }
 
+interface WhitespacePattern {
+    namespaceUri: string | null;
+    localName: string;
+    isWildcard: boolean;
+}
 /**
  * The main class for XSL-T processing.
  *
@@ -755,6 +761,12 @@ declare class Xslt {
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
     warningsCallback: (...args: any[]) => void;
+    /**
+     * Custom fetch function for loading external resources (e.g. xsl:import, xsl:include).
+     * Takes a URI and returns the fetched content as a string.
+     * Defaults to using the global `fetch` API.
+     */
+    fetchFunction: (uri: string) => Promise<string>;
     outputDocument: XDocument;
     outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json' | 'adaptive';
     outputOmitXmlDeclaration: string;
@@ -775,13 +787,13 @@ declare class Xslt {
      * List of element name patterns from xsl:strip-space declarations.
      * Whitespace-only text nodes inside matching elements will be stripped.
      */
-    stripSpacePatterns: string[];
+    stripSpacePatterns: WhitespacePattern[];
     /**
      * List of element name patterns from xsl:preserve-space declarations.
      * Whitespace-only text nodes inside matching elements will be preserved.
      * preserve-space takes precedence over strip-space for conflicting patterns.
      */
-    preserveSpacePatterns: string[];
+    preserveSpacePatterns: WhitespacePattern[];
     /**
      * Namespace aliases from xsl:namespace-alias declarations.
      * Maps stylesheet namespace prefixes to result namespace prefixes.
@@ -1346,6 +1358,9 @@ declare class Xslt {
      * @todo case-order is not implemented.
      */
     protected xsltSort(context: ExprContext, template: XNode): void;
+    private resolveNamespaceUriForPrefix;
+    private isNamespaceDeclaredOnAncestor;
+    private parseWhitespacePattern;
     /**
      * Implements `xsl:strip-space`.
      * Collects element name patterns for which whitespace-only text nodes should be stripped.
@@ -1378,7 +1393,7 @@ declare class Xslt {
      * @param element The element node (for namespace checking).
      * @returns True if the element matches the pattern.
      */
-    protected matchesNamePattern(elementName: string, pattern: string, element: XNode): boolean;
+    protected matchesNamePattern(elementName: string, pattern: WhitespacePattern, element: XNode): boolean;
     /**
      * Implements `xsl:template`.
      * @param context The Expression Context.

package/index.d.ts

@@ -172,6 +172,7 @@ type XsltOptions = {
     selfClosingTags: boolean;
     outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive';
     parameters?: XsltParameter[];
+    fetchFunction?: (uri: string) => Promise<string>;
 };
 
 interface NodeValue {
@@ -719,6 +720,11 @@ declare class MatchResolver {
     private relativeXsltMatch;
 }
 
+interface WhitespacePattern {
+    namespaceUri: string | null;
+    localName: string;
+    isWildcard: boolean;
+}
 /**
  * The main class for XSL-T processing.
  *
@@ -755,6 +761,12 @@ declare class Xslt {
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
     warningsCallback: (...args: any[]) => void;
+    /**
+     * Custom fetch function for loading external resources (e.g. xsl:import, xsl:include).
+     * Takes a URI and returns the fetched content as a string.
+     * Defaults to using the global `fetch` API.
+     */
+    fetchFunction: (uri: string) => Promise<string>;
     outputDocument: XDocument;
     outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json' | 'adaptive';
     outputOmitXmlDeclaration: string;
@@ -775,13 +787,13 @@ declare class Xslt {
      * List of element name patterns from xsl:strip-space declarations.
      * Whitespace-only text nodes inside matching elements will be stripped.
      */
-    stripSpacePatterns: string[];
+    stripSpacePatterns: WhitespacePattern[];
     /**
      * List of element name patterns from xsl:preserve-space declarations.
      * Whitespace-only text nodes inside matching elements will be preserved.
      * preserve-space takes precedence over strip-space for conflicting patterns.
      */
-    preserveSpacePatterns: string[];
+    preserveSpacePatterns: WhitespacePattern[];
     /**
      * Namespace aliases from xsl:namespace-alias declarations.
      * Maps stylesheet namespace prefixes to result namespace prefixes.
@@ -1346,6 +1358,9 @@ declare class Xslt {
      * @todo case-order is not implemented.
      */
     protected xsltSort(context: ExprContext, template: XNode): void;
+    private resolveNamespaceUriForPrefix;
+    private isNamespaceDeclaredOnAncestor;
+    private parseWhitespacePattern;
     /**
      * Implements `xsl:strip-space`.
      * Collects element name patterns for which whitespace-only text nodes should be stripped.
@@ -1378,7 +1393,7 @@ declare class Xslt {
      * @param element The element node (for namespace checking).
      * @returns True if the element matches the pattern.
      */
-    protected matchesNamePattern(elementName: string, pattern: string, element: XNode): boolean;
+    protected matchesNamePattern(elementName: string, pattern: WhitespacePattern, element: XNode): boolean;
     /**
      * Implements `xsl:template`.
      * @param context The Expression Context.

package/index.js

@@ -10973,6 +10973,9 @@ function xmlElementLogicTrivial(node, buffer, options) {
     if (!attribute) {
       continue;
     }
+    if (options.outputMethod === "html" && attribute.nodeName === "xmlns" && attribute.nodeValue === "http://www.w3.org/1999/xhtml") {
+      continue;
+    }
     if (attribute.nodeName && attribute.nodeValue !== null && attribute.nodeValue !== void 0) {
       buffer.push(` ${xmlFullNodeName(attribute)}="${xmlEscapeAttr(attribute.nodeValue)}"`);
     }
@@ -13905,6 +13908,16 @@ var Xslt = class {
     this.firstTemplateRan = false;
     this.forwardsCompatible = false;
     this.warningsCallback = console.warn.bind(console);
+    this.fetchFunction = options.fetchFunction || ((uri) => __async(this, null, function* () {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch === "function" ? globalThis.fetch : null;
+      if (!globalFetch) {
+        throw new Error(
+          "No global fetch implementation available. Please provide options.fetchFunction or use a runtime that exposes globalThis.fetch."
+        );
+      }
+      const response = yield globalFetch(uri);
+      return response.text();
+    }));
     this.streamingProcessor = new StreamingProcessor({
       xPath: this.xPath,
       version: ""
@@ -14475,7 +14488,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;
@@ -14536,6 +14582,19 @@ var Xslt = class {
       const value = xmlValueLegacyBehavior(documentFragment);
       if (output) {
         domSetAttribute(output, name, value);
+        if (name.includes(":")) {
+          const prefix = name.split(":")[0];
+          if (prefix !== "xmlns") {
+            const explicitNs = xmlGetAttribute(template, "namespace");
+            const nsUri = explicitNs || this.resolveNamespaceUriForPrefix(template, prefix);
+            if (nsUri) {
+              const nsAttr = `xmlns:${prefix}`;
+              if (!this.isNamespaceDeclaredOnAncestor(output, nsAttr, nsUri)) {
+                domSetAttribute(output, nsAttr, nsUri);
+              }
+            }
+          }
+        }
       }
     });
   }
@@ -14611,7 +14670,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);
@@ -14634,6 +14697,12 @@ var Xslt = class {
       domAppendChild(destination, node);
     } else if (source.nodeType == DOM_ATTRIBUTE_NODE) {
       domSetAttribute(destination, source.nodeName, source.nodeValue);
+      if (source.prefix && source.namespaceUri && source.prefix !== "xmlns" && !source.nodeName.startsWith("xmlns")) {
+        const nsAttr = `xmlns:${source.prefix}`;
+        if (!this.isNamespaceDeclaredOnAncestor(destination, nsAttr, source.namespaceUri)) {
+          domSetAttribute(destination, nsAttr, source.namespaceUri);
+        }
+      }
     }
     return null;
   }
@@ -15301,16 +15370,6 @@ var Xslt = class {
   xsltImportOrInclude(context, template, output, isImport) {
     return __async(this, null, function* () {
       const elementName = isImport ? "xsl:import" : "xsl:include";
-      const [major, minor] = process.versions.node.split(".").map(Number);
-      if (major <= 17 && minor < 5) {
-        throw new Error(`Your Node.js version does not support \`<${elementName}>\`. If possible, please update your Node.js version to at least version 17.5.0.`);
-      }
-      if (!global.globalThis.fetch) {
-        global.globalThis.fetch = fetch;
-        global.globalThis.Headers = Headers;
-        global.globalThis.Request = Request;
-        global.globalThis.Response = Response;
-      }
       const hrefAttributeFind = template.childNodes.filter((n) => n.nodeName === "href");
       if (hrefAttributeFind.length <= 0) {
         throw new Error(`<${elementName}> with no href attribute defined.`);
@@ -15320,8 +15379,7 @@ var Xslt = class {
       if (this.importedStylesheets.has(href)) {
         return;
       }
-      const fetchTest = yield global.globalThis.fetch(href);
-      const fetchResponse = yield fetchTest.text();
+      const fetchResponse = yield this.fetchFunction(href);
       const includedXslt = this.xmlParser.xmlParse(fetchResponse);
       const currentDepth = this.styleSheetStack.length > 0 ? this.styleSheetStack[this.styleSheetStack.length - 1].importDepth : 0;
       const metadata = {
@@ -16354,6 +16412,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) {
@@ -16482,6 +16551,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.
@@ -16491,7 +16608,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));
+      }
     }
   }
   /**
@@ -16504,7 +16623,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));
+      }
     }
   }
   /**
@@ -16561,19 +16682,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`.
@@ -17459,9 +17580,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"
           );
@@ -17476,6 +17626,12 @@ var Xslt = class {
             const name = attribute.nodeName;
             const value = this.xsltAttributeValue(attribute.nodeValue, elementContext);
             domSetAttribute(newNode, name, value);
+            if (attribute.prefix && attribute.namespaceUri && attribute.prefix !== "xmlns" && !attribute.nodeName.startsWith("xmlns")) {
+              const nsAttr = `xmlns:${attribute.prefix}`;
+              if (!this.isNamespaceDeclaredOnAncestor(newNode, nsAttr, attribute.namespaceUri)) {
+                domSetAttribute(newNode, nsAttr, attribute.namespaceUri);
+              }
+            }
           }
           break;
         default: