@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/whitespace.js

@@ -0,0 +1,200 @@
+/**
+ * `xsl:strip-space` and `xsl:preserve-space` support.
+ *
+ * XSLT 1.0 removes whitespace-only text nodes from the source tree before the
+ * transformation starts. This module builds a stripped copy of the source so
+ * the caller's document is never mutated, and resolves the usual conflict rules
+ * between the two declarations.
+ */
+
+"use strict";
+
+import { isTextContinuation, isTextNode } from "../xpath/axes.js";
+import { matchesNameTest, nameTestPriority } from "./spaceNameTests.js";
+
+/** Node type of a document type declaration, which cannot be imported. */
+const DOCUMENT_TYPE_NODE = 10;
+
+/** Text made only of XML whitespace: #x20, #x9, #xD and #xA (not NBSP). */
+const XML_WHITESPACE_ONLY = /^[ \t\r\n]*$/;
+
+/**
+ * Whether a string consists of XML whitespace only (XML 1.0 production S).
+ * Unlike `trim()` and `\s`, a no-break space is not whitespace.
+ *
+ * @param {string} text - Any string
+ * @returns {boolean} True for "" and strings of #x20 #x9 #xD #xA
+ *
+ * @example
+ * isXmlWhitespace(" \n"); // true
+ * isXmlWhitespace("\u00a0"); // false
+ */
+export function isXmlWhitespace(text) {
+  return XML_WHITESPACE_ONLY.test(text);
+}
+
+/**
+ * The DOM nodes of the text run starting at a node: the node and every
+ * directly following Text/CDATA sibling (one XPath text node).
+ *
+ * @param {Node} first - The first node of the run
+ * @returns {Node[]} The nodes of the run
+ */
+export function textRun(first) {
+  const run = [first];
+  for (
+    let next = first.nextSibling;
+    isTextNode(next);
+    next = next.nextSibling
+  ) {
+    run.push(next);
+  }
+  return run;
+}
+
+/**
+ * Decides which whitespace-only text nodes of the source tree are removed.
+ */
+export class WhitespaceFilter {
+  /**
+   * @param {Array<string|import('./spaceNameTests.js').ElementNameTest>} [stripSpace] -
+   *   Name tests from `xsl:strip-space`: expanded (see spaceNameTests.js),
+   *   or strings matched by their lexical name
+   * @param {Array<string|import('./spaceNameTests.js').ElementNameTest>} [preserveSpace] -
+   *   Name tests from `xsl:preserve-space`
+   */
+  constructor(stripSpace = [], preserveSpace = []) {
+    this.stripSpace = stripSpace;
+    this.preserveSpace = preserveSpace;
+  }
+
+  /**
+   * Whether the filter can remove anything at all.
+   *
+   * @returns {boolean} True when at least one `xsl:strip-space` was declared
+   *
+   * @example
+   * new WhitespaceFilter(['*']).isActive(); // true
+   */
+  isActive() {
+    return this.stripSpace.length > 0;
+  }
+
+  /**
+   * Whether whitespace-only children of an element are stripped.
+   *
+   * The most specific name test wins; `xsl:preserve-space` wins ties.
+   *
+   * @param {Element} element - The parent element
+   * @returns {boolean} True when whitespace-only text children are removed
+   *
+   * @example
+   * new WhitespaceFilter(['*'], ['pre']).isStripped(preElement); // false
+   */
+  isStripped(element) {
+    let stripPriority = -Infinity;
+    let preservePriority = -Infinity;
+
+    for (const nameTest of this.stripSpace) {
+      if (matchesNameTest(element, nameTest)) {
+        stripPriority = Math.max(stripPriority, nameTestPriority(nameTest));
+      }
+    }
+
+    for (const nameTest of this.preserveSpace) {
+      if (matchesNameTest(element, nameTest)) {
+        preservePriority = Math.max(
+          preservePriority,
+          nameTestPriority(nameTest),
+        );
+      }
+    }
+
+    return stripPriority > -Infinity && stripPriority > preservePriority;
+  }
+}
+
+/**
+ * Check whether `xml:space="preserve"` is in scope for a node.
+ *
+ * @param {Node} node - The node to inspect
+ * @returns {boolean} True when whitespace must be preserved
+ */
+function hasXmlSpacePreserve(node) {
+  let current = node;
+
+  while (current?.nodeType === 1) {
+    const value = current.getAttribute("xml:space");
+    if (value === "preserve") return true;
+    if (value === "default") return false;
+    current = current.parentNode;
+  }
+
+  return false;
+}
+
+/**
+ * Remove whitespace-only text nodes from a subtree. Adjacent Text/CDATA
+ * nodes form one text node and are only removed together.
+ *
+ * @param {Node} root - The root of the subtree to prune
+ * @param {WhitespaceFilter} filter - The configured filter
+ * @returns {void}
+ */
+function pruneWhitespace(root, filter) {
+  const doomed = [];
+  const stack = [root];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+
+    if (
+      isTextNode(current) &&
+      !isTextContinuation(current) &&
+      current.parentNode?.nodeType === 1 &&
+      filter.isStripped(current.parentNode) &&
+      !hasXmlSpacePreserve(current.parentNode)
+    ) {
+      const run = textRun(current);
+      if (run.every((node) => isXmlWhitespace(node.nodeValue))) {
+        doomed.push(...run);
+      }
+    }
+
+    const children = current.childNodes;
+    if (children) {
+      for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+    }
+  }
+
+  for (const node of doomed) node.parentNode.removeChild(node);
+}
+
+/**
+ * Build a copy of the source tree with stripped whitespace removed.
+ *
+ * @param {Node} sourceNode - The source document or element
+ * @param {WhitespaceFilter} filter - The configured filter
+ * @param {Document} targetDoc - An empty document owning the copy
+ * @returns {Node} The stripped copy, a document when the source was a document
+ *
+ * @example
+ * const stripped = stripWhitespaceNodes(xmlDoc, filter, emptyDoc);
+ */
+export function stripWhitespaceNodes(sourceNode, filter, targetDoc) {
+  let root;
+
+  if (sourceNode.nodeType === 9) {
+    root = targetDoc;
+    for (const child of Array.from(sourceNode.childNodes)) {
+      if (child.nodeType === DOCUMENT_TYPE_NODE) continue;
+      targetDoc.appendChild(targetDoc.importNode(child, true));
+    }
+  } else {
+    root = targetDoc.importNode(sourceNode, true);
+    targetDoc.appendChild(root);
+  }
+
+  pruneWhitespace(root, filter);
+  return root;
+}

package/LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2026, XSLT-Processor Contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.