xslt-processor 4.8.5 → 5.0.0

package/index.js

@@ -7800,9 +7800,12 @@ var init_expressions = __esm({
 var index_exports = {};
 __export(index_exports, {
   ExprContext: () => ExprContext,
+  XDocument: () => XDocument,
+  XNode: () => XNode,
   XPath: () => XPath,
   XmlParser: () => XmlParser,
   Xslt: () => Xslt,
+  domDocumentToXDocument: () => domDocumentToXDocument,
   xmlEscapeText: () => xmlEscapeText
 });
 module.exports = __toCommonJS(index_exports);
@@ -10279,38 +10282,6 @@ function createXPathParser(version = DEFAULT_XPATH_VERSION, options) {
 // src/xpath/xpath.ts
 init_expressions();
 
-// src/dom/functions.ts
-function domGetAttributeValue(node, name) {
-  return node.getAttributeValue(name);
-}
-function domSetAttribute(node, name, value) {
-  return node.setAttribute(name, value);
-}
-function domAppendChild(node, child) {
-  return node.appendChild(child);
-}
-function domCreateTextNode(node, text) {
-  return node.createTextNode(text);
-}
-function domCreateElement(doc, name) {
-  return doc.createElement(name);
-}
-function domCreateCDATASection(doc, data2) {
-  return doc.createCDATASection(data2);
-}
-function domCreateComment(doc, text) {
-  return doc.createComment(text);
-}
-function domCreateDocumentFragment(doc) {
-  return doc.createDocumentFragment();
-}
-function domCreateDTDSection(doc, data2) {
-  return doc.createDTDSection(data2);
-}
-function domCreateProcessingInstruction(doc, target, data2) {
-  return doc.createProcessingInstruction(target, data2);
-}
-
 // src/constants.ts
 var DOM_ELEMENT_NODE = 1;
 var DOM_ATTRIBUTE_NODE = 2;
@@ -10735,7 +10706,9 @@ var XDocument = class extends XNode {
   }
   appendChild(node) {
     super.appendChild(node);
-    this.documentElement = this.childNodes[0];
+    if (node.nodeType === DOM_ELEMENT_NODE && !this.documentElement) {
+      this.documentElement = node;
+    }
   }
   createElement(name) {
     return XNode.create(DOM_ELEMENT_NODE, name, null, this);
@@ -10769,6 +10742,130 @@ var XDocument = class extends XNode {
   }
 };
 
+// src/dom/dom-to-xdocument.ts
+function domDocumentToXDocument(nativeNode) {
+  if (nativeNode.nodeType === DOM_DOCUMENT_NODE) {
+    const xDoc2 = new XDocument();
+    const childNodes = nativeNode.childNodes;
+    for (let i = 0; i < childNodes.length; i++) {
+      const converted2 = convertNode(childNodes[i], xDoc2);
+      if (converted2) {
+        converted2.siblingPosition = xDoc2.childNodes.length;
+        xDoc2.appendChild(converted2);
+      }
+    }
+    return xDoc2;
+  }
+  const xDoc = new XDocument();
+  const converted = convertNode(nativeNode, xDoc);
+  if (converted) {
+    converted.siblingPosition = 0;
+    xDoc.appendChild(converted);
+  }
+  return xDoc;
+}
+function convertNode(nativeNode, ownerDoc) {
+  switch (nativeNode.nodeType) {
+    case DOM_ELEMENT_NODE: {
+      const element = nativeNode;
+      const xNode = XNode.create(
+        DOM_ELEMENT_NODE,
+        element.nodeName,
+        null,
+        ownerDoc,
+        element.namespaceURI
+      );
+      xNode.prefix = element.prefix || null;
+      xNode.localName = element.localName || element.nodeName;
+      const attrs = element.attributes;
+      for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        const attrNode = XNode.create(
+          DOM_ATTRIBUTE_NODE,
+          attr.name,
+          attr.value,
+          xNode,
+          attr.namespaceURI
+        );
+        attrNode.prefix = attr.prefix || null;
+        attrNode.localName = attr.localName || attr.name;
+        attrNode.parentNode = xNode;
+        attrNode.siblingPosition = xNode.childNodes.length;
+        xNode.appendChild(attrNode);
+      }
+      const childNodes = nativeNode.childNodes;
+      for (let i = 0; i < childNodes.length; i++) {
+        const converted = convertNode(childNodes[i], ownerDoc);
+        if (converted) {
+          converted.siblingPosition = xNode.childNodes.length;
+          xNode.appendChild(converted);
+        }
+      }
+      return xNode;
+    }
+    case DOM_TEXT_NODE:
+      return XNode.create(DOM_TEXT_NODE, "#text", nativeNode.nodeValue || "", ownerDoc);
+    case DOM_CDATA_SECTION_NODE:
+      return XNode.create(DOM_CDATA_SECTION_NODE, "#cdata-section", nativeNode.nodeValue || "", ownerDoc);
+    case DOM_COMMENT_NODE:
+      return XNode.create(DOM_COMMENT_NODE, "#comment", nativeNode.nodeValue || "", ownerDoc);
+    case DOM_PROCESSING_INSTRUCTION_NODE: {
+      const pi2 = nativeNode;
+      return XNode.create(DOM_PROCESSING_INSTRUCTION_NODE, pi2.target, pi2.data, ownerDoc);
+    }
+    case DOM_DOCUMENT_TYPE_NODE: {
+      const dt = nativeNode;
+      return XNode.create(DOM_DOCUMENT_TYPE_NODE, "#dtd-section", dt.name, ownerDoc);
+    }
+    case DOM_DOCUMENT_FRAGMENT_NODE: {
+      const fragment = XNode.create(DOM_DOCUMENT_FRAGMENT_NODE, "#document-fragment", null, ownerDoc);
+      const childNodes = nativeNode.childNodes;
+      for (let i = 0; i < childNodes.length; i++) {
+        const converted = convertNode(childNodes[i], ownerDoc);
+        if (converted) {
+          converted.siblingPosition = fragment.childNodes.length;
+          fragment.appendChild(converted);
+        }
+      }
+      return fragment;
+    }
+    default:
+      return null;
+  }
+}
+
+// src/dom/functions.ts
+function domGetAttributeValue(node, name) {
+  return node.getAttributeValue(name);
+}
+function domSetAttribute(node, name, value) {
+  return node.setAttribute(name, value);
+}
+function domAppendChild(node, child) {
+  return node.appendChild(child);
+}
+function domCreateTextNode(node, text) {
+  return node.createTextNode(text);
+}
+function domCreateElement(doc, name) {
+  return doc.createElement(name);
+}
+function domCreateCDATASection(doc, data2) {
+  return doc.createCDATASection(data2);
+}
+function domCreateComment(doc, text) {
+  return doc.createComment(text);
+}
+function domCreateDocumentFragment(doc) {
+  return doc.createDocumentFragment();
+}
+function domCreateDTDSection(doc, data2) {
+  return doc.createDTDSection(data2);
+}
+function domCreateProcessingInstruction(doc, target, data2) {
+  return doc.createProcessingInstruction(target, data2);
+}
+
 // src/dom/html-entity-decoder.ts
 var NAMED_ENTITIES = {
   "amp": "&",
@@ -10973,7 +11070,7 @@ function xmlElementLogicTrivial(node, buffer, options) {
     if (!attribute) {
       continue;
     }
-    if (options.outputMethod === "html" && (attribute.nodeName === "xmlns" || attribute.nodeName.startsWith("xmlns:"))) {
+    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) {
@@ -13908,6 +14005,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: ""
@@ -13921,16 +14028,7 @@ var Xslt = class {
    */
   xsltProcess(xmlDoc, stylesheet) {
     return __async(this, null, function* () {
-      const outputDocument = new XDocument();
-      this.outputDocument = outputDocument;
-      const expressionContext = new ExprContext([xmlDoc]);
-      expressionContext.warningsCallback = this.warningsCallback;
-      if (this.options.parameters.length > 0) {
-        for (const parameter of this.options.parameters) {
-          expressionContext.setVariable(parameter.name, new StringValue(parameter.value));
-        }
-      }
-      yield this.xsltProcessContext(expressionContext, stylesheet, this.outputDocument);
+      const outputDocument = yield this.xsltProcessToDocument(xmlDoc, stylesheet);
       if (this.outputMethod === "json") {
         return xmlToJson(outputDocument);
       }
@@ -13953,6 +14051,32 @@ var Xslt = class {
       return transformedOutputXml;
     });
   }
+  /**
+   * Processes the XSLT transformation and returns the output as an XDocument
+   * instead of a serialized string. This is useful for:
+   * - Working with the result tree programmatically
+   * - Converting to a different DOM representation (e.g., React elements)
+   * - Using browser-native serialization (XMLSerializer) if desired
+   *
+   * @param xmlDoc The input document root, as DOM node.
+   * @param stylesheet The stylesheet document root, as DOM node.
+   * @returns The processed document as an XDocument tree.
+   */
+  xsltProcessToDocument(xmlDoc, stylesheet) {
+    return __async(this, null, function* () {
+      const outputDocument = new XDocument();
+      this.outputDocument = outputDocument;
+      const expressionContext = new ExprContext([xmlDoc]);
+      expressionContext.warningsCallback = this.warningsCallback;
+      if (this.options.parameters.length > 0) {
+        for (const parameter of this.options.parameters) {
+          expressionContext.setVariable(parameter.name, this.toNodeValue(parameter.value));
+        }
+      }
+      yield this.xsltProcessContext(expressionContext, stylesheet, this.outputDocument);
+      return outputDocument;
+    });
+  }
   /**
    * The main entry point of the XSL-T processor, as explained on the top of the file.
    * @param context The input document root, as XPath `ExprContext`.
@@ -14572,6 +14696,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);
+              }
+            }
+          }
+        }
       }
     });
   }
@@ -14674,6 +14811,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;
   }
@@ -15341,16 +15484,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.`);
@@ -15360,8 +15493,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 = {
@@ -17171,6 +17303,29 @@ var Xslt = class {
         return value;
     }
   }
+  /**
+   * Converts a raw JavaScript value to the appropriate NodeValue type.
+   * Detects NodeValue instances, DOM nodes, arrays, numbers, booleans,
+   * and falls back to StringValue.
+   *
+   * @param value The raw value to convert.
+   * @returns The wrapped NodeValue.
+   */
+  toNodeValue(value) {
+    if (value && typeof value === "object" && "stringValue" in value) {
+      return value;
+    } else if (value && typeof value === "object" && "nodeType" in value) {
+      return new NodeSetValue([value]);
+    } else if (Array.isArray(value)) {
+      return new NodeSetValue(value);
+    } else if (typeof value === "number") {
+      return new NumberValue(value);
+    } else if (typeof value === "boolean") {
+      return new BooleanValue(value);
+    } else {
+      return new StringValue(String(value != null ? value : ""));
+    }
+  }
   /**
    * Execute a user-defined xsl:function.
    * Called when a function from userDefinedFunctions is invoked from XPath.
@@ -17208,30 +17363,10 @@ var Xslt = class {
       const paramName = xmlGetAttribute(params[i], "name");
       if (paramName) {
         if (i < args.length) {
-          let argValue = args[i];
           const paramType = xmlGetAttribute(params[i], "as");
-          let paramValue;
-          if (argValue && typeof argValue === "object" && "stringValue" in argValue) {
-            paramValue = argValue;
-            if (paramType) {
-              paramValue = this.coerceToType(paramValue, paramType);
-            }
-          } else if (argValue && typeof argValue === "object" && "nodeType" in argValue) {
-            paramValue = new NodeSetValue([argValue]);
-            if (paramType) {
-              paramValue = this.coerceToType(paramValue, paramType);
-            }
-          } else if (Array.isArray(argValue)) {
-            paramValue = new NodeSetValue(argValue);
-            if (paramType) {
-              paramValue = this.coerceToType(paramValue, paramType);
-            }
-          } else if (typeof argValue === "number") {
-            paramValue = new NumberValue(argValue);
-          } else if (typeof argValue === "boolean") {
-            paramValue = new BooleanValue(argValue);
-          } else {
-            paramValue = new StringValue(String(argValue != null ? argValue : ""));
+          let paramValue = this.toNodeValue(args[i]);
+          if (paramType) {
+            paramValue = this.coerceToType(paramValue, paramType);
           }
           functionContext.setVariable(paramName, paramValue);
         } else {
@@ -17438,12 +17573,12 @@ var Xslt = class {
       } else if (select) {
         value = this.xPath.xPathEval(select, context);
       } else {
-        let parameterValue = "";
         const filteredParameter = this.options.parameters.filter((p) => p.name === name);
         if (filteredParameter.length > 0) {
-          parameterValue = filteredParameter[0].value;
+          value = this.toNodeValue(filteredParameter[0].value);
+        } else {
+          value = new StringValue("");
         }
-        value = new StringValue(parameterValue);
       }
       if (override || !context.getVariable(name)) {
         context.setVariable(name, value);
@@ -17608,6 +17743,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:
@@ -18012,9 +18153,12 @@ var Xslt = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ExprContext,
+  XDocument,
+  XNode,
   XPath,
   XmlParser,
   Xslt,
+  domDocumentToXDocument,
   xmlEscapeText
 });
 //# sourceMappingURL=index.js.map