xslt-processor 4.2.1 → 4.3.1

package/README.md

@@ -89,12 +89,57 @@ 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`.
+- `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`.
 - `parameters` (`array`, default `[]`): external parameters that you want to use.
     - `name`: the parameter name;
     - `namespaceUri` (optional): the namespace;
     - `value`: the value.
 
+#### JSON Output Format
+
+When using `outputMethod: 'json'`, the XSLT processor will convert the resulting XML document to JSON format. This is useful for APIs and modern JavaScript applications.
+
+**Example:**
+
+```js
+const xslt = new Xslt({ outputMethod: 'json' });
+const xmlParser = new XmlParser();
+
+const xmlString = `<root>
+  <users>
+    <user>Alice</user>
+    <user>Bob</user>
+  </users>
+</root>`;
+
+const xsltString = `<?xml version="1.0"?>
+  <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:template match="/">
+      <xsl:copy-of select="root"/>
+    </xsl:template>
+  </xsl:stylesheet>`;
+
+const result = await xslt.xsltProcess(
+  xmlParser.xmlParse(xmlString),
+  xmlParser.xmlParse(xsltString)
+);
+
+// result will be a JSON string:
+// {"root":{"users":{"user":["Alice","Bob"]}}}
+
+const parsed = JSON.parse(result);
+console.log(parsed.root.users.user); // ["Alice", "Bob"]
+```
+
+**JSON Structure Rules:**
+
+- Each element becomes a property in a JSON object
+- Text-only elements become string values
+- Elements with multiple children of the same name become arrays
+- Empty elements are omitted from the output
+- Attributes are prefixed with `@` (when present in the output)
+- Mixed text and element content uses the `#text` property for text nodes
+
 ### Direct use in browsers
 
 You can simply add a tag like this:

package/index.d.mts

@@ -22,6 +22,7 @@ declare class XNode {
     parentNode: XNode;
     visited: boolean;
     escape: boolean;
+    fromXslText: boolean;
     static _unusedXNodes: any[];
     constructor(type: number, name: string, opt_value: any, opt_owner: any, opt_namespace?: any);
     /**
@@ -138,7 +139,7 @@ interface XPathNode {
     nodeType: number;
     nodeName: string;
     localName?: string;
-    namespaceURI?: string | null;
+    namespaceUri?: string | null;
     textContent?: string | null;
     parentNode?: XPathNode | null;
     childNodes?: ArrayLike<XPathNode>;
@@ -532,6 +533,7 @@ type XsltOptions = {
     cData: boolean;
     escape: boolean;
     selfClosingTags: boolean;
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive';
     parameters?: XsltParameter[];
 };
 
@@ -566,7 +568,7 @@ declare class Xslt {
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
     outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json' | 'adaptive';
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
@@ -591,7 +593,7 @@ declare class Xslt {
      * The exported entry point of the XSL-T processor.
      * @param xmlDoc The input document root, as DOM node.
      * @param stylesheet The stylesheet document root, as DOM node.
-     * @returns the processed document, as XML text in a string.
+     * @returns the processed document, as XML text in a string, JSON string if outputMethod is 'json', or text if outputMethod is 'text' or 'adaptive' (with text content).
      */
     xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): Promise<string>;
     /**
@@ -842,6 +844,17 @@ declare class Xslt {
      */
     protected xsltTemplate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     protected xsltText(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Validates XSLT stylesheet/transform attributes.
+     * According to XSLT specification, validates:
+     * - Required version attribute
+     * - Valid version values (1.0, 2.0, 3.0)
+     * - Valid namespace declarations
+     * - Valid values for optional attributes (extension-element-prefixes, exclude-result-prefixes)
+     * @param stylesheetElement The `<xsl:stylesheet>` or `<xsl:transform>` element to validate.
+     * @param context The Expression Context for namespace access.
+     */
+    protected validateStylesheetAttributes(stylesheetElement: XNode, context: ExprContext): void;
     /**
      * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
      * validations.

package/index.d.ts

@@ -22,6 +22,7 @@ declare class XNode {
     parentNode: XNode;
     visited: boolean;
     escape: boolean;
+    fromXslText: boolean;
     static _unusedXNodes: any[];
     constructor(type: number, name: string, opt_value: any, opt_owner: any, opt_namespace?: any);
     /**
@@ -138,7 +139,7 @@ interface XPathNode {
     nodeType: number;
     nodeName: string;
     localName?: string;
-    namespaceURI?: string | null;
+    namespaceUri?: string | null;
     textContent?: string | null;
     parentNode?: XPathNode | null;
     childNodes?: ArrayLike<XPathNode>;
@@ -532,6 +533,7 @@ type XsltOptions = {
     cData: boolean;
     escape: boolean;
     selfClosingTags: boolean;
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive';
     parameters?: XsltParameter[];
 };
 
@@ -566,7 +568,7 @@ declare class Xslt {
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
     outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json' | 'adaptive';
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
@@ -591,7 +593,7 @@ declare class Xslt {
      * The exported entry point of the XSL-T processor.
      * @param xmlDoc The input document root, as DOM node.
      * @param stylesheet The stylesheet document root, as DOM node.
-     * @returns the processed document, as XML text in a string.
+     * @returns the processed document, as XML text in a string, JSON string if outputMethod is 'json', or text if outputMethod is 'text' or 'adaptive' (with text content).
      */
     xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): Promise<string>;
     /**
@@ -842,6 +844,17 @@ declare class Xslt {
      */
     protected xsltTemplate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     protected xsltText(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Validates XSLT stylesheet/transform attributes.
+     * According to XSLT specification, validates:
+     * - Required version attribute
+     * - Valid version values (1.0, 2.0, 3.0)
+     * - Valid namespace declarations
+     * - Valid values for optional attributes (extension-element-prefixes, exclude-result-prefixes)
+     * @param stylesheetElement The `<xsl:stylesheet>` or `<xsl:transform>` element to validate.
+     * @param context The Expression Context for namespace access.
+     */
+    protected validateStylesheetAttributes(stylesheetElement: XNode, context: ExprContext): void;
     /**
      * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
      * validations.

package/index.js

@@ -742,12 +742,12 @@ var XPathStep = class extends XPathExpression {
           if (!nsUri) {
             return false;
           }
-          const nodeLocalName = node.localName || node.nodeName;
+          const nodeLocalName2 = node.localName || node.nodeName && this.extractLocalName(node.nodeName);
           const nodeNsUri = node.namespaceURI || node.namespaceUri || "";
-          return nodeLocalName === localName && nodeNsUri === nsUri;
+          return nodeLocalName2 === localName && nodeNsUri === nsUri;
         }
-        const nodeName = node.localName || node.nodeName;
-        return nodeName === testName;
+        const nodeLocalName = node.localName || this.extractLocalName(node.nodeName);
+        return nodeLocalName === testName;
       case "node-type":
         switch (this.nodeTest.nodeType) {
           case "node":
@@ -806,6 +806,17 @@ var XPathStep = class extends XPathExpression {
     if (Array.isArray(value)) return value.length > 0;
     return !!value;
   }
+  /**
+   * Extract the local name from a qualified name (e.g., "ns:name" -> "name", "name" -> "name")
+   */
+  extractLocalName(qname) {
+    if (!qname) return "";
+    const colonIndex = qname.indexOf(":");
+    if (colonIndex > 0) {
+      return qname.substring(colonIndex + 1);
+    }
+    return qname;
+  }
 };
 
 // src/xpath/lib/src/expressions/predicate-expression.ts
@@ -1090,7 +1101,7 @@ var XPathFunctionCall = class extends XPathExpression {
   namespaceUri(args, context) {
     var _a;
     const node = this.getNodeArg(args, context);
-    return (_a = node == null ? void 0 : node.namespaceURI) != null ? _a : "";
+    return (_a = node == null ? void 0 : node.namespaceUri) != null ? _a : "";
   }
   nodeName(args, context) {
     var _a;
@@ -1560,6 +1571,7 @@ var _XNode = class _XNode {
     this.childNodes = [];
     this.visited = false;
     this.escape = true;
+    this.fromXslText = false;
     this.siblingPosition = -1;
     this.init(type, name, opt_value, opt_owner, opt_namespace);
   }
@@ -2086,23 +2098,32 @@ function xmlTransformedTextRecursive(node, buffer, options) {
   const nodeType = node.nodeType;
   const nodeValue = node.nodeValue;
   if (nodeType === DOM_TEXT_NODE) {
-    if (node.nodeValue && node.nodeValue.trim() !== "") {
+    const isFromXslText = node.fromXslText === true;
+    if (node.nodeValue && (isFromXslText || node.nodeValue.trim() !== "")) {
       const finalText = node.escape && options.escape ? xmlEscapeText(node.nodeValue) : xmlUnescapeText(node.nodeValue);
       buffer.push(finalText);
     }
   } else if (nodeType === DOM_CDATA_SECTION_NODE) {
-    if (options.cData) {
+    if (options.outputMethod === "text") {
+      buffer.push(nodeValue);
+    } else if (options.cData) {
       buffer.push(xmlEscapeText(nodeValue));
     } else {
       buffer.push(`<![CDATA[${nodeValue}]]>`);
     }
   } else if (nodeType == DOM_COMMENT_NODE) {
-    buffer.push(`<!-- ${nodeValue} -->`);
+    if (options.outputMethod !== "text") {
+      buffer.push(`<!-- ${nodeValue} -->`);
+    }
   } else if (nodeType == DOM_ELEMENT_NODE) {
-    if (node.nodeName !== null && node.nodeName !== void 0) {
-      xmlElementLogicTrivial(node, buffer, options);
+    if (options.outputMethod === "text") {
+      xmlElementLogicTextOnly(node, buffer, options);
     } else {
-      xmlElementLogicMuted(node, buffer, options);
+      if (node.nodeName !== null && node.nodeName !== void 0) {
+        xmlElementLogicTrivial(node, buffer, options);
+      } else {
+        xmlElementLogicMuted(node, buffer, options);
+      }
     }
   } else if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
     let childNodes = node.firstChild ? [] : node.childNodes;
@@ -2190,6 +2211,22 @@ function xmlElementLogicMuted(node, buffer, options) {
     xmlTransformedTextRecursive(childNodes[i], buffer, options);
   }
 }
+function xmlElementLogicTextOnly(node, buffer, options) {
+  let childNodes = [];
+  if (node.firstChild) {
+    let child = node.firstChild;
+    while (child) {
+      childNodes.push(child);
+      child = child.nextSibling;
+    }
+  } else {
+    childNodes = node.childNodes;
+  }
+  childNodes = childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
+  for (let i = 0; i < childNodes.length; ++i) {
+    xmlTransformedTextRecursive(childNodes[i], buffer, options);
+  }
+}
 function xmlFullNodeName(node) {
   const nodeName = node.nodeName;
   if (node.prefix && nodeName.indexOf(`${node.prefix}:`) != 0) {
@@ -2213,6 +2250,157 @@ function xmlGetAttribute(node, name) {
   }
   return value;
 }
+function nodeToJsonObject(node) {
+  if (!node) {
+    return null;
+  }
+  const nodeType = node.nodeType;
+  if (nodeType === DOM_TEXT_NODE || nodeType === DOM_CDATA_SECTION_NODE) {
+    const text = node.nodeValue ? node.nodeValue.trim() : "";
+    return text.length > 0 ? text : null;
+  }
+  if (nodeType === DOM_COMMENT_NODE) {
+    return null;
+  }
+  if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+    const children = node.childNodes || [];
+    const childObjects = [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const childObj = nodeToJsonObject(child);
+      if (childObj !== null) {
+        childObjects.push(childObj);
+      }
+    }
+    if (childObjects.length === 0) {
+      return null;
+    } else if (childObjects.length === 1) {
+      return childObjects[0];
+    } else {
+      return childObjects;
+    }
+  }
+  if (nodeType === DOM_ELEMENT_NODE) {
+    const obj = {};
+    const element = node;
+    const hasAttributes = element.attributes && element.attributes.length > 0;
+    if (hasAttributes) {
+      for (let i = 0; i < element.attributes.length; i++) {
+        const attr = element.attributes[i];
+        obj["@" + attr.nodeName] = attr.nodeValue;
+      }
+    }
+    const children = element.childNodes || [];
+    let textContent = "";
+    let hasElementChildren = false;
+    const childElements = {};
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const childType = child.nodeType;
+      if (childType === DOM_TEXT_NODE || childType === DOM_CDATA_SECTION_NODE) {
+        const text = child.nodeValue ? child.nodeValue.trim() : "";
+        if (text.length > 0) {
+          textContent += text;
+        }
+      } else if (childType === DOM_ELEMENT_NODE) {
+        hasElementChildren = true;
+        const childElement = child;
+        const childName = childElement.localName || childElement.nodeName;
+        const childObj = nodeToJsonObject(child);
+        if (childObj !== null) {
+          if (childElements[childName]) {
+            if (!Array.isArray(childElements[childName])) {
+              childElements[childName] = [childElements[childName]];
+            }
+            childElements[childName].push(childObj);
+          } else {
+            childElements[childName] = childObj;
+          }
+        }
+      }
+    }
+    Object.assign(obj, childElements);
+    if (!hasElementChildren && textContent.length > 0) {
+      if (!hasAttributes && Object.keys(childElements).length === 0) {
+        return textContent;
+      } else {
+        obj["#text"] = textContent;
+      }
+    }
+    if (Object.keys(obj).length === 0) {
+      return null;
+    }
+    return obj;
+  }
+  return null;
+}
+function detectAdaptiveOutputFormat(node) {
+  if (!node) {
+    return "xml";
+  }
+  const nodeType = node.nodeType;
+  if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+    const children = node.childNodes || [];
+    let elementCount = 0;
+    let textCount = 0;
+    let hasSignificantText = false;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.nodeType === DOM_ELEMENT_NODE) {
+        elementCount++;
+      } else if (child.nodeType === DOM_TEXT_NODE) {
+        const text = child.nodeValue ? child.nodeValue.trim() : "";
+        if (text.length > 0) {
+          textCount++;
+          hasSignificantText = true;
+        }
+      }
+    }
+    if (elementCount === 0 && hasSignificantText) {
+      return "text";
+    }
+    return "xml";
+  }
+  if (nodeType === DOM_TEXT_NODE || nodeType === DOM_CDATA_SECTION_NODE) {
+    const text = node.nodeValue ? node.nodeValue.trim() : "";
+    if (text.length > 0) {
+      return "text";
+    }
+  }
+  return "xml";
+}
+function xmlToJson(node) {
+  if (!node) {
+    return "{}";
+  }
+  let rootElement = node;
+  if (node.nodeType === DOM_DOCUMENT_NODE || node.nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+    const children = node.childNodes || [];
+    for (let i = 0; i < children.length; i++) {
+      if (children[i].nodeType === DOM_ELEMENT_NODE) {
+        rootElement = children[i];
+        break;
+      }
+    }
+  }
+  const element = rootElement;
+  const rootName = element.localName || element.nodeName;
+  const jsonObj = {};
+  const elementContent = nodeToJsonObject(rootElement);
+  if (elementContent === null) {
+    jsonObj[rootName] = {};
+  } else if (typeof elementContent === "object" && !Array.isArray(elementContent)) {
+    jsonObj[rootName] = elementContent;
+  } else {
+    jsonObj[rootName] = elementContent;
+  }
+  try {
+    const cleaned = JSON.parse(JSON.stringify(jsonObj));
+    return JSON.stringify(cleaned);
+  } catch (error) {
+    return JSON.stringify(jsonObj);
+  }
+}
 
 // src/dom/xml-parser.ts
 var import_he2 = __toESM(require("he"));
@@ -2457,7 +2645,7 @@ var XmlParser = class {
       } else if (!tag && char === "<") {
         let text = xml.slice(start, i);
         if (text && parent !== root) {
-          domAppendChild(parent, domCreateTextNode(xmlDocument, text));
+          domAppendChild(parent, domCreateTextNode(xmlDocument, import_he2.default.decode(text)));
         }
         if (xml.slice(i + 1, i + 4) === "!--") {
           let endTagIndex = xml.slice(i + 4).indexOf("-->");
@@ -2601,15 +2789,6 @@ var NodeConverter = class {
   adaptXNode(node) {
     if (!node) return null;
     const adapted = node;
-    if (!("namespaceURI" in adapted)) {
-      Object.defineProperty(adapted, "namespaceURI", {
-        get() {
-          return this.namespaceUri;
-        },
-        enumerable: true,
-        configurable: true
-      });
-    }
     if (!("textContent" in adapted)) {
       Object.defineProperty(adapted, "textContent", {
         get() {
@@ -3551,9 +3730,10 @@ var Xslt = class {
       cData: options.cData === true,
       escape: options.escape === true,
       selfClosingTags: options.selfClosingTags === true,
+      outputMethod: options.outputMethod,
       parameters: options.parameters || []
     };
-    this.outputMethod = "xml";
+    this.outputMethod = options.outputMethod || "xml";
     this.outputOmitXmlDeclaration = "no";
     this.stripSpacePatterns = [];
     this.preserveSpacePatterns = [];
@@ -3576,7 +3756,7 @@ var Xslt = class {
    * The exported entry point of the XSL-T processor.
    * @param xmlDoc The input document root, as DOM node.
    * @param stylesheet The stylesheet document root, as DOM node.
-   * @returns the processed document, as XML text in a string.
+   * @returns the processed document, as XML text in a string, JSON string if outputMethod is 'json', or text if outputMethod is 'text' or 'adaptive' (with text content).
    */
   xsltProcess(xmlDoc, stylesheet) {
     return __async(this, null, function* () {
@@ -3589,11 +3769,18 @@ var Xslt = class {
         }
       }
       yield this.xsltProcessContext(expressionContext, stylesheet, this.outputDocument);
+      if (this.outputMethod === "json") {
+        return xmlToJson(outputDocument);
+      }
+      let outputMethod = this.outputMethod;
+      if (this.outputMethod === "adaptive") {
+        outputMethod = detectAdaptiveOutputFormat(outputDocument);
+      }
       const transformedOutputXml = xmlTransformedText(outputDocument, {
         cData: this.options.cData,
         escape: this.options.escape,
         selfClosingTags: this.options.selfClosingTags,
-        outputMethod: this.outputMethod
+        outputMethod
       });
       return transformedOutputXml;
     });
@@ -3754,6 +3941,9 @@ var Xslt = class {
       for (let j = 0; j < modifiedContext.contextSize(); ++j) {
         const currentNode = modifiedContext.nodeList[j];
         if (currentNode.nodeType === DOM_TEXT_NODE) {
+          if (!this.xsltPassText(currentNode)) {
+            continue;
+          }
           const textNodeContext = context.clone(
             [currentNode],
             0
@@ -4522,6 +4712,7 @@ var Xslt = class {
   xsltText(context, template, output) {
     const text = xmlValue(template);
     const node = domCreateTextNode(this.outputDocument, text);
+    node.fromXslText = true;
     const disableOutputEscaping = template.childNodes.filter(
       (a) => a.nodeType === DOM_ATTRIBUTE_NODE && a.nodeName === "disable-output-escaping"
     );
@@ -4529,8 +4720,80 @@ var Xslt = class {
       node.escape = false;
     }
     const destinationTextNode = output || this.outputDocument;
+    node.siblingPosition = destinationTextNode.childNodes.length;
     destinationTextNode.appendChild(node);
   }
+  /**
+   * Validates XSLT stylesheet/transform attributes.
+   * According to XSLT specification, validates:
+   * - Required version attribute
+   * - Valid version values (1.0, 2.0, 3.0)
+   * - Valid namespace declarations
+   * - Valid values for optional attributes (extension-element-prefixes, exclude-result-prefixes)
+   * @param stylesheetElement The `<xsl:stylesheet>` or `<xsl:transform>` element to validate.
+   * @param context The Expression Context for namespace access.
+   */
+  validateStylesheetAttributes(stylesheetElement, context) {
+    const attributes = stylesheetElement.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    const validAttributes = ["version", "id", "extension-element-prefixes", "exclude-result-prefixes", "default-collation"];
+    const validNamespaceAttributes = ["xmlns"];
+    let versionFound = false;
+    for (let attribute of attributes) {
+      const nodeName = attribute.nodeName;
+      const nodeValue = attribute.nodeValue;
+      if (attribute.prefix === "xmlns") {
+        context.knownNamespaces[attribute.localName] = nodeValue;
+        continue;
+      }
+      if (nodeName === "xmlns") {
+        context.knownNamespaces[""] = nodeValue;
+        continue;
+      }
+      if (nodeName === "version") {
+        versionFound = true;
+        if (!["1.0", "2.0", "3.0"].includes(nodeValue)) {
+          throw new Error(
+            `XSLT version not defined or invalid. Actual resolved version: ${nodeValue || "(none)"}.`
+          );
+        }
+        this.version = nodeValue;
+        context.xsltVersion = nodeValue;
+        continue;
+      }
+      if (nodeName === "extension-element-prefixes") {
+        const prefixes = nodeValue.split(/\s+/);
+        for (const prefix of prefixes) {
+          if (prefix && !/^[a-zA-Z_:][\w:.-]*$/.test(prefix)) {
+            throw new Error(`Invalid prefix in extension-element-prefixes: "${prefix}". Prefixes must be valid QNames.`);
+          }
+        }
+        continue;
+      }
+      if (nodeName === "exclude-result-prefixes") {
+        if (nodeValue !== "#all") {
+          const prefixes = nodeValue.split(/\s+/);
+          for (const prefix of prefixes) {
+            if (prefix && !/^[a-zA-Z_:][\w:.-]*$/.test(prefix)) {
+              throw new Error(`Invalid prefix in exclude-result-prefixes: "${prefix}". Prefixes must be valid QNames or "#all".`);
+            }
+          }
+        }
+        continue;
+      }
+      if (nodeName === "default-collation") {
+        if (!nodeValue || nodeValue.trim().length === 0) {
+          throw new Error("The default-collation attribute must contain a URI.");
+        }
+        continue;
+      }
+      if (nodeName === "id") {
+        if (!/^[a-zA-Z_:][\w:.-]*$/.test(nodeValue)) {
+          throw new Error(`Invalid id attribute value: "${nodeValue}". IDs must be valid NCNames.`);
+        }
+        continue;
+      }
+    }
+  }
   /**
    * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
    * validations.
@@ -4541,24 +4804,7 @@ var Xslt = class {
    */
   xsltTransformOrStylesheet(context, template, output) {
     return __async(this, null, function* () {
-      for (let stylesheetAttribute of template.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE)) {
-        switch (stylesheetAttribute.nodeName) {
-          case "version":
-            this.version = stylesheetAttribute.nodeValue;
-            if (!["1.0", "2.0", "3.0"].includes(this.version)) {
-              throw new Error(
-                `XSLT version not defined or invalid. Actual resolved version: ${this.version || "(none)"}.`
-              );
-            }
-            context.xsltVersion = this.version;
-            break;
-          default:
-            if (stylesheetAttribute.prefix === "xmlns") {
-              context.knownNamespaces[stylesheetAttribute.localName] = stylesheetAttribute.nodeValue;
-            }
-            break;
-        }
-      }
+      this.validateStylesheetAttributes(template, context);
       let importsDone = false;
       for (const child of template.childNodes) {
         if (child.nodeType === DOM_ELEMENT_NODE) {
@@ -4598,16 +4844,22 @@ var Xslt = class {
           }
         }
         if (matchCandidates.length > 0) {
-          matchCandidates.sort((a, b) => {
-            if (a.priority.importPrecedence !== b.priority.importPrecedence) {
-              return b.priority.importPrecedence - a.priority.importPrecedence;
-            }
-            if (a.priority.effectivePriority !== b.priority.effectivePriority) {
-              return b.priority.effectivePriority - a.priority.effectivePriority;
-            }
-            return b.priority.documentOrder - a.priority.documentOrder;
-          });
-          const winner = matchCandidates[0];
+          const rootPatternMatch = matchCandidates.find((c) => c.priority.matchPattern === "/");
+          let winner;
+          if (rootPatternMatch) {
+            winner = rootPatternMatch;
+          } else {
+            matchCandidates.sort((a, b) => {
+              if (a.priority.importPrecedence !== b.priority.importPrecedence) {
+                return b.priority.importPrecedence - a.priority.importPrecedence;
+              }
+              if (a.priority.effectivePriority !== b.priority.effectivePriority) {
+                return b.priority.effectivePriority - a.priority.effectivePriority;
+              }
+              return b.priority.documentOrder - a.priority.documentOrder;
+            });
+            winner = matchCandidates[0];
+          }
           const conflicts = matchCandidates.filter(
             (t) => t.priority.importPrecedence === winner.priority.importPrecedence && t.priority.effectivePriority === winner.priority.effectivePriority
           );
@@ -4745,7 +4997,11 @@ var Xslt = class {
     return __async(this, null, function* () {
       const contextClone = context.clone();
       for (let i = 0; i < template.childNodes.length; ++i) {
-        yield this.xsltProcessContext(contextClone, template.childNodes[i], output);
+        const child = template.childNodes[i];
+        if (child.nodeType === DOM_ATTRIBUTE_NODE) {
+          continue;
+        }
+        yield this.xsltProcessContext(contextClone, child, output);
       }
     });
   }