xslt-processor 4.0.0 → 4.1.0

package/README.md

@@ -219,6 +219,54 @@ HTML per se is not strict XML. Because of that, starting on version 2.0.0, this
 - Tags like `<hr>`, `<link>` and `<meta>` don't need to be closed. The output for these tags doesn't close them (adding a `/` before the tag closes, or a corresponding close tag);
   - This rule doesn't apply for XHTML, which is strict XML.
 
+### Whitespace Handling
+
+This library supports `xsl:strip-space` and `xsl:preserve-space` for controlling whitespace in the input document.
+
+#### `xsl:strip-space`
+
+Use `<xsl:strip-space>` to remove whitespace-only text nodes from specified elements in the input document:
+
+```xml
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <!-- Strip whitespace from all elements -->
+    <xsl:strip-space elements="*"/>
+
+    <!-- Or strip from specific elements -->
+    <xsl:strip-space elements="book chapter section"/>
+
+    <!-- ... templates ... -->
+</xsl:stylesheet>
+```
+
+The `elements` attribute accepts:
+- `*` - matches all elements
+- `name` - matches elements with the specified local name
+- `prefix:*` - matches all elements in a namespace
+- `prefix:name` - matches a specific element in a namespace
+- Multiple patterns separated by whitespace (e.g., `"book chapter section"`)
+
+#### `xsl:preserve-space`
+
+Use `<xsl:preserve-space>` to preserve whitespace in specific elements, overriding `xsl:strip-space`:
+
+```xml
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:strip-space elements="*"/>
+    <!-- Preserve whitespace in pre and code elements -->
+    <xsl:preserve-space elements="pre code"/>
+
+    <!-- ... templates ... -->
+</xsl:stylesheet>
+```
+
+#### Precedence Rules
+
+1. `xml:space="preserve"` attribute on an element takes highest precedence
+2. `xsl:preserve-space` overrides `xsl:strip-space` for matching elements
+3. `xsl:strip-space` applies to remaining matches
+4. By default (no declarations), whitespace is preserved
+
 ## References
 
 - XPath Specification: http://www.w3.org/TR/1999/REC-xpath-19991116

package/index.d.mts

@@ -570,6 +570,17 @@ declare class Xslt {
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
+    /**
+     * List of element name patterns from xsl:strip-space declarations.
+     * Whitespace-only text nodes inside matching elements will be stripped.
+     */
+    stripSpacePatterns: string[];
+    /**
+     * 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[];
     constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
@@ -704,6 +715,39 @@ declare class Xslt {
      * @todo case-order is not implemented.
      */
     protected xsltSort(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `xsl:strip-space`.
+     * Collects element name patterns for which whitespace-only text nodes should be stripped.
+     * @param template The `<xsl:strip-space>` node.
+     */
+    protected xsltStripSpace(template: XNode): void;
+    /**
+     * Implements `xsl:preserve-space`.
+     * Collects element name patterns for which whitespace-only text nodes should be preserved.
+     * preserve-space takes precedence over strip-space for matching elements.
+     * @param template The `<xsl:preserve-space>` node.
+     */
+    protected xsltPreserveSpace(template: XNode): void;
+    /**
+     * Determines if a text node from the input document should be stripped.
+     * This applies xsl:strip-space and xsl:preserve-space rules to whitespace-only text nodes.
+     * @param textNode The text node to check.
+     * @returns True if the text node should be stripped (not included in output).
+     */
+    protected shouldStripWhitespaceNode(textNode: XNode): boolean;
+    /**
+     * Matches an element name against a strip-space/preserve-space pattern.
+     * Supports:
+     * - "*" matches any element
+     * - "prefix:*" matches any element in a namespace
+     * - "name" matches elements with that local name
+     * - "prefix:name" matches elements with that QName
+     * @param elementName The local name of the element.
+     * @param pattern The pattern to match against.
+     * @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;
     /**
      * Implements `xsl:template`.
      * @param context The Expression Context.

package/index.d.ts

@@ -570,6 +570,17 @@ declare class Xslt {
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
+    /**
+     * List of element name patterns from xsl:strip-space declarations.
+     * Whitespace-only text nodes inside matching elements will be stripped.
+     */
+    stripSpacePatterns: string[];
+    /**
+     * 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[];
     constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
@@ -704,6 +715,39 @@ declare class Xslt {
      * @todo case-order is not implemented.
      */
     protected xsltSort(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `xsl:strip-space`.
+     * Collects element name patterns for which whitespace-only text nodes should be stripped.
+     * @param template The `<xsl:strip-space>` node.
+     */
+    protected xsltStripSpace(template: XNode): void;
+    /**
+     * Implements `xsl:preserve-space`.
+     * Collects element name patterns for which whitespace-only text nodes should be preserved.
+     * preserve-space takes precedence over strip-space for matching elements.
+     * @param template The `<xsl:preserve-space>` node.
+     */
+    protected xsltPreserveSpace(template: XNode): void;
+    /**
+     * Determines if a text node from the input document should be stripped.
+     * This applies xsl:strip-space and xsl:preserve-space rules to whitespace-only text nodes.
+     * @param textNode The text node to check.
+     * @returns True if the text node should be stripped (not included in output).
+     */
+    protected shouldStripWhitespaceNode(textNode: XNode): boolean;
+    /**
+     * Matches an element name against a strip-space/preserve-space pattern.
+     * Supports:
+     * - "*" matches any element
+     * - "prefix:*" matches any element in a namespace
+     * - "name" matches elements with that local name
+     * - "prefix:name" matches elements with that QName
+     * @param elementName The local name of the element.
+     * @param pattern The pattern to match against.
+     * @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;
     /**
      * Implements `xsl:template`.
      * @param context The Expression Context.

package/index.js

@@ -3548,6 +3548,8 @@ var Xslt = class {
     };
     this.outputMethod = "xml";
     this.outputOmitXmlDeclaration = "no";
+    this.stripSpacePatterns = [];
+    this.preserveSpacePatterns = [];
     this.decimalFormatSettings = {
       decimalSeparator: ".",
       groupingSeparator: ",",
@@ -3680,14 +3682,16 @@ var Xslt = class {
             yield this.xsltVariable(context, template, false);
             break;
           case "preserve-space":
-            throw new Error(`not implemented: ${template.localName}`);
+            this.xsltPreserveSpace(template);
+            break;
           case "processing-instruction":
             throw new Error(`not implemented: ${template.localName}`);
           case "sort":
             this.xsltSort(context, template);
             break;
           case "strip-space":
-            throw new Error(`not implemented: ${template.localName}`);
+            this.xsltStripSpace(template);
+            break;
           case "stylesheet":
           case "transform":
             yield this.xsltTransformOrStylesheet(context, template, output);
@@ -3847,6 +3851,9 @@ var Xslt = class {
       return node;
     }
     if (source.nodeType == DOM_TEXT_NODE) {
+      if (this.shouldStripWhitespaceNode(source)) {
+        return null;
+      }
       let node = domCreateTextNode(this.outputDocument, source.nodeValue);
       node.siblingPosition = destination.childNodes.length;
       domAppendChild(destination, node);
@@ -4106,6 +4113,99 @@ var Xslt = class {
     }
     this.xPath.xPathSort(context, sort);
   }
+  /**
+   * Implements `xsl:strip-space`.
+   * Collects element name patterns for which whitespace-only text nodes should be stripped.
+   * @param template The `<xsl:strip-space>` node.
+   */
+  xsltStripSpace(template) {
+    const elements = xmlGetAttribute(template, "elements");
+    if (elements) {
+      const patterns = elements.trim().split(/\s+/);
+      this.stripSpacePatterns.push(...patterns);
+    }
+  }
+  /**
+   * Implements `xsl:preserve-space`.
+   * Collects element name patterns for which whitespace-only text nodes should be preserved.
+   * preserve-space takes precedence over strip-space for matching elements.
+   * @param template The `<xsl:preserve-space>` node.
+   */
+  xsltPreserveSpace(template) {
+    const elements = xmlGetAttribute(template, "elements");
+    if (elements) {
+      const patterns = elements.trim().split(/\s+/);
+      this.preserveSpacePatterns.push(...patterns);
+    }
+  }
+  /**
+   * Determines if a text node from the input document should be stripped.
+   * This applies xsl:strip-space and xsl:preserve-space rules to whitespace-only text nodes.
+   * @param textNode The text node to check.
+   * @returns True if the text node should be stripped (not included in output).
+   */
+  shouldStripWhitespaceNode(textNode) {
+    if (!textNode.nodeValue || !textNode.nodeValue.match(/^\s*$/)) {
+      return false;
+    }
+    if (this.stripSpacePatterns.length === 0) {
+      return false;
+    }
+    const parentElement = textNode.parentNode;
+    if (!parentElement || parentElement.nodeType !== DOM_ELEMENT_NODE) {
+      return false;
+    }
+    let ancestor = parentElement;
+    while (ancestor && ancestor.nodeType === DOM_ELEMENT_NODE) {
+      const xmlspace = domGetAttributeValue(ancestor, "xml:space");
+      if (xmlspace === "preserve") {
+        return false;
+      }
+      if (xmlspace === "default") {
+        break;
+      }
+      ancestor = ancestor.parentNode;
+    }
+    const parentName = parentElement.localName || parentElement.nodeName;
+    for (const pattern of this.preserveSpacePatterns) {
+      if (this.matchesNamePattern(parentName, pattern, parentElement)) {
+        return false;
+      }
+    }
+    for (const pattern of this.stripSpacePatterns) {
+      if (this.matchesNamePattern(parentName, pattern, parentElement)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Matches an element name against a strip-space/preserve-space pattern.
+   * Supports:
+   * - "*" matches any element
+   * - "prefix:*" matches any element in a namespace
+   * - "name" matches elements with that local name
+   * - "prefix:name" matches elements with that QName
+   * @param elementName The local name of the element.
+   * @param pattern The pattern to match against.
+   * @param element The element node (for namespace checking).
+   * @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;
+      }
+    }
+    return elementName === pattern;
+  }
   /**
    * Implements `xsl:template`.
    * @param context The Expression Context.
@@ -4310,6 +4410,9 @@ var Xslt = class {
    */
   commonLogicTextNode(context, template, output) {
     if (output) {
+      if (this.shouldStripWhitespaceNode(template)) {
+        return;
+      }
       let node = domCreateTextNode(this.outputDocument, template.nodeValue);
       node.siblingPosition = output.childNodes.length;
       domAppendChild(output, node);